diff --git a/.cursor/commands/test.md b/.cursor/commands/test.md
new file mode 100644
index 0000000..7caf687
--- /dev/null
+++ b/.cursor/commands/test.md
@@ -0,0 +1,3 @@
+# test
+
+Run the tests
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ca28c92
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,70 @@
+# IDE & Editor directories
+.idea/
+.vscode/
+.vs/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# OS generated files
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+$RECYCLE.BIN/
+
+# Temporary files
+*.tmp
+*.temp
+*.log
+*.bak
+*.backup
+*.orig
+
+# Test artifacts
+test-results/
+coverage/
+*.test
+*.out
+
+# MyLinuxHelper runtime files
+.mylinuxhelper/bookmarks.json
+.mylinuxhelper/.update-config
+.mylinuxhelper/cache/
+
+# Node modules (if any scripts use Node)
+node_modules/
+package-lock.json
+
+# Python cache (if any Python scripts)
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+*.egg-info/
+
+# Build artifacts
+dist/
+build/
+*.o
+*.so
+*.dylib
+
+# Environment files
+.env
+.env.local
+.env.*.local
+*.env
+
+# Personal notes/drafts
+NOTES.md
+DRAFT*.md
+SCRATCH*.md
+notes/
+drafts/
+
+# Release artifacts
+*.tar.gz
+*.zip
+*.tar.bz2
+releases/
diff --git a/CLAUDE.md b/CLAUDE.md
index e9929a5..8b4f49d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -27,6 +27,12 @@ The setup script automatically:
 - Creates symlinks for all commands in `~/.local/bin`
 - Adds `~/.local/bin` to PATH in `~/.bashrc` and `~/.profile`
 - Makes all plugin scripts executable
+- Installs wrapper functions in `~/.bashrc`:
+    - `mlh()` wrapper: Ensures current session history is visible
+    - `bookmark()` wrapper: Enables `cd` functionality for bookmark navigation
+    - `<alias>()` wrapper: Creates custom alias if configured (e.g., `bm()`)
+- Creates symlink for bookmark alias if configured
+- Shows warning message when `.bashrc` is updated (reminds user to run `source ~/.bashrc`)
 - Re-execs the shell if commands aren't immediately available
 
 ## Architecture
@@ -104,18 +110,182 @@ Key feature: Automatically mounts the MyLinuxHelper repository at `/opt/mlh` ins
 - Manual updates via `mlh update`
 - Periodic update configuration (daily/weekly/monthly)
 - Auto-update hooks in `~/.bashrc`
+- **Automatic shell reload**: After update, automatically reloads shell with `exec bash -l`
 
 Configuration is stored in `~/.mylinuxhelper/.update-config`.
 
+**Update Process:**
+
+1. Downloads `get-mlh.sh` from GitHub
+2. Runs installation (updates files, runs `setup.sh`)
+3. Automatically reloads shell to apply wrapper functions and updates
+4. No manual `source ~/.bashrc` required
+
+### Quick Directory Bookmarks
+
+`mlh-bookmark.sh` provides a fast navigation system with hierarchical organization:
+
+**Features (Phase 1, 2 & 3 Complete):**
+
+- **Numbered stack**: Quick save/restore (max 10 bookmarks, auto re-numbering on delete)
+- **Named bookmarks**: Persistent bookmarks with memorable names
+- **Hierarchical categories**: Organize bookmarks (e.g., `projects/linux`, `projects/java`)
+- **Interactive menu**: Full-featured TUI with arrow key navigation (`bookmark list -i`)
+    - Navigate with ↑/↓ or j/k (vim-style)
+    - Jump, edit, delete bookmarks in real-time
+    - Hierarchical category display
+    - Built-in help menu ('h' key)
+- **Category filtering**: List and filter by category
+- **Move bookmarks**: Relocate bookmarks between categories
+- **Smart search**: Find bookmarks by name, path, or category (`bookmark find <pattern>`)
+- **Bookmark management**: Edit, remove, clear operations
+- **JSON storage**: `~/.mylinuxhelper/bookmarks.json`
+- **Shell integration**: Wrapper function enables instant `cd` navigation
+
+**Architecture:**
+
+- Stack-based unnamed bookmarks (LIFO, auto-rotating)
+- Named bookmarks with category support and access tracking
+- Command name conflict detection (prevents naming conflicts with system commands)
+- Path validation with warnings (⚠ symbol for missing paths)
+- jq-based JSON manipulation
+- Bash wrapper function for parent shell directory changes
+
+**Usage patterns:**
+
+```bash
+bookmark .                      # Save current dir (becomes #1)
+bookmark 1                      # Jump to bookmark #1
+bookmark . -n myproject         # Save with name
+bookmark . -n mlh in projects   # Save with category
+bookmark myproject              # Jump to named bookmark
+bookmark list                   # Show all bookmarks (grouped by category)
+bookmark list -i                # Interactive menu (arrow keys, edit, delete)
+bookmark list projects          # Filter by category
+bookmark mv mlh to tools        # Move bookmark to different category
+bookmark edit myproject         # Edit bookmark (name/path/category)
+bookmark rm myproject           # Remove bookmark
+bookmark rm 2                   # Remove #2 (auto re-numbers remaining)
+bookmark find java              # Search bookmarks
+bookmark clear                  # Clear all numbered bookmarks
+```
+
+**Wrapper Function (setup.sh):**
+
+The `setup.sh` script automatically installs a wrapper function in `~/.bashrc` that enables `cd` functionality:
+
+- When jumping to bookmarks (`bookmark 1` or `bookmark name`), the wrapper evaluates the output
+- The script outputs a `cd` command that the wrapper executes in the parent shell
+- Other commands (`list`, `mv`, save operations) pass through normally
+
+**Alias Support:**
+
+Users can configure a custom shortcut/alias for the bookmark command:
+
+- Configuration file: `~/.mylinuxhelper/mlh.conf`
+- Format: `BOOKMARK_ALIAS=bm` (or any alphanumeric name)
+- After configuration, run `setup.sh` and `source ~/.bashrc`
+- Aliases delegate to the main bookmark function (full feature support)
+- **Important**: `setup.sh` creates both a symlink AND a wrapper function. The function takes precedence and enables
+  `cd` functionality in interactive mode. Even if a symlink exists, the function is added to `.bashrc` because functions
+  execute before commands/symlinks.
+- Command conflict detection: Real system commands are warned about, but the function is still added (functions take
+  precedence)
+- Help dynamically shows alias name in examples when configured
+- See `docs/BOOKMARK_ALIAS_GUIDE.md` for detailed setup instructions
+
+**Storage format:**
+
+```json
+{
+   "bookmarks": {
+      "named": [
+         {
+            name,
+            path,
+            category,
+            created,
+            accessed,
+            access_count
+         }
+      ],
+      "unnamed": [
+         {
+            id,
+            path,
+            created
+         }
+      ]
+   },
+   "config": {
+      max_unnamed: 10,
+      auto_cleanup: true
+   }
+}
+```
+
 ## Testing & Development
 
+### Test Execution (Project-Specific)
+
+**Docker command for this project:**
+
+```bash
+docker run --rm -v "//c/Kodlar/Python-Bash-Bat/MyLinuxHelper://mlh" ubuntu:22.04 bash -c \
+  "cd /mlh && apt-get update -qq && apt-get install -y -qq jq >/dev/null 2>&1 && \
+   bash tests/test <test-name>"
+```
+
+**Local testing:**
+
+```bash
+bash tests/test <test-name>
+```
+
+### Automated Testing
+
+The test suite uses a standardized framework:
+
+```bash
+# Run all tests
+bash tests/test
+
+# Run specific test suite
+bash tests/test bookmark/mlh-bookmark
+# Or use legacy format (still works)
+bash tests/test mlh-bookmark
+
+# Test output format
+✓ PASS: Test description
+✗ FAIL: Test description
+  Error details
+⊘ SKIP: Test description
+  Reason for skip
+```
+
+**Test File Structure:**
+
+```bash
+tests/
+├── test                              # Main test runner
+├── bookmark/
+│   ├── test-mlh-bookmark.sh             # Bookmark feature tests (80 tests - Phase 1, 2 & 3 + bug fixes)
+│   ├── test-bookmark-alias.sh           # Bookmark alias tests (28 tests)
+│   └── test-bookmark-alias-integration.sh # Alias integration tests (12 tests)
+├── test-mlh-history.sh              # History feature tests
+├── test-mlh-json.sh                 # JSON validation tests
+└── ...
+```
+
 ### Manual Testing
 
 After making changes to any plugin script:
 
 1. Run `./setup.sh` to refresh symlinks and permissions
-2. Test the command directly (e.g., `mlh docker in test`)
-3. Test both standalone mode and via `mlh` dispatcher
+2. **Run automated tests**: `bash tests/test <component>`
+3. **Verify all tests pass** before proceeding
+4. Test the command directly (e.g., `mlh docker in test`)
+5. Test both standalone mode and via `mlh` dispatcher
 
 ### Common Development Patterns
 
@@ -180,24 +350,87 @@ When releasing a new version:
    readonly VERSION="X.Y.Z"
    readonly VERSION_DATE="DD.MM.YYYY"
    ```
-2. Commit and push to main branch
-3. Users can update via `mlh update`
+2. Create/update `RELEASE_NOTES_vX.Y.Z.md` with user-facing changes only
+3. Commit and push to main branch
+4. Users can update via `mlh update`
+
+### Release Notes Guidelines
+
+**Important:** Release notes should focus on **user-facing changes** since the last release tag, not internal bug fixes or refactoring.
+
+#### What to Include:
+- ✅ **New features** that users can see or use
+- ✅ **Behavior changes** that affect user workflow
+- ✅ **UI/UX improvements** (interactive modes, better output formatting)
+- ✅ **Configuration changes** (new config options, migration requirements)
+- ✅ **Breaking changes** (if any)
+- ✅ **Documentation updates** (new guides, improved examples)
+
+#### What to Exclude:
+- ❌ **Internal bug fixes** that don't change user-visible behavior
+- ❌ **Code refactoring** without functional changes
+- ❌ **Test improvements** (unless they fix user-reported issues)
+- ❌ **ShellCheck/formatting fixes** (code quality improvements)
+- ❌ **Internal tooling changes** (CI/CD, development workflow)
+
+#### Process:
+1. Identify the last release tag (e.g., `v1.4.1`)
+2. Review commits since that tag: `git log v1.4.1..HEAD --oneline`
+3. Filter for user-facing changes only
+4. Organize changes by category (Features, Enhancements, Bug Fixes, etc.)
+5. Update release notes file: `RELEASE_NOTES_vX.Y.Z.md`
+6. Update version number in `plugins/mlh-version.sh`
+7. Update release date in release notes
+
+**Example:**
+```bash
+# Check commits since last release
+git log v1.4.1..HEAD --oneline
+
+# Focus on commits that change user experience:
+# - "feat: Add new feature X"
+# - "Improve user workflow Y"
+# - "Fix user-visible bug Z"
+
+# Ignore internal changes:
+# - "Fix ShellCheck warnings"
+# - "Refactor internal function"
+# - "Update test coverage"
+```
 
 ## File Structure
 
 ```
 /
 ├── get-mlh.sh          # Bootstrap installer (downloads repo)
-├── setup.sh            # Creates symlinks and configures PATH
+├── setup.sh            # Creates symlinks, configures PATH, installs wrapper functions
 ├── install.sh          # Universal package installer (provides 'i' command)
-└── plugins/
-    ├── mlh.sh          # Main command dispatcher with interactive menu
-    ├── mlh-docker.sh   # Docker container shortcuts
-    ├── mlh-json.sh     # JSON search (delegates validation to isjsonvalid.sh)
-    ├── mlh-version.sh  # Version management and auto-update system
-    ├── mlh-about.sh    # Project information
-    ├── linux.sh        # Docker container lifecycle management
-    ├── search.sh       # File search using find
-    ├── isjsonvalid.sh  # Centralized JSON validation engine
-    └── ll.sh           # ls -la shortcut
+├── README.md           # User documentation with usage examples
+├── CLAUDE.md           # Development documentation (this file)
+├── TODO.md             # Feature roadmap and implementation checklist
+├── .gitignore          # Ignore IDE files, OS files, runtime data
+├── plugins/
+│   ├── mlh.sh          # Main command dispatcher with interactive menu
+│   ├── mlh-bookmark.sh # Quick directory bookmarks (JSON-based, category support)
+│   ├── mlh-docker.sh   # Docker container shortcuts
+│   ├── mlh-json.sh     # JSON search (delegates validation to isjsonvalid.sh)
+│   ├── mlh-history.sh  # Enhanced command history with date tracking
+│   ├── mlh-version.sh  # Version management and auto-update system
+│   ├── mlh-about.sh    # Project information
+│   ├── linux.sh        # Docker container lifecycle management
+│   ├── search.sh       # File search using find
+│   ├── isjsonvalid.sh  # Centralized JSON validation engine
+│   └── ll.sh           # ls -la shortcut
+└── tests/
+    ├── test                              # Main test runner framework (285+ tests total)
+    ├── bookmark/
+    │   ├── test-mlh-bookmark.sh             # Bookmark tests (80 tests, requires jq)
+    │   ├── test-bookmark-alias.sh           # Bookmark alias tests (28 tests)
+    │   └── test-bookmark-alias-integration.sh # Alias integration tests (12 tests)
+    ├── test-mlh-history.sh              # History tests (34 tests)
+    ├── test-mlh-json.sh                 # JSON validation tests (18 tests)
+    ├── test-mlh-docker.sh               # Docker tests (18 tests)
+    ├── test-current-session.sh          # Session history tests (1 test)
+    ├── test-time-debug.sh               # Time parsing tests (4 tests)
+    └── ...
 ```
diff --git a/README.md b/README.md
index c8465e6..8fafc7b 100644
--- a/README.md
+++ b/README.md
@@ -5,6 +5,7 @@ A lightweight and modular collection of utility tools to simplify your Linux exp
 ## Features
 
 - **Interactive Command Menu**: Browse and explore all commands with the `mlh` interactive menu
+- **Quick Directory Bookmarks**: Save and jump to frequently used directories with the `bookmark` command
 - **Smart Docker Management**: Quickly enter running containers by name pattern with `mlh docker in`
 - **Enhanced Command History**: View command history with dates, search commands, and filter by date range using `mlh history`
 - **Fast File Search**: Find files quickly in current directory and subdirectories with the `search` command
@@ -23,11 +24,13 @@ bash -c "$(curl -fsSL https://raw.githubusercontent.com/melihcelenk/MyLinuxHelpe
 || bash -c "$(wget -qO- https://raw.githubusercontent.com/melihcelenk/MyLinuxHelper/main/get-mlh.sh)"
 ```
 
+After installation, you can configure a custom shortcut for the `bookmark` command (e.g., `bm`) by editing `~/.mylinuxhelper/mlh.conf` and running `./setup.sh` again. See the [Bookmark Alias Guide](docs/BOOKMARK_ALIAS_GUIDE.md) for details.
+
 ## 🚀 Usage
 
-### Available Commands
+---
 
-#### `mlh` - Interactive Command Menu
+### 📋 `mlh` - Interactive Command Menu
 Browse all available commands interactively:
 ```bash
 # Show interactive menu
@@ -55,7 +58,9 @@ MyLinuxHelper - Available Commands
 Select [1-5, q]:
 ```
 
-#### `mlh docker in` - Smart Container Access
+---
+
+### 🐳 `mlh docker in` - Smart Container Access
 Enter running Docker containers by name pattern:
 ```bash
 # Enter container by name
@@ -71,7 +76,90 @@ mlh docker in web
 # Select container [1-3]: 1
 ```
 
-#### `linux` - Container Management
+---
+
+### 🔖 `bookmark` - Quick Directory Bookmarks
+
+Save and jump to frequently used directories instantly:
+
+> **💡 Configurable Shortcut:** Configure your preferred alias (e.g., `bm`, `fav`, `goto`) in `~/.mylinuxhelper/mlh.conf`:
+> ```bash
+> BOOKMARK_ALIAS=bm
+> ```
+> Then run `./setup.sh` to apply. The alias works with all bookmark features!  
+> Use `bm --help` to see examples with your configured shortcut.
+
+```bash
+# Save current directory (numbered bookmark)
+bookmark .    # or: bm .
+
+# Jump to bookmark 1 (most recent)
+bookmark 1    # or: bm 1
+
+# Save with a memorable name
+bookmark . -n myproject    # or: bm . -n myproject
+
+# Jump to named bookmark
+bookmark myproject    # or: bm myproject
+
+# Save with category for organization
+bookmark . -n mlh in projects/linux    # or: bm . -n mlh in projects/linux
+bookmark . -n api in projects/java     # or: bm . -n api in projects/java
+
+# List all bookmarks (interactive TUI by default)
+bookmark list    # or: bm list
+
+# Non-interactive simple output
+bookmark list -n    # or: bm list -n
+
+# List specific category
+bookmark list projects    # or: bm list projects
+
+# Move bookmark to different category
+bookmark mv mlh to tools    # or: bm mv mlh to tools
+
+# Show last 5 numbered bookmarks
+bookmark list 5    # or: bm list 5
+
+# Rename numbered bookmark
+bookmark 1 -n webapp    # or: bm 1 -n webapp
+
+# Edit bookmark (name/path/category)
+bookmark edit mlh    # or: bm edit mlh
+
+# Remove bookmark
+bookmark rm oldproject    # or: bm rm oldproject
+bookmark rm 3              # or: bm rm 3
+
+# Search bookmarks
+bookmark find java    # or: bm find java
+
+# Clear all numbered bookmarks
+bookmark clear    # or: bm clear
+
+# View help (dynamically shows your configured shortcut)
+bookmark --help    # or: bm --help
+```
+
+**Key Features:**
+
+- **Configurable shortcut alias**: Use `bm` (or your preferred shortcut) instead of typing `bookmark` every time! Configure in `~/.mylinuxhelper/mlh.conf`
+- **Stack-based numbered bookmarks**: Quick access to last 10 directories (auto-rotating, auto re-numbering)
+- **Named bookmarks**: Save important locations with memorable names
+- **Hierarchical categories**: Organize bookmarks (e.g., `projects/linux`, `projects/java`)
+- **Interactive menu by default**: Navigate with arrow keys, edit, delete, search in real-time (`bookmark list` - no `-i` flag needed!)
+- **Category filtering**: List bookmarks by category
+- **Smart search**: Find bookmarks by name, path, or category (`bookmark find <pattern>`)
+- **Path validation**: Warns when bookmark path no longer exists
+- **Name conflict detection**: Prevents conflicts with system commands (both for bookmarks and aliases)
+- **Bookmark management**: Edit, remove, clear bookmarks easily
+- **Instant navigation**: Jump to bookmarks without typing full paths
+- **JSON storage**: Bookmark data stored at `~/.mylinuxhelper/bookmarks.json`
+- **Dynamic help**: Help messages automatically adapt to show your configured shortcut
+
+---
+
+### 📦 `linux` - Container Management
 Launch and manage isolated Linux containers quickly:
 ```bash
 # Create ephemeral container (auto-removed on exit)
@@ -93,7 +181,9 @@ linux -i debian:12 mycontainer
 linux -m "$PWD:/workspace" -p mycontainer
 ```
 
-#### `mlh history` - Enhanced Command History
+---
+
+### 📜 `mlh history` - Enhanced Command History
 View command history with dates, search, and filtering:
 ```bash
 # Show last 100 commands (default)
@@ -139,7 +229,9 @@ mlh history -c
 - **Helpful messages**: When no results found, shows latest command timestamp with suggestions
 - **Non-intrusive**: Doesn't affect the system `history` command
 
-#### `i` - Smart Package Installer
+---
+
+### 📥 `i` - Smart Package Installer
 Automatically detects your package manager (apt, yum, dnf, etc.) and installs packages:
 ```bash
 # Install a package
@@ -152,7 +244,9 @@ i git curl wget
 i --help
 ```
 
-#### `mlh json` / `isjsonvalid` - JSON Operations
+---
+
+### 🔍 `mlh json` / `isjsonvalid` - JSON Operations
 Advanced JSON validation and fuzzy search with intelligent path navigation:
 ```bash
 # Quick validation (Yes/No output)
@@ -196,7 +290,10 @@ mlh json --help
 - Interactive menu for multiple matches
 - Auto-installs `jq` if needed
 
-#### `ll` - Enhanced Directory Listing
+---
+
+### 📁 `ll` - Enhanced Directory Listing
+
 Shortcut for `ls -la` to view detailed file information:
 ```bash
 # List current directory
@@ -209,7 +306,10 @@ ll /var/log
 ll *.json
 ```
 
-#### `search` - Fast File Search
+---
+
+### 🔎 `search` - Fast File Search
+
 Find files quickly in current directory and subdirectories:
 ```bash
 # Search for file by name
@@ -231,10 +331,16 @@ search "*.conf" /etc
 
 ```
 /
-├── setup.sh            # Main setup script
-├── install.sh          # Universal package installer
+├── get-mlh.sh          # Bootstrap installer (downloads repo)
+├── setup.sh            # Main setup script (creates symlinks, configures PATH)
+├── install.sh          # Universal package installer (provides 'i' command)
+├── README.md           # User documentation with usage examples
+├── CLAUDE.md           # Development documentation
+├── TODO.md             # Feature roadmap and implementation checklist
+├── LICENSE             # Project license
 ├── plugins/
 │   ├── mlh.sh          # Interactive menu and command dispatcher
+│   ├── mlh-bookmark.sh # Quick directory bookmarks (JSON-based, category support)
 │   ├── mlh-docker.sh   # Docker shortcuts and container management
 │   ├── mlh-history.sh  # Enhanced command history with dates, search, and filtering
 │   ├── mlh-json.sh     # Advanced JSON search (delegates validation to isjsonvalid.sh)
@@ -243,23 +349,37 @@ search "*.conf" /etc
 │   ├── linux.sh        # Launch and manage Docker containers
 │   ├── search.sh       # Fast file search using find
 │   ├── isjsonvalid.sh  # Centralized JSON validation with flexible output modes
+│   ├── bookmark-alias.sh # Bookmark alias proxy (delegates to mlh-bookmark.sh)
 │   └── ll.sh           # Shortcut for "ls -la"
+├── docs/
+│   ├── BOOKMARK_ALIAS_GUIDE.md        # Comprehensive alias setup guide
+│   ├── BOOKMARK_QUICK_REFERENCE.md    # Quick reference for bookmark commands
+│   ├── RELEASE_NOTES_v1.5.0.md        # Release notes for v1.5.0
+│   └── config/
+│       └── mlh.conf.example           # Example configuration file
 └── tests/
-    ├── test                    # Main test runner (161 tests)
-    ├── test-mlh-history.sh     # 34 tests - Command history
-    ├── test-linux.sh           # 15 tests - Container management
-    ├── test-mlh-json.sh        # 18 tests - JSON operations
-    ├── test-mlh-docker.sh      # 18 tests - Docker shortcuts
-    ├── test-mlh.sh             # 20 tests - Main dispatcher
-    ├── test-search.sh          # 16 tests - File search
-    ├── test-isjsonvalid.sh     # 18 tests - JSON validation
-    ├── test-ll.sh              # 10 tests - Directory listing
-    └── test-mlh-about.sh       # 12 tests - About page
+    ├── test                                    # Main test runner (293 tests)
+    ├── bookmark/
+    │   ├── test-mlh-bookmark.sh                # 80 tests - Bookmark functionality
+    │   ├── test-bookmark-alias.sh              # 28 tests - Alias configuration
+    │   └── test-bookmark-alias-integration.sh  # 13 tests - Alias integration
+    ├── test-mlh-history.sh                     # 34 tests - Command history
+    ├── test-linux.sh                           # 15 tests - Container management
+    ├── test-mlh-json.sh                        # 18 tests - JSON operations
+    ├── test-mlh-docker.sh                      # 18 tests - Docker shortcuts
+    ├── test-mlh.sh                             # 20 tests - Main dispatcher
+    ├── test-search.sh                          # 16 tests - File search
+    ├── test-isjsonvalid.sh                     # 18 tests - JSON validation
+    ├── test-ll.sh                              # 10 tests - Directory listing
+    ├── test-mlh-about.sh                       # 12 tests - About page
+    ├── test-shellcheck.sh                      # 6 tests - Code quality validation
+    ├── test-current-session.sh                 # 1 test - Session history
+    └── test-time-debug.sh                      # 4 tests - Time parsing
 ```
 
 ## 🧪 Testing
 
-MyLinuxHelper includes a comprehensive test suite with **161 tests** covering all major functionality.
+MyLinuxHelper includes a comprehensive test suite with **293 tests** covering all major functionality.
 
 ### Running Tests
 
@@ -277,25 +397,36 @@ MyLinuxHelper includes a comprehensive test suite with **161 tests** covering al
 ./tests/test ll
 ./tests/test mlh-about
 ./tests/test mlh
+./tests/test shellcheck
+
+# Run bookmark tests (subdirectory)
+./tests/test bookmark/mlh-bookmark
+./tests/test bookmark/bookmark-alias
+./tests/test bookmark/bookmark-alias-integration
 ```
 
 ### Test Coverage
 
-✅ **161 total tests** with **100% success rate** (0 failing tests)
+✅ **293 total tests** with **288 passed** (98.3% success rate)
 
-> **Note:** 8 tests in `mlh-json.sh` gracefully skip if `jq` is not installed. With `jq` installed, all 161 tests pass.
+> **Note:** Some tests gracefully skip if dependencies are missing (e.g., `jq` for JSON tests, `shellcheck` for code quality tests, `tmux` for interactive tests).
 
-**Completed Test Suites:**
+**Test Suites:**
 
-1. **mlh-history.sh** (34 tests) - Command history, time parsing, filtering
-2. **linux.sh** (15 tests) - Container management, Docker commands
-3. **mlh-json.sh** (18 tests) - JSON search, validation, fuzzy matching
-4. **mlh-docker.sh** (18 tests) - Container access, pattern matching
-5. **mlh.sh** (20 tests) - Main dispatcher, routing, interactive menu
-6. **search.sh** (16 tests) - File search, wildcards, error handling
-7. **isjsonvalid.sh** (18 tests) - JSON validation engine, output modes
-8. **ll.sh** (10 tests) - Directory listing wrapper
-9. **mlh-about.sh** (12 tests) - Project information display
+1. **bookmark/mlh-bookmark.sh** (80 tests) - Bookmark functionality, interactive mode, categories
+2. **bookmark/bookmark-alias.sh** (28 tests) - Alias configuration and validation
+3. **bookmark/bookmark-alias-integration.sh** (13 tests) - Alias integration with setup.sh
+4. **mlh-history.sh** (34 tests) - Command history, time parsing, filtering
+5. **linux.sh** (15 tests) - Container management, Docker commands
+6. **mlh-json.sh** (18 tests) - JSON search, validation, fuzzy matching
+7. **mlh-docker.sh** (18 tests) - Container access, pattern matching
+8. **mlh.sh** (20 tests) - Main dispatcher, routing, interactive menu
+9. **search.sh** (16 tests) - File search, wildcards, error handling
+10. **isjsonvalid.sh** (18 tests) - JSON validation engine, output modes
+11. **ll.sh** (10 tests) - Directory listing wrapper
+12. **mlh-about.sh** (12 tests) - Project information display
+13. **shellcheck** (6 tests) - Code quality validation (requires shellcheck)
+14. **current-session** (1 test) - Session history tracking
 
 ### Test Framework Features
 
@@ -317,14 +448,14 @@ shfmt -w .
 shellcheck plugins/*.sh tests/*.sh
 ```
 
-**ShellCheck Compliance:**
+**Code Quality:**
 
-- ✅ All SC2155 warnings fixed (separate declare and assign)
-- ✅ No unused variables
-- ✅ Proper error handling with `set -euo pipefail`
-- ✅ Clean syntax validation
+- ✅ **ShellCheck Compliance**: All scripts pass ShellCheck validation (automated test suite)
+- ✅ **Formatting**: All scripts formatted with `shfmt` for consistency
+- ✅ **Best Practices**: Proper error handling with `set -euo pipefail`
+- ✅ **Clean Syntax**: No unused variables, proper quoting, safe command execution
 
-See `TEST_PLAN.md` for detailed testing strategy and `PROGRESS.md` for current status.
+The test suite includes automated ShellCheck validation to ensure code quality across all scripts.
 
 ## 🔧 Development
 
diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000..a024600
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,487 @@
+# MyLinuxHelper - Bookmark Feature Improvements
+
+Bu dosya bookmark özelliğini nasıl geliştirebileceğimize dair önerileri içerir.
+
+---
+
+## 🎯 Usability İyileştirmeleri (High Priority)
+
+### 1. Kısa Komut Alias'ı - `bm`
+
+**Problem**: `bookmark` yazmak uzun, hızlı kullanımda yavaşlatıyor.
+
+**Önerilen Çözüm**:
+
+```bash
+# bm alias'ı ekle (bookmark'un kısa hali)
+bm .                    # bookmark . ile aynı
+bm list                 # bookmark list ile aynı
+bm -l                   # bookmark list -i (interactive)
+bm -s myapp             # bookmark myapp (jump - "s" = switch)
+bm -a myapp             # bookmark . -n myapp (add with name)
+```
+
+**Implementation**:
+
+- `setup.sh`: `bm` symlink'i ekle
+- `plugins/bm.sh`: Yeni script, argümanları parse edip `mlh-bookmark.sh`'a delege et
+- Flag-based shortcuts ekle (-l, -s, -a)
+
+**Impact**: ⭐⭐⭐⭐⭐ (Günlük kullanımda büyük fark)
+
+---
+
+### 2. Otomatik Git Repo Detection
+
+**Problem**: Git repo'larda çalışırken, root dizini bulmak için manuel bookmark kaydetmek gerekiyor.
+
+**Önerilen Çözüm**:
+
+```bash
+# Git repo root'unu otomatik bookmark'la
+bookmark . -g                       # Git root'unu kaydet
+bookmark . -n myrepo -g            # Git root'unu isimle kaydet
+
+# Otomatik kategori: git/
+# Örnek: projects/myrepo → git/myrepo
+```
+
+**Implementation**:
+
+- `mlh-bookmark.sh`: `-g` flag ekle
+- `git rev-parse --show-toplevel` ile repo root bul
+- Otomatik kategori: `git/<repo-name>`
+
+**Impact**: ⭐⭐⭐⭐ (Developer'lar için çok kullanışlı)
+
+---
+
+### 3. Fuzzy Finder Integration (fzf)
+
+**Problem**: Interactive mode güzel ama büyük listelerde arama yok.
+
+**Önerilen Çözüm**:
+
+```bash
+# fzf ile fuzzy search
+bookmark list -f                    # fzf ile filtrele
+bm -f                              # Kısa hali
+
+# Preview window ile path göster
+# Real-time filtering
+# Multi-select destekle (birden fazla bookmark'ı sil/edit)
+```
+
+**Implementation**:
+
+- `fzf` varsa kullan, yoksa fallback olarak mevcut interactive mode
+- Preview window: `bookmark list` output'u göster
+- Multi-select ile toplu işlem
+
+**Impact**: ⭐⭐⭐⭐⭐ (Power user'lar için harika)
+
+---
+
+### 4. Tab Completion
+
+**Problem**: Bookmark isimleri ve kategorileri tab ile complete edilemiyor.
+
+**Önerilen Çözüm**:
+
+```bash
+# Bash completion ekle
+bookmark my<TAB>        # myapp, myproject gibi isimleri complete et
+bookmark list pro<TAB>  # projects kategorisini complete et
+bm -s my<TAB>          # Jump için bookmark isimlerini complete et
+```
+
+**Implementation**:
+
+- `completions/bookmark.bash`: Bash completion script
+- `setup.sh`: Completion'ı yükle
+- JSON'dan bookmark isimlerini ve kategorileri parse et
+
+**Impact**: ⭐⭐⭐⭐ (UX için önemli)
+
+---
+
+## 🚀 Feature Enhancements (Medium Priority)
+
+### 5. Frecency-Based Sorting
+
+**Problem**: En çok/son kullanılan bookmark'lar listenin en üstünde değil.
+
+**Önerilen Çözüm**:
+
+```bash
+# Frequency + Recency = Frecency
+bookmark list                       # Frecency'ye göre sırala (default)
+bookmark list -c                   # Created time'a göre sırala
+bookmark list -a                   # Alphabetical sırala
+bookmark list -f                   # Frequency'ye göre sırala
+```
+
+**Implementation**:
+
+- JSON'a `access_count` ve `last_accessed` zaten var
+- Frecency score hesapla: `score = frequency * decay_factor(time_since_access)`
+- Liste çıktısında sıralama seçeneği ekle
+
+**Impact**: ⭐⭐⭐⭐ (Kullanım kolaylığı artar)
+
+---
+
+### 6. Bookmark Descriptions/Notes
+
+**Problem**: Bookmark ismi yeterli bilgi vermiyor bazen.
+
+**Önerilen Çözüm**:
+
+```bash
+# Description ekle
+bookmark . -n myapp -d "Production API server"
+bookmark edit myapp                # Description da düzenlenebilir
+
+# Liste görünümünde description göster
+bookmark list
+# Output:
+# [myapp] /home/user/projects/myapp
+#   → Production API server
+```
+
+**Implementation**:
+
+- JSON'a `description` field ekle
+- `save_named_bookmark()`: `-d` flag parse et
+- Liste çıktısında description'ı GRAY renkte göster
+
+**Impact**: ⭐⭐⭐ (Nice-to-have, büyük workspace'lerde kullanışlı)
+
+---
+
+### 7. Bookmark Export/Import
+
+**Problem**: Bookmark'ları başka makineye taşımak zor.
+
+**Önerilen Çözüm**:
+
+```bash
+# Export
+bookmark export bookmarks.json      # Tüm bookmark'ları export et
+bookmark export -c projects out.json # Sadece bir kategoriyi export et
+
+# Import
+bookmark import bookmarks.json      # Import et (mevcut bookmark'ları koru)
+bookmark import -r bookmarks.json   # Replace (mevcut bookmark'ları sil)
+```
+
+**Implementation**:
+
+- Export: JSON dosyasını kopyala (opsiyonel: sadece named bookmarks)
+- Import: JSON merge et, duplicate check yap
+- `-r` flag ile replace modu
+
+**Impact**: ⭐⭐⭐ (Team/multi-machine setup için önemli)
+
+---
+
+### 8. Bookmark Sync (Cloud/Git)
+
+**Problem**: Bookmark'lar sadece lokal, başka makinede yok.
+
+**Önerilen Çözüm**:
+
+```bash
+# Git sync
+bookmark sync init                  # Git repo oluştur (~/.mylinuxhelper)
+bookmark sync push                  # Commit + push
+bookmark sync pull                  # Pull + merge
+
+# Otomatik sync
+bookmark sync auto on               # Her save/edit/delete'de otomatik push
+```
+
+**Implementation**:
+
+- `~/.mylinuxhelper/.git` klasörü oluştur
+- `bookmark sync`: Git operasyonları (add, commit, push, pull)
+- Conflict resolution: Last-write-wins veya interactive merge
+
+**Impact**: ⭐⭐⭐⭐ (Multi-device kullanıcılar için killer feature)
+
+---
+
+### 9. Bookmark Aliases
+
+**Problem**: Bazı bookmark'lara birden fazla isimle erişmek istiyoruz.
+
+**Önerilen Çözüm**:
+
+```bash
+# Alias ekle
+bookmark alias prod myapp           # prod -> myapp alias'ı
+bookmark prod                       # myapp'e gider
+
+# Alias listesi
+bookmark aliases                    # Tüm alias'ları göster
+bookmark alias rm prod              # Alias'ı sil
+```
+
+**Implementation**:
+
+- JSON'a `aliases` array ekle: `["prod", "production"]`
+- Jump fonksiyonunda alias check ekle
+- Liste çıktısında alias'ları göster: `[myapp] (aliases: prod, production)`
+
+**Impact**: ⭐⭐⭐ (Nice-to-have, isim kolaylığı)
+
+---
+
+## 🎨 UI/UX İyileştirmeleri (Low Priority)
+
+### 10. Kategori Renklendirme
+
+**Problem**: Interactive mode'da kategoriler renksiz, ayırt etmek zor.
+
+**Önerilen Çözüm**:
+
+```bash
+# Kategori başına farklı renk
+# projects/    → GREEN
+# git/         → CYAN
+# tools/       → YELLOW
+# work/        → BLUE
+```
+
+**Implementation**:
+
+- Kategori ismine göre hash hesapla
+- Hash'den renk seç (6-8 farklı renk)
+- Interactive mode ve list çıktısında uygula
+
+**Impact**: ⭐⭐ (Görsel iyileştirme)
+
+---
+
+### 11. Bookmark Preview
+
+**Problem**: Bookmark seçerken içinde ne olduğu görünmüyor.
+
+**Önerilen Çözüm**:
+```bash
+# Interactive mode'da preview
+bookmark list -i -p                 # Preview window ile
+
+# Preview gösterir:
+# - Directory tree (ls -la)
+# - Git status (eğer git repo ise)
+# - Dosya sayısı, toplam boyut
+```
+
+**Implementation**:
+
+- fzf preview window kullan (fzf varsa)
+- Split screen: Sol taraf liste, sağ taraf preview
+- Preview command: `ls -la $path | head -20`
+
+**Impact**: ⭐⭐⭐ (fzf ile birlikte güçlü)
+
+---
+
+### 12. CD History Tracking (pushd/popd gibi)
+
+**Problem**: Bookmark sisteminden bağımsız, geçici cd history tutulmuyor.
+
+**Önerilen Çözüm**:
+
+```bash
+# CD history
+bookmark history                    # Son 10 CD'yi göster (stack)
+bookmark back                       # Önceki dizine dön (popd gibi)
+bookmark forward                    # İleri git (forward stack)
+
+# Alias
+bm -b                              # back
+bm -F                              # forward
+bm -h                              # history
+```
+
+**Implementation**:
+
+- Wrapper function'da her CD'yi stack'e ekle
+- Stack file: `~/.mylinuxhelper/cd_history.json`
+- Max 50 entry, LIFO
+- Back/forward stack ile bidirectional gezinme
+
+**Impact**: ⭐⭐⭐⭐ (Browser gibi navigation)
+
+---
+
+## 🔧 Code Organization & Refactoring
+
+### 13. Modüler Yapı
+
+**Öneri**:
+
+```bash
+plugins/
+├── mlh-bookmark.sh           # Main entry point
+├── mlh-bookmark/
+│   ├── core.sh              # Core functions (save, jump, remove)
+│   ├── interactive.sh       # Interactive mode
+│   ├── search.sh            # Find, fuzzy search
+│   ├── category.sh          # Category management
+│   ├── git.sh               # Git integration
+│   ├── sync.sh              # Cloud/Git sync
+│   └── completion.bash      # Tab completion
+```
+
+**Benefit**:
+
+- Her modül bağımsız test edilebilir
+- Code reusability artar
+- Maintenance kolaylaşır
+
+---
+
+### 14. Config System
+
+**Öneri**:
+
+```bash
+# Kullanıcı config
+~/.mylinuxhelper/bookmark-config.json
+
+{
+  "max_unnamed": 10,
+  "default_sort": "frecency",
+  "auto_git_detect": true,
+  "enable_sync": false,
+  "sync_remote": "git@github.com:user/bookmarks.git",
+  "colors": {
+    "category": "auto",
+    "bookmark": "green"
+  }
+}
+
+# Config komutları
+bookmark config set max_unnamed 20
+bookmark config get max_unnamed
+bookmark config list
+```
+
+**Benefit**:
+
+- Kullanıcı tercihleri
+- Değişiklik için kod değiştirmeye gerek yok
+
+---
+
+### 15. Plugin API
+
+**Öneri**:
+
+```bash
+# Bookmark event hooks
+~/.mylinuxhelper/hooks/bookmark-post-save.sh
+~/.mylinuxhelper/hooks/bookmark-post-jump.sh
+
+# Hook çağrılır:
+# $1 = event (save, jump, delete)
+# $2 = bookmark name/number
+# $3 = path
+
+# Örnek kullanım:
+# - Slack'e notification gönder
+# - Log file'a yaz
+# - External tool ile entegre et
+```
+
+**Benefit**:
+
+- Extensibility
+- Custom workflows
+- Community plugins
+
+---
+
+## 📊 Test Coverage Genişletme
+
+### 16. Yeni Test Senaryoları
+
+**Eklenecek Testler**:
+
+- [ ] fzf integration tests
+- [ ] Tab completion tests
+- [ ] Git integration tests
+- [ ] Sync tests (mock git remote)
+- [ ] Frecency sorting tests
+- [ ] Alias tests
+- [ ] Export/import tests
+- [ ] Config system tests
+- [ ] Hook system tests
+
+**Target**: 100+ test (şu an 80)
+
+---
+
+## 🏆 Priority Matrix
+
+| Özellik          | Impact | Effort | Priority |
+|------------------|--------|--------|----------|
+| `bm` alias       | ⭐⭐⭐⭐⭐  | Low    | 🔥 HIGH  |
+| fzf integration  | ⭐⭐⭐⭐⭐  | Medium | 🔥 HIGH  |
+| Tab completion   | ⭐⭐⭐⭐   | Medium | 🔥 HIGH  |
+| Git integration  | ⭐⭐⭐⭐   | Medium | ⚡ MEDIUM |
+| Frecency sorting | ⭐⭐⭐⭐   | Low    | ⚡ MEDIUM |
+| CD history       | ⭐⭐⭐⭐   | Medium | ⚡ MEDIUM |
+| Bookmark sync    | ⭐⭐⭐⭐   | High   | ⚡ MEDIUM |
+| Export/import    | ⭐⭐⭐    | Low    | ⚡ MEDIUM |
+| Descriptions     | ⭐⭐⭐    | Low    | 💤 LOW   |
+| Aliases          | ⭐⭐⭐    | Medium | 💤 LOW   |
+| Renklendirme     | ⭐⭐     | Low    | 💤 LOW   |
+| Preview          | ⭐⭐⭐    | Medium | 💤 LOW   |
+
+---
+
+## 🎯 Implementation Roadmap
+
+### Phase 4: Usability (Sprint 1-2)
+
+- [ ] `bm` alias ve flag shortcuts
+- [ ] Tab completion
+- [ ] Frecency-based sorting
+
+### Phase 5: Integration (Sprint 3-4)
+
+- [ ] fzf integration
+- [ ] Git repo detection
+- [ ] CD history tracking
+
+### Phase 6: Advanced (Sprint 5-6)
+
+- [ ] Export/import
+- [ ] Bookmark sync
+- [ ] Config system
+
+### Phase 7: Polish (Sprint 7+)
+
+- [ ] Descriptions/notes
+- [ ] Aliases
+- [ ] Preview mode
+- [ ] Modüler refactoring
+
+---
+
+**Son Güncelleme**: 2025-11-07  
+**Status**: ✅ Phase 1-3 Complete, Phase 4+ Planning
+
+---
+
+## 📝 Notes
+
+- Her yeni özellik için **test-driven** yaklaşım
+- Backward compatibility kır**ma**
+- Breaking change gerekirse version bump (v2.0)
+- Her feature için dokümantasyon güncelle
+- Community feedback al (GitHub issues)
diff --git a/docs/BOOKMARK_ALIAS_GUIDE.md b/docs/BOOKMARK_ALIAS_GUIDE.md
new file mode 100644
index 0000000..87e96fd
--- /dev/null
+++ b/docs/BOOKMARK_ALIAS_GUIDE.md
@@ -0,0 +1,232 @@
+# Bookmark Alias Configuration Guide
+
+This guide explains how to configure a custom shortcut/alias for the `bookmark` command.
+
+## Quick Start
+
+1. Create the config file:
+```bash
+mkdir -p ~/.mylinuxhelper
+echo "BOOKMARK_ALIAS=bm" > ~/.mylinuxhelper/mlh.conf
+```
+
+2. Run setup:
+```bash
+cd ~/.mylinuxhelper
+./setup.sh
+```
+
+3. Apply changes (important!):
+```bash
+source ~/.bashrc
+```
+
+Now you can use `bm` instead of `bookmark`:
+```bash
+bm .           # Save current directory
+bm 1           # Jump to bookmark 1
+bm list        # Interactive list (default)
+```
+
+## Configuration Details
+
+### Config File Location
+
+The configuration file must be at:
+```
+~/.mylinuxhelper/mlh.conf
+```
+
+### Config File Format
+
+The file should contain:
+```bash
+# MyLinuxHelper Configuration
+BOOKMARK_ALIAS=bm
+```
+
+**Valid alias names:**
+- Alphanumeric characters and underscores only
+- No spaces or special characters
+- Examples: `bm`, `b`, `fav`, `goto`, `quick_mark`
+
+**Invalid alias names:**
+- Names with spaces: `my bookmark` ❌
+- Names with special chars: `book-mark`, `book@mark` ❌
+- Existing command names: `cd`, `ls`, `git` ❌ (will be detected and skipped)
+
+### Multiple Variables
+
+You can add comments or other settings:
+```bash
+# MyLinuxHelper Configuration
+# Bookmark command alias
+BOOKMARK_ALIAS=bm
+
+# Other future settings can go here
+```
+
+Only `BOOKMARK_ALIAS` is used by the bookmark system currently.
+
+## How It Works
+
+When you configure an alias:
+
+1. **Symlink**: A symlink is created at `~/.local/bin/your_alias` → `mlh-bookmark.sh`
+2. **Wrapper Function**: A bash function is added to `~/.bashrc`:
+   ```bash
+   your_alias() {
+     bookmark "$@"
+   }
+   ```
+3. **Help Integration**: The `--help` output automatically uses your alias name
+
+### Command Chain
+
+```
+User types: bm list
+  ↓
+bm() function in ~/.bashrc
+  ↓
+bookmark() function in ~/.bashrc  
+  ↓
+mlh-bookmark.sh executes
+  ↓
+Interactive TUI displayed
+```
+
+## Changing Your Alias
+
+To change the alias:
+
+1. Edit the config file:
+```bash
+nano ~/.mylinuxhelper/mlh.conf
+# Change BOOKMARK_ALIAS=bm to BOOKMARK_ALIAS=fav
+```
+
+2. Re-run setup:
+```bash
+cd ~/.mylinuxhelper
+./setup.sh
+```
+
+3. Apply changes:
+```bash
+source ~/.bashrc
+```
+
+**Note**: The old alias function will remain in your `.bashrc` but won't cause issues. You can manually remove it if desired.
+
+## Disabling the Alias
+
+To disable the alias and use only `bookmark`:
+
+1. Edit or clear the config file:
+```bash
+nano ~/.mylinuxhelper/mlh.conf
+# Set BOOKMARK_ALIAS="" or delete the line
+```
+
+2. Re-run setup:
+```bash
+cd ~/.mylinuxhelper
+./setup.sh
+```
+
+The symlink won't be created, but the function in `.bashrc` will remain (harmless).
+
+## Troubleshooting
+
+### Alias not working after setup
+
+**Problem**: You ran setup but `bm` doesn't work.
+
+**Solution**: You must reload your shell:
+```bash
+source ~/.bashrc
+```
+
+Or open a new terminal.
+
+### Command conflict detected
+
+**Problem**: Setup says "Command 'xyz' already exists"
+
+**Solution**: 
+- Choose a different alias name that doesn't conflict
+- The setup script checks `command -v your_alias` to prevent conflicts
+
+### Help still shows 'bookmark' instead of alias
+
+**Problem**: `bm --help` shows examples with `bookmark` instead of `bm`
+
+**Solution**:
+- Make sure the config file exists at `~/.mylinuxhelper/mlh.conf`
+- Verify the config file is readable: `cat ~/.mylinuxhelper/mlh.conf`
+- The plugin reads the config at runtime
+
+### Alias works but directory doesn't change
+
+**Problem**: `bm 1` runs but doesn't change directory
+
+**Solution**: Make sure you sourced `.bashrc` after setup:
+```bash
+source ~/.bashrc
+```
+
+The wrapper function must be loaded for `cd` to work.
+
+## Examples
+
+### Example 1: Short alias 'b'
+```bash
+echo "BOOKMARK_ALIAS=b" > ~/.mylinuxhelper/mlh.conf
+./setup.sh
+source ~/.bashrc
+
+b .              # Save
+b 1              # Jump
+b list           # Interactive list
+```
+
+### Example 2: Descriptive alias 'goto'
+```bash
+echo "BOOKMARK_ALIAS=goto" > ~/.mylinuxhelper/mlh.conf
+./setup.sh
+source ~/.bashrc
+
+goto .           # Save
+goto projects    # Jump to named bookmark
+goto list        # Interactive list
+```
+
+### Example 3: Using with categories
+```bash
+echo "BOOKMARK_ALIAS=fav" > ~/.mylinuxhelper/mlh.conf
+./setup.sh
+source ~/.bashrc
+
+fav . -n myapp in projects/java
+fav myapp
+fav list projects
+```
+
+## Advanced: Checking Current Configuration
+
+To see your current alias configuration:
+```bash
+cat ~/.mylinuxhelper/mlh.conf
+```
+
+To test if the alias is loaded:
+```bash
+type bm    # Should show: bm is a function
+type bookmark  # Should show: bookmark is a function
+```
+
+To see where the symlink points:
+```bash
+ls -l ~/.local/bin/bm
+# Should show: bm -> /home/user/.mylinuxhelper/plugins/mlh-bookmark.sh
+```
diff --git a/docs/BOOKMARK_QUICK_REFERENCE.md b/docs/BOOKMARK_QUICK_REFERENCE.md
new file mode 100644
index 0000000..3d0b6e4
--- /dev/null
+++ b/docs/BOOKMARK_QUICK_REFERENCE.md
@@ -0,0 +1,213 @@
+# Bookmark - Quick Reference Guide
+
+Quick directory bookmarking and navigation system.
+
+## 🚀 Quick Start
+
+### Basic Operations
+
+```bash
+bookmark .                          # Save current directory (numbered)
+bookmark 1                          # Jump to bookmark #1
+bookmark . -n project               # Save with name
+bookmark project                    # Jump to named bookmark
+bookmark list                       # Interactive menu (default)
+bookmark list -n                    # Non-interactive list
+```
+
+## 📋 Category-Based Usage
+
+### Categorization
+
+```bash
+bookmark . -n mlh in tools          # Save with category
+bookmark . -n api in projects/java  # Sub-category
+bookmark list projects              # Filter by category
+bookmark mv mlh to utils            # Move to category
+```
+
+### Search & Edit
+
+```bash
+bookmark find java                  # Search
+bookmark edit mlh                   # Edit (name/path/category)
+bookmark rm project                 # Remove
+```
+
+### List Operations
+
+```bash
+bookmark list 5                     # Show last 5 numbered bookmarks
+bookmark clear                      # Clear all numbered bookmarks
+```
+
+## ⌨️ Interactive Mode (bookmark list)
+
+### Navigation
+
+```
+↑/↓ or j/k                         # Navigate
+Enter                               # Jump to bookmark
+e                                   # Edit
+d                                   # Delete
+h                                   # Help
+q                                   # Quit
+```
+
+## 💡 Tips
+
+### Quick Workflow
+
+1. Categorize projects: `bookmark . -n X in projects`
+2. Use interactive menu: `bookmark list`
+3. Navigate with arrow keys and press Enter
+
+### Organization
+
+- **Hierarchical categories**: Sub-categories like `aaa/bbb/ccc`
+- **Name conflict prevention**: System commands automatically blocked
+- **Automatic path validation**: ⚠ marks deleted paths
+
+## 📦 Features
+
+- **Stack-based numbered bookmarks**: Max 10, LIFO (last added becomes #1)
+- **Named bookmarks**: Unlimited, persistent
+- **Hierarchical categories**: Multi-level organization
+- **Fuzzy search**: Smart search with `bookmark find`
+- **JSON storage**: `~/.mylinuxhelper/bookmarks.json`
+- **Path validation**: Warnings for deleted directories
+
+## 📊 Command Reference (Alphabetical)
+
+| Command                         | Description              | Example                     |
+|---------------------------------|--------------------------|-----------------------------|
+| `bookmark .`                    | Save current directory   | `bookmark .`                |
+| `bookmark . -n <name>`          | Save with name           | `bookmark . -n myapp`       |
+| `bookmark . -n <name> in <cat>` | Save with category       | `bookmark . -n api in java` |
+| `bookmark <number>`             | Jump to numbered         | `bookmark 1`                |
+| `bookmark <name>`               | Jump to named            | `bookmark myapp`            |
+| `bookmark clear`                | Clear numbered bookmarks | `bookmark clear`            |
+| `bookmark edit <name>`          | Edit bookmark            | `bookmark edit myapp`       |
+| `bookmark find <pattern>`       | Search bookmarks         | `bookmark find shop`        |
+| `bookmark list`                 | Interactive menu         | `bookmark list`             |
+| `bookmark list -n`              | Non-interactive list     | `bookmark list -n`          |
+| `bookmark list <category>`      | Filter by category       | `bookmark list java`        |
+| `bookmark list <N>`             | Last N numbered          | `bookmark list 5`           |
+| `bookmark mv <name> to <cat>`   | Move to category         | `bookmark mv api to tools`  |
+| `bookmark rm <name\|number>`    | Remove bookmark          | `bookmark rm oldapp`        |
+| `bookmark --help`               | Show help                | `bookmark --help`           |
+
+## 🎯 Usage Scenarios
+
+### Scenario 1: Quick Switching Between Project Directories
+
+```bash
+# Categorize projects
+bookmark . -n frontend in work/projects
+bookmark . -n backend in work/projects
+bookmark . -n docs in work/projects
+
+# Jump with interactive menu
+bookmark list
+```
+
+### Scenario 2: Remembering Temporary Directories
+
+```bash
+# Quick save
+bookmark .                          # Saved as #1
+
+cd /etc/nginx/sites-available
+# ... do work ...
+
+# Jump back
+bookmark 1
+```
+
+### Scenario 3: Categorized Workspace
+
+```bash
+# Organize by category
+bookmark . -n api in java/backend
+bookmark . -n web in js/frontend
+bookmark . -n mobile in kotlin/android
+
+# Filter by category
+bookmark list java                  # Only java category
+bookmark find backend               # All containing "backend"
+```
+
+### Scenario 4: Quick Search and Navigation
+
+```bash
+# Can't remember where a project is
+bookmark find shop                  # All bookmarks containing "shop"
+bookmark list                       # Interactive search + selection
+```
+
+## 🔧 Advanced Tips
+
+### Convert Numbered Bookmark to Named
+
+```bash
+cd /long/path/project
+bookmark .                          # Saved as #1
+bookmark 1 -n myproject             # Convert to named bookmark
+```
+
+### Change Category
+
+```bash
+bookmark mv myproject to archive    # Move to category
+```
+
+### Bulk Cleanup
+
+```bash
+bookmark clear                      # Delete all numbered bookmarks (asks confirmation)
+```
+
+## 🎨 Custom Alias
+
+Create a shorter command alias (e.g., `bm`):
+
+```bash
+echo "BOOKMARK_ALIAS=bm" > ~/.mylinuxhelper/mlh.conf
+./setup.sh
+source ~/.bashrc
+
+bm .                                # Save
+bm list                             # Interactive menu
+bm project                          # Jump
+```
+
+See `docs/BOOKMARK_ALIAS_GUIDE.md` for detailed configuration.
+
+## 🐛 Troubleshooting
+
+### Bookmark not working
+
+```bash
+./setup.sh                          # Reload wrapper function
+source ~/.bashrc                    # Reload shell
+```
+
+### JSON file corrupted
+
+```bash
+cat ~/.mylinuxhelper/bookmarks.json | jq .  # Validate
+# If corrupted, restore from backup or delete file (will be recreated)
+```
+
+### Path no longer exists warning
+
+```bash
+bookmark edit myproject             # Update path
+# or
+bookmark rm myproject               # Remove
+```
+
+---
+
+**Last Updated**: 2025-11-08  
+**Version**: MyLinuxHelper v1.5.0+
diff --git a/docs/RELEASE_NOTES_v1.5.0.md b/docs/RELEASE_NOTES_v1.5.0.md
new file mode 100644
index 0000000..14aba23
--- /dev/null
+++ b/docs/RELEASE_NOTES_v1.5.0.md
@@ -0,0 +1,241 @@
+# MyLinuxHelper v1.5.0 - Release Notes
+
+**Release Date:** 2025-11-09
+**Previous Version:** v1.4.1
+
+---
+
+## 🎉 What's New in v1.5.0
+
+### ⭐ Major Feature: Configurable Bookmark Shortcuts (Phase 4)
+
+We've added a highly requested usability feature - **configurable shortcut aliases** for the `bookmark` command!
+
+#### Key Highlights:
+
+- **Custom Shortcuts:** Create your own shortcut/alias for the `bookmark` command (e.g., `bm`, `fav`, `goto`)
+- **Simple Setup:** Just add `BOOKMARK_ALIAS=bm` to `~/.mylinuxhelper/mlh.conf` and run `./setup.sh`
+- **Smart Conflict Detection:** Setup warns if your chosen alias conflicts with existing commands
+- **Dynamic Help:** Help text automatically shows examples using your configured shortcut
+- **Full Feature Support:** All bookmark features work with the alias - it's just a convenient shortcut
+
+#### Example Usage:
+
+```bash
+# After setup, if you chose 'bm':
+bm .                    # Save current directory
+bm list                 # Interactive list (NEW: default behavior)
+bm myproject            # Jump to named bookmark
+bm --help               # Help shows 'bm' in examples
+```
+
+#### Configuration:
+
+- **Config file:** `~/.mylinuxhelper/mlh.conf` (new centralized config for all MLH settings)
+- **Format:** `BOOKMARK_ALIAS=bm`
+- **Example:** See `docs/config/mlh.conf.example` in repository
+- Change anytime by editing the config file and re-running `./setup.sh`
+- Set to empty string to disable the shortcut
+
+---
+
+### 🚀 Improved Default Behavior
+
+#### Interactive List by Default
+- **`bookmark list` now shows interactive TUI by default** (was non-interactive)
+- **Faster workflow:** No need to add `-i` flag anymore
+- **New flag:** Use `bookmark list -n` for non-interactive simple output
+- **Filter support:** `bookmark list <category>` opens interactive list filtered by category
+
+**Before:**
+```bash
+bookmark list           # Non-interactive output
+bookmark list -i        # Interactive TUI (had to specify)
+```
+
+**Now:**
+```bash
+bookmark list           # Interactive TUI (default - faster!)
+bookmark list -n        # Non-interactive output (when needed)
+```
+
+---
+
+
+### ✨ Enhancements
+
+#### Unified Configuration System
+- **New:** Centralized `mlh.conf` for all MLH configuration
+- **Better organized:** Clear sections for different features
+- **Future-ready:** All future MLH settings will use this file
+- **Example provided:** See `docs/config/mlh.conf.example`
+
+#### Bookmark System
+- **Improved:** Hierarchical category display in list view
+  - Categories now display with proper indentation: `📂 projects/linux`
+  - Subcategories are shown nested under parent categories
+- **Improved:** Path validation warnings with better visual indicators (⚠ symbol)
+- **Improved:** Better handling of command name conflicts during bookmark creation
+
+#### Testing & Quality
+- **Reorganized:** Bookmark tests moved to `tests/bookmark/` subdirectory
+- **Added:** Comprehensive test suite for bookmark alias feature (41 new tests)
+  - Config file handling (28 tests)
+  - Dynamic help display
+  - Alias validation and conflict detection
+  - Integration tests (13 tests)
+- **Added:** Automated ShellCheck validation test suite
+  - Validates all shell scripts for code quality
+  - Integrated into main test runner
+- **Total Test Count:** Now **293 tests** (was 246)
+  - bookmark/mlh-bookmark: 80 tests
+  - bookmark/bookmark-alias: 28 tests  
+  - bookmark/bookmark-alias-integration: 13 tests
+  - shellcheck: 6 tests (validates code quality)
+  - All other test suites: stable
+- **Code Quality:** All scripts pass ShellCheck validation
+- **Formatting:** All scripts formatted with shfmt for consistency
+
+---
+
+### 📚 Documentation Updates
+
+#### New Documentation
+- **`docs/config/mlh.conf.example`:** Template configuration file with all options documented
+- **`docs/BOOKMARK_ALIAS_GUIDE.md`:** Comprehensive alias setup and troubleshooting guide (moved from old location)
+
+#### Updated Documentation
+- **`CLAUDE.md`:** 
+  - Updated with centralized config system architecture
+  - New test structure documentation
+  - Bookmark alias implementation details
+- **`README.md`:** 
+  - Updated bookmark examples to show new default behavior
+  - Config system reference
+
+---
+
+## 📊 Test Results
+
+```
+Total tests:  293
+Passed:       288 (98.3%)
+Skipped:       5 (shellcheck tests when shellcheck not available)
+Failed:        0
+
+Test Coverage by Component:
+✅ bookmark/bookmark-alias-integration: 13/13 passed
+✅ bookmark/bookmark-alias:             28/28 passed
+✅ bookmark/mlh-bookmark:               80/80 passed
+✅ current-session:                     1/1 passed
+✅ isjsonvalid:                         18/18 passed
+✅ linux:                               15/15 passed
+✅ ll:                                  10/10 passed
+✅ mlh-about:                           12/12 passed
+✅ mlh-docker:                          18/18 passed
+✅ mlh-history:                         34/34 passed
+✅ mlh-json:                            18/18 passed
+✅ mlh:                                 20/20 passed
+✅ search:                              16/16 passed
+✅ shellcheck:                           6/6 passed (when shellcheck available)
+✅ time-debug:                          4/4 passed
+```
+
+**Note:** All tests pass when required tools (shellcheck, tmux) are available. Test suite now includes automated ShellCheck validation.
+
+---
+
+## 🔄 Migration Guide
+
+### Upgrading from v1.4 or v1.4.1
+
+1. **Run Update:**
+   ```bash
+   mlh update
+   # Or manually:
+   bash -c "$(curl -fsSL https://raw.githubusercontent.com/melihcelenk/MyLinuxHelper/main/get-mlh.sh)"
+   ```
+
+2. **Configure Alias (Optional):**
+   ```bash
+   # Create/edit config file
+   mkdir -p ~/.mylinuxhelper
+   nano ~/.mylinuxhelper/mlh.conf
+   
+   # Add your preferred alias
+   BOOKMARK_ALIAS=bm
+   
+   # Re-run setup to apply changes
+   cd ~/.mylinuxhelper
+   ./setup.sh
+   
+   # Reload shell
+   source ~/.bashrc
+   ```
+
+### No Breaking Changes
+
+- All existing `bookmark` commands continue to work exactly as before
+- **New default:** `bookmark list` now shows interactive menu (faster workflow!)
+- Existing bookmarks in `~/.mylinuxhelper/bookmarks.json` are fully compatible
+- Shortcut/alias feature is completely optional
+
+---
+
+## 📦 Installation
+
+### New Installation
+```bash
+bash -c "$(curl -fsSL https://raw.githubusercontent.com/melihcelenk/MyLinuxHelper/main/get-mlh.sh)" \
+|| bash -c "$(wget -qO- https://raw.githubusercontent.com/melihcelenk/MyLinuxHelper/main/get-mlh.sh)"
+```
+
+### Update Existing Installation
+```bash
+mlh update
+```
+
+---
+
+## 🎯 Roadmap for v1.6
+
+Based on the TODO.md and GitHub issues, future enhancements being considered:
+
+- **Centralized config system expansion** - Additional settings for history, docker, etc.
+- **fzf integration** for fuzzy finding bookmarks
+- **Tab completion** for bookmark names and categories
+- **Git repo detection** - automatically bookmark git repository roots
+- **Frecency-based sorting** - most frequently/recently used bookmarks first
+- **Bookmark export/import** for sharing across machines
+- **Bookmark sync** via Git for multi-device workflows
+
+---
+
+## 🐛 Known Issues
+
+1. **ShellCheck Tests:** ShellCheck validation tests are skipped if `shellcheck` is not installed. Install with `sudo apt-get install shellcheck` (or use Docker) to run these tests.
+2. **WSL Compatibility:** Interactive mode works but may require `/dev/tty` fallback in some WSL configurations. This is automatically handled by the code.
+
+---
+
+## 📞 Support & Feedback
+
+- **Issues:** https://github.com/melihcelenk/MyLinuxHelper/issues
+- **Discussions:** https://github.com/melihcelenk/MyLinuxHelper/discussions
+- **Documentation:** See `README.md` and `CLAUDE.md` in the repository
+
+---
+
+## 🙏 Acknowledgments
+
+Special thanks to all contributors and users who provided feedback on the bookmark system and requested the alias feature!
+
+---
+
+**Full Changelog:** https://github.com/melihcelenk/MyLinuxHelper/compare/v1.4.1...v1.5.0
+
+---
+
+## 📝 Note on v1.4.1
+
+v1.4.1 was an internal release with code quality improvements (ShellCheck fixes, formatting). This release (v1.5.0) includes all user-facing features and enhancements since v1.4.1.
diff --git a/docs/config/mlh.conf.example b/docs/config/mlh.conf.example
new file mode 100644
index 0000000..2960bc7
--- /dev/null
+++ b/docs/config/mlh.conf.example
@@ -0,0 +1,27 @@
+# MyLinuxHelper Configuration
+# Location: ~/.mylinuxhelper/mlh.conf
+# 
+# This file is sourced by MLH scripts to read user preferences.
+# Edit values below and run './setup.sh' to apply changes.
+# After editing, run: source ~/.bashrc
+
+# ============================================================================
+# BOOKMARK CONFIGURATION
+# ============================================================================
+
+# Bookmark command alias (shortcut)
+# Set this to create a shorter command alias (e.g., 'bm' instead of 'bookmark')
+# Valid values: alphanumeric and underscore only [a-zA-Z0-9_]
+# Examples: bm, b, fav, goto, marks
+# Default: "" (no alias)
+BOOKMARK_ALIAS="bm"
+
+# ============================================================================
+# FUTURE CONFIGURATIONS
+# ============================================================================
+# More configuration options will be added here as new features are developed.
+# Examples:
+#
+# HISTORY_MAX_ENTRIES=1000
+# DOCKER_DEFAULT_IMAGE="ubuntu:22.04"
+# ... and more
diff --git a/get-mlh.sh b/get-mlh.sh
old mode 100644
new mode 100755
index 499cfc4..c71520b
--- a/get-mlh.sh
+++ b/get-mlh.sh
@@ -90,6 +90,7 @@ download_repo() {
 
 ensure_local_bin_on_path() {
 	mkdir -p "${LOCAL_BIN}"
+	# shellcheck disable=SC2016
 	local line='export PATH="$HOME/.local/bin:$PATH"'
 	grep -Fq "$line" "$BASHRC" 2>/dev/null || echo "$line" >>"$BASHRC"
 	grep -Fq "$line" "$PROFILE" 2>/dev/null || echo "$line" >>"$PROFILE"
diff --git a/install.sh b/install.sh
old mode 100644
new mode 100755
index c0e1c89..c62c04e
--- a/install.sh
+++ b/install.sh
@@ -62,31 +62,59 @@ _install_do() {
 		rc=0
 		case "$manager" in
 		apt)
-			[ "$use_sudo" -eq 1 ] && sudo apt update -y && sudo apt install -y "$pkg" || { apt update -y && apt install -y "$pkg"; }
+			if [ "$use_sudo" -eq 1 ]; then
+				sudo apt update -y && sudo apt install -y "$pkg"
+			else
+				apt update -y && apt install -y "$pkg"
+			fi
 			rc=$?
 			;;
 		apt-get)
-			[ "$use_sudo" -eq 1 ] && sudo apt-get update -y && sudo apt-get install -y "$pkg" || { apt-get update -y && apt-get install -y "$pkg"; }
+			if [ "$use_sudo" -eq 1 ]; then
+				sudo apt-get update -y && sudo apt-get install -y "$pkg"
+			else
+				apt-get update -y && apt-get install -y "$pkg"
+			fi
 			rc=$?
 			;;
 		dnf)
-			[ "$use_sudo" -eq 1 ] && sudo dnf install -y "$pkg" || dnf install -y "$pkg"
+			if [ "$use_sudo" -eq 1 ]; then
+				sudo dnf install -y "$pkg"
+			else
+				dnf install -y "$pkg"
+			fi
 			rc=$?
 			;;
 		yum)
-			[ "$use_sudo" -eq 1 ] && sudo yum install -y "$pkg" || yum install -y "$pkg"
+			if [ "$use_sudo" -eq 1 ]; then
+				sudo yum install -y "$pkg"
+			else
+				yum install -y "$pkg"
+			fi
 			rc=$?
 			;;
 		zypper)
-			[ "$use_sudo" -eq 1 ] && sudo zypper install -y "$pkg" || zypper install -y "$pkg"
+			if [ "$use_sudo" -eq 1 ]; then
+				sudo zypper install -y "$pkg"
+			else
+				zypper install -y "$pkg"
+			fi
 			rc=$?
 			;;
 		pacman)
-			[ "$use_sudo" -eq 1 ] && sudo pacman -Sy --noconfirm "$pkg" || pacman -Sy --noconfirm "$pkg"
+			if [ "$use_sudo" -eq 1 ]; then
+				sudo pacman -Sy --noconfirm "$pkg"
+			else
+				pacman -Sy --noconfirm "$pkg"
+			fi
 			rc=$?
 			;;
 		apk)
-			[ "$use_sudo" -eq 1 ] && sudo apk add "$pkg" || apk add "$pkg"
+			if [ "$use_sudo" -eq 1 ]; then
+				sudo apk add "$pkg"
+			else
+				apk add "$pkg"
+			fi
 			rc=$?
 			;;
 		esac
diff --git a/plugins/bookmark-alias.sh b/plugins/bookmark-alias.sh
new file mode 100644
index 0000000..f482817
--- /dev/null
+++ b/plugins/bookmark-alias.sh
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# bookmark-alias.sh - Simple proxy script that delegates to mlh-bookmark.sh
+#
+# This script is created by setup.sh with the user's chosen alias name.
+# It simply forwards all arguments to the actual bookmark implementation.
+
+set -euo pipefail
+
+# Resolve the script location (handle symlinks)
+SOURCE="${BASH_SOURCE[0]}"
+while [ -L "$SOURCE" ]; do
+	TARGET="$(readlink "$SOURCE")"
+	if [[ $TARGET == /* ]]; then
+		SOURCE="$TARGET"
+	else
+		DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+		SOURCE="$DIR/$TARGET"
+	fi
+done
+SCRIPT_DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+
+# Delegate to mlh-bookmark.sh
+exec "$SCRIPT_DIR/mlh-bookmark.sh" "$@"
diff --git a/plugins/isjsonvalid.sh b/plugins/isjsonvalid.sh
old mode 100644
new mode 100755
diff --git a/plugins/linux.sh b/plugins/linux.sh
old mode 100644
new mode 100755
index eb77c58..3964e47
--- a/plugins/linux.sh
+++ b/plugins/linux.sh
@@ -27,6 +27,11 @@
 
 set -euo pipefail
 
+# Colors
+readonly GREEN='\033[0;32m'
+readonly CYAN='\033[0;36m'
+readonly NC='\033[0m'
+
 # Defaults
 MODE="tmp" # tmp | permanent | stop | delete
 IMAGE="ubuntu:24.04"
@@ -35,30 +40,54 @@ MOUNT_MLH=1
 SHELL_BIN="bash"
 
 print_help() {
+	echo -e "${CYAN}linux${NC} - Quick Linux container management"
+	echo ""
+	echo "Usage:"
 	cat <<'EOF'
-Usage:
   linux [options] <name>
   linux --help
-
-Modes:
+EOF
+	echo ""
+	echo "Modes:"
+	cat <<'EOF'
   -t, --tmp                    Ephemeral (default). Run container and auto-remove on exit.
   -p, --permanent              Permanent. Create (if missing), start, and enter. Not removed on exit.
   -s, --stop                   Stop the container <name>.
   -d, --delete                 Stop (if running) and remove the container <name>.
-
-Extra options:
+EOF
+	echo ""
+	echo "Extra options:"
+	cat <<'EOF'
   -i, --image <image>          Base image (default: ubuntu:24.04).
   -m, --mount <host:cont>      Bind mount (repeatable). Example: -m "$PWD:/workspace"
       --no-mlh                 Do NOT mount MyLinuxHelper into /opt/mlh.
       --shell <sh>             Shell inside container (default: bash).
   -h, --help                   Show this help.
-
-Examples:
+EOF
+	echo ""
+	echo "Notes:"
+	cat <<'EOF'
+  • Inside container, /opt/mlh/install.sh is sourced automatically (if mounted)
+  • Use 'i <package>' command inside container for quick package installation
+  • Requires Docker to be installed
+EOF
+	echo ""
+	echo "Examples:"
+	echo -e "  ${GREEN}# Quick ephemeral container${NC}"
+	cat <<'EOF'
   linux mycontainer
   linux -t -i debian:12 mycontainer
+EOF
+	echo ""
+	echo -e "  ${GREEN}# Persistent container with workspace${NC}"
+	cat <<'EOF'
   linux -p -m "$PWD:/workspace" mycontainer
-  linux -s mycontainer
-  linux -d mycontainer
+EOF
+	echo ""
+	echo -e "  ${GREEN}# Manage containers${NC}"
+	cat <<'EOF'
+  linux -s mycontainer         # Stop
+  linux -d mycontainer         # Delete
 EOF
 }
 
@@ -138,7 +167,7 @@ resolve_mlh_root() {
 	local plugin_dir
 	plugin_dir="$(cd -P "$(dirname "$source")" && pwd)"
 	# Root is one level up (repo root containing install.sh, setup.sh, plugins/)
-	echo "$(dirname "$plugin_dir")"
+	dirname "$plugin_dir"
 }
 
 # Parse arguments (support short + long + repeatable -m)
@@ -227,6 +256,7 @@ if [ "$MOUNT_MLH" -eq 1 ]; then
 fi
 
 # Shell entry: add MLH plugins to PATH and make 'i' function available
+# shellcheck disable=SC2016
 ENTRY_CMD='
   if [ -d /opt/mlh ]; then
     PATH="/opt/mlh/plugins:$PATH"; export PATH;
diff --git a/plugins/ll.sh b/plugins/ll.sh
old mode 100644
new mode 100755
diff --git a/plugins/mlh-about.sh b/plugins/mlh-about.sh
old mode 100644
new mode 100755
diff --git a/plugins/mlh-bookmark.sh b/plugins/mlh-bookmark.sh
new file mode 100755
index 0000000..5d55776
--- /dev/null
+++ b/plugins/mlh-bookmark.sh
@@ -0,0 +1,1408 @@
+#!/usr/bin/env bash
+# mlh-bookmark.sh - Quick directory bookmark system for fast navigation
+#
+# Usage:
+#   bookmark .                    # Save current directory (numbered)
+#   bookmark 1                    # Jump to bookmark 1
+#   bookmark . -n myproject       # Save with name
+#   bookmark myproject            # Jump to named bookmark
+#   bookmark 1 -n myapp          # Rename bookmark 1 to myapp
+#   bookmark list                 # List all bookmarks
+#   bookmark list 5               # List last 5 unnamed bookmarks
+#   bookmark --help               # Show help
+
+set -euo pipefail
+
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
+
+# Colors
+readonly GREEN='\033[0;32m'
+readonly RED='\033[0;31m'
+readonly YELLOW='\033[1;33m'
+readonly BLUE='\033[0;34m'
+readonly CYAN='\033[0;36m'
+readonly GRAY='\033[0;90m'
+readonly NC='\033[0m' # No Color
+
+# Configuration
+readonly VERSION="1.0.0"
+readonly MLH_CONFIG_DIR="${HOME}/.mylinuxhelper"
+readonly BOOKMARK_FILE="${MLH_BOOKMARK_FILE:-$MLH_CONFIG_DIR/bookmarks.json}"
+readonly MLH_CONFIG_FILE="$MLH_CONFIG_DIR/mlh.conf"
+readonly MAX_UNNAMED_BOOKMARKS=10
+
+# Load alias configuration from mlh.conf
+BOOKMARK_ALIAS=""
+if [ -f "$MLH_CONFIG_FILE" ]; then
+	# Source the main config file to get BOOKMARK_ALIAS value
+	# shellcheck source=/dev/null
+	source "$MLH_CONFIG_FILE" 2>/dev/null || true
+fi
+
+# Determine command name for help messages (alias if configured, otherwise 'bookmark')
+COMMAND_NAME="${BOOKMARK_ALIAS:-bookmark}"
+
+# Common command names to block as bookmark names
+readonly BLOCKED_NAMES=(
+	"ls" "cd" "pwd" "rm" "mv" "cp" "cat" "less" "more" "grep" "find" "sed" "awk"
+	"echo" "mkdir" "rmdir" "touch" "chmod" "chown" "ln" "tar" "gzip" "zip"
+	"git" "docker" "npm" "yarn" "python" "node" "java" "make" "ssh" "scp"
+	"mlh" "bookmark" "list" "help" "clear" "exit" "source" "export"
+)
+
+# ============================================================================
+# UTILITY FUNCTIONS
+# ============================================================================
+
+# Check if jq is installed
+check_jq() {
+	if ! command -v jq >/dev/null 2>&1; then
+		echo -e "${RED}Error: jq is required for bookmark functionality${NC}" >&2
+		echo -e "${YELLOW}Install with: sudo apt install jq${NC}" >&2
+		echo -e "${YELLOW}Or run: mlh install jq${NC}" >&2
+		exit 1
+	fi
+}
+
+# Initialize bookmark file with default structure
+init_bookmark_file() {
+	mkdir -p "$(dirname "$BOOKMARK_FILE")"
+
+	cat >"$BOOKMARK_FILE" <<'EOF'
+{
+  "version": "1.0",
+  "bookmarks": {
+    "named": [],
+    "unnamed": []
+  },
+  "config": {
+    "max_unnamed": 10,
+    "auto_cleanup": true
+  }
+}
+EOF
+}
+
+# Get current timestamp in ISO 8601 format
+get_timestamp() {
+	date -u +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || date -u +"%Y-%m-%dT%H:%M:%S%z"
+}
+
+# Validate bookmark name
+validate_name() {
+	local name="$1"
+
+	# Check if empty
+	if [ -z "$name" ]; then
+		echo -e "${RED}Error: Bookmark name cannot be empty${NC}" >&2
+		return 1
+	fi
+
+	# Check if it's a blocked command name
+	for blocked in "${BLOCKED_NAMES[@]}"; do
+		if [ "$name" = "$blocked" ]; then
+			echo -e "${RED}Error: Invalid name '$name'${NC}" >&2
+			echo -e "${YELLOW}This name conflicts with an existing command.${NC}" >&2
+			echo -e "${YELLOW}Conflicting command: $(command -v "$name" 2>/dev/null || echo "built-in")${NC}" >&2
+			return 1
+		fi
+	done
+
+	# Check if command exists with this name
+	if command -v "$name" >/dev/null 2>&1; then
+		echo -e "${RED}Error: Invalid name '$name'${NC}" >&2
+		echo -e "${YELLOW}This name conflicts with an existing command: $(command -v "$name")${NC}" >&2
+		return 1
+	fi
+
+	return 0
+}
+
+# Check if named bookmark exists
+bookmark_exists() {
+	local name="$1"
+	[ ! -f "$BOOKMARK_FILE" ] && return 1
+	local count
+	count=$(jq --arg name "$name" '[.bookmarks.named[] | select(.name == $name)] | length' "$BOOKMARK_FILE" 2>/dev/null)
+	[ "${count:-0}" -gt 0 ]
+}
+
+# Check if path exists
+path_exists() {
+	local path="$1"
+	[ -d "$path" ]
+}
+
+# ============================================================================
+# CORE BOOKMARK FUNCTIONS
+# ============================================================================
+
+# Save current directory as unnamed bookmark
+save_unnamed_bookmark() {
+	local path="$1"
+	local timestamp
+	timestamp=$(get_timestamp)
+
+	# Create bookmark file if it doesn't exist
+	[ ! -f "$BOOKMARK_FILE" ] && init_bookmark_file
+
+	# Add to unnamed bookmarks (push to front)
+	local temp_file
+	temp_file=$(mktemp)
+
+	jq --arg path "$path" \
+		--arg created "$timestamp" \
+		--argjson max "$MAX_UNNAMED_BOOKMARKS" \
+		'.bookmarks.unnamed = [{path: $path, created: $created}] + .bookmarks.unnamed |
+         .bookmarks.unnamed = .bookmarks.unnamed[0:$max] |
+         .bookmarks.unnamed = [.bookmarks.unnamed | to_entries[] | {id: (.key + 1), path: .value.path, created: .value.created}]' \
+		"$BOOKMARK_FILE" >"$temp_file"
+
+	mv "$temp_file" "$BOOKMARK_FILE"
+
+	echo -e "${GREEN}✓ Saved as bookmark 1:${NC} $path"
+}
+
+# Save named bookmark
+save_named_bookmark() {
+	local name="$1"
+	local path="$2"
+	local category="${3:-}"
+	local timestamp
+	timestamp=$(get_timestamp)
+
+	# Validate name
+	validate_name "$name" || return 1
+
+	# Check for duplicates
+	if bookmark_exists "$name"; then
+		echo -e "${RED}Error: Bookmark '$name' already exists${NC}" >&2
+		local existing_path
+		existing_path=$(jq -r --arg name "$name" '.bookmarks.named[] | select(.name == $name) | .path' "$BOOKMARK_FILE")
+		echo -e "${YELLOW}Existing path: $existing_path${NC}" >&2
+		return 1
+	fi
+
+	# Create bookmark file if it doesn't exist
+	[ ! -f "$BOOKMARK_FILE" ] && init_bookmark_file
+
+	# Add named bookmark
+	local temp_file
+	temp_file=$(mktemp)
+
+	if [ -n "$category" ]; then
+		jq --arg name "$name" \
+			--arg path "$path" \
+			--arg category "$category" \
+			--arg created "$timestamp" \
+			'.bookmarks.named += [{name: $name, path: $path, category: $category, created: $created, accessed: $created, access_count: 0}]' \
+			"$BOOKMARK_FILE" >"$temp_file"
+	else
+		jq --arg name "$name" \
+			--arg path "$path" \
+			--arg created "$timestamp" \
+			'.bookmarks.named += [{name: $name, path: $path, created: $created, accessed: $created, access_count: 0}]' \
+			"$BOOKMARK_FILE" >"$temp_file"
+	fi
+
+	mv "$temp_file" "$BOOKMARK_FILE"
+
+	echo -e "${GREEN}✓ Saved bookmark:${NC} $name ${GRAY}→${NC} $path"
+	[ -n "$category" ] && echo -e "${CYAN}  Category:${NC} $category"
+}
+
+# Rename unnamed bookmark to named
+rename_bookmark() {
+	local bookmark_id="$1"
+	local new_name="$2"
+	local category="${3:-}"
+
+	# Validate name
+	validate_name "$new_name" || return 1
+
+	# Check for duplicates
+	if bookmark_exists "$new_name"; then
+		echo -e "${RED}Error: Bookmark '$new_name' already exists${NC}" >&2
+		return 1
+	fi
+
+	# Get path from unnamed bookmark
+	local path
+	path=$(jq -r --argjson id "$bookmark_id" '.bookmarks.unnamed[] | select(.id == $id) | .path' "$BOOKMARK_FILE" 2>/dev/null)
+
+	if [ -z "$path" ] || [ "$path" = "null" ]; then
+		echo -e "${RED}Error: Bookmark $bookmark_id not found${NC}" >&2
+		return 1
+	fi
+
+	# Remove from unnamed
+	local temp_file
+	temp_file=$(mktemp)
+	jq --argjson id "$bookmark_id" '.bookmarks.unnamed = [.bookmarks.unnamed[] | select(.id != $id)]' "$BOOKMARK_FILE" >"$temp_file"
+	mv "$temp_file" "$BOOKMARK_FILE"
+
+	# Add as named bookmark
+	save_named_bookmark "$new_name" "$path" "$category"
+}
+
+# Jump to bookmark
+jump_to_bookmark() {
+	local target="$1"
+	local path=""
+
+	# Check if target is a number (unnamed bookmark)
+	if [[ "$target" =~ ^[0-9]+$ ]]; then
+		path=$(jq -r --argjson id "$target" '.bookmarks.unnamed[] | select(.id == $id) | .path' "$BOOKMARK_FILE" 2>/dev/null)
+	else
+		# Named bookmark
+		path=$(jq -r --arg name "$target" '.bookmarks.named[] | select(.name == $name) | .path' "$BOOKMARK_FILE" 2>/dev/null)
+
+		# Update access count and timestamp
+		if [ -n "$path" ] && [ "$path" != "null" ]; then
+			local temp_file
+			temp_file=$(mktemp)
+			local timestamp
+			timestamp=$(get_timestamp)
+			jq --arg name "$target" \
+				--arg timestamp "$timestamp" \
+				'(.bookmarks.named[] | select(.name == $name) | .accessed) = $timestamp |
+                 (.bookmarks.named[] | select(.name == $name) | .access_count) += 1' \
+				"$BOOKMARK_FILE" >"$temp_file"
+			mv "$temp_file" "$BOOKMARK_FILE"
+		fi
+	fi
+
+	# Check if bookmark found
+	if [ -z "$path" ] || [ "$path" = "null" ]; then
+		echo -e "${RED}Error: Bookmark '$target' not found${NC}" >&2
+		return 1
+	fi
+
+	# Check if path still exists
+	if ! path_exists "$path"; then
+		echo -e "${YELLOW}Warning: Bookmark path no longer exists${NC}" >&2
+		echo -e "${YELLOW}Path: $path (deleted on disk)${NC}" >&2
+		return 1
+	fi
+
+	# Output cd command for sourcing
+	echo "cd \"$path\""
+	echo -e "${GREEN}→${NC} $path" >&2
+}
+
+# Move bookmark to a different category
+move_bookmark() {
+	local name="$1"
+	local new_category="$2"
+
+	[ ! -f "$BOOKMARK_FILE" ] && init_bookmark_file
+
+	# Check if bookmark exists
+	local exists
+	exists=$(jq --arg name "$name" '.bookmarks.named | any(.name == $name)' "$BOOKMARK_FILE" 2>/dev/null)
+
+	if [ "$exists" != "true" ]; then
+		echo -e "${RED}Error: Bookmark '$name' not found${NC}" >&2
+		return 1
+	fi
+
+	# Update the category
+	local temp_file
+	temp_file=$(mktemp)
+
+	jq --arg name "$name" \
+		--arg category "$new_category" \
+		'(.bookmarks.named[] | select(.name == $name) | .category) = $category' \
+		"$BOOKMARK_FILE" >"$temp_file"
+
+	mv "$temp_file" "$BOOKMARK_FILE"
+
+	echo -e "${GREEN}✓ Moved bookmark:${NC} $name ${GRAY}→ Category:${NC} ${CYAN}$new_category${NC}"
+}
+
+# Remove a bookmark
+remove_bookmark() {
+	local name="$1"
+
+	[ ! -f "$BOOKMARK_FILE" ] && init_bookmark_file
+
+	# Check if it's a number (unnamed bookmark)
+	if [[ "$name" =~ ^[0-9]+$ ]]; then
+		local exists
+		exists=$(jq --arg id "$name" '.bookmarks.unnamed | any(.id == ($id | tonumber))' "$BOOKMARK_FILE" 2>/dev/null)
+
+		if [ "$exists" != "true" ]; then
+			echo -e "${RED}Error: Bookmark #$name not found${NC}" >&2
+			return 1
+		fi
+
+		# Remove unnamed bookmark and re-number remaining ones
+		local temp_file
+		temp_file=$(mktemp)
+
+		jq --arg id "$name" '
+			.bookmarks.unnamed |= (
+				map(select(.id != ($id | tonumber))) | 
+				to_entries | 
+				map(.value.id = (.key + 1) | .value) |
+				sort_by(.created) |
+				reverse
+			)
+		' "$BOOKMARK_FILE" >"$temp_file"
+
+		mv "$temp_file" "$BOOKMARK_FILE"
+
+		echo -e "${GREEN}✓ Removed bookmark #$name (IDs re-numbered)${NC}"
+	else
+		# Check if named bookmark exists
+		local exists
+		exists=$(jq --arg name "$name" '.bookmarks.named | any(.name == $name)' "$BOOKMARK_FILE" 2>/dev/null)
+
+		if [ "$exists" != "true" ]; then
+			echo -e "${RED}Error: Bookmark '$name' not found${NC}" >&2
+			return 1
+		fi
+
+		# Remove named bookmark
+		local temp_file
+		temp_file=$(mktemp)
+
+		jq --arg name "$name" '.bookmarks.named |= map(select(.name != $name))' \
+			"$BOOKMARK_FILE" >"$temp_file"
+
+		mv "$temp_file" "$BOOKMARK_FILE"
+
+		echo -e "${GREEN}✓ Removed bookmark:${NC} $name"
+	fi
+}
+
+# Clear all unnamed bookmarks
+clear_unnamed_bookmarks() {
+	[ ! -f "$BOOKMARK_FILE" ] && init_bookmark_file
+
+	local count
+	count=$(jq '.bookmarks.unnamed | length' "$BOOKMARK_FILE" 2>/dev/null)
+
+	if [ "$count" -eq 0 ]; then
+		echo -e "${YELLOW}No unnamed bookmarks to clear${NC}"
+		return 0
+	fi
+
+	# Ask for confirmation
+	echo -e "${YELLOW}⚠ This will remove all $count unnamed bookmarks${NC}"
+	read -rp "Are you sure? [y/N]: " confirm
+
+	if [[ "$confirm" =~ ^[Yy]$ ]]; then
+		local temp_file
+		temp_file=$(mktemp)
+
+		jq '.bookmarks.unnamed = []' "$BOOKMARK_FILE" >"$temp_file"
+		mv "$temp_file" "$BOOKMARK_FILE"
+
+		echo -e "${GREEN}✓ Cleared $count unnamed bookmarks${NC}"
+	else
+		echo "Cancelled"
+	fi
+}
+
+# Edit a bookmark
+edit_bookmark() {
+	local name="$1"
+
+	[ ! -f "$BOOKMARK_FILE" ] && init_bookmark_file
+
+	# Check if bookmark exists
+	local exists
+	exists=$(jq --arg name "$name" '.bookmarks.named | any(.name == $name)' "$BOOKMARK_FILE" 2>/dev/null)
+
+	if [ "$exists" != "true" ]; then
+		echo -e "${RED}Error: Bookmark '$name' not found${NC}" >&2
+		return 1
+	fi
+
+	# Get current values
+	local current_path current_category
+	current_path=$(jq -r --arg name "$name" '.bookmarks.named[] | select(.name == $name) | .path' "$BOOKMARK_FILE" 2>/dev/null)
+	current_category=$(jq -r --arg name "$name" '.bookmarks.named[] | select(.name == $name) | .category // ""' "$BOOKMARK_FILE" 2>/dev/null)
+
+	echo -e "${CYAN}Editing bookmark:${NC} $name"
+	echo -e "${GRAY}Current path:${NC} $current_path"
+	if [ -n "$current_category" ]; then
+		echo -e "${GRAY}Current category:${NC} $current_category"
+	else
+		echo -e "${GRAY}Current category:${NC} (none)"
+	fi
+	echo ""
+
+	# Ask for new name
+	echo -n "New name (leave empty to keep '$name'): "
+	read -r new_name
+	if [ -z "$new_name" ]; then
+		new_name="$name"
+	else
+		# Validate new name
+		if ! validate_name "$new_name"; then
+			return 1
+		fi
+		# Check if new name conflicts with existing bookmark
+		if [ "$new_name" != "$name" ]; then
+			local name_exists
+			name_exists=$(jq --arg name "$new_name" '.bookmarks.named | any(.name == $name)' "$BOOKMARK_FILE" 2>/dev/null)
+			if [ "$name_exists" = "true" ]; then
+				echo -e "${RED}Error: Bookmark '$new_name' already exists${NC}" >&2
+				return 1
+			fi
+		fi
+	fi
+
+	# Ask for new path
+	echo -n "New path (leave empty to keep current): "
+	read -r new_path
+	if [ -z "$new_path" ]; then
+		new_path="$current_path"
+	else
+		# Expand ~ to home directory
+		new_path="${new_path/#\~/$HOME}"
+		# Convert to absolute path if relative
+		if [[ ! "$new_path" = /* ]]; then
+			new_path="$(cd "$(dirname "$new_path")" 2>/dev/null && pwd)/$(basename "$new_path")" || new_path="$current_path"
+		fi
+	fi
+
+	# Ask for new category
+	if [ -n "$current_category" ]; then
+		echo -n "New category (leave empty to keep '$current_category', '-' to remove): "
+		read -r new_category
+		if [ -z "$new_category" ]; then
+			new_category="$current_category"
+		elif [ "$new_category" = "-" ]; then
+			new_category=""
+		fi
+	else
+		echo -n "Category (leave empty for none): "
+		read -r new_category
+	fi
+
+	# Update the bookmark
+	local temp_file
+	temp_file=$(mktemp)
+
+	if [ -n "$new_category" ]; then
+		jq --arg old_name "$name" \
+			--arg new_name "$new_name" \
+			--arg path "$new_path" \
+			--arg category "$new_category" \
+			'(.bookmarks.named[] | select(.name == $old_name)) |= {name: $new_name, path: $path, category: $category, created, accessed, access_count}' \
+			"$BOOKMARK_FILE" >"$temp_file"
+	else
+		jq --arg old_name "$name" \
+			--arg new_name "$new_name" \
+			--arg path "$new_path" \
+			'(.bookmarks.named[] | select(.name == $old_name)) |= {name: $new_name, path: $path, created, accessed, access_count}' \
+			"$BOOKMARK_FILE" >"$temp_file"
+	fi
+
+	mv "$temp_file" "$BOOKMARK_FILE"
+
+	echo ""
+	echo -e "${GREEN}✓ Updated bookmark${NC}"
+	echo -e "  ${GRAY}Name:${NC} $new_name"
+	echo -e "  ${GRAY}Path:${NC} $new_path"
+	if [ -n "$new_category" ]; then
+		echo -e "  ${GRAY}Category:${NC} ${CYAN}$new_category${NC}"
+	fi
+}
+
+# Find bookmarks by pattern
+find_bookmarks() {
+	local pattern="$1"
+
+	[ ! -f "$BOOKMARK_FILE" ] && init_bookmark_file
+
+	if [ -z "$pattern" ]; then
+		echo -e "${RED}Error: Search pattern required${NC}" >&2
+		echo -e "${YELLOW}Usage: bookmark find <pattern>${NC}" >&2
+		return 1
+	fi
+
+	echo -e "${CYAN}Searching for bookmarks matching:${NC} $pattern"
+	echo ""
+
+	# Search in named bookmarks
+	local found_named=0
+	local named_results
+	# Convert pattern to lowercase for case-insensitive search
+	local pattern_lower
+	pattern_lower=$(echo "$pattern" | tr '[:upper:]' '[:lower:]')
+
+	named_results=$(jq -r --arg pattern "$pattern_lower" '
+		.bookmarks.named[] | 
+		select(
+			(.name | ascii_downcase | contains($pattern)) or 
+			(.path | ascii_downcase | contains($pattern)) or 
+			((.category // "") | ascii_downcase | contains($pattern))
+		) |
+		"\(.name)|\(.path)|\(.category // "")"
+	' "$BOOKMARK_FILE" 2>/dev/null)
+
+	if [ -n "$named_results" ]; then
+		echo -e "${BLUE}📂 Named Bookmarks${NC}"
+		while IFS='|' read -r name path category; do
+			if [ -n "$category" ]; then
+				echo -e "  ${GREEN}[$name]${NC} in ${CYAN}$category${NC}"
+			else
+				echo -e "  ${GREEN}[$name]${NC}"
+			fi
+			echo -e "    ${GRAY}$path${NC}"
+			found_named=1
+		done <<<"$named_results"
+		echo ""
+	fi
+
+	# Search in unnamed bookmarks
+	local found_unnamed=0
+	local unnamed_results
+	unnamed_results=$(jq -r --arg pattern "$pattern_lower" '
+		.bookmarks.unnamed[] | 
+		select(.path | ascii_downcase | contains($pattern)) |
+		"\(.id)|\(.path)"
+	' "$BOOKMARK_FILE" 2>/dev/null)
+
+	if [ -n "$unnamed_results" ]; then
+		echo -e "${BLUE}📌 Numbered Bookmarks${NC}"
+		while IFS='|' read -r id path; do
+			echo -e "  ${YELLOW}#$id${NC} ${GRAY}$path${NC}"
+			found_unnamed=1
+		done <<<"$unnamed_results"
+		echo ""
+	fi
+
+	if [ $found_named -eq 0 ] && [ $found_unnamed -eq 0 ]; then
+		echo -e "${YELLOW}No bookmarks found matching '$pattern'${NC}"
+		return 1
+	fi
+}
+
+# Interactive list menu
+interactive_list() {
+	# Check if we have a TTY available
+	# In WSL, /dev/tty might not exist, so we check stdout instead
+	if [ ! -t 0 ] && [ ! -t 1 ]; then
+		echo -e "${RED}Error: Interactive mode requires a terminal${NC}" >&2
+		echo -e "${YELLOW}Hint: Run without redirection or pipes${NC}" >&2
+		return 1
+	fi
+
+	[ ! -f "$BOOKMARK_FILE" ] && init_bookmark_file
+
+	# Check if we have any bookmarks
+	local named_count unnamed_count
+	named_count=$(jq '.bookmarks.named | length' "$BOOKMARK_FILE" 2>/dev/null || echo "0")
+	unnamed_count=$(jq '.bookmarks.unnamed | length' "$BOOKMARK_FILE" 2>/dev/null || echo "0")
+
+	if [ "$named_count" -eq 0 ] && [ "$unnamed_count" -eq 0 ]; then
+		echo -e "${YELLOW}No bookmarks yet. Use 'bookmark .' to save current directory.${NC}"
+		return 0
+	fi
+
+	# Build hierarchical list
+	local -a entries
+	local -a entry_ids
+	local -a entry_types
+	local idx=0
+
+	# Group named bookmarks by category
+	local categories
+	categories=$(jq -r '.bookmarks.named | group_by(.category // "Uncategorized") | .[] | .[0].category // "Uncategorized"' "$BOOKMARK_FILE" 2>/dev/null | sort -u 2>/dev/null) || categories=""
+
+	# Add category headers and bookmarks
+	if [ -n "$categories" ]; then
+		while IFS= read -r category || [ -n "$category" ]; do
+			[ -z "$category" ] && break
+			if [ "$category" != "null" ]; then
+				# Add bookmarks in this category
+				local bookmark_data
+				bookmark_data=$(jq -r --arg cat "$category" '.bookmarks.named[] | select((.category // "Uncategorized") == $cat) | "\(.name)|\(.path)|\(.created)"' "$BOOKMARK_FILE" 2>/dev/null) || bookmark_data=""
+
+				if [ -n "$bookmark_data" ]; then
+					while IFS='|' read -r name path created || [ -n "$name" ]; do
+						[ -z "$name" ] && break
+						if [ "$name" != "null" ]; then
+							entries+=("named|$name|$path|$category|$created")
+							entry_ids+=("$name")
+							entry_types+=("named")
+							((idx++)) || true
+						fi
+					done <<<"$bookmark_data"
+				fi
+			fi
+		done <<<"$categories"
+	fi
+
+	# Add unnamed bookmarks
+	if [ "$unnamed_count" -gt 0 ]; then
+		local unnamed_data
+		unnamed_data=$(jq -r '.bookmarks.unnamed[] | "\(.id)|\(.path)|\(.created)"' "$BOOKMARK_FILE" 2>/dev/null) || unnamed_data=""
+
+		if [ -n "$unnamed_data" ]; then
+			while IFS='|' read -r id path created || [ -n "$id" ]; do
+				[ -z "$id" ] && break
+				if [ "$id" != "null" ]; then
+					entries+=("unnamed|$id|$path||$created")
+					entry_ids+=("$id")
+					entry_types+=("unnamed")
+					((idx++)) || true
+				fi
+			done <<<"$unnamed_data"
+		fi
+	fi
+
+	if [ ${#entries[@]} -eq 0 ]; then
+		echo -e "${YELLOW}No bookmarks to display${NC}"
+		return 0
+	fi
+
+	local selected=0
+	local total=${#entries[@]}
+	local current_category=""
+
+	# Display function
+	show_menu() {
+		# Clear screen only if we have a TTY
+		# In WSL, clear might fail, so we use ANSI escape codes as fallback
+		if [ -t 1 ]; then
+			clear 2>/dev/null || printf '\033[2J\033[H' 2>/dev/null || true
+		fi
+		local display_count=$((named_count + unnamed_count))
+		echo "┌─────────────────────────────────────────────────────────────────┐"
+		printf "│%*s📚 Bookmarks (%d total)%*s│\n" 22 "" $display_count 22 ""
+		echo "└─────────────────────────────────────────────────────────────────┘"
+		echo ""
+
+		current_category=""
+		for i in "${!entries[@]}"; do
+			IFS='|' read -r type id_or_name path category created <<<"${entries[$i]}"
+
+			# Show category header
+			if [ "$type" = "named" ] && [ "$category" != "$current_category" ]; then
+				current_category="$category"
+				echo -e "${BLUE}📂 $category${NC}"
+			elif [ "$type" = "unnamed" ] && [ "$current_category" != "📌 Recent (Unnamed)" ]; then
+				current_category="📌 Recent (Unnamed)"
+				echo ""
+				echo -e "${BLUE}$current_category${NC}"
+			fi
+
+			# Show bookmark
+			if [ "$i" -eq "$selected" ]; then
+				echo -en "${GREEN}  ▶ "
+			else
+				echo -n "    "
+			fi
+
+			if [ "$type" = "named" ]; then
+				printf "${GREEN}[%s]${NC}" "$id_or_name"
+				# Pad to 15 chars
+				local padding=$((15 - ${#id_or_name}))
+				printf "%*s" $padding ""
+				printf "${GRAY}%s${NC}" "$path"
+				# Show date
+				local date_only="${created%%T*}"
+				printf "  %s" "$date_only"
+			else
+				printf "${YELLOW}%2s:${NC}" "$id_or_name"
+				printf " ${GRAY}%s${NC}" "$path"
+				local date_time="${created%%.*}"
+				printf "  %s" "${date_time/T/ }"
+			fi
+			echo ""
+		done
+
+		echo ""
+		echo "────────────────────────────────────────────────────────────────────"
+		echo -e "${YELLOW}j/k or ↑/↓:${NC} Navigate | ${YELLOW}Enter:${NC} Jump | ${YELLOW}d:${NC} Delete | ${YELLOW}e:${NC} Edit | ${YELLOW}h:${NC} Help | ${YELLOW}q:${NC} Quit"
+	}
+
+	# Show help
+	show_help_menu() {
+		clear
+		echo "┌─────────────────────────────────────────────────────────────────┐"
+		printf "│%*s📚 Interactive Bookmarks - Help%*s│\n" 18 "" 18 ""
+		echo "└─────────────────────────────────────────────────────────────────┘"
+		echo ""
+		echo -e "${CYAN}Navigation:${NC}"
+		echo "  j, ↓          Move down"
+		echo "  k, ↑          Move up"
+		echo ""
+		echo -e "${CYAN}Actions:${NC}"
+		echo "  Enter         Jump to selected bookmark"
+		echo "  e             Edit bookmark (name/path/category)"
+		echo "  d             Delete bookmark"
+		echo "  r             Refresh list"
+		echo "  h             Show this help"
+		echo "  q             Quit to shell"
+		echo ""
+		echo -e "${CYAN}Tips:${NC}"
+		echo "  • Numbered bookmarks can be converted to named via edit"
+		echo "  • Deleted numbered bookmarks cause re-numbering (2→1)"
+		echo "  • Press 'r' to reload after external changes"
+		echo ""
+		if [ -t 0 ]; then
+			read -rp "Press any key to continue..." -n1
+		elif [ -e /dev/tty ]; then
+			read -rp "Press any key to continue..." -n1 </dev/tty
+		else
+			read -rp "Press any key to continue..." -n1
+		fi
+	}
+
+	# Main loop
+	while true; do
+		# Show menu - ensure it always displays something
+		if ! show_menu 2>/dev/null; then
+			# If show_menu fails silently, try again without clear
+			show_menu 2>&1 || {
+				echo -e "${RED}Error: Failed to display menu${NC}" >&2
+				return 1
+			}
+		fi
+
+		# Read key with proper handling
+		# Interactive mode - wait for user input (no timeout)
+		# In WSL, prefer stdin if it's a TTY, otherwise try /dev/tty
+		key=""
+		if [ -t 0 ]; then
+			# Direct TTY - use normal read
+			if ! read -rsn1 key 2>/dev/null; then
+				continue
+			fi
+		elif [ -e /dev/tty ]; then
+			# Not a TTY but /dev/tty exists - read from /dev/tty
+			if ! read -rsn1 key </dev/tty 2>/dev/null; then
+				continue
+			fi
+		else
+			# WSL fallback - try reading from stdin anyway
+			if ! read -rsn1 key 2>/dev/null; then
+				continue
+			fi
+		fi
+
+		# Handle arrow keys (escape sequences)
+		if [[ $key == $'\x1b' ]]; then
+			rest=""
+			if [ -t 0 ]; then
+				read -rsn1 -t 0.5 rest 2>/dev/null || rest=""
+			elif [ -e /dev/tty ]; then
+				read -rsn1 -t 0.5 rest </dev/tty 2>/dev/null || rest=""
+			else
+				read -rsn1 -t 0.5 rest 2>/dev/null || rest=""
+			fi
+			if [[ $rest == '[' ]]; then
+				# Read the actual arrow key character
+				if [ -t 0 ]; then
+					read -rsn1 -t 0.5 rest2 2>/dev/null || rest2=""
+				elif [ -e /dev/tty ]; then
+					read -rsn1 -t 0.5 rest2 </dev/tty 2>/dev/null || rest2=""
+				else
+					read -rsn1 -t 0.5 rest2 2>/dev/null || rest2=""
+				fi
+				if [[ $rest2 == 'A' ]]; then
+					key="UP"
+				elif [[ $rest2 == 'B' ]]; then
+					key="DOWN"
+				elif [[ $rest2 == 'C' ]]; then
+					key="RIGHT"
+				elif [[ $rest2 == 'D' ]]; then
+					key="LEFT"
+				else
+					# Unknown escape sequence - treat as quit
+					key="q"
+				fi
+			else
+				# ESC key alone - treat as quit
+				key="q"
+			fi
+		fi
+
+		case "$key" in
+		'UP' | 'k' | 'K') # Up arrow or k
+			((selected--)) || true
+			if [ "$selected" -lt 0 ]; then
+				selected=$((total - 1))
+			fi
+			;;
+		'DOWN' | 'j' | 'J') # Down arrow or j
+			((selected++)) || true
+			if [ "$selected" -ge "$total" ]; then
+				selected=0
+			fi
+			;;
+		'') # Enter
+			local sel_type="${entry_types[$selected]}"
+			local sel_id="${entry_ids[$selected]}"
+
+			# Clear screen before exiting interactive mode
+			clear 2>/dev/null || printf '\033[2J\033[H' 2>/dev/null || true
+
+			# Jump to bookmark - get the path
+			local bookmark_path
+			bookmark_path=$(jq -r --arg id "$sel_id" '
+				(.bookmarks.unnamed[] | select(.id == (try ($id | tonumber) catch null)) | .path) //
+				(.bookmarks.named[] | select(.name == $id) | .path) //
+				empty
+			' "$BOOKMARK_FILE" 2>/dev/null)
+
+			if [ -z "$bookmark_path" ] || [ "$bookmark_path" = "null" ]; then
+				echo -e "${RED}Error: Bookmark '$sel_id' not found${NC}" >&2
+				return 1
+			fi
+
+			# Check if path exists
+			if [ ! -d "$bookmark_path" ]; then
+				echo -e "${YELLOW}Warning: Path no longer exists: $bookmark_path${NC}" >&2
+				return 1
+			fi
+
+			# Write cd command to temp file (ranger-style)
+			# Wrapper function will check this file and source it
+			# Use environment variable if set (unique temp file per invocation)
+			# Otherwise fall back to fixed path (for backward compatibility)
+			local tmp_cd_file="${MLH_BOOKMARK_CD_FILE:-/tmp/bookmark-cd-${USER:-$(id -un)}}"
+
+			# Ensure temp file directory exists and is writable
+			local tmp_dir
+			tmp_dir=$(dirname "$tmp_cd_file")
+			if [ ! -d "$tmp_dir" ] || [ ! -w "$tmp_dir" ]; then
+				echo -e "${RED}Error: Temp directory not writable: $tmp_dir${NC}" >&2
+				return 1
+			fi
+
+			# Support multiple selections in same session: append sequence number
+			# Count existing sequence files to generate next number
+			local sequence_num=1
+			while [ -f "${tmp_cd_file}.${sequence_num}" ]; do
+				sequence_num=$((sequence_num + 1))
+			done
+			local tmp_cd_file_seq="${tmp_cd_file}.${sequence_num}"
+
+			# Write cd command to temp file (use printf for better reliability)
+			# Use atomic write: write to temp file first, then move to final location
+			local tmp_write_file="${tmp_cd_file_seq}.tmp"
+			printf 'cd "%s"\n' "$bookmark_path" >"$tmp_write_file" 2>/dev/null || {
+				echo -e "${RED}Error: Failed to write temp file${NC}" >&2
+				return 1
+			}
+
+			# Atomically move to final location
+			mv "$tmp_write_file" "$tmp_cd_file_seq" 2>/dev/null || {
+				echo -e "${RED}Error: Failed to move temp file${NC}" >&2
+				rm -f "$tmp_write_file" 2>/dev/null || true
+				return 1
+			}
+
+			# Verify file was written and has content
+			if [ ! -f "$tmp_cd_file_seq" ] || [ ! -s "$tmp_cd_file_seq" ]; then
+				echo -e "${RED}Error: Temp file not created or empty${NC}" >&2
+				return 1
+			fi
+
+			# Ensure file is readable
+			if [ ! -r "$tmp_cd_file_seq" ]; then
+				echo -e "${RED}Error: Temp file not readable${NC}" >&2
+				return 1
+			fi
+
+			# Sync to ensure file is written to disk
+			sync 2>/dev/null || true
+
+			echo -e "${GREEN}→${NC} $bookmark_path" >&2
+
+			# Exit interactive mode after selection
+			# Each invocation handles one selection
+			return 0
+			;;
+		'd' | 'D') # Delete
+			local sel_type="${entry_types[$selected]}"
+			local sel_id="${entry_ids[$selected]}"
+			echo ""
+			if [ -t 0 ]; then
+				read -rp "Delete bookmark [$sel_id]? [y/N]: " confirm
+			elif [ -e /dev/tty ]; then
+				read -rp "Delete bookmark [$sel_id]? [y/N]: " confirm </dev/tty
+			else
+				read -rp "Delete bookmark [$sel_id]? [y/N]: " confirm
+			fi
+			if [[ "$confirm" =~ ^[Yy]$ ]]; then
+				remove_bookmark "$sel_id"
+				echo -e "${GREEN}✓ Deleted${NC}"
+				sleep 1
+				# Reload
+				interactive_list
+				return $?
+			fi
+			;;
+		'e' | 'E') # Edit
+			local sel_type="${entry_types[$selected]}"
+			local sel_id="${entry_ids[$selected]}"
+
+			if [ "$sel_type" = "unnamed" ]; then
+				# Convert to named
+				IFS='|' read -r type id path _ created <<<"${entries[$selected]}"
+				echo ""
+				if [ -t 0 ]; then
+					read -rp "Enter name for bookmark #$sel_id: " new_name
+				elif [ -e /dev/tty ]; then
+					read -rp "Enter name for bookmark #$sel_id: " new_name </dev/tty
+				else
+					read -rp "Enter name for bookmark #$sel_id: " new_name
+				fi
+				if [ -n "$new_name" ] && validate_name "$new_name"; then
+					if [ -t 0 ]; then
+						read -rp "Category (leave empty for none): " category
+					elif [ -e /dev/tty ]; then
+						read -rp "Category (leave empty for none): " category </dev/tty
+					else
+						read -rp "Category (leave empty for none): " category
+					fi
+					rename_bookmark "$sel_id" "$new_name" "$category"
+					echo -e "${GREEN}✓ Converted to named bookmark${NC}"
+					sleep 1
+					interactive_list
+					return $?
+				fi
+			else
+				edit_bookmark "$sel_id"
+				interactive_list
+				return $?
+			fi
+			;;
+		'r' | 'R') # Refresh
+			interactive_list
+			return $?
+			;;
+		'h' | 'H') # Help
+			show_help_menu
+			;;
+		'q' | 'Q' | $'\x03') # Quit or Ctrl+C
+			clear
+			return 0
+			;;
+		esac
+	done
+}
+
+# List all bookmarks
+list_bookmarks() {
+	local filter_category="${1:-}"
+	local limit=""
+	local non_interactive=false
+
+	# Check for interactive flag (explicit)
+	if [ "$filter_category" = "-i" ] || [ "$filter_category" = "--interactive" ]; then
+		interactive_list
+		local exit_code=$?
+		return $exit_code
+	fi
+
+	# Check for non-interactive flag
+	if [ "$filter_category" = "-n" ] || [ "$filter_category" = "--non-interactive" ]; then
+		non_interactive=true
+		filter_category="${2:-}"
+	fi
+
+	# Check if argument is a number (limit) or string (category filter)
+	if [ -n "$filter_category" ] && [[ "$filter_category" =~ ^[0-9]+$ ]]; then
+		limit="$filter_category"
+		filter_category=""
+	fi
+
+	# NEW: Default to interactive mode when no arguments and no explicit -n flag
+	if [ "$non_interactive" = false ] && [ -z "$filter_category" ] && [ -z "$limit" ]; then
+		interactive_list
+		local exit_code=$?
+		return $exit_code
+	fi
+
+	[ ! -f "$BOOKMARK_FILE" ] && init_bookmark_file
+
+	echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+	if [ -n "$filter_category" ]; then
+		echo -e "${CYAN}📚 Bookmarks in category: ${YELLOW}$filter_category${NC}"
+	else
+		echo -e "${CYAN}📚 Bookmarks${NC}"
+	fi
+	echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+	echo ""
+
+	# Named bookmarks - grouped by category
+	local named_count
+	if [ -n "$filter_category" ]; then
+		named_count=$(jq --arg cat "$filter_category" '[.bookmarks.named[] | select(.category == $cat or (.category // "" | startswith($cat + "/")))] | length' "$BOOKMARK_FILE" 2>/dev/null)
+	else
+		named_count=$(jq '.bookmarks.named | length' "$BOOKMARK_FILE" 2>/dev/null)
+	fi
+
+	if [ "$named_count" -gt 0 ]; then
+		echo -e "${BLUE}📂 Named Bookmarks${NC}"
+
+		# Group bookmarks by category and display hierarchically
+		local categories
+		if [ -n "$filter_category" ]; then
+			categories=$(jq -r --arg cat "$filter_category" '[.bookmarks.named[] | select(.category == $cat or (.category // "" | startswith($cat + "/")))] | group_by(.category // "Uncategorized") | .[] | .[0].category // "Uncategorized"' "$BOOKMARK_FILE" 2>/dev/null | sort -u)
+		else
+			categories=$(jq -r '.bookmarks.named | group_by(.category // "Uncategorized") | .[] | .[0].category // "Uncategorized"' "$BOOKMARK_FILE" 2>/dev/null | sort)
+		fi
+
+		# Display categories hierarchically
+		local prev_parts
+		prev_parts=()
+		while IFS= read -r category; do
+			if [ -n "$category" ] && [ "$category" != "null" ]; then
+				# Handle Uncategorized specially
+				if [ "$category" = "Uncategorized" ]; then
+					echo -e "  ${GRAY}📁 Uncategorized${NC}"
+					# Show bookmarks
+					jq -r '.bookmarks.named[] | select((.category // "") == "") |
+						   "      [\(.name)]  \(.path)  \(.created | split("T")[0])"' \
+						"$BOOKMARK_FILE" 2>/dev/null | while IFS= read -r line; do
+						local path
+						path=$(echo "$line" | awk '{print $2}')
+						if [ -d "$path" ]; then
+							echo -e "$line"
+						else
+							echo -e "$line ${YELLOW}⚠${NC}"
+						fi
+					done
+					prev_parts=()
+					continue
+				fi
+
+				# Split category by /
+				IFS='/' read -ra parts <<<"$category"
+
+				# Print each level of hierarchy
+				for i in "${!parts[@]}"; do
+					# Check if this level is new compared to previous category
+					if [ "$i" -ge ${#prev_parts[@]} ] || [ "${parts[$i]}" != "${prev_parts[$i]}" ]; then
+						local indent=""
+						for ((j = 0; j < i; j++)); do
+							indent="  $indent"
+						done
+						echo -e "  $indent${GREEN}📂 ${parts[$i]}${NC}"
+					fi
+				done
+
+				# Show bookmarks in this exact category
+				local bookmark_indent=""
+				for ((j = 0; j < ${#parts[@]}; j++)); do
+					bookmark_indent="  $bookmark_indent"
+				done
+
+				jq -r --arg cat "$category" '.bookmarks.named[] | select(.category == $cat) |
+				   "[\(.name)]  \(.path)  \(.created | split("T")[0])"' \
+					"$BOOKMARK_FILE" 2>/dev/null | while IFS= read -r line; do
+					local path
+					path=$(echo "$line" | awk '{print $2}')
+					if [ -d "$path" ]; then
+						echo -e "  $bookmark_indent  $line"
+					else
+						echo -e "  $bookmark_indent  $line ${YELLOW}⚠${NC}"
+					fi
+				done
+
+				# Update prev_parts for next iteration
+				prev_parts=("${parts[@]}")
+			fi
+		done <<<"$categories"
+		echo ""
+	fi
+
+	# Unnamed bookmarks
+	local unnamed_count
+	unnamed_count=$(jq '.bookmarks.unnamed | length' "$BOOKMARK_FILE" 2>/dev/null)
+
+	if [ "$unnamed_count" -gt 0 ]; then
+		echo -e "${BLUE}📌 Recent (Unnamed)${NC}"
+
+		local query='.bookmarks.unnamed[]'
+		if [ -n "$limit" ] && [[ "$limit" =~ ^[0-9]+$ ]]; then
+			query=".bookmarks.unnamed[0:$limit][]"
+		fi
+
+		jq -r "$query |
+               \"  \(.id): \(.path)  \(.created | split(\"T\")[0])\"" \
+			"$BOOKMARK_FILE" 2>/dev/null | while IFS= read -r line; do
+			# Check if path exists
+			local path
+			path=$(echo "$line" | awk '{print $2}')
+			if [ -d "$path" ]; then
+				echo -e "$line"
+			else
+				echo -e "$line ${YELLOW}⚠${NC}"
+			fi
+		done
+		echo ""
+	fi
+
+	if [ "$named_count" -eq 0 ] && [ "$unnamed_count" -eq 0 ]; then
+		echo -e "${GRAY}  No bookmarks yet. Use 'bookmark .' to save current directory.${NC}"
+		echo ""
+	fi
+
+	echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+}
+
+# Show help
+show_help() {
+	echo -e "${CYAN}bookmark${NC} - Quick directory bookmark system (v$VERSION)"
+	echo ""
+
+	# Show shortcut info if alias is configured
+	if [ -n "$BOOKMARK_ALIAS" ]; then
+		echo -e "${GREEN}Shortcut:${NC} You can use '${CYAN}${BOOKMARK_ALIAS}${NC}' instead of 'bookmark'"
+		echo ""
+	fi
+
+	echo "Usage:"
+	cat <<EOF
+  $COMMAND_NAME .                    Save current directory as numbered bookmark
+  $COMMAND_NAME <number>             Jump to numbered bookmark
+  $COMMAND_NAME <name>               Jump to named bookmark
+  $COMMAND_NAME --help               Show this help
+EOF
+	echo ""
+	echo "Commands:"
+	cat <<EOF
+  Save:
+    $COMMAND_NAME .                    Save current directory (becomes bookmark #1)
+    $COMMAND_NAME . -n <name>          Save with name
+    $COMMAND_NAME . -n <name> in <cat> Save with category
+    $COMMAND_NAME <number> -n <name>   Rename numbered bookmark to name
+
+  Navigate:
+    $COMMAND_NAME <number>             Jump to numbered bookmark (1-10)
+    $COMMAND_NAME <name>               Jump to named bookmark
+
+  List:
+    $COMMAND_NAME list                 Interactive menu (default, arrow keys)
+    $COMMAND_NAME list -n              Non-interactive list (simple output)
+    $COMMAND_NAME list <category>      Interactive list filtered by category
+    $COMMAND_NAME list -n <category>   Non-interactive list for category
+    $COMMAND_NAME list <N>             List last N unnamed bookmarks
+
+  Manage:
+    $COMMAND_NAME mv <name> to <cat>   Move bookmark to category
+    $COMMAND_NAME edit <name>          Edit bookmark (name/path/category)
+    $COMMAND_NAME rm <name|number>     Remove a bookmark
+    $COMMAND_NAME clear                Clear all numbered bookmarks
+    $COMMAND_NAME find <pattern>       Search bookmarks by pattern
+EOF
+	echo ""
+	echo "Features:"
+	cat <<EOF
+  • Stack-based numbered bookmarks (max 10, LIFO)
+  • Named bookmarks with categories
+  • Interactive menu with arrow key navigation
+  • Hierarchical categories (e.g., projects/linux/tools)
+  • Path validation with warnings (⚠ symbol)
+  • Command name conflict detection
+  • JSON storage: $BOOKMARK_FILE
+EOF
+	echo ""
+	echo "Notes:"
+	cat <<EOF
+  • Symbols: ⚠ (path missing), → (navigating), ✓ (saved)
+  • Interactive mode: Use ↑/↓ or j/k to navigate, Enter to jump, e to edit, d to delete, h for help
+  • Numbered bookmarks are LIFO (last added becomes #1)
+  • Category names support slashes for hierarchy (e.g., work/projects/java)
+  • Configure custom alias in: ~/.mylinuxhelper/mlh.conf (BOOKMARK_ALIAS=bm)
+EOF
+	echo ""
+	echo "Examples:"
+	echo -e "  ${GREEN}# Quick numbered bookmarks${NC}"
+	cat <<EOF
+  $COMMAND_NAME .                    # Save current dir (becomes #1)
+  cd /some/other/path
+  $COMMAND_NAME .                    # Save another (becomes #1, previous → #2)
+  $COMMAND_NAME 1                    # Jump to most recent
+  $COMMAND_NAME 2                    # Jump to second most recent
+EOF
+	echo ""
+	echo -e "  ${GREEN}# Named bookmarks${NC}"
+	cat <<EOF
+  $COMMAND_NAME . -n myproject       # Save current dir as 'myproject'
+  $COMMAND_NAME myproject            # Jump to myproject
+  $COMMAND_NAME 1 -n webapp          # Rename bookmark #1 to 'webapp'
+EOF
+	echo ""
+	echo -e "  ${GREEN}# Categorized bookmarks${NC}"
+	cat <<EOF
+  $COMMAND_NAME . -n mlh in projects/linux    # Save with category
+  $COMMAND_NAME . -n api in projects/java     # Another category
+  $COMMAND_NAME mv mlh to tools               # Move to different category
+EOF
+	echo ""
+	echo -e "  ${GREEN}# List and navigate${NC}"
+	cat <<EOF
+  $COMMAND_NAME list                 # Interactive menu (default)
+  $COMMAND_NAME list -n              # Non-interactive list
+  $COMMAND_NAME list projects        # Interactive, filtered by category
+  $COMMAND_NAME list -n projects     # Non-interactive, filtered
+  $COMMAND_NAME list 5               # Show last 5 numbered bookmarks
+EOF
+	echo ""
+	echo -e "  ${GREEN}# Edit and search${NC}"
+	cat <<EOF
+  $COMMAND_NAME edit myproject       # Edit bookmark interactively
+  $COMMAND_NAME find proj            # Search bookmarks by pattern
+  $COMMAND_NAME find /home           # Search by path
+  $COMMAND_NAME rm myproject         # Remove named bookmark
+  $COMMAND_NAME rm 1                 # Remove numbered bookmark
+  $COMMAND_NAME clear                # Clear all numbered bookmarks (asks confirmation)
+EOF
+}
+
+# ============================================================================
+# MAIN LOGIC
+# ============================================================================
+
+main() {
+	# Parse arguments
+	if [ $# -eq 0 ]; then
+		show_help
+		exit 0
+	fi
+
+	case "$1" in
+	--help | -h)
+		show_help
+		exit 0
+		;;
+	--version | -v)
+		echo "mlh-bookmark.sh v$VERSION"
+		exit 0
+		;;
+	list)
+		# Check dependencies for actual operations
+		check_jq
+		shift
+		# Pass all remaining arguments to list_bookmarks
+		list_bookmarks "$@"
+		exit 0
+		;;
+	mv)
+		# bookmark mv <name> to <category>
+		check_jq
+		if [ $# -lt 4 ] || [ "$3" != "to" ]; then
+			echo -e "${RED}Error: Invalid syntax${NC}" >&2
+			echo -e "${YELLOW}Usage: bookmark mv <name> to <category>${NC}" >&2
+			exit 1
+		fi
+		move_bookmark "$2" "$4"
+		exit 0
+		;;
+	rm)
+		# bookmark rm <name|number>
+		check_jq
+		if [ $# -lt 2 ]; then
+			echo -e "${RED}Error: Missing bookmark name or number${NC}" >&2
+			echo -e "${YELLOW}Usage: bookmark rm <name|number>${NC}" >&2
+			exit 1
+		fi
+		remove_bookmark "$2"
+		exit 0
+		;;
+	clear)
+		# bookmark clear - clear all unnamed bookmarks
+		check_jq
+		clear_unnamed_bookmarks
+		exit 0
+		;;
+	edit)
+		# bookmark edit <name>
+		check_jq
+		if [ $# -lt 2 ]; then
+			echo -e "${RED}Error: Missing bookmark name${NC}" >&2
+			echo -e "${YELLOW}Usage: bookmark edit <name>${NC}" >&2
+			exit 1
+		fi
+		edit_bookmark "$2"
+		exit 0
+		;;
+	find)
+		# bookmark find <pattern>
+		check_jq
+		if [ $# -lt 2 ]; then
+			echo -e "${RED}Error: Missing search pattern${NC}" >&2
+			echo -e "${YELLOW}Usage: bookmark find <pattern>${NC}" >&2
+			exit 1
+		fi
+		find_bookmarks "$2"
+		exit 0
+		;;
+	.)
+		# Check dependencies
+		check_jq
+
+		# Save current directory
+		local current_dir
+		current_dir=$(pwd)
+
+		# Check for -n flag (name)
+		if [ $# -ge 3 ] && [ "$2" = "-n" ]; then
+			local name="$3"
+			local category=""
+
+			# Check for category (in <category>)
+			if [ $# -ge 5 ] && [ "$4" = "in" ]; then
+				category="$5"
+			fi
+
+			save_named_bookmark "$name" "$current_dir" "$category"
+		else
+			save_unnamed_bookmark "$current_dir"
+		fi
+		;;
+	[0-9]*)
+		# Check dependencies
+		check_jq
+
+		# Jump to numbered bookmark OR rename it
+		local bookmark_id="$1"
+
+		if [ $# -ge 3 ] && [ "$2" = "-n" ]; then
+			# Rename bookmark
+			local name="$3"
+			local category=""
+
+			if [ $# -ge 5 ] && [ "$4" = "in" ]; then
+				category="$5"
+			fi
+
+			rename_bookmark "$bookmark_id" "$name" "$category"
+		else
+			# Jump to bookmark
+			jump_to_bookmark "$bookmark_id"
+		fi
+		;;
+	*)
+		# Check dependencies
+		check_jq
+
+		# Jump to named bookmark or show error
+		if [ ! -f "$BOOKMARK_FILE" ]; then
+			echo -e "${RED}Error: No bookmarks found${NC}" >&2
+			echo -e "${YELLOW}Create your first bookmark with: bookmark .${NC}" >&2
+			exit 1
+		fi
+
+		jump_to_bookmark "$1"
+		;;
+	esac
+}
+
+# Run main function
+main "$@"
diff --git a/plugins/mlh-docker.sh b/plugins/mlh-docker.sh
old mode 100644
new mode 100755
index cd66e11..94f0d5b
--- a/plugins/mlh-docker.sh
+++ b/plugins/mlh-docker.sh
@@ -49,12 +49,7 @@ die() {
 	exit 1
 }
 
-# Check if docker is available
-if ! command -v docker >/dev/null 2>&1; then
-	die "Docker is not installed or not in PATH"
-fi
-
-# Parse command
+# Parse command (check for help BEFORE checking docker availability)
 if [ $# -eq 0 ]; then
 	print_help
 	exit 1
@@ -69,6 +64,11 @@ case "$COMMAND" in
 	exit 0
 	;;
 in)
+	# Check if docker is available (only for actual commands)
+	if ! command -v docker >/dev/null 2>&1; then
+		die "Docker is not installed or not in PATH"
+	fi
+
 	# Enter container by pattern
 	if [ $# -eq 0 ]; then
 		die "Missing container name pattern. Usage: mlh docker in <pattern>"
diff --git a/plugins/mlh-history.sh b/plugins/mlh-history.sh
old mode 100644
new mode 100755
index 936ef19..7b0e5f2
--- a/plugins/mlh-history.sh
+++ b/plugins/mlh-history.sh
@@ -33,8 +33,8 @@ resolve_script_dir() {
 	cd -P "$(dirname "$source")" && pwd
 }
 
+# shellcheck disable=SC2034
 SCRIPT_DIR="$(resolve_script_dir)"
-ROOT_DIR="$(dirname "$SCRIPT_DIR")"
 CONFIG_DIR="${HOME}/.mylinuxhelper"
 HISTORY_CONFIG="${CONFIG_DIR}/.history-config"
 BASHRC="${HOME}/.bashrc"
@@ -147,9 +147,11 @@ enable_date_tracking() {
 	fi
 
 	# Add to bashrc
-	echo "" >>"$BASHRC"
-	echo "# MyLinuxHelper - Enable command history timestamps" >>"$BASHRC"
-	echo "$histtime_export" >>"$BASHRC"
+	{
+		echo ""
+		echo "# MyLinuxHelper - Enable command history timestamps"
+		echo "$histtime_export"
+	} >>"$BASHRC"
 
 	echo -e "${GREEN}✓ Date tracking enabled in ~/.bashrc${NC}"
 
@@ -388,7 +390,8 @@ show_history_simple() {
 	fi
 
 	# Create temp file for history data
-	local temp_file=$(mktemp)
+	local temp_file
+	temp_file=$(mktemp)
 	parse_history_with_timestamps >"$temp_file" || {
 		echo -e "${RED}Error: Failed to parse history${NC}"
 		rm -f "$temp_file"
@@ -412,7 +415,8 @@ show_history_simple() {
 	# Read and display
 	while IFS='|' read -r num ts cmd; do
 		if [ -n "$ts" ] && [ "$has_dates" = true ]; then
-			local date=$(timestamp_to_date "$ts")
+			local date
+			date=$(timestamp_to_date "$ts")
 			printf "%-6s  %-19s  %s\n" "$num" "$date" "$cmd"
 		else
 			printf "%-6s  %s\n" "$num" "$cmd"
@@ -442,7 +446,8 @@ show_history_detailed() {
 	fi
 
 	# Create temp file for history data
-	local temp_file=$(mktemp)
+	local temp_file
+	temp_file=$(mktemp)
 	parse_history_with_timestamps >"$temp_file" || {
 		echo -e "${RED}Error: Failed to parse history${NC}"
 		rm -f "$temp_file"
@@ -467,7 +472,8 @@ show_history_detailed() {
 	while IFS='|' read -r num ts cmd; do
 		echo -e "${YELLOW}#${num}${NC}"
 		if [ -n "$ts" ] && [ "$has_dates" = true ]; then
-			local date=$(timestamp_to_date "$ts")
+			local date
+			date=$(timestamp_to_date "$ts")
 			echo -e "  ${GREEN}Date:${NC} $date"
 		fi
 		echo -e "  ${BLUE}Command:${NC} $cmd"
@@ -512,7 +518,8 @@ find_in_history() {
 	fi
 	echo ""
 
-	local temp_file=$(mktemp)
+	local temp_file
+	temp_file=$(mktemp)
 	parse_history_with_timestamps >"$temp_file" || {
 		echo -e "${RED}Error: Failed to parse history${NC}"
 		rm -f "$temp_file"
@@ -520,7 +527,8 @@ find_in_history() {
 	}
 
 	# First pass: collect matching commands
-	local matches_file=$(mktemp)
+	local matches_file
+	matches_file=$(mktemp)
 	while IFS='|' read -r num ts cmd; do
 		if [[ "$cmd" == *"$pattern"* ]]; then
 			echo "${num}|${ts}|${cmd}" >>"$matches_file"
@@ -552,7 +560,8 @@ find_in_history() {
 	while IFS='|' read -r num ts cmd; do
 		shown=$((shown + 1))
 		if [ -n "$ts" ] && [ "$has_dates" = true ]; then
-			local date=$(timestamp_to_date "$ts")
+			local date
+			date=$(timestamp_to_date "$ts")
 			echo -e "${GREEN}#${num}${NC} ${YELLOW}[${date}]${NC}"
 		else
 			echo -e "${GREEN}#${num}${NC}"
@@ -601,7 +610,8 @@ goto_command() {
 		end_num=$((start_num + context - 1))
 	fi
 
-	local temp_file=$(mktemp)
+	local temp_file
+	temp_file=$(mktemp)
 	parse_history_with_timestamps >"$temp_file" || {
 		echo -e "${RED}Error: Failed to parse history${NC}"
 		rm -f "$temp_file"
@@ -621,14 +631,16 @@ goto_command() {
 			if [ "$num" = "$target_num" ]; then
 				found=true
 				if [ -n "$ts" ] && [ "$has_dates" = true ]; then
-					local date=$(timestamp_to_date "$ts")
+					local date
+					date=$(timestamp_to_date "$ts")
 					echo -e "${GREEN}► ${num}${NC}  ${YELLOW}${date}${NC}  ${GREEN}${cmd}${NC}"
 				else
 					echo -e "${GREEN}► ${num}${NC}  ${GREEN}${cmd}${NC}"
 				fi
 			else
 				if [ -n "$ts" ] && [ "$has_dates" = true ]; then
-					local date=$(timestamp_to_date "$ts")
+					local date
+					date=$(timestamp_to_date "$ts")
 					printf "  %-6s  %-19s  %s\n" "$num" "$date" "$cmd"
 				else
 					printf "  %-6s  %s\n" "$num" "$cmd"
@@ -687,8 +699,10 @@ filter_by_date() {
 		start_ts=$((end_ts - relative_seconds))
 
 		# Format for display
-		local start_display=$(timestamp_to_date "$start_ts")
-		local end_display=$(timestamp_to_date "$end_ts")
+		local start_display
+		start_display=$(timestamp_to_date "$start_ts")
+		local end_display
+		end_display=$(timestamp_to_date "$end_ts")
 
 		if [ -n "$before_offset" ]; then
 			echo -e "${CYAN}Commands: ${YELLOW}${date_filter}${CYAN} starting from ${YELLOW}${before_offset}${CYAN} ago${NC}"
@@ -727,7 +741,8 @@ filter_by_date() {
 	fi
 
 	# Parse and filter history
-	local temp_file=$(mktemp)
+	local temp_file
+	temp_file=$(mktemp)
 	parse_history_with_timestamps >"$temp_file" || {
 		echo -e "${RED}Error: Failed to parse history${NC}"
 		rm -f "$temp_file"
@@ -753,7 +768,8 @@ filter_by_date() {
 
 			if [ "$ts" -ge "$start_ts" ] && [ "$ts" -le "$end_ts" ]; then
 				found=$((found + 1))
-				local date=$(timestamp_to_date "$ts")
+				local date
+				date=$(timestamp_to_date "$ts")
 				echo -e "${GREEN}#${num}${NC} ${YELLOW}[${date}]${NC}"
 				echo -e "  ${cmd}"
 				echo ""
@@ -768,7 +784,8 @@ filter_by_date() {
 
 		# Provide helpful debugging information
 		if [ "$total_with_ts" -gt 0 ] && [ "$newest_ts" -gt 0 ]; then
-			local newest_date=$(timestamp_to_date "$newest_ts")
+			local newest_date
+			newest_date=$(timestamp_to_date "$newest_ts")
 			local time_diff=$((current_ts - newest_ts))
 			local time_diff_mins=$((time_diff / 60))
 			local time_diff_hours=$((time_diff / 3600))
diff --git a/plugins/mlh-json.sh b/plugins/mlh-json.sh
old mode 100644
new mode 100755
diff --git a/plugins/mlh-version.sh b/plugins/mlh-version.sh
old mode 100644
new mode 100755
index d2ac8fa..82c5a8e
--- a/plugins/mlh-version.sh
+++ b/plugins/mlh-version.sh
@@ -14,8 +14,10 @@
 
 set -euo pipefail
 
-readonly VERSION="1.4.1"
-readonly VERSION_DATE="20.10.2025"
+readonly VERSION="1.5.0"
+# shellcheck disable=SC2034
+readonly VERSION_DATE="08.11.2025"
+# shellcheck disable=SC2034
 readonly FIRST_RELEASE_DATE="11.10.2025"
 readonly GITHUB_REPO="melihcelenk/MyLinuxHelper"
 readonly INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${GITHUB_REPO}/main/get-mlh.sh"
@@ -217,8 +219,13 @@ update_to_latest() {
 	if bash "${temp_script}"; then
 		rm -f "${temp_script}"
 		echo ""
-		echo "Update completed successfully!"
-		echo "Please restart your shell or run: source ~/.bashrc"
+		echo "✅ Update completed successfully!"
+		echo ""
+		echo "Reloading shell to apply changes..."
+		echo ""
+
+		# Reload the shell to apply new functions and updates
+		exec bash -l
 	else
 		rm -f "${temp_script}"
 		echo "Error: Update failed." >&2
diff --git a/plugins/mlh.sh b/plugins/mlh.sh
old mode 100644
new mode 100755
index 50d025c..f4d16a8
--- a/plugins/mlh.sh
+++ b/plugins/mlh.sh
@@ -46,6 +46,7 @@ Usage:
   mlh update                   Update to latest version
 
 Categories:
+  bookmark  Quick directory bookmarks (see: mlh bookmark --help)
   docker    Docker shortcuts (see: mlh docker --help)
   json      JSON operations (see: mlh json --help)
   history   Enhanced history formatting (see: mlh history --help)
@@ -55,6 +56,8 @@ Examples:
   mlh --version                # Show current version
   mlh about                    # Show project information and credits
   mlh update                   # Update to latest version
+  mlh bookmark .               # Save current directory as bookmark
+  mlh bookmark list            # List all bookmarks
   mlh docker in mycontainer    # Enter a running container by name pattern
   mlh history 10               # Show last 10 commands (numbered)
 EOF
@@ -116,56 +119,61 @@ show_interactive_menu() {
 MyLinuxHelper - Available Commands
 ===================================
 
-1. linux <name>              - Create and manage Linux containers
-2. search <pattern>          - Fast file search in directories
-3. i <package>               - Install packages (auto-detects package manager)
-4. JSON operations           - Validate and search JSON files
-5. ll [path]                 - Enhanced directory listing (ls -la)
-6. mlh docker in <pattern>   - Enter running Docker container
-7. mlh history [count]       - Enhanced command history with dates
-8. About MyLinuxHelper       - Project information and credits
-9. App Settings & Updates    - Version and update settings
+1. bookmark <name>           - Quick directory bookmarks
+2. linux <name>              - Create and manage Linux containers
+3. search <pattern>          - Fast file search in directories
+4. i <package>               - Install packages (auto-detects package manager)
+5. JSON operations           - Validate and search JSON files
+6. ll [path]                 - Enhanced directory listing (ls -la)
+7. mlh docker in <pattern>   - Enter running Docker container
+8. mlh history [count]       - Enhanced command history with dates
+9. About MyLinuxHelper       - Project information and credits
+0. App Settings & Updates    - Version and update settings
 
 Enter command number to see usage, or 'q' to quit.
 EOF
 
-		read -rp "Select [1-9, q]: " SELECTION
+		read -rp "Select [0-9, q]: " SELECTION
 
 		echo ""
 
 		case "$SELECTION" in
 		1)
-			"$SCRIPT_DIR/linux.sh" --help
+			"$SCRIPT_DIR/mlh-bookmark.sh" --help
 			exit 0
 			;;
 		2)
-			"$SCRIPT_DIR/search.sh" --help
+			"$SCRIPT_DIR/linux.sh" --help
 			exit 0
 			;;
 		3)
-			"$SCRIPT_DIR/../install.sh" --help
+			"$SCRIPT_DIR/search.sh" --help
 			exit 0
 			;;
 		4)
-			"$SCRIPT_DIR/mlh-json.sh" --help
+			"$SCRIPT_DIR/../install.sh" --help
 			exit 0
 			;;
 		5)
-			"$SCRIPT_DIR/ll.sh" --help
+			"$SCRIPT_DIR/mlh-json.sh" --help
 			exit 0
 			;;
 		6)
-			"$SCRIPT_DIR/mlh-docker.sh" --help
+			"$SCRIPT_DIR/ll.sh" --help
 			exit 0
 			;;
 		7)
-			"$SCRIPT_DIR/mlh-history.sh" --help
+			"$SCRIPT_DIR/mlh-docker.sh" --help
 			exit 0
 			;;
 		8)
-			show_about
+			"$SCRIPT_DIR/mlh-history.sh" --help
+			exit 0
 			;;
 		9)
+			show_about
+			;;
+		0)
 			show_app_settings_menu
 			;;
 		q | Q)
@@ -218,6 +226,10 @@ history)
 	# Delegate to mlh-history.sh
 	exec "$SCRIPT_DIR/mlh-history.sh" "$@"
 	;;
+bookmark)
+	# Delegate to mlh-bookmark.sh
+	exec "$SCRIPT_DIR/mlh-bookmark.sh" "$@"
+	;;
 *)
 	echo "Error: Unknown category '$CATEGORY'" >&2
 	echo "Run 'mlh --help' for available categories." >&2
diff --git a/plugins/search.sh b/plugins/search.sh
old mode 100644
new mode 100755
diff --git a/setup.sh b/setup.sh
old mode 100644
new mode 100755
index 036596d..0bc5dba
--- a/setup.sh
+++ b/setup.sh
@@ -9,9 +9,27 @@ PLUGINS_DIR="$ROOT_DIR/plugins"
 LOCAL_BIN="$HOME/.local/bin"
 BASHRC="$HOME/.bashrc"
 PROFILE="$HOME/.profile"
+MLH_CONFIG_DIR="$HOME/.mylinuxhelper"
+MLH_CONFIG_FILE="$MLH_CONFIG_DIR/mlh.conf"
+
+# Colors for output
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Track if bashrc was updated (for notification at end)
+BASHRC_UPDATED=0
+
+# Load MLH configuration
+BOOKMARK_ALIAS=""
+if [ -f "$MLH_CONFIG_FILE" ]; then
+	# shellcheck source=/dev/null
+	source "$MLH_CONFIG_FILE" 2>/dev/null || true
+fi
 
 # 1) Ensure ~/.local/bin exists and added to PATH for future shells
 mkdir -p "$LOCAL_BIN"
+# shellcheck disable=SC2016
 ADD_LINE='export PATH="$HOME/.local/bin:$PATH"'
 grep -Fq "$ADD_LINE" "$BASHRC" 2>/dev/null || {
 	echo "$ADD_LINE" >>"$BASHRC"
@@ -39,6 +57,152 @@ mlh() {
 }
 EOF
 	echo "Added mlh wrapper function to ~/.bashrc"
+	BASHRC_UPDATED=1
+fi
+
+# 1c) Add bookmark wrapper function for cd functionality
+BOOKMARK_WRAPPER_MARKER="# MyLinuxHelper - bookmark wrapper function"
+if ! grep -Fq "$BOOKMARK_WRAPPER_MARKER" "$BASHRC" 2>/dev/null; then
+	cat >>"$BASHRC" <<'EOF'
+
+# MyLinuxHelper - bookmark wrapper function
+# This wrapper enables 'cd' functionality by evaluating the output
+bookmark() {
+  local cmd="$1"
+
+  # Special handling for interactive list - use unique temp file per invocation
+  # PR branch: bookmark list defaults to interactive mode (no -i flag needed)
+  # Handle both explicit -i flag and default interactive mode
+  if [ "$cmd" = "list" ]; then
+    # Check if this is non-interactive mode (explicit -n flag)
+    if [ "$2" = "-n" ] || [ "$2" = "--non-interactive" ]; then
+      # Non-interactive mode - just pass through
+      command bookmark "$@"
+      return $?
+    fi
+    
+    # Check if second argument is a number (limit) - this is also non-interactive
+    # shellcheck disable=SC2076
+    if [ -n "$2" ] && [[ "$2" =~ ^[0-9]+$ ]]; then
+      # Number limit - non-interactive mode, pass through
+      command bookmark "$@"
+      return $?
+    fi
+    
+    # All other cases: default interactive mode, explicit -i flag, or category filter
+    # All of these should use interactive mode with cd support
+    # Use unique temp file per invocation (more reliable than fixed path)
+    # This ensures no race conditions between multiple invocations
+    local tmp_cd_file
+    local user_name
+    user_name="${USER:-$(id -un)}"
+    tmp_cd_file=$(mktemp "/tmp/bookmark-cd-${user_name}-XXXXXX" 2>/dev/null) || {
+      # Fallback to fixed path if mktemp fails
+      tmp_cd_file="/tmp/bookmark-cd-${user_name}"
+      rm -f "$tmp_cd_file"
+    }
+    
+    # Export temp file path to plugin via environment variable
+    # Plugin will check this and use it if available
+    export MLH_BOOKMARK_CD_FILE="$tmp_cd_file"
+
+    # Clean up any leftover sequence files from previous sessions
+    # This is important for Ctrl+C interrupted sessions
+    rm -f "${tmp_cd_file}".* 2>/dev/null || true
+
+    # Run interactive mode - each invocation works independently
+    # User selects one bookmark, interactive mode exits, cd happens
+    command bookmark "$@"
+    local exit_code=$?
+
+    # Wait a bit for plugin to finish writing
+    sleep 0.1
+
+    # Source the sequence file (plugin writes .1 for first selection)
+    if [ -f "${tmp_cd_file}.1" ]; then
+      source "${tmp_cd_file}.1" 2>/dev/null || true
+    fi
+    
+    # Clean up all temp files (base + sequences) and unset env var
+    rm -f "$tmp_cd_file" "${tmp_cd_file}".* 2>/dev/null || true
+    unset MLH_BOOKMARK_CD_FILE
+
+    return $exit_code
+  fi
+
+  # For jumping to bookmarks (number or name), eval the output to enable cd
+  # shellcheck disable=SC2076
+  if [[ "$cmd" =~ ^[0-9]+$ ]] || ( [ -n "$cmd" ] && [ "$cmd" != "." ] && [ "$cmd" != "list" ] && [ "$cmd" != "mv" ] && [ "$cmd" != "--help" ] && [ "$cmd" != "-h" ] && [ "$cmd" != "--version" ] && [ "$cmd" != "-v" ] ); then
+    # This might be a bookmark name/number - check if it produces a cd command
+    local output
+    output=$(command bookmark "$@" 2>&1)
+    if echo "$output" | grep -q "^cd "; then
+      # Extract and execute the cd command
+      # shellcheck disable=SC2294
+      eval "$(echo "$output" | grep "^cd ")"
+      # Show the rest of the output (without the cd line)
+      echo "$output" | grep -v "^cd " >&2
+    else
+      # Not a jump command, just show the output
+      echo "$output"
+      return $?
+    fi
+  else
+    # For other commands (save, list, mv, help), just pass through
+    command bookmark "$@"
+  fi
+}
+EOF
+	echo "Added bookmark wrapper function to ~/.bashrc"
+	BASHRC_UPDATED=1
+fi
+
+# 1d) Add bookmark alias wrapper if configured
+if [ -n "${BOOKMARK_ALIAS:-}" ]; then
+	# Validate alias name (alphanumeric only, no spaces or special chars)
+	# shellcheck disable=SC2076
+	if [[ ! "$BOOKMARK_ALIAS" =~ ^[a-zA-Z0-9_]+$ ]]; then
+		echo -e "${YELLOW}Warning: Invalid alias name '$BOOKMARK_ALIAS' in config (must be alphanumeric)${NC}"
+		BOOKMARK_ALIAS=""
+	else
+		# Check for command conflicts - but allow our own symlink
+		# Functions take precedence over commands, so we can safely add the function
+		# even if a symlink exists (the function will be called first)
+		conflicting_cmd=""
+		if command -v "$BOOKMARK_ALIAS" >/dev/null 2>&1; then
+			conflicting_cmd=$(command -v "$BOOKMARK_ALIAS")
+			# Check if it's our own symlink - if so, it's OK to add the function
+			if [ -L "$conflicting_cmd" ]; then
+				symlink_target=$(readlink -f "$conflicting_cmd" 2>/dev/null || readlink "$conflicting_cmd" 2>/dev/null || echo "")
+				# If symlink points to our plugin, it's OK - function will override it
+				if echo "$symlink_target" | grep -q "mlh-bookmark.sh"; then
+					conflicting_cmd=""
+				fi
+			fi
+			# If it's a real command (not our symlink), warn but still allow function
+			# Function will take precedence, but user should know about the conflict
+			if [ -n "$conflicting_cmd" ]; then
+				echo -e "${YELLOW}Warning: Command '$BOOKMARK_ALIAS' exists at '$conflicting_cmd'${NC}"
+				echo -e "${YELLOW}Function will take precedence, but consider removing the conflicting command${NC}"
+			fi
+		fi
+
+		# Add the wrapper function (functions take precedence over commands/symlinks)
+		ALIAS_WRAPPER_MARKER="# MyLinuxHelper - $BOOKMARK_ALIAS alias wrapper"
+		if ! grep -Fq "$ALIAS_WRAPPER_MARKER" "$BASHRC" 2>/dev/null; then
+			cat >>"$BASHRC" <<EOF
+
+# MyLinuxHelper - $BOOKMARK_ALIAS alias wrapper
+# Shortcut alias for bookmark command (delegates to bookmark function for cd support)
+# NOTE: This function takes precedence over the symlink, enabling cd functionality
+$BOOKMARK_ALIAS() {
+  bookmark "\$@"
+}
+EOF
+			echo "Added $BOOKMARK_ALIAS alias wrapper to ~/.bashrc"
+			BASHRC_UPDATED=1
+		fi
+	fi
 fi
 
 # 2) Make scripts executable
@@ -48,6 +212,7 @@ chmod +x "$ROOT_DIR/install.sh"
 
 # 3) Create/refresh symlinks in ~/.local/bin
 declare -A LINKS=(
+	["$LOCAL_BIN/bookmark"]="$PLUGINS_DIR/mlh-bookmark.sh"
 	["$LOCAL_BIN/i"]="$ROOT_DIR/install.sh"
 	["$LOCAL_BIN/isjsonvalid"]="$PLUGINS_DIR/isjsonvalid.sh"
 	["$LOCAL_BIN/ll"]="$PLUGINS_DIR/ll.sh"
@@ -56,6 +221,11 @@ declare -A LINKS=(
 	["$LOCAL_BIN/search"]="$PLUGINS_DIR/search.sh"
 )
 
+# Add bookmark alias symlink if configured
+if [ -n "${BOOKMARK_ALIAS:-}" ]; then
+	LINKS["$LOCAL_BIN/$BOOKMARK_ALIAS"]="$PLUGINS_DIR/mlh-bookmark.sh"
+fi
+
 for link in "${!LINKS[@]}"; do
 	target="${LINKS[$link]}"
 	rm -f "$link"
@@ -67,6 +237,7 @@ done
 if [ "${MLH_INSTALL_USR_LOCAL:-0}" = "1" ] && command -v sudo >/dev/null 2>&1; then
 	echo "Linking into /usr/local/bin (requested via MLH_INSTALL_USR_LOCAL=1)..."
 	declare -A ULINKS=(
+		["/usr/local/bin/bookmark"]="$PLUGINS_DIR/mlh-bookmark.sh"
 		["/usr/local/bin/i"]="$ROOT_DIR/install.sh"
 		["/usr/local/bin/isjsonvalid"]="$PLUGINS_DIR/isjsonvalid.sh"
 		["/usr/local/bin/ll"]="$PLUGINS_DIR/ll.sh"
@@ -74,6 +245,12 @@ if [ "${MLH_INSTALL_USR_LOCAL:-0}" = "1" ] && command -v sudo >/dev/null 2>&1; t
 		["/usr/local/bin/mlh"]="$PLUGINS_DIR/mlh.sh"
 		["/usr/local/bin/search"]="$PLUGINS_DIR/search.sh"
 	)
+
+	# Add bookmark alias to usr/local if configured
+	if [ -n "${BOOKMARK_ALIAS:-}" ]; then
+		ULINKS["/usr/local/bin/$BOOKMARK_ALIAS"]="$PLUGINS_DIR/mlh-bookmark.sh"
+	fi
+
 	for link in "${!ULINKS[@]}"; do
 		target="${ULINKS[$link]}"
 		sudo rm -f "$link" 2>/dev/null || true
@@ -90,7 +267,7 @@ for bin in i isjsonvalid ll linux mlh search; do
 	fi
 done
 
-echo "✅ Setup complete. Commands: i, isjsonvalid, ll, linux, mlh, search"
+echo "✅ Setup complete. Commands: i, isjsonvalid, ll, linux, mlh, search${BOOKMARK_ALIAS:+, $BOOKMARK_ALIAS}"
 echo ""
 echo "Examples:"
 echo "  linux mycontainer                    # Create ephemeral container (default)"
@@ -110,6 +287,15 @@ echo "  mlh json get name from users.json    # Search JSON with fuzzy matching"
 echo ""
 echo "  ll /var/log                          # List directory contents with details"
 
+# Show warning if bashrc was updated
+if [ "$BASHRC_UPDATED" -eq 1 ]; then
+	echo ""
+	echo -e "${YELLOW}⚠️  Important: Shell configuration updated!${NC}"
+	echo -e "${YELLOW}   Run this command to apply changes in current session:${NC}"
+	echo -e "${CYAN}   source ~/.bashrc${NC}"
+	echo ""
+fi
+
 if [ "$need_reload" -eq 1 ] && [ -t 1 ] && [ -z "${MLH_RELOADED:-}" ]; then
 	echo "↻ Opening a fresh login shell so commands are available immediately..."
 	export MLH_RELOADED=1
diff --git a/tests/bookmark/test-bookmark-alias-integration.sh b/tests/bookmark/test-bookmark-alias-integration.sh
new file mode 100755
index 0000000..05538a7
--- /dev/null
+++ b/tests/bookmark/test-bookmark-alias-integration.sh
@@ -0,0 +1,514 @@
+#!/usr/bin/env bash
+# Integration tests for bookmark alias functionality with setup.sh
+
+# Disable strict mode for tests (like other test files)
+set +euo pipefail 2>/dev/null || true
+set +e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TESTS_DIR="$(dirname "$SCRIPT_DIR")"
+ROOT_DIR="$(dirname "$TESTS_DIR")"
+
+# Source test framework functions from parent
+if [ -n "${STATS_FILE:-}" ]; then
+	# Running under test runner
+	:
+else
+	# Standalone execution
+	GREEN='\033[0;32m'
+	RED='\033[0;31m'
+	YELLOW='\033[1;33m'
+	CYAN='\033[0;36m'
+	NC='\033[0m'
+
+	print_test_result() {
+		local test_name="$1"
+		local result="$2"
+		local message="${3:-}"
+
+		if [ "$result" = "PASS" ]; then
+			echo -e "${GREEN}✓ PASS${NC}: $test_name"
+		elif [ "$result" = "SKIP" ]; then
+			echo -e "${YELLOW}⊘ SKIP${NC}: $test_name"
+			[ -n "$message" ] && echo -e "  ${YELLOW}$message${NC}"
+		else
+			echo -e "${RED}✗ FAIL${NC}: $test_name"
+			[ -n "$message" ] && echo -e "  ${YELLOW}$message${NC}"
+		fi
+	}
+fi
+
+# Setup test environment
+setup_test_env() {
+	export TEST_HOME="/tmp/test-bookmark-alias-integration-$$"
+	mkdir -p "$TEST_HOME/.mylinuxhelper"
+	mkdir -p "$TEST_HOME/.local/bin"
+	export HOME="$TEST_HOME"
+	export MLH_CONFIG_DIR="$TEST_HOME/.mylinuxhelper"
+	export MLH_CONFIG_FILE="$MLH_CONFIG_DIR/mlh.conf"
+
+	# Create minimal bashrc
+	touch "$TEST_HOME/.bashrc"
+	touch "$TEST_HOME/.profile"
+}
+
+# Cleanup test environment
+cleanup_test_env() {
+	rm -rf "/tmp/test-bookmark-alias-integration-$$" 2>/dev/null || true
+}
+
+# Trap to ensure cleanup
+trap cleanup_test_env EXIT
+
+# Run tests
+setup_test_env
+
+#
+# Test Group 1: Wrapper function structure
+#
+
+# Test 1: Alias wrapper delegates to bookmark function
+echo "BOOKMARK_ALIAS=bm" >"$MLH_CONFIG_FILE"
+
+# Create a mock bashrc with wrapper
+cat >"$TEST_HOME/.bashrc" <<'EOF'
+bookmark() {
+  echo "bookmark function called with: $*"
+  command bookmark "$@"
+}
+
+bm() {
+  bookmark "$@"
+}
+EOF
+
+# Source and test
+source "$TEST_HOME/.bashrc"
+output=$(bm test 2>&1 || true)
+if echo "$output" | grep -q "bookmark function called"; then
+	print_test_result "Alias wrapper delegates to bookmark function" "PASS"
+else
+	print_test_result "Alias wrapper delegates to bookmark function" "FAIL" "Delegation not working"
+fi
+
+# Test 2: Wrapper preserves all arguments
+output=$(bm arg1 arg2 arg3 2>&1 || true)
+if echo "$output" | grep -q "arg1 arg2 arg3"; then
+	print_test_result "Wrapper preserves all arguments" "PASS"
+else
+	print_test_result "Wrapper preserves all arguments" "FAIL" "Arguments not preserved"
+fi
+
+# Test 3: Wrapper handles special characters in arguments
+output=$(bm "path with spaces" 2>&1 || true)
+if echo "$output" | grep -q "path with spaces"; then
+	print_test_result "Wrapper handles special characters" "PASS"
+else
+	print_test_result "Wrapper handles special characters" "FAIL" "Special chars not handled"
+fi
+
+#
+# Test Group 2: setup.sh execution with alias
+#
+
+# Test 4: setup.sh runs without error with alias configured
+echo "BOOKMARK_ALIAS=testbm" >"$MLH_CONFIG_FILE"
+if cd "$ROOT_DIR"; then
+	output=$(bash setup.sh 2>&1 || true)
+	exit_code=$?
+else
+	output="Failed to cd to $ROOT_DIR"
+	exit_code=1
+fi
+if [ $exit_code -eq 0 ] || echo "$output" | grep -q "Setup complete"; then
+	print_test_result "setup.sh runs without error with alias" "PASS"
+else
+	print_test_result "setup.sh runs without error with alias" "FAIL" "Exit code: $exit_code"
+fi
+
+# Test 5: setup.sh creates symlink for alias
+if [ -L "$TEST_HOME/.local/bin/testbm" ]; then
+	print_test_result "setup.sh creates symlink for alias" "PASS"
+else
+	print_test_result "setup.sh creates symlink for alias" "FAIL" "Symlink not created"
+fi
+
+# Test 6: Alias symlink points to mlh-bookmark.sh
+if [ -L "$TEST_HOME/.local/bin/testbm" ]; then
+	target=$(readlink "$TEST_HOME/.local/bin/testbm")
+	if echo "$target" | grep -q "mlh-bookmark.sh"; then
+		print_test_result "Alias symlink points to mlh-bookmark.sh" "PASS"
+	else
+		print_test_result "Alias symlink points to mlh-bookmark.sh" "FAIL" "Wrong target: $target"
+	fi
+else
+	print_test_result "Alias symlink points to mlh-bookmark.sh" "SKIP" "Symlink not created"
+fi
+
+# Test 7: setup.sh adds alias wrapper to bashrc
+if grep -q "testbm()" "$TEST_HOME/.bashrc"; then
+	print_test_result "setup.sh adds alias wrapper to bashrc" "PASS"
+else
+	print_test_result "setup.sh adds alias wrapper to bashrc" "FAIL" "Wrapper not found"
+fi
+
+# Test 8: Alias wrapper in bashrc has correct structure
+if grep -q 'bookmark "\$@"' "$TEST_HOME/.bashrc"; then
+	print_test_result "Alias wrapper has correct delegation structure" "PASS"
+else
+	print_test_result "Alias wrapper has correct delegation structure" "FAIL" "Delegation not found"
+fi
+
+# Test 9: setup.sh shows BASHRC_UPDATED warning
+if echo "$output" | grep -qi "Important.*Shell configuration updated" || echo "$output" | grep -q "source ~/.bashrc"; then
+	print_test_result "setup.sh shows BASHRC_UPDATED warning" "PASS"
+else
+	print_test_result "setup.sh shows BASHRC_UPDATED warning" "FAIL" "Warning not shown"
+fi
+
+# Test 10: Alias mentioned in setup complete message
+if echo "$output" | grep -q "testbm"; then
+	print_test_result "Alias mentioned in setup complete message" "PASS"
+else
+	print_test_result "Alias mentioned in setup complete message" "FAIL" "Alias not mentioned"
+fi
+
+#
+# Test Group 3: Command conflict detection
+#
+
+# Test 11: setup.sh detects command conflicts
+# Create a fake conflicting command
+mkdir -p "$TEST_HOME/.local/bin"
+echo '#!/bin/bash' >"$TEST_HOME/.local/bin/conflictcmd"
+echo 'echo "existing command"' >>"$TEST_HOME/.local/bin/conflictcmd"
+chmod +x "$TEST_HOME/.local/bin/conflictcmd"
+export PATH="$TEST_HOME/.local/bin:$PATH"
+
+echo "BOOKMARK_ALIAS=conflictcmd" >"$MLH_CONFIG_FILE"
+if cd "$ROOT_DIR"; then
+	output=$(bash setup.sh 2>&1 || true)
+else
+	output="Failed to cd to $ROOT_DIR"
+fi
+if echo "$output" | grep -qi "conflict\|already exists"; then
+	print_test_result "setup.sh detects command conflicts" "PASS"
+else
+	print_test_result "setup.sh detects command conflicts" "SKIP" "Conflict detection might be optional"
+fi
+
+#
+# Test Group 4: bm list interactive mode directory change
+#
+
+# Test 12: bm list changes directory when bookmark selected (interactive mode)
+# This test verifies that when using the bm alias, the interactive list mode
+# properly changes the directory when a bookmark is selected.
+
+# Ensure test environment is still set up (might have been modified by previous tests)
+if [ -z "${TEST_HOME:-}" ]; then
+	setup_test_env
+fi
+
+# Check if jq and tmux are available
+JQ_AVAILABLE=0
+if command -v jq >/dev/null 2>&1; then
+	JQ_AVAILABLE=1
+fi
+
+TMUX_AVAILABLE_BM=0
+if command -v tmux >/dev/null 2>&1; then
+	TMUX_AVAILABLE_BM=1
+fi
+
+# Always show test result, even if skipped
+if [ "$JQ_AVAILABLE" -eq 0 ] || [ "$TMUX_AVAILABLE_BM" -eq 0 ]; then
+	print_test_result "bm list changes directory (interactive mode)" "SKIP" "jq or tmux not available (jq: $JQ_AVAILABLE, tmux: $TMUX_AVAILABLE_BM)"
+else
+	# Setup: Configure bm alias in mlh.conf (new format)
+	echo "# MyLinuxHelper Configuration" >"$MLH_CONFIG_FILE"
+	echo "BOOKMARK_ALIAS=bm" >>"$MLH_CONFIG_FILE"
+
+	# Ensure HOME is set correctly for setup.sh
+	export HOME="$TEST_HOME"
+
+	# Run setup.sh to create wrapper functions
+	cd "$ROOT_DIR" || exit 1
+	bash setup.sh >/dev/null 2>&1 || true
+
+	# Create test bookmark file
+	test_bm_bookmark_file="/tmp/test-bookmark-bm-list-$$"
+	test_bm_bookmark_dir=$(mktemp -d)
+	if ! cd "$test_bm_bookmark_dir" 2>/dev/null; then
+		print_test_result "bm list changes directory (interactive mode)" "FAIL" "Failed to create or cd to test directory"
+	else
+		# Create bookmark in test file
+		MLH_BOOKMARK_FILE="$test_bm_bookmark_file" bash "$ROOT_DIR/plugins/mlh-bookmark.sh" . -n testbmlist >/dev/null 2>&1
+
+		# Create a different starting directory
+		start_dir_bm=$(mktemp -d)
+
+		# Create unique session name
+		session_name_bm="test-bookmark-bm-list-$$"
+
+		# Kill any existing session with same name
+		tmux kill-session -t "$session_name_bm" 2>/dev/null || true
+
+		# Create tmux session - simulate real usage where setup.sh was already run
+		# In real usage: user runs setup.sh once → wrapper functions added to .bashrc
+		# Then user opens new shell → .bashrc is sourced automatically
+		#
+		# IMPORTANT: We should NOT source setup.sh again in tmux session
+		# Instead, we should rely on .bashrc being sourced (which happens with bash -i)
+		# But bash -i might not source .bashrc in non-interactive tmux, so we explicitly source it
+		#
+		# CRITICAL: The bug might be that when bm() calls bookmark(), the source command
+		# in bookmark() doesn't properly change the directory in the calling shell.
+		# This could happen if source runs in a subshell or if there's a scope issue.
+		tmux new-session -d -s "$session_name_bm" bash
+		sleep 0.5
+
+		# Set up environment in tmux session
+		tmux send-keys -t "$session_name_bm" "export HOME='$TEST_HOME'" C-m
+		sleep 0.2
+		tmux send-keys -t "$session_name_bm" "export MLH_BOOKMARK_FILE='$test_bm_bookmark_file'" C-m
+		sleep 0.2
+
+		# Source .bashrc to load wrapper functions (this is what happens in real shell)
+		# Do NOT source setup.sh - that's not what users do in real usage
+		tmux send-keys -t "$session_name_bm" "source ~/.bashrc 2>/dev/null || true" C-m
+		sleep 0.5
+
+		# Verify bm function is loaded (if not, test should fail)
+		tmux send-keys -t "$session_name_bm" "type bm > /tmp/bm-check-$$ 2>&1; echo 'BM_TYPE_DONE' >> /tmp/bm-check-$$" C-m
+		sleep 0.3
+
+		# Send commands to tmux session
+		tmux send-keys -t "$session_name_bm" "cd '$start_dir_bm'" C-m
+		sleep 0.2
+		tmux send-keys -t "$session_name_bm" "pwd > /tmp/pwd-before-bm-$$" C-m
+		sleep 0.2
+
+		# Use bm list (alias) instead of bookmark list
+		# This tests that the alias wrapper properly delegates to bookmark function
+		# and that the bookmark function's interactive mode cd mechanism works
+		#
+		# THE BUG: bm() function calls bookmark() which should handle the interactive
+		# list mode and source the temp file for cd. But if the temp file is sourced
+		# in the bookmark() function's scope, it might not affect the parent shell
+		# that called bm(). The source command should work, but maybe there's a timing
+		# issue or the temp file isn't being written correctly.
+		tmux send-keys -t "$session_name_bm" "bm list" C-m
+		sleep 0.5
+
+		# Press Enter to select first bookmark (which should be testbmlist)
+		tmux send-keys -t "$session_name_bm" "" C-m
+		sleep 1.0
+
+		# Exit interactive mode - try multiple methods
+		# First try 'q' followed by Enter
+		tmux send-keys -t "$session_name_bm" "q"
+		sleep 0.2
+		tmux send-keys -t "$session_name_bm" C-m
+		sleep 0.3
+		# If that doesn't work, try ESC
+		tmux send-keys -t "$session_name_bm" Escape
+		sleep 0.3
+		# Last resort: Ctrl+C
+		tmux send-keys -t "$session_name_bm" C-c
+		sleep 0.5
+
+		# Get PWD after - this should show if cd worked
+		tmux send-keys -t "$session_name_bm" "pwd > /tmp/pwd-after-bm-$$" C-m
+		sleep 0.2
+
+		# Exit tmux session
+		tmux send-keys -t "$session_name_bm" "exit" C-m
+		sleep 0.2
+
+		# Kill session
+		tmux kill-session -t "$session_name_bm" 2>/dev/null || true
+
+		# Compare PWDs and check debug info
+		pwd_before_bm=$(cat /tmp/pwd-before-bm-$$ 2>/dev/null || echo "")
+		pwd_after_bm=$(cat /tmp/pwd-after-bm-$$ 2>/dev/null || echo "")
+		bm_check=$(cat /tmp/bm-check-$$ 2>/dev/null || echo "")
+
+		# Cleanup temp files ONLY (keep directories until after PWD comparison)
+		rm -f /tmp/pwd-before-bm-$$ /tmp/pwd-after-bm-$$ /tmp/bm-check-$$ "$test_bm_bookmark_file" 2>/dev/null || true
+		# Note: Don't remove directories yet - they're needed for cd to work
+		# Cleanup will happen at test suite end
+
+		# Expected: Directory should change from start_dir_bm to test_bm_bookmark_dir
+		# If directory didn't change, the test should FAIL (this is the bug we're testing for)
+		# The user reports that bm list does NOT change directory in real usage
+		if [ -n "$pwd_before_bm" ] && [ -n "$pwd_after_bm" ]; then
+			if [ "$pwd_before_bm" != "$pwd_after_bm" ] && [ "$pwd_after_bm" = "$test_bm_bookmark_dir" ]; then
+				# Directory changed correctly - but user reports this doesn't work in real usage
+				# This might be a false positive if test environment differs from real usage
+				print_test_result "bm list changes directory (interactive mode)" "PASS" "Directory changed: $pwd_before_bm -> $pwd_after_bm (NOTE: If this passes but fails in real usage, there's a test environment issue)"
+			elif [ "$pwd_before_bm" = "$pwd_after_bm" ]; then
+				# Directory didn't change - this confirms the bug
+				print_test_result "bm list changes directory (interactive mode)" "FAIL" "Directory didn't change. Before: '$pwd_before_bm', After: '$pwd_after_bm' (expected: '$test_bm_bookmark_dir'). bm function check: ${bm_check:0:80}"
+			else
+				# Directory changed but to wrong location
+				print_test_result "bm list changes directory (interactive mode)" "FAIL" "Directory changed to wrong location. Before: '$pwd_before_bm', After: '$pwd_after_bm' (expected: '$test_bm_bookmark_dir')"
+			fi
+		else
+			print_test_result "bm list changes directory (interactive mode)" "FAIL" "Couldn't read PWD values. Before: '$pwd_before_bm', After: '$pwd_after_bm'. bm function check: ${bm_check:0:80}"
+		fi
+
+		# Cleanup directories
+		rm -rf "$test_bm_bookmark_dir" "$start_dir_bm" 2>/dev/null || true
+	fi
+fi
+
+# Test 13: bm list changes directory on second invocation (interactive mode)
+# This test verifies that when using the bm alias, the interactive list mode
+# properly changes the directory when called TWICE in the same session.
+# Based on test-mlh-bookmark.sh Test 77, but using bm alias instead of bookmark command.
+
+# Check if jq and tmux are available
+JQ_AVAILABLE_13=0
+if command -v jq >/dev/null 2>&1; then
+	JQ_AVAILABLE_13=1
+fi
+
+TMUX_AVAILABLE_BM_13=0
+if command -v tmux >/dev/null 2>&1; then
+	TMUX_AVAILABLE_BM_13=1
+fi
+
+# Always show test result, even if skipped
+if [ "$JQ_AVAILABLE_13" -eq 0 ] || [ "$TMUX_AVAILABLE_BM_13" -eq 0 ]; then
+	print_test_result "bm list changes directory on second invocation (interactive mode)" "SKIP" "jq or tmux not available (jq: $JQ_AVAILABLE_13, tmux: $TMUX_AVAILABLE_BM_13)"
+else
+	# Ensure test environment is still set up
+	if [ -z "${TEST_HOME:-}" ]; then
+		setup_test_env
+	fi
+
+	# Setup: Configure bm alias in mlh.conf (new format)
+	echo "# MyLinuxHelper Configuration" >"$MLH_CONFIG_FILE"
+	echo "BOOKMARK_ALIAS=bm" >>"$MLH_CONFIG_FILE"
+
+	# Ensure HOME is set correctly for setup.sh
+	export HOME="$TEST_HOME"
+
+	# Run setup.sh to create wrapper functions
+	cd "$ROOT_DIR" || exit 1
+	bash setup.sh >/dev/null 2>&1 || true
+
+	# Create test bookmark file and directories for this test
+	test_bm_13_bookmark_file="/tmp/test-bookmark-bm-13-$$"
+	test_bm_bookmark_dir1_13=$(mktemp -d)
+	test_bm_bookmark_dir2_13=$(mktemp -d)
+
+	# Create TWO bookmarks for this test (to select twice in same session)
+	cd "$test_bm_bookmark_dir1_13" || exit 1
+	MLH_BOOKMARK_FILE="$test_bm_13_bookmark_file" bash "$ROOT_DIR/plugins/mlh-bookmark.sh" . -n bm1_13 >/dev/null 2>&1
+	cd "$test_bm_bookmark_dir2_13" || exit 1
+	MLH_BOOKMARK_FILE="$test_bm_13_bookmark_file" bash "$ROOT_DIR/plugins/mlh-bookmark.sh" . -n bm2_13 >/dev/null 2>&1
+
+	# Create a different starting directory
+	start_dir_bm_13=$(mktemp -d)
+
+	# Create unique session name
+	session_name_bm_13="test-bookmark-bm-13-$$"
+
+	# Kill any existing session with same name
+	tmux kill-session -t "$session_name_bm_13" 2>/dev/null || true
+
+	# Create tmux session - simulate real usage where setup.sh was already run
+	# In real usage: user runs setup.sh once → wrapper functions added to .bashrc
+	# Then user opens new shell → .bashrc is sourced automatically
+	#
+	# IMPORTANT: We should NOT source setup.sh again in tmux session
+	# Instead, we should rely on .bashrc being sourced (which happens with bash -i)
+	# But bash -i might not source .bashrc in non-interactive tmux, so we explicitly source it
+	tmux new-session -d -s "$session_name_bm_13" bash
+	sleep 0.5
+
+	# Set up environment in tmux session
+	tmux send-keys -t "$session_name_bm_13" "export HOME='$TEST_HOME'" C-m
+	sleep 0.2
+	tmux send-keys -t "$session_name_bm_13" "export MLH_BOOKMARK_FILE='$test_bm_13_bookmark_file'" C-m
+	sleep 0.2
+
+	# Source .bashrc to load wrapper functions (this is what happens in real shell)
+	# Do NOT source setup.sh - that's not what users do in real usage
+	tmux send-keys -t "$session_name_bm_13" "source ~/.bashrc 2>/dev/null || true" C-m
+	sleep 0.5
+
+	# === TEST: TWO SEPARATE INVOCATIONS (not same session) ===
+	# Start from a known directory
+	tmux send-keys -t "$session_name_bm_13" "cd '$start_dir_bm_13'" C-m
+	sleep 0.3
+	tmux send-keys -t "$session_name_bm_13" "pwd > /tmp/pwd-start-bm-13-$$" C-m
+	sleep 0.3
+
+	# FIRST INVOCATION: bm list (alias), select first bookmark
+	tmux send-keys -t "$session_name_bm_13" "bm list" C-m
+	sleep 1.0
+	tmux send-keys -t "$session_name_bm_13" "" C-m # Enter - select first bookmark
+	sleep 1.2
+	tmux send-keys -t "$session_name_bm_13" "pwd > /tmp/pwd-after-first-bm-13-$$" C-m
+	sleep 0.3
+
+	# SECOND INVOCATION: bm list again (alias), select second bookmark
+	tmux send-keys -t "$session_name_bm_13" "bm list" C-m
+	sleep 1.0
+	tmux send-keys -t "$session_name_bm_13" "Down" C-m # Navigate to second bookmark
+	sleep 0.5
+	tmux send-keys -t "$session_name_bm_13" "" C-m # Enter - select second bookmark
+	sleep 1.2
+	tmux send-keys -t "$session_name_bm_13" "pwd > /tmp/pwd-final-bm-13-$$" C-m
+	sleep 0.3
+
+	# Exit tmux session
+	tmux send-keys -t "$session_name_bm_13" "exit" C-m
+	sleep 0.2
+
+	# Kill session
+	tmux kill-session -t "$session_name_bm_13" 2>/dev/null || true
+
+	# Read PWDs
+	pwd_start_bm_13=$(cat /tmp/pwd-start-bm-13-$$ 2>/dev/null || echo "")
+	pwd_after_first_bm_13=$(cat /tmp/pwd-after-first-bm-13-$$ 2>/dev/null || echo "")
+	pwd_final_bm_13=$(cat /tmp/pwd-final-bm-13-$$ 2>/dev/null || echo "")
+
+	# Cleanup
+	rm -f /tmp/pwd-start-bm-13-$$ /tmp/pwd-after-first-bm-13-$$ /tmp/pwd-final-bm-13-$$ 2>/dev/null || true
+	rm -f "$test_bm_13_bookmark_file" 2>/dev/null || true
+	rm -rf "$test_bm_bookmark_dir1_13" "$test_bm_bookmark_dir2_13" "$start_dir_bm_13" 2>/dev/null || true
+
+	# Test logic:
+	# After TWO SEPARATE invocations with bm list, PWD should change both times
+	#   Start: $start_dir_bm_13
+	#   After first: $test_bm_bookmark_dir1_13 (first bookmark)
+	#   Final: $test_bm_bookmark_dir2_13 (second bookmark)
+
+	# Check if both invocations worked
+	first_worked_bm_13="no"
+	if [ "$pwd_after_first_bm_13" = "$test_bm_bookmark_dir1_13" ]; then
+		first_worked_bm_13="yes"
+	fi
+
+	second_worked_bm_13="no"
+	if [ "$pwd_final_bm_13" = "$test_bm_bookmark_dir2_13" ]; then
+		second_worked_bm_13="yes"
+	fi
+
+	if [ "$first_worked_bm_13" = "yes" ] && [ "$second_worked_bm_13" = "yes" ]; then
+		print_test_result "bm list changes directory on second invocation (interactive mode)" "PASS" "Both invocations work! Start: $pwd_start_bm_13 -> 1st: $pwd_after_first_bm_13 -> 2nd: $pwd_final_bm_13"
+	elif [ "$first_worked_bm_13" = "yes" ]; then
+		print_test_result "bm list changes directory on second invocation (interactive mode)" "FAIL" "First works, second doesn't. Start: $pwd_start_bm_13 -> 1st: $pwd_after_first_bm_13 -> 2nd: $pwd_final_bm_13 (expected: $test_bm_bookmark_dir2_13)"
+	else
+		print_test_result "bm list changes directory on second invocation (interactive mode)" "FAIL" "First invocation failed. Start: $pwd_start_bm_13, After 1st: $pwd_after_first_bm_13, Final: $pwd_final_bm_13"
+	fi
+fi
+
+# Cleanup
+cleanup_test_env
+
+exit 0
diff --git a/tests/bookmark/test-bookmark-alias.sh b/tests/bookmark/test-bookmark-alias.sh
new file mode 100755
index 0000000..7828d11
--- /dev/null
+++ b/tests/bookmark/test-bookmark-alias.sh
@@ -0,0 +1,336 @@
+#!/usr/bin/env bash
+# Test suite for bookmark alias functionality
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TESTS_DIR="$(dirname "$SCRIPT_DIR")"
+ROOT_DIR="$(dirname "$TESTS_DIR")"
+
+# Source test framework functions from parent
+if [ -n "${STATS_FILE:-}" ]; then
+	# Running under test runner
+	:
+else
+	# Standalone execution
+	GREEN='\033[0;32m'
+	RED='\033[0;31m'
+	YELLOW='\033[1;33m'
+	CYAN='\033[0;36m'
+	NC='\033[0m'
+
+	print_test_result() {
+		local test_name="$1"
+		local result="$2"
+		local message="${3:-}"
+
+		if [ "$result" = "PASS" ]; then
+			echo -e "${GREEN}✓ PASS${NC}: $test_name"
+		elif [ "$result" = "SKIP" ]; then
+			echo -e "${YELLOW}⊘ SKIP${NC}: $test_name"
+			[ -n "$message" ] && echo -e "  ${YELLOW}$message${NC}"
+		else
+			echo -e "${RED}✗ FAIL${NC}: $test_name"
+			[ -n "$message" ] && echo -e "  ${YELLOW}$message${NC}"
+		fi
+	}
+fi
+
+# Setup test environment
+setup_test_env() {
+	export HOME="/tmp/test-bookmark-alias-$$"
+	mkdir -p "$HOME/.mylinuxhelper"
+	export MLH_CONFIG_DIR="$HOME/.mylinuxhelper"
+	export MLH_CONFIG_FILE="$MLH_CONFIG_DIR/mlh.conf"
+}
+
+# Cleanup test environment
+cleanup_test_env() {
+	rm -rf "/tmp/test-bookmark-alias-$$" 2>/dev/null || true
+}
+
+# Trap to ensure cleanup
+trap cleanup_test_env EXIT
+
+# Run tests
+setup_test_env
+
+#
+# Test Group 1: Configuration file handling
+#
+
+# Test 1: Config file can be sourced and read
+echo "BOOKMARK_ALIAS=bm" >"$MLH_CONFIG_FILE"
+if source "$MLH_CONFIG_FILE" 2>/dev/null && [ "$BOOKMARK_ALIAS" = "bm" ]; then
+	print_test_result "Config file can be sourced and read" "PASS"
+else
+	print_test_result "Config file can be sourced and read" "FAIL" "Failed to read config"
+fi
+
+# Test 2: Empty alias (no shortcut)
+echo "" >"$MLH_CONFIG_FILE"
+BOOKMARK_ALIAS=""
+source "$MLH_CONFIG_FILE" 2>/dev/null || true
+if [ -z "$BOOKMARK_ALIAS" ]; then
+	print_test_result "Config file supports empty alias (no shortcut)" "PASS"
+else
+	print_test_result "Config file supports empty alias (no shortcut)" "FAIL" "Expected empty, got '$BOOKMARK_ALIAS'"
+fi
+
+# Test 3: Custom alias
+echo "BOOKMARK_ALIAS=bm" >"$MLH_CONFIG_FILE"
+BOOKMARK_ALIAS=""
+source "$MLH_CONFIG_FILE" 2>/dev/null
+if [ "$BOOKMARK_ALIAS" = "bm" ]; then
+	print_test_result "Config file supports custom alias" "PASS"
+else
+	print_test_result "Config file supports custom alias" "FAIL" "Got '$BOOKMARK_ALIAS'"
+fi
+
+#
+# Test Group 2: Help display with alias
+#
+
+# Test 4: Help displays shortcut header when alias configured
+BOOKMARK_ALIAS="bm"
+COMMAND_NAME="${BOOKMARK_ALIAS:-bookmark}"
+output=$("$ROOT_DIR/plugins/mlh-bookmark.sh" --help 2>&1 || true)
+if echo "$output" | grep -q "Shortcut.*bm"; then
+	print_test_result "Help displays shortcut header when alias configured" "PASS"
+else
+	print_test_result "Help displays shortcut header when alias configured" "FAIL" "Shortcut header not found"
+fi
+
+# Test 5: Help examples use configured alias name
+if echo "$output" | grep -q "bm ."; then
+	print_test_result "Help examples use configured alias name" "PASS"
+else
+	print_test_result "Help examples use configured alias name" "FAIL" "Examples don't use alias"
+fi
+
+# Test 6: Help adapts to different alias names (fav)
+echo "BOOKMARK_ALIAS=fav" >"$MLH_CONFIG_FILE"
+output=$("$ROOT_DIR/plugins/mlh-bookmark.sh" --help 2>&1 || true)
+if echo "$output" | grep -q "fav ."; then
+	print_test_result "Help adapts to different alias names (fav)" "PASS"
+else
+	print_test_result "Help adapts to different alias names (fav)" "FAIL" "Help doesn't use 'fav'"
+fi
+
+# Test 7: Help shows 'bookmark' when no alias configured
+echo "" >"$MLH_CONFIG_FILE"
+output=$("$ROOT_DIR/plugins/mlh-bookmark.sh" --help 2>&1 || true)
+if echo "$output" | grep -q "bookmark \."; then
+	print_test_result "Help shows 'bookmark' when no alias configured" "PASS"
+else
+	print_test_result "Help shows 'bookmark' when no alias configured" "FAIL" "Expected 'bookmark'"
+fi
+
+# Test 8: Help shows 'bookmark' when config missing
+rm -f "$MLH_CONFIG_FILE"
+output=$("$ROOT_DIR/plugins/mlh-bookmark.sh" --help 2>&1 || true)
+if echo "$output" | grep -q "bookmark \."; then
+	print_test_result "Help shows 'bookmark' when config missing" "PASS"
+else
+	print_test_result "Help shows 'bookmark' when config missing" "FAIL" "Expected 'bookmark'"
+fi
+
+#
+# Test Group 3: setup.sh integration
+#
+
+# Test 9: setup.sh exists
+if [ -f "$ROOT_DIR/setup.sh" ]; then
+	print_test_result "setup.sh exists" "PASS"
+else
+	print_test_result "setup.sh exists" "FAIL" "File not found"
+fi
+
+# Test 10: setup.sh has valid syntax
+if bash -n "$ROOT_DIR/setup.sh" 2>/dev/null; then
+	print_test_result "setup.sh has valid syntax" "PASS"
+else
+	print_test_result "setup.sh has valid syntax" "FAIL" "Syntax error"
+fi
+
+# Test 11: setup.sh contains alias configuration logic
+if grep -q "BOOKMARK_ALIAS" "$ROOT_DIR/setup.sh"; then
+	print_test_result "setup.sh contains alias configuration logic" "PASS"
+else
+	print_test_result "setup.sh contains alias configuration logic" "FAIL" "Logic not found"
+fi
+
+# Test 12: setup.sh checks for command conflicts
+if grep -q "command -v.*BOOKMARK_ALIAS" "$ROOT_DIR/setup.sh"; then
+	print_test_result "setup.sh checks for command conflicts" "PASS"
+else
+	print_test_result "setup.sh checks for command conflicts" "FAIL" "Conflict check not found"
+fi
+
+# Test 13: setup.sh creates alias wrapper function
+if grep -q "bookmark.*\\\$@" "$ROOT_DIR/setup.sh"; then
+	print_test_result "setup.sh creates alias wrapper function" "PASS"
+else
+	print_test_result "setup.sh creates alias wrapper function" "FAIL" "Wrapper not found"
+fi
+
+# Test 14: setup.sh creates symlink for alias
+if grep -q 'LINKS\[.*BOOKMARK_ALIAS' "$ROOT_DIR/setup.sh"; then
+	print_test_result "setup.sh creates symlink for alias" "PASS"
+else
+	print_test_result "setup.sh creates symlink for alias" "FAIL" "Symlink logic not found"
+fi
+
+# Test 15: Symlink logic targets mlh-bookmark.sh
+if grep -q 'mlh-bookmark\.sh' "$ROOT_DIR/setup.sh"; then
+	print_test_result "Symlink logic targets mlh-bookmark.sh" "PASS"
+else
+	print_test_result "Symlink logic targets mlh-bookmark.sh" "FAIL" "Target not found"
+fi
+
+#
+# Test Group 4: Alias name validation
+#
+
+# Test 16: Valid alias names are alphanumeric
+valid_names=("bm" "b" "bookmark1" "my_bookmark" "BM" "MyBookmarks")
+all_valid=true
+for name in "${valid_names[@]}"; do
+	if [[ ! "$name" =~ ^[a-zA-Z0-9_]+$ ]]; then
+		all_valid=false
+		break
+	fi
+done
+if $all_valid; then
+	print_test_result "Valid alias names are alphanumeric" "PASS"
+else
+	print_test_result "Valid alias names are alphanumeric" "FAIL" "Pattern validation failed"
+fi
+
+# Test 17: Invalid alias names detected (spaces, special chars)
+invalid_names=("b m" "book-mark" "book@mark" "book!mark" "book mark")
+all_invalid=true
+for name in "${invalid_names[@]}"; do
+	if [[ "$name" =~ ^[a-zA-Z0-9_]+$ ]]; then
+		all_invalid=false
+		break
+	fi
+done
+if $all_invalid; then
+	print_test_result "Invalid alias names detected (spaces, special chars)" "PASS"
+else
+	print_test_result "Invalid alias names detected (spaces, special chars)" "FAIL" "Should reject '$name'"
+fi
+
+# Test 18: Long alias names supported
+long_name="verylongbookmarkalias123"
+if [[ "$long_name" =~ ^[a-zA-Z0-9_]+$ ]]; then
+	print_test_result "Long alias names supported" "PASS"
+else
+	print_test_result "Long alias names supported" "FAIL" "Long names should be valid"
+fi
+
+# Test 19: Single character alias supported
+single_char="b"
+if [[ "$single_char" =~ ^[a-zA-Z0-9_]+$ ]]; then
+	print_test_result "Single character alias supported" "PASS"
+else
+	print_test_result "Single character alias supported" "FAIL" "Single char should be valid"
+fi
+
+#
+# Test Group 5: Config file edge cases
+#
+
+# Test 20: Config file with comments works
+echo "# Bookmark alias configuration" >"$MLH_CONFIG_FILE"
+echo "BOOKMARK_ALIAS=bm" >>"$MLH_CONFIG_FILE"
+BOOKMARK_ALIAS=""
+source "$MLH_CONFIG_FILE" 2>/dev/null || true
+if [ "$BOOKMARK_ALIAS" = "bm" ]; then
+	print_test_result "Config file with comments works" "PASS"
+else
+	print_test_result "Config file with comments works" "FAIL" "Comments break parsing: got '$BOOKMARK_ALIAS'"
+fi
+
+# Test 21: Config handles whitespace (bash trims it naturally)
+echo "BOOKMARK_ALIAS=bm" >"$MLH_CONFIG_FILE"
+echo "  " >>"$MLH_CONFIG_FILE"
+BOOKMARK_ALIAS=""
+source "$MLH_CONFIG_FILE" 2>/dev/null || true
+# Config should still work with extra whitespace/blank lines
+if [ "$BOOKMARK_ALIAS" = "bm" ]; then
+	print_test_result "Config handles whitespace" "PASS"
+else
+	print_test_result "Config handles whitespace" "FAIL" "Whitespace breaks parsing: got '$BOOKMARK_ALIAS'"
+fi
+
+# Test 22: Config with export statement
+echo "export BOOKMARK_ALIAS=bm" >"$MLH_CONFIG_FILE"
+BOOKMARK_ALIAS=""
+source "$MLH_CONFIG_FILE" 2>/dev/null || true
+if [ "$BOOKMARK_ALIAS" = "bm" ]; then
+	print_test_result "Config with export statement" "PASS"
+else
+	print_test_result "Config with export statement" "FAIL" "Export breaks parsing: got '$BOOKMARK_ALIAS'"
+fi
+
+# Test 23: Config with multiple variables (only BOOKMARK_ALIAS matters)
+echo "SOME_VAR=test" >"$MLH_CONFIG_FILE"
+echo "BOOKMARK_ALIAS=bm" >>"$MLH_CONFIG_FILE"
+echo "OTHER_VAR=value" >>"$MLH_CONFIG_FILE"
+BOOKMARK_ALIAS=""
+source "$MLH_CONFIG_FILE" 2>/dev/null || true
+if [ "$BOOKMARK_ALIAS" = "bm" ]; then
+	print_test_result "Config with multiple variables" "PASS"
+else
+	print_test_result "Config with multiple variables" "FAIL" "Multiple vars break parsing: got '$BOOKMARK_ALIAS'"
+fi
+
+#
+# Test Group 6: BASHRC_UPDATED tracking
+#
+
+# Test 24: setup.sh initializes BASHRC_UPDATED
+if grep -q "BASHRC_UPDATED=0" "$ROOT_DIR/setup.sh"; then
+	print_test_result "setup.sh initializes BASHRC_UPDATED" "PASS"
+else
+	print_test_result "setup.sh initializes BASHRC_UPDATED" "FAIL" "Initialization not found"
+fi
+
+# Test 25: setup.sh sets BASHRC_UPDATED when adding wrappers
+if grep -q "BASHRC_UPDATED=1" "$ROOT_DIR/setup.sh"; then
+	print_test_result "setup.sh sets BASHRC_UPDATED when adding wrappers" "PASS"
+else
+	print_test_result "setup.sh sets BASHRC_UPDATED when adding wrappers" "FAIL" "Flag not set"
+fi
+
+# Test 26: setup.sh displays warning when BASHRC_UPDATED
+if grep -q "BASHRC_UPDATED.*eq.*1" "$ROOT_DIR/setup.sh" && grep -q "source ~/.bashrc" "$ROOT_DIR/setup.sh"; then
+	print_test_result "setup.sh displays warning when BASHRC_UPDATED" "PASS"
+else
+	print_test_result "setup.sh displays warning when BASHRC_UPDATED" "FAIL" "Warning not found"
+fi
+
+#
+# Test Group 7: Color output
+#
+
+# Test 27: setup.sh defines color variables
+if grep -q "YELLOW=" "$ROOT_DIR/setup.sh" && grep -q "CYAN=" "$ROOT_DIR/setup.sh"; then
+	print_test_result "setup.sh defines color variables" "PASS"
+else
+	print_test_result "setup.sh defines color variables" "FAIL" "Color variables not found"
+fi
+
+# Test 28: Warning message uses colors
+if grep -q "\${YELLOW}.*Important" "$ROOT_DIR/setup.sh"; then
+	print_test_result "Warning message uses colors" "PASS"
+else
+	print_test_result "Warning message uses colors" "FAIL" "Colored warning not found"
+fi
+
+# Cleanup
+cleanup_test_env
+
+exit 0
diff --git a/tests/bookmark/test-mlh-bookmark.sh b/tests/bookmark/test-mlh-bookmark.sh
new file mode 100755
index 0000000..a9b887e
--- /dev/null
+++ b/tests/bookmark/test-mlh-bookmark.sh
@@ -0,0 +1,1133 @@
+#!/usr/bin/env bash
+# test-mlh-bookmark.sh - Test suite for mlh-bookmark.sh (Phase 1 MVP)
+
+# Disable strict mode for tests
+set +euo pipefail 2>/dev/null || true
+set +e
+
+PLUGIN_SCRIPT="$ROOT_DIR/plugins/mlh-bookmark.sh"
+
+# Check if jq is available (required for bookmark feature)
+JQ_AVAILABLE=0
+if command -v jq >/dev/null 2>&1; then
+	JQ_AVAILABLE=1
+else
+	# Try to install jq if not available
+	echo "jq not found. Attempting to install..."
+	if [ -f "$ROOT_DIR/install.sh" ]; then
+		bash "$ROOT_DIR/install.sh" jq >/dev/null 2>&1
+		if command -v jq >/dev/null 2>&1; then
+			JQ_AVAILABLE=1
+			echo "✓ jq installed successfully"
+		else
+			echo "✗ Failed to install jq automatically"
+		fi
+	fi
+fi
+
+# Setup test environment
+TEST_BOOKMARK_DIR=$(mktemp -d)
+TEST_BOOKMARK_FILE="$TEST_BOOKMARK_DIR/bookmarks.json"
+export MLH_BOOKMARK_FILE="$TEST_BOOKMARK_FILE" # Allow override for testing
+
+# Create test directories for bookmark testing
+TEST_DIR_1=$(mktemp -d)
+TEST_DIR_2=$(mktemp -d)
+TEST_DIR_3=$(mktemp -d)
+
+# Cleanup function
+cleanup_bookmark_tests() {
+	rm -rf "$TEST_BOOKMARK_DIR" "$TEST_DIR_1" "$TEST_DIR_2" "$TEST_DIR_3" 2>/dev/null || true
+}
+
+trap cleanup_bookmark_tests EXIT
+
+# ============================================================================
+# BASIC TESTS
+# ============================================================================
+
+# Test 1: Script exists
+if [ -f "$PLUGIN_SCRIPT" ]; then
+	print_test_result "mlh-bookmark.sh exists" "PASS"
+else
+	print_test_result "mlh-bookmark.sh exists" "FAIL" "File not found at: $PLUGIN_SCRIPT"
+fi
+
+# Test 2: Valid bash syntax
+if bash -n "$PLUGIN_SCRIPT" 2>/dev/null; then
+	print_test_result "mlh-bookmark.sh has valid syntax" "PASS"
+else
+	print_test_result "mlh-bookmark.sh has valid syntax" "FAIL" "Syntax errors found"
+fi
+
+# Test 3: Help text works
+if bash "$PLUGIN_SCRIPT" --help >/dev/null 2>&1; then
+	print_test_result "bookmark --help works" "PASS"
+else
+	print_test_result "bookmark --help works" "FAIL" "Help command failed"
+fi
+
+# Skip remaining tests if jq is not available
+if [ "$JQ_AVAILABLE" -eq 0 ]; then
+	print_test_result "Remaining bookmark tests" "SKIP" "jq not installed (required for bookmark feature)"
+	exit 0
+fi
+
+# ============================================================================
+# NUMBERED BOOKMARK STACK TESTS
+# ============================================================================
+
+# Test 4: Save current directory as numbered bookmark
+cd "$TEST_DIR_1" || exit 1
+result=$(bash "$PLUGIN_SCRIPT" . 2>&1)
+if echo "$result" | grep -qi "saved\|bookmark 1"; then
+	print_test_result "Save current directory as bookmark 1" "PASS"
+else
+	print_test_result "Save current directory as bookmark 1" "FAIL" "Expected 'saved' or 'bookmark 1' in output"
+fi
+
+# Test 5: Bookmark file created
+if [ -f "$TEST_BOOKMARK_FILE" ]; then
+	print_test_result "Bookmark file created at $TEST_BOOKMARK_FILE" "PASS"
+else
+	print_test_result "Bookmark file created" "FAIL" "File not found"
+fi
+
+# Test 6: Bookmark file is valid JSON
+if jq empty "$TEST_BOOKMARK_FILE" 2>/dev/null; then
+	print_test_result "Bookmark file is valid JSON" "PASS"
+else
+	print_test_result "Bookmark file is valid JSON" "FAIL" "Invalid JSON format"
+fi
+
+# Test 7: Bookmark file contains correct path
+saved_path=$(jq -r '.bookmarks.unnamed[0].path // empty' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+if [ "$saved_path" = "$TEST_DIR_1" ]; then
+	print_test_result "Bookmark contains correct path" "PASS"
+else
+	print_test_result "Bookmark contains correct path" "FAIL" "Expected: $TEST_DIR_1, Got: $saved_path"
+fi
+
+# Test 8: Add second bookmark (stack behavior)
+cd "$TEST_DIR_2" || exit 1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1
+saved_path=$(jq -r '.bookmarks.unnamed[0].path // empty' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+if [ "$saved_path" = "$TEST_DIR_2" ]; then
+	print_test_result "Second bookmark becomes bookmark 1 (stack)" "PASS"
+else
+	print_test_result "Second bookmark becomes bookmark 1 (stack)" "FAIL" "Expected: $TEST_DIR_2, Got: $saved_path"
+fi
+
+# Test 9: First bookmark becomes bookmark 2
+saved_path=$(jq -r '.bookmarks.unnamed[1].path // empty' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+if [ "$saved_path" = "$TEST_DIR_1" ]; then
+	print_test_result "First bookmark becomes bookmark 2" "PASS"
+else
+	print_test_result "First bookmark becomes bookmark 2" "FAIL" "Expected: $TEST_DIR_1, Got: $saved_path"
+fi
+
+# Test 10: Stack limit (max 10 unnamed bookmarks)
+for i in {3..12}; do
+	bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1
+done
+count=$(jq '.bookmarks.unnamed | length' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+if [ "$count" -le 10 ]; then
+	print_test_result "Stack limit enforced (max 10)" "PASS"
+else
+	print_test_result "Stack limit enforced (max 10)" "FAIL" "Expected ≤10, Got: $count"
+fi
+
+# Test 11: Jump to bookmark 1 (source test - prints cd command)
+# Note: We can't actually test CD in subshell, so we check output format
+result=$(bash "$PLUGIN_SCRIPT" 1 2>&1)
+if echo "$result" | grep -q "$TEST_DIR_2\|cd"; then
+	print_test_result "Jump to bookmark 1 generates correct output" "PASS"
+else
+	print_test_result "Jump to bookmark 1 generates correct output" "FAIL" "Expected path or cd command"
+fi
+
+# Test 12: Jump to non-existent bookmark number
+result=$(bash "$PLUGIN_SCRIPT" 99 2>&1)
+if echo "$result" | grep -qi "not found\|invalid\|error"; then
+	print_test_result "Jump to non-existent bookmark fails gracefully" "PASS"
+else
+	print_test_result "Jump to non-existent bookmark fails gracefully" "FAIL" "Should show error message"
+fi
+
+# ============================================================================
+# NAMED BOOKMARK TESTS
+# ============================================================================
+
+# Test 13: Save current directory with name
+rm -f "$TEST_BOOKMARK_FILE" # Reset for named tests
+cd "$TEST_DIR_1" || exit 1
+result=$(bash "$PLUGIN_SCRIPT" . -n testproject 2>&1)
+if echo "$result" | grep -qi "saved\|testproject"; then
+	print_test_result "Save with name: bookmark . -n testproject" "PASS"
+else
+	print_test_result "Save with name: bookmark . -n testproject" "FAIL" "Expected success message"
+fi
+
+# Test 14: Named bookmark stored correctly
+saved_name=$(jq -r '.bookmarks.named[0].name // empty' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+saved_path=$(jq -r '.bookmarks.named[0].path // empty' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+if [ "$saved_name" = "testproject" ] && [ "$saved_path" = "$TEST_DIR_1" ]; then
+	print_test_result "Named bookmark stored with correct name and path" "PASS"
+else
+	print_test_result "Named bookmark stored with correct name and path" "FAIL" "Name: $saved_name, Path: $saved_path"
+fi
+
+# Test 15: Jump to named bookmark
+result=$(bash "$PLUGIN_SCRIPT" testproject 2>&1)
+if echo "$result" | grep -q "$TEST_DIR_1"; then
+	print_test_result "Jump to named bookmark works" "PASS"
+else
+	print_test_result "Jump to named bookmark works" "FAIL" "Expected path in output"
+fi
+
+# Test 16: Rename numbered bookmark to named
+cd "$TEST_DIR_2" || exit 1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1 # Create unnamed bookmark
+result=$(bash "$PLUGIN_SCRIPT" 1 -n myapp 2>&1)
+if echo "$result" | grep -qi "renamed\|saved\|myapp"; then
+	print_test_result "Rename bookmark 1 to 'myapp'" "PASS"
+else
+	print_test_result "Rename bookmark 1 to 'myapp'" "FAIL" "Expected success message"
+fi
+
+# Test 17: Renamed bookmark accessible by name
+result=$(bash "$PLUGIN_SCRIPT" myapp 2>&1)
+if echo "$result" | grep -q "$TEST_DIR_2"; then
+	print_test_result "Renamed bookmark accessible by name" "PASS"
+else
+	print_test_result "Renamed bookmark accessible by name" "FAIL" "Expected $TEST_DIR_2 in output"
+fi
+
+# Test 18: Duplicate name detection
+result=$(bash "$PLUGIN_SCRIPT" . -n testproject 2>&1)
+if echo "$result" | grep -qi "exists\|duplicate\|already\|error"; then
+	print_test_result "Duplicate bookmark name rejected" "PASS"
+else
+	print_test_result "Duplicate bookmark name rejected" "FAIL" "Should reject duplicate names"
+fi
+
+# Test 19: Invalid name detection (command conflict)
+result=$(bash "$PLUGIN_SCRIPT" . -n ls 2>&1)
+if echo "$result" | grep -qi "invalid\|conflict\|command\|error"; then
+	print_test_result "Invalid name 'ls' rejected (command conflict)" "PASS"
+else
+	print_test_result "Invalid name 'ls' rejected (command conflict)" "FAIL" "Should reject command names"
+fi
+
+# Test 20: Invalid name detection (empty name)
+result=$(bash "$PLUGIN_SCRIPT" . -n "" 2>&1)
+if echo "$result" | grep -qi "invalid\|empty\|error"; then
+	print_test_result "Empty bookmark name rejected" "PASS"
+else
+	print_test_result "Empty bookmark name rejected" "FAIL" "Should reject empty names"
+fi
+
+# ============================================================================
+# LIST VIEW TESTS
+# ============================================================================
+
+# Test 21: List all bookmarks
+result=$(bash "$PLUGIN_SCRIPT" list -n 2>&1)
+if echo "$result" | grep -q "testproject\|myapp"; then
+	print_test_result "bookmark list shows named bookmarks" "PASS"
+else
+	print_test_result "bookmark list shows named bookmarks" "FAIL" "Expected named bookmarks in list"
+fi
+
+# Test 22: List shows unnamed bookmarks
+cd "$TEST_DIR_3" || exit 1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1
+result=$(bash "$PLUGIN_SCRIPT" list -n 2>&1)
+if echo "$result" | grep -qi "unnamed\|recent\|1:"; then
+	print_test_result "bookmark list shows unnamed bookmarks" "PASS"
+else
+	print_test_result "bookmark list shows unnamed bookmarks" "FAIL" "Expected unnamed section"
+fi
+
+# Test 23: List last N bookmarks
+result=$(bash "$PLUGIN_SCRIPT" list 2 2>&1)
+# Check if any test directory appears in the output
+count=0
+for test_dir in "$TEST_DIR_1" "$TEST_DIR_2" "$TEST_DIR_3"; do
+	if echo "$result" | grep -q "$test_dir"; then
+		count=$((count + 1))
+	fi
+done
+if [ "$count" -ge 1 ]; then
+	print_test_result "bookmark list N shows limited results" "PASS"
+else
+	print_test_result "bookmark list N shows limited results" "FAIL" "Expected limited output"
+fi
+
+# ============================================================================
+# ERROR HANDLING TESTS
+# ============================================================================
+
+# Test 24: Invalid argument handling
+result=$(bash "$PLUGIN_SCRIPT" --invalid-flag 2>&1)
+if echo "$result" | grep -qi "invalid\|unknown\|error\|usage"; then
+	print_test_result "Invalid argument shows error/usage" "PASS"
+else
+	print_test_result "Invalid argument shows error/usage" "FAIL" "Should show error message"
+fi
+
+# Test 25: Non-existent bookmark name
+result=$(bash "$PLUGIN_SCRIPT" nonexistent 2>&1)
+if echo "$result" | grep -qi "not found\|doesn't exist\|error"; then
+	print_test_result "Non-existent bookmark name shows error" "PASS"
+else
+	print_test_result "Non-existent bookmark name shows error" "FAIL" "Should show error message"
+fi
+
+# Test 26: Path no longer exists warning
+# Create a bookmark, then delete the directory
+TEMP_DIR=$(mktemp -d)
+cd "$TEMP_DIR" || exit 1
+bash "$PLUGIN_SCRIPT" . -n deleted_dir >/dev/null 2>&1
+rm -rf "$TEMP_DIR"
+result=$(bash "$PLUGIN_SCRIPT" deleted_dir 2>&1)
+if echo "$result" | grep -qi "not exist\|warning\|deleted"; then
+	print_test_result "Warn when bookmark path no longer exists" "PASS"
+else
+	print_test_result "Warn when bookmark path no longer exists" "FAIL" "Should warn about missing path"
+fi
+
+# ============================================================================
+# JSON STRUCTURE TESTS
+# ============================================================================
+
+# Test 27: JSON has correct structure
+if jq -e '.bookmarks.named' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1 &&
+	jq -e '.bookmarks.unnamed' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1; then
+	print_test_result "JSON structure has named and unnamed sections" "PASS"
+else
+	print_test_result "JSON structure has named and unnamed sections" "FAIL" "Missing required sections"
+fi
+
+# Test 28: Named bookmarks have required fields
+has_name=$(jq -e '.bookmarks.named[0].name' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1 && echo "yes" || echo "no")
+has_path=$(jq -e '.bookmarks.named[0].path' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1 && echo "yes" || echo "no")
+has_created=$(jq -e '.bookmarks.named[0].created' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1 && echo "yes" || echo "no")
+if [ "$has_name" = "yes" ] && [ "$has_path" = "yes" ] && [ "$has_created" = "yes" ]; then
+	print_test_result "Named bookmarks have required fields (name, path, created)" "PASS"
+else
+	print_test_result "Named bookmarks have required fields" "FAIL" "Missing fields: name=$has_name path=$has_path created=$has_created"
+fi
+
+# Test 29: Unnamed bookmarks have required fields
+has_id=$(jq -e '.bookmarks.unnamed[0].id' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1 && echo "yes" || echo "no")
+has_path=$(jq -e '.bookmarks.unnamed[0].path' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1 && echo "yes" || echo "no")
+has_created=$(jq -e '.bookmarks.unnamed[0].created' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1 && echo "yes" || echo "no")
+if [ "$has_id" = "yes" ] && [ "$has_path" = "yes" ] && [ "$has_created" = "yes" ]; then
+	print_test_result "Unnamed bookmarks have required fields (id, path, created)" "PASS"
+else
+	print_test_result "Unnamed bookmarks have required fields" "FAIL" "Missing fields: id=$has_id path=$has_path created=$has_created"
+fi
+
+# Test 30: Config section exists
+if jq -e '.config' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1; then
+	print_test_result "JSON has config section" "PASS"
+else
+	print_test_result "JSON has config section" "FAIL" "Missing config section"
+fi
+
+# ============================================================================
+# EDGE CASES
+# ============================================================================
+
+# Test 31: Special characters in path
+SPECIAL_DIR=$(mktemp -d -p /tmp "test dir with spaces-XXXXXX")
+cd "$SPECIAL_DIR" || exit 1
+result=$(bash "$PLUGIN_SCRIPT" . -n special_path 2>&1)
+if echo "$result" | grep -qi "saved"; then
+	print_test_result "Bookmark path with spaces handled correctly" "PASS"
+else
+	print_test_result "Bookmark path with spaces handled correctly" "FAIL" "Failed to save path with spaces"
+fi
+cd "$TEST_DIR_1" || exit 1 # Return to valid directory before cleanup
+rm -rf "$SPECIAL_DIR"
+
+# Test 32: Very long bookmark name
+LONG_NAME="this_is_a_very_long_bookmark_name_that_should_still_work_properly"
+result=$(bash "$PLUGIN_SCRIPT" . -n "$LONG_NAME" 2>&1)
+if echo "$result" | grep -qi "saved"; then
+	print_test_result "Long bookmark name accepted" "PASS"
+else
+	print_test_result "Long bookmark name accepted" "FAIL" "Output: $result"
+fi
+
+# Test 33: Concurrent bookmark creation (race condition test)
+# This is a basic test - in production, file locking would be needed
+cd "$TEST_DIR_1" || exit 1
+bash "$PLUGIN_SCRIPT" . -n concurrent1 >/dev/null 2>&1 &
+bash "$PLUGIN_SCRIPT" . -n concurrent2 >/dev/null 2>&1 &
+wait
+# Just check that file is still valid JSON after concurrent writes
+if jq empty "$TEST_BOOKMARK_FILE" 2>/dev/null; then
+	print_test_result "Concurrent bookmark creation maintains JSON validity" "PASS"
+else
+	print_test_result "Concurrent bookmark creation maintains JSON validity" "FAIL" "JSON corrupted by concurrent writes"
+fi
+
+# ============================================================================
+# CATEGORY TESTS (Phase 2)
+# ============================================================================
+
+# Test 34: Save bookmark with category
+cd "$TEST_DIR_1" || exit 1
+result=$(bash "$PLUGIN_SCRIPT" . -n cattest in projects/test 2>&1)
+if echo "$result" | grep -qi "category.*projects/test"; then
+	print_test_result "Save bookmark with category" "PASS"
+else
+	print_test_result "Save bookmark with category" "FAIL" "Output: $result"
+fi
+
+# Test 35: Category stored correctly in JSON
+category=$(jq -r '.bookmarks.named[] | select(.name == "cattest") | .category' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+if [ "$category" = "projects/test" ]; then
+	print_test_result "Category stored correctly in JSON" "PASS"
+else
+	print_test_result "Category stored correctly in JSON" "FAIL" "Expected 'projects/test', got: $category"
+fi
+
+# Test 36: Rename bookmark with category
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1 # Create unnamed bookmark
+result=$(bash "$PLUGIN_SCRIPT" 1 -n renamedcat in tools 2>&1)
+if echo "$result" | grep -qi "category.*tools"; then
+	print_test_result "Rename bookmark with category" "PASS"
+else
+	print_test_result "Rename bookmark with category" "FAIL" "Output: $result"
+fi
+
+# Test 37: List bookmarks shows categories
+result=$(bash "$PLUGIN_SCRIPT" list -n 2>&1)
+if echo "$result" | grep -qi "projects/test\|tools"; then
+	print_test_result "List bookmarks shows categories" "PASS"
+else
+	print_test_result "List bookmarks shows categories" "FAIL" "Categories not shown in output"
+fi
+
+# Test 38: Filter bookmarks by category
+bash "$PLUGIN_SCRIPT" . -n proj1 in projects/java >/dev/null 2>&1
+bash "$PLUGIN_SCRIPT" . -n proj2 in projects/python >/dev/null 2>&1
+bash "$PLUGIN_SCRIPT" . -n tool1 in tools >/dev/null 2>&1
+result=$(bash "$PLUGIN_SCRIPT" list projects 2>&1)
+# Check for proj1 and proj2 (hierarchical display shows "java" and "python" separately)
+if echo "$result" | grep -q "\[proj1\]" && echo "$result" | grep -q "\[proj2\]" && ! echo "$result" | grep -q "\[tool1\]"; then
+	print_test_result "Filter bookmarks by category" "PASS"
+else
+	print_test_result "Filter bookmarks by category" "FAIL" "Category filter not working"
+fi
+
+# Test 39: Move bookmark to different category
+bash "$PLUGIN_SCRIPT" . -n moveme in oldcat >/dev/null 2>&1
+result=$(bash "$PLUGIN_SCRIPT" mv moveme to newcat 2>&1)
+if echo "$result" | grep -qi "moved.*newcat"; then
+	print_test_result "Move bookmark to different category" "PASS"
+else
+	print_test_result "Move bookmark to different category" "FAIL" "Output: $result"
+fi
+
+# Test 40: Verify moved bookmark has new category
+new_category=$(jq -r '.bookmarks.named[] | select(.name == "moveme") | .category' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+if [ "$new_category" = "newcat" ]; then
+	print_test_result "Moved bookmark has correct new category" "PASS"
+else
+	print_test_result "Moved bookmark has correct new category" "FAIL" "Expected 'newcat', got: $new_category"
+fi
+
+# Test 41: Move non-existent bookmark fails gracefully
+result=$(bash "$PLUGIN_SCRIPT" mv nonexistent to somecat 2>&1)
+if echo "$result" | grep -qi "not found\|error"; then
+	print_test_result "Move non-existent bookmark fails gracefully" "PASS"
+else
+	print_test_result "Move non-existent bookmark fails gracefully" "FAIL" "Should show error"
+fi
+
+# ============================================================================
+# OUTPUT FORMAT & INTEGRATION TESTS
+# ============================================================================
+
+# Test 42: Help output uses echo -e for ANSI codes (not raw \033)
+# This ensures colors work properly when displayed
+help_output=$(bash "$PLUGIN_SCRIPT" --help 2>&1)
+if echo "$help_output" | grep -q '\\033'; then
+	print_test_result "Help output doesn't contain raw ANSI codes" "FAIL" "Found raw \\033 codes - need echo -e"
+else
+	print_test_result "Help output doesn't contain raw ANSI codes" "PASS"
+fi
+
+# Test 43: Jump command outputs valid cd command for shell sourcing
+cd "$TEST_DIR_1" || exit 1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1 # Create a bookmark
+jump_output=$(bash "$PLUGIN_SCRIPT" 1 2>&1)
+if echo "$jump_output" | grep -q '^cd "'; then
+	print_test_result "Jump command outputs valid cd command" "PASS"
+else
+	print_test_result "Jump command outputs valid cd command" "FAIL" "Expected 'cd \"path\"' format, got: $jump_output"
+fi
+
+# Test 44: Jump command output is eval-safe (properly quoted path)
+cd "$TEST_DIR_WITH_SPACES" || exit 1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1 # Save path with spaces
+jump_output=$(bash "$PLUGIN_SCRIPT" 1 2>&1)
+cd_line=$(echo "$jump_output" | grep '^cd ')
+if [ -n "$cd_line" ]; then
+	# Try to eval the cd command (should not fail even with spaces)
+	if eval "$cd_line" 2>/dev/null; then
+		print_test_result "Jump command handles paths with spaces correctly" "PASS"
+	else
+		print_test_result "Jump command handles paths with spaces correctly" "FAIL" "eval failed on: $cd_line"
+	fi
+else
+	print_test_result "Jump command handles paths with spaces correctly" "FAIL" "No cd command in output"
+fi
+
+# Test 45: Named bookmark jump also outputs cd command
+bash "$PLUGIN_SCRIPT" . -n testjump >/dev/null 2>&1
+jump_output=$(bash "$PLUGIN_SCRIPT" testjump 2>&1)
+if echo "$jump_output" | grep -q '^cd "'; then
+	print_test_result "Named bookmark jump outputs cd command" "PASS"
+else
+	print_test_result "Named bookmark jump outputs cd command" "FAIL" "Expected 'cd \"path\"', got: $jump_output"
+fi
+
+# Test 46: List command output uses echo -e for colors
+bash "$PLUGIN_SCRIPT" . -n colortest in testcat >/dev/null 2>&1
+list_output=$(bash "$PLUGIN_SCRIPT" list -n 2>&1)
+if echo "$list_output" | grep -q '\\033'; then
+	print_test_result "List output doesn't contain raw ANSI codes" "FAIL" "Found raw \\033 codes"
+else
+	print_test_result "List output doesn't contain raw ANSI codes" "PASS"
+fi
+
+# Test 47: Error messages use echo -e for colored output
+error_output=$(bash "$PLUGIN_SCRIPT" nonexistent 2>&1)
+if echo "$error_output" | grep -q '\\033'; then
+	print_test_result "Error messages don't contain raw ANSI codes" "FAIL" "Found raw \\033 codes"
+else
+	print_test_result "Error messages don't contain raw ANSI codes" "PASS"
+fi
+
+# ============================================================================
+# PHASE 3: BOOKMARK MANAGEMENT (rm, clear)
+# ============================================================================
+
+# Test 48: Remove named bookmark
+cd "$TEST_DIR_1" || exit 1
+bash "$PLUGIN_SCRIPT" . -n rmtest >/dev/null 2>&1
+result=$(bash "$PLUGIN_SCRIPT" rm rmtest 2>&1)
+if echo "$result" | grep -qi "removed.*rmtest"; then
+	print_test_result "Remove named bookmark" "PASS"
+else
+	print_test_result "Remove named bookmark" "FAIL" "Output: $result"
+fi
+
+# Test 49: Verify bookmark was removed from JSON
+if jq -e '.bookmarks.named[] | select(.name == "rmtest")' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1; then
+	print_test_result "Named bookmark removed from JSON" "FAIL" "Bookmark still exists in JSON"
+else
+	print_test_result "Named bookmark removed from JSON" "PASS"
+fi
+
+# Test 50: Remove numbered bookmark and verify re-numbering
+cd "$TEST_DIR_1" || exit 1
+# Clear unnamed bookmarks first to have clean state
+jq '.bookmarks.unnamed = []' "$TEST_BOOKMARK_FILE" >"$TEST_BOOKMARK_FILE.tmp" && mv "$TEST_BOOKMARK_FILE.tmp" "$TEST_BOOKMARK_FILE"
+# Create 3 numbered bookmarks
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1
+cd "$TEST_DIR_2" || exit 1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1
+cd "$TEST_DIR_3" || exit 1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1
+# Now we have bookmarks 1, 2, 3
+result=$(bash "$PLUGIN_SCRIPT" rm 1 2>&1)
+if echo "$result" | grep -qi "removed.*#1"; then
+	print_test_result "Remove numbered bookmark" "PASS"
+else
+	print_test_result "Remove numbered bookmark" "FAIL" "Output: $result"
+fi
+
+# Test 51: Verify re-numbering happened (should now have IDs 1 and 2 instead of 2 and 3)
+count=$(jq '.bookmarks.unnamed | length' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+if [ "$count" -eq 2 ]; then
+	# Check that IDs are 1 and 2 (re-numbered)
+	id1_exists=$(jq -e '.bookmarks.unnamed[] | select(.id == 1)' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1 && echo "yes" || echo "no")
+	id2_exists=$(jq -e '.bookmarks.unnamed[] | select(.id == 2)' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1 && echo "yes" || echo "no")
+	id3_exists=$(jq -e '.bookmarks.unnamed[] | select(.id == 3)' "$TEST_BOOKMARK_FILE" >/dev/null 2>&1 && echo "yes" || echo "no")
+
+	if [ "$id1_exists" = "yes" ] && [ "$id2_exists" = "yes" ] && [ "$id3_exists" = "no" ]; then
+		print_test_result "Numbered bookmark removed from JSON" "PASS"
+	else
+		print_test_result "Numbered bookmark removed from JSON" "FAIL" "Re-numbering didn't work correctly"
+	fi
+else
+	print_test_result "Numbered bookmark removed from JSON" "FAIL" "Expected 2 bookmarks, got $count"
+fi
+
+# Test 52: Remove non-existent bookmark fails gracefully
+result=$(bash "$PLUGIN_SCRIPT" rm nonexistent 2>&1)
+if echo "$result" | grep -qi "not found\|error"; then
+	print_test_result "Remove non-existent bookmark fails gracefully" "PASS"
+else
+	print_test_result "Remove non-existent bookmark fails gracefully" "FAIL" "Should show error"
+fi
+
+# Test 53: Clear command with no unnamed bookmarks
+jq '.bookmarks.unnamed = []' "$TEST_BOOKMARK_FILE" >"$TEST_BOOKMARK_FILE.tmp" && mv "$TEST_BOOKMARK_FILE.tmp" "$TEST_BOOKMARK_FILE"
+result=$(echo "n" | bash "$PLUGIN_SCRIPT" clear 2>&1)
+if echo "$result" | grep -qi "no unnamed bookmarks"; then
+	print_test_result "Clear command with no unnamed bookmarks" "PASS"
+else
+	print_test_result "Clear command with no unnamed bookmarks" "FAIL" "Output: $result"
+fi
+
+# Test 54: Clear unnamed bookmarks (with confirmation)
+cd "$TEST_DIR_1" || exit 1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1
+# Confirm with 'y'
+result=$(echo "y" | bash "$PLUGIN_SCRIPT" clear 2>&1)
+if echo "$result" | grep -qi "cleared.*3.*unnamed"; then
+	print_test_result "Clear unnamed bookmarks with confirmation" "PASS"
+else
+	print_test_result "Clear unnamed bookmarks with confirmation" "FAIL" "Output: $result"
+fi
+
+# Test 55: Verify unnamed bookmarks were cleared
+count=$(jq '.bookmarks.unnamed | length' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+if [ "$count" -eq 0 ]; then
+	print_test_result "Unnamed bookmarks cleared from JSON" "PASS"
+else
+	print_test_result "Unnamed bookmarks cleared from JSON" "FAIL" "Expected 0, got: $count"
+fi
+
+# Test 56: Clear cancelled by user
+cd "$TEST_DIR_1" || exit 1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1
+# Cancel with 'n'
+result=$(echo "n" | bash "$PLUGIN_SCRIPT" clear 2>&1)
+if echo "$result" | grep -qi "cancelled"; then
+	print_test_result "Clear cancelled by user" "PASS"
+else
+	print_test_result "Clear cancelled by user" "FAIL" "Should show 'Cancelled'"
+fi
+
+# Test 57: Verify bookmarks not cleared after cancellation
+count=$(jq '.bookmarks.unnamed | length' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+if [ "$count" -eq 2 ]; then
+	print_test_result "Bookmarks preserved after cancel" "PASS"
+else
+	print_test_result "Bookmarks preserved after cancel" "FAIL" "Expected 2, got: $count"
+fi
+
+# ============================================================================
+# PHASE 3: BOOKMARK EDIT & SEARCH
+# ============================================================================
+
+# Test 58: Edit bookmark - change name only
+cd "$TEST_DIR_1" || exit 1
+bash "$PLUGIN_SCRIPT" . -n editme >/dev/null 2>&1
+# Input: newname (for name), empty (keep path), empty (no category)
+result=$(echo -e "newname\n\n" | bash "$PLUGIN_SCRIPT" edit editme 2>&1)
+if echo "$result" | grep -qi "updated"; then
+	print_test_result "Edit bookmark - change name" "PASS"
+else
+	print_test_result "Edit bookmark - change name" "FAIL" "Output: $result"
+fi
+
+# Test 59: Verify edited bookmark name in JSON
+new_name=$(jq -r '.bookmarks.named[] | select(.name == "newname") | .name' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+if [ "$new_name" = "newname" ]; then
+	print_test_result "Edited bookmark name updated in JSON" "PASS"
+else
+	print_test_result "Edited bookmark name updated in JSON" "FAIL" "Expected 'newname', got: $new_name"
+fi
+
+# Test 60: Edit non-existent bookmark fails
+result=$(bash "$PLUGIN_SCRIPT" edit nonexistent 2>&1)
+if echo "$result" | grep -qi "not found\|error"; then
+	print_test_result "Edit non-existent bookmark fails gracefully" "PASS"
+else
+	print_test_result "Edit non-existent bookmark fails gracefully" "FAIL" "Should show error"
+fi
+
+# Test 61: Find bookmarks by name pattern
+cd "$TEST_DIR_1" || exit 1
+bash "$PLUGIN_SCRIPT" . -n searchtest1 in tools >/dev/null 2>&1
+bash "$PLUGIN_SCRIPT" . -n searchtest2 in projects >/dev/null 2>&1
+bash "$PLUGIN_SCRIPT" . -n other in tools >/dev/null 2>&1
+result=$(bash "$PLUGIN_SCRIPT" find "search" 2>&1)
+# Check if at least one searchtest bookmark is found
+if echo "$result" | grep -q "searchtest"; then
+	print_test_result "Find bookmarks by name pattern" "PASS"
+else
+	print_test_result "Find bookmarks by name pattern" "FAIL" "Output: $result"
+fi
+
+# Test 62: Find bookmarks by category
+result=$(bash "$PLUGIN_SCRIPT" find tools 2>&1)
+if echo "$result" | grep -qi "tools"; then
+	print_test_result "Find bookmarks by category" "PASS"
+else
+	print_test_result "Find bookmarks by category" "FAIL" "Should find bookmarks in tools category"
+fi
+
+# Test 63: Find bookmarks by path
+result=$(bash "$PLUGIN_SCRIPT" find "$TEST_DIR_1" 2>&1)
+if echo "$result" | grep -qi "$(basename "$TEST_DIR_1")"; then
+	print_test_result "Find bookmarks by path" "PASS"
+else
+	print_test_result "Find bookmarks by path" "FAIL" "Should find bookmarks matching path"
+fi
+
+# Test 64: Find with no matches
+result=$(bash "$PLUGIN_SCRIPT" find "xyznonexistentpattern987654321xyz" 2>&1)
+# Case insensitive check
+if echo "$result" | grep -qi "no bookmarks found"; then
+	print_test_result "Find with no matches shows appropriate message" "PASS"
+else
+	print_test_result "Find with no matches shows appropriate message" "FAIL" "Output: $result"
+fi
+
+# Test 65: Find without pattern fails
+result=$(bash "$PLUGIN_SCRIPT" find 2>&1)
+if echo "$result" | grep -qi "pattern required\|error"; then
+	print_test_result "Find without pattern shows error" "PASS"
+else
+	print_test_result "Find without pattern shows error" "FAIL" "Should require pattern"
+fi
+
+# ============================================================================
+# INTERACTIVE LIST - Function exists check (requires manual testing)
+# ============================================================================
+
+# Test 66: Interactive list function exists in script
+if grep -q "interactive_list()" "$PLUGIN_SCRIPT"; then
+	print_test_result "Interactive list function exists" "PASS"
+else
+	print_test_result "Interactive list function exists" "FAIL" "Function not found"
+fi
+
+# Test 67: Non-interactive list flag handling in list_bookmarks (changed from --interactive to --non-interactive)
+if grep -q -- '--non-interactive' "$PLUGIN_SCRIPT" && grep -q 'interactive_list' "$PLUGIN_SCRIPT"; then
+	print_test_result "Non-interactive list flag handling present" "PASS"
+else
+	print_test_result "Non-interactive list flag handling present" "FAIL" "Flag handling not found"
+fi
+
+# ============================================================================
+# BUG FIXES - Issue-specific tests
+# ============================================================================
+
+# Test 68: Edit prompt order (echo -n before read, not read -rp)
+if grep -q 'echo -n.*New name' "$PLUGIN_SCRIPT" && ! grep -q 'read -rp.*New name' "$PLUGIN_SCRIPT"; then
+	print_test_result "Edit uses proper prompt order (echo -n + read)" "PASS"
+else
+	print_test_result "Edit uses proper prompt order (echo -n + read)" "FAIL" "Should use echo -n before read, not read -rp"
+fi
+
+# Test 69: Interactive list TTY check and /dev/tty fallback
+if grep -q '/dev/tty' "$PLUGIN_SCRIPT" && grep -q '\[ ! -t 0 \]' "$PLUGIN_SCRIPT"; then
+	print_test_result "Interactive list has TTY check and /dev/tty fallback" "PASS"
+else
+	print_test_result "Interactive list has TTY check and /dev/tty fallback" "FAIL" "Missing TTY check or /dev/tty fallback"
+fi
+
+# Test 70: Hierarchical category display (check for IFS='/' split)
+if grep -q "IFS='/'" "$PLUGIN_SCRIPT" && grep -q 'parts' "$PLUGIN_SCRIPT"; then
+	print_test_result "Hierarchical category parsing exists" "PASS"
+else
+	print_test_result "Hierarchical category parsing exists" "FAIL" "Missing category hierarchy logic"
+fi
+
+# Test 71: Hierarchical category test with real data
+cd "$TEST_DIR_1" || exit 1
+bash "$PLUGIN_SCRIPT" . -n bookmark1 in aaa/bbb >/dev/null 2>&1
+bash "$PLUGIN_SCRIPT" . -n bookmark2 in aaa/bbb/ccc >/dev/null 2>&1
+bash "$PLUGIN_SCRIPT" . -n bookmark3 in aaa >/dev/null 2>&1
+result=$(bash "$PLUGIN_SCRIPT" list -n 2>&1)
+# Check if hierarchy is displayed (aaa should appear, then bbb under it, then ccc under bbb)
+if echo "$result" | grep -q "📂 aaa" && echo "$result" | grep -q "📂 bbb" && echo "$result" | grep -q "📂 ccc"; then
+	print_test_result "Hierarchical category display works" "PASS"
+else
+	print_test_result "Hierarchical category display works" "FAIL" "Categories not displayed hierarchically"
+fi
+
+# Test 72: Interactive mode /dev/tty reading (manual test required)
+# Note: Interactive mode reads from /dev/tty which bypasses piped input
+# This test verifies the code paths exist, but full testing requires manual verification
+if grep -q 'read.*< */dev/tty' "$PLUGIN_SCRIPT"; then
+	print_test_result "Interactive mode uses /dev/tty for input" "PASS"
+else
+	print_test_result "Interactive mode uses /dev/tty for input" "FAIL" "Missing /dev/tty input redirection"
+fi
+
+# Test 73: Wrapper function handles interactive mode cd (ranger-style fixed temp file)
+# Test 73: Wrapper function uses unique temp file per invocation with environment variable
+# The wrapper should use mktemp to create unique temp files and export MLH_BOOKMARK_CD_FILE
+setup_script="$ROOT_DIR/setup.sh"
+if [ -f "$setup_script" ]; then
+	# Extract the wrapper function from setup.sh
+	wrapper_content=$(sed -n '/# MyLinuxHelper - bookmark wrapper function/,/^}/p' "$setup_script" 2>/dev/null)
+
+	# Check if interactive mode handling uses unique temp file with environment variable
+	# The fix should:
+	# 1. Use mktemp to create unique temp file: tmp_cd_file=$(mktemp ...)
+	# 2. Export environment variable: export MLH_BOOKMARK_CD_FILE="$tmp_cd_file"
+	# 3. Run command directly: command bookmark "$@" (not captured)
+	# 4. Poll for file existence: while loop checking if file exists
+	# 5. Source the temp file if exists: source "$tmp_cd_file"
+	# 6. Clean up: rm -f "$tmp_cd_file" and unset MLH_BOOKMARK_CD_FILE
+
+	if echo "$wrapper_content" | grep -A 20 'interactive' | grep -q 'mktemp' &&
+		echo "$wrapper_content" | grep -A 20 'interactive' | grep -q 'MLH_BOOKMARK_CD_FILE' &&
+		echo "$wrapper_content" | grep -A 20 'interactive' | grep -q 'export.*MLH_BOOKMARK_CD_FILE' &&
+		echo "$wrapper_content" | grep -A 20 'interactive' | grep -q 'source.*tmp_cd_file'; then
+		print_test_result "Wrapper function uses unique temp file with environment variable for cd" "PASS"
+	else
+		print_test_result "Wrapper function uses unique temp file with environment variable for cd" "FAIL" "Interactive mode should use mktemp and export MLH_BOOKMARK_CD_FILE"
+	fi
+else
+	print_test_result "Wrapper function uses unique temp file with environment variable for cd" "SKIP" "setup.sh not found"
+fi
+
+# Test 74: Plugin code uses environment variable for temp file in interactive mode
+# Check that the Enter key handler in interactive mode uses MLH_BOOKMARK_CD_FILE if available
+plugin_file="$ROOT_DIR/plugins/mlh-bookmark.sh"
+if [ -f "$plugin_file" ]; then
+	# Check for the environment variable usage in interactive Enter handler
+	# Should contain: tmp_cd_file="${MLH_BOOKMARK_CD_FILE:-/tmp/bookmark-cd-${USER:-$(id -un)}}"
+	# Should contain: printf 'cd "%s"\n' "$bookmark_path" > "$tmp_cd_file"
+	# Should contain: atomic write with mv (tmp file then move)
+	if grep -A 10 "# Write cd command to temp file" "$plugin_file" | grep -q 'MLH_BOOKMARK_CD_FILE' &&
+		grep -A 10 "# Write cd command to temp file" "$plugin_file" | grep -q 'printf.*cd' &&
+		grep -A 10 "# Write cd command to temp file" "$plugin_file" | grep -q 'mv.*tmp_cd_file'; then
+		print_test_result "Plugin uses environment variable for temp file on bookmark selection" "PASS"
+	else
+		print_test_result "Plugin uses environment variable for temp file on bookmark selection" "FAIL" "Interactive mode should use MLH_BOOKMARK_CD_FILE env var and atomic write"
+	fi
+else
+	print_test_result "Plugin uses environment variable for temp file on bookmark selection" "SKIP" "mlh-bookmark.sh not found"
+fi
+
+# Test 74b: Wrapper function handles default interactive mode
+# PR branch: bookmark list defaults to interactive mode (no -i flag needed)
+# Wrapper function should detect this and handle cd correctly
+wrapper_file="$ROOT_DIR/setup.sh"
+if [ -f "$wrapper_file" ]; then
+	wrapper_content=$(sed -n '/# MyLinuxHelper - bookmark wrapper function/,/^}/p' "$wrapper_file" 2>/dev/null)
+	# Check if wrapper handles "bookmark list" (without -i) as interactive
+	# The wrapper should check for list command and handle default interactive mode
+	# Should NOT require explicit -i flag when list defaults to interactive
+	# shellcheck disable=SC2016
+	if echo "$wrapper_content" | grep -A 40 "bookmark()" | grep -A 20 "list" | grep -qE '\[.*"\$cmd".*=.*"list".*\]'; then
+		# Wrapper checks for list command
+		# Check if it handles default interactive mode (not just explicit -i flag)
+		# Should handle: bookmark list (no args) as interactive
+		# Should exclude: bookmark list -n (non-interactive)
+		# Should exclude: bookmark list 5 (number limit, non-interactive)
+		# shellcheck disable=SC2016
+		if echo "$wrapper_content" | grep -A 40 "bookmark()" | grep -A 20 "list" | grep -qE '\[.*"\$2".*=.*"-n".*\]|\[.*"\$2".*=.*"--non-interactive".*\]'; then
+			# Wrapper excludes non-interactive flags
+			# Check if it handles default case (no -n flag) as interactive
+			if echo "$wrapper_content" | grep -A 40 "bookmark()" | grep -A 20 "list" | grep -qE 'MLH_BOOKMARK_CD_FILE|tmp_cd_file'; then
+				print_test_result "Wrapper function handles default interactive mode (bookmark list without -i)" "PASS" "Wrapper correctly handles default interactive mode for bookmark list"
+			else
+				print_test_result "Wrapper function handles default interactive mode (bookmark list without -i)" "FAIL" "Wrapper checks for list but doesn't set up temp file for default interactive mode"
+			fi
+		else
+			print_test_result "Wrapper function handles default interactive mode (bookmark list without -i)" "FAIL" "Wrapper doesn't exclude non-interactive flags properly"
+		fi
+	else
+		print_test_result "Wrapper function handles default interactive mode (bookmark list without -i)" "FAIL" "Wrapper doesn't check for list command"
+	fi
+else
+	print_test_result "Wrapper function handles default interactive mode (bookmark list without -i)" "SKIP" "setup.sh not found"
+fi
+
+# ============================================================================
+# INTERACTIVE MODE CD TEST - Issue #5: Second invocation fails
+# ============================================================================
+
+# Test 75: Interactive mode cd works on first invocation
+# This test uses tmux to create a real terminal session and test interactive mode
+# Expected: PASS (first invocation works)
+
+# Check if tmux is available (install if needed)
+TMUX_AVAILABLE=0
+if command -v tmux >/dev/null 2>&1; then
+	TMUX_AVAILABLE=1
+else
+	# Try to install tmux
+	if [ -f "$ROOT_DIR/install.sh" ]; then
+		bash "$ROOT_DIR/install.sh" tmux >/dev/null 2>&1
+		if command -v tmux >/dev/null 2>&1; then
+			TMUX_AVAILABLE=1
+		fi
+	fi
+fi
+
+if [ "$TMUX_AVAILABLE" -eq 0 ]; then
+	print_test_result "Interactive mode cd on first invocation (tmux required)" "SKIP" "tmux not available - install with: apt-get install tmux"
+else
+	# Create test bookmark file and directory for this test
+	test75_bookmark_file="/tmp/test-bookmark-75-$$"
+	test_bookmark_dir=$(mktemp -d)
+	cd "$test_bookmark_dir" || exit 1
+
+	# Create bookmark in test file
+	MLH_BOOKMARK_FILE="$test75_bookmark_file" bash "$PLUGIN_SCRIPT" . -n test75bookmark >/dev/null 2>&1
+
+	# Create a different starting directory
+	start_dir=$(mktemp -d)
+
+	# Create unique session name
+	session_name="test-bookmark-75-$$"
+
+	# Kill any existing session with same name
+	tmux kill-session -t "$session_name" 2>/dev/null || true
+
+	# Create tmux session with bash -i (interactive, loads .bashrc)
+	# Pass environment variable to tmux session
+	# IMPORTANT: Must load fresh setup.sh to get latest wrapper function
+	# NOTE: Don't use 'exec bash -i' because it replaces the shell and loses function definitions!
+	tmux new-session -d -s "$session_name" "source '$ROOT_DIR/setup.sh'; export MLH_BOOKMARK_FILE='$test75_bookmark_file'; bash -i"
+	sleep 1.5
+
+	# Send commands to tmux session
+	tmux send-keys -t "$session_name" "cd '$start_dir'" C-m
+	sleep 0.2
+	tmux send-keys -t "$session_name" "pwd > /tmp/pwd-before-75-$$" C-m
+	sleep 0.2
+
+	# Start interactive bookmark list (default interactive mode - no -i flag needed in PR branch)
+	# PR branch: bookmark list defaults to interactive mode
+	# This tests that wrapper function works with default interactive mode
+	tmux send-keys -t "$session_name" "bookmark list" C-m
+	sleep 0.5
+
+	# Press Enter to select first bookmark (which should be test75bookmark)
+	tmux send-keys -t "$session_name" "" C-m
+	sleep 1.0
+
+	# Exit interactive mode - try multiple methods
+	# First try 'q' followed by Enter
+	tmux send-keys -t "$session_name" "q"
+	sleep 0.2
+	tmux send-keys -t "$session_name" C-m
+	sleep 0.3
+	# If that doesn't work, try ESC
+	tmux send-keys -t "$session_name" Escape
+	sleep 0.3
+	# Last resort: Ctrl+C
+	tmux send-keys -t "$session_name" C-c
+	sleep 0.5
+
+	# Get PWD after
+	tmux send-keys -t "$session_name" "pwd > /tmp/pwd-after-75-$$" C-m
+	sleep 0.2
+
+	# Exit tmux session
+	tmux send-keys -t "$session_name" "exit" C-m
+	sleep 0.2
+
+	# Kill session
+	tmux kill-session -t "$session_name" 2>/dev/null || true
+
+	# Compare PWDs
+	pwd_before=$(cat /tmp/pwd-before-75-$$ 2>/dev/null || echo "")
+	pwd_after=$(cat /tmp/pwd-after-75-$$ 2>/dev/null || echo "")
+
+	# Cleanup temp files ONLY (keep directories until after PWD comparison)
+	rm -f /tmp/pwd-before-75-$$ /tmp/pwd-after-75-$$ "$test75_bookmark_file" 2>/dev/null || true
+	# Note: Don't remove directories yet - they're needed for cd to work
+	# Cleanup will happen at test suite end via cleanup_bookmark_tests
+
+	if [ -n "$pwd_before" ] && [ -n "$pwd_after" ] && [ "$pwd_before" != "$pwd_after" ]; then
+		print_test_result "Interactive mode cd on first invocation" "PASS" "Directory changed: $pwd_before -> $pwd_after"
+	else
+		print_test_result "Interactive mode cd on first invocation" "FAIL" "Directory didn't change. Before: '$pwd_before', After: '$pwd_after'"
+	fi
+fi
+
+# Test 76: Interactive mode cd on second invocation (Issue #5)
+# Note: This is a known issue being tracked separately
+
+# Test 77: Interactive mode cd on second INVOCATION (not same session)
+# This test uses tmux to test: calling bookmark list -i TWICE (separate invocations)
+# Expected: PASS (each invocation should work independently)
+
+# Check if tmux is available
+TMUX_AVAILABLE_77=0
+if command -v tmux >/dev/null 2>&1; then
+	TMUX_AVAILABLE_77=1
+else
+	# Try to install tmux
+	if [ -f "$ROOT_DIR/install.sh" ]; then
+		bash "$ROOT_DIR/install.sh" tmux >/dev/null 2>&1
+		if command -v tmux >/dev/null 2>&1; then
+			TMUX_AVAILABLE_77=1
+		fi
+	fi
+fi
+
+if [ "$TMUX_AVAILABLE_77" -eq 0 ]; then
+	# Mark as FAIL because bug exists even if we can't test it
+	print_test_result "Interactive mode cd bug on second invocation (Issue #5 - tmux required)" "FAIL" "tmux not available - install with: apt-get install tmux. Bug exists: second invocation doesn't change directory"
+else
+	# Create test bookmark file and directories for this test
+	test77_bookmark_file="/tmp/test-bookmark-77-$$"
+	test_bookmark_dir1_77=$(mktemp -d)
+	test_bookmark_dir2_77=$(mktemp -d)
+
+	# Create TWO bookmarks for this test (to select twice in same session)
+	cd "$test_bookmark_dir1_77" || exit 1
+	MLH_BOOKMARK_FILE="$test77_bookmark_file" bash "$PLUGIN_SCRIPT" . -n bm1_77 >/dev/null 2>&1
+	cd "$test_bookmark_dir2_77" || exit 1
+	MLH_BOOKMARK_FILE="$test77_bookmark_file" bash "$PLUGIN_SCRIPT" . -n bm2_77 >/dev/null 2>&1
+
+	# Create a different starting directory
+	start_dir_77=$(mktemp -d)
+
+	# Create unique session name
+	session_name_77="test-bookmark-77-$$"
+
+	# Kill any existing session with same name
+	tmux kill-session -t "$session_name_77" 2>/dev/null || true
+
+	# Create tmux session with bash -i (interactive, loads .bashrc)
+	# Pass environment variable to tmux session
+	# IMPORTANT: Must load fresh setup.sh to get latest wrapper function
+	# NOTE: Don't use 'exec bash -i' because it replaces the shell and loses function definitions!
+	tmux new-session -d -s "$session_name_77" "source '$ROOT_DIR/setup.sh'; export MLH_BOOKMARK_FILE='$test77_bookmark_file'; bash -i"
+	sleep 1.5
+
+	# === TEST: TWO SEPARATE INVOCATIONS (not same session) ===
+	# Start from a known directory
+	tmux send-keys -t "$session_name_77" "cd '$start_dir_77'" C-m
+	sleep 0.3
+	tmux send-keys -t "$session_name_77" "pwd > /tmp/pwd-start-77-$$" C-m
+	sleep 0.3
+
+	# FIRST INVOCATION: bookmark list (default interactive mode in PR branch), select first bookmark
+	tmux send-keys -t "$session_name_77" "bookmark list" C-m
+	sleep 1.0
+	tmux send-keys -t "$session_name_77" "" C-m # Enter - select first bookmark
+	sleep 1.2
+	tmux send-keys -t "$session_name_77" "pwd > /tmp/pwd-after-first-77-$$" C-m
+	sleep 0.3
+
+	# SECOND INVOCATION: bookmark list again (default interactive mode), select second bookmark
+	tmux send-keys -t "$session_name_77" "bookmark list" C-m
+	sleep 1.0
+	tmux send-keys -t "$session_name_77" "Down" C-m # Navigate to second bookmark
+	sleep 0.5
+	tmux send-keys -t "$session_name_77" "" C-m # Enter - select second bookmark
+	sleep 1.2
+	tmux send-keys -t "$session_name_77" "pwd > /tmp/pwd-final-77-$$" C-m
+	sleep 0.3
+
+	# Exit tmux session
+	tmux send-keys -t "$session_name_77" "exit" C-m
+	sleep 0.2
+
+	# Kill session
+	tmux kill-session -t "$session_name_77" 2>/dev/null || true
+
+	# Read PWDs
+	pwd_start=$(cat /tmp/pwd-start-77-$$ 2>/dev/null || echo "")
+	pwd_after_first=$(cat /tmp/pwd-after-first-77-$$ 2>/dev/null || echo "")
+	pwd_final=$(cat /tmp/pwd-final-77-$$ 2>/dev/null || echo "")
+
+	# Cleanup
+	rm -f /tmp/pwd-start-77-$$ /tmp/pwd-after-first-77-$$ /tmp/pwd-final-77-$$ 2>/dev/null || true
+	rm -f "$test77_bookmark_file" 2>/dev/null || true
+	rm -rf "$test_bookmark_dir1_77" "$test_bookmark_dir2_77" "$start_dir_77" 2>/dev/null || true
+
+	# Test logic:
+	# After TWO SEPARATE invocations, PWD should change both times
+	#   Start: $start_dir_77
+	#   After first: $test_bookmark_dir1_77 (first bookmark)
+	#   Final: $test_bookmark_dir2_77 (second bookmark)
+
+	# Check if both invocations worked
+	first_worked="no"
+	if [ "$pwd_after_first" = "$test_bookmark_dir1_77" ]; then
+		first_worked="yes"
+	fi
+
+	second_worked="no"
+	if [ "$pwd_final" = "$test_bookmark_dir2_77" ]; then
+		second_worked="yes"
+	fi
+
+	if [ "$first_worked" = "yes" ] && [ "$second_worked" = "yes" ]; then
+		print_test_result "Interactive mode cd on second invocation (Issue #5)" "PASS" "Both invocations work! Start: $pwd_start -> 1st: $pwd_after_first -> 2nd: $pwd_final"
+	elif [ "$first_worked" = "yes" ]; then
+		print_test_result "Interactive mode cd on second invocation (Issue #5)" "FAIL" "First works, second doesn't. Start: $pwd_start -> 1st: $pwd_after_first -> 2nd: $pwd_final (expected: $test_bookmark_dir2_77)"
+	else
+		print_test_result "Interactive mode cd on second invocation (Issue #5)" "FAIL" "First invocation failed. Start: $pwd_start, After 1st: $pwd_after_first, Final: $pwd_final"
+	fi
+fi
+
+# ============================================================================
+# BUG FIX: Categorized bookmark navigation in interactive mode (Issue #6)
+# ============================================================================
+
+# Test 78: Named bookmark with category can be jumped to (non-interactive)
+cd "$TEST_DIR_1" || exit 1
+rm -f "$TEST_BOOKMARK_FILE" # Reset
+bash "$PLUGIN_SCRIPT" . -n testcat1 in cat1/cat2 >/dev/null 2>&1
+result=$(bash "$PLUGIN_SCRIPT" testcat1 2>&1)
+if echo "$result" | grep -q "$TEST_DIR_1"; then
+	print_test_result "Jump to categorized named bookmark (non-interactive)" "PASS"
+else
+	print_test_result "Jump to categorized named bookmark (non-interactive)" "FAIL" "Expected $TEST_DIR_1 in output, got: $result"
+fi
+
+# Test 79: Interactive mode - jq query handles named bookmarks correctly
+# This tests the jq query used in interactive mode
+cd "$TEST_DIR_1" || exit 1
+rm -f "$TEST_BOOKMARK_FILE" # Reset
+bash "$PLUGIN_SCRIPT" . -n a123 in aaa/bbb >/dev/null 2>&1
+bash "$PLUGIN_SCRIPT" . -n mesela in cart/curt >/dev/null 2>&1
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1 # Unnamed bookmark
+bash "$PLUGIN_SCRIPT" . >/dev/null 2>&1 # Another unnamed
+
+# Test the jq query that's used in interactive mode for named bookmarks
+named_path=$(jq -r --arg id "a123" '
+	(.bookmarks.unnamed[] | select(.id == (try ($id | tonumber) catch null)) | .path) //
+	(.bookmarks.named[] | select(.name == $id) | .path) //
+	empty
+' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+
+if [ "$named_path" = "$TEST_DIR_1" ]; then
+	print_test_result "Interactive mode jq query finds named bookmark" "PASS"
+else
+	print_test_result "Interactive mode jq query finds named bookmark" "FAIL" "Expected: $TEST_DIR_1, Got: '$named_path'"
+fi
+
+# Test 80: Interactive mode jq query doesn't fail on named bookmark strings
+# When tonumber fails, the query should still work
+unnamed_path=$(jq -r --arg id "1" '
+	(.bookmarks.unnamed[] | select(.id == (try ($id | tonumber) catch null)) | .path) //
+	(.bookmarks.named[] | select(.name == $id) | .path) //
+	empty
+' "$TEST_BOOKMARK_FILE" 2>/dev/null)
+
+if [ -n "$unnamed_path" ] && [ "$unnamed_path" != "null" ]; then
+	print_test_result "Interactive mode jq query finds unnamed bookmark" "PASS"
+else
+	print_test_result "Interactive mode jq query finds unnamed bookmark" "FAIL" "Got empty or null path"
+fi
+
+# Cleanup
+cleanup_bookmark_tests
diff --git a/tests/test b/tests/test
old mode 100644
new mode 100755
index a630fe1..5c750b4
--- a/tests/test
+++ b/tests/test
@@ -17,11 +17,23 @@ NC='\033[0m' # No Color
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT_DIR="$(dirname "$SCRIPT_DIR")"
 
-# Test statistics
-TOTAL_TESTS=0
-PASSED_TESTS=0
-FAILED_TESTS=0
-SKIPPED_TESTS=0
+# Test statistics (use temp file for cross-subshell communication)
+STATS_FILE=$(mktemp)
+echo "0 0 0 0" >"$STATS_FILE" # total passed failed skipped
+
+# Suite statistics file (one line per suite: suite_name total passed failed skipped)
+SUITE_STATS_FILE=$(mktemp)
+
+# Cleanup stats files on exit
+trap "rm -f '$STATS_FILE' '$SUITE_STATS_FILE'" EXIT
+
+load_stats() {
+	read -r TOTAL_TESTS PASSED_TESTS FAILED_TESTS SKIPPED_TESTS <"$STATS_FILE"
+}
+
+save_stats() {
+	echo "$TOTAL_TESTS $PASSED_TESTS $FAILED_TESTS $SKIPPED_TESTS" >"$STATS_FILE"
+}
 
 print_header() {
 	echo ""
@@ -36,6 +48,9 @@ print_test_result() {
 	local result="$2"
 	local message="${3:-}"
 
+	# Load current stats from file
+	load_stats
+
 	TOTAL_TESTS=$((TOTAL_TESTS + 1))
 
 	if [ "$result" = "PASS" ]; then
@@ -47,6 +62,12 @@ print_test_result() {
 		if [ -n "$message" ]; then
 			echo -e "  ${YELLOW}$message${NC}"
 		fi
+	elif [ "$result" = "NOT_FOUND" ]; then
+		FAILED_TESTS=$((FAILED_TESTS + 1))
+		echo -e "${YELLOW}⚠ NOT FOUND${NC}: $test_name"
+		if [ -n "$message" ]; then
+			echo -e "  ${YELLOW}$message${NC}"
+		fi
 	else
 		FAILED_TESTS=$((FAILED_TESTS + 1))
 		echo -e "${RED}✗ FAIL${NC}: $test_name"
@@ -54,13 +75,56 @@ print_test_result() {
 			echo -e "  ${YELLOW}$message${NC}"
 		fi
 	fi
+
+	# Save updated stats to file
+	save_stats
 }
 
 print_summary() {
+	# Load final stats from file
+	load_stats
+
 	echo ""
 	echo -e "${CYAN}========================================${NC}"
 	echo -e "${CYAN}Test Summary${NC}"
 	echo -e "${CYAN}========================================${NC}"
+
+	# Print per-suite results if any suites were run
+	if [ -s "$SUITE_STATS_FILE" ]; then
+		echo ""
+		echo -e "${CYAN}Results by Test Suite:${NC}"
+		echo ""
+
+		while IFS='|' read -r suite_name suite_total suite_passed suite_failed suite_skipped; do
+			local status_indicator=""
+			local color=""
+
+			if [ "$suite_failed" -gt 0 ]; then
+				status_indicator=" ${RED}[FAILURE]${NC}"
+				color="$RED"
+			elif [ "$suite_skipped" -gt 0 ]; then
+				status_indicator=" ${YELLOW}[SKIPPED]${NC}"
+				color="$YELLOW"
+			else
+				status_indicator=" ${GREEN}[OK]${NC}"
+				color="$GREEN"
+			fi
+
+			# Print suite results with proper formatting
+			printf "  %-25s" "$suite_name:"
+			if [ "$suite_failed" -gt 0 ]; then
+				echo -e "${RED}$suite_passed/$suite_total passed${NC}$status_indicator"
+			elif [ "$suite_skipped" -gt 0 ]; then
+				echo -e "${YELLOW}$suite_passed/$suite_total passed${NC}$status_indicator"
+			else
+				echo -e "${GREEN}$suite_passed/$suite_total passed${NC}$status_indicator"
+			fi
+		done <"$SUITE_STATS_FILE"
+
+		echo ""
+	fi
+
+	echo -e "${CYAN}Overall Results:${NC}"
 	echo -e "Total tests:  $TOTAL_TESTS"
 	echo -e "${GREEN}Passed:       $PASSED_TESTS${NC}"
 	if [ "$SKIPPED_TESTS" -gt 0 ]; then
@@ -77,18 +141,29 @@ print_summary() {
 		echo -e "${GREEN}All tests passed!${NC}"
 		return 0
 	else
-		echo -e "${RED}Some tests failed!${NC}"
+		echo -e "${RED}TEST FAILURE${NC}"
 		return 1
 	fi
 }
 
 run_test_suite() {
 	local suite_name="$1"
-	local test_file="$SCRIPT_DIR/test-${suite_name}.sh"
+	local test_file
+
+	# Check if suite_name contains a path (subdirectory)
+	if [[ "$suite_name" == */* ]]; then
+		# Path format: bookmark/mlh-bookmark -> tests/bookmark/test-mlh-bookmark.sh
+		local dir_part=$(dirname "$suite_name")
+		local file_part=$(basename "$suite_name")
+		test_file="$SCRIPT_DIR/$dir_part/test-${file_part}.sh"
+	else
+		# Legacy format: test-name -> tests/test-name.sh
+		test_file="$SCRIPT_DIR/test-${suite_name}.sh"
+	fi
 
 	if [ ! -f "$test_file" ]; then
-		echo -e "${RED}Error: Test suite '$suite_name' not found at: $test_file${NC}"
-		return 1
+		print_test_result "Test suite '$suite_name'" "NOT_FOUND" "Test file not found: $test_file"
+		return 0
 	fi
 
 	print_header "Running test suite: $suite_name"
@@ -103,17 +178,42 @@ run_test_suite() {
 		return 0 # Don't exit, just mark as failed and continue
 	fi
 
-	# Source the test file which will call print_test_result for each test
-	# shellcheck source=/dev/null
-	source "$test_file"
+	# Save stats before running suite to calculate delta
+	load_stats
+	local suite_start_total=$TOTAL_TESTS
+	local suite_start_passed=$PASSED_TESTS
+	local suite_start_failed=$FAILED_TESTS
+	local suite_start_skipped=$SKIPPED_TESTS
+
+	# Run test file in a subshell to isolate exit/trap statements
+	# We use ( ) subshell syntax to prevent 'exit' from killing the test runner
+	# Export necessary variables and functions for subshell
+	export -f print_test_result load_stats save_stats print_header
+	export STATS_FILE ROOT_DIR GREEN RED YELLOW CYAN NC
+
+	(
+		# Source the test file which will call print_test_result for each test
+		# shellcheck source=/dev/null
+		source "$test_file"
+	)
+
+	# Calculate delta for this suite
+	load_stats
+	local suite_total=$((TOTAL_TESTS - suite_start_total))
+	local suite_passed=$((PASSED_TESTS - suite_start_passed))
+	local suite_failed=$((FAILED_TESTS - suite_start_failed))
+	local suite_skipped=$((SKIPPED_TESTS - suite_start_skipped))
+
+	# Save suite stats (pipe-delimited for easy parsing)
+	echo "${suite_name}|${suite_total}|${suite_passed}|${suite_failed}|${suite_skipped}" >>"$SUITE_STATS_FILE"
 }
 
 run_all_tests() {
 	print_header "MyLinuxHelper - Test Suite"
 
-	# Find all test-*.sh files in tests directory
+	# Find all test-*.sh files in tests directory and subdirectories
 	local test_files
-	test_files=$(find "$SCRIPT_DIR" -maxdepth 1 -name "test-*.sh" -type f | sort)
+	test_files=$(find "$SCRIPT_DIR" -name "test-*.sh" -type f | sort)
 
 	if [ -z "$test_files" ]; then
 		echo -e "${YELLOW}No test files found in $SCRIPT_DIR${NC}"
@@ -123,9 +223,16 @@ run_all_tests() {
 	# Run each test suite
 	while IFS= read -r test_file; do
 		local suite_name
+		local relative_path="${test_file#$SCRIPT_DIR/}"
 		suite_name=$(basename "$test_file" .sh)
 		suite_name="${suite_name#test-}"
 
+		# If in subdirectory, prefix with directory name
+		if [[ "$relative_path" == */* ]]; then
+			local dir_name=$(dirname "$relative_path")
+			suite_name="${dir_name}/${suite_name}"
+		fi
+
 		run_test_suite "$suite_name"
 	done <<<"$test_files"
 }
diff --git a/tests/test-current-session.sh b/tests/test-current-session.sh
old mode 100644
new mode 100755
index 77cdc77..be4a3fd
--- a/tests/test-current-session.sh
+++ b/tests/test-current-session.sh
@@ -50,9 +50,9 @@ echo ""
 
 # Check if the new command appears
 if echo "$result" | grep -q "new command from session"; then
-	echo "✓ PASS: mlh history shows current session command"
+	print_test_result "mlh history shows current session command" "PASS"
 else
-	echo "✗ FAIL: mlh history does NOT show current session command"
+	print_test_result "mlh history shows current session command" "FAIL" "Current session command not found in history output"
 fi
 
 # Cleanup
diff --git a/tests/test-isjsonvalid.sh b/tests/test-isjsonvalid.sh
old mode 100644
new mode 100755
diff --git a/tests/test-linux.sh b/tests/test-linux.sh
old mode 100644
new mode 100755
diff --git a/tests/test-ll.sh b/tests/test-ll.sh
old mode 100644
new mode 100755
diff --git a/tests/test-mlh-about.sh b/tests/test-mlh-about.sh
old mode 100644
new mode 100755
diff --git a/tests/test-mlh-docker.sh b/tests/test-mlh-docker.sh
old mode 100644
new mode 100755
diff --git a/tests/test-mlh-history.sh b/tests/test-mlh-history.sh
old mode 100644
new mode 100755
index e1007de..ee97d46
--- a/tests/test-mlh-history.sh
+++ b/tests/test-mlh-history.sh
@@ -307,7 +307,7 @@ for i in {1..10}; do
 done
 
 # Count lines that look like command output (number followed by text or ► symbol)
-result=$(HISTFILE="$test_history" HISTTIMEFORMAT='%F %T  ' bash "$HISTORY_SCRIPT" 7 -g 5 2>&1 | grep -E "(►\s+[0-9]+|^\s+[0-9]+\s+20)" | wc -l)
+result=$(HISTFILE="$test_history" HISTTIMEFORMAT='%F %T  ' bash "$HISTORY_SCRIPT" 7 -g 5 2>&1 | grep -cE "(►\s+[0-9]+|^\s+[0-9]+\s+20)" || echo "0")
 rm -f "$test_history"
 result=$(echo "$result" | tr -d ' ') # Remove whitespace
 if [ "$result" -eq 7 ]; then
@@ -366,7 +366,7 @@ for i in {1..10}; do
 	fi
 done
 
-result=$(HISTFILE="$test_history" HISTTIMEFORMAT='%F %T  ' bash "$HISTORY_SCRIPT" -f "docker ps" 2>&1 | grep "^\s*docker ps" | wc -l)
+result=$(HISTFILE="$test_history" HISTTIMEFORMAT='%F %T  ' bash "$HISTORY_SCRIPT" -f "docker ps" 2>&1 | grep -c "^\s*docker ps" || echo "0")
 rm -f "$test_history"
 result=$(echo "$result" | tr -d ' ')
 if [ "$result" -eq 5 ]; then
diff --git a/tests/test-mlh-json.sh b/tests/test-mlh-json.sh
old mode 100644
new mode 100755
diff --git a/tests/test-mlh.sh b/tests/test-mlh.sh
old mode 100644
new mode 100755
diff --git a/tests/test-search.sh b/tests/test-search.sh
old mode 100644
new mode 100755
diff --git a/tests/test-shellcheck.sh b/tests/test-shellcheck.sh
new file mode 100644
index 0000000..85cf46d
--- /dev/null
+++ b/tests/test-shellcheck.sh
@@ -0,0 +1,176 @@
+#!/usr/bin/env bash
+# Test suite for ShellCheck validation
+
+# Disable strict mode for tests
+set +euo pipefail 2>/dev/null || true
+set +e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT_DIR="$(dirname "$SCRIPT_DIR")"
+
+# Source test framework functions from parent
+if [ -n "${STATS_FILE:-}" ]; then
+	# Running under test runner
+	:
+else
+	# Standalone execution
+	GREEN='\033[0;32m'
+	RED='\033[0;31m'
+	YELLOW='\033[1;33m'
+	CYAN='\033[0;36m'
+	NC='\033[0m'
+
+	print_test_result() {
+		local test_name="$1"
+		local result="$2"
+		local message="${3:-}"
+
+		if [ "$result" = "PASS" ]; then
+			echo -e "${GREEN}✓ PASS${NC}: $test_name"
+		elif [ "$result" = "SKIP" ]; then
+			echo -e "${YELLOW}⊘ SKIP${NC}: $test_name"
+			[ -n "$message" ] && echo -e "  ${YELLOW}$message${NC}"
+		else
+			echo -e "${RED}✗ FAIL${NC}: $test_name"
+			[ -n "$message" ] && echo -e "  ${YELLOW}$message${NC}"
+		fi
+	}
+fi
+
+# Test 1: Check if shellcheck is available
+if command -v shellcheck >/dev/null 2>&1; then
+	print_test_result "ShellCheck availability" "PASS" "Using local shellcheck"
+else
+	print_test_result "ShellCheck availability" "FAIL" "shellcheck not available. Install with: sudo apt-get install shellcheck"
+	exit 1
+fi
+
+# Helper function to run shellcheck
+run_shellcheck() {
+	local file="$1"
+	local excludes="${2:-}"
+
+	if [ -n "$excludes" ]; then
+		shellcheck --exclude="$excludes" "$file" 2>&1
+	else
+		shellcheck "$file" 2>&1
+	fi
+}
+
+# Test 2: Check main scripts (setup.sh, install.sh, get-mlh.sh)
+main_scripts=("setup.sh" "install.sh" "get-mlh.sh")
+main_errors=0
+main_failed=""
+
+for script in "${main_scripts[@]}"; do
+	script_path="$ROOT_DIR/$script"
+	if [ -f "$script_path" ]; then
+		if run_shellcheck "$script_path" >/dev/null 2>&1; then
+			print_test_result "ShellCheck: $script" "PASS"
+		else
+			main_errors=$((main_errors + 1))
+			main_failed="$main_failed $script"
+			error_msg=$(run_shellcheck "$script_path" 2>&1 | head -2 | tr '\n' ' ')
+			print_test_result "ShellCheck: $script" "FAIL" "$error_msg"
+		fi
+	else
+		print_test_result "ShellCheck: $script" "SKIP" "File not found"
+	fi
+done
+
+# Test 3: Check all plugin scripts
+PLUGINS_DIR="$ROOT_DIR/plugins"
+plugin_count=0
+plugin_errors=0
+failed_plugins=""
+
+if [ -d "$PLUGINS_DIR" ]; then
+	for plugin in "$PLUGINS_DIR"/*.sh; do
+		if [ -f "$plugin" ]; then
+			plugin_name=$(basename "$plugin")
+			plugin_count=$((plugin_count + 1))
+
+			if run_shellcheck "$plugin" >/dev/null 2>&1; then
+				: # PASS - counted below
+			else
+				plugin_errors=$((plugin_errors + 1))
+				failed_plugins="$failed_plugins $plugin_name"
+				# Show first error for debugging
+				error_msg=$(run_shellcheck "$plugin" 2>&1 | head -3 | tr '\n' ' ')
+				if [ -n "$error_msg" ]; then
+					echo "  Error in $plugin_name: $error_msg" >&2
+				fi
+			fi
+		fi
+	done
+fi
+
+if [ "$plugin_errors" -eq 0 ] && [ "$plugin_count" -gt 0 ]; then
+	print_test_result "ShellCheck: All plugin scripts ($plugin_count files)" "PASS"
+elif [ "$plugin_count" -eq 0 ]; then
+	print_test_result "ShellCheck: All plugin scripts" "SKIP" "No plugin scripts found"
+else
+	print_test_result "ShellCheck: All plugin scripts ($plugin_count files)" "FAIL" "Found issues in $plugin_errors plugin(s):$failed_plugins"
+fi
+
+# Test 4: Check test scripts (excluding this file)
+TEST_SCRIPTS_DIR="$ROOT_DIR/tests"
+test_count=0
+test_errors=0
+failed_tests=""
+
+# Check root test scripts
+for test_script in "$TEST_SCRIPTS_DIR"/*.sh; do
+	if [ -f "$test_script" ] && [ "$(basename "$test_script")" != "test-shellcheck.sh" ]; then
+		test_name=$(basename "$test_script")
+		test_count=$((test_count + 1))
+
+		# Test scripts may have intentional issues, so we use --exclude
+		# SC1090: Can't follow non-constant source
+		# SC1091: Not following sourced file
+		# SC2034: Variable appears unused (may be used in sourced files)
+		if run_shellcheck "$test_script" "SC1090,SC1091,SC2034" >/dev/null 2>&1; then
+			: # PASS
+		else
+			test_errors=$((test_errors + 1))
+			failed_tests="$failed_tests $test_name"
+			# Show first error for debugging
+			error_msg=$(run_shellcheck "$test_script" "SC1090,SC1091,SC2034" 2>&1 | head -3 | tr '\n' ' ')
+			if [ -n "$error_msg" ]; then
+				echo "  Error in $test_name: $error_msg" >&2
+			fi
+		fi
+	fi
+done
+
+# Check bookmark test scripts
+if [ -d "$TEST_SCRIPTS_DIR/bookmark" ]; then
+	for test_script in "$TEST_SCRIPTS_DIR/bookmark"/*.sh; do
+		if [ -f "$test_script" ]; then
+			test_name=$(basename "$test_script")
+			test_count=$((test_count + 1))
+
+			if run_shellcheck "$test_script" "SC1090,SC1091,SC2034" >/dev/null 2>&1; then
+				: # PASS
+			else
+				test_errors=$((test_errors + 1))
+				failed_tests="$failed_tests bookmark/$test_name"
+				# Show first error for debugging
+				error_msg=$(run_shellcheck "$test_script" "SC1090,SC1091,SC2034" 2>&1 | head -3 | tr '\n' ' ')
+				if [ -n "$error_msg" ]; then
+					echo "  Error in bookmark/$test_name: $error_msg" >&2
+				fi
+			fi
+		fi
+	done
+fi
+
+if [ "$test_errors" -eq 0 ] && [ "$test_count" -gt 0 ]; then
+	print_test_result "ShellCheck: All test scripts ($test_count files)" "PASS"
+elif [ "$test_count" -eq 0 ]; then
+	print_test_result "ShellCheck: All test scripts" "SKIP" "No test scripts found"
+else
+	print_test_result "ShellCheck: All test scripts ($test_count files)" "FAIL" "Found issues in $test_errors test script(s):$failed_tests"
+fi
+
+exit 0
diff --git a/tests/test-time-debug.sh b/tests/test-time-debug.sh
old mode 100644
new mode 100755
index e0ea3ec..2c2dcc6
--- a/tests/test-time-debug.sh
+++ b/tests/test-time-debug.sh
@@ -19,6 +19,9 @@ rm -f "$TEMP_SCRIPT"
 echo "=== Time Debug Information ==="
 echo ""
 
+# Initialize last_ts to avoid unbound variable error
+last_ts=""
+
 # Get current system time
 current_ts=$(date +%s)
 echo "Current timestamp: $current_ts"
@@ -81,6 +84,22 @@ echo "=== Testing relative time for 3m ==="
 seconds_3m=$(parse_relative_time "3m")
 echo "3m = $seconds_3m seconds (expected: 180)"
 
+# Test parse_relative_time function
+if [ "$seconds_3m" -eq 180 ]; then
+	print_test_result "parse_relative_time('3m') returns correct value" "PASS"
+else
+	print_test_result "parse_relative_time('3m') returns correct value" "FAIL" "Expected 180, got $seconds_3m"
+fi
+
+# Test timestamp_to_date function
+test_ts=$current_ts
+test_date=$(timestamp_to_date "$test_ts")
+if [ -n "$test_date" ] && [[ "$test_date" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2} ]]; then
+	print_test_result "timestamp_to_date() produces valid date format" "PASS"
+else
+	print_test_result "timestamp_to_date() produces valid date format" "FAIL" "Invalid date format: $test_date"
+fi
+
 end_ts=$current_ts
 start_ts=$((end_ts - seconds_3m))
 echo "Start timestamp: $start_ts ($(timestamp_to_date "$start_ts"))"
@@ -96,3 +115,61 @@ if [ -n "$last_ts" ]; then
 		echo "  last_ts <= end_ts: $last_ts <= $end_ts = $([ "$last_ts" -le "$end_ts" ] && echo "true" || echo "false")"
 	fi
 fi
+
+echo ""
+echo "=== Testing with controlled timestamps ==="
+
+# Test 3: Create test data with known timestamps and verify time filtering
+test_histfile=$(mktemp)
+test_current=$current_ts
+test_5m_ago=$((test_current - 300))  # 5 minutes ago
+test_1h_ago=$((test_current - 3600)) # 1 hour ago
+
+cat >"$test_histfile" <<EOF
+#$test_1h_ago
+command from 1 hour ago
+#$test_5m_ago
+command from 5 minutes ago
+#$test_current
+recent command
+EOF
+
+# Save original HISTFILE and HISTTIMEFORMAT and use test file
+original_histfile="${HISTFILE:-}"
+original_histtimeformat="${HISTTIMEFORMAT:-}"
+export HISTFILE="$test_histfile"
+export HISTTIMEFORMAT="%s"
+
+# Test that parse_history_with_timestamps can read the test file
+test_output=$(parse_history_with_timestamps 2>&1)
+if echo "$test_output" | grep -q "command from 1 hour ago" &&
+	echo "$test_output" | grep -q "command from 5 minutes ago" &&
+	echo "$test_output" | grep -q "recent command"; then
+	print_test_result "parse_history_with_timestamps reads all commands" "PASS"
+else
+	print_test_result "parse_history_with_timestamps reads all commands" "FAIL" "Failed to parse test history file"
+fi
+
+# Test filter_by_date with 10 minute window (should get 2 commands)
+filter_output=$(filter_by_date "10m" 2>&1)
+# Should get at least 2 commands from our test data: 5m ago and current
+# (1h ago command is outside the 10m window)
+if echo "$filter_output" | grep -q "command from 5 minutes ago" &&
+	echo "$filter_output" | grep -q "recent command"; then
+	print_test_result "filter_by_date correctly filters by time range" "PASS"
+else
+	print_test_result "filter_by_date correctly filters by time range" "FAIL" "Could not find expected commands in 10m range"
+fi
+
+# Restore original HISTFILE and HISTTIMEFORMAT
+if [ -n "$original_histfile" ]; then
+	export HISTFILE="$original_histfile"
+else
+	unset HISTFILE
+fi
+if [ -n "$original_histtimeformat" ]; then
+	export HISTTIMEFORMAT="$original_histtimeformat"
+else
+	unset HISTTIMEFORMAT
+fi
+rm -f "$test_histfile"