gsd-pi 2.31.2-dev.91f95cf → 2.31.2-dev.c8d7e03

package/dist/cli.js

@@ -359,16 +359,16 @@ if (cliFlags.messages[0] === 'worktree' || cliFlags.messages[0] === 'wt') {
     const sub = cliFlags.messages[1];
     const subArgs = cliFlags.messages.slice(2);
     if (!sub || sub === 'list') {
-        handleList(process.cwd());
+        await handleList(process.cwd());
     }
     else if (sub === 'merge') {
         await handleMerge(process.cwd(), subArgs);
     }
     else if (sub === 'clean') {
-        handleClean(process.cwd());
+        await handleClean(process.cwd());
     }
     else if (sub === 'remove' || sub === 'rm') {
-        handleRemove(process.cwd(), subArgs);
+        await handleRemove(process.cwd(), subArgs);
     }
     else {
         process.stderr.write(`Unknown worktree command: ${sub}\n`);
@@ -381,7 +381,7 @@ if (cliFlags.messages[0] === 'worktree' || cliFlags.messages[0] === 'wt') {
 // ---------------------------------------------------------------------------
 if (cliFlags.worktree) {
     const { handleWorktreeFlag } = await import('./worktree-cli.js');
-    handleWorktreeFlag(cliFlags.worktree);
+    await handleWorktreeFlag(cliFlags.worktree);
 }
 // ---------------------------------------------------------------------------
 // Active worktree banner — remind user of unmerged worktrees on normal launch
@@ -389,7 +389,7 @@ if (cliFlags.worktree) {
 if (!cliFlags.worktree && !isPrintMode) {
     try {
         const { handleStatusBanner } = await import('./worktree-cli.js');
-        handleStatusBanner(process.cwd());
+        await handleStatusBanner(process.cwd());
     }
     catch { /* non-fatal */ }
 }

package/dist/resources/extensions/gsd/auto.ts

@@ -833,6 +833,9 @@ export async function handleAgentEnd(
     // permanently stalled with no unit running and no watchdog set.
     if (s.pendingAgentEndRetry) {
       s.pendingAgentEndRetry = false;
+      // Clear gap watchdog from the previous cycle to prevent concurrent
+      // dispatch when the deferred handleAgentEnd calls dispatchNextUnit (#1272).
+      clearDispatchGapWatchdog();
       setImmediate(() => {
         handleAgentEnd(ctx, pi).catch((err) => {
           const msg = err instanceof Error ? err.message : String(err);
@@ -975,8 +978,12 @@ async function dispatchNextUnit(
     return;
   }
 
-  // Reentrancy guard
-  if (s.dispatching && s.skipDepth === 0) {
+  // Reentrancy guard — unconditional to prevent concurrent dispatch from
+  // gap watchdog or pendingAgentEndRetry during skip chains (#1272).
+  // Previously the guard was bypassed when skipDepth > 0, but the recursive
+  // skip chain's inner finally block resets s.dispatching = false before the
+  // outer call's finally runs, opening a window for concurrent entry.
+  if (s.dispatching) {
     debugLog("dispatchNextUnit reentrancy guard — another dispatch in progress, bailing");
     return;
   }
@@ -1448,8 +1455,12 @@ async function dispatchNextUnit(
   }
 
   if (dispatchResult.action !== "dispatch") {
-    await new Promise(r => setImmediate(r));
-    await dispatchNextUnit(ctx, pi);
+    // Defer re-dispatch to next microtask so s.dispatching is released first,
+    // preventing reentrancy guard bypass during concurrent entry (#1272).
+    setImmediate(() => dispatchNextUnit(ctx, pi).catch(err => {
+      ctx.ui.notify(`Deferred dispatch failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+      pauseAuto(ctx, pi).catch(() => {});
+    }));
     return;
   }
 
@@ -1467,8 +1478,10 @@ async function dispatchNextUnit(
   }
   if (preDispatchResult.action === "skip") {
     ctx.ui.notify(`Skipping ${unitType} ${unitId} (pre-dispatch hook).`, "info");
-    await new Promise(r => setImmediate(r));
-    await dispatchNextUnit(ctx, pi);
+    setImmediate(() => dispatchNextUnit(ctx, pi).catch(err => {
+      ctx.ui.notify(`Deferred dispatch failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+      pauseAuto(ctx, pi).catch(() => {});
+    }));
     return;
   }
   if (preDispatchResult.action === "replace") {
@@ -1499,9 +1512,16 @@ async function dispatchNextUnit(
     if (idempotencyResult.reason === "completed" || idempotencyResult.reason === "fallback-persisted" || idempotencyResult.reason === "phantom-loop-cleared" || idempotencyResult.reason === "evicted") {
       if (!s.active) return;
       s.skipDepth++;
-      await new Promise(r => setTimeout(r, idempotencyResult.reason === "phantom-loop-cleared" ? 50 : 150));
-      await dispatchNextUnit(ctx, pi);
-      s.skipDepth = Math.max(0, s.skipDepth - 1);
+      const skipDelay = idempotencyResult.reason === "phantom-loop-cleared" ? 50 : 150;
+      // Defer re-dispatch so s.dispatching is released first (#1272).
+      setTimeout(() => {
+        dispatchNextUnit(ctx, pi).catch(err => {
+          ctx.ui.notify(`Deferred skip-dispatch failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+          pauseAuto(ctx, pi).catch(() => {});
+        }).finally(() => {
+          s.skipDepth = Math.max(0, s.skipDepth - 1);
+        });
+      }, skipDelay);
       return;
     }
   } else if (idempotencyResult.action === "stop") {
@@ -1532,8 +1552,11 @@ async function dispatchNextUnit(
     return;
   }
   if (stuckResult.action === "recovered" && stuckResult.dispatchAgain) {
-    await new Promise(r => setImmediate(r));
-    await dispatchNextUnit(ctx, pi);
+    // Defer re-dispatch so s.dispatching is released first (#1272).
+    setImmediate(() => dispatchNextUnit(ctx, pi).catch(err => {
+      ctx.ui.notify(`Deferred recovery-dispatch failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+      pauseAuto(ctx, pi).catch(() => {});
+    }));
     return;
   }
 
@@ -1779,6 +1802,15 @@ export {
 export function _getUnitConsecutiveSkips(): Map<string, number> { return s.unitConsecutiveSkips; }
 export function _resetUnitConsecutiveSkips(): void { s.unitConsecutiveSkips.clear(); }
 
+/**
+ * Test-only: expose dispatching / skipDepth state for reentrancy guard tests.
+ * Not part of the public API.
+ */
+export function _getDispatching(): boolean { return s.dispatching; }
+export function _setDispatching(v: boolean): void { s.dispatching = v; }
+export function _getSkipDepth(): number { return s.skipDepth; }
+export function _setSkipDepth(v: number): void { s.skipDepth = v; }
+
 /**
  * Dispatch a hook unit directly, bypassing normal pre-dispatch hooks.
  * Used for manual hook triggers via /gsd run-hook.

package/dist/resources/extensions/gsd/tests/auto-reentrancy-guard.test.ts

@@ -0,0 +1,127 @@
+/**
+ * auto-reentrancy-guard.test.ts — Tests for the unconditional reentrancy guard.
+ *
+ * Regression for #1272: auto-mode stuck-loop where gap watchdog or
+ * pendingAgentEndRetry could enter dispatchNextUnit concurrently during
+ * recursive skip chains because the reentrancy guard was bypassed when
+ * skipDepth > 0.
+ *
+ * The fix makes the guard unconditional (`if (s.dispatching)` without
+ * `&& s.skipDepth === 0`), and defers recursive re-dispatch via
+ * setImmediate/setTimeout so s.dispatching is released first.
+ */
+
+import {
+  _getDispatching,
+  _setDispatching,
+  _getSkipDepth,
+  _setSkipDepth,
+} from "../auto.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+  // ─── Test-only accessors work ───────────────────────────────────────────
+  console.log("\n=== reentrancy guard: test accessors round-trip ===");
+  {
+    _setDispatching(false);
+    assertEq(_getDispatching(), false, "dispatching starts false");
+
+    _setDispatching(true);
+    assertEq(_getDispatching(), true, "dispatching set to true");
+
+    _setDispatching(false);
+    assertEq(_getDispatching(), false, "dispatching reset to false");
+  }
+
+  // ─── skipDepth accessors ────────────────────────────────────────────────
+  console.log("\n=== reentrancy guard: skipDepth accessors round-trip ===");
+  {
+    _setSkipDepth(0);
+    assertEq(_getSkipDepth(), 0, "skipDepth starts at 0");
+
+    _setSkipDepth(3);
+    assertEq(_getSkipDepth(), 3, "skipDepth set to 3");
+
+    _setSkipDepth(0);
+    assertEq(_getSkipDepth(), 0, "skipDepth reset to 0");
+  }
+
+  // ─── Guard blocks even when skipDepth > 0 (#1272 regression) ───────────
+  console.log("\n=== reentrancy guard: blocks when dispatching=true regardless of skipDepth ===");
+  {
+    // Simulate the scenario from #1272: dispatching=true + skipDepth>0
+    // The old guard (`if (s.dispatching && s.skipDepth === 0)`) would allow
+    // concurrent entry when skipDepth > 0. The fix makes the check
+    // unconditional on skipDepth.
+    _setDispatching(true);
+    _setSkipDepth(2);
+
+    // Verify dispatching is true — guard should block regardless of skipDepth
+    assertTrue(
+      _getDispatching() === true,
+      "dispatching flag is true during skip chain"
+    );
+
+    // The actual reentrancy guard in dispatchNextUnit checks:
+    //   if (s.dispatching) { return; }
+    // We verify the state that would trigger the guard:
+    const wouldBlock = _getDispatching(); // unconditional check
+    const wouldBlockOld = _getDispatching() && _getSkipDepth() === 0; // old check
+
+    assertTrue(wouldBlock === true, "new guard blocks when dispatching=true, skipDepth=2");
+    assertTrue(wouldBlockOld === false, "old guard WOULD NOT block when dispatching=true, skipDepth=2 (the bug)");
+
+    // Clean up
+    _setDispatching(false);
+    _setSkipDepth(0);
+  }
+
+  // ─── Guard allows entry when dispatching=false ──────────────────────────
+  console.log("\n=== reentrancy guard: allows entry when dispatching=false ===");
+  {
+    _setDispatching(false);
+    _setSkipDepth(0);
+    assertTrue(!_getDispatching(), "guard allows entry when dispatching=false, skipDepth=0");
+
+    _setDispatching(false);
+    _setSkipDepth(3);
+    assertTrue(!_getDispatching(), "guard allows entry when dispatching=false, skipDepth=3");
+
+    _setSkipDepth(0);
+  }
+
+  // ─── skipDepth does not affect guard decision (the fix) ─────────────────
+  console.log("\n=== reentrancy guard: skipDepth is irrelevant to guard decision ===");
+  {
+    for (const depth of [0, 1, 2, 5]) {
+      _setDispatching(true);
+      _setSkipDepth(depth);
+      assertTrue(
+        _getDispatching() === true,
+        `guard blocks at skipDepth=${depth} when dispatching=true`
+      );
+    }
+
+    for (const depth of [0, 1, 2, 5]) {
+      _setDispatching(false);
+      _setSkipDepth(depth);
+      assertTrue(
+        _getDispatching() === false,
+        `guard allows at skipDepth=${depth} when dispatching=false`
+      );
+    }
+
+    // Clean up
+    _setDispatching(false);
+    _setSkipDepth(0);
+  }
+
+  report();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/worktree-cli.d.ts

@@ -12,7 +12,43 @@
  * On session exit (via session_shutdown event), auto-commits dirty work
  * so nothing is lost. The GSD extension reads GSD_CLI_WORKTREE to know
  * when a session was launched via -w.
+ *
+ * Note: Extension modules are .ts files loaded via jiti (not compiled to .js).
+ * We use createJiti() here because this module is compiled by tsc but imports
+ * from resources/extensions/gsd/ which are shipped as raw .ts (#1283).
  */
+interface ExtensionModules {
+    createWorktree: (basePath: string, name: string) => {
+        path: string;
+        branch: string;
+    };
+    listWorktrees: (basePath: string) => Array<{
+        name: string;
+        path: string;
+        branch: string;
+    }>;
+    removeWorktree: (basePath: string, name: string, opts?: {
+        deleteBranch?: boolean;
+    }) => void;
+    mergeWorktreeToMain: (basePath: string, name: string, commitMessage: string) => void;
+    diffWorktreeAll: (basePath: string, name: string) => {
+        added: any[];
+        modified: any[];
+        removed: any[];
+    };
+    diffWorktreeNumstat: (basePath: string, name: string) => Array<{
+        added: number;
+        removed: number;
+    }>;
+    worktreeBranchName: (name: string) => string;
+    worktreePath: (basePath: string, name: string) => string;
+    runWorktreePostCreateHook: (basePath: string, wtPath: string) => string | null;
+    nativeHasChanges: (path: string) => boolean;
+    nativeDetectMainBranch: (basePath: string) => string;
+    nativeCommitCountBetween: (basePath: string, from: string, to: string) => number;
+    inferCommitType: (name: string) => string;
+    autoCommitCurrentBranch: (wtPath: string, reason: string, name: string) => void;
+}
 interface WorktreeStatus {
     name: string;
     path: string;
@@ -24,11 +60,11 @@ interface WorktreeStatus {
     uncommitted: boolean;
     commits: number;
 }
-declare function getWorktreeStatus(basePath: string, name: string, wtPath: string): WorktreeStatus;
-declare function handleList(basePath: string): void;
+declare function getWorktreeStatus(ext: ExtensionModules, basePath: string, name: string, wtPath: string): WorktreeStatus;
+declare function handleList(basePath: string): Promise<void>;
 declare function handleMerge(basePath: string, args: string[]): Promise<void>;
-declare function handleClean(basePath: string): void;
-declare function handleRemove(basePath: string, args: string[]): void;
-declare function handleStatusBanner(basePath: string): void;
-declare function handleWorktreeFlag(worktreeFlag: boolean | string): void;
+declare function handleClean(basePath: string): Promise<void>;
+declare function handleRemove(basePath: string, args: string[]): Promise<void>;
+declare function handleStatusBanner(basePath: string): Promise<void>;
+declare function handleWorktreeFlag(worktreeFlag: boolean | string): Promise<void>;
 export { handleList, handleMerge, handleClean, handleRemove, handleStatusBanner, handleWorktreeFlag, getWorktreeStatus, };

package/dist/worktree-cli.js

@@ -12,18 +12,53 @@
  * On session exit (via session_shutdown event), auto-commits dirty work
  * so nothing is lost. The GSD extension reads GSD_CLI_WORKTREE to know
  * when a session was launched via -w.
+ *
+ * Note: Extension modules are .ts files loaded via jiti (not compiled to .js).
+ * We use createJiti() here because this module is compiled by tsc but imports
+ * from resources/extensions/gsd/ which are shipped as raw .ts (#1283).
  */
 import chalk from 'chalk';
-import { createWorktree, listWorktrees, removeWorktree, mergeWorktreeToMain, diffWorktreeAll, diffWorktreeNumstat, worktreeBranchName, } from './resources/extensions/gsd/worktree-manager.js';
-import { runWorktreePostCreateHook } from './resources/extensions/gsd/auto-worktree.js';
+import { createJiti } from '@mariozechner/jiti';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 import { generateWorktreeName } from './worktree-name-gen.js';
-import { nativeHasChanges, nativeDetectMainBranch, nativeCommitCountBetween, } from './resources/extensions/gsd/native-git-bridge.js';
-import { inferCommitType } from './resources/extensions/gsd/git-service.js';
 import { existsSync } from 'node:fs';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const jiti = createJiti(fileURLToPath(import.meta.url), { interopDefault: true, debug: false });
+// Lazily-loaded extension modules (loaded once on first use via jiti)
+let _ext = null;
+async function loadExtensionModules() {
+    if (_ext)
+        return _ext;
+    const [wtMgr, autoWt, gitBridge, gitSvc, wt] = await Promise.all([
+        jiti.import(join(__dirname, 'resources/extensions/gsd/worktree-manager.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/auto-worktree.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/native-git-bridge.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/git-service.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/worktree.ts'), {}),
+    ]);
+    _ext = {
+        createWorktree: wtMgr.createWorktree,
+        listWorktrees: wtMgr.listWorktrees,
+        removeWorktree: wtMgr.removeWorktree,
+        mergeWorktreeToMain: wtMgr.mergeWorktreeToMain,
+        diffWorktreeAll: wtMgr.diffWorktreeAll,
+        diffWorktreeNumstat: wtMgr.diffWorktreeNumstat,
+        worktreeBranchName: wtMgr.worktreeBranchName,
+        worktreePath: wtMgr.worktreePath,
+        runWorktreePostCreateHook: autoWt.runWorktreePostCreateHook,
+        nativeHasChanges: gitBridge.nativeHasChanges,
+        nativeDetectMainBranch: gitBridge.nativeDetectMainBranch,
+        nativeCommitCountBetween: gitBridge.nativeCommitCountBetween,
+        inferCommitType: gitSvc.inferCommitType,
+        autoCommitCurrentBranch: wt.autoCommitCurrentBranch,
+    };
+    return _ext;
+}
 // ─── Status Helpers ─────────────────────────────────────────────────────────
-function getWorktreeStatus(basePath, name, wtPath) {
-    const diff = diffWorktreeAll(basePath, name);
-    const numstat = diffWorktreeNumstat(basePath, name);
+function getWorktreeStatus(ext, basePath, name, wtPath) {
+    const diff = ext.diffWorktreeAll(basePath, name);
+    const numstat = ext.diffWorktreeNumstat(basePath, name);
     const filesChanged = diff.added.length + diff.modified.length + diff.removed.length;
     let linesAdded = 0;
     let linesRemoved = 0;
@@ -33,19 +68,19 @@ function getWorktreeStatus(basePath, name, wtPath) {
     }
     let uncommitted = false;
     try {
-        uncommitted = existsSync(wtPath) && nativeHasChanges(wtPath);
+        uncommitted = existsSync(wtPath) && ext.nativeHasChanges(wtPath);
     }
     catch { /* */ }
     let commits = 0;
     try {
-        const mainBranch = nativeDetectMainBranch(basePath);
-        commits = nativeCommitCountBetween(basePath, mainBranch, worktreeBranchName(name));
+        const mainBranch = ext.nativeDetectMainBranch(basePath);
+        commits = ext.nativeCommitCountBetween(basePath, mainBranch, ext.worktreeBranchName(name));
     }
     catch { /* */ }
     return {
         name,
         path: wtPath,
-        branch: worktreeBranchName(name),
+        branch: ext.worktreeBranchName(name),
         exists: existsSync(wtPath),
         filesChanged,
         linesAdded,
@@ -71,65 +106,66 @@ function formatStatus(s) {
     return lines.join('\n');
 }
 // ─── Subcommand: list ───────────────────────────────────────────────────────
-function handleList(basePath) {
-    const worktrees = listWorktrees(basePath);
+async function handleList(basePath) {
+    const ext = await loadExtensionModules();
+    const worktrees = ext.listWorktrees(basePath);
     if (worktrees.length === 0) {
         process.stderr.write(chalk.dim('No worktrees. Create one with: gsd -w <name>\n'));
         return;
     }
     process.stderr.write(chalk.bold('\nWorktrees\n\n'));
     for (const wt of worktrees) {
-        const status = getWorktreeStatus(basePath, wt.name, wt.path);
+        const status = getWorktreeStatus(ext, basePath, wt.name, wt.path);
         process.stderr.write(formatStatus(status) + '\n\n');
     }
 }
 // ─── Subcommand: merge ──────────────────────────────────────────────────────
 async function handleMerge(basePath, args) {
+    const ext = await loadExtensionModules();
     const name = args[0];
     if (!name) {
         // If only one worktree exists, merge it
-        const worktrees = listWorktrees(basePath);
+        const worktrees = ext.listWorktrees(basePath);
         if (worktrees.length === 1) {
-            await doMerge(basePath, worktrees[0].name);
+            await doMerge(ext, basePath, worktrees[0].name);
             return;
         }
         process.stderr.write(chalk.red('Usage: gsd worktree merge <name>\n'));
         process.stderr.write(chalk.dim('Run gsd worktree list to see worktrees.\n'));
         process.exit(1);
     }
-    await doMerge(basePath, name);
+    await doMerge(ext, basePath, name);
 }
-async function doMerge(basePath, name) {
-    const worktrees = listWorktrees(basePath);
+async function doMerge(ext, basePath, name) {
+    const worktrees = ext.listWorktrees(basePath);
     const wt = worktrees.find(w => w.name === name);
     if (!wt) {
         process.stderr.write(chalk.red(`Worktree "${name}" not found.\n`));
         process.exit(1);
     }
-    const status = getWorktreeStatus(basePath, name, wt.path);
+    const status = getWorktreeStatus(ext, basePath, name, wt.path);
     if (status.filesChanged === 0 && !status.uncommitted) {
         process.stderr.write(chalk.dim(`Worktree "${name}" has no changes to merge.\n`));
         // Clean up empty worktree
-        removeWorktree(basePath, name, { deleteBranch: true });
+        ext.removeWorktree(basePath, name, { deleteBranch: true });
         process.stderr.write(chalk.green(`Removed empty worktree ${chalk.bold(name)}.\n`));
         return;
     }
     // Auto-commit dirty work before merge
     if (status.uncommitted) {
         try {
-            const { autoCommitCurrentBranch } = await import('./resources/extensions/gsd/worktree.js');
-            autoCommitCurrentBranch(wt.path, 'worktree-merge', name);
+            ext.autoCommitCurrentBranch(wt.path, 'worktree-merge', name);
             process.stderr.write(chalk.dim('  Auto-committed dirty work before merge.\n'));
         }
         catch { /* best-effort */ }
     }
-    const commitType = inferCommitType(name);
+    const commitType = ext.inferCommitType(name);
     const commitMessage = `${commitType}(${name}): merge worktree ${name}`;
-    process.stderr.write(`\nMerging ${chalk.bold.cyan(name)} → ${chalk.magenta(nativeDetectMainBranch(basePath))}\n`);
+    process.stderr.write(`\nMerging ${chalk.bold.cyan(name)} → ${chalk.magenta(ext.nativeDetectMainBranch(basePath))}\n`);
     process.stderr.write(chalk.dim(`  ${status.filesChanged} files, ${chalk.green(`+${status.linesAdded}`)} ${chalk.red(`-${status.linesRemoved}`)}\n\n`));
     try {
-        mergeWorktreeToMain(basePath, name, commitMessage);
-        removeWorktree(basePath, name, { deleteBranch: true });
+        ext.mergeWorktreeToMain(basePath, name, commitMessage);
+        ext.removeWorktree(basePath, name, { deleteBranch: true });
         process.stderr.write(chalk.green(`✓ Merged and cleaned up ${chalk.bold(name)}\n`));
         process.stderr.write(chalk.dim(`  commit: ${commitMessage}\n`));
     }
@@ -141,18 +177,19 @@ async function doMerge(basePath, name) {
     }
 }
 // ─── Subcommand: clean ──────────────────────────────────────────────────────
-function handleClean(basePath) {
-    const worktrees = listWorktrees(basePath);
+async function handleClean(basePath) {
+    const ext = await loadExtensionModules();
+    const worktrees = ext.listWorktrees(basePath);
     if (worktrees.length === 0) {
         process.stderr.write(chalk.dim('No worktrees to clean.\n'));
         return;
     }
     let cleaned = 0;
     for (const wt of worktrees) {
-        const status = getWorktreeStatus(basePath, wt.name, wt.path);
+        const status = getWorktreeStatus(ext, basePath, wt.name, wt.path);
         if (status.filesChanged === 0 && !status.uncommitted) {
             try {
-                removeWorktree(basePath, wt.name, { deleteBranch: true });
+                ext.removeWorktree(basePath, wt.name, { deleteBranch: true });
                 process.stderr.write(chalk.green(`  ✓ Removed ${chalk.bold(wt.name)} (clean)\n`));
                 cleaned++;
             }
@@ -167,19 +204,20 @@ function handleClean(basePath) {
     process.stderr.write(chalk.dim(`\nCleaned ${cleaned} worktree${cleaned === 1 ? '' : 's'}.\n`));
 }
 // ─── Subcommand: remove ─────────────────────────────────────────────────────
-function handleRemove(basePath, args) {
+async function handleRemove(basePath, args) {
+    const ext = await loadExtensionModules();
     const name = args[0];
     if (!name) {
         process.stderr.write(chalk.red('Usage: gsd worktree remove <name>\n'));
         process.exit(1);
     }
-    const worktrees = listWorktrees(basePath);
+    const worktrees = ext.listWorktrees(basePath);
     const wt = worktrees.find(w => w.name === name);
     if (!wt) {
         process.stderr.write(chalk.red(`Worktree "${name}" not found.\n`));
         process.exit(1);
     }
-    const status = getWorktreeStatus(basePath, name, wt.path);
+    const status = getWorktreeStatus(ext, basePath, name, wt.path);
     if (status.filesChanged > 0 || status.uncommitted) {
         process.stderr.write(chalk.yellow(`⚠ Worktree "${name}" has unmerged changes (${status.filesChanged} files).\n`));
         process.stderr.write(chalk.yellow('  Use --force to remove anyway, or merge first: gsd worktree merge ' + name + '\n'));
@@ -187,17 +225,18 @@ function handleRemove(basePath, args) {
             process.exit(1);
         }
     }
-    removeWorktree(basePath, name, { deleteBranch: true });
+    ext.removeWorktree(basePath, name, { deleteBranch: true });
     process.stderr.write(chalk.green(`✓ Removed worktree ${chalk.bold(name)}\n`));
 }
 // ─── Subcommand: status (default when no args) ─────────────────────────────
-function handleStatusBanner(basePath) {
-    const worktrees = listWorktrees(basePath);
+async function handleStatusBanner(basePath) {
+    const ext = await loadExtensionModules();
+    const worktrees = ext.listWorktrees(basePath);
     if (worktrees.length === 0)
         return;
     const withChanges = worktrees.filter(wt => {
         try {
-            const diff = diffWorktreeAll(basePath, wt.name);
+            const diff = ext.diffWorktreeAll(basePath, wt.name);
             return diff.added.length + diff.modified.length + diff.removed.length > 0;
         }
         catch {
@@ -214,14 +253,15 @@ function handleStatusBanner(basePath) {
         chalk.dim('Resume: gsd -w <name>  |  Merge: gsd worktree merge <name>  |  List: gsd worktree list\n\n'));
 }
 // ─── -w flag: create/resume worktree for interactive session ────────────────
-function handleWorktreeFlag(worktreeFlag) {
+async function handleWorktreeFlag(worktreeFlag) {
+    const ext = await loadExtensionModules();
     const basePath = process.cwd();
     // gsd -w (no name) — resume most recent worktree with changes, or create new
     if (worktreeFlag === true) {
-        const existing = listWorktrees(basePath);
+        const existing = ext.listWorktrees(basePath);
         const withChanges = existing.filter(wt => {
             try {
-                const diff = diffWorktreeAll(basePath, wt.name);
+                const diff = ext.diffWorktreeAll(basePath, wt.name);
                 return diff.added.length + diff.modified.length + diff.removed.length > 0;
             }
             catch {
@@ -243,7 +283,7 @@ function handleWorktreeFlag(worktreeFlag) {
             // Multiple active worktrees — show them and ask user to pick
             process.stderr.write(chalk.yellow(`${withChanges.length} worktrees have unmerged changes:\n\n`));
             for (const wt of withChanges) {
-                const status = getWorktreeStatus(basePath, wt.name, wt.path);
+                const status = getWorktreeStatus(ext, basePath, wt.name, wt.path);
                 process.stderr.write(formatStatus(status) + '\n\n');
             }
             process.stderr.write(chalk.dim('Specify which one: gsd -w <name>\n'));
@@ -251,12 +291,12 @@ function handleWorktreeFlag(worktreeFlag) {
         }
         // No active worktrees — create a new one
         const name = generateWorktreeName();
-        createAndEnter(basePath, name);
+        await createAndEnter(ext, basePath, name);
         return;
     }
     // gsd -w <name> — create or resume named worktree
     const name = worktreeFlag;
-    const existing = listWorktrees(basePath);
+    const existing = ext.listWorktrees(basePath);
     const found = existing.find(wt => wt.name === name);
     if (found) {
         process.chdir(found.path);
@@ -267,13 +307,13 @@ function handleWorktreeFlag(worktreeFlag) {
         process.stderr.write(chalk.dim(`  branch ${found.branch}\n\n`));
     }
     else {
-        createAndEnter(basePath, name);
+        await createAndEnter(ext, basePath, name);
     }
 }
-function createAndEnter(basePath, name) {
+async function createAndEnter(ext, basePath, name) {
     try {
-        const info = createWorktree(basePath, name);
-        const hookError = runWorktreePostCreateHook(basePath, info.path);
+        const info = ext.createWorktree(basePath, name);
+        const hookError = ext.runWorktreePostCreateHook(basePath, info.path);
         if (hookError) {
             process.stderr.write(chalk.yellow(`[gsd] ${hookError}\n`));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.31.2-dev.91f95cf",
+  "version": "2.31.2-dev.c8d7e03",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {

package/src/resources/extensions/gsd/auto.ts

@@ -833,6 +833,9 @@ export async function handleAgentEnd(
     // permanently stalled with no unit running and no watchdog set.
     if (s.pendingAgentEndRetry) {
       s.pendingAgentEndRetry = false;
+      // Clear gap watchdog from the previous cycle to prevent concurrent
+      // dispatch when the deferred handleAgentEnd calls dispatchNextUnit (#1272).
+      clearDispatchGapWatchdog();
       setImmediate(() => {
         handleAgentEnd(ctx, pi).catch((err) => {
           const msg = err instanceof Error ? err.message : String(err);
@@ -975,8 +978,12 @@ async function dispatchNextUnit(
     return;
   }
 
-  // Reentrancy guard
-  if (s.dispatching && s.skipDepth === 0) {
+  // Reentrancy guard — unconditional to prevent concurrent dispatch from
+  // gap watchdog or pendingAgentEndRetry during skip chains (#1272).
+  // Previously the guard was bypassed when skipDepth > 0, but the recursive
+  // skip chain's inner finally block resets s.dispatching = false before the
+  // outer call's finally runs, opening a window for concurrent entry.
+  if (s.dispatching) {
     debugLog("dispatchNextUnit reentrancy guard — another dispatch in progress, bailing");
     return;
   }
@@ -1448,8 +1455,12 @@ async function dispatchNextUnit(
   }
 
   if (dispatchResult.action !== "dispatch") {
-    await new Promise(r => setImmediate(r));
-    await dispatchNextUnit(ctx, pi);
+    // Defer re-dispatch to next microtask so s.dispatching is released first,
+    // preventing reentrancy guard bypass during concurrent entry (#1272).
+    setImmediate(() => dispatchNextUnit(ctx, pi).catch(err => {
+      ctx.ui.notify(`Deferred dispatch failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+      pauseAuto(ctx, pi).catch(() => {});
+    }));
     return;
   }
 
@@ -1467,8 +1478,10 @@ async function dispatchNextUnit(
   }
   if (preDispatchResult.action === "skip") {
     ctx.ui.notify(`Skipping ${unitType} ${unitId} (pre-dispatch hook).`, "info");
-    await new Promise(r => setImmediate(r));
-    await dispatchNextUnit(ctx, pi);
+    setImmediate(() => dispatchNextUnit(ctx, pi).catch(err => {
+      ctx.ui.notify(`Deferred dispatch failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+      pauseAuto(ctx, pi).catch(() => {});
+    }));
     return;
   }
   if (preDispatchResult.action === "replace") {
@@ -1499,9 +1512,16 @@ async function dispatchNextUnit(
     if (idempotencyResult.reason === "completed" || idempotencyResult.reason === "fallback-persisted" || idempotencyResult.reason === "phantom-loop-cleared" || idempotencyResult.reason === "evicted") {
       if (!s.active) return;
       s.skipDepth++;
-      await new Promise(r => setTimeout(r, idempotencyResult.reason === "phantom-loop-cleared" ? 50 : 150));
-      await dispatchNextUnit(ctx, pi);
-      s.skipDepth = Math.max(0, s.skipDepth - 1);
+      const skipDelay = idempotencyResult.reason === "phantom-loop-cleared" ? 50 : 150;
+      // Defer re-dispatch so s.dispatching is released first (#1272).
+      setTimeout(() => {
+        dispatchNextUnit(ctx, pi).catch(err => {
+          ctx.ui.notify(`Deferred skip-dispatch failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+          pauseAuto(ctx, pi).catch(() => {});
+        }).finally(() => {
+          s.skipDepth = Math.max(0, s.skipDepth - 1);
+        });
+      }, skipDelay);
       return;
     }
   } else if (idempotencyResult.action === "stop") {
@@ -1532,8 +1552,11 @@ async function dispatchNextUnit(
     return;
   }
   if (stuckResult.action === "recovered" && stuckResult.dispatchAgain) {
-    await new Promise(r => setImmediate(r));
-    await dispatchNextUnit(ctx, pi);
+    // Defer re-dispatch so s.dispatching is released first (#1272).
+    setImmediate(() => dispatchNextUnit(ctx, pi).catch(err => {
+      ctx.ui.notify(`Deferred recovery-dispatch failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+      pauseAuto(ctx, pi).catch(() => {});
+    }));
     return;
   }
 
@@ -1779,6 +1802,15 @@ export {
 export function _getUnitConsecutiveSkips(): Map<string, number> { return s.unitConsecutiveSkips; }
 export function _resetUnitConsecutiveSkips(): void { s.unitConsecutiveSkips.clear(); }
 
+/**
+ * Test-only: expose dispatching / skipDepth state for reentrancy guard tests.
+ * Not part of the public API.
+ */
+export function _getDispatching(): boolean { return s.dispatching; }
+export function _setDispatching(v: boolean): void { s.dispatching = v; }
+export function _getSkipDepth(): number { return s.skipDepth; }
+export function _setSkipDepth(v: number): void { s.skipDepth = v; }
+
 /**
  * Dispatch a hook unit directly, bypassing normal pre-dispatch hooks.
  * Used for manual hook triggers via /gsd run-hook.

package/src/resources/extensions/gsd/tests/auto-reentrancy-guard.test.ts

@@ -0,0 +1,127 @@
+/**
+ * auto-reentrancy-guard.test.ts — Tests for the unconditional reentrancy guard.
+ *
+ * Regression for #1272: auto-mode stuck-loop where gap watchdog or
+ * pendingAgentEndRetry could enter dispatchNextUnit concurrently during
+ * recursive skip chains because the reentrancy guard was bypassed when
+ * skipDepth > 0.
+ *
+ * The fix makes the guard unconditional (`if (s.dispatching)` without
+ * `&& s.skipDepth === 0`), and defers recursive re-dispatch via
+ * setImmediate/setTimeout so s.dispatching is released first.
+ */
+
+import {
+  _getDispatching,
+  _setDispatching,
+  _getSkipDepth,
+  _setSkipDepth,
+} from "../auto.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+  // ─── Test-only accessors work ───────────────────────────────────────────
+  console.log("\n=== reentrancy guard: test accessors round-trip ===");
+  {
+    _setDispatching(false);
+    assertEq(_getDispatching(), false, "dispatching starts false");
+
+    _setDispatching(true);
+    assertEq(_getDispatching(), true, "dispatching set to true");
+
+    _setDispatching(false);
+    assertEq(_getDispatching(), false, "dispatching reset to false");
+  }
+
+  // ─── skipDepth accessors ────────────────────────────────────────────────
+  console.log("\n=== reentrancy guard: skipDepth accessors round-trip ===");
+  {
+    _setSkipDepth(0);
+    assertEq(_getSkipDepth(), 0, "skipDepth starts at 0");
+
+    _setSkipDepth(3);
+    assertEq(_getSkipDepth(), 3, "skipDepth set to 3");
+
+    _setSkipDepth(0);
+    assertEq(_getSkipDepth(), 0, "skipDepth reset to 0");
+  }
+
+  // ─── Guard blocks even when skipDepth > 0 (#1272 regression) ───────────
+  console.log("\n=== reentrancy guard: blocks when dispatching=true regardless of skipDepth ===");
+  {
+    // Simulate the scenario from #1272: dispatching=true + skipDepth>0
+    // The old guard (`if (s.dispatching && s.skipDepth === 0)`) would allow
+    // concurrent entry when skipDepth > 0. The fix makes the check
+    // unconditional on skipDepth.
+    _setDispatching(true);
+    _setSkipDepth(2);
+
+    // Verify dispatching is true — guard should block regardless of skipDepth
+    assertTrue(
+      _getDispatching() === true,
+      "dispatching flag is true during skip chain"
+    );
+
+    // The actual reentrancy guard in dispatchNextUnit checks:
+    //   if (s.dispatching) { return; }
+    // We verify the state that would trigger the guard:
+    const wouldBlock = _getDispatching(); // unconditional check
+    const wouldBlockOld = _getDispatching() && _getSkipDepth() === 0; // old check
+
+    assertTrue(wouldBlock === true, "new guard blocks when dispatching=true, skipDepth=2");
+    assertTrue(wouldBlockOld === false, "old guard WOULD NOT block when dispatching=true, skipDepth=2 (the bug)");
+
+    // Clean up
+    _setDispatching(false);
+    _setSkipDepth(0);
+  }
+
+  // ─── Guard allows entry when dispatching=false ──────────────────────────
+  console.log("\n=== reentrancy guard: allows entry when dispatching=false ===");
+  {
+    _setDispatching(false);
+    _setSkipDepth(0);
+    assertTrue(!_getDispatching(), "guard allows entry when dispatching=false, skipDepth=0");
+
+    _setDispatching(false);
+    _setSkipDepth(3);
+    assertTrue(!_getDispatching(), "guard allows entry when dispatching=false, skipDepth=3");
+
+    _setSkipDepth(0);
+  }
+
+  // ─── skipDepth does not affect guard decision (the fix) ─────────────────
+  console.log("\n=== reentrancy guard: skipDepth is irrelevant to guard decision ===");
+  {
+    for (const depth of [0, 1, 2, 5]) {
+      _setDispatching(true);
+      _setSkipDepth(depth);
+      assertTrue(
+        _getDispatching() === true,
+        `guard blocks at skipDepth=${depth} when dispatching=true`
+      );
+    }
+
+    for (const depth of [0, 1, 2, 5]) {
+      _setDispatching(false);
+      _setSkipDepth(depth);
+      assertTrue(
+        _getDispatching() === false,
+        `guard allows at skipDepth=${depth} when dispatching=false`
+      );
+    }
+
+    // Clean up
+    _setDispatching(false);
+    _setSkipDepth(0);
+  }
+
+  report();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});