gsd-pi 2.50.0 → 2.51.0-dev.7d435fe

package/src/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -7,17 +7,28 @@ const require = createRequire(import.meta.url);
 const ROOT = new URL("../../../../../", import.meta.url);
 
 export function resolve(specifier, context, nextResolve) {
-  // 1. Direct redirects to dist/ for specific packages
+  // 1. Redirect all workspace package bare imports to source.
+  //    CI portability runs don't build any packages/ dist artifacts, so every
+  //    @gsd/* specifier (including transitive ones pulled in by pi-coding-agent
+  //    source itself) must resolve to the TypeScript source entrypoint.
   if (specifier === "../../packages/pi-coding-agent/src/index.js") {
-    specifier = new URL("packages/pi-coding-agent/dist/index.js", ROOT).href;
+    specifier = new URL("packages/pi-coding-agent/src/index.ts", ROOT).href;
+  } else if (specifier === "@gsd/pi-coding-agent") {
+    specifier = new URL("packages/pi-coding-agent/src/index.ts", ROOT).href;
   } else if (specifier === "@gsd/pi-ai/oauth") {
-    specifier = new URL("packages/pi-ai/dist/utils/oauth/index.js", ROOT).href;
+    specifier = new URL("packages/pi-ai/src/utils/oauth/index.ts", ROOT).href;
   } else if (specifier === "@gsd/pi-ai") {
-    specifier = new URL("packages/pi-ai/dist/index.js", ROOT).href;
+    specifier = new URL("packages/pi-ai/src/index.ts", ROOT).href;
   } else if (specifier === "@gsd/pi-agent-core") {
-    specifier = new URL("packages/pi-agent-core/dist/index.js", ROOT).href;
+    specifier = new URL("packages/pi-agent-core/src/index.ts", ROOT).href;
   } else if (specifier === "@gsd/pi-tui") {
-    specifier = new URL("packages/pi-tui/dist/index.js", ROOT).href;
+    specifier = new URL("packages/pi-tui/src/index.ts", ROOT).href;
+  } else if (specifier === "@gsd/native") {
+    specifier = new URL("packages/native/src/index.ts", ROOT).href;
+  } else if (specifier.startsWith("@gsd/native/")) {
+    // Sub-path imports like @gsd/native/fd, @gsd/native/text, etc.
+    const subpath = specifier.slice("@gsd/native/".length);
+    specifier = new URL(`packages/native/src/${subpath}/index.ts`, ROOT).href;
   }
   // 2. Redirect packages/*/dist/ → packages/*/src/ with .js→.ts for strip-types
   //    Also handles local imports — skip rewrite for dist/ paths that are real compiled artifacts.
@@ -54,9 +65,15 @@ export function resolve(specifier, context, nextResolve) {
 }
 
 export function load(url, context, nextLoad) {
-  // Node's --experimental-strip-types handles .ts but not .tsx (which may contain JSX).
-  // Use TypeScript to transpile .tsx → JS with react-jsx transform, then serve as module.
-  if (url.endsWith('.tsx')) {
+  // Node's --experimental-strip-types handles plain .ts but not .tsx and not
+  // all TypeScript syntax used by workspace packages (parameter properties,
+  // decorators, etc.). Transpile all workspace package source files and .tsx
+  // files through TypeScript's transpileModule to avoid those crashes.
+  const shouldTranspileWithTypeScript =
+    url.endsWith('.tsx') ||
+    (url.endsWith('.ts') && url.includes('/packages/') && url.includes('/src/'));
+
+  if (shouldTranspileWithTypeScript) {
     const ts = require('typescript');
     const source = readFileSync(fileURLToPath(url), 'utf-8');
     const { outputText } = ts.transpileModule(source, {
@@ -66,6 +83,8 @@ export function load(url, context, nextLoad) {
         module: ts.ModuleKind.ESNext,
         target: ts.ScriptTarget.ESNext,
         esModuleInterop: true,
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
       },
     });
     return { format: 'module', source: outputText, shortCircuit: true };

package/src/resources/extensions/gsd/tests/doctor-git.test.ts

@@ -64,11 +64,11 @@ _None_
   return dir;
 }
 
-/** Write a .gsd/preferences.md with the given git isolation mode. */
+/** Write a .gsd/PREFERENCES.md with the given git isolation mode. */
 function writePreferencesFile(dir: string, isolation: "none" | "worktree" | "branch"): void {
   const gsdDir = join(dir, ".gsd");
   mkdirSync(gsdDir, { recursive: true });
-  writeFileSync(join(gsdDir, "preferences.md"), `---\ngit:\n  isolation: "${isolation}"\n---\n`);
+  writeFileSync(join(gsdDir, "PREFERENCES.md"), `---\ngit:\n  isolation: "${isolation}"\n---\n`);
 }
 
 /** Create a repo with an in-progress milestone. */
@@ -302,7 +302,7 @@ describe('doctor-git', async () => {
     // ─── Test 7: none-mode skips orphaned worktree check ───────────────
     // NOTE: loadEffectiveGSDPreferences() resolves PROJECT_PREFERENCES_PATH
     // at module load time from process.cwd(). We write the prefs file to
-    // the test runner's cwd .gsd/preferences.md and clean up afterwards.
+    // the test runner's cwd .gsd/PREFERENCES.md and clean up afterwards.
     if (process.platform !== "win32") {
     test('none-mode skips orphaned worktree', async () => {
       const dir = createRepoWithCompletedMilestone();
@@ -409,7 +409,7 @@ describe('doctor-git', async () => {
       cleanups.push(dir);
 
       run("git branch trunk", dir);
-      writeFileSync(join(dir, ".gsd", "preferences.md"), `---\ngit:\n  isolation: "worktree"\n  main_branch: "trunk"\n---\n`);
+      writeFileSync(join(dir, ".gsd", "PREFERENCES.md"), `---\ngit:\n  isolation: "worktree"\n  main_branch: "trunk"\n---\n`);
 
       const metaPath = join(dir, ".gsd", "milestones", "M001", "M001-META.json");
       writeFileSync(metaPath, JSON.stringify({ integrationBranch: "feat/does-not-exist" }, null, 2));

package/src/resources/extensions/gsd/tests/doctor-proactive.test.ts

@@ -297,7 +297,7 @@ describe('doctor-proactive', async () => {
       cleanups.push(dir);
 
       run("git branch trunk", dir);
-      writeFileSync(join(dir, ".gsd", "preferences.md"), `---\ngit:\n  main_branch: "trunk"\n---\n`);
+      writeFileSync(join(dir, ".gsd", "PREFERENCES.md"), `---\ngit:\n  main_branch: "trunk"\n---\n`);
       const metaPath = join(dir, ".gsd", "milestones", "M001", "M001-META.json");
       writeFileSync(metaPath, JSON.stringify({ integrationBranch: "feature/missing" }, null, 2));
 

package/src/resources/extensions/gsd/tests/doctor-providers.test.ts

@@ -419,7 +419,7 @@ test("runProviderChecks uses provider-qualified anthropic-vertex model IDs", ()
   const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-prefix-repo-")));
   mkdirSync(join(repo, ".gsd"), { recursive: true });
   writeFileSync(
-    join(repo, ".gsd", "preferences.md"),
+    join(repo, ".gsd", "PREFERENCES.md"),
     [
       "---",
       "models:",
@@ -454,7 +454,7 @@ test("runProviderChecks uses object provider field for anthropic-vertex models",
   const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-provider-repo-")));
   mkdirSync(join(repo, ".gsd"), { recursive: true });
   writeFileSync(
-    join(repo, ".gsd", "preferences.md"),
+    join(repo, ".gsd", "PREFERENCES.md"),
     [
       "---",
       "models:",

package/src/resources/extensions/gsd/tests/double-merge-guard.test.ts

@@ -0,0 +1,97 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AutoSession } from "../auto/session.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+describe("double mergeAndExit guard (#2645)", () => {
+  test("phases.ts sets milestoneMergedInPhases after mergeAndExit in milestone-complete path", () => {
+    // Source audit: the "complete" phase path must set the guard flag
+    // after calling mergeAndExit so that stopAuto skips the second merge.
+    const phasesSrc = readFileSync(
+      join(__dirname, "..", "auto", "phases.ts"),
+      "utf-8",
+    );
+
+    // Find the "complete" phase block
+    const completeIdx = phasesSrc.indexOf('state.phase === "complete"');
+    assert.ok(completeIdx > 0, "phases.ts should have a 'complete' phase check");
+
+    const afterComplete = phasesSrc.slice(completeIdx, completeIdx + 600);
+    const mergeIdx = afterComplete.indexOf("deps.resolver.mergeAndExit");
+    const flagIdx = afterComplete.indexOf("s.milestoneMergedInPhases = true");
+
+    assert.ok(mergeIdx > 0, "complete path should call mergeAndExit");
+    assert.ok(flagIdx > 0, "complete path should set milestoneMergedInPhases");
+    assert.ok(
+      flagIdx > mergeIdx,
+      "milestoneMergedInPhases must be set AFTER mergeAndExit (not before)",
+    );
+  });
+
+  test("phases.ts sets milestoneMergedInPhases after mergeAndExit in all-milestones-complete path", () => {
+    const phasesSrc = readFileSync(
+      join(__dirname, "..", "auto", "phases.ts"),
+      "utf-8",
+    );
+
+    // The "all milestones complete" block checks incomplete.length === 0
+    const allCompleteIdx = phasesSrc.indexOf("incomplete.length === 0");
+    assert.ok(allCompleteIdx > 0, "phases.ts should have an all-milestones-complete check");
+
+    const afterAllComplete = phasesSrc.slice(allCompleteIdx, allCompleteIdx + 600);
+    const mergeIdx = afterAllComplete.indexOf("deps.resolver.mergeAndExit");
+    const flagIdx = afterAllComplete.indexOf("s.milestoneMergedInPhases = true");
+
+    assert.ok(mergeIdx > 0, "all-complete path should call mergeAndExit");
+    assert.ok(flagIdx > 0, "all-complete path should set milestoneMergedInPhases");
+    assert.ok(
+      flagIdx > mergeIdx,
+      "milestoneMergedInPhases must be set AFTER mergeAndExit (not before)",
+    );
+  });
+
+  test("stopAuto checks milestoneMergedInPhases before calling mergeAndExit", () => {
+    const autoSrc = readFileSync(
+      join(__dirname, "..", "auto.ts"),
+      "utf-8",
+    );
+
+    // The Step 4 worktree exit block must check the guard flag
+    const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
+    assert.ok(step4Idx > 0, "auto.ts should have Step 4 worktree exit");
+
+    const step4Block = autoSrc.slice(step4Idx, step4Idx + 600);
+    assert.ok(
+      step4Block.includes("milestoneMergedInPhases"),
+      "stopAuto Step 4 must check milestoneMergedInPhases before merging",
+    );
+    assert.ok(
+      step4Block.includes("!s.milestoneMergedInPhases"),
+      "stopAuto should skip merge when milestoneMergedInPhases is true",
+    );
+  });
+
+  test("AutoSession.milestoneMergedInPhases defaults to false", () => {
+    const session = new AutoSession();
+    assert.equal(
+      session.milestoneMergedInPhases,
+      false,
+      "new session should have milestoneMergedInPhases = false",
+    );
+  });
+
+  test("AutoSession.reset() clears milestoneMergedInPhases", () => {
+    const session = new AutoSession();
+    session.milestoneMergedInPhases = true;
+    session.reset();
+    assert.equal(
+      session.milestoneMergedInPhases,
+      false,
+      "reset() should clear milestoneMergedInPhases back to false",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/empty-db-reconciliation.test.ts

@@ -0,0 +1,79 @@
+/**
+ * Regression test for #2631: deriveState disk→DB reconciliation must
+ * run even when the milestones table starts empty.
+ *
+ * When getAllMilestones() returns [] (e.g. after a failed initial migration),
+ * the reconciliation code inside deriveStateFromDb was unreachable because
+ * deriveState only called it when dbMilestones.length > 0. The fix moves
+ * disk→DB sync into deriveState itself, before the length check.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { deriveState, invalidateStateCache } from "../state.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  getAllMilestones,
+} from "../gsd-db.ts";
+
+test("deriveState populates empty DB from disk milestones (#2631)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-empty-db-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    // Create a milestone on disk with a CONTEXT file (not a ghost)
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+      "# M001: Test Milestone\n\nSome context about this milestone.",
+    );
+
+    // Open DB — milestones table is empty (simulating failed migration)
+    openDatabase(":memory:");
+    const before = getAllMilestones();
+    assert.equal(before.length, 0, "DB should start with 0 milestones");
+
+    // deriveState should reconcile disk → DB
+    invalidateStateCache();
+    const state = await deriveState(base);
+
+    // After deriveState, the DB should now have the disk milestone
+    const after = getAllMilestones();
+    assert.ok(after.length > 0, "DB should have milestones after reconciliation");
+    assert.equal(after[0]!.id, "M001", "reconciled milestone should be M001");
+
+    // State should reflect the milestone (not "No milestones found")
+    assert.ok(
+      state.activeMilestone !== null,
+      "activeMilestone should not be null after reconciliation",
+    );
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("deriveState does NOT insert ghost milestones into DB (#2631 guard)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-empty-db-"));
+  // Create a ghost milestone directory (empty — no CONTEXT, no ROADMAP)
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    openDatabase(":memory:");
+    invalidateStateCache();
+    await deriveState(base);
+
+    const milestones = getAllMilestones();
+    assert.equal(milestones.length, 0, "ghost milestone should NOT be inserted");
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/git-service.test.ts

@@ -1142,7 +1142,7 @@ describe('git-service', async () => {
     mkdirSync(join(repo, ".gsd", "runtime"), { recursive: true });
     mkdirSync(join(repo, ".gsd", "activity"), { recursive: true });
     writeFileSync(join(repo, ".gsd", "milestones", "M001", "ROADMAP.md"), "# Roadmap");
-    writeFileSync(join(repo, ".gsd", "preferences.md"), "---\nversion: 1\n---");
+    writeFileSync(join(repo, ".gsd", "PREFERENCES.md"), "---\nversion: 1\n---");
     writeFileSync(join(repo, ".gsd", "STATE.md"), "# State");
     writeFileSync(join(repo, ".gsd", "runtime", "units.json"), "{}");
     writeFileSync(join(repo, ".gsd", "activity", "log.jsonl"), "{}");

package/src/resources/extensions/gsd/tests/gsd-db.test.ts

@@ -64,7 +64,7 @@ describe('gsd-db', () => {
     // Check schema_version table
     const adapter = _getAdapter()!;
     const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
-    assert.deepStrictEqual(version?.['version'], 12, 'schema version should be 12');
+    assert.deepStrictEqual(version?.['version'], 14, 'schema version should be 14');
 
     // Check tables exist by querying them
     const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();

package/src/resources/extensions/gsd/tests/idle-recovery.test.ts

@@ -294,3 +294,66 @@ test('verifyExpectedArtifact: hook types always return true', () => {
   }
 });
 
+
+test('writeBlockerPlaceholder: updates DB task status for execute-task (#2531)', async () => {
+  const base = createFixtureBase();
+  try {
+    const { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getTask, isDbAvailable } =
+      await import("../gsd-db.ts");
+
+    const dbPath = join(base, ".gsd", "gsd.db");
+    // Create the tasks directory (required for artifact path resolution)
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+
+    openDatabase(dbPath);
+    try {
+      insertMilestone({ id: "M001", title: "Test", status: "active" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active" });
+      insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Task", status: "pending" });
+
+      // Before fix: writeBlockerPlaceholder wrote the file but left DB as "pending"
+      writeBlockerPlaceholder("execute-task", "M001/S01/T01", base, "idle recovery exhausted");
+
+      const task = getTask("M001", "S01", "T01");
+      assert.equal(task?.status, "complete",
+        "writeBlockerPlaceholder must update DB task status to 'complete' so verifyExpectedArtifact passes");
+
+      // Verify the full chain works: verifyExpectedArtifact should return true
+      const verified = verifyExpectedArtifact("execute-task", "M001/S01/T01", base);
+      assert.equal(verified, true,
+        "verifyExpectedArtifact should pass after writeBlockerPlaceholder updates DB status");
+    } finally {
+      if (isDbAvailable()) closeDatabase();
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('writeBlockerPlaceholder: does NOT update DB for non-execute-task types', async () => {
+  const base = createFixtureBase();
+  try {
+    const { openDatabase, closeDatabase, insertMilestone, insertSlice, getSlice, isDbAvailable } =
+      await import("../gsd-db.ts");
+
+    const dbPath = join(base, ".gsd", "gsd.db");
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+
+    openDatabase(dbPath);
+    try {
+      insertMilestone({ id: "M001", title: "Test", status: "active" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active" });
+
+      // research-slice is NOT execute-task — DB should NOT be updated
+      writeBlockerPlaceholder("research-slice", "M001/S01", base, "idle recovery exhausted");
+
+      const slice = getSlice("M001", "S01");
+      assert.equal(slice?.status, "active",
+        "writeBlockerPlaceholder should not change DB status for non-execute-task types");
+    } finally {
+      if (isDbAvailable()) closeDatabase();
+    }
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/idle-watchdog-stall-override.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Regression tests for #2527: idle watchdog stalled-tool detection.
+ *
+ * Bug 1: When a tool is stalled longer than idle_timeout, the watchdog
+ * notifies but falls through to detectWorkingTreeActivity(), which
+ * resets lastProgressAt if files were modified earlier. Recovery is
+ * never called — the session burns tokens indefinitely.
+ *
+ * Bug 2: After async recoverTimedOutUnit(), pauseAuto/stopAuto may set
+ * s.currentUnit = null, but the next line accesses .startedAt — crash.
+ *
+ * These tests verify the auto-timers.ts source contains the structural
+ * fixes: the stalledToolDetected flag, clearInFlightTools() call, the
+ * filesystem-check guard, and the null guard after recovery.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+
+const TIMERS_SRC = readFileSync(
+  join(import.meta.dirname, "..", "auto-timers.ts"),
+  "utf-8",
+);
+
+// ═══ Bug 1: stalledToolDetected flag prevents filesystem-activity override ═══
+
+describe("#2527 Bug 1: stalled tool should not be overridden by filesystem activity", () => {
+  test("auto-timers.ts imports clearInFlightTools", () => {
+    assert.ok(
+      TIMERS_SRC.includes("clearInFlightTools"),
+      "clearInFlightTools must be imported from auto-tool-tracking",
+    );
+  });
+
+  test("auto-timers.ts declares stalledToolDetected flag", () => {
+    assert.ok(
+      TIMERS_SRC.includes("stalledToolDetected"),
+      "stalledToolDetected flag must exist in idle watchdog",
+    );
+  });
+
+  test("stalled tool sets flag to true", () => {
+    // The flag must be set before the filesystem check
+    const flagSet = TIMERS_SRC.indexOf("stalledToolDetected = true");
+    assert.ok(flagSet > -1, "stalledToolDetected must be set to true when tool is stalled");
+
+    const notify = TIMERS_SRC.indexOf("Stalled tool detected:");
+    assert.ok(flagSet < notify, "flag must be set before the stall notification");
+  });
+
+  test("stalled tool calls clearInFlightTools", () => {
+    // clearInFlightTools() must be called when tool is stalled, so subsequent
+    // watchdog ticks don't re-detect the same stale entries
+    const clearCall = TIMERS_SRC.indexOf("clearInFlightTools()");
+    assert.ok(clearCall > -1, "clearInFlightTools() must be called when tool is stalled");
+
+    const flagSet = TIMERS_SRC.indexOf("stalledToolDetected = true");
+    assert.ok(
+      Math.abs(clearCall - flagSet) < 200,
+      "clearInFlightTools() should be near stalledToolDetected = true",
+    );
+  });
+
+  test("filesystem-activity check is guarded by stalledToolDetected", () => {
+    // The detectWorkingTreeActivity check must be skipped when stalledToolDetected is true
+    assert.ok(
+      TIMERS_SRC.includes("!stalledToolDetected && detectWorkingTreeActivity"),
+      "detectWorkingTreeActivity must be guarded by !stalledToolDetected",
+    );
+  });
+
+  test("control flow: stalled tool → skip filesystem check → reach recovery", () => {
+    // Verify the structural ordering: flag declaration → stall block → guarded fs check → recovery
+    const flagDecl = TIMERS_SRC.indexOf("let stalledToolDetected = false");
+    const stallBlock = TIMERS_SRC.indexOf("stalledToolDetected = true");
+    const fsGuard = TIMERS_SRC.indexOf("!stalledToolDetected && detectWorkingTreeActivity");
+    const recovery = TIMERS_SRC.indexOf("recoverTimedOutUnit(ctx, pi, unitType, unitId, \"idle\"");
+
+    assert.ok(flagDecl > -1, "flag declaration must exist");
+    assert.ok(flagDecl < stallBlock, "flag declared before stall block");
+    assert.ok(stallBlock < fsGuard, "stall block before filesystem guard");
+    assert.ok(fsGuard < recovery, "filesystem guard before recovery call");
+  });
+});
+
+// ═══ Bug 2: null guard after async recoverTimedOutUnit ═══════════════════════
+
+describe("#2527 Bug 2: null guard after async recovery prevents crash", () => {
+  test("idle watchdog has null guard after recoverTimedOutUnit", () => {
+    // Find the idle recovery call
+    const idleRecovery = TIMERS_SRC.indexOf(
+      'recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle"',
+    );
+    assert.ok(idleRecovery > -1, "idle recovery call must exist");
+
+    // The null guard must appear between the recovery call and the next
+    // writeUnitRuntimeRecord that accesses s.currentUnit.startedAt
+    const afterRecovery = TIMERS_SRC.slice(idleRecovery, idleRecovery + 400);
+    assert.ok(
+      afterRecovery.includes("if (!s.currentUnit) return"),
+      "null guard for s.currentUnit must exist after idle recoverTimedOutUnit",
+    );
+  });
+
+  test("null guard is between recovery and writeUnitRuntimeRecord", () => {
+    const idleRecovery = TIMERS_SRC.indexOf(
+      'recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle"',
+    );
+    const afterRecovery = TIMERS_SRC.slice(idleRecovery);
+
+    const recoveredReturn = afterRecovery.indexOf('if (recovery === "recovered") return');
+    const nullGuard = afterRecovery.indexOf("if (!s.currentUnit) return");
+    const writeRecord = afterRecovery.indexOf("writeUnitRuntimeRecord(s.basePath");
+
+    assert.ok(recoveredReturn > -1, "recovered return must exist");
+    assert.ok(nullGuard > -1, "null guard must exist");
+    assert.ok(writeRecord > -1, "writeUnitRuntimeRecord must exist after recovery");
+    assert.ok(
+      recoveredReturn < nullGuard && nullGuard < writeRecord,
+      "order must be: recovered-return → null-guard → writeUnitRuntimeRecord",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/init-wizard.test.ts

@@ -123,7 +123,7 @@ test("init-wizard: v2 .gsd/ preferences detected", (t) => {
   const dir = makeTempDir("prefs-detect");
   try {
     mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
-    writeFileSync(join(dir, ".gsd", "preferences.md"), "---\nversion: 1\nmode: solo\n---\n", "utf-8");
+    writeFileSync(join(dir, ".gsd", "PREFERENCES.md"), "---\nversion: 1\nmode: solo\n---\n", "utf-8");
 
     const detection = detectProjectState(dir);
     assert.ok(detection.v2);

package/src/resources/extensions/gsd/tests/interactive-tool-idle-exemption.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Tests for #2676: idle watchdog must exempt user-interactive tools
+ * (ask_user_questions, secure_env_collect) from stall detection.
+ */
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  markToolStart,
+  markToolEnd,
+  hasInteractiveToolInFlight,
+  getInFlightToolCount,
+  getOldestInFlightToolStart,
+  getOldestInFlightToolAgeMs,
+  clearInFlightTools,
+} from "../auto-tool-tracking.ts";
+
+// These tests call the tracking module directly (bypassing the auto.ts
+// wrapper which guards on s.active) so we always pass isActive=true.
+
+beforeEach(() => {
+  clearInFlightTools();
+});
+
+describe("hasInteractiveToolInFlight", () => {
+  test("returns false when no tools are in-flight", () => {
+    assert.equal(hasInteractiveToolInFlight(), false);
+  });
+
+  test("returns false when only non-interactive tools are in-flight", () => {
+    markToolStart("call-1", true, "bash");
+    markToolStart("call-2", true, "read");
+    assert.equal(hasInteractiveToolInFlight(), false);
+  });
+
+  test("returns true when ask_user_questions is in-flight", () => {
+    markToolStart("call-1", true, "bash");
+    markToolStart("call-2", true, "ask_user_questions");
+    assert.equal(hasInteractiveToolInFlight(), true);
+  });
+
+  test("returns true when secure_env_collect is in-flight", () => {
+    markToolStart("call-1", true, "secure_env_collect");
+    assert.equal(hasInteractiveToolInFlight(), true);
+  });
+
+  test("returns false after interactive tool completes", () => {
+    markToolStart("call-1", true, "ask_user_questions");
+    assert.equal(hasInteractiveToolInFlight(), true);
+    markToolEnd("call-1");
+    assert.equal(hasInteractiveToolInFlight(), false);
+  });
+
+  test("returns true if one of multiple tools is interactive", () => {
+    markToolStart("call-1", true, "bash");
+    markToolStart("call-2", true, "edit");
+    markToolStart("call-3", true, "ask_user_questions");
+    markToolStart("call-4", true, "write");
+    assert.equal(hasInteractiveToolInFlight(), true);
+  });
+});
+
+describe("toolName tracking in markToolStart", () => {
+  test("defaults toolName to 'unknown' when not provided", () => {
+    markToolStart("call-1", true);
+    // unknown tool should not be treated as interactive
+    assert.equal(hasInteractiveToolInFlight(), false);
+    assert.equal(getInFlightToolCount(), 1);
+  });
+
+  test("no-ops when isActive is false", () => {
+    markToolStart("call-1", false, "ask_user_questions");
+    assert.equal(getInFlightToolCount(), 0);
+    assert.equal(hasInteractiveToolInFlight(), false);
+  });
+});
+
+describe("existing tracking behavior preserved with toolName", () => {
+  test("getInFlightToolCount tracks correctly", () => {
+    assert.equal(getInFlightToolCount(), 0);
+    markToolStart("call-1", true, "bash");
+    assert.equal(getInFlightToolCount(), 1);
+    markToolStart("call-2", true, "ask_user_questions");
+    assert.equal(getInFlightToolCount(), 2);
+    markToolEnd("call-1");
+    assert.equal(getInFlightToolCount(), 1);
+    markToolEnd("call-2");
+    assert.equal(getInFlightToolCount(), 0);
+  });
+
+  test("getOldestInFlightToolStart returns correct timestamp", () => {
+    assert.equal(getOldestInFlightToolStart(), undefined);
+    const before = Date.now();
+    markToolStart("call-1", true, "bash");
+    const after = Date.now();
+    const oldest = getOldestInFlightToolStart();
+    assert.ok(oldest !== undefined);
+    assert.ok(oldest! >= before && oldest! <= after);
+  });
+
+  test("getOldestInFlightToolAgeMs returns 0 with no tools", () => {
+    assert.equal(getOldestInFlightToolAgeMs(), 0);
+  });
+
+  test("getOldestInFlightToolAgeMs returns positive value with tools", () => {
+    markToolStart("call-1", true, "read");
+    const age = getOldestInFlightToolAgeMs();
+    assert.ok(age >= 0, `age should be non-negative, got ${age}`);
+  });
+
+  test("clearInFlightTools resets all state", () => {
+    markToolStart("call-1", true, "ask_user_questions");
+    markToolStart("call-2", true, "bash");
+    assert.equal(getInFlightToolCount(), 2);
+    assert.equal(hasInteractiveToolInFlight(), true);
+    clearInFlightTools();
+    assert.equal(getInFlightToolCount(), 0);
+    assert.equal(hasInteractiveToolInFlight(), false);
+  });
+});