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

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -21,6 +21,14 @@ function runGit(args: string[], cwd: string): void {
   });
 }
 
+function renderOutcomeWidget(widget: unknown): string {
+  const component = (widget as any)(
+    { requestRender() {} },
+    { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+  );
+  return component.render(100).join("\n");
+}
+
 test("cleanupAfterLoopExit preserves paused auto badge after provider pause", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-paused-cleanup-"));
   const previousCwd = process.cwd();
@@ -167,13 +175,17 @@ test("cleanupAfterLoopExit preserves completion closeout surface after stopAuto
       false,
       "completion cleanup must not replace the closeout surface with a generic outcome card",
     );
-    assert.equal(autoSession.completionStopInProgress, false);
+    assert.equal(
+      autoSession.completionStopInProgress,
+      true,
+      "completion closeout preservation must survive post-loop cleanup until the next agent turn",
+    );
   } finally {
     autoSession.reset();
   }
 });
 
-test("cleanupAfterLoopExit clears completionStopInProgress even when preserveStepSurfaceAfterLoopExit is also set", async () => {
+test("cleanupAfterLoopExit preserves completionStopInProgress even when preserveStepSurfaceAfterLoopExit is also set", async () => {
   const statusCalls: unknown[] = [];
   const widgetCalls: unknown[] = [];
 
@@ -196,8 +208,8 @@ test("cleanupAfterLoopExit clears completionStopInProgress even when preserveSte
 
     assert.equal(
       autoSession.completionStopInProgress,
-      false,
-      "completionStopInProgress must be cleared even when preserveStepSurfaceAfterLoopExit was also set",
+      true,
+      "completionStopInProgress must survive cleanup even when preserveStepSurfaceAfterLoopExit was also set",
     );
     assert.equal(autoSession.preserveStepSurfaceAfterLoopExit, false);
   } finally {
@@ -641,6 +653,10 @@ test("stopAuto foreground completion closeout reroots session and preserves the
       false,
       "foreground completion stop must not install a replacement roll-up widget over the transcript",
     );
+    assert.ok(
+      widgetCalls.some(([key, value]) => key === "gsd-progress" && value === undefined),
+      "foreground completion stop must clear stale progress controls in the rerooted session",
+    );
     assert.ok(
       notifications.every(message => !message.includes("/gsd auto to resume")),
       "completion stop notification must not tell users to resume a finished auto run",
@@ -649,10 +665,15 @@ test("stopAuto foreground completion closeout reroots session and preserves the
       notifications.every(message => !message.includes("Auto-mode stopped") && !message.includes("Session:") && !message.includes("Debug log written")),
       "completion stop must not append generic stop/session/debug notifications after the report",
     );
-    assert.ok(
-      widgetCalls.every(([key, value]) => key !== "gsd-outcome" || value === undefined),
-      "foreground completion stop must not replace the transcript with a generic outcome card",
+    const outcome = widgetCalls.find(([key, value]) => key === "gsd-outcome" && typeof value === "function")?.[1];
+    assert.equal(
+      typeof outcome,
+      "function",
+      "foreground completion stop must install a durable closeout outcome in the rerooted session",
     );
+    const rendered = renderOutcomeWidget(outcome);
+    assert.match(rendered, /Milestone M003 complete/);
+    assert.match(rendered, /Review the closeout/);
 
     const widgetCallCountBeforePostLoopCleanup = widgetCalls.length;
     await cleanupAfterLoopExit(ctx);
@@ -822,7 +843,7 @@ test("stopAuto closeout-transcript preservation suppresses generic stop widgets"
   }
 });
 
-test("stopAuto foreground all-complete closeout preserves the transcript surface", async () => {
+test("stopAuto foreground all-complete closeout installs a durable terminal outcome", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-all-complete-closeout-"));
   const previousCwd = process.cwd();
   const widgetCalls: Array<[string, unknown]> = [];
@@ -875,8 +896,15 @@ test("stopAuto foreground all-complete closeout preserves the transcript surface
       false,
       "foreground all-complete closeout must not replace the visible transcript with a roll-up widget",
     );
-    const finalOutcome = widgetCalls.filter(([key]) => key === "gsd-outcome").at(-1);
-    assert.equal(finalOutcome?.[1], undefined, "foreground all-complete closeout must not add an outcome replacement");
+    const finalOutcome = widgetCalls.filter(([key]) => key === "gsd-outcome").at(-1)?.[1];
+    assert.equal(
+      typeof finalOutcome,
+      "function",
+      "foreground all-complete closeout must install a durable terminal outcome",
+    );
+    const rendered = renderOutcomeWidget(finalOutcome);
+    assert.match(rendered, /All milestones complete/);
+    assert.match(rendered, /start new work/);
   } finally {
     try { closeDatabase(); } catch { /* noop */ }
     autoSession.reset();

package/src/resources/extensions/gsd/tests/debug-logger.test.ts

@@ -115,6 +115,21 @@ test('debugCount increments counters', () => {
   assert.strictEqual(summary.dispatches, 5);
 });
 
+test('debugCount tracks gitInvocations and writeDebugSummary reports it', () => {
+  const tmp = createTempGsdDir();
+  enableDebug(tmp);
+
+  debugCount('gitInvocations');
+  debugCount('gitInvocations', 13);
+
+  const logPath = writeDebugSummary()!;
+  const lines = readLogLines(logPath);
+
+  const summary = lines.find(l => l.event === 'debug-summary') as any;
+  assert.ok(summary, 'should have debug-summary event');
+  assert.strictEqual(summary.gitInvocations, 14);
+});
+
 test('debugPeak tracks max values', () => {
   const tmp = createTempGsdDir();
   enableDebug(tmp);

package/src/resources/extensions/gsd/tests/execute-summary-save-empty-project.test.ts

@@ -6,7 +6,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { openDatabase, closeDatabase, getAllMilestones } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, getAllMilestones, getArtifact } from "../gsd-db.ts";
+import { parseProject } from "../schemas/parsers.ts";
 import { markApprovalGateVerified, clearDiscussionFlowState } from "../bootstrap/write-gate.ts";
 import { executeSummarySave } from "../tools/workflow-tool-executors.ts";
 
@@ -107,3 +108,65 @@ test("executeSummarySave registers milestones when PROJECT.md uses canonical em-
   assert.deepEqual(result.details.registeredMilestones, ["M001", "M002"]);
   assert.equal(getAllMilestones().length, 2);
 });
+
+test("executeSummarySave self-heals the Milestone Sequence when DB already has milestones but content parses zero", async (t) => {
+  const base = setupBase(t);
+
+  // 1) First save registers M001 as complete; DB now holds the milestone with
+  //    authoritative status.
+  const canonical = [
+    "# Project",
+    "",
+    "## Milestone Sequence",
+    "",
+    "<!-- Check off milestones as they complete. -->",
+    "",
+    "- [x] M001: Foo — bar",
+    "",
+  ].join("\n");
+  await inProjectDir(base, () => executeSummarySave({ artifact_type: "PROJECT", content: canonical }, base));
+  assert.equal(getAllMilestones().length, 1);
+
+  // 2) A completion re-save reflows the sequence with an en-dash separator the
+  //    canonical parser rejects → zero parseable lines, but the DB is intact.
+  //    (A trailing non-bullet section prevents MILESTONE_LINE_RE from bridging
+  //    onto a later bullet.) The checkbox here is deliberately WRONG (unchecked)
+  //    to prove the rebuild takes status from the DB, not the malformed content.
+  const malformed = [
+    "# Project",
+    "",
+    "## Milestone Sequence",
+    "",
+    "<!-- Check off milestones as they complete. -->",
+    "",
+    "- [ ] M001: Foo – shipped bar", // en-dash U+2013, not accepted by MILESTONE_LINE_RE
+    "",
+    "## Notes",
+    "",
+    "Trailing prose with no list bullets.",
+    "",
+  ].join("\n");
+
+  const result = await inProjectDir(base, () => executeSummarySave({ artifact_type: "PROJECT", content: malformed }, base));
+
+  // Non-fatal: the save succeeds and reports the self-heal.
+  assert.notEqual(result.isError, true);
+  assert.equal(result.details.milestoneSequenceSelfHealed, true);
+  assert.deepEqual(result.details.registeredMilestones, ["M001"]);
+  assert.equal(getAllMilestones().length, 1);
+
+  // The persisted PROJECT.md now parses canonically and preserves status + prose.
+  const persisted = getArtifact("PROJECT.md");
+  assert.ok(persisted);
+  const parsed = parseProject(persisted!.full_content);
+  assert.equal(parsed.milestones.length, 1);
+  const m001 = parsed.milestones.find(m => m.id === "M001");
+  assert.ok(m001);
+  // Status comes from the DB (M001 complete), not the unchecked box in the
+  // malformed content.
+  assert.equal(m001!.done, true);
+  assert.equal(m001!.title, "Foo");
+  assert.match(m001!.oneLiner, /shipped bar/);
+  // The HTML comment hint survives the rebuild.
+  assert.match(persisted!.full_content, /Check off milestones as they complete/);
+});

package/src/resources/extensions/gsd/tests/markdown-renderer-parse-cache.test.ts

@@ -0,0 +1,75 @@
+// Project/App: gsd-pi
+// File Purpose: Performance-contract test for the detectStaleRenders file-identity
+// parse cache (#442 Phase 1.5). Asserts the observable contract: an unchanged
+// projection is NOT re-parsed on the next dispatch (cache hit), while a changed
+// projection IS re-parsed (cache miss on path+mtime+size). Modeled on the
+// prepared-statement caching contract test in db-adapter.test.ts — it asserts
+// external behavior (parse happened / did not), never internal wiring.
+
+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 { openDatabase, closeDatabase, insertMilestone, insertSlice } from "../gsd-db.ts";
+import { clearParseCache } from "../files.ts";
+import { clearPathCache } from "../paths.ts";
+import { invalidateStateCache } from "../state.ts";
+import { detectStaleRenders } from "../markdown-renderer.ts";
+import { enableDebug, disableDebug, getDebugCounters } from "../debug-logger.ts";
+
+function roadmapMd(slices: Array<{ id: string; title: string; done: boolean }>): string {
+  const lines = ["# M001 Roadmap", "", "**Vision:** cache contract", "", "## Slices", ""];
+  for (const s of slices) lines.push(`- ${s.done ? "[x]" : "[ ]"} **${s.id}: ${s.title}** \`risk:medium\` \`depends:[]\``);
+  lines.push("");
+  return lines.join("\n");
+}
+
+test("#442: detectStaleRenders re-parses ROADMAP only when it changes on disk", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-parse-cache-"));
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  const roadmapPath = join(milestoneDir, "M001-ROADMAP.md");
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    disableDebug();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Cache", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active", risk: "medium", depends: [], sequence: 1 });
+
+  // Start from a cold cache so counts are attributable to this test.
+  clearParseCache();
+  clearPathCache();
+  invalidateStateCache();
+
+  writeFileSync(roadmapPath, roadmapMd([{ id: "S01", title: "Slice", done: false }]));
+
+  enableDebug(base); // resets counters
+
+  // First dispatch: cold cache → the roadmap is read + parsed.
+  detectStaleRenders(base);
+  const afterCold = getDebugCounters().parseRoadmapCalls;
+  assert.ok(afterCold > 0, "cold dispatch must parse the roadmap");
+
+  // Second dispatch, file unchanged: cache hit → NO new parse.
+  detectStaleRenders(base);
+  const afterWarm = getDebugCounters().parseRoadmapCalls;
+  assert.equal(afterWarm, afterCold, "unchanged projection must not be re-parsed");
+
+  // Change the file (different content AND size) WITHOUT clearing caches:
+  // the path+mtime+size identity changes, forcing a re-parse.
+  writeFileSync(
+    roadmapPath,
+    roadmapMd([
+      { id: "S01", title: "Slice", done: true },
+      { id: "S02", title: "Added Slice", done: false },
+    ]),
+  );
+  detectStaleRenders(base);
+  const afterChange = getDebugCounters().parseRoadmapCalls;
+  assert.ok(afterChange > afterWarm, "a changed projection must be re-parsed");
+});

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");