gsd-pi 2.33.1 → 2.34.0-dev.bbb5216

package/src/resources/extensions/gsd/repo-identity.ts

@@ -8,9 +8,9 @@
 
 import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
-import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, symlinkSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, symlinkSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve, sep } from "node:path";
+import { join, resolve } from "node:path";
 
 // ─── Repo Identity ──────────────────────────────────────────────────────────
 
@@ -35,35 +35,56 @@ function getRemoteUrl(basePath: string): string {
  * Resolve the git toplevel (real root) for the given path.
  * For worktrees this returns the main repo root, not the worktree path.
  */
-function resolveGitRoot(basePath: string): string {
+function canonicalizeExistingPath(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+
+function resolveGitCommonDir(basePath: string): string {
   try {
-    // In a worktree, --show-toplevel returns the worktree path, not the main
-    // repo root. Use --git-common-dir to find the shared .git directory,
-    // then derive the main repo root from it (#1288).
-    const commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+    return execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+      cwd: basePath,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5_000,
+    }).trim();
+  } catch {
+    const raw = execFileSync("git", ["rev-parse", "--git-common-dir"], {
       cwd: basePath,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 5_000,
     }).trim();
+    return resolve(basePath, raw);
+  }
+}
+
+function resolveGitRoot(basePath: string): string {
+  try {
+    const commonDir = resolveGitCommonDir(basePath);
+    const normalizedCommonDir = commonDir.replaceAll("\\", "/");
+
+    // Normal repo or worktree with shared common dir pointing at <repo>/.git.
+    if (normalizedCommonDir.endsWith("/.git")) {
+      return canonicalizeExistingPath(resolve(commonDir, ".."));
+    }
 
-    // If commonDir ends with .git/worktrees/<name>, the main repo is two
-    // levels up from the worktrees dir. If it's just .git, resolve normally.
-    if (commonDir.includes(`${sep}worktrees${sep}`) || commonDir.includes("/worktrees/")) {
-      // e.g., /path/to/project/.gsd/worktrees/M001/.git → /path/to/project
-      // or /path/to/project/.git/worktrees/M001 → /path/to/project
-      const gitDir = commonDir.replace(/[/\\]worktrees[/\\][^/\\]+$/, "");
-      const mainRoot = resolve(gitDir, "..");
-      return mainRoot;
+    // Some git setups may still expose <repo>/.git/worktrees/<name>.
+    const worktreeMarker = "/.git/worktrees/";
+    if (normalizedCommonDir.includes(worktreeMarker)) {
+      return canonicalizeExistingPath(resolve(commonDir, "..", ".."));
     }
 
-    // Not in a worktree — use --show-toplevel as usual
-    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+    // Fallback for unusual layouts.
+    return canonicalizeExistingPath(execFileSync("git", ["rev-parse", "--show-toplevel"], {
       cwd: basePath,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 5_000,
-    }).trim();
+    }).trim());
   } catch {
     return resolve(basePath);
   }
@@ -111,10 +132,17 @@ export function externalGsdRoot(basePath: string): string {
 export function ensureGsdSymlink(projectPath: string): string {
   const externalPath = externalGsdRoot(projectPath);
   const localGsd = join(projectPath, ".gsd");
+  const inWorktree = isInsideWorktree(projectPath);
 
   // Ensure external directory exists
   mkdirSync(externalPath, { recursive: true });
 
+  const replaceWithSymlink = (): string => {
+    rmSync(localGsd, { recursive: true, force: true });
+    symlinkSync(externalPath, localGsd, "junction");
+    return externalPath;
+  };
+
   if (!existsSync(localGsd)) {
     // Nothing exists yet — create symlink
     symlinkSync(externalPath, localGsd, "junction");
@@ -130,14 +158,20 @@ export function ensureGsdSymlink(projectPath: string): string {
       if (target === externalPath) {
         return externalPath; // correct symlink, no-op
       }
-      // Symlink exists but points elsewhere — leave it for now
-      // (could be a custom override or stale symlink)
+      // In a worktree, mismatched symlinks are always stale. Heal them so
+      // the worktree points at the same external state dir as the main repo.
+      if (inWorktree) {
+        return replaceWithSymlink();
+      }
+      // Outside worktrees, preserve custom overrides or legacy symlinks.
       return target;
     }
 
     if (stat.isDirectory()) {
-      // Real directory — migration will handle this later.
-      // Return the local path so existing code still works.
+      // Real directory in the main repo — migration will handle this later.
+      // In worktrees, keep the directory in place and let syncGsdStateToWorktree
+      // refresh its contents. Replacing a git-tracked .gsd directory with a
+      // symlink makes git think tracked planning files were deleted.
       return localGsd;
     }
   } catch {

package/src/resources/extensions/gsd/session-lock.ts

@@ -122,6 +122,12 @@ function ensureExitHandler(gsdDir: string): void {
     try {
       if (_releaseFunction) { _releaseFunction(); _releaseFunction = null; }
     } catch { /* best-effort */ }
+    // Remove the auto.lock metadata file so crash-recovery doesn't
+    // falsely detect an interrupted session on the next startup.
+    try {
+      const lockFile = join(gsdDir, LOCK_FILE);
+      if (existsSync(lockFile)) unlinkSync(lockFile);
+    } catch { /* best-effort */ }
     try {
       const lockDir = join(gsdDir + ".lock");
       if (existsSync(lockDir)) rmSync(lockDir, { recursive: true, force: true });
@@ -143,6 +149,16 @@ function ensureExitHandler(gsdDir: string): void {
 export function acquireSessionLock(basePath: string): SessionLockResult {
   const lp = lockPath(basePath);
 
+  // Re-entrant acquire on the same path: release our current OS lock first so
+  // proper-lockfile clears its update timer before we acquire a fresh lock.
+  if (_releaseFunction && _lockedPath === basePath) {
+    try { _releaseFunction(); } catch { /* may already be released */ }
+    _releaseFunction = null;
+    _lockedPath = null;
+    _lockPid = 0;
+    _lockCompromised = false;
+  }
+
   // Ensure the directory exists
   mkdirSync(dirname(lp), { recursive: true });
 
@@ -228,6 +244,7 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
         _releaseFunction = release;
         _lockedPath = basePath;
         _lockPid = process.pid;
+        _lockCompromised = false;
 
         // Safety net — uses centralized handler to avoid double-registration
         ensureExitHandler(gsdDir);

package/src/resources/extensions/gsd/templates/preferences.md

@@ -30,6 +30,7 @@ token_profile:
 phases:
   skip_research:
   skip_reassess:
+  reassess_after_slice:
   skip_slice_research:
 dynamic_routing:
   enabled:

package/src/resources/extensions/gsd/tests/agent-end-retry.test.ts

@@ -1,14 +1,9 @@
 /**
- * agent-end-retry.test.ts — Verifies the deferred agent_end retry mechanism (#1072).
+ * agent-end-retry.test.ts — Regression checks for the post-#1419 agent_end model.
  *
- * When handleAgentEnd is already running and a second agent_end event fires
- * (e.g. a hook/triage/quick-task unit dispatched inside handleAgentEnd completes
- * before it returns), the reentrancy guard must not silently drop the event.
- * Instead, it should queue a retry via pendingAgentEndRetry so the completed
- * unit's agent_end is processed after the current handler finishes.
- *
- * Without this, auto-mode can stall permanently in the "summarizing" phase
- * with no unit running and no watchdog set.
+ * The old recursive handleAgentEnd retry path is gone. The loop now keeps
+ * pendingResolve + pendingAgentEndQueue on AutoSession, and handleAgentEnd is
+ * only a thin compatibility wrapper around resolveAgentEnd().
  */
 
 import test from "node:test";
@@ -29,79 +24,57 @@ function getSessionTsSource(): string {
   return readFileSync(SESSION_TS_PATH, "utf-8");
 }
 
-// ── AutoSession must declare pendingAgentEndRetry ────────────────────────────
-
-test("AutoSession declares pendingAgentEndRetry field", () => {
+test("AutoSession declares pending agent_end queue state", () => {
   const source = getSessionTsSource();
   assert.ok(
-    source.includes("pendingAgentEndRetry"),
-    "AutoSession (auto/session.ts) must declare pendingAgentEndRetry field for deferred retry",
+    source.includes("pendingResolve"),
+    "AutoSession must declare pendingResolve for the in-flight unit promise",
+  );
+  assert.ok(
+    source.includes("pendingAgentEndQueue"),
+    "AutoSession must declare pendingAgentEndQueue for between-iteration agent_end events",
   );
 });
 
-test("AutoSession resets pendingAgentEndRetry in reset()", () => {
+test("AutoSession reset clears pending agent_end queue state", () => {
   const source = getSessionTsSource();
-  // Find the reset() method — it's declared as "reset(): void {"
   const resetIdx = source.indexOf("reset(): void");
   assert.ok(resetIdx > -1, "AutoSession must have a reset() method");
-  const resetBlock = source.slice(resetIdx, resetIdx + 3000);
+  const resetBlock = source.slice(resetIdx, resetIdx + 4000);
   assert.ok(
-    resetBlock.includes("pendingAgentEndRetry"),
-    "reset() must clear pendingAgentEndRetry",
+    resetBlock.includes("this.pendingResolve = null"),
+    "reset() must clear pendingResolve",
   );
-});
-
-// ── handleAgentEnd reentrancy guard must queue retry ─────────────────────────
-
-test("handleAgentEnd sets pendingAgentEndRetry when reentrant", () => {
-  const source = getAutoTsSource();
-  // Find the handleAgentEnd function
-  const fnIdx = source.indexOf("export async function handleAgentEnd");
-  assert.ok(fnIdx > -1, "handleAgentEnd must exist in auto.ts");
-
-  // The reentrancy guard section (within ~500 chars of the function start)
-  const guardBlock = source.slice(fnIdx, fnIdx + 800);
   assert.ok(
-    guardBlock.includes("s.handlingAgentEnd"),
-    "handleAgentEnd must check s.handlingAgentEnd",
+    resetBlock.includes("this.pendingAgentEndQueue = []"),
+    "reset() must clear pendingAgentEndQueue",
   );
+});
+
+test("legacy pendingAgentEndRetry state is gone", () => {
+  const source = getSessionTsSource();
   assert.ok(
-    guardBlock.includes("pendingAgentEndRetry = true"),
-    "reentrancy guard must set pendingAgentEndRetry = true instead of silently dropping (#1072)",
+    !source.includes("pendingAgentEndRetry"),
+    "AutoSession should no longer use legacy pendingAgentEndRetry state",
   );
 });
 
-// ── finally block must process pendingAgentEndRetry ──────────────────────────
-
-test("handleAgentEnd finally block retries if pendingAgentEndRetry is set", () => {
+test("handleAgentEnd is a thin compatibility wrapper", () => {
   const source = getAutoTsSource();
   const fnIdx = source.indexOf("export async function handleAgentEnd");
-  assert.ok(fnIdx > -1, "handleAgentEnd must exist");
-
-  // Find the finally block within handleAgentEnd (search for the closing pattern)
+  assert.ok(fnIdx > -1, "handleAgentEnd must exist in auto.ts");
   const fnBlock = source.slice(fnIdx, source.indexOf("\n// ─── ", fnIdx + 100));
+
   assert.ok(
-    fnBlock.includes("pendingAgentEndRetry"),
-    "handleAgentEnd finally block must check pendingAgentEndRetry",
-  );
-  assert.ok(
-    fnBlock.includes("setImmediate"),
-    "deferred retry must use setImmediate to avoid stack overflow (#1072)",
+    fnBlock.includes("resolveAgentEnd("),
+    "handleAgentEnd must delegate to resolveAgentEnd",
   );
   assert.ok(
-    fnBlock.includes("handleAgentEnd(ctx, pi)"),
-    "deferred retry must call handleAgentEnd recursively (#1072)",
+    !fnBlock.includes("pendingAgentEndRetry"),
+    "handleAgentEnd must not use legacy retry state",
   );
-});
-
-// ── Regression: reentrancy guard must NOT silently return ─────────────────────
-
-test("reentrancy guard references issue #1072", () => {
-  const source = getAutoTsSource();
-  const fnIdx = source.indexOf("export async function handleAgentEnd");
-  const guardBlock = source.slice(fnIdx, fnIdx + 800);
   assert.ok(
-    guardBlock.includes("1072"),
-    "reentrancy guard comment must reference #1072 for traceability",
+    !fnBlock.includes("dispatchNextUnit"),
+    "handleAgentEnd must not dispatch recursively",
   );
 });

package/src/resources/extensions/gsd/tests/all-milestones-complete-merge.test.ts

@@ -12,7 +12,15 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, realpathSync, readFileSync } from "node:fs";
+import {
+  mkdtempSync,
+  mkdirSync,
+  rmSync,
+  writeFileSync,
+  existsSync,
+  realpathSync,
+  readFileSync,
+} from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -28,11 +36,17 @@ import {
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 function run(command: string, cwd: string): string {
-  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+  return execSync(command, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
 }
 
 function createTempRepo(): string {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-all-complete-test-")));
+  const dir = realpathSync(
+    mkdtempSync(join(tmpdir(), "gsd-all-complete-test-")),
+  );
   run("git init", dir);
   run("git config user.email test@test.com", dir);
   run("git config user.name Test", dir);
@@ -63,41 +77,54 @@ function createMilestoneArtifacts(dir: string, mid: string): void {
 
 // ─── Source-level: verify the merge code exists in the "all complete" path ────
 
-test("auto.ts 'all milestones complete' path merges before stopping (#962)", () => {
-  const autoSrc = readFileSync(join(__dirname, "..", "auto.ts"), "utf-8");
+test("auto-loop 'all milestones complete' path merges before stopping (#962)", () => {
+  const loopSrc = readFileSync(join(__dirname, "..", "auto-loop.ts"), "utf-8");
+  const resolverSrc = readFileSync(
+    join(__dirname, "..", "worktree-resolver.ts"),
+    "utf-8",
+  );
 
   // Find the "incomplete.length === 0" block
-  const incompleteIdx = autoSrc.indexOf("incomplete.length === 0");
-  assert.ok(incompleteIdx > -1, "auto.ts should have 'incomplete.length === 0' check");
+  const incompleteIdx = loopSrc.indexOf("incomplete.length === 0");
+  assert.ok(
+    incompleteIdx > -1,
+    "auto-loop.ts should have 'incomplete.length === 0' check",
+  );
 
   // The merge call must appear BETWEEN the incomplete check and the stopAuto call.
-  // After the #1308 refactor, the merge is delegated to tryMergeMilestone.
-  const blockAfterIncomplete = autoSrc.slice(incompleteIdx, incompleteIdx + 3000);
+  const blockAfterIncomplete = loopSrc.slice(
+    incompleteIdx,
+    incompleteIdx + 3000,
+  );
 
   assert.ok(
-    blockAfterIncomplete.includes("tryMergeMilestone"),
-    "auto.ts should call tryMergeMilestone in the 'all milestones complete' path",
+    blockAfterIncomplete.includes("deps.resolver.mergeAndExit"),
+    "auto-loop.ts should call resolver.mergeAndExit in the 'all milestones complete' path",
   );
 
   // The merge should come before stopAuto in this block
-  const mergePos = blockAfterIncomplete.indexOf("tryMergeMilestone");
+  const mergePos = blockAfterIncomplete.indexOf("deps.resolver.mergeAndExit");
   const stopPos = blockAfterIncomplete.indexOf("stopAuto");
   assert.ok(
     mergePos < stopPos,
-    "tryMergeMilestone should be called before stopAuto in the 'all complete' path",
+    "resolver.mergeAndExit should be called before stopAuto in the 'all complete' path",
   );
 
-  // Verify tryMergeMilestone handles both worktree and branch isolation
-  const helperIdx = autoSrc.indexOf("function tryMergeMilestone");
-  assert.ok(helperIdx > -1, "tryMergeMilestone helper should exist");
-  const helperBlock = autoSrc.slice(helperIdx, helperIdx + 2000);
+  const helperIdx = resolverSrc.indexOf("mergeAndExit(milestoneId");
+  assert.ok(
+    helperIdx > -1,
+    "WorktreeResolver.mergeAndExit helper should exist",
+  );
+  const helperBlock = resolverSrc.slice(helperIdx, helperIdx + 2600);
   assert.ok(
-    helperBlock.includes("isInAutoWorktree"),
-    "tryMergeMilestone should check isInAutoWorktree for worktree mode",
+    helperBlock.includes('mode === "worktree"') ||
+      helperBlock.includes('mode: "worktree"'),
+    "WorktreeResolver.mergeAndExit should handle worktree mode",
   );
   assert.ok(
-    helperBlock.includes("getIsolationMode") || helperBlock.includes("isolationMode"),
-    "tryMergeMilestone should check isolation mode for branch mode",
+    helperBlock.includes('mode === "branch"') ||
+      helperBlock.includes('mode: "branch"'),
+    "WorktreeResolver.mergeAndExit should handle branch mode",
   );
 });
 
@@ -124,23 +151,38 @@ test("single milestone worktree is merged to main when all complete (#962)", ()
     run('git commit -m "feat(M001): add feature"', wt);
 
     // Simulate the fix: merge before stopping (what the "all complete" path now does)
-    const roadmapPath = join(tempDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    const roadmapPath = join(
+      tempDir,
+      ".gsd",
+      "milestones",
+      "M001",
+      "M001-ROADMAP.md",
+    );
     const roadmapContent = readFileSync(roadmapPath, "utf-8");
     const mergeResult = mergeMilestoneToMain(tempDir, "M001", roadmapContent);
 
     // Verify work is on main
-    assert.ok(existsSync(join(tempDir, "feature.ts")), "feature.ts should be on main after merge");
+    assert.ok(
+      existsSync(join(tempDir, "feature.ts")),
+      "feature.ts should be on main after merge",
+    );
     assert.equal(process.cwd(), tempDir, "cwd restored to project root");
     assert.ok(!isInAutoWorktree(tempDir), "no longer in auto-worktree");
     assert.equal(getAutoWorktreeOriginalBase(), null, "originalBase cleared");
 
     // Verify milestone branch was cleaned up
     const branches = run("git branch", tempDir);
-    assert.ok(!branches.includes("milestone/M001"), "milestone branch should be deleted");
+    assert.ok(
+      !branches.includes("milestone/M001"),
+      "milestone branch should be deleted",
+    );
 
     // Verify squash commit on main
     const log = run("git log --oneline -3", tempDir);
-    assert.ok(log.includes("M001"), "squash commit on main should reference M001");
+    assert.ok(
+      log.includes("M001"),
+      "squash commit on main should reference M001",
+    );
 
     assert.ok(mergeResult.commitMessage.length > 0, "commit message returned");
   } finally {
@@ -171,7 +213,10 @@ test("last milestone worktree is merged when it's the final one (#962)", () => {
     writeFileSync(join(wt1, "m001-work.ts"), "export const m001 = true;\n");
     run("git add .", wt1);
     run('git commit -m "feat(M001): m001 work"', wt1);
-    const roadmap1 = readFileSync(join(tempDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf-8");
+    const roadmap1 = readFileSync(
+      join(tempDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "utf-8",
+    );
     mergeMilestoneToMain(tempDir, "M001", roadmap1);
 
     // Now complete M002 (the LAST milestone — this is the #962 scenario)
@@ -179,7 +224,10 @@ test("last milestone worktree is merged when it's the final one (#962)", () => {
     writeFileSync(join(wt2, "m002-work.ts"), "export const m002 = true;\n");
     run("git add .", wt2);
     run('git commit -m "feat(M002): m002 work"', wt2);
-    const roadmap2 = readFileSync(join(tempDir, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "utf-8");
+    const roadmap2 = readFileSync(
+      join(tempDir, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
+      "utf-8",
+    );
     mergeMilestoneToMain(tempDir, "M002", roadmap2);
 
     // Both features should now be on main

package/src/resources/extensions/gsd/tests/auto-budget-alerts.test.ts

@@ -5,7 +5,7 @@ import {
   getBudgetAlertLevel,
   getBudgetEnforcementAction,
   getNewBudgetAlertLevel,
-} from "../auto-budget.js";
+} from "../auto.js";
 
 test("getBudgetAlertLevel returns the expected threshold bucket", () => {
   assert.equal(getBudgetAlertLevel(0.10), 0);

package/src/resources/extensions/gsd/tests/auto-lock-creation.test.ts

@@ -1,10 +1,25 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, mkdtempSync, writeFileSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { writeLock, readCrashLock, clearLock, isLockProcessAlive } from "../crash-recovery.ts";
+import { acquireSessionLock, releaseSessionLock } from "../session-lock.ts";
+
+const require = createRequire(import.meta.url);
+
+function hasProperLockfile(): boolean {
+  try {
+    require("proper-lockfile");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const properLockfileAvailable = hasProperLockfile();
 
 // ─── writeLock creates auto.lock in .gsd/ ────────────────────────────────
 
@@ -95,6 +110,28 @@ test("clearLock is safe when no lock file exists", () => {
   rmSync(dir, { recursive: true, force: true });
 });
 
+test("bootstrap cleanup releases session lock artifacts", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  try {
+    const result = acquireSessionLock(dir);
+    assert.equal(result.acquired, true, "session lock should be acquired");
+    assert.ok(existsSync(join(dir, ".gsd", "auto.lock")), "auto.lock should exist while lock is held");
+    if (properLockfileAvailable) {
+      assert.ok(existsSync(join(dir, ".gsd.lock")), ".gsd.lock should exist while lock is held");
+    }
+
+    releaseSessionLock(dir);
+    clearLock(dir);
+
+    assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "auto.lock should be removed by bootstrap cleanup");
+    assert.ok(!existsSync(join(dir, ".gsd.lock")), ".gsd.lock should be removed by bootstrap cleanup");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 // ─── isLockProcessAlive detects live vs dead PIDs ────────────────────────
 
 test("isLockProcessAlive returns false for dead PID", () => {