gsd-pi 2.78.0-dev.aeeb2ca00 → 2.78.1-dev.84a383f51

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -236,6 +236,20 @@ test("valid values pass through correctly", () => {
   assert.equal(p3.auto_supervisor?.model, "claude-opus-4-6");
 });
 
+test("min_request_interval_ms floors decimals and rejects timer overflow values", () => {
+  const valid = validatePreferences({ min_request_interval_ms: 1000.9 });
+  assert.equal(valid.errors.length, 0);
+  assert.equal(valid.preferences.min_request_interval_ms, 1000);
+
+  const max = validatePreferences({ min_request_interval_ms: 2_147_483_647 });
+  assert.equal(max.errors.length, 0);
+  assert.equal(max.preferences.min_request_interval_ms, 2_147_483_647);
+
+  const tooHigh = validatePreferences({ min_request_interval_ms: 2_147_483_648 });
+  assert.ok(tooHigh.errors.some(e => e.includes("min_request_interval_ms must be a non-negative number <= 2147483647")));
+  assert.equal(tooHigh.preferences.min_request_interval_ms, undefined);
+});
+
 test("mixed valid/invalid/unknown keys handled correctly", () => {
   const { preferences, errors, warnings } = validatePreferences({
     uat_dispatch: true, totally_made_up: "value", budget_ceiling: "garbage",
@@ -246,6 +260,71 @@ test("mixed valid/invalid/unknown keys handled correctly", () => {
   assert.equal(preferences.budget_ceiling, undefined);
 });
 
+test("disabled_model_providers validates and normalizes string arrays", () => {
+  const { preferences, errors } = validatePreferences({
+    disabled_model_providers: ["google-gemini-cli", "  google-gemini-cli  ", "openai-codex", "   "],
+  });
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.disabled_model_providers, ["google-gemini-cli", "openai-codex"]);
+});
+
+test("disabled_model_providers rejects non-array values", () => {
+  const { errors } = validatePreferences({ disabled_model_providers: "google-gemini-cli" as any });
+  assert.ok(errors.some((e) => e.includes("disabled_model_providers must be an array of strings")));
+});
+
+test("loadEffectiveGSDPreferences preserves disabled_model_providers across merge layers", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-disabled-provider-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-disabled-provider-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+
+    writeFileSync(
+      join(tempGsdHome, "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "disabled_model_providers:",
+        "  - google-gemini-cli",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "disabled_model_providers:",
+        "  - openai-codex",
+        "  - google-gemini-cli",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const loaded = loadEffectiveGSDPreferences();
+    assert.notEqual(loaded, null);
+    assert.deepEqual(
+      loaded!.preferences.disabled_model_providers,
+      ["google-gemini-cli", "openai-codex"],
+    );
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 // ── Wizard fields ────────────────────────────────────────────────────────────
 
 test("budget fields validate correctly", () => {
@@ -683,6 +762,54 @@ test("loadEffectiveGSDPreferences exposes slice_parallel prefs to runtime caller
   }
 });
 
+test("loadEffectiveGSDPreferences merges min_request_interval_ms with project overriding global (#2996)", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-rate-limit-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-rate-limit-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+
+    writeFileSync(
+      join(tempGsdHome, "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "min_request_interval_ms: 250",
+        "budget_ceiling: 45",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "min_request_interval_ms: 100",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const loaded = loadEffectiveGSDPreferences();
+    assert.notEqual(loaded, null);
+    assert.equal(loaded!.preferences.min_request_interval_ms, 100);
+    assert.equal(loaded!.preferences.budget_ceiling, 45);
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("preferences paths use canonical uppercase filenames", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;

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

@@ -93,4 +93,20 @@ describe('register-hooks session_before_compact (#3696)', () => {
       'session_before_compact should not check isAutoPaused',
     );
   });
+
+  test('session_before_compact does not gate checkpointing to executing phase (#4258)', () => {
+    const compactIdx = registerHooksSrc.indexOf('session_before_compact');
+    assert.ok(compactIdx > -1, 'session_before_compact hook should exist');
+
+    const preCheckpointSection = registerHooksSrc.slice(
+      compactIdx,
+      registerHooksSrc.indexOf('const sliceDir', compactIdx),
+    );
+
+    const normalized = preCheckpointSection.replace(/\/\/.*$/gm, '');
+    assert.ok(
+      !/if\s*\(\s*state\.phase\s*!==\s*['"]executing['"]\s*\)\s*\{?\s*return\b/.test(normalized),
+      'session_before_compact should not early-return on non-executing phases',
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -103,6 +103,13 @@ test("classifyError detects Codex server_error from extracted message", () => {
   assert.ok("retryAfterMs" in result && result.retryAfterMs === 30_000);
 });
 
+test("classifyError detects stream INTERNAL_ERROR received from peer as transient server", () => {
+  const result = classifyError("stream error: stream ID 75; INTERNAL_ERROR; received from peer");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "server");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 30_000);
+});
+
 test("classifyError detects overloaded error", () => {
   const result = classifyError("overloaded_error: Overloaded");
   assert.ok(isTransient(result));

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/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/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]");
+  });
+});