gsd-pi 2.78.0 → 2.78.1-dev.9d08d820b

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", () => {

package/src/resources/extensions/gsd/tests/turn-epoch.test.ts

@@ -144,19 +144,10 @@ test("recoverTimedOutUnit: no top-level bumpTurnGeneration — steering branches
   );
 });
 
-test("recoverTimedOutUnit: bumpAndResolveSynthetic appears exactly four times (one per advance branch)", async () => {
-  const fs = await import("node:fs");
-  const path = await import("node:path");
-  const url = await import("node:url");
-  const here = path.dirname(url.fileURLToPath(import.meta.url));
-  const src = fs.readFileSync(
-    path.join(here, "..", "auto-timeout-recovery.ts"),
-    "utf-8",
-  );
-  const matches = src.match(/bumpAndResolveSynthetic\s*\(/g) ?? [];
-  assert.equal(
-    matches.length,
-    4,
-    `expected 4 advance-branch supersede sites (durableComplete, execute-task-exhausted, artifact-already-exists, non-execute-exhausted); found ${matches.length}`,
-  );
-});
+// Removed: source-grep count of `bumpAndResolveSynthetic\s*\(` occurrences.
+// A literal 4 hardcodes the current branch shape, not behaviour. The
+// behavioural invariant — "advance branches supersede atomically; non-advance
+// branches do not bump" — is enforced by the previous test (no direct
+// bumpTurnGeneration calls) plus the per-branch behavioural tests above
+// (`recoverTimedOutUnit: …`). Refactors that split a branch into two would
+// trip a count test without affecting correctness. Refs #4851.

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

@@ -199,8 +199,8 @@ test("#4934: every manifest declares a tools policy", () => {
   }
 });
 
-test("#4934: tools.mode is one of the four declared policies", () => {
-  const validModes = new Set(["all", "read-only", "planning", "docs"]);
+test("#4934: tools.mode is one of the declared policies", () => {
+  const validModes = new Set(["all", "read-only", "planning", "planning-dispatch", "docs"]);
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const mode = (manifest as { tools: { mode: string } }).tools.mode;
     assert.ok(
@@ -219,7 +219,42 @@ test('#4934: only execute-task and reactive-execute may use tools.mode "all" (fu
         allowedAllUnits.has(unitType),
         `manifest "${unitType}" declares tools.mode = "all" but is not on the execute-track. ` +
         'Only execute-task and reactive-execute should have full source write access; ' +
-        'planning/discuss/research units must use "planning" (or "docs" for rewrite-docs).',
+        'planning/discuss/research units must use "planning" or "planning-dispatch" (or "docs" for rewrite-docs).',
+      );
+    }
+  }
+});
+
+test('planning-dispatch mode is reserved for slice-level decomposition and completion units', () => {
+  const allowedDispatchUnits = new Set([
+    "plan-slice",
+    "refine-slice",
+    "complete-slice",
+    "complete-milestone",
+  ]);
+  for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
+    const mode = (manifest as { tools: { mode: string } }).tools.mode;
+    if (mode === "planning-dispatch") {
+      assert.ok(
+        allowedDispatchUnits.has(unitType),
+        `manifest "${unitType}" declares tools.mode = "planning-dispatch" but is not on the dispatch-allowed allowlist. ` +
+        'planning-dispatch is intentionally narrow — extend the allowlist consciously when a new unit type genuinely benefits from subagent delegation.',
+      );
+    }
+  }
+});
+
+test('planning-dispatch manifests declare non-empty allowedSubagents lists', () => {
+  for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
+    if (manifest.tools.mode !== "planning-dispatch") continue;
+    assert.ok(
+      Array.isArray(manifest.tools.allowedSubagents) && manifest.tools.allowedSubagents.length > 0,
+      `manifest "${unitType}" has planning-dispatch policy but no allowedSubagents — explicit allowlist is required for runtime dispatch gating`,
+    );
+    for (const agent of manifest.tools.allowedSubagents) {
+      assert.ok(
+        typeof agent === "string" && agent.length > 0,
+        `manifest "${unitType}" has empty/invalid allowedSubagents entry: ${JSON.stringify(agent)}`,
       );
     }
   }

package/src/resources/extensions/gsd/tests/unstructured-continue-context-injection.test.ts

@@ -76,13 +76,11 @@ describe("#3615 — structural: fallback exists with correct guards", () => {
     );
   });
 
-  test("only one return null at the end", () => {
-    const returnNulls = fnBody.match(/return null;/g);
-    assert.ok(
-      returnNulls && returnNulls.length === 1,
-      `expected exactly 1 'return null' (at end after fallback), got ${returnNulls?.length ?? 0}`,
-    );
-  });
+  // Removed: source-grep count of `return null;` occurrences. The behaviour
+  // we care about ("function returns null only when no auto-dispatch /
+  // guided-resume / fallback path matches") is exercised by the behavioural
+  // tests below — counting literal `return null;` tokens encodes statement
+  // shape, not contract. Refs #4851.
 });
 
 // ── Behavioral tests: RESUME_INTENT_PATTERNS ────────────────────────

package/src/resources/extensions/gsd/tests/uok-gitops-turn-action.test.ts

@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { execSync } from "node:child_process";
-import { runTurnGitAction } from "../git-service.ts";
+import { handleTurnGitActionError, runTurnGitAction } from "../git-service.ts";
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
@@ -83,3 +83,17 @@ test("uok gitops turn action commit creates commit with unit trailer", () => {
     rmSync(repo, { recursive: true, force: true });
   }
 });
+
+test("uok gitops turn action rethrows infrastructure failures", () => {
+  const err = Object.assign(new Error("ENFILE: file table overflow"), { code: "ENFILE" });
+
+  assert.throws(() => handleTurnGitActionError("commit", err), (thrown) => thrown === err);
+});
+
+test("uok gitops turn action keeps non-infrastructure git failures recoverable", () => {
+  const result = handleTurnGitActionError("commit", new Error("nothing to commit"));
+
+  assert.equal(result.action, "commit");
+  assert.equal(result.status, "failed");
+  assert.equal(result.error, "nothing to commit");
+});

package/src/resources/extensions/gsd/tests/visualizer-overlay.test.ts

@@ -13,7 +13,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import { GSDVisualizerOverlay } from "../visualizer-overlay.ts";
+import { GSDVisualizerOverlay, TAB_COUNT } from "../visualizer-overlay.ts";
 
 function makeTui() {
   const renders: number[] = [];
@@ -93,16 +93,16 @@ test("overlay switches tabs via 1–9,0 digit keys", (t) => {
 
 test("overlay Tab key cycles forward and wraps around at TAB_COUNT", (t) => {
   const { overlay } = makeOverlay(t);
-  overlay.activeTab = 9;
+  overlay.activeTab = TAB_COUNT - 1;
   overlay.handleInput("\t");
-  assert.equal(overlay.activeTab, 0, "Tab wraps from 9 back to 0");
+  assert.equal(overlay.activeTab, 0, `Tab wraps from ${TAB_COUNT - 1} back to 0`);
 });
 
 test("overlay Shift+Tab cycles backward and wraps", (t) => {
   const { overlay } = makeOverlay(t);
   overlay.activeTab = 0;
   overlay.handleInput("\u001b[Z");
-  assert.equal(overlay.activeTab, 9, "Shift+Tab wraps from 0 to 9");
+  assert.equal(overlay.activeTab, TAB_COUNT - 1, `Shift+Tab wraps from 0 to ${TAB_COUNT - 1}`);
 });
 
 // ─── Filter mode ─────────────────────────────────────────────────────────
@@ -331,9 +331,9 @@ test("overlay footer hint mentions tab navigation, filter, scroll, and help", (t
 
 // ─── Scroll offsets array is sized to TAB_COUNT ──────────────────────────
 
-test("overlay scrollOffsets array has one slot per tab (10 tabs total)", (t) => {
+test("overlay scrollOffsets array has one slot per tab", (t) => {
   const { overlay } = makeOverlay(t);
-  assert.equal(overlay.scrollOffsets.length, 10, "scrollOffsets sized to TAB_COUNT=10");
+  assert.equal(overlay.scrollOffsets.length, TAB_COUNT, "scrollOffsets sized to TAB_COUNT");
   assert.ok(overlay.scrollOffsets.every((n: number) => n === 0), "initialized to zero");
 });