@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.72e3af2a

package/src/resources/extensions/gsd/tests/blocker-placeholder-logs.test.ts

@@ -0,0 +1,218 @@
+// gsd-pi — Blocker-placeholder recovery log coverage.
+//
+// writeBlockerPlaceholder (auto-recovery.ts:782) writes a placeholder artifact
+// so the pipeline can advance past a stuck unit, then marks the task/slice
+// complete in the DB and appends a workflow event so reconciliation can replay
+// the recovery. Each of those side-effects is individually best-effort and logs
+// a recovery warning on failure (auto-recovery.ts:837/840/843/844/853/854). No
+// test asserted any of them. We trigger each by breaking the specific sink
+// (drop the relevant DB table, or block the events-file append) and assert the
+// warning lands.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { writeBlockerPlaceholder } from "../auto-recovery.ts";
+import { writeReactiveExecuteBlocker } from "../auto-recovery.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+  _getAdapter,
+} from "../gsd-db.ts";
+import {
+  drainLogs,
+  setStderrLoggingEnabled,
+  _resetLogs,
+  type LogEntry,
+} from "../workflow-logger.ts";
+
+function makeBase(prefix = "gsd-blocker-logs-"): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  // Slice projection dirs so the placeholder path resolves.
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function captureLogs<T>(fn: () => T): { result: T; logs: LogEntry[] } {
+  const previous = setStderrLoggingEnabled(false);
+  _resetLogs();
+  try {
+    const result = fn();
+    return { result, logs: drainLogs() };
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previous);
+  }
+}
+
+function recoveryWarnings(logs: readonly LogEntry[]): LogEntry[] {
+  return logs.filter((e) => e.component === "recovery" && e.severity === "warn");
+}
+
+test("writeBlockerPlaceholder logs a recovery warning when updateTaskStatus throws (auto-recovery.ts:837)", () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Drop tasks so updateTaskStatus throws inside the execute-task DB block.
+    _getAdapter()!.exec("DROP TABLE tasks");
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("execute-task", "M001/S01/T01", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) => /updateTaskStatus failed during context exhaustion/u.test(w.message));
+    assert.ok(warn, "a recovery warning must be logged when updateTaskStatus throws");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("writeBlockerPlaceholder logs a recovery warning when updateSliceStatus throws (auto-recovery.ts:843)", () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Drop slices so updateSliceStatus throws inside the complete-slice DB block.
+    _getAdapter()!.exec("DROP TABLE slices");
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("complete-slice", "M001/S01", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) => /updateSliceStatus failed during context exhaustion/u.test(w.message));
+    assert.ok(warn, "a recovery warning must be logged when updateSliceStatus throws");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("writeBlockerPlaceholder logs a recovery warning when the plan-milestone insertSlice throws (auto-recovery.ts:853)", () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Drop slices so the S00-blocker insertSlice throws inside the
+    // plan-milestone placeholder branch.
+    _getAdapter()!.exec("DROP TABLE slices");
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("plan-milestone", "M001", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) =>
+      /insertSlice placeholder failed for plan-milestone recovery/u.test(w.message),
+    );
+    assert.ok(warn, "a recovery warning must be logged when the blocker slice insert throws");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("writeBlockerPlaceholder logs a recovery warning when the workflow-event append throws (auto-recovery.ts:840)", () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Block the workflow-events append by turning its target into a directory
+    // (appendFileSync on a directory throws EISDIR). The placeholder write still
+    // succeeds because it targets a different path under milestones/.
+    mkdirSync(join(base, ".gsd", "event-log.jsonl"), { recursive: true });
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("execute-task", "M001/S01/T01", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) => /appendEvent failed for task recovery/u.test(w.message));
+    assert.ok(warn, "a recovery warning must be logged when the recovery event append fails");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("writeBlockerPlaceholder logs a recovery warning when the complete-slice appendEvent throws (auto-recovery.ts:898)", () => {
+  const base = makeBase("gsd-blocker-logs-cs-");
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Slices table intact so updateSliceStatus (:897) succeeds; block the
+    // workflow-event append so the complete-slice appendEvent (:898) throws.
+    mkdirSync(join(base, ".gsd", "event-log.jsonl"), { recursive: true });
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("complete-slice", "M001/S01", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) => /appendEvent failed for slice recovery/u.test(w.message));
+    assert.ok(warn, "a recovery warning must be logged when the complete-slice appendEvent throws");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("writeBlockerPlaceholder logs a recovery warning when the plan-milestone appendEvent throws (auto-recovery.ts:908)", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-blocker-logs-pm-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Slices table intact so the S00-blocker insertSlice (:907) succeeds;
+    // block the workflow-event append so the plan-milestone appendEvent (:908) throws.
+    mkdirSync(join(base, ".gsd", "event-log.jsonl"), { recursive: true });
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("plan-milestone", "M001", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) => /appendEvent failed for plan-milestone recovery/u.test(w.message));
+    assert.ok(warn, "a recovery warning must be logged when the plan-milestone appendEvent throws");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ── writeReactiveExecuteBlocker append-event warnings (:755 / :768) ────────
+// These fire after the reactive batch recovery transaction commits, when the
+// per-task workflow-event append throws. We seed a real slice with two tasks,
+// plant the event-log target as a directory (appendFileSync → EISDIR), and call
+// writeReactiveExecuteBlocker; both the complete-task and skip-task appends fail.
+
+test("writeReactiveExecuteBlocker logs recovery warnings when the post-recovery event appends throw (auto-recovery.ts:755/:768)", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-blocker-logs-reactive-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "M", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "S", status: "active", risk: "low", depends: [], demo: "", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "T1", status: "active" });
+    insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "T2", status: "active" });
+    // T01 has a summary (→ complete recovery path → :755), T02 does not
+    // (→ skip recovery path → :768).
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"), "# T01\n", "utf-8");
+    // Block the workflow-event append (event-log.jsonl is the real ledger file).
+    mkdirSync(join(base, ".gsd", "event-log.jsonl"), { recursive: true });
+
+    const { logs } = captureLogs(() =>
+      writeReactiveExecuteBlocker("M001/S01/reactive+T01,T02", base, "batch exhausted"),
+    );
+
+    const warnings = recoveryWarnings(logs).map((w) => w.message);
+    assert.ok(
+      warnings.some((m) => /appendEvent failed for reactive complete recovery/u.test(m)),
+      "the complete-task append warning must be logged (:755)",
+    );
+    assert.ok(
+      warnings.some((m) => /appendEvent failed for reactive skip recovery/u.test(m)),
+      "the skip-task append warning must be logged (:768)",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/browser-automation-contract-fixture.ts

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+
+import {
+	getUatBrowserToolSupportError,
+	hasUatBrowserToolSurface,
+	type UatType,
+} from "../uat-policy.ts";
+
+export const BROWSER_AUTOMATION_CONTRACT_TOOLS = {
+	piProvider: ["read", "browser_navigate"],
+	externalMcpClient: ["read", "mcp__gsd-browser__browser_navigate"],
+	externalMcpWildcard: ["read", "mcp__gsd-browser__*"],
+	otherBrowserMcp: ["read", "mcp__browser-uat__*"],
+	workflowOnly: ["read", "mcp__gsd-workflow__*"],
+	withoutBrowser: ["read", "gsd_uat_exec"],
+} as const;
+
+export function assertBrowserAutomationContractAvailable(tools: readonly string[]): void {
+	assert.equal(hasUatBrowserToolSurface(tools), true, `${tools.join(", ")} should satisfy the Browser Automation Contract`);
+}
+
+export function assertBrowserAutomationContractMissing(tools: readonly string[] | undefined): void {
+	assert.equal(hasUatBrowserToolSurface(tools), false, `${tools?.join(", ") ?? "undefined"} should not satisfy the Browser Automation Contract`);
+}
+
+export function assertBrowserBackedUatCanDispatch(options: {
+	uatType: UatType;
+	activeTools: readonly string[] | undefined;
+	registeredTools?: readonly string[];
+}): void {
+	assert.equal(
+		getUatBrowserToolSupportError({
+			...options,
+			milestoneId: "M001",
+			sliceId: "S01",
+		}),
+		null,
+	);
+}

package/src/resources/extensions/gsd/tests/browser-contract.test.ts

@@ -0,0 +1,44 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  BROWSER_CONTRACT_TOOL_NAMES,
+  BROWSER_EVIDENCE_SIGNAL_TOOL_NAMES,
+  hasBrowserContractPrefix,
+  isBrowserContractToolName,
+} from "../../shared/browser-contract.ts";
+import { isUatBrowserToolName } from "../uat-policy.ts";
+import { BROWSER_REQUIREMENT_RE, BROWSER_RUNTIME_RE } from "../browser-evidence.ts";
+
+// Note: RUN_UAT_BROWSER_TOOL_NAMES and MANAGED_GSD_BROWSER_TOOL_NAMES are
+// reference-equal aliases of BROWSER_CONTRACT_TOOL_NAMES, and the managed
+// adapter's spec table is Record-keyed by BrowserContractToolName — both
+// derivations are pinned by the type system, not by runtime assertions here.
+describe("Browser Automation Contract parity", () => {
+  it("every contract name satisfies the UAT browser-tool predicate, bare and MCP-prefixed", () => {
+    for (const name of BROWSER_CONTRACT_TOOL_NAMES) {
+      assert.equal(isUatBrowserToolName(name), true, name);
+      assert.equal(isUatBrowserToolName(`mcp__gsd-browser__${name}`), true, `mcp__gsd-browser__${name}`);
+    }
+  });
+
+  it("contract names are canonical browser_* names with no duplicates", () => {
+    assert.equal(new Set(BROWSER_CONTRACT_TOOL_NAMES).size, BROWSER_CONTRACT_TOOL_NAMES.length);
+    for (const name of BROWSER_CONTRACT_TOOL_NAMES) {
+      assert.equal(hasBrowserContractPrefix(name), true, name);
+      assert.equal(isBrowserContractToolName(name), true, name);
+    }
+    assert.equal(isBrowserContractToolName("browser_not_a_real_tool"), false);
+    assert.equal(hasBrowserContractPrefix("gsd_uat_exec"), false);
+  });
+
+  it("evidence-signal names stay a subset of the contract and drive the detection regexes", () => {
+    for (const name of BROWSER_EVIDENCE_SIGNAL_TOOL_NAMES) {
+      assert.equal(isBrowserContractToolName(name), true, name);
+      // Identifier-shaped names keep the regex splice in browser-evidence.ts escape-free.
+      assert.match(name, /^browser_[a-z_]+$/);
+      assert.match(`Verified via ${name} call`, BROWSER_REQUIREMENT_RE);
+      assert.match(`Verified via ${name} call`, BROWSER_RUNTIME_RE);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/browser-daemon-auto-prep.test.ts

@@ -0,0 +1,144 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  prepareBrowserDaemonForUat,
+  shouldWarmBrowserDaemonForUat,
+} from "../browser-daemon-auto-prep.ts";
+import { commitBrowserEngineResolution } from "../../browser-tools/engine/selection.ts";
+import { resolveGsdBrowserCliAvailability } from "../../shared/gsd-browser-cli.ts";
+
+const GSD_BROWSER_ENGINE = { GSD_BROWSER_ENGINE: "gsd-browser" } as const;
+
+test("shouldWarmBrowserDaemonForUat skips artifact-driven UAT", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "artifact-driven",
+      sessionProvider: "claude-code",
+      projectRoot: "/tmp/project",
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat enables Claude Code browser UAT when gsd-browser is available", (t) => {
+  const availability = resolveGsdBrowserCliAvailability();
+  if (!availability.available) {
+    t.skip("bundled gsd-browser CLI unavailable");
+  }
+
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      sessionAuthMode: "externalCli",
+      projectRoot: "/tmp/project",
+      env: GSD_BROWSER_ENGINE,
+    }),
+    true,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat enables warm-up for Claude Code oauth/apiKey when engine is gsd-browser", (t) => {
+  const availability = resolveGsdBrowserCliAvailability();
+  if (!availability.available) {
+    t.skip("bundled gsd-browser CLI unavailable");
+  }
+
+  for (const sessionAuthMode of ["oauth", "apiKey"] as const) {
+    assert.equal(
+      shouldWarmBrowserDaemonForUat({
+        uatType: "browser-executable",
+        sessionProvider: "claude-code",
+        sessionAuthMode,
+        sessionBaseUrl: "https://api.anthropic.com",
+        projectRoot: "/tmp/project",
+        env: GSD_BROWSER_ENGINE,
+      }),
+      true,
+      `expected warm-up for sessionAuthMode=${sessionAuthMode}`,
+    );
+  }
+});
+
+test("shouldWarmBrowserDaemonForUat skips legacy Playwright engine for Claude Code", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      sessionAuthMode: "oauth",
+      projectRoot: "/tmp/project",
+      env: { GSD_BROWSER_ENGINE: "legacy" },
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat uses session-committed ambient engine for non-Claude providers", () => {
+  const projectRoot = "/tmp/ambient-engine-project";
+  commitBrowserEngineResolution(projectRoot, {
+    engine: "legacy",
+    source: "probe",
+    reason: "gsd-browser daemon connect failed (test); using legacy Playwright",
+  });
+
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "openai",
+      projectRoot,
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat skips when browser MCP is disabled", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      projectRoot: "/tmp/project",
+      env: { GSD_BROWSER_MCP_ENABLED: "0" },
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat skips when warm-up is disabled", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      projectRoot: "/tmp/project",
+      env: { GSD_BROWSER_WARMUP: "0" },
+    }),
+    false,
+  );
+});
+
+test("prepareBrowserDaemonForUat returns null when warm-up is not required", () => {
+  assert.equal(
+    prepareBrowserDaemonForUat({
+      uatType: "artifact-driven",
+      sessionProvider: "claude-code",
+      sessionAuthMode: "externalCli",
+      projectRoot: "/tmp/example-project",
+    }),
+    null,
+  );
+});
+
+test("prepareBrowserDaemonForUat returns actionable error when daemon start fails", () => {
+  const error = prepareBrowserDaemonForUat({
+    uatType: "browser-executable",
+    sessionProvider: "claude-code",
+    sessionAuthMode: "externalCli",
+    projectRoot: "/tmp/example-project",
+    env: {
+      ...GSD_BROWSER_ENGINE,
+      GSD_BROWSER_MCP_COMMAND: "/definitely/missing/gsd-browser",
+    },
+  });
+
+  assert.match(error ?? "", /gsd-browser daemon failed to start/i);
+});

package/src/resources/extensions/gsd/tests/canonical-milestone-root.test.ts

@@ -17,6 +17,7 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.ts";
+import { resolveCloseoutArtifactProjection } from "../artifact-projection.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-canon-test-${randomUUID()}`);
@@ -106,3 +107,22 @@ test("only returns the worktree for the requested milestone, not siblings", () =
     cleanup(base);
   }
 });
+
+test("resolveCloseoutArtifactProjection names project and canonical artifact roots", () => {
+  const base = makeTmpBase();
+  try {
+    const wtPath = makeLiveWorktree(base, "M001");
+    const projection = resolveCloseoutArtifactProjection({
+      milestoneId: "M001",
+      basePath: wtPath,
+      originalBasePath: base,
+    });
+
+    assert.equal(projection.projectRoot, base);
+    assert.equal(projection.canonicalMilestoneRoot, wtPath);
+    assert.equal(projection.summaryArtifactBasePath, wtPath);
+    assert.equal(projection.gateEvidenceBasePath, wtPath);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/checkout-branch-stash-guard.test.ts

@@ -5,7 +5,7 @@ import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSy
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { checkoutBranchWithStashGuard } from "../auto-worktree.ts";
+import { checkoutBranchWithStashGuard } from "../worktree-git-recovery.ts";
 
 function git(args: string[], cwd: string): string {
   return execFileSync("git", args, {
@@ -159,4 +159,69 @@ describe("checkoutBranchWithStashGuard", () => {
     const stashList = git(["stash", "list"], repo).trim();
     assert.equal(stashList, "");
   });
+
+  test("auto-resolves combined non-.gsd untracked collision and .gsd index conflict", (t) => {
+    // Regression for: gate checked nonGsdUnmerged.length === 0 but ignored
+    // .gsd/ index conflicts, so a failed pop with both an untracked non-.gsd/
+    // collision AND a .gsd/ tracked conflict would drop the stash while leaving
+    // .gsd/ index unmerged entries unresolved.
+    const repo = createRepo(t);
+    // Add .gsd/DECISIONS.md to base so both branches diverge from it
+    writeFileSync(join(repo, ".gsd", "DECISIONS.md"), "base\n");
+    git(["add", ".gsd/DECISIONS.md"], repo);
+    git(["commit", "-m", "add decisions"], repo);
+
+    git(["checkout", "-b", "milestone/M003"], repo);
+    // Branch has its own version of DECISIONS.md (non-JSONL .gsd/ file)
+    writeFileSync(join(repo, ".gsd", "DECISIONS.md"), "target-version\n");
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"dark\"}\n");
+    git(["add", ".gsd/DECISIONS.md", ".harness/settings.json"], repo);
+    git(["commit", "-m", "branch state"], repo);
+    git(["checkout", "main"], repo);
+
+    // On main: tracked .gsd/ change (creates unmerged index entry on pop) +
+    // untracked harness file (triggers "already exists, no checkout").
+    writeFileSync(join(repo, ".gsd", "DECISIONS.md"), "local-version\n");
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"light\"}\n");
+
+    checkoutBranchWithStashGuard(repo, "milestone/M003", "test-combined-gsd-conflict");
+
+    const branch = git(["branch", "--show-current"], repo).trim();
+    assert.equal(branch, "milestone/M003");
+    const decisions = readFileSync(join(repo, ".gsd", "DECISIONS.md"), "utf8");
+    assert.equal(decisions, "target-version\n");
+    assert.doesNotMatch(decisions, /<<<<<<<|=======|>>>>>>>/);
+    const status = git(["status", "--porcelain"], repo).trim();
+    assert.equal(status, "");
+    const stashList = git(["stash", "list"], repo).trim();
+    assert.equal(stashList, "");
+  });
+
+  test("auto-resolves non-.gsd untracked restore collisions (e.g. harness config outside .gsd/)", (t) => {
+    const repo = createRepo(t);
+    // Target branch has a harness config file committed; source (main) has it untracked.
+    // Use a path not affected by global gitignore rules (unlike .claude/settings.local.json).
+    git(["checkout", "-b", "milestone/M001"], repo);
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"dark\"}\n");
+    git(["add", ".harness/settings.json"], repo);
+    git(["commit", "-m", "add harness settings"], repo);
+    git(["checkout", "main"], repo);
+
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"light\"}\n");
+
+    checkoutBranchWithStashGuard(repo, "milestone/M001", "test-non-gsd-untracked-collision");
+
+    const branch = git(["branch", "--show-current"], repo).trim();
+    assert.equal(branch, "milestone/M001");
+    const wtContent = readFileSync(join(repo, ".harness", "settings.json"), "utf8");
+    assert.equal(wtContent, "{\"theme\":\"dark\"}\n");
+    const status = git(["status", "--porcelain"], repo).trim();
+    assert.equal(status, "");
+    const stashList = git(["stash", "list"], repo).trim();
+    assert.equal(stashList, "");
+  });
 });

package/src/resources/extensions/gsd/tests/clear-stale-autostart.test.ts

@@ -73,4 +73,48 @@ describe("clear stale pending auto-start (#3667)", () => {
       "pending auto-start gate must clear stale map entries for completed discussions",
     );
   });
+
+  test("guided-flow recovers a finished-but-unconsumed discussion instead of dead-ending", () => {
+    // CONTEXT exists + no live turn means the discussion completed but the
+    // agent_end handoff never consumed the entry (e.g. an external-engine
+    // post-hoc gate re-arm wiped the depth verification after the save).
+    // Without recovery, every /gsd prints "Discussion already in progress"
+    // forever: the stale heuristic requires CONTEXT to be absent and
+    // discussPlanComplete requires a ROADMAP that planning never produced.
+    const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
+    assert.ok(
+      source.includes("milestoneHasContext && !isAgentTurnInFlight(ctx)"),
+      "pending-entry guard must have a recovery branch for CONTEXT-present, no-turn-in-flight entries",
+    );
+    assert.ok(
+      source.includes("extractDepthVerificationMilestoneId(pendingGateId) === entry.milestoneId"),
+      "recovery must only clear a pending gate belonging to the entry's own milestone",
+    );
+    assert.ok(
+      source.includes("if (checkAutoStartAfterDiscuss(basePath)) return;"),
+      "recovery must re-run the discuss→auto handoff after clearing the stale gate",
+    );
+  });
+
+  test("guided-flow does not treat a live discuss turn as a stale pending entry", () => {
+    const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
+    assert.ok(
+      source.includes("!isAgentTurnInFlight(ctx)"),
+      "stale-entry deletion must be gated on no agent turn being in flight — a dispatched " +
+      "discuss turn can think for over 30s before writing its first artifact, and deleting " +
+      "its entry re-dispatches the workflow (duplicate interview + duplicate completion message)",
+    );
+    assert.ok(
+      source.includes('const milestoneHasDraft = !!resolveMilestoneFile(basePath, entry.milestoneId, "CONTEXT-DRAFT");'),
+      "stale-entry check must treat an existing CONTEXT-DRAFT as proof of an in-progress interview",
+    );
+    assert.ok(
+      source.includes("!milestoneHasDraft"),
+      "stale-entry deletion must require the CONTEXT-DRAFT to be absent",
+    );
+    assert.ok(
+      source.includes("ctx.hasPendingMessages"),
+      "in-flight detection must also cover dispatched-but-not-yet-started queued messages",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/codebase-generator.test.ts

@@ -696,3 +696,29 @@ test("ensureCodebaseMapFresh: does not rewrite expired metadata when fingerprint
     cleanup(base);
   }
 });
+
+test("ensureCodebaseMapFresh: uses TTL cache before enumerating files", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    const initial = ensureCodebaseMapFresh(base, undefined, { ttlMs: 60_000 });
+    assert.equal(initial.status, "generated");
+
+    const emptyBin = join(base, "empty-bin");
+    mkdirSync(emptyBin);
+    const originalPath = process.env.PATH;
+    try {
+      process.env.PATH = emptyBin;
+
+      const cached = ensureCodebaseMapFresh(base, undefined, { ttlMs: 60_000 });
+      assert.equal(cached.status, "generated");
+      assert.equal(cached.fingerprint, initial.fingerprint);
+      assert.equal(cached.fileCount, 1);
+    } finally {
+      if (originalPath === undefined) delete process.env.PATH;
+      else process.env.PATH = originalPath;
+    }
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-context.test.ts

@@ -101,6 +101,32 @@ test("analyzeSessionContext buckets injections, tool results, and loaded skills"
   assert.equal(result.subagentSpawns, 1);
 });
 
+test("analyzeSessionContext bounds large assistant tool-call arguments", () => {
+  const result = analyzeSessionContext(sessionEntries({
+    role: "assistant",
+    content: [
+      {
+        type: "toolCall",
+        id: "tc-save",
+        name: "gsd_summary_save",
+        arguments: {
+          path: ".gsd/milestones/M001/M001-SUMMARY.md",
+          artifact_type: "SUMMARY",
+          content: "x".repeat(20_000),
+        },
+      },
+    ],
+    timestamp: TS,
+  }), PROVIDER);
+
+  const assistant = result.conversationSections.find((section) => section.label === "Assistant responses");
+  assert.ok(assistant);
+  assert.ok(
+    assistant.tokens < 200,
+    `assistant tool-call arguments should be redacted before token counting, got ${assistant.tokens} tokens`,
+  );
+});
+
 test("formatContextReport lists skills and subagents", () => {
   const report = buildContextBreakdown({
     modelLabel: "claude-code/claude-sonnet-4-6",