gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.42ef05fbe

package/src/resources/extensions/gsd/tests/planning-depth-setter.test.ts

@@ -0,0 +1,172 @@
+// GSD-2 — Deep planning mode setPlanningDepth helper.
+// Verifies the helper correctly creates and updates .gsd/PREFERENCES.md while
+// preserving existing frontmatter keys and body content.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { parse as parseYaml } from "yaml";
+
+import { setPlanningDepth } from "../planning-depth.ts";
+
+function makeBase(): string {
+  const base = join(tmpdir(), `gsd-planning-depth-${randomUUID()}`);
+  mkdirSync(base, { recursive: true });
+  return base;
+}
+
+function readFrontmatter(path: string): { frontmatter: Record<string, unknown>; body: string } {
+  const content = readFileSync(path, "utf-8");
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  assert.ok(match, "PREFERENCES.md must have frontmatter delimiters");
+  const parsed = parseYaml(match[1]);
+  assert.ok(parsed && typeof parsed === "object", "frontmatter must parse to an object");
+  return { frontmatter: parsed as Record<string, unknown>, body: match[2] };
+}
+
+test("Deep mode: setPlanningDepth creates PREFERENCES.md when missing", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  setPlanningDepth(base, "deep");
+
+  const path = join(base, ".gsd", "PREFERENCES.md");
+  assert.ok(existsSync(path), "PREFERENCES.md must be created");
+  const { frontmatter } = readFrontmatter(path);
+  assert.strictEqual(frontmatter.planning_depth, "deep");
+  assert.strictEqual(frontmatter.workflow_prefs_captured, true);
+  assert.strictEqual(frontmatter.commit_policy, "per-task");
+  assert.strictEqual(frontmatter.branch_model, "single");
+  assert.strictEqual(frontmatter.uat_dispatch, true);
+  assert.deepStrictEqual(frontmatter.models, { executor_class: "balanced" });
+  assert.ok(existsSync(join(base, ".gsd", "runtime", "research-decision.json")));
+  const researchDecision = JSON.parse(
+    readFileSync(join(base, ".gsd", "runtime", "research-decision.json"), "utf-8"),
+  );
+  assert.strictEqual(researchDecision.decision, "skip");
+  assert.strictEqual(researchDecision.source, "workflow-preferences");
+  assert.strictEqual(researchDecision.reason, "deterministic-default");
+});
+
+test("Deep mode: setPlanningDepth updates existing planning_depth", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\nplanning_depth: light\n---\n");
+  setPlanningDepth(base, "deep");
+
+  const { frontmatter } = readFrontmatter(join(base, ".gsd", "PREFERENCES.md"));
+  assert.strictEqual(frontmatter.planning_depth, "deep");
+});
+
+test("Deep mode: setPlanningDepth preserves other frontmatter keys", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\nversion: 1\nmode: solo\nuat_dispatch: true\n---\n",
+  );
+  setPlanningDepth(base, "deep");
+
+  const { frontmatter } = readFrontmatter(join(base, ".gsd", "PREFERENCES.md"));
+  assert.strictEqual(frontmatter.planning_depth, "deep");
+  assert.strictEqual(frontmatter.version, 1);
+  assert.strictEqual(frontmatter.mode, "solo");
+  assert.strictEqual(frontmatter.uat_dispatch, true);
+});
+
+test("Deep mode: setPlanningDepth preserves explicit workflow preference values", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "planning_depth: deep",
+      "commit_policy: manual",
+      "branch_model: per-milestone-worktree",
+      "uat_dispatch: false",
+      "models:",
+      "  executor_class: heavy",
+      "---",
+      "",
+    ].join("\n"),
+  );
+  setPlanningDepth(base, "deep");
+
+  const { frontmatter } = readFrontmatter(join(base, ".gsd", "PREFERENCES.md"));
+  assert.strictEqual(frontmatter.workflow_prefs_captured, true);
+  assert.strictEqual(frontmatter.commit_policy, "manual");
+  assert.strictEqual(frontmatter.branch_model, "per-milestone-worktree");
+  assert.strictEqual(frontmatter.uat_dispatch, false);
+  assert.deepStrictEqual(frontmatter.models, { executor_class: "heavy" });
+});
+
+test("Deep mode: setPlanningDepth preserves body content", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  const original = "---\nversion: 1\n---\n\n# User notes\n\nKeep this body intact.\n";
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), original);
+  setPlanningDepth(base, "deep");
+
+  const content = readFileSync(join(base, ".gsd", "PREFERENCES.md"), "utf-8");
+  assert.ok(content.includes("# User notes"), "body header must survive");
+  assert.ok(content.includes("Keep this body intact."), "body text must survive");
+});
+
+test("Deep mode: setPlanningDepth handles file without frontmatter delimiters", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  // Some agents write preferences without frontmatter delimiters (#2036 case)
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "version: 1\nmode: solo\n");
+  setPlanningDepth(base, "deep");
+
+  const content = readFileSync(join(base, ".gsd", "PREFERENCES.md"), "utf-8");
+  assert.ok(content.startsWith("---\n"), "result must have frontmatter delimiters");
+  const { frontmatter, body } = readFrontmatter(join(base, ".gsd", "PREFERENCES.md"));
+  assert.strictEqual(frontmatter.planning_depth, "deep");
+  // The legacy non-frontmatter content is preserved as body
+  assert.ok(body.includes("version: 1"), "legacy content preserved as body");
+});
+
+test("Deep mode: setPlanningDepth can flip back to light", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  setPlanningDepth(base, "deep");
+  setPlanningDepth(base, "light");
+
+  const { frontmatter } = readFrontmatter(join(base, ".gsd", "PREFERENCES.md"));
+  assert.strictEqual(frontmatter.planning_depth, "light");
+});
+
+test("Deep mode: setPlanningDepth preserves explicit user research decision", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "runtime", "research-decision.json"),
+    JSON.stringify({ decision: "research", source: "research-decision", decided_at: "2026-04-27T00:00:00Z" }),
+  );
+
+  setPlanningDepth(base, "deep");
+
+  const researchDecision = JSON.parse(
+    readFileSync(join(base, ".gsd", "runtime", "research-decision.json"), "utf-8"),
+  );
+  assert.strictEqual(researchDecision.decision, "research");
+  assert.strictEqual(researchDecision.source, "research-decision");
+});

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

@@ -16,6 +16,7 @@ const EXPOSED_OUTSIDE_WIZARD = new Set<string>([
   "version",          // auto-managed by writePreferencesFile
   "modelOverrides",   // advanced routing — edit PREFERENCES.md directly (not in KNOWN_PREFERENCE_KEYS)
   "context_mode",     // advanced sandbox config (gsd_exec + compaction) — enabled by default; edit PREFERENCES.md directly to tune timeouts/caps. Wizard coverage tracked separately.
+  "planning_depth",   // exposed through /gsd new-project --deep and /gsd new-milestone --deep
 ]);
 
 test("every KNOWN_PREFERENCE_KEYS entry is reachable from the wizard source", () => {

package/src/resources/extensions/gsd/tests/project-root-cwd-crash.test.ts

@@ -3,7 +3,7 @@
  *
  * When the working directory is deleted (e.g. worktree teardown), process.cwd()
  * throws ENOENT. The fix wraps process.cwd() in a try/catch and falls back to
- * process.env.HOME.
+ * os.homedir().
  *
  * Also verifies #3589 — nativeBranchExists validation for prefs.main_branch
  * in auto-worktree.ts to prevent merge failures with stale preferences.
@@ -29,9 +29,9 @@ describe('projectRoot cwd crash guard (#3598)', () => {
       'process.cwd() should be inside a try block');
   });
 
-  test('catch block falls back to process.env.HOME', () => {
-    assert.match(contextSource, /catch[\s\S]*?process\.env\.HOME/,
-      'catch block should fall back to process.env.HOME');
+  test('catch block falls back to homedir()', () => {
+    assert.match(contextSource, /catch[\s\S]*?homedir\(\)/,
+      'catch block should fall back to homedir()');
   });
 
   test('projectRoot function is exported', () => {

package/src/resources/extensions/gsd/tests/prompt-budget-enforcement.test.ts

@@ -521,7 +521,7 @@ describe("prompt-budget: modelRegistry + sessionContextWindow wiring", () => {
     );
     assert.match(
       autoPromptsSrc,
-      /formatExecutorConstraints\(sessionContextWindow,\s*modelRegistry\)/,
+      /formatExecutorConstraints\(sessionContextWindow,\s*modelRegistry(?:,\s*sessionProvider)?\)/,
       "renderSlicePrompt must forward both to formatExecutorConstraints",
     );
   });
@@ -612,4 +612,4 @@ describe("prompt-budget: modelRegistry + sessionContextWindow wiring", () => {
       `dispatchDirectPhase must forward the pair at both prompt-builder call sites (≥2), got ${passes}`,
     );
   });
-});
+});

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -76,6 +76,88 @@ test("guided milestone discussion scopes depth verification to the milestone id"
   assert.doesNotMatch(prompt, /depth_verification_confirm" — this enables the write-gate downstream/i, "legacy global depth gate wording should be gone");
 });
 
+test("guided requirements prompt requires milestone-qualified provisional owners", () => {
+  const prompt = readPrompt("guided-discuss-requirements");
+  assert.match(prompt, /M###\/none yet/, "unsliced requirements should retain milestone ownership");
+  assert.match(prompt, /never bare `none yet`/, "prompt should forbid bare provisional ownership");
+  assert.doesNotMatch(prompt, /primary owning slice \(or `none yet`\)/i);
+});
+
+test("guided requirements prompt saves requirement records before final summary write", () => {
+  const prompt = readPrompt("guided-discuss-requirements");
+  const output = prompt.slice(prompt.indexOf("## Output"));
+  const requirementSaveIndex = output.indexOf("gsd_requirement_save");
+  const summarySaveIndex = output.indexOf("gsd_summary_save");
+
+  assert.ok(requirementSaveIndex >= 0, "output instructions should call gsd_requirement_save");
+  assert.ok(summarySaveIndex >= 0, "output instructions should call gsd_summary_save");
+  assert.ok(
+    requirementSaveIndex < summarySaveIndex,
+    "DB-backed requirement records should be saved before writing REQUIREMENTS.md",
+  );
+});
+
+test("guided requirements prompt uses supported summary artifact types", () => {
+  const prompt = readPrompt("guided-discuss-requirements");
+  assert.match(prompt, /artifact_type:\s*"REQUIREMENTS-DRAFT"/);
+  assert.match(prompt, /artifact_type:\s*"REQUIREMENTS"(?!-)/);
+  assert.match(prompt, /omit `milestone_id`/);
+  assert.match(prompt, /Do NOT use `artifact_type: "CONTEXT"` and do NOT pass `milestone_id: "REQUIREMENTS"`/);
+  assert.match(prompt, /depth_verification_requirements_confirm/);
+  assert.doesNotMatch(prompt, /call `gsd_summary_save` with `artifact_type: "CONTEXT"`/);
+});
+
+test("workflow preferences prompt writes defaults without interactive questions", () => {
+  const prompt = readPrompt("guided-workflow-preferences");
+  assert.match(prompt, /default-writing/i);
+  assert.match(prompt, /Do NOT call `ask_user_questions`/);
+  assert.match(prompt, /commit_policy:\s*per-task/);
+  assert.match(prompt, /branch_model:\s*single/);
+  assert.match(prompt, /research:\s*skip/);
+  assert.match(prompt, /"decision": "skip"/);
+  assert.doesNotMatch(prompt, /research:\s*research/);
+  assert.doesNotMatch(prompt, /Ask all three questions/i);
+  assert.doesNotMatch(prompt, /Ask all four questions/i);
+  assert.doesNotMatch(prompt, /Ask all five questions/i);
+});
+
+test("project research prompt dispatches scout agents allowed by planning-dispatch", () => {
+  const prompt = readPrompt("guided-research-project");
+  assert.match(prompt, /agent:\s*"scout"/);
+  assert.match(prompt, /Do not use `agent: "researcher"`/);
+  assert.match(prompt, /runtime clears the dispatch marker/i);
+  assert.doesNotMatch(prompt, /Delete `\.gsd\/runtime\/research-project-inflight`/);
+});
+
+test("slice planning prompts name scout for external research dispatch", () => {
+  const planSlice = readPrompt("plan-slice");
+  const refineSlice = readPrompt("refine-slice");
+  assert.match(planSlice, /dispatch the \*\*scout\*\* agent/);
+  assert.match(refineSlice, /dispatch the \*\*scout\*\* agent/);
+  assert.doesNotMatch(planSlice, /dispatch the \*\*researcher\*\* agent/);
+  assert.doesNotMatch(refineSlice, /dispatch the \*\*researcher\*\* agent/);
+});
+
+test("guided project prompt writes root PROJECT artifact, not PROJECT milestone", () => {
+  const prompt = readPrompt("guided-discuss-project");
+  assert.match(prompt, /artifact_type:\s*"PROJECT"/);
+  assert.match(prompt, /omit `milestone_id`/);
+  assert.match(prompt, /Do NOT use `artifact_type: "CONTEXT"` and do NOT pass `milestone_id: "PROJECT"`/);
+  assert.match(prompt, /single freeform question in plain text, not structured/i);
+  assert.doesNotMatch(prompt, /project_initial_shape/);
+  assert.match(prompt, /depth_verification_project_confirm/);
+});
+
+test("guided research decision prompt keeps exact chat confirmation strings", () => {
+  const prompt = readPrompt("guided-research-decision");
+  assert.match(prompt, /^Research decision: research$/m);
+  assert.match(prompt, /^Research decision recorded\.$/m);
+  assert.match(prompt, /Skip \(Recommended\)/);
+  assert.match(prompt, /"source": "research-decision"/);
+  assert.match(prompt, /Do not change the required confirmation strings/i);
+  assert.doesNotMatch(prompt, /note the inference in the chat confirmation line/i);
+});
+
 test("queue prompt requires waiting for user response between rounds", () => {
   const prompt = readPrompt("queue");
   assert.match(prompt, /Never fabricate or simulate user input during this discussion/i);

package/src/resources/extensions/gsd/tests/ready-phrase-no-files-4573.test.ts

@@ -285,6 +285,67 @@ describe("#4573 maybeHandleEmptyIntentTurn", () => {
     }
   });
 
+  test("multi-line message with mid-message question → treated as user-handoff (regression: discuss flow)", () => {
+    // Regression for the deep-mode discuss-project case where the LLM asked
+    // a clarifying question mid-message and ended on a closing remark. The
+    // previous heuristic only checked the LAST line for `?` and missed the
+    // earlier question, causing the empty-turn nudge to auto-reply on
+    // behalf of the user.
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const text = [
+        "Let me make sure I understand what you're testing here.",
+        "",
+        "We need something to plan. A few lightweight options:",
+        "- A simple CLI tool",
+        "- A static API",
+        "",
+        "What should the fictional project be?",
+        "",
+        "If you have a preference, say the word and I'll pick one.",
+      ].join("\n");
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg(text)] },
+        false,
+      );
+      assert.equal(handled, false, "any line ending in ? must defer to the user");
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test('"Let me make sure" meta phrase → not flagged as commit intent (regression)', () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      // No question mark anywhere — so the only thing keeping this from
+      // firing the nudge should be the refined commit-intent regex
+      // (dropping "make" from the verb list).
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("Let me make sure I have this right.")] },
+        false,
+      );
+      assert.equal(handled, false, "meta acknowledgments are not action announcements");
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
   test("commit-intent phrase WITHOUT tool call → nudge fires", () => {
     const base = mkBase();
     try {

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -162,3 +162,159 @@ test("register-hooks clears depth gate when remote (Telegram/Slack/Discord) answ
     "remote confirmation must unlock the matching milestone context write",
   );
 });
+
+test("register-hooks returns hard blocker when depth question is cancelled", async (t) => {
+  const dir = makeTempDir("cancelled");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState();
+
+  t.after(() => {
+    resetWriteGateState();
+    process.chdir(originalCwd);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const questionId = "depth_verification_M003_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Did I capture this correctly?",
+      options: [
+        { label: "Yes, you got it (Recommended)" },
+        { label: "Needs adjustment" },
+      ],
+    },
+  ];
+
+  for (const handler of handlers.get("tool_call") ?? []) {
+    await handler({ toolName: "ask_user_questions", input: { questions } });
+  }
+  assert.equal(getPendingGate(), questionId);
+
+  let patch: any;
+  for (const handler of handlers.get("tool_result") ?? []) {
+    const result = await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: { cancelled: true, response: null },
+    });
+    if (result) patch = result;
+  }
+
+  assert.equal(getPendingGate(), questionId, "cancelled question must leave gate pending");
+  assert.match(
+    patch?.content?.[0]?.text ?? "",
+    /HARD BLOCK: approval gate "depth_verification_M003_confirm" is still pending/,
+  );
+  assert.match(
+    patch?.content?.[0]?.text ?? "",
+    /Do not infer approval from earlier or prior messages/,
+  );
+});
+
+test("register-hooks gates MCP ask_user_questions cancellation before requirement saves", async (t) => {
+  const dir = makeTempDir("mcp-cancelled");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState();
+
+  t.after(() => {
+    resetWriteGateState();
+    process.chdir(originalCwd);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const questionId = "depth_verification_requirements_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Are these the right requirements at the right scope?",
+      options: [
+        { label: "Yes, ship it (Recommended)" },
+        { label: "Not quite — let me adjust" },
+      ],
+    },
+  ];
+
+  const askBlocks: any[] = [];
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({
+      toolName: "mcp__gsd-workflow__ask_user_questions",
+      input: { questions },
+    });
+    if (result) askBlocks.push(result);
+  }
+
+  assert.equal(getPendingGate(), questionId, "MCP ask_user_questions should set the pending gate");
+  assert.equal(
+    askBlocks.some((result) => result?.block === true),
+    false,
+    "the gate-setting MCP ask_user_questions call itself should be allowed",
+  );
+
+  let hardBlock: any;
+  for (const handler of handlers.get("tool_result") ?? []) {
+    const result = await handler({
+      toolName: "mcp__gsd-workflow__ask_user_questions",
+      input: { questions },
+      details: { cancelled: true, response: null },
+    });
+    if (result) hardBlock = result;
+  }
+
+  assert.equal(getPendingGate(), questionId, "cancelled MCP question must leave gate pending");
+  assert.match(
+    hardBlock?.content?.[0]?.text ?? "",
+    /approval gate "depth_verification_requirements_confirm" is still pending/,
+  );
+
+  let toolSearchBlock: any;
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({
+      toolName: "ToolSearch",
+      input: { query: "select:mcp__gsd-workflow__gsd_requirement_save", max_results: 2 },
+    });
+    if (result?.block) toolSearchBlock = result;
+  }
+  assert.equal(toolSearchBlock?.block, true, "ToolSearch must not bury a pending approval question");
+
+  let requirementBlock: any;
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({
+      toolName: "mcp__gsd-workflow__gsd_requirement_save",
+      input: {
+        class: "functional",
+        description: "User can add tasks to the todo list",
+        why: "Primary product value",
+        source: "primary-user-loop",
+      },
+    });
+    if (result?.block) requirementBlock = result;
+  }
+
+  assert.equal(requirementBlock?.block, true, "requirement save must be blocked while gate is pending");
+  assert.match(requirementBlock?.reason ?? "", /has not been confirmed/);
+});

package/src/resources/extensions/gsd/tests/stash-pop-gsd-conflict.test.ts

@@ -21,6 +21,7 @@ import { _clearGsdRootCache } from "../paths.ts";
 // Isolate from user's global preferences (which may have git.main_branch set)
 let originalHome: string | undefined;
 let fakeHome: string;
+const testCwd = process.cwd();
 
 test.before(() => {
   originalHome = process.env.HOME;
@@ -37,6 +38,11 @@ test.after(() => {
   rmSync(fakeHome, { recursive: true, force: true });
 });
 
+function cleanupTempRepo(repo: string): void {
+  try { process.chdir(testCwd); } catch { /* best-effort */ }
+  try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* cleanup best-effort */ }
+}
+
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -106,7 +112,7 @@ test("#2766: stash pop conflict on .gsd/ files is auto-resolved", () => {
     try { stashList = run("git stash list", repo); } catch { /* empty stash */ }
     assert.strictEqual(stashList, "", "stash is empty after .gsd/ conflict auto-resolution");
   } finally {
-    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* cleanup best-effort */ }
+    cleanupTempRepo(repo);
   }
 });
 
@@ -141,6 +147,6 @@ test("#2766: stash pop conflict on non-.gsd files preserves stash for manual res
       "merge succeeds even with non-.gsd stash pop conflict",
     );
   } finally {
-    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* cleanup best-effort */ }
+    cleanupTempRepo(repo);
   }
 });

package/src/resources/extensions/gsd/tests/stash-queued-context-files.test.ts

@@ -35,6 +35,7 @@ import { _clearGsdRootCache } from "../paths.ts";
 // Isolate from user's global preferences (which may have git.main_branch set)
 let originalHome: string | undefined;
 let fakeHome: string;
+const testCwd = process.cwd();
 
 test.before(() => {
   originalHome = process.env.HOME;
@@ -51,6 +52,13 @@ test.after(() => {
   rmSync(fakeHome, { recursive: true, force: true });
 });
 
+function cleanupTempPaths(...paths: string[]): void {
+  try { process.chdir(testCwd); } catch { /* best-effort */ }
+  for (const p of paths) {
+    rmSync(p, { recursive: true, force: true });
+  }
+}
+
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, {
     cwd,
@@ -271,7 +279,7 @@ test("#2505: mergeMilestoneToMain preserves queued CONTEXT files (not swept into
       }
     }
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    cleanupTempPaths(repo);
   }
 });
 
@@ -308,8 +316,7 @@ test("#2505: pre-merge stash handles symlinked .gsd without traversing it", () =
     assert.equal(readFileSync(join(repo, "README.md"), "utf-8").replace(/\r\n/g, "\n"), "# test\n\nDirty change.\n");
     assert.equal(readFileSync(join(repo, "local-note.txt"), "utf-8"), "local scratch\n");
   } finally {
-    rmSync(repo, { recursive: true, force: true });
-    rmSync(stateDir, { recursive: true, force: true });
+    cleanupTempPaths(repo, stateDir);
   }
 });
 
@@ -375,7 +382,7 @@ test("#2505: back-to-back merges preserve queued CONTEXT files", () => {
       "M013 context content preserved after back-to-back merges",
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    cleanupTempPaths(repo);
   }
 });
 
@@ -430,7 +437,6 @@ test("#4573: gitignored .gsd symlink does not break pre-merge stash", () => {
       ".gsd symlink remains in place",
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
-    rmSync(stateDir, { recursive: true, force: true });
+    cleanupTempPaths(repo, stateDir);
   }
 });

package/src/resources/extensions/gsd/tests/token-counter.test.ts

@@ -20,6 +20,10 @@ describe("token-counter: getCharsPerToken", () => {
     assert.equal(getCharsPerToken("anthropic"), 3.5);
   });
 
+  it("returns 3.5 for claude-code", () => {
+    assert.equal(getCharsPerToken("claude-code"), 3.5);
+  });
+
   it("returns 4.0 for openai", () => {
     assert.equal(getCharsPerToken("openai"), 4.0);
   });
@@ -51,6 +55,11 @@ describe("token-counter: estimateTokensForProvider", () => {
     assert.equal(tokens, Math.ceil(1000 / 3.5));
   });
 
+  it("estimates tokens for claude-code using 3.5 chars/token ratio", () => {
+    const tokens = estimateTokensForProvider(sampleText, "claude-code");
+    assert.equal(tokens, Math.ceil(1000 / 3.5));
+  });
+
   it("estimates tokens for openai using 4.0 chars/token ratio", () => {
     const tokens = estimateTokensForProvider(sampleText, "openai");
     assert.equal(tokens, Math.ceil(1000 / 4.0));