gsd-pi 2.78.0 → 2.78.1-dev.8a893322c

package/src/resources/extensions/gsd/tests/quick-turn-end-cleanup.test.ts

@@ -23,19 +23,19 @@ describe("quick task turn_end cleanup (#2668)", () => {
     "utf-8",
   );
 
-  it("register-hooks.ts imports cleanupQuickBranch from quick.ts", () => {
+  it("register-hooks.ts loads cleanupQuickBranch from quick.ts", () => {
     assert.ok(
       hooksSource.includes("cleanupQuickBranch"),
       "register-hooks.ts must reference cleanupQuickBranch",
     );
 
-    // Verify it's imported (not just mentioned in a comment)
-    const importMatch = hooksSource.match(
-      /import\s*\{[^}]*cleanupQuickBranch[^}]*\}\s*from\s*["'][^"']*quick/,
-    );
+    // Verify it is loaded from quick.ts (static or lazy), not just mentioned in a comment.
+    const importMatch =
+      hooksSource.match(/import\s*\{[^}]*cleanupQuickBranch[^}]*\}\s*from\s*["'][^"']*quick/) ||
+      hooksSource.match(/const\s+\{\s*cleanupQuickBranch\s*\}\s*=\s*await\s+import\(["'][^"']*quick\.js["']\)/);
     assert.ok(
       importMatch,
-      "cleanupQuickBranch must be imported from quick module",
+      "cleanupQuickBranch must be loaded from quick module",
     );
   });
 

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

@@ -0,0 +1,93 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { parseContinue } from "../files.ts";
+import { closeDatabase } from "../gsd-db.ts";
+import { deriveState, invalidateStateCache } from "../state.ts";
+
+function createPlanningFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-compact-checkpoint-"));
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    `# M001: Test Milestone
+
+**Vision:** Validate compaction checkpointing.
+
+## Slices
+
+- [ ] **S01: Test Slice** \`risk:low\` \`depends:[]\`
+  > After this: Slice is done.
+`,
+  );
+
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    `# S01: Test Slice
+
+**Goal:** Validate planning checkpoint.
+**Demo:** Checkpoint exists after compaction.
+
+## Tasks
+`,
+  );
+
+  return base;
+}
+
+test("register-hooks writes CONTINUE checkpoint during planning phase without active task (#4258)", async (t) => {
+  const base = createPlanningFixtureBase();
+  const originalCwd = process.cwd();
+  process.chdir(base);
+  invalidateStateCache();
+  closeDatabase();
+
+  t.after(() => {
+    invalidateStateCache();
+    closeDatabase();
+    process.chdir(originalCwd);
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const state = await deriveState(base);
+  assert.equal(state.phase, "planning", "fixture should derive planning phase");
+  assert.equal(state.activeMilestone?.id, "M001", "fixture should have active milestone");
+  assert.equal(state.activeSlice?.id, "S01", "fixture should have active slice");
+  assert.equal(state.activeTask, null, "fixture should have no active task");
+
+  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({});
+  }
+
+  const continuePath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-CONTINUE.md");
+  assert.ok(existsSync(continuePath), "compaction should create slice CONTINUE checkpoint");
+
+  const parsed = parseContinue(readFileSync(continuePath, "utf-8"));
+  assert.equal(parsed.frontmatter.milestone, "M001");
+  assert.equal(parsed.frontmatter.slice, "S01");
+  assert.equal(parsed.frontmatter.task, "none", "planning checkpoint should use non-task placeholder");
+  assert.equal(parsed.frontmatter.status, "compacted");
+  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");
+});

package/src/resources/extensions/gsd/tests/safety-harness-false-positives.test.ts

@@ -18,9 +18,11 @@ import { shouldBlockQueueExecution } from "../bootstrap/write-gate.ts";
 import {
   resetEvidence,
   recordToolCall,
+  recordToolResult,
   getEvidence,
   saveEvidenceToDisk,
   loadEvidenceFromDisk,
+  type BashEvidence,
 } from "../safety/evidence-collector.ts";
 import { validateFileChanges } from "../safety/file-change-validator.ts";
 
@@ -110,6 +112,38 @@ test("safety-harness-bug2: loadEvidenceFromDisk returns empty array when no file
   assert.equal(getEvidence().length, 0, "no evidence on fresh unit is correct — not a false positive");
 });
 
+test("safety-harness-bug2-race: bash evidence survives mid-unit reset between tool_call and tool_execution_end", (t) => {
+  // Reproduces the race where runUnitPhase re-fires (resetEvidence + loadEvidenceFromDisk)
+  // between a bash tool_call and its tool_execution_end. Pre-fix, the call entry lived
+  // only in memory until tool_execution_end; the reset wiped it and recordToolResult
+  // silently no-op'd, producing the "task complete with no bash calls" false positive.
+  // Post-fix, register-hooks.ts persists at tool_call time too — so the entry survives
+  // the reset via the disk round-trip.
+  const base = mkdtempSync(join(tmpdir(), "gsd-evidence-race-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  resetEvidence();
+
+  // tool_call fires: record AND persist (post-fix register-hooks.ts behavior).
+  recordToolCall("tc-bash-1", "bash", { command: "grep -q saveTodos app.js" });
+  saveEvidenceToDisk(base, "M001", "S01", "T02");
+
+  // Mid-unit race: runUnitPhase re-fires, calling resetEvidence + loadEvidenceFromDisk.
+  resetEvidence();
+  assert.equal(getEvidence().length, 0, "memory cleared by mid-unit reset");
+  loadEvidenceFromDisk(base, "M001", "S01", "T02");
+  assert.equal(getEvidence().length, 1, "entry restored from disk-persisted tool_call");
+
+  // tool_execution_end fires: result must update the restored entry by toolCallId.
+  recordToolResult("tc-bash-1", "bash", "Command exited with code 0\nfound\n", false);
+
+  const bash = getEvidence().filter((e): e is BashEvidence => e.kind === "bash");
+  assert.equal(bash.length, 1, "bash entry must survive race + result update");
+  assert.equal(bash[0].exitCode, 0, "result populated the restored entry");
+  assert.equal(bash[0].command, "grep -q saveTodos app.js", "command preserved across race");
+  assert.ok(bash[0].outputSnippet.includes("found"), "output snippet captured");
+});
+
 // ─── Bug 3: git diff HEAD~1 scope check ─────────────────────────────────────
 
 test("safety-harness-bug3: validateFileChanges works on initial commit (no HEAD~1)", (t) => {

package/src/resources/extensions/gsd/tests/session-start-footer.test.ts

@@ -7,20 +7,20 @@
  *
  * Testing strategy:
  *   1. Source-code regression guards: structural checks on register-hooks.ts.
- *   2. Behavioral integration test: fires the live session_start handler with a
- *      fake ctx when isAutoActive() is false (default) and confirms neither
- *      setFooter nor setWidget("gsd-health") is called.
+ *   2. Behavioral integration tests: fire the live session handlers with fake
+ *      contexts and confirm footer/widget behavior from runtime effects.
  *
  * Relates to #4314.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, readFileSync, rmSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
+import { autoSession } from "../auto-runtime-state.ts";
 import { registerHooks } from "../bootstrap/register-hooks.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -68,27 +68,89 @@ test("session_start handler guards initHealthWidget with !isAutoActive()", () =>
   );
 });
 
-test("session_switch handler suppresses gsd-health when isAutoActive()", () => {
-  const sessionSwitchIdx = HOOKS_SOURCE.indexOf('"session_switch"');
-  assert.ok(sessionSwitchIdx > -1, "session_switch handler must exist");
+test("session_switch toggles gsd-health from runtime auto state without touching the footer", async (t) => {
+  const dir = join(
+    tmpdir(),
+    `gsd-session-switch-widget-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  const tempGsdHome = join(dir, "home");
+  mkdirSync(tempGsdHome, { recursive: true });
 
-  const beforeAgentStartIdx = HOOKS_SOURCE.indexOf('"before_agent_start"');
-  assert.ok(beforeAgentStartIdx > sessionSwitchIdx, "before_agent_start handler must follow session_switch");
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(dir);
+  autoSession.reset();
+  t.after(() => {
+    autoSession.reset();
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  });
 
-  const sessionSwitchBody = HOOKS_SOURCE.slice(sessionSwitchIdx, beforeAgentStartIdx);
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
 
-  assert.ok(
-    sessionSwitchBody.includes("isAutoActive()"),
-    "session_switch handler must call isAutoActive()",
-  );
-  assert.ok(
-    sessionSwitchBody.includes('setWidget("gsd-health", undefined)'),
-    "session_switch handler must call setWidget(\"gsd-health\", undefined) when auto is active",
+  registerHooks(pi, []);
+
+  const sessionSwitch = handlers.get("session_switch");
+  assert.ok(sessionSwitch, "session_switch handler must be registered");
+
+  let setFooterCallCount = 0;
+  const widgetCalls: Array<{ key: string; value: unknown }> = [];
+  const ctx = {
+    hasUI: true,
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setFooter: (_footer: unknown) => {
+        setFooterCallCount++;
+      },
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: (key: string, value: unknown) => {
+        widgetCalls.push({ key, value });
+      },
+    },
+    sessionManager: { getSessionId: () => null },
+    model: null,
+    modelRegistry: {
+      setDisabledModelProviders: () => {},
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => false,
+    },
+  };
+
+  autoSession.active = true;
+  await sessionSwitch!({ reason: "resume" }, ctx);
+  assert.deepEqual(
+    widgetCalls.filter((call) => call.key === "gsd-health").map((call) => call.value),
+    [undefined],
+    "session_switch should hide gsd-health when auto is active",
   );
+  assert.equal(setFooterCallCount, 0, "session_switch must not call setFooter when auto is active");
+
+  widgetCalls.length = 0;
+  autoSession.active = false;
+  await sessionSwitch!({ reason: "resume" }, ctx);
+  const healthWidgetValues = widgetCalls
+    .filter((call) => call.key === "gsd-health")
+    .map((call) => call.value);
+
+  assert.ok(healthWidgetValues.length >= 2, "session_switch should initialize gsd-health when auto is inactive");
   assert.ok(
-    !sessionSwitchBody.includes("setFooter"),
-    "session_switch handler must NOT call setFooter",
+    healthWidgetValues.every((value) => value !== undefined),
+    "session_switch must not hide gsd-health when auto is inactive",
   );
+  assert.ok(Array.isArray(healthWidgetValues[0]), "initHealthWidget should publish initial health lines");
+  assert.equal(typeof healthWidgetValues.at(-1), "function", "initHealthWidget should register the live widget factory");
+  assert.equal(setFooterCallCount, 0, "session_switch must not call setFooter when auto is inactive");
 });
 
 // ─── Behavioral test: neither setFooter nor health suppression when auto inactive ─
@@ -143,3 +205,90 @@ test("session_start does NOT call setFooter or suppress gsd-health when isAutoAc
   assert.equal(setFooterCallCount, 0, "setFooter must NOT be called when isAutoActive() is false");
   assert.equal(healthWidgetHideCount, 0, "gsd-health must NOT be hidden when isAutoActive() is false");
 });
+
+test("session_start and session_switch apply disabled model provider policy from current preferences", async (t) => {
+  const dir = join(
+    tmpdir(),
+    `gsd-disabled-provider-policy-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  const tempGsdHome = join(dir, "home");
+  mkdirSync(tempGsdHome, { recursive: true });
+
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(dir);
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  });
+
+  const writePrefs = (providers: string[]) => {
+    writeFileSync(
+      join(dir, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "disabled_model_providers:",
+        ...providers.map((provider) => `  - ${provider}`),
+        "---",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+  };
+
+  const appliedPolicies: string[][] = [];
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
+  const ctx = {
+    hasUI: true,
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setFooter: () => {},
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: () => {},
+    },
+    sessionManager: { getSessionId: () => null },
+    model: null,
+    modelRegistry: {
+      setDisabledModelProviders: (providers: string[]) => {
+        appliedPolicies.push([...providers]);
+      },
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => false,
+    },
+  };
+
+  registerHooks(pi, []);
+
+  const sessionStart = handlers.get("session_start");
+  const sessionSwitch = handlers.get("session_switch");
+  assert.ok(sessionStart, "session_start handler must be registered");
+  assert.ok(sessionSwitch, "session_switch handler must be registered");
+
+  writePrefs(["google-gemini-cli", " google-gemini-cli ", "openai-codex"]);
+  await sessionStart!({}, ctx);
+  assert.deepEqual(
+    appliedPolicies.at(-1),
+    ["google-gemini-cli", "openai-codex"],
+    "session_start should apply normalized disabled providers before the first agent turn",
+  );
+
+  writePrefs(["anthropic"]);
+  await sessionSwitch!({ reason: "resume" }, ctx);
+  assert.deepEqual(
+    appliedPolicies.at(-1),
+    ["anthropic"],
+    "session_switch should re-read preferences for the switched project/session context",
+  );
+});

package/src/resources/extensions/gsd/tests/slice-parallel-orchestrator.test.ts

@@ -11,7 +11,7 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
-import { restoreSliceState } from "../slice-parallel-orchestrator.ts";
+import { restoreSliceState, SLICE_WORKER_AUTO_ARGS } from "../slice-parallel-orchestrator.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const gsdDir = join(__dirname, "..");
@@ -100,6 +100,12 @@ describe("slice-parallel-orchestrator structural tests", () => {
     );
   });
 
+  it("slice workers use headless auto instead of print-mode slash commands", () => {
+    const args: readonly string[] = SLICE_WORKER_AUTO_ARGS;
+    assert.deepEqual([...args], ["headless", "--json", "auto"]);
+    assert.equal(args.includes("--print"), false);
+  });
+
   it("maxWorkers default is 2", () => {
     const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
     // Check that default max workers is 2 (in opts.maxWorkers ?? 2 or similar)

package/src/resources/extensions/gsd/tests/smart-entry-complete.test.ts

@@ -48,6 +48,28 @@ test("guided-flow complete branch offers a chooser for next milestone or status"
 
   assert.match(branchChunk, /showNextAction\(/, "complete branch should present a chooser");
   assert.match(branchChunk, /findMilestoneIds\(basePath\)/, "complete branch should compute the next milestone id");
-  assert.match(branchChunk, /nextMilestoneId(?:Reserved)?\(milestoneIds, uniqueMilestoneIds\)/, "complete branch should derive the next milestone id");
+  assert.match(
+    branchChunk,
+    /nextMilestoneIdReserved\(milestoneIds,\s*uniqueMilestoneIds,\s*basePath\)/,
+    "complete branch should derive the next milestone id",
+  );
   assert.match(branchChunk, /dispatchWorkflow\(pi, await prepareAndBuildDiscussPrompt\(/, "complete branch should dispatch the prepared discuss prompt");
 });
+
+test("guided-flow needs-discussion skip branch opens the project DB before reserving a new milestone", () => {
+  const guidedFlowSource = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
+  const laterDbOpenIdx = guidedFlowSource.indexOf("// Ensure DB is open before querying slices (#2560).");
+  assert.ok(laterDbOpenIdx > -1, "guided-flow.ts should contain the post-draft DB-open guard");
+
+  const branchPrefix = guidedFlowSource.slice(0, laterDbOpenIdx);
+  const skipBranchIdx = branchPrefix.lastIndexOf('choice === "skip_milestone"');
+  assert.ok(skipBranchIdx > -1, "needs-discussion skip branch should be present");
+
+  const branchChunk = branchPrefix.slice(skipBranchIdx);
+  const ensureIdx = branchChunk.indexOf("ensureDbOpen(basePath)");
+  const reserveIdx = branchChunk.indexOf("nextMilestoneIdReserved");
+
+  assert.ok(ensureIdx > -1, "skip branch should open the project DB");
+  assert.ok(reserveIdx > -1, "skip branch should reserve the next milestone ID");
+  assert.ok(ensureIdx < reserveIdx, "project DB must be opened before milestone ID reservation");
+});

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

@@ -4,7 +4,7 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { appendOverride, loadActiveOverrides } from "../files.ts";
@@ -73,6 +73,22 @@ describe("steer worktree path resolution (#3476)", () => {
     assert.equal(result, null, "returns null for worktree without .git file");
   });
 
+  test("getAutoWorktreePath returns null when .git is a directory", () => {
+    mkdirSync(join(worktreePath, ".git"), { recursive: true });
+
+    const result = getAutoWorktreePath(projectRoot, "M001");
+
+    assert.equal(result, null, "returns null for standalone .git directories");
+  });
+
+  test("getAutoWorktreePath returns null when .git file is not a gitdir pointer", () => {
+    writeFileSync(join(worktreePath, ".git"), "not-a-gitdir\n", "utf-8");
+
+    const result = getAutoWorktreePath(projectRoot, "M001");
+
+    assert.equal(result, null, "returns null for invalid .git files");
+  });
+
   test("override routing: inactive worktree directory should not receive overrides", async () => {
     // Simulate the handleSteer path-resolution logic:
     // When no auto-mode is running, even if a worktree dir exists,

package/src/resources/extensions/gsd/tests/system-context-message-routing.test.ts

@@ -0,0 +1,101 @@
+// GSD bootstrap + system-context-message-routing.test — regression coverage
+// for #5019. `memoryBlock` is FTS-queried against the user prompt and changes
+// per call; embedding it in the cached system prefix invalidates Anthropic
+// prompt-cache hits on every request. The fix routes memory through the
+// existing context-message channel (volatile user-message suffix) and combines
+// it with any active guided-execute or forensics injection.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { buildContextMessage } from "../bootstrap/system-context.ts";
+
+describe("buildContextMessage (#5019 — memory routing)", () => {
+  test("returns null when nothing to inject", () => {
+    const result = buildContextMessage({
+      memoryBlock: "",
+      injection: null,
+      forensicsInjection: null,
+    });
+    assert.equal(result, null);
+  });
+
+  test("whitespace-only memoryBlock counts as empty", () => {
+    const result = buildContextMessage({
+      memoryBlock: "   \n\n   ",
+      injection: null,
+      forensicsInjection: null,
+    });
+    assert.equal(result, null);
+  });
+
+  test("memory-only path emits gsd-memory message with trimmed content", () => {
+    const result = buildContextMessage({
+      memoryBlock: "\n\n[MEMORY]\nrule one\nrule two\n\n",
+      injection: null,
+      forensicsInjection: null,
+    });
+    assert.ok(result, "expected a context message");
+    assert.equal(result.customType, "gsd-memory");
+    assert.equal(result.content, "[MEMORY]\nrule one\nrule two");
+    assert.equal(result.display, false);
+  });
+
+  test("guided-execute injection alone emits gsd-guided-context", () => {
+    const result = buildContextMessage({
+      memoryBlock: "",
+      injection: "[GUIDED]\nexecute T01",
+      forensicsInjection: null,
+    });
+    assert.ok(result);
+    assert.equal(result.customType, "gsd-guided-context");
+    assert.equal(result.content, "[GUIDED]\nexecute T01");
+  });
+
+  test("forensics injection alone emits gsd-forensics", () => {
+    const result = buildContextMessage({
+      memoryBlock: "",
+      injection: null,
+      forensicsInjection: "[FORENSICS]\ninvestigation context",
+    });
+    assert.ok(result);
+    assert.equal(result.customType, "gsd-forensics");
+    assert.equal(result.content, "[FORENSICS]\ninvestigation context");
+  });
+
+  test("memory + guided injection: memory prepended, customType is gsd-guided-context", () => {
+    const result = buildContextMessage({
+      memoryBlock: "[MEMORY]\nrule one",
+      injection: "[GUIDED]\nexecute T01",
+      forensicsInjection: null,
+    });
+    assert.ok(result);
+    assert.equal(result.customType, "gsd-guided-context");
+    assert.equal(result.content, "[MEMORY]\nrule one\n\n[GUIDED]\nexecute T01");
+  });
+
+  test("memory + forensics: memory prepended, customType is gsd-forensics", () => {
+    const result = buildContextMessage({
+      memoryBlock: "[MEMORY]\nrule one",
+      injection: null,
+      forensicsInjection: "[FORENSICS]\ninvestigation context",
+    });
+    assert.ok(result);
+    assert.equal(result.customType, "gsd-forensics");
+    assert.equal(result.content, "[MEMORY]\nrule one\n\n[FORENSICS]\ninvestigation context");
+  });
+
+  test("guided takes precedence over forensics when both are somehow present", () => {
+    // The caller in buildBeforeAgentStartResult already gates forensics on
+    // `!injection`, but the helper's documented priority is guided > forensics.
+    // Test the contract directly so a future refactor can't silently flip it.
+    const result = buildContextMessage({
+      memoryBlock: "",
+      injection: "[GUIDED]",
+      forensicsInjection: "[FORENSICS]",
+    });
+    assert.ok(result);
+    assert.equal(result.customType, "gsd-guided-context");
+    assert.equal(result.content, "[GUIDED]");
+  });
+});

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

@@ -107,6 +107,50 @@ test("profile: resolveProfileDefaults exists and handles all 4 tiers", () => {
   );
 });
 
+test("profile: PROFILE_TIER_MAP defines tier intentions for all profiles", async () => {
+  const { getProfileTierMap } = await import("../preferences-models.ts");
+  const profileMaps = {
+    budget: getProfileTierMap("budget"),
+    balanced: getProfileTierMap("balanced"),
+    quality: getProfileTierMap("quality"),
+  };
+
+  assert.deepEqual(
+    Object.keys(profileMaps).sort(),
+    ["balanced", "budget", "quality"],
+    "PROFILE_TIER_MAP should include the profile default tiers",
+  );
+
+  const expectedPhaseKeys = ["completion", "execution", "execution_simple", "planning", "research", "subagent"];
+  const validTiers = new Set(["light", "standard", "heavy"]);
+  for (const [profile, tierMap] of Object.entries(profileMaps)) {
+    assert.deepEqual(
+      Object.keys(tierMap).sort(),
+      expectedPhaseKeys,
+      `${profile} should define all model-bearing phases`,
+    );
+    for (const [phase, tier] of Object.entries(tierMap)) {
+      assert.ok(validTiers.has(tier), `${profile}.${phase} should be a tier name`);
+      assert.ok(!tier.includes("claude-"), `${profile}.${phase} should not be a model ID`);
+    }
+  }
+});
+
+test("profile: resolveProfileDefaults is provider-agnostic — picks OpenAI when only OpenAI is available", async () => {
+  // Behavioral check: with only OpenAI models in the available list, no slot
+  // should resolve to a claude-* model. Source-grep cannot prove this — only
+  // exercising the function with a controlled available-model list can.
+  const { resolveProfileDefaults } = await import("../preferences-models.ts");
+  const defaults = resolveProfileDefaults("balanced", ["gpt-4o", "gpt-4o-mini"]);
+  assert.ok(defaults.models, "balanced profile should populate models");
+  for (const [phase, modelId] of Object.entries(defaults.models!)) {
+    assert.ok(
+      typeof modelId === "string" && !String(modelId).startsWith("claude-"),
+      `${phase} resolved to ${modelId} but only OpenAI is available`,
+    );
+  }
+});
+
 test("profile: budget profile sets phase skips to true", () => {
   // Extract the budget case block
   const budgetIdx = preferencesSrc.indexOf('case "budget":');
@@ -222,11 +266,14 @@ test("merge: mergePreferences handles phases with spread", () => {
 // Subagent Model Routing
 // ═══════════════════════════════════════════════════════════════════════════
 
-test("subagent: budget profile sets subagent model", () => {
-  const budgetIdx = preferencesSrc.indexOf('case "budget":');
-  const balancedIdx = preferencesSrc.indexOf('case "balanced":');
+test("subagent: budget profile assigns light tier for subagent", () => {
+  // PROFILE_TIER_MAP.budget.subagent should be "light"
+  const tierMapIdx = preferencesSrc.indexOf("PROFILE_TIER_MAP");
+  const budgetIdx = preferencesSrc.indexOf("budget:", tierMapIdx);
+  const balancedIdx = preferencesSrc.indexOf("balanced:", tierMapIdx);
   const budgetBlock = preferencesSrc.slice(budgetIdx, balancedIdx);
-  assert.ok(budgetBlock.includes("subagent:"), "budget profile should set subagent model");
+  assert.ok(budgetBlock.includes("subagent:"), "budget profile should define subagent tier");
+  assert.ok(budgetBlock.includes('"light"'), "budget subagent should use light tier");
 });
 
 test("subagent: resolveModelWithFallbacksForUnit handles subagent unit types", () => {