@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.844675c9

package/src/resources/extensions/gsd/tests/orchestrator-legacy-parity.test.ts

@@ -0,0 +1,127 @@
+// Project/App: gsd-pi
+// File Purpose: #442 Phase 3.14 — characterization battery proving the
+// Orchestrator's dispatch DECISION matches what the legacy
+// runPreDispatch/runDispatch path would produce, across representative
+// resolveDispatch outcomes. This is the safety net that licenses deleting the
+// dead legacy `else` branch in auto/loop.ts (loop never reaches it because
+// ensureOrchestrationModule runs unconditionally before autoLoop, so
+// s.orchestration is always set).
+//
+// Both paths delegate to the same resolveDispatch rule engine; the only thing
+// that differs is how each TRANSLATES a resolveDispatch action into a loop
+// outcome. We pin that translation equivalence here:
+//   resolveDispatch action  | legacy runDispatch -> loop | orchestrator decision
+//   ------------------------|----------------------------|----------------------
+//   dispatch                | IterationData(unit)        | { unitType, unitId } (advanced)
+//   stop                    | break -> stopped/blocked   | { kind: "blocked", action } | stopped
+//   skip                    | continue -> skipped        | { kind: "skipped" }
+//   (no rule matches)       | stop/no-unit               | null -> stopped(no remaining)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { decideOrchestratorDispatch } from "../auto/orchestrator.ts";
+import { resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
+import { RuleRegistry, setRegistry, resetRegistry } from "../rule-registry.ts";
+import type { UnifiedRule } from "../rule-types.ts";
+import type { GSDState } from "../types.ts";
+
+function makeState(): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "Milestone" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "executing",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Execute task",
+    registry: [],
+    requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+}
+
+const fakeCtx = {
+  model: { provider: "anthropic", baseUrl: "https://api.anthropic.com", contextWindow: 200_000 },
+  modelRegistry: { getAll: () => [], getProviderAuthMode: (_p: string) => "apiKey" as const },
+} as never;
+const fakePi = { getActiveTools: () => ["read_file", "write_file"] } as never;
+const BASE = "/tmp/orchestrator-legacy-parity";
+
+function installRule(where: UnifiedRule["where"]): void {
+  setRegistry(new RuleRegistry([{
+    name: "parity-rule",
+    when: "dispatch",
+    evaluation: "first-match",
+    where,
+    then: (r: unknown) => r,
+  }]));
+}
+
+function directCtx(state: GSDState): DispatchContext {
+  return {
+    basePath: BASE,
+    mid: state.activeMilestone!.id,
+    midTitle: state.activeMilestone!.title,
+    state,
+    prefs: undefined,
+    structuredQuestionsAvailable: "true",
+    sessionContextWindow: 200_000,
+    sessionProvider: "anthropic",
+    modelRegistry: (fakeCtx as { modelRegistry: unknown }).modelRegistry as never,
+  };
+}
+
+test("#442 characterization: dispatch action → orchestrator picks the same unit the legacy path would", async (t) => {
+  t.after(() => resetRegistry());
+  const state = makeState();
+  installRule(async () => ({ action: "dispatch", unitType: "execute-task", unitId: "T07", prompt: "p" }));
+
+  const legacy = await resolveDispatch(directCtx(state));
+  const decision = await decideOrchestratorDispatch(fakeCtx, fakePi, BASE, undefined, { stateSnapshot: state });
+
+  assert.equal((legacy as { action: string }).action, "dispatch");
+  assert.ok(decision && "unitType" in decision, "orchestrator must produce a unit decision");
+  assert.equal(decision.unitType, (legacy as { unitType: string }).unitType);
+  assert.equal(decision.unitId, (legacy as { unitId: string }).unitId);
+});
+
+test("#442 characterization: stop action → orchestrator blocks with stop, matching legacy break", async (t) => {
+  t.after(() => resetRegistry());
+  const state = makeState();
+  installRule(async () => ({ action: "stop", reason: "milestone blocked" }));
+
+  const legacy = await resolveDispatch(directCtx(state));
+  const decision = await decideOrchestratorDispatch(fakeCtx, fakePi, BASE, undefined, { stateSnapshot: state });
+
+  assert.equal((legacy as { action: string }).action, "stop");
+  assert.ok(decision && "kind" in decision && decision.kind === "blocked", "stop must translate to a blocked decision");
+  assert.equal((decision as { action: string }).action, "stop");
+});
+
+test("#442 characterization: skip action → orchestrator skips, matching legacy continue", async (t) => {
+  t.after(() => resetRegistry());
+  const state = makeState();
+  installRule(async () => ({ action: "skip", reason: "nothing to do this pass" }));
+
+  const legacy = await resolveDispatch(directCtx(state));
+  const decision = await decideOrchestratorDispatch(fakeCtx, fakePi, BASE, undefined, { stateSnapshot: state });
+
+  assert.equal((legacy as { action: string }).action, "skip");
+  assert.ok(decision && "kind" in decision && decision.kind === "skipped", "skip must translate to a skipped decision");
+});
+
+test("#442 characterization: no matching rule → orchestrator yields no unit (legacy 'no remaining units')", async (t) => {
+  t.after(() => resetRegistry());
+  const state = makeState();
+  installRule(async () => null);
+
+  const legacy = await resolveDispatch(directCtx(state));
+  const decision = await decideOrchestratorDispatch(fakeCtx, fakePi, BASE, undefined, { stateSnapshot: state });
+
+  // resolveDispatch with no match yields no dispatch action; the orchestrator
+  // surfaces that as a null decision, which advance() turns into a "stopped:
+  // no remaining units" outcome — the same terminal the legacy path reaches.
+  assert.ok(legacy == null || (legacy as { action?: string }).action !== "dispatch");
+  assert.ok(decision == null || !("unitType" in decision), "no-match must not yield a unit dispatch");
+});

package/src/resources/extensions/gsd/tests/parse-project-milestone-bridge.test.ts

@@ -0,0 +1,77 @@
+// gsd-pi / parseProject MILESTONE_LINE_RE bridging regression
+//
+// Guards against a silent data-integrity bug: MILESTONE_LINE_RE used `\s+`
+// around its separator, and `\s` matches newlines. A milestone line lacking a
+// valid internal separator could therefore "bridge" onto the NEXT bullet's
+// `- `, consuming it as the separator and swallowing the following well-formed
+// milestone. The separator gaps are now horizontal-whitespace-only so a line
+// can never span a newline.
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { parseProject } from "../schemas/parsers.ts";
+
+function milestoneSection(...lines: string[]): string {
+  return ["# Project", "", "## Milestone Sequence", "", ...lines, ""].join("\n");
+}
+
+describe("parseProject milestone bridging", () => {
+  test("a malformed milestone line does not swallow the following well-formed one", () => {
+    // M001 uses an invalid " : " separator; M002 is canonical. Before the fix
+    // this returned a SINGLE match (M001 with oneLiner "[ ] M002: Baz — qux"),
+    // dropping M002 entirely.
+    const content = milestoneSection(
+      "- [ ] M001: Foo : bar",
+      "- [ ] M002: Baz — qux",
+    );
+
+    const { milestones } = parseProject(content);
+
+    // M002 must survive intact — it must NOT be consumed as M001's one-liner.
+    const m002 = milestones.find(m => m.id === "M002");
+    assert.ok(m002, "M002 must be registered, not swallowed by the malformed M001 line");
+    assert.equal(m002!.title, "Baz", "M002 title parsed cleanly");
+    assert.equal(m002!.oneLiner, "qux", "M002 one-liner parsed cleanly");
+
+    // No milestone may have bridged the M002 bullet into its own one-liner.
+    assert.ok(
+      !milestones.some(m => m.oneLiner.includes("M002")),
+      "no milestone may bridge across the newline and consume the M002 bullet",
+    );
+
+    // M001 has no valid separator, so it is skipped — consistent with the
+    // empty-parse hard-fail in execute-summary-save-empty-project.test.ts.
+    // The fixture therefore yields exactly the one well-formed milestone.
+    assert.deepEqual(milestones.map(m => m.id), ["M002"], "only the well-formed milestone parses");
+  });
+
+  test("two well-formed milestones on adjacent lines both parse", () => {
+    const content = milestoneSection(
+      "- [x] M001: Foo — bar",
+      "- [ ] M002: Baz — qux",
+    );
+
+    const { milestones } = parseProject(content);
+    assert.deepEqual(
+      milestones.map(m => ({ id: m.id, title: m.title, oneLiner: m.oneLiner, done: m.done })),
+      [
+        { id: "M001", title: "Foo", oneLiner: "bar", done: true },
+        { id: "M002", title: "Baz", oneLiner: "qux", done: false },
+      ],
+      "adjacent canonical milestone lines are parsed independently",
+    );
+  });
+
+  test("a trailing malformed line cannot bridge onto a following bullet of any kind", () => {
+    // The last milestone is malformed and is followed by a non-milestone list
+    // bullet. The malformed line must be skipped without consuming the bullet.
+    const content = milestoneSection(
+      "- [ ] M001: Foo — bar",
+      "- [ ] M002: Baz : qux",
+      "- some unrelated bullet",
+    );
+
+    const { milestones } = parseProject(content);
+    assert.deepEqual(milestones.map(m => m.id), ["M001"], "malformed M002 is skipped, not bridged onto the unrelated bullet");
+  });
+});

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

@@ -76,8 +76,10 @@ test("plan-slice prompt: compact planning gates survive template substitution",
   assert.ok(result.includes("Bias toward \"roadmap is fine.\""), "roadmap reassessment brake should remain visible");
   assert.ok(result.includes("Self-audit before finishing"), "self-audit gate should remain visible");
   assert.ok(result.includes("Quality gates: non-trivial slices/tasks include specific Q3-Q7 coverage where applicable."));
-  assert.ok(result.includes("C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\plan.md"));
-  assert.ok(result.includes("C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\task-plan.md"));
+  assert.ok(result.includes("Use the inlined Output Template sections already present in this prompt."));
+  assert.ok(result.includes("Do not read template files from disk."));
+  assert.ok(!result.includes("C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\plan.md"));
+  assert.ok(!result.includes("C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\task-plan.md"));
   assert.ok(!result.includes("{{templatesDir}}/plan.md"));
   assert.ok(!result.includes("{{templatesDir}}/task-plan.md"));
   assert.ok(!result.includes("{{"));

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

@@ -564,6 +564,33 @@ test("validate-milestone prompt dispatches parallel reviewers", () => {
   assert.match(prompt, /assessment evidence/i);
 });
 
+// ─── ADR-029: forward preloaded evidence to validate reviewers ────────
+test("validate-milestone forwards preloaded evidence to reviewers and keeps full reads on-demand", () => {
+  const prompt = readPrompt("validate-milestone");
+  // Orchestrator is told to embed the preloaded evidence into reviewer tasks.
+  assert.match(prompt, /[Ee]mbed the relevant preloaded evidence/);
+  // Each reviewer is told to use the preloaded evidence, not re-read from disk.
+  const useCount = (prompt.match(/do not re-read them from disk/g) ?? []).length;
+  assert.ok(useCount >= 3, `expected all three reviewers to use preloaded evidence, found ${useCount}`);
+  // Full reads are explicitly the on-demand exception, not the routine path.
+  assert.match(prompt, /only if (its|the) preloaded (excerpt|evidence) is missing, truncated, or inconsistent/i);
+});
+
+// ─── ADR-029: research-milestone grounds instead of surveying ─────────
+test("research-milestone prompt grounds in preloaded context instead of open-ended survey", () => {
+  const prompt = readPrompt("research-milestone");
+  // Grounded-research invariant present.
+  assert.match(prompt, /do not re-survey/i);
+  assert.match(prompt, /Codebase Snapshot and Project Classification/);
+  // The old open-ended survey license is gone (no "use `scout` to build a broad map").
+  assert.doesNotMatch(prompt, /use `scout` to build a broad map/);
+  // resolve_library/docs lookups remain permitted (bounded, external).
+  assert.match(prompt, /resolve_library/);
+  // Incremental save enables resume after interruption.
+  assert.match(prompt, /Save \*\*incrementally\*\*/);
+  assert.match(prompt, /Resume — Prior Partial Research/);
+});
+
 // ─── Prompt migration: replan-slice → gsd_replan_slice ────────────────
 
 test("replan-slice prompt names gsd_replan_slice as the tool to use", () => {
@@ -700,8 +727,8 @@ test("guided-discuss prompts require 3-or-4 options plus Other-let-me-discuss in
     );
     assert.match(
       prompt,
-      /grounded in (the |your |)investigation/i,
-      `${name} must require options grounded in prior investigation`,
+      /grounded in (the |your |)(investigation|preloaded context)/i,
+      `${name} must require options grounded in the preloaded context / prior investigation`,
     );
   }
 });

package/src/resources/extensions/gsd/tests/research-milestone-composer.test.ts

@@ -130,3 +130,68 @@ test("buildResearchMilestonePrompt keeps broad project docs on-demand", async (t
   assert.match(prompt, /`\.gsd\/REQUIREMENTS\.md`/);
   assert.match(prompt, /`\.gsd\/DECISIONS\.md`/);
 });
+
+// ─── ADR-029: preload-authoritative research grounding ────────────────
+
+test("ADR-029: research-milestone inlines project classification + codebase snapshot", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001 Context\n");
+  // Give the codebase scan something real to sample.
+  writeFileSync(join(base, "index.html"), "<!doctype html><html><body><h1>hi</h1></body></html>\n");
+  writeFileSync(join(base, "script.js"), "const x = 1;\nasync function go() { await x; }\n");
+
+  const prompt = await buildResearchMilestonePrompt("M001", "Research Test", base);
+
+  // Project-size signal (same block plan-milestone gets).
+  assert.match(prompt, /### Project Classification/);
+  assert.match(prompt, /Workflow sizing:/);
+  // Bounded codebase snapshot grounds research in current code reality.
+  assert.match(prompt, /### Codebase Snapshot \(current code reality\)/);
+  assert.match(prompt, /do NOT re-survey the tree/);
+});
+
+test("ADR-029: codebase snapshot is suppressed when discuss_preparation is false", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001 Context\n");
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\ndiscuss_preparation: false\n---\n");
+  invalidateAllCaches();
+
+  const prompt = await buildResearchMilestonePrompt("M001", "Research Test", base);
+
+  // Snapshot opt-out honored; classification (unconditional) still present.
+  assert.doesNotMatch(prompt, /### Codebase Snapshot/);
+  assert.match(prompt, /### Project Classification/);
+});
+
+test("ADR-029: prior partial RESEARCH is inlined as a resume block; absent otherwise", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001 Context\n");
+
+  // No prior research yet → no resume block. (Match the rendered block heading,
+  // not the bare phrase — step 8 of the template references the phrase by name.)
+  const before = await buildResearchMilestonePrompt("M001", "Research Test", base);
+  assert.doesNotMatch(before, /### Resume — Prior Partial Research \(continue, do not redo\)/);
+
+  // A partial RESEARCH draft from a prior (interrupted) attempt.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-RESEARCH.md"),
+    "# Research\n\n## Findings\n\nPartial finding: the app is a static site.\n",
+  );
+  invalidateAllCaches();
+
+  const after = await buildResearchMilestonePrompt("M001", "Research Test", base);
+  assert.match(after, /Resume — Prior Partial Research \(continue, do not redo\)/);
+  assert.match(after, /Partial finding: the app is a static site/);
+});

package/src/resources/extensions/gsd/tests/start-auto-detached.test.ts

@@ -3,7 +3,10 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
-import { _withDetachedAutoKeepaliveForTest } from "../auto.ts";
+import {
+  _resolveEffectiveUnitIsolationModeForTest,
+  _withDetachedAutoKeepaliveForTest,
+} from "../auto.ts";
 import {
   _scheduleAutoStartAfterIdleForTest,
   resolveGuidedExecuteLaunchMode,
@@ -337,17 +340,28 @@ test("resume path only hard-exits on blocked stop, not blocked pause (#6154)", (
 });
 
 test("prepareForUnit skips worktree safety when isolation is not worktree (#6154)", () => {
-  const autoSrc = readGsdFile("auto.ts");
-  const prepareForUnitIdx = autoSrc.indexOf("async prepareForUnit(unitType, unitId) {");
-  const prepareForUnitBody = autoSrc.slice(prepareForUnitIdx, autoSrc.indexOf("async syncAfterUnit() {}", prepareForUnitIdx));
+  const orchSrc = readGsdFile("auto/orchestrator.ts");
+  const prepareForUnitIdx = orchSrc.indexOf("private async prepareWorktreeForUnit(");
+  const prepareForUnitBody = orchSrc.slice(prepareForUnitIdx, orchSrc.indexOf("private classifyAndRecover(", prepareForUnitIdx));
 
   assert.ok(prepareForUnitIdx > -1, "prepareForUnit should exist");
   assert.ok(
-    prepareForUnitBody.includes('if (getIsolationMode(runtimeBasePath) !== "worktree")'),
+    prepareForUnitBody.includes("const isolationMode = this.getEffectiveUnitIsolationMode(this.runtimeBasePath);"),
+    "prepareForUnit should resolve the effective isolation mode once",
+  );
+  assert.ok(
+    prepareForUnitBody.includes('if (isolationMode !== "worktree")'),
     "prepareForUnit should bypass worktree safety validation outside worktree isolation mode",
   );
 });
 
+test("effective unit isolation follows degraded branch fallback", () => {
+  assert.equal(_resolveEffectiveUnitIsolationModeForTest("worktree", true), "branch");
+  assert.equal(_resolveEffectiveUnitIsolationModeForTest("worktree", false), "worktree");
+  assert.equal(_resolveEffectiveUnitIsolationModeForTest("branch", true), "branch");
+  assert.equal(_resolveEffectiveUnitIsolationModeForTest("none", true), "none");
+});
+
 test("discuss-to-auto handoff defaults to step mode unless explicitly disabled", () => {
   const guidedFlowSrc = readGsdFile("guided-flow.ts");
   const workflowSrc = readGsdFile("commands/handlers/workflow.ts");

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

@@ -24,7 +24,9 @@ test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surf
     "gsd_milestone_status",
     "gsd_checkpoint_db",
     "memory_query",
+    "gsd_memory_query",
     "capture_thought",
+    "gsd_capture_thought",
     "gsd_graph",
   ]);
 
@@ -575,6 +577,42 @@ test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visib
   assert.equal(calls.filter((call) => call.kind === "skills").length, 2);
 });
 
+// ── Regression #534: auto-mode subprocess cannot call gsd_memory_query / gsd_capture_thought ──
+// MCP-workflow subprocesses register the gsd_-prefixed variants, not the pi-native names.
+// MINIMAL_GSD_TOOL_NAMES must include both so resolveScopedToolNames exposes them.
+
+test("MINIMAL_GSD_TOOL_NAMES includes gsd_memory_query and gsd_capture_thought (regression #534)", () => {
+  assert.ok(
+    (MINIMAL_GSD_TOOL_NAMES as readonly string[]).includes("gsd_memory_query"),
+    "MINIMAL_GSD_TOOL_NAMES must include gsd_memory_query for MCP-workflow surface parity",
+  );
+  assert.ok(
+    (MINIMAL_GSD_TOOL_NAMES as readonly string[]).includes("gsd_capture_thought"),
+    "MINIMAL_GSD_TOOL_NAMES must include gsd_capture_thought for MCP-workflow surface parity",
+  );
+});
+
+test("buildMinimalAutoGsdToolSet resolves MCP-scoped gsd_memory_query and gsd_capture_thought when subprocess only registers gsd_-prefixed variants (regression #534)", () => {
+  // Simulate a subprocess that only exposes gsd_-prefixed MCP tool names,
+  // not the pi-native memory_query / capture_thought variants.
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "mcp__gsd-workflow__gsd_exec",
+    "mcp__gsd-workflow__gsd_memory_query",
+    "mcp__gsd-workflow__gsd_capture_thought",
+  ], "execute-task");
+
+  assert.ok(
+    result.includes("mcp__gsd-workflow__gsd_memory_query"),
+    "mcp__gsd-workflow__gsd_memory_query must be included when only the gsd_-prefixed variant is available",
+  );
+  assert.ok(
+    result.includes("mcp__gsd-workflow__gsd_capture_thought"),
+    "mcp__gsd-workflow__gsd_capture_thought must be included when only the gsd_-prefixed variant is available",
+  );
+});
+
 test("applyUnitSkillVisibility sets manifest or clears for wildcard", () => {
   const calls: Array<string[] | undefined> = [];
   applyUnitSkillVisibility({

package/src/resources/extensions/gsd/tests/user-input-boundary.test.ts

@@ -2,6 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import * as userInputBoundary from "../user-input-boundary.ts";
+import { isAwaitingUserInput, shouldPauseForUserApprovalQuestion } from "../user-input-boundary.ts";
 
 test("lastAssistantText extracts the latest assistant text block content", () => {
   const lastAssistantText = (userInputBoundary as {
@@ -24,3 +25,64 @@ test("lastAssistantText extracts the latest assistant text block content", () =>
   );
   assert.equal(lastAssistantText?.(null), "");
 });
+
+test("lastAssistantText includes thinking blocks so rate-limit notices are not dropped", () => {
+  const lastAssistantText = (userInputBoundary as {
+    lastAssistantText?: (messages: unknown[] | null | undefined) => string;
+  }).lastAssistantText;
+
+  assert.equal(typeof lastAssistantText, "function");
+  // Turn with only a thinking block (no text block) — must not return ""
+  const result = lastAssistantText?.([
+    {
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking: "You've hit your limit · resets in 2h" },
+      ],
+    },
+  ]);
+  assert.ok(result?.includes("You've hit your limit"), `expected rate-limit text, got: ${JSON.stringify(result)}`);
+});
+
+test("isAwaitingUserInput does not trigger on thinking-block question marks", () => {
+  // A thinking block with a question mark must NOT pause auto-mode —
+  // it's internal reasoning, not a user-visible prompt.
+  const messages = [
+    {
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking: "Should I skip research? Let me check the config." },
+      ],
+    },
+  ];
+  assert.equal(isAwaitingUserInput(messages), false);
+  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+});
+
+test("isAwaitingUserInput does not trigger on thinking-block approval phrases", () => {
+  // A thinking block with approval phrases must NOT pause auto-mode.
+  const messages = [
+    {
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking: "The user confirmed and approved the plan. Should I proceed?" },
+      ],
+    },
+  ];
+  assert.equal(isAwaitingUserInput(messages), false);
+  assert.equal(shouldPauseForUserApprovalQuestion("discuss-requirements", messages), false);
+});
+
+test("isAwaitingUserInput still triggers on text-block question marks when thinking is also present", () => {
+  // When thinking + text are both present and the text asks a question, it should still pause.
+  const messages = [
+    {
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking: "Internal reasoning without questions." },
+        { type: "text", text: "Does this look correct?" },
+      ],
+    },
+  ];
+  assert.equal(isAwaitingUserInput(messages), true);
+});

package/src/resources/extensions/gsd/tests/worktree-safety.test.ts

@@ -150,6 +150,30 @@ describe("Worktree Safety module", () => {
     assert.equal(result.kind, "safe");
   });
 
+  test("accepts project root for source-writing Unit when isolation mode is branch", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => false }),
+      listRegisteredWorktrees: () => [{ path: projectRoot, branch: "milestone/M001" }],
+      getCurrentBranch: () => "milestone/M001",
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot: projectRoot,
+      milestoneId: "M001",
+      isolationMode: "branch",
+      expectedBranch: "milestone/M001",
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(result.kind, "safe");
+    assert.equal(result.branch, "milestone/M001");
+  });
+
   test("rejects non-project root for source-writing Unit when isolation mode is none", () => {
     const safety = createWorktreeSafetyModule({
       existsSync: () => true,

package/src/resources/extensions/gsd/tests/write-gate-planning-unit.test.ts

@@ -9,7 +9,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { join, sep } from 'node:path';
 
-import { GSD_PHASE_SCOPE_DISPLAY_REASON } from '../auto-unit-tool-scope.ts';
+import { GSD_PHASE_SCOPE_DISPLAY_REASON, GSD_SECTION_CLOSE_GATE_DISPLAY_REASON } from '../auto-unit-tool-scope.ts';
 import { ALLOWED_PLANNING_DISPATCH_AGENTS, shouldBlockPlanningUnit } from '../bootstrap/write-gate.ts';
 import { extractSubagentAgentClasses } from '../bootstrap/subagent-input.ts';
 import { isDeterministicPolicyError } from '../auto-tool-tracking.ts';
@@ -377,14 +377,26 @@ test('auto-unit scope: execute-task allows only its task completion lifecycle to
   );
   assert.strictEqual(allowed.block, false);
 
+  // execute-task closes gates from summary sections, so gsd_save_gate_result gets
+  // the softer deterministic redirect instead of the normal HARD BLOCK wall.
   const blocked = shouldBlockPlanningUnit('gsd_save_gate_result', '', BASE, 'execute-task', ALL);
   assert.strictEqual(blocked.block, true);
-  assert.match(blocked.reason!, /HARD BLOCK/);
+  assert.doesNotMatch(blocked.reason!, /HARD BLOCK/);
   assert.match(blocked.reason!, /gsd_save_gate_result/);
-  assert.strictEqual(blocked.displayReason, GSD_PHASE_SCOPE_DISPLAY_REASON);
+  assert.match(blocked.reason!, /summary sections/);
+  assert.strictEqual(blocked.displayReason, GSD_SECTION_CLOSE_GATE_DISPLAY_REASON);
   assert.strictEqual(isDeterministicPolicyError(blocked.reason!), true);
 });
 
+test('auto-unit scope: section-close gate units get the calm gsd_save_gate_result redirect', () => {
+  for (const unit of ['execute-task', 'complete-slice', 'validate-milestone']) {
+    const r = shouldBlockPlanningUnit('gsd_save_gate_result', '', BASE, unit, ALL);
+    assert.strictEqual(r.block, true, `${unit} should still block the call`);
+    assert.doesNotMatch(r.reason!, /HARD BLOCK/, `${unit} should use the calm redirect`);
+    assert.strictEqual(isDeterministicPolicyError(r.reason!), true, `${unit} redirect must stay deterministic`);
+  }
+});
+
 test('auto-unit scope: execute-task blocks sibling task completion', () => {
   const r = shouldBlockPlanningUnit(
     'gsd_complete_task',