gsd-pi 2.78.1-dev.eccf86e27 → 2.79.0-dev.487011134

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -14,7 +14,7 @@ import { normalizeStringArray } from "../shared/format-utils.js";
 
 import {
   KNOWN_PREFERENCE_KEYS,
-  KNOWN_UNIT_TYPES,
+  KNOWN_UNIT_LABELS,
 
   SKILL_ACTIONS,
   type WorkflowMode,
@@ -441,7 +441,7 @@ export function validatePreferences(preferences: GSDPreferences): {
   if (preferences.post_unit_hooks && Array.isArray(preferences.post_unit_hooks)) {
     const validHooks: PostUnitHookConfig[] = [];
     const seenNames = new Set<string>();
-    const knownUnitTypes = new Set<string>(KNOWN_UNIT_TYPES);
+    const knownUnitTypes = new Set<string>(KNOWN_UNIT_LABELS);
     for (const hook of preferences.post_unit_hooks) {
       if (!hook || typeof hook !== "object") {
         errors.push("post_unit_hooks entry must be an object");
@@ -503,7 +503,7 @@ export function validatePreferences(preferences: GSDPreferences): {
   if (preferences.pre_dispatch_hooks && Array.isArray(preferences.pre_dispatch_hooks)) {
     const validPreHooks: PreDispatchHookConfig[] = [];
     const seenPreNames = new Set<string>();
-    const knownUnitTypes = new Set<string>(KNOWN_UNIT_TYPES);
+    const knownUnitTypes = new Set<string>(KNOWN_UNIT_LABELS);
     const validActions = new Set(["modify", "skip", "replace"]);
     for (const hook of preferences.pre_dispatch_hooks) {
       if (!hook || typeof hook !== "object") {

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

@@ -7,7 +7,7 @@ import { randomUUID } from "node:crypto";
 
 import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps, writeBlockerPlaceholder } from "../auto-recovery.ts";
 import { resolveMilestoneFile } from "../paths.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask } from "../gsd-db.ts";
 import { clearParseCache } from "../files.ts";
 import { parseRoadmap } from "../parsers-legacy.ts";
 import { invalidateAllCaches } from "../cache.ts";
@@ -764,6 +764,73 @@ test("hasImplementationArtifacts finds implementation commits when .gsd/ is giti
   }
 });
 
+test("hasImplementationArtifacts binds GSD-Task trailer to milestone via DB state when .gsd/ is gitignored", () => {
+  const base = makeGitBase();
+  try {
+    writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+    });
+
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}\n");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync(
+      "git",
+      ["commit", "-m", "feat: add feature\n\nGSD-Task: S01/T01"],
+      { cwd: base, stdio: "ignore" },
+    );
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(
+      result,
+      "present",
+      "DB task ownership should bind S01/T01 implementation commits to M001 without explicit M001 text",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts does not bind GSD-Task trailer without milestone ownership evidence", () => {
+  const base = makeGitBase();
+  try {
+    writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}\n");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync(
+      "git",
+      ["commit", "-m", "feat: add feature\n\nGSD-Task: S01/T01"],
+      { cwd: base, stdio: "ignore" },
+    );
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(
+      result,
+      "absent",
+      "S01/T01 shape alone must not bind an implementation commit to M001",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("hasImplementationArtifacts ignores malformed milestone IDs in commit-message fallback", () => {
   const base = makeGitBase();
   try {

package/src/resources/extensions/gsd/tests/bootstrap-derive-state-db-open.test.ts

@@ -31,9 +31,9 @@ describe("bootstrap deriveState DB guards (#3844)", () => {
     const compactIdx = registerHooksSrc.indexOf('pi.on("session_before_compact"');
     assert.ok(compactIdx > -1, "register-hooks should define session_before_compact");
     const compactSection = extractSourceRegion(registerHooksSrc, 'pi.on("session_before_compact"');
-    const ensureIdx = compactSection.indexOf("ensureDbOpen()");
+    const ensureIdx = compactSection.indexOf("ensureDbOpen(basePath)");
     const deriveIdx = compactSection.indexOf("deriveGsdState(basePath)");
-    assert.ok(ensureIdx > -1, "session_before_compact should call ensureDbOpen()");
+    assert.ok(ensureIdx > -1, "session_before_compact should call ensureDbOpen(basePath)");
     assert.ok(deriveIdx > -1, "session_before_compact should derive state");
     assert.ok(ensureIdx < deriveIdx, "session_before_compact should open DB before deriveState");
   });

package/src/resources/extensions/gsd/tests/current-directory-root-homedir-fallback.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Regression test — currentDirectoryRoot() uses os.homedir() as fallback
+ * when process.cwd() throws (e.g. worktree teardown deletes the cwd).
+ *
+ * Before the fix, the catch block used `process.env.HOME ?? "/"`. On
+ * Windows, HOME is typically unset so this resolved to "/", an invalid
+ * path. After the fix, os.homedir() is used — it checks USERPROFILE,
+ * HOMEDRIVE+HOMEPATH, etc., returning a valid path on all platforms.
+ *
+ * The test monkey-patches process.cwd() to throw ENOENT, simulating a
+ * deleted cwd. currentDirectoryRoot() must NOT propagate the raw error;
+ * instead it falls back to homedir(), which validateDirectory correctly
+ * rejects as "blocked", yielding GSDNoProjectError — the same controlled
+ * error path handlers already know how to catch.
+ *
+ * The error message is also asserted to match validateDirectory(homedir()),
+ * confirming the fallback resolved to homedir() specifically (not "/" or
+ * any other path).
+ */
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { homedir } from "node:os";
+
+import { currentDirectoryRoot, GSDNoProjectError } from "../commands/context.ts";
+import { validateDirectory } from "../validate-directory.ts";
+
+describe("currentDirectoryRoot() homedir() fallback on deleted cwd", () => {
+  const originalCwd = process.cwd.bind(process);
+
+  beforeEach(() => {
+    process.cwd = () => {
+      const err = new Error("ENOENT: no such file or directory, uv_cwd");
+      (err as NodeJS.ErrnoException).code = "ENOENT";
+      throw err;
+    };
+  });
+
+  afterEach(() => {
+    process.cwd = originalCwd;
+  });
+
+  test("does not propagate ENOENT — throws GSDNoProjectError via homedir() fallback", () => {
+    const expected = validateDirectory(homedir());
+    assert.equal(expected.severity, "blocked", "homedir() itself should be blocked");
+
+    assert.throws(
+      () => currentDirectoryRoot(),
+      (err: unknown) => {
+        assert.ok(
+          err instanceof GSDNoProjectError,
+          `expected GSDNoProjectError, got: ${err}`,
+        );
+        assert.equal(
+          (err as Error).message,
+          expected.reason ?? "GSD must be run inside a project directory.",
+          "error message must match validateDirectory(homedir()), confirming homedir() was the fallback",
+        );
+        return true;
+      },
+      "should throw GSDNoProjectError (homedir fallback validated), not raw ENOENT",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/deep-planning-mode-dispatch.test.ts

@@ -14,6 +14,7 @@ import {
   DISPATCH_RULES,
   getDeepStageGate,
   hasPendingDeepStage,
+  resolveDispatch,
   setResearchProjectPromptBuilderForTest,
   type DispatchContext,
 } from "../auto-dispatch.ts";
@@ -248,6 +249,11 @@ function writeCapturedDeepPrefs(base: string): void {
   );
 }
 
+function writeSkippedProjectResearchDecision(base: string): void {
+  mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "runtime", "research-decision.json"), JSON.stringify({ decision: "skip" }));
+}
+
 function makeCtx(
   basePath: string,
   prefs: GSDPreferences | undefined,
@@ -785,6 +791,42 @@ test("Deep mode: research-project DOES dispatch when only 3 of 4 research files
   assert.ok(result && result.action === "dispatch", "any missing dimension must trigger re-run");
 });
 
+test("Deep mode: queued milestone without CONTEXT.md routes to milestone research after project setup", async (t) => {
+  const base = makeIsolatedBaseWithCleanup(t);
+
+  writeCapturedDeepPrefs(base);
+  writeValidProject(base);
+  writeValidRequirements(base);
+  writeSkippedProjectResearchDecision(base);
+
+  const prefs = { planning_depth: "deep" } as GSDPreferences;
+  const result = await resolveDispatch(makeCtx(base, prefs));
+
+  assert.equal(result.action, "dispatch");
+  if (result.action === "dispatch") {
+    assert.equal(result.unitType, "research-milestone");
+    assert.equal(result.unitId, "M001");
+  }
+});
+
+test("Deep mode: queued milestone without CONTEXT.md can route directly to milestone planning", async (t) => {
+  const base = makeIsolatedBaseWithCleanup(t);
+
+  writeCapturedDeepPrefs(base);
+  writeValidProject(base);
+  writeValidRequirements(base);
+  writeSkippedProjectResearchDecision(base);
+
+  const prefs = { planning_depth: "deep", phases: { skip_research: true } } as GSDPreferences;
+  const result = await resolveDispatch(makeCtx(base, prefs));
+
+  assert.equal(result.action, "dispatch");
+  if (result.action === "dispatch") {
+    assert.equal(result.unitType, "plan-milestone");
+    assert.equal(result.unitId, "M001");
+  }
+});
+
 // ─── centralized deep-stage gate ─────────────────────────────────────────
 
 test("Deep mode gate reports the earliest missing section", (t) => {

package/src/resources/extensions/gsd/tests/deep-project-auto-loop.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -23,6 +23,11 @@ import {
   showSmartEntry,
   startDeepProjectSetupForeground,
 } from "../guided-flow.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  openDatabase,
+} from "../gsd-db.ts";
 import type { GSDPreferences } from "../preferences.ts";
 import type { GSDState } from "../types.ts";
 
@@ -342,6 +347,62 @@ test("deep project setup: pre-dispatch can run before the first milestone exists
   }
 });
 
+test("deep project setup: bootstrap continues queued M002 without milestone context", async () => {
+  const base = makeRepo();
+  try {
+    writeCapturedDeepPrefs(base);
+    writeValidProjectAndRequirements(base);
+    mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "runtime", "research-decision.json"), '{"decision":"skip"}\n');
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "First milestone", status: "complete" });
+    insertMilestone({ id: "M002", title: "Second milestone", status: "queued" });
+    closeDatabase();
+
+    const messages: unknown[] = [];
+    const pi = {
+      ...makePi(messages),
+      getThinkingLevel: () => "medium",
+    };
+    const s = new AutoSession();
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(`queued-${randomUUID()}`) as any,
+      pi as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        lockBase: () => base,
+        buildResolver: () => ({}) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    assert.equal(ready, true);
+    assert.equal(s.active, true);
+    assert.equal(s.currentMilestoneId, "M002");
+    assert.equal(messages.length, 0, "queued deep milestone must not re-enter smart new-milestone discussion");
+  } finally {
+    try { closeDatabase(); } catch {}
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("deep project setup: pre-dispatch takes precedence over an existing draft milestone", async () => {
   const base = makeBase();
   try {
@@ -1020,7 +1081,7 @@ test("deep project setup: research-project blocker placeholder is a file, not th
   const base = makeBase();
   try {
     const expectedPath = resolveExpectedArtifactPath("research-project", "PROJECT-RESEARCH", base);
-    assert.equal(expectedPath, join(base, ".gsd", "research", "PROJECT-RESEARCH-BLOCKER.md"));
+    assert.equal(expectedPath, join(realpathSync(base), ".gsd", "research", "PROJECT-RESEARCH-BLOCKER.md"));
 
     mkdirSync(join(base, ".gsd", "research"), { recursive: true });
     const diagnosis = writeBlockerPlaceholder(

package/src/resources/extensions/gsd/tests/guided-flow-prompt-consolidation.test.ts

@@ -101,6 +101,20 @@ describe("guided-flow → auto-prompts consolidation (#5183)", () => {
       prompt.includes("Implement the thing"),
       "must include task plan body content from disk",
     );
+    assert.ok(prompt.includes("## Context Mode"), "execute-task should include standalone Context Mode guidance");
+    assert.ok(prompt.includes("execution lane"), "execute-task should render the execution lane");
+  });
+
+  test("buildExecuteTaskPrompt omits Context Mode when disabled", async () => {
+    writeFileSync(
+      join(base, ".gsd", "PREFERENCES.md"),
+      ["---", "context_mode:", "  enabled: false", "---", ""].join("\n"),
+    );
+
+    const prompt = await buildExecuteTaskPrompt(MID, SID, S_TITLE, TID, T_TITLE, base);
+
+    assert.ok(!prompt.includes("## Context Mode"));
+    assert.ok(!prompt.includes("Context Mode (execution lane)"));
   });
 
   test("buildCompleteSlicePrompt carries the complete-slice contract", async () => {

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -147,4 +147,12 @@ test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skil
     prompt.includes(SKILL_ACTIVATION_SUBSTRING),
     `parallel-research-slices prompt should reference the always-used skill '${SKILL_NAME}'`,
   );
+  assert.ok(
+    prompt.includes("Context Mode (research lane):"),
+    "embedded parallel research subagent prompts should use nested Context Mode guidance",
+  );
+  assert.ok(
+    !prompt.includes("## Context Mode\n\nLane: **research lane**."),
+    "embedded parallel research subagent prompts should not use standalone Context Mode heading",
+  );
 });

package/src/resources/extensions/gsd/tests/pre-exec-gate-loop.test.ts

@@ -111,6 +111,9 @@ test("#4551: buildPlanSlicePrompt injects fix section when priorPreExecFailure p
     },
   );
 
+  assert.ok(prompt.includes("## Context Mode"), "plan-slice should include standalone Context Mode guidance");
+  assert.ok(prompt.includes("planning lane"), "plan-slice should render the planning lane");
+
   assert.ok(
     prompt.includes("Fix these specific issues from the prior pre-exec check"),
     "prompt must contain the fix section heading",

package/src/resources/extensions/gsd/tests/register-hooks-compaction-checkpoint.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { autoSession } from "../auto-runtime-state.ts";
 import { parseContinue } from "../files.ts";
 import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 import { deriveState, invalidateStateCache } from "../state.ts";
@@ -96,3 +97,87 @@ test("register-hooks writes CONTINUE checkpoint during planning phase without ac
   assert.match(parsed.completedWork, /planning phase/i, "completed-work should capture non-executing phase context");
   assert.match(parsed.nextAction, /slice S01/i, "next action should route resume to the active slice");
 });
+
+test("register-hooks writes Context Mode snapshot before active auto cancels compaction", async (t) => {
+  const base = createPlanningFixtureBase();
+  const originalCwd = process.cwd();
+  process.chdir(base);
+  invalidateStateCache();
+  closeDatabase();
+  autoSession.reset();
+  autoSession.active = true;
+
+  t.after(() => {
+    autoSession.reset();
+    invalidateStateCache();
+    closeDatabase();
+    process.chdir(originalCwd);
+    rmSync(base, { 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 compactHandlers = handlers.get("session_before_compact");
+  assert.ok(compactHandlers && compactHandlers.length > 0, "session_before_compact handler should be registered");
+
+  const result = await compactHandlers![0]({});
+
+  assert.deepEqual(result, { cancel: true }, "active auto should still cancel compaction");
+  const snapshotPath = join(base, ".gsd", "last-snapshot.md");
+  assert.ok(existsSync(snapshotPath), "active auto cancel should still leave a Context Mode snapshot");
+  assert.match(readFileSync(snapshotPath, "utf-8"), /GSD context snapshot/);
+});
+
+test("register-hooks does not write Context Mode snapshot when disabled", async (t) => {
+  const base = createPlanningFixtureBase();
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ncontext_mode:\n  enabled: false\n---\n",
+    "utf-8",
+  );
+  const originalCwd = process.cwd();
+  process.chdir(base);
+  invalidateStateCache();
+  closeDatabase();
+  autoSession.reset();
+
+  t.after(() => {
+    autoSession.reset();
+    invalidateStateCache();
+    closeDatabase();
+    process.chdir(originalCwd);
+    rmSync(base, { 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 compactHandlers = handlers.get("session_before_compact");
+  assert.ok(compactHandlers && compactHandlers.length > 0, "session_before_compact handler should be registered");
+
+  for (const handler of compactHandlers ?? []) {
+    await handler({});
+  }
+
+  assert.ok(
+    !existsSync(join(base, ".gsd", "last-snapshot.md")),
+    "disabled Context Mode should not write a snapshot",
+  );
+});

package/src/resources/extensions/gsd/tests/run-uat-composer.test.ts

@@ -95,6 +95,8 @@ test("#4782 phase 3: buildRunUatPrompt inlines slice UAT, slice summary, project
 
   // Context wrapper present
   assert.match(prompt, /## Inlined Context \(preloaded — do not re-read these files\)/);
+  assert.match(prompt, /## Context Mode/);
+  assert.match(prompt, /verification lane/);
 
   // Artifacts from the manifest inline list, in declared order:
   // slice-uat → slice-summary → project (#4925 review).

package/src/resources/extensions/gsd/tests/subagent-model-dispatch.test.ts

@@ -211,6 +211,14 @@ test("buildReactiveExecutePrompt: output contains model string when subagentMode
     prompt.includes('model: "claude-opus-4-6"'),
     `Prompt should contain model instruction. Got:\n${prompt.slice(0, 500)}`,
   );
+  assert.ok(
+    prompt.includes("Context Mode (execution lane):"),
+    "embedded reactive-execute task prompt should use nested Context Mode guidance",
+  );
+  assert.ok(
+    prompt.includes("## Context Mode"),
+    "reactive-execute parent prompt should include standalone Context Mode guidance",
+  );
 });
 
 test("buildReactiveExecutePrompt: no model instruction when subagentModel omitted", async (t) => {
@@ -266,3 +274,54 @@ test("buildReactiveExecutePrompt: no model instruction when subagentModel omitte
     "Prompt should not contain model instruction when subagentModel is omitted",
   );
 });
+
+test("buildGateEvaluatePrompt: embedded gate prompts use nested Context Mode guidance", async (t) => {
+  const { buildGateEvaluatePrompt } = await import("../auto-prompts.ts");
+  const { closeDatabase, insertGateRow, insertMilestone, insertSlice, openDatabase } = await import("../gsd-db.ts");
+  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-gate-"));
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(repo, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01 Plan\n\n## Verification\n- Run checks.\n");
+  openDatabase(join(repo, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test Milestone", status: "active", depends_on: [] });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Test Slice",
+    status: "planned",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+  insertGateRow({
+    milestoneId: "M001",
+    sliceId: "S01",
+    gateId: "Q3",
+    scope: "slice",
+  });
+
+  const prompt = await buildGateEvaluatePrompt(
+    "M001",
+    "Test Milestone",
+    "S01",
+    "Test Slice",
+    repo,
+    "claude-opus-4-6",
+  );
+
+  assert.ok(
+    prompt.includes("Context Mode (verification lane):"),
+    "embedded gate-evaluate prompt should use nested Context Mode guidance",
+  );
+  assert.ok(
+    prompt.includes("## Context Mode"),
+    "gate-evaluate parent prompt should include standalone Context Mode guidance",
+  );
+  assert.ok(prompt.includes('model: "claude-opus-4-6"'), "gate subagent prompt should preserve model instruction");
+});

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

@@ -9,6 +9,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import {
+  composeContextModeInstructions,
   composeInlinedContext,
   composeUnitContext,
   manifestBudgetChars,
@@ -101,6 +102,43 @@ test("#4782 composer: manifestBudgetChars returns declared budget", () => {
   assert.strictEqual(manifestBudgetChars("never-dispatched"), null);
 });
 
+test("Context Mode composer: disabled, unknown, and none modes return empty string", () => {
+  assert.strictEqual(
+    composeContextModeInstructions("execute-task", { enabled: false, renderMode: "standalone" }),
+    "",
+  );
+  assert.strictEqual(
+    composeContextModeInstructions("never-dispatched", { enabled: true, renderMode: "standalone" }),
+    "",
+  );
+  assert.strictEqual(
+    composeContextModeInstructions("workflow-preferences", { enabled: true, renderMode: "standalone" }),
+    "",
+  );
+});
+
+test("Context Mode composer: standalone output starts with heading and includes required tools", () => {
+  const out = composeContextModeInstructions("execute-task", { enabled: true, renderMode: "standalone" });
+  assert.ok(out.startsWith("## Context Mode"));
+  assert.match(out, /execution lane/i);
+  assert.match(out, /`gsd_exec`/);
+  assert.match(out, /noisy scans, builds, and tests/);
+  assert.match(out, /`gsd_exec_search`/);
+  assert.match(out, /before repeating prior runs/);
+  assert.match(out, /`gsd_resume`/);
+  assert.match(out, /after compaction or resume/);
+});
+
+test("Context Mode composer: nested output is compact single sentence", () => {
+  const out = composeContextModeInstructions("gate-evaluate", { enabled: true, renderMode: "nested" });
+  assert.ok(!out.startsWith("## Context Mode"));
+  assert.match(out, /^Context Mode \(verification lane\): /);
+  assert.strictEqual(out.split(/\n/).length, 1);
+  assert.match(out, /`gsd_exec`/);
+  assert.match(out, /`gsd_exec_search`/);
+  assert.match(out, /`gsd_resume`/);
+});
+
 // ─── Integration: migrated buildReassessRoadmapPrompt ─────────────────────
 
 function makeFixtureBase(): string {

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

@@ -12,6 +12,7 @@ import {
   UNIT_MANIFESTS,
   resolveManifest,
   type ArtifactKey,
+  type ContextModePolicy,
   type SkillsPolicy,
   type UnitContextManifest,
 } from "../unit-context-manifest.ts";
@@ -105,6 +106,37 @@ test("#4782 phase 1: every manifest has a positive maxSystemPromptChars", () =>
   }
 });
 
+test("Context Mode: every manifest declares the expected contextMode lane", () => {
+  const expected: Record<string, ContextModePolicy> = {
+    "workflow-preferences": "none",
+    "research-decision": "none",
+    "discuss-project": "interview",
+    "discuss-requirements": "interview",
+    "discuss-milestone": "interview",
+    "research-project": "research",
+    "research-milestone": "research",
+    "research-slice": "research",
+    "plan-milestone": "planning",
+    "plan-slice": "planning",
+    "refine-slice": "planning",
+    "replan-slice": "planning",
+    "reassess-roadmap": "planning",
+    "execute-task": "execution",
+    "reactive-execute": "execution",
+    "run-uat": "verification",
+    "gate-evaluate": "verification",
+    "validate-milestone": "verification",
+    "complete-slice": "verification",
+    "complete-milestone": "verification",
+    "rewrite-docs": "docs",
+  };
+
+  assert.deepEqual(Object.keys(expected).sort(), [...KNOWN_UNIT_TYPES].sort());
+  for (const unitType of KNOWN_UNIT_TYPES) {
+    assert.strictEqual(UNIT_MANIFESTS[unitType].contextMode, expected[unitType]);
+  }
+});
+
 test("#4782 phase 1: skills policy shapes are valid discriminated-union members", () => {
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const p = manifest.skills as SkillsPolicy;