gsd-pi 2.78.1-dev.84a383f51 → 2.78.1

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 tests: fire the live session handlers with fake
- *      contexts and confirm footer/widget behavior from runtime effects.
+ *   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.
  *
  * Relates to #4314.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync } 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,89 +68,27 @@ test("session_start handler guards initHealthWidget with !isAutoActive()", () =>
   );
 });
 
-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 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 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;
+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");
 
-  registerHooks(pi, []);
+  const beforeAgentStartIdx = HOOKS_SOURCE.indexOf('"before_agent_start"');
+  assert.ok(beforeAgentStartIdx > sessionSwitchIdx, "before_agent_start handler must follow session_switch");
 
-  const sessionSwitch = handlers.get("session_switch");
-  assert.ok(sessionSwitch, "session_switch handler must be registered");
+  const sessionSwitchBody = HOOKS_SOURCE.slice(sessionSwitchIdx, beforeAgentStartIdx);
 
-  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.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",
   );
-  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(
-    healthWidgetValues.every((value) => value !== undefined),
-    "session_switch must not hide gsd-health when auto is inactive",
+    !sessionSwitchBody.includes("setFooter"),
+    "session_switch handler must NOT call setFooter",
   );
-  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 ─
@@ -205,90 +143,3 @@ 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, SLICE_WORKER_AUTO_ARGS } from "../slice-parallel-orchestrator.ts";
+import { restoreSliceState } from "../slice-parallel-orchestrator.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const gsdDir = join(__dirname, "..");
@@ -100,12 +100,6 @@ 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,28 +48,6 @@ 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,
-    /nextMilestoneIdReserved\(milestoneIds,\s*uniqueMilestoneIds,\s*basePath\)/,
-    "complete branch should derive the next milestone id",
-  );
+  assert.match(branchChunk, /nextMilestoneId(?:Reserved)?\(milestoneIds, uniqueMilestoneIds\)/, "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/token-profile.test.ts

@@ -107,50 +107,6 @@ 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":');
@@ -266,14 +222,11 @@ test("merge: mergePreferences handles phases with spread", () => {
 // Subagent Model Routing
 // ═══════════════════════════════════════════════════════════════════════════
 
-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);
+test("subagent: budget profile sets subagent model", () => {
+  const budgetIdx = preferencesSrc.indexOf('case "budget":');
+  const balancedIdx = preferencesSrc.indexOf('case "balanced":');
   const budgetBlock = preferencesSrc.slice(budgetIdx, balancedIdx);
-  assert.ok(budgetBlock.includes("subagent:"), "budget profile should define subagent tier");
-  assert.ok(budgetBlock.includes('"light"'), "budget subagent should use light tier");
+  assert.ok(budgetBlock.includes("subagent:"), "budget profile should set subagent model");
 });
 
 test("subagent: resolveModelWithFallbacksForUnit handles subagent unit types", () => {

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

@@ -144,10 +144,19 @@ test("recoverTimedOutUnit: no top-level bumpTurnGeneration — steering branches
   );
 });
 
-// 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.
+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}`,
+  );
+});

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

@@ -76,11 +76,13 @@ describe("#3615 — structural: fallback exists with correct guards", () => {
     );
   });
 
-  // 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.
+  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}`,
+    );
+  });
 });
 
 // ── 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 { handleTurnGitActionError, runTurnGitAction } from "../git-service.ts";
+import { runTurnGitAction } from "../git-service.ts";
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
@@ -83,17 +83,3 @@ 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, TAB_COUNT } from "../visualizer-overlay.ts";
+import { GSDVisualizerOverlay } 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 = TAB_COUNT - 1;
+  overlay.activeTab = 9;
   overlay.handleInput("\t");
-  assert.equal(overlay.activeTab, 0, `Tab wraps from ${TAB_COUNT - 1} back to 0`);
+  assert.equal(overlay.activeTab, 0, "Tab wraps from 9 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, TAB_COUNT - 1, `Shift+Tab wraps from 0 to ${TAB_COUNT - 1}`);
+  assert.equal(overlay.activeTab, 9, "Shift+Tab wraps from 0 to 9");
 });
 
 // ─── 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", (t) => {
+test("overlay scrollOffsets array has one slot per tab (10 tabs total)", (t) => {
   const { overlay } = makeOverlay(t);
-  assert.equal(overlay.scrollOffsets.length, TAB_COUNT, "scrollOffsets sized to TAB_COUNT");
+  assert.equal(overlay.scrollOffsets.length, 10, "scrollOffsets sized to TAB_COUNT=10");
   assert.ok(overlay.scrollOffsets.every((n: number) => n === 0), "initialized to zero");
 });
 

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

@@ -10,7 +10,6 @@ import assert from 'node:assert/strict';
 import { join, sep } from 'node:path';
 
 import { shouldBlockPlanningUnit } from '../bootstrap/write-gate.ts';
-import { isDeterministicPolicyError } from '../auto-tool-tracking.ts';
 import type { ToolsPolicy } from '../unit-context-manifest.ts';
 
 const BASE = join('/tmp', 'fake-project');
@@ -37,20 +36,6 @@ 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);

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

@@ -96,24 +96,8 @@ export function executeMemoryCapture(params: MemoryCaptureParams): ToolExecution
   const tags = normalizeTags(params.tags);
 
   const structuredFields = normalizeStructuredFields(params.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,
-    };
-  }
+  const id = createMemory({ category, content, confidence, scope, tags, structuredFields });
   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).
  *
- * 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.
+ * 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.
  *
  * Modes:
  *   - "all"        — Read + Edit/Write/MultiEdit/NotebookEdit + Bash + Task.
@@ -214,10 +214,10 @@ export interface UnitContextManifest {
   /** Preferences block policy. */
   readonly preferences: PreferencesPolicy;
   /**
-   * 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.
+   * 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.
    */
   readonly tools: ToolsPolicy;
   /** Artifact handling: inline (full body), excerpt (compact), or on-demand (path only). */

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";
 
-export const TAB_COUNT = 10;
+const TAB_COUNT = 10;
 const TAB_LABELS = [
   "1 Progress",
   "2 Timeline",

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

@@ -98,15 +98,13 @@ export function readGitBranch(projectRoot: string): string {
 }
 
 /**
- * Read MCP server names from .mcp.json, .gsd/mcp.json, and the global
- * ~/.gsd/mcp.json (or $GSD_HOME/mcp.json).
+ * Read MCP server names from .mcp.json or .gsd/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,7 +66,6 @@ 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)