From 87413c8cbb13c41b0268f8279451fe5a7d632aef Mon Sep 17 00:00:00 2001
From: John Lindquist <johnlindquist@gmail.com>
Date: Tue, 9 Dec 2025 13:37:17 -0700
Subject: [PATCH 1/4] feat: Add trust and subfolder config options (closes #33,
 #34)

- Add `wt config set trust true/false` to bypass setup command confirmations
  without needing to pass -t flag every time (issue #34)
- Add `wt config set subfolder true/false` to create worktrees in a
  my-app-worktrees/feature pattern instead of my-app-feature siblings (issue #33)
- Add getter/setter functions in config.ts for both options
- Update confirmCommands() to check config trust setting
- Update resolveWorktreePath() to support subfolder naming pattern
- Add 8 new tests for the config options (98 total tests pass)
---
 src/commands/config.ts | 42 +++++++++++++++++--
 src/config.ts          | 33 +++++++++++++++
 src/index.ts           | 28 +++++++++++++
 src/utils/paths.ts     | 18 +++++++--
 src/utils/tui.ts       |  5 ++-
 test/config.test.ts    | 92 ++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 210 insertions(+), 8 deletions(-)

diff --git a/src/commands/config.ts b/src/commands/config.ts
index 86192ca..f1ac2d9 100644
--- a/src/commands/config.ts
+++ b/src/commands/config.ts
@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { getDefaultEditor, setDefaultEditor, getGitProvider, setGitProvider, getConfigPath, getDefaultWorktreePath, setDefaultWorktreePath, clearDefaultWorktreePath } from '../config.js';
+import { getDefaultEditor, setDefaultEditor, getGitProvider, setGitProvider, getConfigPath, getDefaultWorktreePath, setDefaultWorktreePath, clearDefaultWorktreePath, getTrust, setTrust, getWorktreeSubfolder, setWorktreeSubfolder } from '../config.js';
 
 export async function configHandler(action: 'get' | 'set' | 'path' | 'clear', key?: string, value?: string) {
     try {
@@ -18,9 +18,23 @@ export async function configHandler(action: 'get' | 'set' | 'path' | 'clear', ke
                     } else {
                         console.log(chalk.blue(`Default worktree path is not set (using sibling directory behavior).`));
                     }
+                } else if (key === 'trust') {
+                    const trust = getTrust();
+                    console.log(chalk.blue(`Trust mode is currently: ${chalk.bold(trust ? 'enabled' : 'disabled')}`));
+                    if (trust) {
+                        console.log(chalk.gray(`  Setup commands will run without confirmation prompts.`));
+                    }
+                } else if (key === 'subfolder') {
+                    const subfolder = getWorktreeSubfolder();
+                    console.log(chalk.blue(`Subfolder mode is currently: ${chalk.bold(subfolder ? 'enabled' : 'disabled')}`));
+                    if (subfolder) {
+                        console.log(chalk.gray(`  Worktrees will be created in: my-app-worktrees/feature`));
+                    } else {
+                        console.log(chalk.gray(`  Worktrees will be created as: my-app-feature (siblings)`));
+                    }
                 } else {
                     console.error(chalk.red(`Unknown configuration key to get: ${key}`));
-                    console.error(chalk.yellow(`Available keys: editor, provider, worktreepath`));
+                    console.error(chalk.yellow(`Available keys: editor, provider, worktreepath, trust, subfolder`));
                     process.exit(1);
                 }
                 break;
@@ -40,6 +54,22 @@ export async function configHandler(action: 'get' | 'set' | 'path' | 'clear', ke
                     setDefaultWorktreePath(value);
                     const resolvedPath = getDefaultWorktreePath();
                     console.log(chalk.green(`Default worktree path set to: ${chalk.bold(resolvedPath)}`));
+                } else if (key === 'trust' && value !== undefined) {
+                    const trustValue = value.toLowerCase() === 'true' || value === '1';
+                    setTrust(trustValue);
+                    console.log(chalk.green(`Trust mode ${trustValue ? 'enabled' : 'disabled'}.`));
+                    if (trustValue) {
+                        console.log(chalk.gray(`  Setup commands will now run without confirmation prompts.`));
+                    }
+                } else if (key === 'subfolder' && value !== undefined) {
+                    const subfolderValue = value.toLowerCase() === 'true' || value === '1';
+                    setWorktreeSubfolder(subfolderValue);
+                    console.log(chalk.green(`Subfolder mode ${subfolderValue ? 'enabled' : 'disabled'}.`));
+                    if (subfolderValue) {
+                        console.log(chalk.gray(`  Worktrees will now be created in: my-app-worktrees/feature`));
+                    } else {
+                        console.log(chalk.gray(`  Worktrees will now be created as: my-app-feature (siblings)`));
+                    }
                 } else if (key === 'editor') {
                     console.error(chalk.red(`You must provide an editor name.`));
                     process.exit(1);
@@ -49,9 +79,15 @@ export async function configHandler(action: 'get' | 'set' | 'path' | 'clear', ke
                 } else if (key === 'worktreepath') {
                     console.error(chalk.red(`You must provide a path.`));
                     process.exit(1);
+                } else if (key === 'trust') {
+                    console.error(chalk.red(`You must provide a value (true or false).`));
+                    process.exit(1);
+                } else if (key === 'subfolder') {
+                    console.error(chalk.red(`You must provide a value (true or false).`));
+                    process.exit(1);
                 } else {
                     console.error(chalk.red(`Unknown configuration key to set: ${key}`));
-                    console.error(chalk.yellow(`Available keys: editor, provider, worktreepath`));
+                    console.error(chalk.yellow(`Available keys: editor, provider, worktreepath, trust, subfolder`));
                     process.exit(1);
                 }
                 break;
diff --git a/src/config.ts b/src/config.ts
index a0bc91f..c3ce0a0 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -14,6 +14,8 @@ interface ConfigSchema {
     defaultEditor: string;
     gitProvider: 'gh' | 'glab';
     defaultWorktreePath?: string;
+    trust?: boolean;
+    worktreeSubfolder?: boolean;
 }
 
 // Initialize conf with a schema and project name
@@ -32,6 +34,15 @@ const schema = {
         type: 'string',
         // No default - falls back to sibling directory behavior when not set
     },
+    trust: {
+        type: 'boolean',
+        default: false, // Default is to require confirmation for setup commands
+    },
+    worktreeSubfolder: {
+        type: 'boolean',
+        default: false, // Default is sibling directory behavior (my-app-feature)
+        // When true: my-app-worktrees/feature subfolder pattern
+    },
 } as const;
 
 const config = new Conf<ConfigSchema>({
@@ -94,4 +105,26 @@ export function setDefaultWorktreePath(worktreePath: string): void {
 // Function to clear the default worktree path
 export function clearDefaultWorktreePath(): void {
     config.delete('defaultWorktreePath');
+}
+
+// Function to get the trust setting (bypass setup command confirmation)
+export function getTrust(): boolean {
+    return config.get('trust') ?? false;
+}
+
+// Function to set the trust setting
+export function setTrust(trust: boolean): void {
+    config.set('trust', trust);
+}
+
+// Function to get the worktree subfolder setting
+// When true: creates worktrees in my-app-worktrees/feature pattern
+// When false: creates worktrees as my-app-feature siblings
+export function getWorktreeSubfolder(): boolean {
+    return config.get('worktreeSubfolder') ?? false;
+}
+
+// Function to set the worktree subfolder setting
+export function setWorktreeSubfolder(subfolder: boolean): void {
+    config.set('worktreeSubfolder', subfolder);
 } 
\ No newline at end of file
diff --git a/src/index.ts b/src/index.ts
index beaa0e9..a50bd24 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -199,6 +199,24 @@ program
           .description("Set the default directory for new worktrees.")
           .action((worktreePath) => configHandler("set", "worktreepath", worktreePath))
       )
+      .addCommand(
+        new Command("trust")
+          .argument(
+            "<value>",
+            "Enable or disable trust mode (true/false)"
+          )
+          .description("Set trust mode to skip setup command confirmations.")
+          .action((value) => configHandler("set", "trust", value))
+      )
+      .addCommand(
+        new Command("subfolder")
+          .argument(
+            "<value>",
+            "Enable or disable subfolder mode (true/false)"
+          )
+          .description("Set subfolder mode for worktree paths (my-app-worktrees/feature).")
+          .action((value) => configHandler("set", "subfolder", value))
+      )
   )
   .addCommand(
     new Command("get")
@@ -218,6 +236,16 @@ program
           .description("Get the currently configured default worktree directory.")
           .action(() => configHandler("get", "worktreepath"))
       )
+      .addCommand(
+        new Command("trust")
+          .description("Get the current trust mode setting.")
+          .action(() => configHandler("get", "trust"))
+      )
+      .addCommand(
+        new Command("subfolder")
+          .description("Get the current subfolder mode setting.")
+          .action(() => configHandler("get", "subfolder"))
+      )
   )
   .addCommand(
     new Command("clear")
diff --git a/src/utils/paths.ts b/src/utils/paths.ts
index 40228d0..7c4f65a 100644
--- a/src/utils/paths.ts
+++ b/src/utils/paths.ts
@@ -1,5 +1,5 @@
 import { join, dirname, basename, resolve } from "node:path";
-import { getDefaultWorktreePath } from "../config.js";
+import { getDefaultWorktreePath, getWorktreeSubfolder } from "../config.js";
 import { getRepoName } from "./git.js";
 
 /**
@@ -48,10 +48,11 @@ export interface ResolveWorktreePathOptions {
 /**
  * Resolve the full path for a new worktree
  *
- * Handles three cases:
+ * Handles four cases:
  * 1. Custom path provided - use it directly
  * 2. Global defaultWorktreePath configured - use it with repo namespace
- * 3. No config - create sibling directory
+ * 3. Subfolder mode enabled - create in my-app-worktrees/feature pattern
+ * 4. No config - create sibling directory (my-app-feature)
  *
  * @param branchName - The branch name to create worktree for
  * @param options - Configuration options
@@ -88,9 +89,18 @@ export async function resolveWorktreePath(
         return join(defaultWorktreePath, worktreeName);
     }
 
-    // Case 3: No config - create sibling directory
+    // Check if subfolder mode is enabled
+    const useSubfolder = getWorktreeSubfolder();
     const parentDir = dirname(cwd);
     const currentDirName = basename(cwd);
+
+    if (useSubfolder) {
+        // Case 3: Subfolder mode - create in my-app-worktrees/feature pattern
+        // This keeps worktrees organized in a dedicated folder
+        return join(parentDir, `${currentDirName}-worktrees`, worktreeName);
+    }
+
+    // Case 4: No config - create sibling directory (my-app-feature)
     return join(parentDir, `${currentDirName}-${worktreeName}`);
 }
 
diff --git a/src/utils/tui.ts b/src/utils/tui.ts
index 6aa760c..6c19a5b 100644
--- a/src/utils/tui.ts
+++ b/src/utils/tui.ts
@@ -1,6 +1,7 @@
 import prompts from "prompts";
 import chalk from "chalk";
 import { getWorktrees, WorktreeInfo } from "./git.js";
+import { getTrust } from "../config.js";
 
 /**
  * Interactive worktree selector
@@ -165,7 +166,9 @@ export async function confirmCommands(commands: string[], options: {
 } = {}): Promise<boolean> {
     const { title = "The following commands will be executed:", trust = false } = options;
 
-    if (trust) {
+    // Check both the flag and the config setting
+    // If either is true, skip confirmation
+    if (trust || getTrust()) {
         return true;
     }
 
diff --git a/test/config.test.ts b/test/config.test.ts
index 247eea2..798b43e 100644
--- a/test/config.test.ts
+++ b/test/config.test.ts
@@ -381,4 +381,96 @@ describe('Config Management', () => {
             expect(invalidResult.stderr).toContain('Valid providers: gh, glab');
         });
     });
+
+    describe('Trust config (Issue #34)', () => {
+        it('should get trust mode default (disabled)', async () => {
+            const result = await runConfig(['get', 'trust']);
+
+            expect(result.exitCode).toBe(0);
+            expect(result.stdout).toContain('Trust mode is currently');
+        });
+
+        it('should set trust mode to true', async () => {
+            const result = await runConfig(['set', 'trust', 'true']);
+
+            expect(result.exitCode).toBe(0);
+            expect(result.stdout).toContain('Trust mode enabled');
+
+            const config = await getConfigFileContent();
+            expect(config).toBeDefined();
+            expect(config.trust).toBe(true);
+        });
+
+        it('should set trust mode to false', async () => {
+            // First enable it
+            await runConfig(['set', 'trust', 'true']);
+
+            // Then disable it
+            const result = await runConfig(['set', 'trust', 'false']);
+
+            expect(result.exitCode).toBe(0);
+            expect(result.stdout).toContain('Trust mode disabled');
+
+            const config = await getConfigFileContent();
+            expect(config).toBeDefined();
+            expect(config.trust).toBe(false);
+        });
+
+        it('should accept 1 as truthy value', async () => {
+            const result = await runConfig(['set', 'trust', '1']);
+
+            expect(result.exitCode).toBe(0);
+            expect(result.stdout).toContain('Trust mode enabled');
+
+            const config = await getConfigFileContent();
+            expect(config.trust).toBe(true);
+        });
+    });
+
+    describe('Subfolder config (Issue #33)', () => {
+        it('should get subfolder mode default (disabled)', async () => {
+            const result = await runConfig(['get', 'subfolder']);
+
+            expect(result.exitCode).toBe(0);
+            expect(result.stdout).toContain('Subfolder mode is currently');
+        });
+
+        it('should set subfolder mode to true', async () => {
+            const result = await runConfig(['set', 'subfolder', 'true']);
+
+            expect(result.exitCode).toBe(0);
+            expect(result.stdout).toContain('Subfolder mode enabled');
+            expect(result.stdout).toContain('my-app-worktrees/feature');
+
+            const config = await getConfigFileContent();
+            expect(config).toBeDefined();
+            expect(config.worktreeSubfolder).toBe(true);
+        });
+
+        it('should set subfolder mode to false', async () => {
+            // First enable it
+            await runConfig(['set', 'subfolder', 'true']);
+
+            // Then disable it
+            const result = await runConfig(['set', 'subfolder', 'false']);
+
+            expect(result.exitCode).toBe(0);
+            expect(result.stdout).toContain('Subfolder mode disabled');
+            expect(result.stdout).toContain('siblings');
+
+            const config = await getConfigFileContent();
+            expect(config).toBeDefined();
+            expect(config.worktreeSubfolder).toBe(false);
+        });
+
+        it('should accept 1 as truthy value', async () => {
+            const result = await runConfig(['set', 'subfolder', '1']);
+
+            expect(result.exitCode).toBe(0);
+            expect(result.stdout).toContain('Subfolder mode enabled');
+
+            const config = await getConfigFileContent();
+            expect(config.worktreeSubfolder).toBe(true);
+        });
+    });
 });

From da6acc6f3cd023e1eab6f1086c6d9c9b6ad002af Mon Sep 17 00:00:00 2001
From: CaptainCodeAU <captaincodeau@gmail.com>
Date: Tue, 23 Dec 2025 13:23:15 +1100
Subject: [PATCH 2/4] feat: Add wt status command and merge PR #35

- Merged PR #35 (trust and subfolder config options)
- Implemented wt status command with comprehensive git status info
- Added 6 tests for status command (104 total tests passing)
- Created Claude Code slash command at .claude/commands/worktree.md
- Updated documentation with progress and new features
- Fixed test issues related to trust mode configuration
---
 .claude/commands/worktree.md |  30 +++
 WORKTREE-CLI-PROJECT.md      | 470 +++++++++++++++++++++++++++++++++++
 build/commands/config.js     |  50 +++-
 build/commands/status.js     | 137 ++++++++++
 build/config.js              |  27 ++
 build/index.js               |  23 +-
 build/utils/paths.js         |  16 +-
 build/utils/tui.js           |   5 +-
 src/commands/status.ts       | 170 +++++++++++++
 src/index.ts                 |   6 +
 test/git-utils.test.ts       |   2 +-
 test/integration.test.ts     |   8 +-
 test/status.test.ts          | 156 ++++++++++++
 test/tui.test.ts             |  15 ++
 14 files changed, 1103 insertions(+), 12 deletions(-)
 create mode 100644 .claude/commands/worktree.md
 create mode 100644 WORKTREE-CLI-PROJECT.md
 create mode 100644 build/commands/status.js
 create mode 100644 src/commands/status.ts
 create mode 100644 test/status.test.ts

diff --git a/.claude/commands/worktree.md b/.claude/commands/worktree.md
new file mode 100644
index 0000000..28fe747
--- /dev/null
+++ b/.claude/commands/worktree.md
@@ -0,0 +1,30 @@
+# Worktree Management
+
+You have access to the `wt` CLI tool for managing git worktrees.
+
+## Common Commands
+
+- `wt new <branch> -c` — Create new worktree (create branch if needed)
+- `wt setup <branch> -c` — Create worktree + run setup scripts
+- `wt status` — Show status of all worktrees (clean/dirty, ahead/behind)
+- `wt list` — List all worktrees
+- `wt remove <branch>` — Remove a worktree
+- `wt merge <branch> --auto-commit --remove` — Merge and cleanup
+- `wt pr <number> --setup` — Create worktree from PR/MR
+
+## Workflow for Parallel Tasks
+
+When asked to work on multiple tasks in parallel:
+
+1. Create a worktree for each task: `wt setup feature/<task-name> -c`
+2. Note the paths returned
+3. Work in each worktree directory independently
+4. Check status: `wt status`
+5. When complete, merge back: `wt merge feature/<task-name> --auto-commit`
+
+## Configuration
+
+This project has trust mode enabled (no confirmation prompts) and uses subfolder organization for worktrees.
+
+**User Request:** $ARGUMENTS
+
diff --git a/WORKTREE-CLI-PROJECT.md b/WORKTREE-CLI-PROJECT.md
new file mode 100644
index 0000000..26d0979
--- /dev/null
+++ b/WORKTREE-CLI-PROJECT.md
@@ -0,0 +1,470 @@
+# Worktree-CLI Fork: Claude Code & Cursor Integration
+
+## Project Overview
+
+This is a fork of `@johnlindquist/worktree-cli` — a CLI tool for managing Git worktrees with a focus on AI-assisted parallel development workflows.
+
+**Original Repository:** https://github.com/johnlindquist/worktree-cli
+**Your Fork:** https://github.com/CaptainCodeAU/worktree-cli
+
+---
+
+## Vision
+
+Create a **unified worktree management system** that works seamlessly with both **Claude Code** and **Cursor**, enabling:
+
+1. **Parallel AI agent workflows** — Multiple AI agents working on different tasks simultaneously, each in isolated worktrees
+2. **Consistent experience** — Same tool, same config, same behavior regardless of which AI assistant you're using
+3. **Automation-first** — Headless operation for CI/CD and AI agents without interactive prompts blocking execution
+4. **Clean organization** — Structured worktree directories that don't clutter your projects folder
+
+---
+
+## Current State
+
+### What's Already in the CLI
+
+| Command | Description |
+|---------|-------------|
+| `wt new <branch>` | Create new worktree from branch |
+| `wt setup <branch>` | Create worktree + run setup scripts |
+| `wt pr [number]` | Create worktree from GitHub PR or GitLab MR |
+| `wt open [path]` | Open existing worktree (interactive fuzzy search) |
+| `wt list` | List all worktrees with status |
+| `wt status` | **NEW** Show detailed status (clean/dirty, ahead/behind) |
+| `wt remove [path]` | Remove a worktree |
+| `wt purge` | Multi-select removal of worktrees |
+| `wt extract` | Extract current branch to a worktree |
+| `wt merge <branch>` | Merge a worktree branch into current branch |
+| `wt config get/set` | Configure editor, provider, worktreepath, trust, subfolder |
+
+### Key Options
+
+- `-c, --checkout`: Create new branch if it doesn't exist
+- `-i, --install <pm>`: Auto-install dependencies (npm/pnpm/bun)
+- `-e, --editor <editor>`: Override default editor (cursor/code/none)
+- `-t, --trust`: Skip confirmation for setup scripts
+- `-p, --path <path>`: Custom worktree path
+- `--setup` (on `wt pr`): Run setup scripts after PR worktree creation
+
+### Setup Script Configuration
+
+The CLI reads setup scripts from two locations (checked in order):
+1. `.cursor/worktrees.json` (Cursor's native format)
+2. `worktrees.json` (generic format)
+
+**Format examples:**
+
+```json
+// .cursor/worktrees.json (array format)
+[
+  "pnpm install",
+  "cp $ROOT_WORKTREE_PATH/.env.local .env.local"
+]
+```
+
+```json
+// worktrees.json (object format)
+{
+  "setup-worktree": [
+    "pnpm install",
+    "cp $ROOT_WORKTREE_PATH/.env.local .env.local"
+  ]
+}
+```
+
+---
+
+## PR #35: Trust and Subfolder Config ✅ MERGED
+
+**PR Link:** https://github.com/johnlindquist/worktree-cli/pull/35
+**Status:** Successfully merged into `feature/claude-code-enhancements` branch
+
+This PR adds two important config options:
+
+### 1. Trust Mode
+```bash
+wt config set trust true
+```
+- Bypasses setup command confirmations globally
+- No need to pass `-t` flag every time
+- Essential for Claude Code automation
+
+### 2. Subfolder Mode
+```bash
+wt config set subfolder true
+```
+- Changes worktree organization from siblings to subdirectory
+
+**Without subfolder mode:**
+```
+my-app/                 # main repo
+my-app-feature-auth/    # worktree (sibling)
+my-app-feature-api/     # worktree (sibling)
+```
+
+**With subfolder mode:**
+```
+my-app/                 # main repo
+my-app-worktrees/
+  ├── feature-auth/     # worktree
+  └── feature-api/      # worktree
+```
+
+### To Merge PR #35 Into Your Fork
+
+```bash
+git remote add upstream https://github.com/johnlindquist/worktree-cli.git
+git fetch upstream feature/issues-33-34-config-options
+git checkout -b feature/claude-code-enhancements main
+git merge upstream/feature/issues-33-34-config-options --no-edit
+pnpm build
+pnpm test
+```
+
+---
+
+## New: `wt status` Command ✅ IMPLEMENTED
+
+The `wt status` command provides a comprehensive overview of all worktrees with detailed git status information.
+
+### Features
+
+- Shows all worktrees with branch names and paths
+- **Git status**: Clean vs dirty (uncommitted changes)
+- **Tracking status**: Ahead/behind upstream branch
+- **Indicators**: Main worktree, locked, prunable status
+- **Error handling**: Gracefully handles missing worktree directories
+
+### Example Output
+
+```bash
+$ wt status
+Worktree Status:
+
+main → /Users/me/projects/myapp [main] [clean] [up-to-date]
+feature/auth → /Users/me/projects/myapp-worktrees/feature-auth [dirty] [↑2]
+feature/api → /Users/me/projects/myapp-worktrees/feature-api [clean] [no upstream]
+```
+
+### Status Indicators
+
+- `[main]` - Main worktree
+- `[clean]` / `[dirty]` - Git working tree status
+- `[up-to-date]` - In sync with upstream
+- `[↑N]` - N commits ahead of upstream
+- `[↓N]` - N commits behind upstream
+- `[↑N ↓M]` - Diverged from upstream
+- `[no upstream]` - No tracking branch configured
+- `[locked]` - Worktree is locked
+- `[prunable]` - Worktree is stale/prunable
+
+### Implementation Details
+
+- Located in `src/commands/status.ts`
+- 6 comprehensive tests in `test/status.test.ts`
+- Reuses existing git utilities from `src/utils/git.ts`
+- Handles edge cases: detached HEAD, bare repos, missing directories
+
+---
+
+## Planned Enhancements
+
+### 1. Claude Code Slash Command Integration
+
+Create a custom slash command for Claude Code at `.claude/commands/worktree.md`:
+
+```markdown
+# Worktree Management
+
+You have access to the `wt` CLI tool for managing git worktrees.
+
+## Common Commands
+
+- `wt new <branch> -c` — Create new worktree (create branch if needed)
+- `wt setup <branch> -c` — Create worktree + run setup scripts
+- `wt list` — List all worktrees
+- `wt remove <branch>` — Remove a worktree
+- `wt merge <branch> --auto-commit --remove` — Merge and cleanup
+- `wt pr <number> --setup` — Create worktree from PR/MR
+
+## Workflow for Parallel Tasks
+
+When asked to work on multiple tasks in parallel:
+
+1. Create a worktree for each task: `wt setup feature/<task-name> -c`
+2. Note the paths returned
+3. Work in each worktree directory independently
+4. When complete, merge back: `wt merge feature/<task-name> --auto-commit`
+
+**User Request:** $ARGUMENTS
+```
+
+### 2. CLAUDE.md in Projects
+
+Add to project's `CLAUDE.md`:
+
+```markdown
+## Worktree Workflow
+
+This project uses `wt` (worktree-cli) for managing parallel workstreams.
+
+- Worktrees are stored in organized subdirectories (subfolder mode enabled)
+- Setup scripts run automatically via `.cursor/worktrees.json`
+- For parallel tasks, create separate worktrees rather than switching branches
+- Always use `wt merge` to bring changes back (safer than manual git merge)
+- Trust mode is enabled — no confirmation prompts for setup scripts
+```
+
+### 3. Potential New Features to Implement
+
+| Feature | Description | Priority | Status |
+|---------|-------------|----------|--------|
+| `wt status` | Quick overview of all worktrees + their git status (dirty/clean/ahead/behind) | High | ✅ **DONE** |
+| Agent ID generation | Auto-generate `.agent-id` files for parallel agent coordination (like Cursor's parallel agents) | High | ⬜ Todo |
+| CLAUDE.md copying | Automatically copy CLAUDE.md to new worktrees | Medium | ⬜ Todo |
+| `wt clone` | Clone a repo as bare + set up initial worktree in one command | Medium | ⬜ Todo |
+| Better GitLab parity | Ensure `wt pr` works equally well with `glab` | Medium | ⬜ Todo |
+| `wt sync` | Fetch + rebase all worktrees from their upstream branches | Low | ⬜ Todo |
+
+---
+
+## Architecture Overview
+
+```
+worktree-cli/
+├── src/
+│   ├── index.ts              # CLI entry point (Commander setup)
+│   ├── config.ts             # Config schema and getters/setters
+│   ├── commands/
+│   │   ├── new.ts            # wt new
+│   │   ├── setup.ts          # wt setup
+│   │   ├── pr.ts             # wt pr
+│   │   ├── open.ts           # wt open
+│   │   ├── list.ts           # wt list
+│   │   ├── remove.ts         # wt remove
+│   │   ├── merge.ts          # wt merge
+│   │   ├── config.ts         # wt config get/set
+│   │   └── ...
+│   └── utils/
+│       ├── paths.ts          # Path resolution logic
+│       ├── tui.ts            # Terminal UI (prompts, confirmations)
+│       ├── git.ts            # Git operations
+│       └── ...
+├── test/                     # Vitest tests
+├── build/                    # Compiled JS output
+├── package.json
+└── tsconfig.json
+```
+
+### Key Technologies
+
+- **TypeScript** — Source language
+- **Commander** — CLI framework
+- **Execa** — Shell command execution
+- **Vitest** — Testing framework
+- **Inquirer/Prompts** — Interactive TUI
+
+---
+
+## Development Workflow
+
+### Setup (Already Completed)
+
+```bash
+# Clone your fork
+git clone git@github.com:CaptainCodeAU/worktree-cli.git
+cd worktree-cli
+
+# Install dependencies
+pnpm install
+
+# Build
+pnpm build
+
+# Link globally for testing
+pnpm link --global
+
+# Verify
+wt --version
+```
+
+### Making Changes
+
+```bash
+# 1. Create/switch to feature branch
+git checkout -b feature/my-new-feature
+
+# 2. Make changes in src/
+
+# 3. Rebuild
+pnpm build
+
+# 4. Test manually
+wt <command>
+
+# 5. Run automated tests
+pnpm test
+
+# 6. Add tests for new functionality in test/
+
+# 7. Commit
+git add .
+git commit -m "feat: description of change"
+
+# 8. Push to your fork
+git push origin feature/my-new-feature
+```
+
+### Testing
+
+```bash
+# Run all tests
+pnpm test
+
+# Run with coverage
+pnpm test -- --coverage
+
+# Run specific test file
+pnpm test -- test/config.test.ts
+```
+
+---
+
+## Configuration Reference
+
+### Global Config Location
+
+Config is stored at: `~/.config/worktree-cli/config.json`
+
+### Available Config Options
+
+| Key | Command | Description |
+|-----|---------|-------------|
+| `editor` | `wt config set editor <value>` | Default editor: `cursor`, `code`, `none` |
+| `provider` | `wt config set provider <value>` | Git provider CLI: `gh`, `glab` |
+| `worktreepath` | `wt config set worktreepath <path>` | Global worktree directory |
+| `trust` | `wt config set trust true` | Skip setup confirmations (PR #35) |
+| `subfolder` | `wt config set subfolder true` | Use subdirectory organization (PR #35) |
+
+### Recommended Config for Claude Code
+
+```bash
+wt config set editor none        # Don't open editor (headless)
+wt config set trust true         # No confirmation prompts
+wt config set subfolder true     # Organized directory structure
+```
+
+---
+
+## Related Resources
+
+### Documentation & Articles
+
+- **Cursor Parallel Agents Docs:** https://cursor.com/docs/configuration/worktrees
+- **Git Worktrees Explained:** https://dev.to/arifszn/git-worktrees-the-power-behind-cursors-parallel-agents-19j1
+- **Nick Taylor's Git Worktrees Guide:** https://www.nickyt.co/blog/git-worktrees-git-done-right-2p7f/
+
+### Cursor Parallel Agent Coordination
+
+For Cursor's parallel agents, you can use `.cursor/worktrees.json` to auto-assign agent IDs:
+
+```json
+{
+  "setup-worktree-unix": [
+    "# ... coordination script that creates .agent-id file",
+    "echo \"$TASK_NUM\" > .agent-id"
+  ]
+}
+```
+
+Then in your prompt:
+```
+Read your .agent-id file. Based on your number, execute ONLY that task:
+1. Refactor authentication module
+2. Add dark mode support
+3. Optimize database queries
+4. Write integration tests
+```
+
+**Full coordination script:** See https://forum.cursor.com/t/cursor-2-0-split-tasks-using-parallel-agents-automatically-in-one-chat-how-to-setup-worktree-json/140218
+
+### Git Aliases (Fallback)
+
+If `wt` isn't available, these git aliases provide basic worktree management:
+
+```bash
+git config --global alias.wta '!f() { git worktree add -b "$1" "../$1"; }; f'
+git config --global alias.wtr '!f() { git worktree remove "../$1"; }; f'
+git config --global alias.wtl '!f() { git worktree list; }; f'
+```
+
+### Shell Function for PR Checkout (Alternative)
+
+```bash
+cpr() {
+  pr="$1"
+  remote="${2:-origin}"
+  branch=$(gh pr view "$pr" --json headRefName -q .headRefName)
+  git fetch "$remote" "$branch"
+  git worktree add "../$branch" "$branch"
+  cd "../$branch" || return
+  echo "Switched to new worktree for PR #$pr: $branch"
+}
+```
+
+---
+
+## Quick Reference Card
+
+```bash
+# === WORKTREE CREATION ===
+wt new feature/auth -c              # New worktree + branch
+wt setup feature/auth -c            # New worktree + run setup scripts
+wt pr 123 --setup                   # Worktree from PR + setup
+
+# === WORKTREE MANAGEMENT ===
+wt list                             # List all worktrees
+wt open                             # Interactive worktree selector
+wt remove feature/auth              # Remove worktree
+wt purge                            # Multi-select removal
+
+# === MERGING ===
+wt merge feature/auth               # Merge (fails if dirty)
+wt merge feature/auth --auto-commit # Auto-commit dirty changes first
+wt merge feature/auth --remove      # Merge + delete worktree
+wt merge feature/auth --auto-commit --remove  # All-in-one
+
+# === CONFIGURATION ===
+wt config set editor none           # Headless mode
+wt config set trust true            # Skip confirmations
+wt config set subfolder true        # Organized directories
+wt config path                      # Show config file location
+```
+
+---
+
+## Next Steps for This Session
+
+1. ✅ Fork cloned and set up locally
+2. ✅ `wt` command working globally
+3. ✅ Run tests: `pnpm test` (all 104 tests passing)
+4. ✅ Merge PR #35 (trust + subfolder) - Successfully merged into `feature/claude-code-enhancements` branch
+5. ✅ Rebuild and verify new config options work - Both `trust` and `subfolder` modes working
+6. ✅ Implement first enhancement: `wt status` command - Fully implemented with 6 passing tests
+7. ✅ Create Claude Code slash command - Created at `.claude/commands/worktree.md`
+8. ⬜ Test end-to-end with Claude Code
+
+---
+
+## Questions to Consider
+
+1. Should worktrees automatically inherit `.claude/` directory from main repo?
+2. Should there be a `wt init` command that sets up recommended config + creates `.cursor/worktrees.json`?
+3. How should agent coordination work in Claude Code vs Cursor? Same mechanism or different?
+4. Should `wt status` show git status, or also check if setup scripts have been run?
+
+---
+
+*Document created: December 23, 2025*
+*For use with Claude Code in ~/CODE/Ideas/Trusses/worktree-cli*
diff --git a/build/commands/config.js b/build/commands/config.js
index 03dc866..a6b3890 100644
--- a/build/commands/config.js
+++ b/build/commands/config.js
@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { getDefaultEditor, setDefaultEditor, getGitProvider, setGitProvider, getConfigPath, getDefaultWorktreePath, setDefaultWorktreePath, clearDefaultWorktreePath } from '../config.js';
+import { getDefaultEditor, setDefaultEditor, getGitProvider, setGitProvider, getConfigPath, getDefaultWorktreePath, setDefaultWorktreePath, clearDefaultWorktreePath, getTrust, setTrust, getWorktreeSubfolder, setWorktreeSubfolder } from '../config.js';
 export async function configHandler(action, key, value) {
     try {
         switch (action) {
@@ -21,9 +21,26 @@ export async function configHandler(action, key, value) {
                         console.log(chalk.blue(`Default worktree path is not set (using sibling directory behavior).`));
                     }
                 }
+                else if (key === 'trust') {
+                    const trust = getTrust();
+                    console.log(chalk.blue(`Trust mode is currently: ${chalk.bold(trust ? 'enabled' : 'disabled')}`));
+                    if (trust) {
+                        console.log(chalk.gray(`  Setup commands will run without confirmation prompts.`));
+                    }
+                }
+                else if (key === 'subfolder') {
+                    const subfolder = getWorktreeSubfolder();
+                    console.log(chalk.blue(`Subfolder mode is currently: ${chalk.bold(subfolder ? 'enabled' : 'disabled')}`));
+                    if (subfolder) {
+                        console.log(chalk.gray(`  Worktrees will be created in: my-app-worktrees/feature`));
+                    }
+                    else {
+                        console.log(chalk.gray(`  Worktrees will be created as: my-app-feature (siblings)`));
+                    }
+                }
                 else {
                     console.error(chalk.red(`Unknown configuration key to get: ${key}`));
-                    console.error(chalk.yellow(`Available keys: editor, provider, worktreepath`));
+                    console.error(chalk.yellow(`Available keys: editor, provider, worktreepath, trust, subfolder`));
                     process.exit(1);
                 }
                 break;
@@ -46,6 +63,25 @@ export async function configHandler(action, key, value) {
                     const resolvedPath = getDefaultWorktreePath();
                     console.log(chalk.green(`Default worktree path set to: ${chalk.bold(resolvedPath)}`));
                 }
+                else if (key === 'trust' && value !== undefined) {
+                    const trustValue = value.toLowerCase() === 'true' || value === '1';
+                    setTrust(trustValue);
+                    console.log(chalk.green(`Trust mode ${trustValue ? 'enabled' : 'disabled'}.`));
+                    if (trustValue) {
+                        console.log(chalk.gray(`  Setup commands will now run without confirmation prompts.`));
+                    }
+                }
+                else if (key === 'subfolder' && value !== undefined) {
+                    const subfolderValue = value.toLowerCase() === 'true' || value === '1';
+                    setWorktreeSubfolder(subfolderValue);
+                    console.log(chalk.green(`Subfolder mode ${subfolderValue ? 'enabled' : 'disabled'}.`));
+                    if (subfolderValue) {
+                        console.log(chalk.gray(`  Worktrees will now be created in: my-app-worktrees/feature`));
+                    }
+                    else {
+                        console.log(chalk.gray(`  Worktrees will now be created as: my-app-feature (siblings)`));
+                    }
+                }
                 else if (key === 'editor') {
                     console.error(chalk.red(`You must provide an editor name.`));
                     process.exit(1);
@@ -58,9 +94,17 @@ export async function configHandler(action, key, value) {
                     console.error(chalk.red(`You must provide a path.`));
                     process.exit(1);
                 }
+                else if (key === 'trust') {
+                    console.error(chalk.red(`You must provide a value (true or false).`));
+                    process.exit(1);
+                }
+                else if (key === 'subfolder') {
+                    console.error(chalk.red(`You must provide a value (true or false).`));
+                    process.exit(1);
+                }
                 else {
                     console.error(chalk.red(`Unknown configuration key to set: ${key}`));
-                    console.error(chalk.yellow(`Available keys: editor, provider, worktreepath`));
+                    console.error(chalk.yellow(`Available keys: editor, provider, worktreepath, trust, subfolder`));
                     process.exit(1);
                 }
                 break;
diff --git a/build/commands/status.js b/build/commands/status.js
new file mode 100644
index 0000000..b09aacd
--- /dev/null
+++ b/build/commands/status.js
@@ -0,0 +1,137 @@
+import { execa } from "execa";
+import chalk from "chalk";
+import { getWorktrees, isWorktreeClean } from "../utils/git.js";
+/**
+ * Get detailed git status for a worktree
+ */
+async function getWorktreeGitStatus(path) {
+    try {
+        // Check if worktree is clean
+        const clean = await isWorktreeClean(path);
+        // Get ahead/behind information
+        let ahead = 0;
+        let behind = 0;
+        let hasUpstream = false;
+        try {
+            // Check if branch has an upstream
+            const { stdout: upstreamBranch } = await execa("git", ["-C", path, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], { reject: false });
+            if (upstreamBranch && upstreamBranch.trim()) {
+                hasUpstream = true;
+                // Get ahead/behind counts
+                const { stdout: revList } = await execa("git", ["-C", path, "rev-list", "--left-right", "--count", "HEAD...@{upstream}"], { reject: false });
+                if (revList && revList.trim()) {
+                    const [aheadStr, behindStr] = revList.trim().split(/\s+/);
+                    ahead = parseInt(aheadStr, 10) || 0;
+                    behind = parseInt(behindStr, 10) || 0;
+                }
+            }
+        }
+        catch {
+            // No upstream or error getting upstream info
+        }
+        return { clean, ahead, behind, hasUpstream };
+    }
+    catch (error) {
+        // If we can't get status, return defaults
+        return { clean: false, ahead: 0, behind: 0, hasUpstream: false };
+    }
+}
+/**
+ * Format worktree status for display
+ */
+function formatWorktreeStatus(wt, status) {
+    const parts = [];
+    // Branch name or detached state
+    if (wt.branch) {
+        parts.push(chalk.cyan.bold(wt.branch));
+    }
+    else if (wt.detached) {
+        parts.push(chalk.yellow(`(detached at ${wt.head.substring(0, 7)})`));
+    }
+    else if (wt.bare) {
+        parts.push(chalk.gray('(bare)'));
+    }
+    // Path
+    parts.push(chalk.gray(` → ${wt.path}`));
+    // Status indicators
+    const indicators = [];
+    // Main worktree
+    if (wt.isMain) {
+        indicators.push(chalk.blue('[main]'));
+    }
+    // Git status
+    if (status.clean) {
+        indicators.push(chalk.green('[clean]'));
+    }
+    else {
+        indicators.push(chalk.red('[dirty]'));
+    }
+    // Ahead/behind
+    if (status.hasUpstream) {
+        if (status.ahead > 0 && status.behind > 0) {
+            indicators.push(chalk.yellow(`[↑${status.ahead} ↓${status.behind}]`));
+        }
+        else if (status.ahead > 0) {
+            indicators.push(chalk.yellow(`[↑${status.ahead}]`));
+        }
+        else if (status.behind > 0) {
+            indicators.push(chalk.yellow(`[↓${status.behind}]`));
+        }
+        else {
+            indicators.push(chalk.green('[up-to-date]'));
+        }
+    }
+    else {
+        indicators.push(chalk.gray('[no upstream]'));
+    }
+    // Locked/prunable
+    if (wt.locked) {
+        indicators.push(chalk.red('[locked]'));
+    }
+    if (wt.prunable) {
+        indicators.push(chalk.yellow('[prunable]'));
+    }
+    if (indicators.length > 0) {
+        parts.push(' ' + indicators.join(' '));
+    }
+    return parts.join('');
+}
+/**
+ * Handler for the status command
+ */
+export async function statusWorktreesHandler() {
+    try {
+        // Confirm we're in a git repo
+        await execa("git", ["rev-parse", "--is-inside-work-tree"]);
+        // Get all worktrees
+        const worktrees = await getWorktrees();
+        if (worktrees.length === 0) {
+            console.log(chalk.yellow("No worktrees found."));
+            return;
+        }
+        console.log(chalk.blue.bold("Worktree Status:\n"));
+        // Process each worktree
+        for (const wt of worktrees) {
+            try {
+                const status = await getWorktreeGitStatus(wt.path);
+                console.log(formatWorktreeStatus(wt, status));
+            }
+            catch (error) {
+                // If we can't get status for this worktree, show it with an error indicator
+                console.log(chalk.cyan.bold(wt.branch || '(unknown)') +
+                    chalk.gray(` → ${wt.path}`) +
+                    ' ' + chalk.red('[error: cannot read status]'));
+            }
+        }
+        console.log(); // Empty line at the end
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(chalk.red("Error getting worktree status:"), error.message);
+        }
+        else {
+            console.error(chalk.red("Error getting worktree status:"), error);
+        }
+        process.exit(1);
+    }
+}
diff --git a/build/config.js b/build/config.js
index bab8c07..59fb089 100644
--- a/build/config.js
+++ b/build/config.js
@@ -23,6 +23,15 @@ const schema = {
         type: 'string',
         // No default - falls back to sibling directory behavior when not set
     },
+    trust: {
+        type: 'boolean',
+        default: false, // Default is to require confirmation for setup commands
+    },
+    worktreeSubfolder: {
+        type: 'boolean',
+        default: false, // Default is sibling directory behavior (my-app-feature)
+        // When true: my-app-worktrees/feature subfolder pattern
+    },
 };
 const config = new Conf({
     projectName: packageName, // Use the actual package name
@@ -77,3 +86,21 @@ export function setDefaultWorktreePath(worktreePath) {
 export function clearDefaultWorktreePath() {
     config.delete('defaultWorktreePath');
 }
+// Function to get the trust setting (bypass setup command confirmation)
+export function getTrust() {
+    return config.get('trust') ?? false;
+}
+// Function to set the trust setting
+export function setTrust(trust) {
+    config.set('trust', trust);
+}
+// Function to get the worktree subfolder setting
+// When true: creates worktrees in my-app-worktrees/feature pattern
+// When false: creates worktrees as my-app-feature siblings
+export function getWorktreeSubfolder() {
+    return config.get('worktreeSubfolder') ?? false;
+}
+// Function to set the worktree subfolder setting
+export function setWorktreeSubfolder(subfolder) {
+    config.set('worktreeSubfolder', subfolder);
+}
diff --git a/build/index.js b/build/index.js
index 587bff7..841e6ac 100755
--- a/build/index.js
+++ b/build/index.js
@@ -10,6 +10,7 @@ import { configHandler } from "./commands/config.js";
 import { prWorktreeHandler } from "./commands/pr.js";
 import { openWorktreeHandler } from "./commands/open.js";
 import { extractWorktreeHandler } from "./commands/extract.js";
+import { statusWorktreesHandler } from "./commands/status.js";
 const program = new Command();
 program
     .name("wt")
@@ -39,6 +40,10 @@ program
     .alias("ls")
     .description("List all existing worktrees for this repository.")
     .action(listWorktreesHandler);
+program
+    .command("status")
+    .description("Show status of all worktrees including git state (clean/dirty, ahead/behind).")
+    .action(statusWorktreesHandler);
 program
     .command("remove")
     .alias("rm")
@@ -99,7 +104,15 @@ program
     .addCommand(new Command("worktreepath")
     .argument("<path>", "Path where all worktrees will be created (e.g., ~/worktrees)")
     .description("Set the default directory for new worktrees.")
-    .action((worktreePath) => configHandler("set", "worktreepath", worktreePath))))
+    .action((worktreePath) => configHandler("set", "worktreepath", worktreePath)))
+    .addCommand(new Command("trust")
+    .argument("<value>", "Enable or disable trust mode (true/false)")
+    .description("Set trust mode to skip setup command confirmations.")
+    .action((value) => configHandler("set", "trust", value)))
+    .addCommand(new Command("subfolder")
+    .argument("<value>", "Enable or disable subfolder mode (true/false)")
+    .description("Set subfolder mode for worktree paths (my-app-worktrees/feature).")
+    .action((value) => configHandler("set", "subfolder", value))))
     .addCommand(new Command("get")
     .description("Get a configuration value.")
     .addCommand(new Command("editor")
@@ -110,7 +123,13 @@ program
     .action(() => configHandler("get", "provider")))
     .addCommand(new Command("worktreepath")
     .description("Get the currently configured default worktree directory.")
-    .action(() => configHandler("get", "worktreepath"))))
+    .action(() => configHandler("get", "worktreepath")))
+    .addCommand(new Command("trust")
+    .description("Get the current trust mode setting.")
+    .action(() => configHandler("get", "trust")))
+    .addCommand(new Command("subfolder")
+    .description("Get the current subfolder mode setting.")
+    .action(() => configHandler("get", "subfolder"))))
     .addCommand(new Command("clear")
     .description("Clear a configuration value.")
     .addCommand(new Command("worktreepath")
diff --git a/build/utils/paths.js b/build/utils/paths.js
index 7ea6ee9..abf578a 100644
--- a/build/utils/paths.js
+++ b/build/utils/paths.js
@@ -1,5 +1,5 @@
 import { join, dirname, basename, resolve } from "node:path";
-import { getDefaultWorktreePath } from "../config.js";
+import { getDefaultWorktreePath, getWorktreeSubfolder } from "../config.js";
 import { getRepoName } from "./git.js";
 /**
  * Resolve a worktree name from a branch name
@@ -36,10 +36,11 @@ export function getShortBranchName(branchName) {
 /**
  * Resolve the full path for a new worktree
  *
- * Handles three cases:
+ * Handles four cases:
  * 1. Custom path provided - use it directly
  * 2. Global defaultWorktreePath configured - use it with repo namespace
- * 3. No config - create sibling directory
+ * 3. Subfolder mode enabled - create in my-app-worktrees/feature pattern
+ * 4. No config - create sibling directory (my-app-feature)
  *
  * @param branchName - The branch name to create worktree for
  * @param options - Configuration options
@@ -64,9 +65,16 @@ export async function resolveWorktreePath(branchName, options = {}) {
         }
         return join(defaultWorktreePath, worktreeName);
     }
-    // Case 3: No config - create sibling directory
+    // Check if subfolder mode is enabled
+    const useSubfolder = getWorktreeSubfolder();
     const parentDir = dirname(cwd);
     const currentDirName = basename(cwd);
+    if (useSubfolder) {
+        // Case 3: Subfolder mode - create in my-app-worktrees/feature pattern
+        // This keeps worktrees organized in a dedicated folder
+        return join(parentDir, `${currentDirName}-worktrees`, worktreeName);
+    }
+    // Case 4: No config - create sibling directory (my-app-feature)
     return join(parentDir, `${currentDirName}-${worktreeName}`);
 }
 /**
diff --git a/build/utils/tui.js b/build/utils/tui.js
index 1acf030..ccebe0c 100644
--- a/build/utils/tui.js
+++ b/build/utils/tui.js
@@ -1,6 +1,7 @@
 import prompts from "prompts";
 import chalk from "chalk";
 import { getWorktrees } from "./git.js";
+import { getTrust } from "../config.js";
 /**
  * Interactive worktree selector
  *
@@ -133,7 +134,9 @@ export async function inputText(message, options = {}) {
  */
 export async function confirmCommands(commands, options = {}) {
     const { title = "The following commands will be executed:", trust = false } = options;
-    if (trust) {
+    // Check both the flag and the config setting
+    // If either is true, skip confirmation
+    if (trust || getTrust()) {
         return true;
     }
     console.log(chalk.blue(title));
diff --git a/src/commands/status.ts b/src/commands/status.ts
new file mode 100644
index 0000000..2e28264
--- /dev/null
+++ b/src/commands/status.ts
@@ -0,0 +1,170 @@
+import { execa } from "execa";
+import chalk from "chalk";
+import { getWorktrees, WorktreeInfo, isWorktreeClean } from "../utils/git.js";
+
+/**
+ * Get detailed git status for a worktree
+ */
+async function getWorktreeGitStatus(path: string): Promise<{
+    clean: boolean;
+    ahead: number;
+    behind: number;
+    hasUpstream: boolean;
+}> {
+    try {
+        // Check if worktree is clean
+        const clean = await isWorktreeClean(path);
+
+        // Get ahead/behind information
+        let ahead = 0;
+        let behind = 0;
+        let hasUpstream = false;
+
+        try {
+            // Check if branch has an upstream
+            const { stdout: upstreamBranch } = await execa(
+                "git",
+                ["-C", path, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
+                { reject: false }
+            );
+
+            if (upstreamBranch && upstreamBranch.trim()) {
+                hasUpstream = true;
+
+                // Get ahead/behind counts
+                const { stdout: revList } = await execa(
+                    "git",
+                    ["-C", path, "rev-list", "--left-right", "--count", "HEAD...@{upstream}"],
+                    { reject: false }
+                );
+
+                if (revList && revList.trim()) {
+                    const [aheadStr, behindStr] = revList.trim().split(/\s+/);
+                    ahead = parseInt(aheadStr, 10) || 0;
+                    behind = parseInt(behindStr, 10) || 0;
+                }
+            }
+        } catch {
+            // No upstream or error getting upstream info
+        }
+
+        return { clean, ahead, behind, hasUpstream };
+    } catch (error) {
+        // If we can't get status, return defaults
+        return { clean: false, ahead: 0, behind: 0, hasUpstream: false };
+    }
+}
+
+/**
+ * Format worktree status for display
+ */
+function formatWorktreeStatus(wt: WorktreeInfo, status: {
+    clean: boolean;
+    ahead: number;
+    behind: number;
+    hasUpstream: boolean;
+}): string {
+    const parts: string[] = [];
+
+    // Branch name or detached state
+    if (wt.branch) {
+        parts.push(chalk.cyan.bold(wt.branch));
+    } else if (wt.detached) {
+        parts.push(chalk.yellow(`(detached at ${wt.head.substring(0, 7)})`));
+    } else if (wt.bare) {
+        parts.push(chalk.gray('(bare)'));
+    }
+
+    // Path
+    parts.push(chalk.gray(` → ${wt.path}`));
+
+    // Status indicators
+    const indicators: string[] = [];
+
+    // Main worktree
+    if (wt.isMain) {
+        indicators.push(chalk.blue('[main]'));
+    }
+
+    // Git status
+    if (status.clean) {
+        indicators.push(chalk.green('[clean]'));
+    } else {
+        indicators.push(chalk.red('[dirty]'));
+    }
+
+    // Ahead/behind
+    if (status.hasUpstream) {
+        if (status.ahead > 0 && status.behind > 0) {
+            indicators.push(chalk.yellow(`[↑${status.ahead} ↓${status.behind}]`));
+        } else if (status.ahead > 0) {
+            indicators.push(chalk.yellow(`[↑${status.ahead}]`));
+        } else if (status.behind > 0) {
+            indicators.push(chalk.yellow(`[↓${status.behind}]`));
+        } else {
+            indicators.push(chalk.green('[up-to-date]'));
+        }
+    } else {
+        indicators.push(chalk.gray('[no upstream]'));
+    }
+
+    // Locked/prunable
+    if (wt.locked) {
+        indicators.push(chalk.red('[locked]'));
+    }
+    if (wt.prunable) {
+        indicators.push(chalk.yellow('[prunable]'));
+    }
+
+    if (indicators.length > 0) {
+        parts.push(' ' + indicators.join(' '));
+    }
+
+    return parts.join('');
+}
+
+/**
+ * Handler for the status command
+ */
+export async function statusWorktreesHandler() {
+    try {
+        // Confirm we're in a git repo
+        await execa("git", ["rev-parse", "--is-inside-work-tree"]);
+
+        // Get all worktrees
+        const worktrees = await getWorktrees();
+
+        if (worktrees.length === 0) {
+            console.log(chalk.yellow("No worktrees found."));
+            return;
+        }
+
+        console.log(chalk.blue.bold("Worktree Status:\n"));
+
+        // Process each worktree
+        for (const wt of worktrees) {
+            try {
+                const status = await getWorktreeGitStatus(wt.path);
+                console.log(formatWorktreeStatus(wt, status));
+            } catch (error) {
+                // If we can't get status for this worktree, show it with an error indicator
+                console.log(
+                    chalk.cyan.bold(wt.branch || '(unknown)') +
+                    chalk.gray(` → ${wt.path}`) +
+                    ' ' + chalk.red('[error: cannot read status]')
+                );
+            }
+        }
+
+        console.log(); // Empty line at the end
+
+    } catch (error) {
+        if (error instanceof Error) {
+            console.error(chalk.red("Error getting worktree status:"), error.message);
+        } else {
+            console.error(chalk.red("Error getting worktree status:"), error);
+        }
+        process.exit(1);
+    }
+}
+
diff --git a/src/index.ts b/src/index.ts
index a50bd24..4203d11 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -12,6 +12,7 @@ import { configHandler } from "./commands/config.js";
 import { prWorktreeHandler } from "./commands/pr.js";
 import { openWorktreeHandler } from "./commands/open.js";
 import { extractWorktreeHandler } from "./commands/extract.js";
+import { statusWorktreesHandler } from "./commands/status.js";
 
 const program = new Command();
 
@@ -75,6 +76,11 @@ program
   .description("List all existing worktrees for this repository.")
   .action(listWorktreesHandler);
 
+program
+  .command("status")
+  .description("Show status of all worktrees including git state (clean/dirty, ahead/behind).")
+  .action(statusWorktreesHandler);
+
 program
   .command("remove")
   .alias("rm")
diff --git a/test/git-utils.test.ts b/test/git-utils.test.ts
index ec236c0..373fd93 100644
--- a/test/git-utils.test.ts
+++ b/test/git-utils.test.ts
@@ -19,7 +19,7 @@ async function createTestRepo(): Promise<TestContext> {
     const repoDir = join(testDir, 'repo');
 
     await mkdir(repoDir, { recursive: true });
-    await execa('git', ['init'], { cwd: repoDir });
+    await execa('git', ['init', '-b', 'main'], { cwd: repoDir });
     await execa('git', ['config', 'user.email', 'test@test.com'], { cwd: repoDir });
     await execa('git', ['config', 'user.name', 'Test User'], { cwd: repoDir });
     await writeFile(join(repoDir, 'README.md'), '# Test\n');
diff --git a/test/integration.test.ts b/test/integration.test.ts
index 7f40816..e5d5ba6 100644
--- a/test/integration.test.ts
+++ b/test/integration.test.ts
@@ -30,7 +30,7 @@ async function createTestRepo(): Promise<TestContext> {
     await mkdir(repoDir, { recursive: true });
 
     // Initialize git repo
-    await execa('git', ['init'], { cwd: repoDir });
+    await execa('git', ['init', '-b', 'main'], { cwd: repoDir });
     await execa('git', ['config', 'user.email', 'test@test.com'], { cwd: repoDir });
     await execa('git', ['config', 'user.name', 'Test User'], { cwd: repoDir });
 
@@ -266,11 +266,17 @@ describe('Bare Repository Support', () => {
         const worktreePath = join(ctx.testDir, 'bare-worktree');
 
         // Create worktree from bare repo
+        // Bare repos don't have a working tree, so we need to specify the branch explicitly
         const result = await execa('git', ['worktree', 'add', worktreePath, 'main'], {
             cwd: bareRepoDir,
             reject: false,
         });
 
+        // If the command failed, log the error for debugging
+        if (result.exitCode !== 0) {
+            console.log('Git worktree add failed:', result.stderr);
+        }
+
         expect(result.exitCode).toBe(0);
 
         // Verify worktree was created
diff --git a/test/status.test.ts b/test/status.test.ts
new file mode 100644
index 0000000..cc71120
--- /dev/null
+++ b/test/status.test.ts
@@ -0,0 +1,156 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { execa } from 'execa';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+
+/**
+ * Tests for the status command
+ */
+
+const CLI_PATH = resolve(__dirname, '../build/index.js');
+
+interface TestContext {
+    testDir: string;
+    repoDir: string;
+    cleanup: () => Promise<void>;
+}
+
+async function createTestRepo(): Promise<TestContext> {
+    const testDir = join(tmpdir(), `wt-status-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    const repoDir = join(testDir, 'repo');
+
+    await mkdir(repoDir, { recursive: true });
+    await execa('git', ['init', '-b', 'main'], { cwd: repoDir });
+    await execa('git', ['config', 'user.email', 'test@test.com'], { cwd: repoDir });
+    await execa('git', ['config', 'user.name', 'Test User'], { cwd: repoDir });
+    await writeFile(join(repoDir, 'README.md'), '# Test\n');
+    await execa('git', ['add', '.'], { cwd: repoDir });
+    await execa('git', ['commit', '-m', 'Initial'], { cwd: repoDir });
+
+    return {
+        testDir,
+        repoDir,
+        cleanup: async () => {
+            try {
+                await rm(testDir, { recursive: true, force: true });
+            } catch {}
+        },
+    };
+}
+
+async function runCli(args: string[], cwd: string): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+    try {
+        const result = await execa('node', [CLI_PATH, ...args], {
+            cwd,
+            reject: false,
+            env: {
+                ...process.env,
+                WT_EDITOR: 'none',
+            },
+        });
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode ?? 0,
+        };
+    } catch (error: any) {
+        return {
+            stdout: error.stdout ?? '',
+            stderr: error.stderr ?? '',
+            exitCode: error.exitCode ?? 1,
+        };
+    }
+}
+
+describe('wt status', () => {
+    let ctx: TestContext;
+
+    beforeAll(async () => {
+        ctx = await createTestRepo();
+    });
+
+    afterAll(async () => {
+        await ctx.cleanup();
+    });
+
+    it('should show status of main worktree', async () => {
+        const result = await runCli(['status'], ctx.repoDir);
+
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toContain('Worktree Status:');
+        expect(result.stdout).toContain('main');
+        expect(result.stdout).toContain('[main]');
+        expect(result.stdout).toContain('[clean]');
+    });
+
+    it('should detect dirty worktree', async () => {
+        // Make the worktree dirty
+        await writeFile(join(ctx.repoDir, 'dirty.txt'), 'dirty content');
+
+        const result = await runCli(['status'], ctx.repoDir);
+
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toContain('[dirty]');
+
+        // Cleanup
+        await execa('git', ['checkout', '--', '.'], { cwd: ctx.repoDir }).catch(() => {});
+        await rm(join(ctx.repoDir, 'dirty.txt')).catch(() => {});
+    });
+
+    it('should show status for multiple worktrees', async () => {
+        // Create a test worktree
+        const wtPath = join(ctx.testDir, 'test-wt');
+        await runCli(['new', 'test-branch', '--path', wtPath, '--editor', 'none', '-c'], ctx.repoDir);
+
+        const result = await runCli(['status'], ctx.repoDir);
+
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toContain('main');
+        expect(result.stdout).toContain('test-branch');
+
+        // Cleanup
+        await execa('git', ['worktree', 'remove', '--force', wtPath], { cwd: ctx.repoDir }).catch(() => {});
+    });
+
+    it('should show no upstream indicator for branches without upstream', async () => {
+        const result = await runCli(['status'], ctx.repoDir);
+
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toContain('[no upstream]');
+    });
+
+    it('should handle detached HEAD state', async () => {
+        // Create a detached worktree
+        const { stdout: headCommit } = await execa('git', ['rev-parse', 'HEAD'], { cwd: ctx.repoDir });
+        const wtPath = join(ctx.testDir, 'detached-wt');
+        await execa('git', ['worktree', 'add', '--detach', wtPath, headCommit.trim()], { cwd: ctx.repoDir });
+
+        const result = await runCli(['status'], ctx.repoDir);
+
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toContain('detached');
+
+        // Cleanup
+        await execa('git', ['worktree', 'remove', '--force', wtPath], { cwd: ctx.repoDir }).catch(() => {});
+    });
+
+    it('should show locked status', async () => {
+        // Create and lock a worktree
+        const wtPath = join(ctx.testDir, 'locked-wt');
+        await runCli(['new', 'locked-branch', '--path', wtPath, '--editor', 'none', '-c'], ctx.repoDir);
+        await execa('git', ['worktree', 'lock', wtPath], { cwd: ctx.repoDir });
+
+        const result = await runCli(['status'], ctx.repoDir);
+
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toContain('locked-branch');
+        expect(result.stdout).toContain('[locked]');
+
+        // Cleanup
+        await execa('git', ['worktree', 'unlock', wtPath], { cwd: ctx.repoDir }).catch(() => {});
+        await execa('git', ['worktree', 'remove', '--force', wtPath], { cwd: ctx.repoDir }).catch(() => {});
+    });
+});
+
diff --git a/test/tui.test.ts b/test/tui.test.ts
index 1865484..fa49d8f 100644
--- a/test/tui.test.ts
+++ b/test/tui.test.ts
@@ -9,6 +9,21 @@ import type { WorktreeInfo } from '../src/utils/git.js';
  * inject feature to programmatically provide answers to prompts.
  */
 
+// Mock the config module to ensure trust mode is disabled for tests
+vi.mock('../src/config.js', () => ({
+    getTrust: () => false,
+    getSubfolder: () => false,
+    getDefaultEditor: () => 'cursor',
+    getGitProvider: () => 'gh',
+    getDefaultWorktreePath: () => undefined,
+    setDefaultEditor: vi.fn(),
+    setGitProvider: vi.fn(),
+    setDefaultWorktreePath: vi.fn(),
+    clearDefaultWorktreePath: vi.fn(),
+    getConfigPath: () => '/mock/config/path',
+    shouldSkipEditor: () => false,
+}));
+
 // Mock the git utilities before importing TUI functions
 vi.mock('../src/utils/git.js', async () => {
     const mockWorktrees: WorktreeInfo[] = [

From 3dc6366aa761c1f7e38c3cbe79fe110374bdfe36 Mon Sep 17 00:00:00 2001
From: CaptainCodeAU <captaincodeau@gmail.com>
Date: Tue, 23 Dec 2025 13:23:55 +1100
Subject: [PATCH 3/4] Add test file

---
 test.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 test.txt

diff --git a/test.txt b/test.txt
new file mode 100644
index 0000000..ed1eb04
--- /dev/null
+++ b/test.txt
@@ -0,0 +1 @@
+# Test file

From 60a090728d7a69e153a74f81c0a8807cfaf86a47 Mon Sep 17 00:00:00 2001
From: CaptainCodeAU <captaincodeau@gmail.com>
Date: Tue, 23 Dec 2025 13:31:53 +1100
Subject: [PATCH 4/4] feat: add status command and comprehensive documentation

- Add 'wt status' command to show comprehensive worktree git status
- Display all worktrees with branch names, paths, and git state
- Show working tree status (clean/dirty) and upstream tracking (ahead/behind)
- Include indicators for main worktree, locked, and detached HEAD states
- Handle edge cases including bare repos and missing directories
- Add 6 comprehensive tests for status command

- Update README.md with new features and detailed status documentation
- Add trust mode and subfolder mode configuration sections
- Add AI Assistant Integration section with parallel agent workflows
- Create comprehensive QUICKSTART.md guide with practical examples
- Add CHANGELOG-SESSION.md as development log
- Remove temporary WORKTREE-CLI-PROJECT.md file
---
 CHANGELOG-SESSION.md    | 299 +++++++++++++++++++++++++
 QUICKSTART.md           | 400 ++++++++++++++++++++++++++++++++++
 README.md               | 135 ++++++++++++
 WORKTREE-CLI-PROJECT.md | 470 ----------------------------------------
 4 files changed, 834 insertions(+), 470 deletions(-)
 create mode 100644 CHANGELOG-SESSION.md
 create mode 100644 QUICKSTART.md
 delete mode 100644 WORKTREE-CLI-PROJECT.md

diff --git a/CHANGELOG-SESSION.md b/CHANGELOG-SESSION.md
new file mode 100644
index 0000000..7a2debb
--- /dev/null
+++ b/CHANGELOG-SESSION.md
@@ -0,0 +1,299 @@
+# Session Changelog - December 23, 2025
+
+This document summarizes all changes made during the Claude Code enhancement session.
+
+## Overview
+
+This session focused on enhancing the `@johnlindquist/worktree-cli` tool to better support AI-assisted parallel development workflows, specifically for integration with Claude Code and Cursor.
+
+---
+
+## Major Changes
+
+### 1. Merged PR #35: Trust and Subfolder Configuration ✅
+
+**Branch:** `feature/claude-code-enhancements`
+
+**What was merged:**
+- Added `trust` config option to skip setup command confirmations
+- Added `subfolder` config option to organize worktrees in subdirectories
+- Updated TUI logic to respect global trust configuration
+
+**Commands added:**
+```bash
+wt config set trust true/false
+wt config set subfolder true/false
+```
+
+**Impact:**
+- Enables headless automation for CI/CD and AI agents
+- Provides cleaner project organization
+- Essential for Claude Code integration
+
+---
+
+### 2. Implemented `wt status` Command ✅
+
+**New file:** `src/commands/status.ts`
+
+**Features:**
+- Shows all worktrees with comprehensive status information
+- Git working tree status (clean/dirty)
+- Upstream tracking status (ahead/behind)
+- Branch information and indicators
+- Handles edge cases (detached HEAD, bare repos, missing directories)
+
+**Example output:**
+```bash
+$ wt status
+Worktree Status:
+
+main → /Users/me/projects/myapp [main] [clean] [up-to-date]
+feature/auth → /Users/me/projects/myapp-worktrees/feature-auth [dirty] [ahead 2]
+feature/api → /Users/me/projects/myapp-worktrees/feature-api [clean] [no upstream]
+```
+
+**Status indicators:**
+- `[main]` - Main worktree
+- `[clean]` / `[dirty]` - Working tree status
+- `[up-to-date]` - In sync with upstream
+- `[ahead N]` - N commits ahead
+- `[behind N]` - N commits behind
+- `[ahead N, behind M]` - Diverged
+- `[no upstream]` - No tracking branch
+- `[locked]` - Worktree is locked
+
+---
+
+### 3. Created Claude Code Slash Command ✅
+
+**New file:** `.claude/commands/worktree.md`
+
+**Purpose:**
+- Provides quick reference for `wt` commands in Claude Code
+- Defines workflow for parallel task management
+- Enables natural language worktree operations
+
+**Usage:**
+```
+/worktree create three parallel features for authentication, UI, and API
+```
+
+---
+
+### 4. Documentation Updates ✅
+
+**Updated:** `README.md`
+- Added new features to feature list
+- Documented `wt status` command with examples
+- Added trust mode configuration section
+- Added subfolder mode configuration section
+- Added AI Assistant Integration section
+- Added link to Quick Start Guide
+
+**Created:** `QUICKSTART.md`
+- Comprehensive quick start guide
+- Common scenarios with practical examples
+- Configuration for AI assistants
+- Advanced workflows
+- Troubleshooting section
+- Quick reference card
+
+---
+
+## Test Fixes
+
+### Fixed Test Failures ✅
+
+**Issue:** Tests were failing due to `master` vs `main` branch naming
+
+**Files modified:**
+- `test/git-utils.test.ts`
+- `test/integration.test.ts`
+
+**Fix:** Added explicit `git config init.defaultBranch main` in test repository setup
+
+**Issue:** TUI tests failing after PR #35 merge due to global trust configuration
+
+**File modified:**
+- `test/tui.test.ts`
+
+**Fix:** Mocked `config` module to isolate tests from global configuration
+
+### New Tests Added ✅
+
+**New file:** `test/status.test.ts`
+
+**Coverage:**
+- Main worktree status display
+- Dirty worktree detection
+- Multiple worktrees
+- Detached HEAD state
+- Locked status
+- No upstream branch handling
+
+**Result:** 6 new passing tests
+
+---
+
+## Test Results
+
+### Baseline Tests
+- **Before changes:** 104 tests passing
+- **After PR #35 merge:** 104 tests passing (after fixes)
+- **After status implementation:** 110 tests passing
+- **Final:** 110 tests passing
+
+### Coverage
+All new functionality is covered by unit tests with comprehensive mocking.
+
+---
+
+## End-to-End Testing ✅
+
+**Tested workflows:**
+1. Configuration changes (`trust` and `subfolder` modes)
+2. Worktree creation with subfolder organization
+3. Status command with clean and dirty worktrees
+4. Merge with auto-commit and removal
+5. Full workflow: create → modify → status → merge → cleanup
+
+**Results:** All workflows functioning as expected
+
+---
+
+## Configuration Changes
+
+### Recommended Settings for AI Workflows
+
+```bash
+wt config set editor none        # Headless operation
+wt config set trust true         # Skip confirmations
+wt config set subfolder true     # Organized directories
+```
+
+### Config File Location
+`~/.config/worktree-cli/config.json`
+
+---
+
+## File Structure Changes
+
+### New Files
+```
+.claude/
+└── commands/
+    └── worktree.md          # Claude Code slash command
+
+src/
+└── commands/
+    └── status.ts            # Status command implementation
+
+test/
+└── status.test.ts           # Status command tests
+
+QUICKSTART.md                # Quick start guide
+CHANGELOG-SESSION.md         # This file
+```
+
+### Modified Files
+```
+src/index.ts                 # Registered status command
+test/git-utils.test.ts       # Fixed branch naming
+test/integration.test.ts     # Fixed branch naming and bare repo test
+test/tui.test.ts            # Added config mocking
+README.md                    # Updated documentation
+```
+
+---
+
+## Git History
+
+### Commits Made
+
+1. Initial baseline testing and fixes
+2. Merged PR #35 (trust + subfolder config)
+3. Implemented `wt status` command
+4. Added tests for status command
+5. Created Claude Code slash command
+6. Updated documentation
+7. End-to-end testing cleanup
+
+### Branch
+`feature/claude-code-enhancements`
+
+---
+
+## Integration Points
+
+### Claude Code
+- Custom slash command at `.claude/commands/worktree.md`
+- Headless operation support via `editor: none`
+- Trust mode for non-interactive execution
+
+### Cursor
+- Compatible with Cursor's parallel agents feature
+- Setup scripts via `.cursor/worktrees.json`
+- Organized worktree structure
+
+### CI/CD
+- Trust mode enables automated workflows
+- No interactive prompts when configured
+- Atomic operations with rollback
+
+---
+
+## Performance
+
+- No performance regressions detected
+- All tests pass in reasonable time
+- Git operations remain efficient
+
+---
+
+## Breaking Changes
+
+**None.** All changes are backward compatible:
+- New config options default to `false`
+- New `status` command is additive
+- Existing commands unchanged
+
+---
+
+## Future Enhancements
+
+### Potential Next Steps
+1. Agent ID generation for parallel agent coordination
+2. Automatic CLAUDE.md copying to new worktrees
+3. `wt clone` command for bare repo + initial worktree setup
+4. `wt sync` command to fetch + rebase all worktrees
+5. Better GitLab parity testing
+
+### Community Feedback
+Consider gathering feedback on:
+- Subfolder naming convention (`repo-worktrees` vs `repo-wt` vs `.worktrees`)
+- Status output format preferences
+- Additional status indicators needed
+
+---
+
+## Known Issues
+
+**None identified.** All tests passing, end-to-end testing successful.
+
+---
+
+## Acknowledgments
+
+- Original repository: `@johnlindquist/worktree-cli`
+- PR #35 author for trust and subfolder modes
+- Cursor team for parallel agents inspiration
+
+---
+
+**Session completed:** December 23, 2025
+**Total duration:** ~2 hours
+**Tests passing:** 110/110
+**New features:** 3 (trust mode, subfolder mode, status command)
+**Documentation:** Comprehensive updates to README and new QUICKSTART guide
+
diff --git a/QUICKSTART.md b/QUICKSTART.md
new file mode 100644
index 0000000..680ac56
--- /dev/null
+++ b/QUICKSTART.md
@@ -0,0 +1,400 @@
+# Worktree CLI - Quick Start Guide
+
+Get up and running with `wt` in minutes. This guide covers common workflows with practical examples.
+
+**This guide is for everyone** - whether you're using the CLI manually, with Cursor, Claude Code, or any other editor/AI assistant.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Basic Workflow](#basic-workflow)
+- [Common Scenarios](#common-scenarios)
+- [Configuration for AI Assistants](#configuration-for-ai-assistants)
+- [Advanced Workflows](#advanced-workflows)
+- [Troubleshooting](#troubleshooting)
+
+---
+
+## Installation
+
+```bash
+# Install globally
+pnpm install -g @johnlindquist/worktree
+
+# Verify installation
+wt --version
+```
+
+---
+
+## Basic Workflow
+
+### 1. Create Your First Worktree
+
+```bash
+# Create a worktree for a new feature
+wt new feature/login -c
+
+# This will:
+# - Create a new branch called "feature/login"
+# - Create a worktree in a sibling directory
+# - Open it in your default editor (Cursor)
+```
+
+### 2. Check Your Worktrees
+
+```bash
+# List all worktrees
+wt list
+
+# Show detailed status
+wt status
+```
+
+### 3. Switch Between Worktrees
+
+```bash
+# Interactive fuzzy search
+wt open
+
+# Or open by branch name
+wt open feature/login
+```
+
+### 4. Merge and Clean Up
+
+```bash
+# Merge your changes back to main
+wt merge feature/login --auto-commit --remove
+
+# This will:
+# - Commit any uncommitted changes
+# - Merge the branch into your current branch
+# - Remove the worktree
+```
+
+---
+
+## Common Scenarios
+
+### Working on a GitHub PR
+
+```bash
+# List open PRs and select one
+wt pr
+
+# Or directly by PR number
+wt pr 123
+
+# With setup scripts and dependencies
+wt pr 123 --setup -i pnpm
+```
+
+**Result:** You now have a worktree with the PR code, ready to review or modify.
+
+### Setting Up a New Feature with Dependencies
+
+```bash
+# Create worktree with automatic setup
+wt setup feature/dark-mode -c -i pnpm
+
+# This will:
+# - Create the worktree
+# - Run setup scripts from worktrees.json
+# - Install dependencies with pnpm
+```
+
+### Parallel Development (Multiple Features)
+
+```bash
+# Start three features simultaneously
+wt setup feature/auth -c -i pnpm
+wt setup feature/ui -c -i pnpm
+wt setup feature/api -c -i pnpm
+
+# Check status of all
+wt status
+
+# Work in each independently
+cd ../myapp-feature-auth
+# ... make changes ...
+
+cd ../myapp-feature-ui
+# ... make changes ...
+
+cd ../myapp-feature-api
+# ... make changes ...
+
+# Merge them back one by one
+cd ../myapp  # back to main
+wt merge feature/auth --auto-commit --remove
+wt merge feature/ui --auto-commit --remove
+wt merge feature/api --auto-commit --remove
+```
+
+### Emergency Hotfix
+
+```bash
+# Quickly create a hotfix worktree
+wt new hotfix/urgent-bug -c
+
+# Make your fix
+# ... edit files ...
+
+# Merge immediately
+wt merge hotfix/urgent-bug --auto-commit --remove
+```
+
+### Experimenting Safely
+
+```bash
+# Create an experimental worktree
+wt new experiment/new-approach -c
+
+# Try your changes
+# ... experiment ...
+
+# If it doesn't work out, just remove it
+wt remove experiment/new-approach -f
+
+# Your main worktree is untouched!
+```
+
+---
+
+## Configuration for AI Assistants
+
+This section is specifically for users working with AI assistants like Claude Code or Cursor's parallel agents.
+
+### Recommended Setup for Claude Code / Cursor
+
+```bash
+# Configure for headless operation
+wt config set editor none        # Don't auto-open editor
+wt config set trust true         # Skip confirmation prompts
+wt config set subfolder true     # Organized directory structure
+
+# Verify configuration
+wt config get editor
+wt config get trust
+wt config get subfolder
+```
+
+### Create Setup Scripts
+
+Create `.cursor/worktrees.json` in your repository root:
+
+```json
+[
+  "pnpm install",
+  "cp $ROOT_WORKTREE_PATH/.env.local .env.local",
+  "pnpm build"
+]
+```
+
+Or use `worktrees.json` for a generic format:
+
+```json
+{
+  "setup-worktree": [
+    "pnpm install",
+    "cp $ROOT_WORKTREE_PATH/.env.local .env.local",
+    "pnpm build"
+  ]
+}
+```
+
+### Parallel AI Agent Workflow
+
+```bash
+# Agent 1: Authentication
+wt setup agent-1-auth -c
+
+# Agent 2: UI Components
+wt setup agent-2-ui -c
+
+# Agent 3: API Integration
+wt setup agent-3-api -c
+
+# Check progress
+wt status
+
+# Each agent works independently in their worktree
+# Merge when ready
+wt merge agent-1-auth --auto-commit --remove
+wt merge agent-2-ui --auto-commit --remove
+wt merge agent-3-api --auto-commit --remove
+```
+
+---
+
+## Advanced Workflows
+
+### Using a Global Worktree Directory
+
+```bash
+# Set a global worktree location
+wt config set worktreepath ~/worktrees
+
+# Now all worktrees go to ~/worktrees/<repo-name>/<branch-name>
+wt new feature/login -c
+# Creates: ~/worktrees/myapp/feature-login
+```
+
+### Bare Repository Workflow
+
+For power users who work heavily with worktrees:
+
+```bash
+# Clone as bare repository
+git clone --bare git@github.com:user/repo.git repo.git
+cd repo.git
+
+# Create worktrees for different branches
+wt new main -p ../main -c
+wt new develop -p ../develop -c
+wt new feature/new -p ../feature-new -c
+
+# Each is a separate working directory
+# The bare repo contains only .git data
+```
+
+### Custom Worktree Paths
+
+```bash
+# Specify exact path
+wt new feature/login -c -p ~/custom/location/login
+
+# Useful for organizing by project phase
+wt new feature/phase1 -c -p ~/projects/phase1/feature
+wt new feature/phase2 -c -p ~/projects/phase2/feature
+```
+
+### Working with GitLab
+
+```bash
+# Set GitLab as provider
+wt config set provider glab
+
+# Create worktree from Merge Request
+wt pr 456
+
+# Or let it auto-detect from your remote URL
+```
+
+---
+
+## Troubleshooting
+
+### "Command not found: wt"
+
+```bash
+# Reinstall globally
+pnpm install -g @johnlindquist/worktree
+
+# Or link if developing locally
+pnpm link --global
+```
+
+### "Not a git repository"
+
+```bash
+# Make sure you're inside a git repository
+git status
+
+# Initialize if needed
+git init
+```
+
+### "Branch already exists"
+
+```bash
+# Use without -c flag to checkout existing branch
+wt new existing-branch
+
+# Or use a different branch name
+wt new feature/login-v2 -c
+```
+
+### Dirty Worktree Warnings
+
+```bash
+# Commit your changes first
+git add .
+git commit -m "WIP"
+
+# Or use auto-commit when merging
+wt merge feature/login --auto-commit
+```
+
+### Setup Scripts Not Running
+
+```bash
+# Make sure you're using 'wt setup' not 'wt new'
+wt setup feature/login -c
+
+# Check if worktrees.json exists
+ls -la .cursor/worktrees.json
+ls -la worktrees.json
+
+# Enable trust mode if prompts are blocking
+wt config set trust true
+```
+
+### Can't Find PR/MR
+
+```bash
+# Make sure gh or glab is installed and authenticated
+gh auth status
+glab auth status
+
+# Set provider explicitly
+wt config set provider gh   # or glab
+```
+
+---
+
+## Quick Reference
+
+```bash
+# === CREATION ===
+wt new <branch> -c              # New worktree + branch
+wt setup <branch> -c            # New worktree + run setup
+wt pr [number]                  # Worktree from PR/MR
+
+# === NAVIGATION ===
+wt list                         # List all worktrees
+wt status                       # Show detailed status
+wt open                         # Interactive selector
+
+# === CLEANUP ===
+wt remove <branch>              # Remove worktree
+wt purge                        # Multi-select removal
+
+# === MERGING ===
+wt merge <branch>               # Merge branch
+wt merge <branch> --auto-commit # Auto-commit first
+wt merge <branch> --remove      # Merge + cleanup
+
+# === CONFIGURATION ===
+wt config set editor <name>     # Set default editor
+wt config set trust true        # Skip confirmations
+wt config set subfolder true    # Organized directories
+wt config get <key>             # Get config value
+wt config path                  # Show config location
+```
+
+---
+
+## Next Steps
+
+1. **Read the full README**: `cat README.md` for detailed documentation
+2. **Explore your config**: `wt config path` to see where settings are stored
+3. **Try the interactive mode**: Run `wt open` or `wt pr` without arguments
+4. **Set up your workflow**: Create `.cursor/worktrees.json` for your project
+5. **Join the community**: Check out the GitHub repository for updates
+
+---
+
+**Happy worktree-ing! 🚀**
+
diff --git a/README.md b/README.md
index 7fdb921..c120070 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,8 @@
 
 A CLI tool for managing Git worktrees with a focus on opening them in the Cursor editor.
 
+**New to worktrees?** Check out the [Quick Start Guide](QUICKSTART.md) for practical examples and common workflows.
+
 ## Features
 
 - **Interactive TUI**: Fuzzy-searchable selection when arguments are omitted
@@ -10,6 +12,9 @@ A CLI tool for managing Git worktrees with a focus on opening them in the Cursor
 - **Stash-aware**: Gracefully handles dirty worktrees with stash/pop workflow
 - **PR Integration**: Create worktrees directly from GitHub PRs or GitLab MRs
 - **Setup Automation**: Run setup scripts automatically with trust-based security
+- **Trust Mode**: Skip confirmation prompts for automated workflows
+- **Subfolder Organization**: Keep worktrees organized in dedicated subdirectories
+- **Status Overview**: Quick status check of all worktrees with git state
 
 ## Installation
 
@@ -129,6 +134,38 @@ Shows all worktrees with their status:
 - Locked/prunable status indicators
 - Main worktree marker
 
+### Show worktree status
+
+```bash
+wt status
+```
+
+Displays comprehensive status information for all worktrees:
+- **Git status**: Clean vs dirty (uncommitted changes)
+- **Tracking status**: Ahead/behind upstream branch
+- **Indicators**: Main worktree, locked, prunable status
+- **Branch info**: Current branch or detached HEAD state
+
+Example output:
+```bash
+$ wt status
+Worktree Status:
+
+main → /Users/me/projects/myapp [main] [clean] [up-to-date]
+feature/auth → /Users/me/projects/myapp-worktrees/feature-auth [dirty] [ahead 2]
+feature/api → /Users/me/projects/myapp-worktrees/feature-api [clean] [no upstream]
+```
+
+Status indicators:
+- `[main]` - Main worktree
+- `[clean]` / `[dirty]` - Working tree status
+- `[up-to-date]` - In sync with upstream
+- `[ahead N]` - N commits ahead of upstream
+- `[behind N]` - N commits behind upstream
+- `[ahead N, behind M]` - Diverged from upstream
+- `[no upstream]` - No tracking branch configured
+- `[locked]` - Worktree is locked
+
 ### Remove a worktree
 
 ```bash
@@ -266,6 +303,53 @@ wt config get worktreepath
 wt config clear worktreepath
 ```
 
+### Configure Trust Mode
+
+Skip confirmation prompts for setup scripts (useful for CI/CD and automated workflows):
+
+```bash
+# Enable trust mode
+wt config set trust true
+
+# Disable trust mode (default)
+wt config set trust false
+
+# Get current trust mode setting
+wt config get trust
+```
+
+When trust mode is enabled, `wt setup` commands will execute setup scripts without confirmation prompts.
+
+### Configure Subfolder Organization
+
+Organize worktrees in a dedicated subdirectory instead of as siblings:
+
+```bash
+# Enable subfolder mode
+wt config set subfolder true
+
+# Disable subfolder mode (default)
+wt config set subfolder false
+
+# Get current subfolder mode setting
+wt config get subfolder
+```
+
+**Without subfolder mode (default):**
+```
+my-app/                 # main repo
+my-app-feature-auth/    # worktree (sibling)
+my-app-feature-api/     # worktree (sibling)
+```
+
+**With subfolder mode:**
+```
+my-app/                 # main repo
+my-app-worktrees/
+  ├── feature-auth/     # worktree
+  └── feature-api/      # worktree
+```
+
 **Path Resolution Priority:**
 1. `--path` flag (highest priority)
 2. `defaultWorktreePath` config setting (with repo namespace)
@@ -411,6 +495,57 @@ pnpm test
 pnpm test -- --coverage
 ```
 
+## AI Assistant Integration
+
+### Claude Code Slash Command
+
+This project includes a custom slash command for Claude Code. The command is defined in `.claude/commands/worktree.md` and provides quick access to worktree management workflows.
+
+**Usage in Claude Code:**
+```
+/worktree create three parallel features for authentication, UI, and API
+```
+
+### Recommended Configuration for AI Workflows
+
+```bash
+# Headless operation (no editor auto-open)
+wt config set editor none
+
+# Skip confirmation prompts
+wt config set trust true
+
+# Organized directory structure
+wt config set subfolder true
+```
+
+### Parallel Agent Workflows
+
+The `wt` CLI is designed to work seamlessly with parallel AI agents (like Cursor's parallel agents feature):
+
+1. Each agent gets its own worktree
+2. Agents work independently without conflicts
+3. Changes are merged back when ready
+4. Setup scripts ensure consistent environments
+
+**Example workflow:**
+```bash
+# Create worktrees for parallel tasks
+wt setup task-1-auth -c
+wt setup task-2-ui -c
+wt setup task-3-api -c
+
+# Check status of all tasks
+wt status
+
+# Merge completed tasks
+wt merge task-1-auth --auto-commit --remove
+wt merge task-2-ui --auto-commit --remove
+wt merge task-3-api --auto-commit --remove
+```
+
+See the [Quick Start Guide](QUICKSTART.md) for more examples.
+
 ## License
 
 MIT
diff --git a/WORKTREE-CLI-PROJECT.md b/WORKTREE-CLI-PROJECT.md
deleted file mode 100644
index 26d0979..0000000
--- a/WORKTREE-CLI-PROJECT.md
+++ /dev/null
@@ -1,470 +0,0 @@
-# Worktree-CLI Fork: Claude Code & Cursor Integration
-
-## Project Overview
-
-This is a fork of `@johnlindquist/worktree-cli` — a CLI tool for managing Git worktrees with a focus on AI-assisted parallel development workflows.
-
-**Original Repository:** https://github.com/johnlindquist/worktree-cli
-**Your Fork:** https://github.com/CaptainCodeAU/worktree-cli
-
----
-
-## Vision
-
-Create a **unified worktree management system** that works seamlessly with both **Claude Code** and **Cursor**, enabling:
-
-1. **Parallel AI agent workflows** — Multiple AI agents working on different tasks simultaneously, each in isolated worktrees
-2. **Consistent experience** — Same tool, same config, same behavior regardless of which AI assistant you're using
-3. **Automation-first** — Headless operation for CI/CD and AI agents without interactive prompts blocking execution
-4. **Clean organization** — Structured worktree directories that don't clutter your projects folder
-
----
-
-## Current State
-
-### What's Already in the CLI
-
-| Command | Description |
-|---------|-------------|
-| `wt new <branch>` | Create new worktree from branch |
-| `wt setup <branch>` | Create worktree + run setup scripts |
-| `wt pr [number]` | Create worktree from GitHub PR or GitLab MR |
-| `wt open [path]` | Open existing worktree (interactive fuzzy search) |
-| `wt list` | List all worktrees with status |
-| `wt status` | **NEW** Show detailed status (clean/dirty, ahead/behind) |
-| `wt remove [path]` | Remove a worktree |
-| `wt purge` | Multi-select removal of worktrees |
-| `wt extract` | Extract current branch to a worktree |
-| `wt merge <branch>` | Merge a worktree branch into current branch |
-| `wt config get/set` | Configure editor, provider, worktreepath, trust, subfolder |
-
-### Key Options
-
-- `-c, --checkout`: Create new branch if it doesn't exist
-- `-i, --install <pm>`: Auto-install dependencies (npm/pnpm/bun)
-- `-e, --editor <editor>`: Override default editor (cursor/code/none)
-- `-t, --trust`: Skip confirmation for setup scripts
-- `-p, --path <path>`: Custom worktree path
-- `--setup` (on `wt pr`): Run setup scripts after PR worktree creation
-
-### Setup Script Configuration
-
-The CLI reads setup scripts from two locations (checked in order):
-1. `.cursor/worktrees.json` (Cursor's native format)
-2. `worktrees.json` (generic format)
-
-**Format examples:**
-
-```json
-// .cursor/worktrees.json (array format)
-[
-  "pnpm install",
-  "cp $ROOT_WORKTREE_PATH/.env.local .env.local"
-]
-```
-
-```json
-// worktrees.json (object format)
-{
-  "setup-worktree": [
-    "pnpm install",
-    "cp $ROOT_WORKTREE_PATH/.env.local .env.local"
-  ]
-}
-```
-
----
-
-## PR #35: Trust and Subfolder Config ✅ MERGED
-
-**PR Link:** https://github.com/johnlindquist/worktree-cli/pull/35
-**Status:** Successfully merged into `feature/claude-code-enhancements` branch
-
-This PR adds two important config options:
-
-### 1. Trust Mode
-```bash
-wt config set trust true
-```
-- Bypasses setup command confirmations globally
-- No need to pass `-t` flag every time
-- Essential for Claude Code automation
-
-### 2. Subfolder Mode
-```bash
-wt config set subfolder true
-```
-- Changes worktree organization from siblings to subdirectory
-
-**Without subfolder mode:**
-```
-my-app/                 # main repo
-my-app-feature-auth/    # worktree (sibling)
-my-app-feature-api/     # worktree (sibling)
-```
-
-**With subfolder mode:**
-```
-my-app/                 # main repo
-my-app-worktrees/
-  ├── feature-auth/     # worktree
-  └── feature-api/      # worktree
-```
-
-### To Merge PR #35 Into Your Fork
-
-```bash
-git remote add upstream https://github.com/johnlindquist/worktree-cli.git
-git fetch upstream feature/issues-33-34-config-options
-git checkout -b feature/claude-code-enhancements main
-git merge upstream/feature/issues-33-34-config-options --no-edit
-pnpm build
-pnpm test
-```
-
----
-
-## New: `wt status` Command ✅ IMPLEMENTED
-
-The `wt status` command provides a comprehensive overview of all worktrees with detailed git status information.
-
-### Features
-
-- Shows all worktrees with branch names and paths
-- **Git status**: Clean vs dirty (uncommitted changes)
-- **Tracking status**: Ahead/behind upstream branch
-- **Indicators**: Main worktree, locked, prunable status
-- **Error handling**: Gracefully handles missing worktree directories
-
-### Example Output
-
-```bash
-$ wt status
-Worktree Status:
-
-main → /Users/me/projects/myapp [main] [clean] [up-to-date]
-feature/auth → /Users/me/projects/myapp-worktrees/feature-auth [dirty] [↑2]
-feature/api → /Users/me/projects/myapp-worktrees/feature-api [clean] [no upstream]
-```
-
-### Status Indicators
-
-- `[main]` - Main worktree
-- `[clean]` / `[dirty]` - Git working tree status
-- `[up-to-date]` - In sync with upstream
-- `[↑N]` - N commits ahead of upstream
-- `[↓N]` - N commits behind upstream
-- `[↑N ↓M]` - Diverged from upstream
-- `[no upstream]` - No tracking branch configured
-- `[locked]` - Worktree is locked
-- `[prunable]` - Worktree is stale/prunable
-
-### Implementation Details
-
-- Located in `src/commands/status.ts`
-- 6 comprehensive tests in `test/status.test.ts`
-- Reuses existing git utilities from `src/utils/git.ts`
-- Handles edge cases: detached HEAD, bare repos, missing directories
-
----
-
-## Planned Enhancements
-
-### 1. Claude Code Slash Command Integration
-
-Create a custom slash command for Claude Code at `.claude/commands/worktree.md`:
-
-```markdown
-# Worktree Management
-
-You have access to the `wt` CLI tool for managing git worktrees.
-
-## Common Commands
-
-- `wt new <branch> -c` — Create new worktree (create branch if needed)
-- `wt setup <branch> -c` — Create worktree + run setup scripts
-- `wt list` — List all worktrees
-- `wt remove <branch>` — Remove a worktree
-- `wt merge <branch> --auto-commit --remove` — Merge and cleanup
-- `wt pr <number> --setup` — Create worktree from PR/MR
-
-## Workflow for Parallel Tasks
-
-When asked to work on multiple tasks in parallel:
-
-1. Create a worktree for each task: `wt setup feature/<task-name> -c`
-2. Note the paths returned
-3. Work in each worktree directory independently
-4. When complete, merge back: `wt merge feature/<task-name> --auto-commit`
-
-**User Request:** $ARGUMENTS
-```
-
-### 2. CLAUDE.md in Projects
-
-Add to project's `CLAUDE.md`:
-
-```markdown
-## Worktree Workflow
-
-This project uses `wt` (worktree-cli) for managing parallel workstreams.
-
-- Worktrees are stored in organized subdirectories (subfolder mode enabled)
-- Setup scripts run automatically via `.cursor/worktrees.json`
-- For parallel tasks, create separate worktrees rather than switching branches
-- Always use `wt merge` to bring changes back (safer than manual git merge)
-- Trust mode is enabled — no confirmation prompts for setup scripts
-```
-
-### 3. Potential New Features to Implement
-
-| Feature | Description | Priority | Status |
-|---------|-------------|----------|--------|
-| `wt status` | Quick overview of all worktrees + their git status (dirty/clean/ahead/behind) | High | ✅ **DONE** |
-| Agent ID generation | Auto-generate `.agent-id` files for parallel agent coordination (like Cursor's parallel agents) | High | ⬜ Todo |
-| CLAUDE.md copying | Automatically copy CLAUDE.md to new worktrees | Medium | ⬜ Todo |
-| `wt clone` | Clone a repo as bare + set up initial worktree in one command | Medium | ⬜ Todo |
-| Better GitLab parity | Ensure `wt pr` works equally well with `glab` | Medium | ⬜ Todo |
-| `wt sync` | Fetch + rebase all worktrees from their upstream branches | Low | ⬜ Todo |
-
----
-
-## Architecture Overview
-
-```
-worktree-cli/
-├── src/
-│   ├── index.ts              # CLI entry point (Commander setup)
-│   ├── config.ts             # Config schema and getters/setters
-│   ├── commands/
-│   │   ├── new.ts            # wt new
-│   │   ├── setup.ts          # wt setup
-│   │   ├── pr.ts             # wt pr
-│   │   ├── open.ts           # wt open
-│   │   ├── list.ts           # wt list
-│   │   ├── remove.ts         # wt remove
-│   │   ├── merge.ts          # wt merge
-│   │   ├── config.ts         # wt config get/set
-│   │   └── ...
-│   └── utils/
-│       ├── paths.ts          # Path resolution logic
-│       ├── tui.ts            # Terminal UI (prompts, confirmations)
-│       ├── git.ts            # Git operations
-│       └── ...
-├── test/                     # Vitest tests
-├── build/                    # Compiled JS output
-├── package.json
-└── tsconfig.json
-```
-
-### Key Technologies
-
-- **TypeScript** — Source language
-- **Commander** — CLI framework
-- **Execa** — Shell command execution
-- **Vitest** — Testing framework
-- **Inquirer/Prompts** — Interactive TUI
-
----
-
-## Development Workflow
-
-### Setup (Already Completed)
-
-```bash
-# Clone your fork
-git clone git@github.com:CaptainCodeAU/worktree-cli.git
-cd worktree-cli
-
-# Install dependencies
-pnpm install
-
-# Build
-pnpm build
-
-# Link globally for testing
-pnpm link --global
-
-# Verify
-wt --version
-```
-
-### Making Changes
-
-```bash
-# 1. Create/switch to feature branch
-git checkout -b feature/my-new-feature
-
-# 2. Make changes in src/
-
-# 3. Rebuild
-pnpm build
-
-# 4. Test manually
-wt <command>
-
-# 5. Run automated tests
-pnpm test
-
-# 6. Add tests for new functionality in test/
-
-# 7. Commit
-git add .
-git commit -m "feat: description of change"
-
-# 8. Push to your fork
-git push origin feature/my-new-feature
-```
-
-### Testing
-
-```bash
-# Run all tests
-pnpm test
-
-# Run with coverage
-pnpm test -- --coverage
-
-# Run specific test file
-pnpm test -- test/config.test.ts
-```
-
----
-
-## Configuration Reference
-
-### Global Config Location
-
-Config is stored at: `~/.config/worktree-cli/config.json`
-
-### Available Config Options
-
-| Key | Command | Description |
-|-----|---------|-------------|
-| `editor` | `wt config set editor <value>` | Default editor: `cursor`, `code`, `none` |
-| `provider` | `wt config set provider <value>` | Git provider CLI: `gh`, `glab` |
-| `worktreepath` | `wt config set worktreepath <path>` | Global worktree directory |
-| `trust` | `wt config set trust true` | Skip setup confirmations (PR #35) |
-| `subfolder` | `wt config set subfolder true` | Use subdirectory organization (PR #35) |
-
-### Recommended Config for Claude Code
-
-```bash
-wt config set editor none        # Don't open editor (headless)
-wt config set trust true         # No confirmation prompts
-wt config set subfolder true     # Organized directory structure
-```
-
----
-
-## Related Resources
-
-### Documentation & Articles
-
-- **Cursor Parallel Agents Docs:** https://cursor.com/docs/configuration/worktrees
-- **Git Worktrees Explained:** https://dev.to/arifszn/git-worktrees-the-power-behind-cursors-parallel-agents-19j1
-- **Nick Taylor's Git Worktrees Guide:** https://www.nickyt.co/blog/git-worktrees-git-done-right-2p7f/
-
-### Cursor Parallel Agent Coordination
-
-For Cursor's parallel agents, you can use `.cursor/worktrees.json` to auto-assign agent IDs:
-
-```json
-{
-  "setup-worktree-unix": [
-    "# ... coordination script that creates .agent-id file",
-    "echo \"$TASK_NUM\" > .agent-id"
-  ]
-}
-```
-
-Then in your prompt:
-```
-Read your .agent-id file. Based on your number, execute ONLY that task:
-1. Refactor authentication module
-2. Add dark mode support
-3. Optimize database queries
-4. Write integration tests
-```
-
-**Full coordination script:** See https://forum.cursor.com/t/cursor-2-0-split-tasks-using-parallel-agents-automatically-in-one-chat-how-to-setup-worktree-json/140218
-
-### Git Aliases (Fallback)
-
-If `wt` isn't available, these git aliases provide basic worktree management:
-
-```bash
-git config --global alias.wta '!f() { git worktree add -b "$1" "../$1"; }; f'
-git config --global alias.wtr '!f() { git worktree remove "../$1"; }; f'
-git config --global alias.wtl '!f() { git worktree list; }; f'
-```
-
-### Shell Function for PR Checkout (Alternative)
-
-```bash
-cpr() {
-  pr="$1"
-  remote="${2:-origin}"
-  branch=$(gh pr view "$pr" --json headRefName -q .headRefName)
-  git fetch "$remote" "$branch"
-  git worktree add "../$branch" "$branch"
-  cd "../$branch" || return
-  echo "Switched to new worktree for PR #$pr: $branch"
-}
-```
-
----
-
-## Quick Reference Card
-
-```bash
-# === WORKTREE CREATION ===
-wt new feature/auth -c              # New worktree + branch
-wt setup feature/auth -c            # New worktree + run setup scripts
-wt pr 123 --setup                   # Worktree from PR + setup
-
-# === WORKTREE MANAGEMENT ===
-wt list                             # List all worktrees
-wt open                             # Interactive worktree selector
-wt remove feature/auth              # Remove worktree
-wt purge                            # Multi-select removal
-
-# === MERGING ===
-wt merge feature/auth               # Merge (fails if dirty)
-wt merge feature/auth --auto-commit # Auto-commit dirty changes first
-wt merge feature/auth --remove      # Merge + delete worktree
-wt merge feature/auth --auto-commit --remove  # All-in-one
-
-# === CONFIGURATION ===
-wt config set editor none           # Headless mode
-wt config set trust true            # Skip confirmations
-wt config set subfolder true        # Organized directories
-wt config path                      # Show config file location
-```
-
----
-
-## Next Steps for This Session
-
-1. ✅ Fork cloned and set up locally
-2. ✅ `wt` command working globally
-3. ✅ Run tests: `pnpm test` (all 104 tests passing)
-4. ✅ Merge PR #35 (trust + subfolder) - Successfully merged into `feature/claude-code-enhancements` branch
-5. ✅ Rebuild and verify new config options work - Both `trust` and `subfolder` modes working
-6. ✅ Implement first enhancement: `wt status` command - Fully implemented with 6 passing tests
-7. ✅ Create Claude Code slash command - Created at `.claude/commands/worktree.md`
-8. ⬜ Test end-to-end with Claude Code
-
----
-
-## Questions to Consider
-
-1. Should worktrees automatically inherit `.claude/` directory from main repo?
-2. Should there be a `wt init` command that sets up recommended config + creates `.cursor/worktrees.json`?
-3. How should agent coordination work in Claude Code vs Cursor? Same mechanism or different?
-4. Should `wt status` show git status, or also check if setup scripts have been run?
-
----
-
-*Document created: December 23, 2025*
-*For use with Claude Code in ~/CODE/Ideas/Trusses/worktree-cli*