gsd-pi 2.78.0 → 2.78.1-dev.8a893322c

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

package/src/resources/extensions/gsd/tests/worktree-symlink-removal.test.ts

@@ -20,7 +20,7 @@ import {
   listWorktrees,
   worktreePath,
 } from "../worktree-manager.ts";
-import { describe, test } from 'node:test';
+import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
 
@@ -28,37 +28,41 @@ function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
 
-// Set up a test repo with .gsd/ as a symlink to an external directory,
-// mimicking the external state directory layout (~/.gsd/projects/<hash>/).
-// Resolve tmpdir to handle macOS /tmp -> /private/var/... symlink.
-const realTmp = realpathSync(tmpdir());
-const base = mkdtempSync(join(realTmp, "gsd-wt-symlink-test-"));
-const externalState = mkdtempSync(join(realTmp, "gsd-wt-symlink-ext-"));
-
-run("git init -b main", base);
-run('git config user.name "Test"', base);
-run('git config user.email "test@example.com"', base);
-
-// Create external state directory structure
-mkdirSync(join(externalState, "worktrees"), { recursive: true });
-
-// Create .gsd as a symlink to the external state directory
-symlinkSync(externalState, join(base, ".gsd"));
-
-// Verify the symlink is in place
-assert.ok(existsSync(join(base, ".gsd")), ".gsd symlink exists");
-assert.ok(
-  realpathSync(join(base, ".gsd")) === externalState,
-  ".gsd resolves to external state dir",
-);
+test('worktree-symlink-removal removes the git-registered symlink target safely', (t) => {
+  console.log("\n=== #1852: removeWorktree with symlinked .gsd/ ===");
 
-// Create initial commit so we have a valid repo
-writeFileSync(join(base, "README.md"), "# Test\n", "utf-8");
-run("git add .", base);
-run('git commit -m "init"', base);
+  // Set up a test repo with .gsd/ as a symlink to an external directory,
+  // mimicking the external state directory layout (~/.gsd/projects/<hash>/).
+  // Resolve tmpdir to handle macOS /tmp -> /private/var/... symlink.
+  const realTmp = realpathSync(tmpdir());
+  const base = mkdtempSync(join(realTmp, "gsd-wt-symlink-test-"));
+  const externalState = mkdtempSync(join(realTmp, "gsd-wt-symlink-ext-"));
+  t.after(() => {
+    rmSync(base, { recursive: true, force: true });
+    rmSync(externalState, { recursive: true, force: true });
+  });
+
+  run("git init -b main", base);
+  run('git config user.name "Test"', base);
+  run('git config user.email "test@example.com"', base);
+
+  // Create external state directory structure
+  mkdirSync(join(externalState, "worktrees"), { recursive: true });
+
+  // Create .gsd as a symlink to the external state directory
+  symlinkSync(externalState, join(base, ".gsd"));
+
+  // Verify the symlink is in place
+  assert.ok(existsSync(join(base, ".gsd")), ".gsd symlink exists");
+  assert.ok(
+    realpathSync(join(base, ".gsd")) === externalState,
+    ".gsd resolves to external state dir",
+  );
 
-describe('worktree-symlink-removal', async () => {
-  console.log("\n=== #1852: removeWorktree with symlinked .gsd/ ===");
+  // Create initial commit so we have a valid repo
+  writeFileSync(join(base, "README.md"), "# Test\n", "utf-8");
+  run("git add .", base);
+  run('git commit -m "init"', base);
 
   // Create a worktree — git will resolve the symlink and register
   // the worktree at the external path
@@ -127,7 +131,4 @@ describe('worktree-symlink-removal', async () => {
   const listed = listWorktrees(base);
   assert.deepStrictEqual(listed.length, 0, "no worktrees listed after removal");
 
-  // Cleanup
-  rmSync(base, { recursive: true, force: true });
-  rmSync(externalState, { recursive: true, force: true });
 });

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

@@ -255,6 +255,14 @@ describe('worktree', async () => {
     "returns unchanged for non-worktree path",
   );
 
+  const nestedRepoDir = join(base, "packages", "demo");
+  mkdirSync(nestedRepoDir, { recursive: true });
+  assert.deepStrictEqual(
+    normalizePath(resolveProjectRoot(nestedRepoDir)),
+    normalizePath(base),
+    "resolves normal repo subdirectories to the project root",
+  );
+
   // Without GSD_PROJECT_ROOT, direct layout with nested subdirs
   assert.deepStrictEqual(
     resolveProjectRoot("/data/.gsd/worktrees/M003/nested"),

package/src/resources/extensions/gsd/tests/write-gate-planning-unit.test.ts

@@ -9,11 +9,21 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { join, sep } from 'node:path';
 
-import { shouldBlockPlanningUnit } from '../bootstrap/write-gate.ts';
+import { ALLOWED_PLANNING_DISPATCH_AGENTS, shouldBlockPlanningUnit } from '../bootstrap/write-gate.ts';
+import { extractSubagentAgentClasses } from '../bootstrap/subagent-input.ts';
+import { isDeterministicPolicyError } from '../auto-tool-tracking.ts';
 import type { ToolsPolicy } from '../unit-context-manifest.ts';
 
 const BASE = join('/tmp', 'fake-project');
 const PLANNING: ToolsPolicy = { mode: 'planning' };
+const PLANNING_DISPATCH: ToolsPolicy = {
+  mode: 'planning-dispatch',
+  allowedSubagents: [...ALLOWED_PLANNING_DISPATCH_AGENTS],
+};
+const PLANNING_DISPATCH_REVIEW: ToolsPolicy = {
+  mode: 'planning-dispatch',
+  allowedSubagents: ['reviewer', 'security', 'tester'],
+};
 const READ_ONLY: ToolsPolicy = { mode: 'read-only' };
 const ALL: ToolsPolicy = { mode: 'all' };
 const DOCS: ToolsPolicy = {
@@ -36,6 +46,20 @@ test('planning-unit: blocks edit to user source (the b23 forensic)', () => {
   assert.match(r.reason!, /discuss-milestone/);
 });
 
+test('planning-unit: deterministic block reason is suitable for retry short-circuiting', () => {
+  const r = shouldBlockPlanningUnit(
+    'edit',
+    'src/main.ts',
+    BASE,
+    'discuss-milestone',
+    PLANNING,
+  );
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /HARD BLOCK/);
+  assert.match(r.reason!, /tools-policy/);
+  assert.strictEqual(isDeterministicPolicyError(r.reason!), true);
+});
+
 test('planning-unit: blocks write to user source via relative path', () => {
   const r = shouldBlockPlanningUnit('write', 'src/main.ts', BASE, 'plan-milestone', PLANNING);
   assert.strictEqual(r.block, true);
@@ -128,6 +152,112 @@ test('planning-unit: blocks task tool (alt subagent name)', () => {
   assert.strictEqual(r.block, true);
 });
 
+test('planning-dispatch: allows subagent dispatch (delegated recon/planner during slice planning)', () => {
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'plan-slice', PLANNING_DISPATCH, ['scout']);
+  assert.strictEqual(r.block, false);
+});
+
+test('planning-dispatch: allows task dispatch (delegated recon/planner during slice planning)', () => {
+  const r = shouldBlockPlanningUnit('task', '', BASE, 'plan-slice', PLANNING_DISPATCH, ['planner']);
+  assert.strictEqual(r.block, false);
+});
+
+test('planning-dispatch: extracts subagent classes from single, parallel, and chain inputs', () => {
+  assert.deepEqual(extractSubagentAgentClasses({ agent: ' scout ' }), ['scout']);
+  assert.deepEqual(
+    extractSubagentAgentClasses({ tasks: [{ agent: 'planner' }, { agent: ' tester ' }] }),
+    ['planner', 'tester'],
+  );
+  assert.deepEqual(
+    extractSubagentAgentClasses({ chain: [{ agent: 'reviewer' }, { agent: 'security' }] }),
+    ['reviewer', 'security'],
+  );
+});
+
+test('planning-dispatch: blocks subagent dispatch when agentClasses is undefined (stale caller shim)', () => {
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'plan-slice', PLANNING_DISPATCH, undefined);
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /stale caller/);
+  assert.match(r.reason!, /tools-policy "planning-dispatch"/);
+});
+
+test('planning-dispatch: allows explicitly empty agent classes for downstream validation', () => {
+  const emptyClasses = extractSubagentAgentClasses({});
+  assert.deepEqual(emptyClasses, []);
+  const empty = shouldBlockPlanningUnit('subagent', '', BASE, 'plan-slice', PLANNING_DISPATCH, emptyClasses);
+  assert.strictEqual(empty.block, false);
+});
+
+test('planning-dispatch: allows all globally allowed specialists when listed by policy', () => {
+  const policy: ToolsPolicy = {
+    mode: 'planning-dispatch',
+    allowedSubagents: [...ALLOWED_PLANNING_DISPATCH_AGENTS],
+  };
+  const r = shouldBlockPlanningUnit(
+    'subagent',
+    '',
+    BASE,
+    'complete-milestone',
+    policy,
+    [...ALLOWED_PLANNING_DISPATCH_AGENTS],
+  );
+  assert.strictEqual(r.block, false);
+});
+
+test('planning-dispatch: blocks implementation-tier agent', () => {
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'plan-slice', PLANNING_DISPATCH, ['worker']);
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /"worker"/);
+  assert.match(r.reason!, /read-only specialists/);
+});
+
+test('planning-dispatch: blocks globally disallowed agent even if listed by policy', () => {
+  const policy: ToolsPolicy = {
+    mode: 'planning-dispatch',
+    allowedSubagents: ['refactorer'],
+  };
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'refine-slice', policy, ['refactorer']);
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /"refactorer"/);
+  assert.match(r.reason!, /read-only specialists/);
+  assert.doesNotMatch(r.reason!, /ToolsPolicy\.allowedSubagents|permitted agents for this unit/);
+});
+
+test('planning-dispatch: blocks mixed batch containing a disallowed agent', () => {
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'plan-slice', PLANNING_DISPATCH, ['scout', 'worker']);
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /"worker"/);
+});
+
+test('planning-dispatch: allows review-tier agent under closeout policy', () => {
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'complete-slice', PLANNING_DISPATCH_REVIEW, ['reviewer']);
+  assert.strictEqual(r.block, false);
+});
+
+test('planning-dispatch: blocks recon agent under closeout policy', () => {
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'complete-slice', PLANNING_DISPATCH_REVIEW, ['scout']);
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /"scout"/);
+  assert.match(r.reason!, /ToolsPolicy\.allowedSubagents|permitted agents for this unit/);
+  assert.doesNotMatch(r.reason!, /read-only specialists/);
+});
+
+test('planning-dispatch: still blocks writes to user source (write isolation preserved)', () => {
+  const r = shouldBlockPlanningUnit('write', join(BASE, 'src', 'main.ts'), BASE, 'plan-slice', PLANNING_DISPATCH);
+  assert.strictEqual(r.block, true);
+});
+
+test('planning-dispatch: still allows writes inside .gsd/', () => {
+  const r = shouldBlockPlanningUnit(
+    'write',
+    join(BASE, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'PLAN.md'),
+    BASE,
+    'plan-slice',
+    PLANNING_DISPATCH,
+  );
+  assert.strictEqual(r.block, false);
+});
+
 // ─── planning mode: pass-through tools ────────────────────────────────────
 
 test('planning-unit: allows read tool', () => {

package/src/resources/extensions/gsd/tools/memory-tools.ts

@@ -96,8 +96,24 @@ export function executeMemoryCapture(params: MemoryCaptureParams): ToolExecution
   const tags = normalizeTags(params.tags);
 
   const structuredFields = normalizeStructuredFields(params.structuredFields);
-  const id = createMemory({ category, content, confidence, scope, tags, structuredFields });
+  let id: string | null;
+  try {
+    id = createMemory({ category, content, confidence, scope, tags, structuredFields });
+  } catch (err) {
+    // Surface the underlying SQL message (e.g. "database disk image is
+    // malformed", "no such table: memories") so the operator gets the
+    // actionable signal instead of an opaque "create_failed". See #4967.
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      content: [{ type: "text", text: `Error: failed to create memory: ${message}` }],
+      details: { operation: "memory_capture", error: message },
+      isError: true,
+    };
+  }
   if (!id) {
+    // DB unavailable or adapter missing — distinct from the SQL-error path
+    // above. Keep the legacy create_failed token here so any consumers that
+    // explicitly key on the unavailable case continue to work.
     return {
       content: [{ type: "text", text: "Error: failed to create memory." }],
       details: { operation: "memory_capture", error: "create_failed" },

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

@@ -93,10 +93,10 @@ export type PreferencesPolicy = "none" | "active-only" | "full";
 /**
  * Tool-access policy per unit type (#4934).
  *
- * Declarative-only in this PR — runtime enforcement (write-gate.ts predicate
- * + dispatch-time isolation) lands in follow-up PRs. The shape is the
- * agreement between manifest authors and enforcement; surfacing it now lets
- * reviewers ratify per-unit policy intent before any blocking logic ships.
+ * Runtime-enforced by the GSD write gate for active auto-mode units. The
+ * manifest declares the allowed tool surface; register-hooks.ts resolves the
+ * active unit's manifest before each tool call and write-gate.ts rejects
+ * violations before the tool executes.
  *
  * Modes:
  *   - "all"        — Read + Edit/Write/MultiEdit/NotebookEdit + Bash + Task.
@@ -111,6 +111,12 @@ export type PreferencesPolicy = "none" | "active-only" | "full";
  *                    Task subagent dispatch denied. Catches the bug class
  *                    where a discuss-milestone turn modifies user source
  *                    files (forensics: ~/Github/test-apps/b23, #4934).
+ *   - "planning-dispatch"
+ *                  — Same read + .gsd/** write + safe-Bash surface as
+ *                    "planning", but permits controlled subagent dispatch
+ *                    only to the agents listed in the ToolsPolicy
+ *                    `allowedSubagents` field. See write-gate.ts for the
+ *                    runtime agent-class enforcement details.
  *   - "docs"       — Read tools always; writes restricted to .gsd/** AND
  *                    the explicit `allowedPathGlobs` set; Bash safe-allowlist;
  *                    no subagents. Reserved for rewrite-docs, which legitimately
@@ -125,6 +131,7 @@ export type ToolsPolicy =
   | { readonly mode: "all" }
   | { readonly mode: "read-only" }
   | { readonly mode: "planning" }
+  | { readonly mode: "planning-dispatch"; readonly allowedSubagents: readonly string[] }
   | { readonly mode: "docs"; readonly allowedPathGlobs: readonly string[] };
 
 // ─── Computed-artifact registry (#4924 v2 contract) ───────────────────────
@@ -214,10 +221,10 @@ export interface UnitContextManifest {
   /** Preferences block policy. */
   readonly preferences: PreferencesPolicy;
   /**
-   * Tool-access policy (#4934). Declarative in this PR; runtime enforcement
-   * (path-scoped write blocking + subagent denial + bash allowlist) lands
-   * in follow-ups. Required on every manifest so missing entries fail loud
-   * via the CI invariant test rather than defaulting to "all" silently.
+   * Tool-access policy (#4934). Runtime enforcement covers path-scoped write
+   * blocking, subagent denial, and bash allowlisting for active auto-mode
+   * units. Required on every manifest so missing entries fail loud via the CI
+   * invariant test rather than defaulting to "all" silently.
    */
   readonly tools: ToolsPolicy;
   /** Artifact handling: inline (full body), excerpt (compact), or on-demand (path only). */
@@ -268,6 +275,18 @@ const COMMON_BUDGET_SMALL = 250_000;    // ~65K tokens
 
 const TOOLS_ALL: ToolsPolicy = { mode: "all" };
 const TOOLS_PLANNING: ToolsPolicy = { mode: "planning" };
+// Like TOOLS_PLANNING but permits dispatch to read-only recon/planning
+// specialists. Runtime-enforced by write-gate.ts before the subagent tool runs.
+const TOOLS_PLANNING_DISPATCH_RECON: ToolsPolicy = {
+  mode: "planning-dispatch",
+  allowedSubagents: ["scout", "planner"],
+};
+// Like TOOLS_PLANNING_DISPATCH_RECON, but for closeout units that fan out
+// verification work to review-tier specialists.
+const TOOLS_PLANNING_DISPATCH_REVIEW: ToolsPolicy = {
+  mode: "planning-dispatch",
+  allowedSubagents: ["reviewer", "security", "tester"],
+};
 const TOOLS_DOCS: ToolsPolicy = {
   mode: "docs",
   // Globs are resolved relative to project basePath. The set is intentionally
@@ -376,7 +395,11 @@ export const UNIT_MANIFESTS: Record<UnitType, UnitContextManifest> = {
     memory: "prompt-relevant",
     codebaseMap: false,
     preferences: "active-only",
-    tools: TOOLS_PLANNING,
+    // planning-dispatch: completion is a high-leverage place to fan out to
+    // reviewer / security / tester subagents. They read the diff and report
+    // findings; they do not write user source. Write isolation to .gsd/ is
+    // preserved.
+    tools: TOOLS_PLANNING_DISPATCH_REVIEW,
     artifacts: {
       // #4780 landed slice-summary as excerpt for this unit; phase 2 of
       // the architecture will read this manifest as the source of truth
@@ -409,7 +432,10 @@ export const UNIT_MANIFESTS: Record<UnitType, UnitContextManifest> = {
     memory: "prompt-relevant",
     codebaseMap: true,
     preferences: "active-only",
-    tools: TOOLS_PLANNING,
+    // planning-dispatch: allows subagent dispatch so the planner can fan out
+    // to scout for codebase recon and to planner/decompose-style specialists
+    // for sub-decomposition. Write-isolation to .gsd/ is preserved.
+    tools: TOOLS_PLANNING_DISPATCH_RECON,
     artifacts: {
       inline: ["roadmap", "slice-research", "dependency-summaries", "requirements", "decisions", "templates"],
       excerpt: [],
@@ -423,7 +449,10 @@ export const UNIT_MANIFESTS: Record<UnitType, UnitContextManifest> = {
     memory: "prompt-relevant",
     codebaseMap: true,
     preferences: "active-only",
-    tools: TOOLS_PLANNING,
+    // See plan-slice — same rationale: dispatch to scout/planner-style
+    // specialists during refinement is materially better than re-doing recon
+    // inline.
+    tools: TOOLS_PLANNING_DISPATCH_RECON,
     artifacts: {
       inline: ["slice-plan", "slice-research", "dependency-summaries", "templates"],
       excerpt: [],
@@ -451,7 +480,10 @@ export const UNIT_MANIFESTS: Record<UnitType, UnitContextManifest> = {
     memory: "prompt-relevant",
     codebaseMap: false,
     preferences: "active-only",
-    tools: TOOLS_PLANNING,
+    // See complete-milestone — same rationale: dispatch to reviewer / security /
+    // tester subagents to fan out review work without bloating this unit's
+    // context.
+    tools: TOOLS_PLANNING_DISPATCH_REVIEW,
     artifacts: {
       // Phase 3 migration (#4782): matches today's actual
       // buildCompleteSlicePrompt inlining order. Overrides prepend +

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

@@ -20,7 +20,7 @@ import { writeExportFile } from "./export.js";
 import { gsdRoot } from "./paths.js";
 import { stripAnsi } from "../shared/mod.js";
 
-const TAB_COUNT = 10;
+export const TAB_COUNT = 10;
 const TAB_LABELS = [
   "1 Progress",
   "2 Timeline",

package/src/resources/extensions/gsd/watch/header-renderer.ts

@@ -98,13 +98,15 @@ export function readGitBranch(projectRoot: string): string {
 }
 
 /**
- * Read MCP server names from .mcp.json or .gsd/mcp.json.
+ * Read MCP server names from .mcp.json, .gsd/mcp.json, and the global
+ * ~/.gsd/mcp.json (or $GSD_HOME/mcp.json).
  * Returns array of server name strings.
  */
 export function readMcpServerNames(projectRoot: string): string[] {
   const configPaths = [
     join(projectRoot, ".mcp.json"),
     join(projectRoot, ".gsd", "mcp.json"),
+    join(process.env.GSD_HOME || join(homedir(), ".gsd"), "mcp.json"),
   ];
   const names: string[] = [];
   const seen = new Set<string>();

package/src/resources/extensions/gsd/workflow-logger.ts

@@ -66,6 +66,7 @@ export type LogComponent =
   | "memory-embeddings" // Memory layer embedding generation
   | "memory-ingest"     // Memory layer ingestion pipeline
   | "memory-backfill"   // ADR-013: decisions->memories backfill
+  | "memory-store"      // Memory CRUD layer — surfaces SQLite/store-level faults (#4967)
   | "context-mode"     // Context-mode exec sandbox and compaction snapshot
   | "preflight"        // Clean-root preflight gate at milestone completion
   | "postUnit";     // Post-unit processing (abandon detection, overrides)