cluttry 1.5.1 → 2.1.0

package/README.md

@@ -1,6 +1,6 @@
 # cluttry
 
-AI session lifecycle in git worktrees.
+**Worktrees for coding agents. Safe by default.**
 
 **CLI command:** `cry`
 
@@ -14,11 +14,11 @@ npm install -g cluttry
 cd your-repo
 cry init
 
-# One command: create worktree → launch Claude → finish when done
-cry feat-login claude --finish-on-exit
+# One command: create worktree → launch Claude → auto-finish when done
+cry feat-login claude --auto
 ```
 
-That's it. When Claude exits, you'll see a menu to commit, create a PR, and clean up.
+That's it. When Claude exits, cry automatically commits, creates a PR, and cleans up.
 
 ## The Lifecycle
 
@@ -42,7 +42,10 @@ cry feat-auth claude
 # Explicit
 cry spawn feat-auth --new --agent claude
 
-# Full lifecycle in one command
+# Full autopilot: agent exits → commit → PR → cleanup
+cry feat-auth claude --auto
+
+# Interactive finish menu when agent exits
 cry feat-auth claude --finish-on-exit
 ```
 
@@ -50,7 +53,7 @@ cry feat-auth claude --finish-on-exit
 
 Your AI agent works in the isolated worktree. Each worktree has:
 - Its own branch
-- Copy of your `.env` and secret files
+- Copy of your `.env` and secret files (or injected env vars)
 - Independent git state
 
 Run multiple sessions in parallel—each in its own terminal.
@@ -64,10 +67,13 @@ cry finish
 ```
 
 Interactive flow:
-1. Shows session summary (branch, commits, diff stats)
-2. If dirty: offers to commit (with suggested message from branch name)
-3. Pushes branch and creates PR via `gh` CLI
-4. Offers cleanup prompt
+1. Runs `preFinish` hooks (tests, lint, etc.)
+2. Shows session summary (branch, commits, diff stats)
+3. If dirty: offers to commit (with suggested message from branch name)
+4. Pushes branch and creates PR via `gh` CLI
+5. Offers merge options (PR only, local merge, or gh merge)
+6. Runs `postFinish` hooks
+7. Offers cleanup prompt
 
 Non-interactive:
 ```bash
@@ -113,21 +119,54 @@ After `cry init`, edit `.cry.json`:
 {
   "include": [".env", ".env.*", "config/secrets.json"],
   "defaultMode": "copy",
-  "hooks": { "postCreate": ["npm install"] },
+  "hooks": {
+    "postCreate": ["npm install"],
+    "preFinish": ["npm test", "npm run lint"],
+    "postFinish": ["echo 'PR created!'"],
+    "preMerge": ["npm run build"]
+  },
   "agentCommand": "claude"
 }
 ```
 
 | Key | Description |
 |-----|-------------|
-| `include` | Glob patterns for files to copy to worktrees |
-| `defaultMode` | `copy`, `symlink`, or `none` |
+| `include` | Glob patterns for files to copy/inject to worktrees |
+| `defaultMode` | `copy`, `symlink`, `inject`, or `none` |
 | `hooks.postCreate` | Commands to run after spawn |
+| `hooks.preFinish` | Commands to run before finish (tests, lint) |
+| `hooks.postFinish` | Commands to run after PR creation |
+| `hooks.preMerge` | Commands to run before merge attempts |
 | `agentCommand` | Agent CLI command (default: `claude`) |
 | `editorCommand` | Editor command (default: `code`) |
+| `injectNonEnv` | For inject mode: `skip` or `symlink` non-dotenv files |
+| `agents` | Agent presets (see below) |
 
 Machine-specific overrides go in `.cry.local.json` (gitignored).
 
+### Agent Presets
+
+Configure per-agent behavior:
+
+```json
+{
+  "agents": {
+    "claude": {
+      "command": "claude",
+      "deny": [".env", ".env.*"],
+      "finishOnExitDefault": true
+    },
+    "cursor": {
+      "command": "cursor",
+      "args": ["."],
+      "finishOnExitDefault": false
+    }
+  }
+}
+```
+
+Built-in presets for `claude` and `cursor` are provided. Override or add your own.
+
 ## Security Model
 
 **Tracked files are never copied.** This is enforced, not optional.
@@ -151,14 +190,20 @@ cry explain-copy
 cry spawn feat-test --new --dry-run
 ```
 
-### Copy vs Symlink
+### Copy vs Symlink vs Inject
 
 | Mode | Behavior |
 |------|----------|
 | `copy` | Independent copies. Safe default. |
 | `symlink` | Linked to original. Changes sync everywhere. |
+| `inject` | **No files copied.** Env vars injected into commands. Safest for AI agents. |
 | `none` | Nothing copied. Set up secrets manually. |
 
+**Inject mode** is recommended when running AI agents:
+- Parses `.env` files and injects variables into hooks and agent commands
+- No secret files exist in the worktree for the agent to read
+- Non-dotenv files are skipped (or optionally symlinked via `injectNonEnv: "symlink"`)
+
 ## Commands
 
 ### Session Lifecycle
@@ -191,10 +236,13 @@ cry spawn feat-test --new --dry-run
 
 ```
 -n, --new               Create new branch
--a, --agent <agent>     Launch agent (claude, cursor, none)
+-a, --agent <agent>     Launch agent (claude, cursor, or custom preset)
 --finish-on-exit        Show finish menu when agent exits
+--auto                  Autopilot: auto-commit, PR, cleanup when agent exits
+--auto-merge            With --auto: also merge PR via gh
+--auto-commit-message   With --auto: custom commit message
 --base-branch <branch>  PR target branch
--m, --mode <mode>       Secret handling (copy, symlink, none)
+-m, --mode <mode>       Secret handling (copy, symlink, inject, none)
 -r, --run <cmd>         Run command after spawn
 --dry-run               Preview without creating
 ```
@@ -203,6 +251,10 @@ cry spawn feat-test --new --dry-run
 
 ```
 -m, --message <msg>     Commit with message (non-interactive)
+--skip-hooks            Skip all hooks (preFinish, postFinish, preMerge)
+--merge                 Merge locally into base branch after PR
+--pr-merge              Merge PR via GitHub (gh pr merge)
+--no-merge              Skip merge prompt (PR only)
 --cleanup               Auto-cleanup after PR
 --skip-commit           Skip commit step
 --non-interactive       Never prompt
@@ -252,7 +304,17 @@ brew install gh && gh auth login
 
 ### How do I prevent AI from reading secrets?
 
-For Claude Code, add to `.clauderc`:
+**Best option: Use inject mode** (no files copied to worktree):
+```bash
+cry spawn feat-auth --new --agent claude --mode inject
+```
+
+Or configure it as default in `.cry.json`:
+```json
+{ "defaultMode": "inject" }
+```
+
+For Claude Code specifically, you can also add to `.clauderc`:
 ```json
 { "deny": [".env", ".env.*"] }
 ```

package/dist/commands/finish.d.ts

@@ -15,6 +15,11 @@ export interface FinishOptions {
     deleteBranch?: boolean;
     message?: string;
     skipCommit?: boolean;
+    skipHooks?: boolean;
+    merge?: boolean;
+    prMerge?: boolean;
+    noMerge?: boolean;
+    cherryPick?: boolean;
 }
 export declare function finish(options: FinishOptions): Promise<void>;
 //# sourceMappingURL=finish.d.ts.map

package/dist/commands/finish.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"finish.d.ts","sourceRoot":"","sources":["../../src/commands/finish.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA0BH,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AA2sBD,wBAAsB,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAwMlE"}
+{"version":3,"file":"finish.d.ts","sourceRoot":"","sources":["../../src/commands/finish.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAgCH,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAi4BD,wBAAsB,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAoYlE"}

package/dist/commands/finish.js

@@ -6,8 +6,10 @@
  */
 import { createInterface } from 'node:readline';
 import { execSync, spawnSync } from 'node:child_process';
-import { isGitRepo, getRepoRoot, getCurrentBranch, git, removeWorktree, deleteBranch, getDefaultBranch, getUpstreamBranch, } from '../lib/git.js';
-import { findSessionForCwd, findMainRepoRoot, deleteSession, } from '../lib/session.js';
+import { isGitRepo, getRepoRoot, getCurrentBranch, git, removeWorktree, deleteBranch, isWorktreeDirty, getDefaultBranch, getUpstreamBranch, getCommitsAhead, cherryPick, cherryPickAbort, } from '../lib/git.js';
+import { findSessionForCwd, findMainRepoRoot, deleteSession, updateSessionManifest, } from '../lib/session.js';
+import { runHooks } from '../lib/hooks.js';
+import { getMergedConfig } from '../lib/config.js';
 import * as out from '../lib/output.js';
 import { fail, errors, printError } from '../lib/errors.js';
 /**
@@ -399,6 +401,171 @@ function createPullRequest(branch, baseBranch, cwd) {
         return { success: false, error: error.message };
     }
 }
+/**
+ * Perform local merge in the main worktree
+ */
+function performLocalMerge(mainRepoRoot, sessionBranch, baseBranch, dryRun) {
+    if (dryRun) {
+        out.log(out.fmt.dim('[dry-run] Would perform local merge:'));
+        out.log(out.fmt.dim(`  1. cd ${mainRepoRoot}`));
+        out.log(out.fmt.dim(`  2. git fetch origin && git checkout ${baseBranch}`));
+        out.log(out.fmt.dim(`  3. git merge --no-ff ${sessionBranch}`));
+        out.log(out.fmt.dim(`  4. git push origin ${baseBranch}`));
+        return { success: true };
+    }
+    try {
+        // Check if main worktree is clean
+        if (isWorktreeDirty(mainRepoRoot)) {
+            return { success: false, error: 'Main worktree has uncommitted changes. Please commit or stash them first.' };
+        }
+        // Save current branch to restore on failure
+        let originalBranch = null;
+        try {
+            originalBranch = getCurrentBranch(mainRepoRoot);
+        }
+        catch {
+            // May be in detached HEAD
+        }
+        // Fetch and checkout base branch
+        out.log(`Fetching and checking out ${out.fmt.branch(baseBranch)}...`);
+        try {
+            git(['fetch', 'origin'], mainRepoRoot);
+        }
+        catch {
+            // Fetch may fail if no remote, continue anyway
+        }
+        git(['checkout', baseBranch], mainRepoRoot);
+        // Try to merge
+        out.log(`Merging ${out.fmt.branch(sessionBranch)} into ${out.fmt.branch(baseBranch)}...`);
+        try {
+            git(['merge', '--no-ff', sessionBranch, '-m', `Merge branch '${sessionBranch}'`], mainRepoRoot);
+        }
+        catch (mergeError) {
+            // Conflict detected - abort and restore
+            out.error('Merge conflict detected! Aborting merge...');
+            try {
+                git(['merge', '--abort'], mainRepoRoot);
+            }
+            catch {
+                // Abort may fail if merge wasn't in progress
+            }
+            if (originalBranch && originalBranch !== baseBranch) {
+                try {
+                    git(['checkout', originalBranch], mainRepoRoot);
+                }
+                catch {
+                    // Best effort restore
+                }
+            }
+            return { success: false, error: 'Merge conflicts detected. Please resolve manually or use PR workflow.' };
+        }
+        // Push to origin
+        out.log(`Pushing ${out.fmt.branch(baseBranch)} to origin...`);
+        try {
+            git(['push', 'origin', baseBranch], mainRepoRoot);
+            out.success('Local merge and push completed');
+        }
+        catch (pushError) {
+            out.warn('Merge succeeded locally but push failed. You may need to push manually.');
+        }
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Perform cherry-pick of commits to the base branch in main worktree
+ */
+function performCherryPickToBase(mainRepoRoot, _sessionBranch, baseBranch, commits, dryRun) {
+    if (dryRun) {
+        out.log(out.fmt.dim('[dry-run] Would perform cherry-pick:'));
+        out.log(out.fmt.dim(`  1. cd ${mainRepoRoot}`));
+        out.log(out.fmt.dim(`  2. git fetch origin && git checkout ${baseBranch}`));
+        for (const commit of commits) {
+            out.log(out.fmt.dim(`  3. git cherry-pick ${commit.sha} # ${commit.message}`));
+        }
+        out.log(out.fmt.dim(`  4. git push origin ${baseBranch}`));
+        return { success: true };
+    }
+    try {
+        // Check if main worktree is clean
+        if (isWorktreeDirty(mainRepoRoot)) {
+            return { success: false, error: 'Main worktree has uncommitted changes. Please commit or stash them first.' };
+        }
+        // Save current branch to restore on failure
+        let originalBranch = null;
+        try {
+            originalBranch = getCurrentBranch(mainRepoRoot);
+        }
+        catch {
+            // May be in detached HEAD
+        }
+        // Fetch and checkout base branch
+        out.log(`Fetching and checking out ${out.fmt.branch(baseBranch)}...`);
+        try {
+            git(['fetch', 'origin'], mainRepoRoot);
+        }
+        catch {
+            // Fetch may fail if no remote, continue anyway
+        }
+        git(['checkout', baseBranch], mainRepoRoot);
+        // Cherry-pick each commit
+        out.log(`Cherry-picking ${commits.length} commit(s) onto ${out.fmt.branch(baseBranch)}...`);
+        for (const commit of commits) {
+            out.log(`  Cherry-picking ${out.fmt.dim(commit.sha)} ${commit.message}`);
+            if (!cherryPick(commit.sha, mainRepoRoot)) {
+                out.error(`Cherry-pick conflict on commit ${commit.sha}! Aborting...`);
+                cherryPickAbort(mainRepoRoot);
+                // Try to restore original branch
+                if (originalBranch && originalBranch !== baseBranch) {
+                    try {
+                        git(['checkout', originalBranch], mainRepoRoot);
+                    }
+                    catch {
+                        // Best effort restore
+                    }
+                }
+                return { success: false, error: `Cherry-pick conflict on commit ${commit.sha}. Please resolve manually or use PR workflow.` };
+            }
+        }
+        out.success(`Successfully cherry-picked ${commits.length} commit(s)`);
+        // Push to origin
+        out.log(`Pushing ${out.fmt.branch(baseBranch)} to origin...`);
+        try {
+            git(['push', 'origin', baseBranch], mainRepoRoot);
+            out.success('Cherry-pick and push completed');
+        }
+        catch {
+            out.warn('Cherry-pick succeeded locally but push failed. You may need to push manually.');
+        }
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Merge PR using gh CLI
+ */
+function performPrMerge(branch, cwd) {
+    try {
+        const result = spawnSync('gh', ['pr', 'merge', '--merge', '--delete-branch', branch], {
+            cwd,
+            encoding: 'utf-8',
+            stdio: 'pipe',
+        });
+        if (result.status === 0) {
+            return { success: true };
+        }
+        else {
+            return { success: false, error: result.stderr || 'Unknown error' };
+        }
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
 /**
  * Show git diff in pager
  */
@@ -659,9 +826,28 @@ export async function finish(options) {
     }
     // Print summary
     printSummary(summary);
+    // Load config for hooks
+    const mainRepoRoot = findMainRepoRoot(cwd);
+    const config = mainRepoRoot ? getMergedConfig(mainRepoRoot) : null;
     const isDirty = !summary.status.clean;
     const hasCommits = summary.commits.ahead > 0;
     const dryRun = options.dryRun ?? false;
+    // Run preFinish hooks
+    if (!options.skipHooks && config && config.hooks.preFinish.length > 0) {
+        if (dryRun) {
+            out.log(out.fmt.dim('[dry-run] Would run preFinish hooks:'));
+            for (const hook of config.hooks.preFinish) {
+                out.log(out.fmt.dim(`  - ${hook}`));
+            }
+        }
+        else {
+            const hookResult = await runHooks('preFinish', config.hooks.preFinish, { cwd });
+            if (!hookResult.success) {
+                out.error('preFinish hooks failed. Aborting finish.');
+                process.exit(1);
+            }
+        }
+    }
     // Handle dirty state
     if (isDirty) {
         // Skip commit entirely if --skip-commit is set
@@ -741,7 +927,54 @@ export async function finish(options) {
     const ghAvailable = isGhAvailable();
     const hasOrigin = hasOriginRemote(cwd);
     const canCreatePr = ghAvailable && hasOrigin;
-    if (updatedHasCommits || options.pr) {
+    // Cherry-pick workflow (alternative to PR)
+    if (options.cherryPick) {
+        out.newline();
+        if (!updatedHasCommits) {
+            out.log(out.fmt.dim('No commits to cherry-pick.'));
+        }
+        else if (!mainRepoRoot) {
+            out.error('Could not find main repository root for cherry-pick.');
+            process.exit(1);
+        }
+        else {
+            out.header('Cherry-Pick to Base Branch');
+            out.newline();
+            const commits = getCommitsAhead(summary.baseBranch, cwd);
+            if (commits.length === 0) {
+                out.log(out.fmt.dim('No commits ahead of base branch.'));
+            }
+            else {
+                out.log(`Found ${commits.length} commit(s) to cherry-pick:`);
+                for (const commit of commits.slice(0, 5)) {
+                    out.log(`  ${out.fmt.dim(commit.sha)} ${commit.message}`);
+                }
+                if (commits.length > 5) {
+                    out.log(out.fmt.dim(`  ... and ${commits.length - 5} more`));
+                }
+                out.newline();
+                const cherryPickResult = performCherryPickToBase(mainRepoRoot, summary.branch, summary.baseBranch, commits, dryRun);
+                if (!cherryPickResult.success) {
+                    out.error(`Cherry-pick failed: ${cherryPickResult.error}`);
+                    process.exit(1);
+                }
+                // Update session manifest
+                if (sessionId && mainRepoRoot) {
+                    updateSessionManifest(mainRepoRoot, sessionId, {
+                        status: 'finished',
+                        lastActiveAt: new Date().toISOString(),
+                        lastFinishResult: {
+                            success: true,
+                            prCreated: false,
+                            checksRan: false,
+                            message: 'Cherry-picked to base branch',
+                        },
+                    });
+                }
+            }
+        }
+    }
+    else if (updatedHasCommits || options.pr) {
         out.newline();
         if (dryRun) {
             out.log(out.fmt.dim('[dry-run] Would push branch and create PR'));
@@ -760,6 +993,19 @@ export async function finish(options) {
             const prResult = createPullRequest(summary.branch, summary.baseBranch, cwd);
             if (prResult.success) {
                 out.success(`PR created: ${prResult.url}`);
+                // Update session manifest with PR URL
+                if (sessionId && mainRepoRoot) {
+                    updateSessionManifest(mainRepoRoot, sessionId, {
+                        prUrl: prResult.url,
+                        status: 'finished',
+                        lastActiveAt: new Date().toISOString(),
+                        lastFinishResult: {
+                            success: true,
+                            prCreated: true,
+                            checksRan: false,
+                        },
+                    });
+                }
             }
             else {
                 // PR might already exist
@@ -769,6 +1015,88 @@ export async function finish(options) {
                 else {
                     out.warn(`Could not create PR: ${prResult.error}`);
                 }
+                // Update session manifest with finish result
+                if (sessionId && mainRepoRoot) {
+                    updateSessionManifest(mainRepoRoot, sessionId, {
+                        status: prResult.error?.includes('already exists') ? 'finished' : 'error',
+                        lastActiveAt: new Date().toISOString(),
+                        lastFinishResult: {
+                            success: prResult.error?.includes('already exists') ?? false,
+                            prCreated: false,
+                            checksRan: false,
+                            message: prResult.error,
+                        },
+                    });
+                }
+            }
+            // Merge options
+            let mergeAction = 'done';
+            // Handle non-interactive merge flags
+            if (options.merge) {
+                mergeAction = 'local';
+            }
+            else if (options.prMerge) {
+                mergeAction = 'gh';
+            }
+            else if (!options.noMerge && !options.nonInteractive) {
+                // Interactive merge menu
+                out.newline();
+                mergeAction = await promptChoice('What would you like to do next?', [
+                    { key: 'p', label: 'Done (PR only)', value: 'done' },
+                    { key: 'm', label: 'Merge locally into base branch', value: 'local' },
+                    { key: 'g', label: 'Merge PR via GitHub (gh pr merge)', value: 'gh' },
+                    { key: 'x', label: 'Cancel', value: 'cancel' },
+                ]);
+            }
+            // Handle merge action
+            if (mergeAction === 'cancel') {
+                out.log('Cancelled.');
+                process.exit(0);
+            }
+            if (mergeAction === 'local' || mergeAction === 'gh') {
+                // Run preMerge hooks
+                if (!options.skipHooks && config && config.hooks.preMerge.length > 0) {
+                    if (dryRun) {
+                        out.log(out.fmt.dim('[dry-run] Would run preMerge hooks:'));
+                        for (const hook of config.hooks.preMerge) {
+                            out.log(out.fmt.dim(`  - ${hook}`));
+                        }
+                    }
+                    else {
+                        const hookResult = await runHooks('preMerge', config.hooks.preMerge, { cwd });
+                        if (!hookResult.success) {
+                            out.error('preMerge hooks failed. Merge aborted.');
+                            process.exit(1);
+                        }
+                    }
+                }
+                // Perform the merge
+                if (mergeAction === 'local') {
+                    out.newline();
+                    out.header('Local Merge');
+                    const mergeResult = performLocalMerge(mainRepoRoot, summary.branch, summary.baseBranch, dryRun);
+                    if (!mergeResult.success) {
+                        out.error(`Local merge failed: ${mergeResult.error}`);
+                        process.exit(1);
+                    }
+                }
+                else if (mergeAction === 'gh') {
+                    out.newline();
+                    out.log('Merging PR via GitHub...');
+                    if (dryRun) {
+                        out.log(out.fmt.dim(`[dry-run] Would run: gh pr merge --merge --delete-branch ${summary.branch}`));
+                    }
+                    else {
+                        const mergeResult = performPrMerge(summary.branch, cwd);
+                        if (mergeResult.success) {
+                            out.success('PR merged and branch deleted via GitHub');
+                        }
+                        else {
+                            out.error(`PR merge failed: ${mergeResult.error}`);
+                            process.exit(1);
+                        }
+                    }
+                }
             }
         }
         else if (!ghAvailable) {
@@ -783,6 +1111,21 @@ export async function finish(options) {
     else {
         out.log(out.fmt.dim('No commits to push.'));
     }
+    // Run postFinish hooks
+    if (!options.skipHooks && config && config.hooks.postFinish.length > 0) {
+        if (dryRun) {
+            out.log(out.fmt.dim('[dry-run] Would run postFinish hooks:'));
+            for (const hook of config.hooks.postFinish) {
+                out.log(out.fmt.dim(`  - ${hook}`));
+            }
+        }
+        else {
+            const hookResult = await runHooks('postFinish', config.hooks.postFinish, { cwd });
+            if (!hookResult.success) {
+                out.warn('postFinish hooks failed, but finish will continue.');
+            }
+        }
+    }
     // Cleanup prompt
     if (options.noCleanup) {
         // Skip cleanup entirely