gsd-pi 2.80.0-dev.4ea7d80e7 → 2.80.0-dev.7582bf37a

package/src/resources/extensions/gsd/tests/dispatch-guard-closed-status.test.ts

@@ -1,33 +1,43 @@
 /**
  * dispatch-guard-closed-status.test.ts — #3653
  *
- * Verify that the dispatch guard uses isClosedStatus() instead of a raw
- * `status === "complete"` check when determining whether a slice is done.
+ * Verify that the dispatch guard treats all closed DB slice statuses as done.
  * Reconciled slices may carry statuses like "skipped" or "cancelled" which
  * are also closed — the raw check caused false dispatch blocks.
  */
 
-import { describe, test } from "node:test";
+import { afterEach, beforeEach, describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "dispatch-guard.ts");
+import { getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
 describe("dispatch-guard isClosedStatus migration (#3653)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
+  let base: string;
 
-  test("imports isClosedStatus from status-guards", () => {
-    assert.match(source, /import\s*\{[^}]*isClosedStatus[^}]*\}\s*from\s*["']\.\/status-guards/);
+  beforeEach(() => {
+    base = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-closed-"));
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "CONTEXT.md"), "# M001\n");
+    openDatabase(join(base, ".gsd", "gsd.db"));
   });
 
-  test("uses isClosedStatus() for slice done check instead of raw comparison", () => {
-    assert.match(source, /done:\s*isClosedStatus\(r\.status\)/);
+  afterEach(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
   });
 
-  test("does not use raw status === 'complete' for DB slice rows", () => {
-    assert.doesNotMatch(source, /done:\s*r\.status\s*===\s*["']complete["']/);
+  test("skipped prior DB slices do not block later slice dispatch", () => {
+    insertMilestone({ id: "M001", title: "Milestone 1", status: "active", depends_on: [] });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Skipped Slice", status: "skipped", depends: [] });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Next Slice", status: "pending", depends: [] });
+
+    assert.equal(
+      getPriorSliceCompletionBlocker(base, "main", "execute-task", "M001-S02-T01"),
+      null,
+    );
   });
 });

package/src/resources/extensions/gsd/tests/dispatch-rule-coverage.test.ts

@@ -0,0 +1,313 @@
+// gsd-2 / dispatch rule coverage canary test
+//
+// Iterates DISPATCH_RULES in order against representative GSDState stubs and
+// asserts that the first matching rule has the expected name and unitType
+// (mirroring auto-dispatch's first-match-wins semantics). The goal is a
+// canary: if a future PR adds a new rule in the wrong position and steals
+// a match from an existing one, this test fails.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { DISPATCH_RULES } from "../auto-dispatch.ts";
+import type { DispatchContext, DispatchAction } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+
+// ─── State helpers ────────────────────────────────────────────────────────
+
+function makeState(overrides: Partial<GSDState> = {}): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "Test Milestone" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "pre-planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+    ...overrides,
+  };
+}
+
+function makeCtx(basePath: string, state: GSDState, mid = "M001"): DispatchContext {
+  return {
+    basePath,
+    mid,
+    midTitle: "Test Milestone",
+    state,
+    prefs: undefined,
+  };
+}
+
+// ─── Disk scaffold helpers ────────────────────────────────────────────────
+
+function writeMilestoneFile(basePath: string, mid: string, suffix: string, content = "stub\n"): void {
+  const dir = join(basePath, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-${suffix}.md`), content);
+}
+
+function writeSliceFile(
+  basePath: string,
+  mid: string,
+  sid: string,
+  suffix: string,
+  content = "stub\n",
+): void {
+  const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${sid}-${suffix}.md`), content);
+}
+
+function writeTaskPlan(basePath: string, mid: string, sid: string, tid: string): void {
+  const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid, "tasks");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${tid}-PLAN.md`), `# ${tid}\n\n## Steps\n- [ ] Step\n`);
+}
+
+// ─── Rule evaluation ──────────────────────────────────────────────────────
+
+interface MatchEntry {
+  ruleName: string;
+  result: DispatchAction;
+}
+
+// First-match-wins semantics: walks DISPATCH_RULES in order and stops at the
+// first non-null result. This mirrors the production resolver and is the
+// canary against rule reordering or shadowing.
+async function findFirstMatch(ctx: DispatchContext): Promise<MatchEntry | null> {
+  for (const rule of DISPATCH_RULES) {
+    const result = await rule.match(ctx);
+    if (result) return { ruleName: rule.name, result };
+  }
+  return null;
+}
+
+function assertMatch(
+  match: MatchEntry | null,
+  expected: { ruleName: string; action: DispatchAction["action"]; unitType?: string },
+  scenario: string,
+): void {
+  assert.ok(match, `${scenario}: no rule matched`);
+  assert.equal(match.ruleName, expected.ruleName, `${scenario}: matched rule mismatch`);
+  assert.equal(match.result.action, expected.action, `${scenario}: action mismatch`);
+  if (expected.action === "dispatch" && expected.unitType) {
+    assert.ok(
+      match.result.action === "dispatch" && match.result.unitType === expected.unitType,
+      `${scenario}: unitType mismatch (got ${
+        match.result.action === "dispatch" ? match.result.unitType : match.result.action
+      })`,
+    );
+  }
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────
+
+test("dispatch-rule-coverage: escalating-task → stop (info)", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-esc-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const ctx = makeCtx(
+    tmp,
+    makeState({
+      phase: "escalating-task",
+      activeSlice: { id: "S01", title: "Slice" },
+      nextAction: "Resolve escalation X",
+    }),
+  );
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    { ruleName: "escalating-task → pause-for-escalation", action: "stop" },
+    "escalating-task",
+  );
+});
+
+test("dispatch-rule-coverage: pre-planning, no CONTEXT → discuss-milestone", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-disc-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  // Bare milestone dir, no CONTEXT/RESEARCH/ROADMAP files.
+  mkdirSync(join(tmp, ".gsd", "milestones", "M001"), { recursive: true });
+
+  const ctx = makeCtx(tmp, makeState({ phase: "pre-planning" }));
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "pre-planning (no context) → discuss-milestone",
+      action: "dispatch",
+      unitType: "discuss-milestone",
+    },
+    "pre-planning no context",
+  );
+});
+
+test("dispatch-rule-coverage: pre-planning, has CONTEXT, no RESEARCH → research-milestone", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-res-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+
+  const ctx = makeCtx(tmp, makeState({ phase: "pre-planning" }));
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "pre-planning (no research) → research-milestone",
+      action: "dispatch",
+      unitType: "research-milestone",
+    },
+    "pre-planning no research",
+  );
+});
+
+test("dispatch-rule-coverage: pre-planning, has CONTEXT + RESEARCH → plan-milestone", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-plan-m-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+  writeMilestoneFile(tmp, "M001", "RESEARCH", "# Research\n");
+
+  const ctx = makeCtx(tmp, makeState({ phase: "pre-planning" }));
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "pre-planning (has research) → plan-milestone",
+      action: "dispatch",
+      unitType: "plan-milestone",
+    },
+    "pre-planning has research",
+  );
+});
+
+test("dispatch-rule-coverage: planning with active slice and skip_research → plan-slice", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-plan-s-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+  writeMilestoneFile(tmp, "M001", "ROADMAP", "# Roadmap\n");
+
+  const state = makeState({
+    phase: "planning",
+    activeSlice: { id: "S01", title: "First Slice" },
+  });
+  const ctx: DispatchContext = {
+    basePath: tmp,
+    mid: "M001",
+    midTitle: "Test Milestone",
+    state,
+    // Skip slice research so the parallel/single research rules fall through.
+    prefs: { phases: { skip_slice_research: true } } as DispatchContext["prefs"],
+  };
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "planning → plan-slice",
+      action: "dispatch",
+      unitType: "plan-slice",
+    },
+    "planning → plan-slice",
+  );
+});
+
+test("dispatch-rule-coverage: executing with task plan present → execute-task", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-exec-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+  writeSliceFile(tmp, "M001", "S01", "PLAN", "# Plan\n");
+  writeTaskPlan(tmp, "M001", "S01", "T01");
+
+  const state = makeState({
+    phase: "executing",
+    activeSlice: { id: "S01", title: "First Slice" },
+    activeTask: { id: "T01", title: "First Task" },
+  });
+  // Disable reactive dispatch so the parallel batching rule falls through.
+  const ctx: DispatchContext = {
+    basePath: tmp,
+    mid: "M001",
+    midTitle: "Test Milestone",
+    state,
+    prefs: { reactive_execution: { enabled: false } } as DispatchContext["prefs"],
+  };
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "executing → execute-task",
+      action: "dispatch",
+      unitType: "execute-task",
+    },
+    "executing → execute-task",
+  );
+});
+
+test("dispatch-rule-coverage: summarizing → complete-slice", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-sum-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  // Rule "execution-entry phase (no context)" fires for summarizing if CONTEXT
+  // is missing — write it so the summarizing rule wins.
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+
+  const ctx = makeCtx(
+    tmp,
+    makeState({
+      phase: "summarizing",
+      activeSlice: { id: "S01", title: "First Slice" },
+    }),
+  );
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "summarizing → complete-slice",
+      action: "dispatch",
+      unitType: "complete-slice",
+    },
+    "summarizing → complete-slice",
+  );
+});
+
+test("dispatch-rule-coverage: complete phase → stop", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-done-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const ctx = makeCtx(
+    tmp,
+    makeState({
+      phase: "complete",
+      activeMilestone: null,
+      lastCompletedMilestone: { id: "M001", title: "Test Milestone" },
+    }),
+  );
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    { ruleName: "complete → stop", action: "stop" },
+    "complete → stop",
+  );
+});
+
+// ─── Ordering canary: every scenario above resolves to exactly one rule ────
+
+test("dispatch-rule-coverage: rule registry has the expected size", () => {
+  // Sanity check that complements the per-state assertions: if someone adds a
+  // new rule, this number changes — prompting them to add a state stub above.
+  // Exact count is a brittle but useful canary; update when adding rules
+  // intentionally.
+  assert.equal(
+    DISPATCH_RULES.length,
+    29,
+    `DISPATCH_RULES length changed (got ${DISPATCH_RULES.length}). ` +
+      "If you added a rule, add a state stub to dispatch-rule-coverage.test.ts " +
+      "and update this expected count.",
+  );
+});

package/src/resources/extensions/gsd/tests/dispatcher-stuck-planning.test.ts

@@ -6,32 +6,50 @@
  * planning/import APIs.
  */
 
-import { describe, test } from "node:test";
+import { afterEach, beforeEach, describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "state.ts");
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
+import { deriveStateFromDb, invalidateStateCache } from "../state.ts";
 
 describe("dispatcher DB-authoritative planning boundary", () => {
-  const source = readFileSync(sourceFile, "utf-8");
+  let base: string;
 
-  test("does not import insertTask into state derivation", () => {
-    assert.doesNotMatch(source, /import\s*\{[^}]*insertTask[^}]*\}\s*from/);
+  beforeEach(() => {
+    base = mkdtempSync(join(tmpdir(), "gsd-dispatcher-planning-"));
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "S01"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "CONTEXT.md"), "# M001\n");
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "ROADMAP.md"), [
+      "## Slices",
+      "- [ ] **S01: Build** `risk:low` `depends:[]`",
+    ].join("\n"));
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "S01", "PLAN.md"), [
+      "## Tasks",
+      "- [ ] **T01: Projection-only task**",
+    ].join("\n"));
+    openDatabase(join(base, ".gsd", "gsd.db"));
   });
 
-  test("does not contain plan-file task reconciliation block", () => {
-    assert.doesNotMatch(source, /dbTaskIds\.has\(t\.id\)/);
-    assert.match(source, /Slice \$\{activeSlice\.id\} has no DB tasks/);
+  afterEach(() => {
+    closeDatabase();
+    invalidateStateCache();
+    rmSync(base, { recursive: true, force: true });
   });
 
-  test("does not call insertTask from state derivation", () => {
-    assert.doesNotMatch(source, /insertTask\(\{/);
-  });
+  test("PLAN.md projection tasks are not imported into runtime DB state", async () => {
+    insertMilestone({ id: "M001", title: "Milestone 1", status: "active", depends_on: [] });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Build", status: "active", depends: [] });
+
+    const state = await deriveStateFromDb(base);
 
-  test("documents markdown projections as non-authoritative", () => {
-    assert.match(source, /Markdown files are projections only/);
+    assert.equal(state.phase, "planning");
+    assert.equal(state.activeTask, null);
+    assert.match(
+      state.nextAction ?? "",
+      /Slice S01 has no DB tasks\. Plan slice tasks before execution\./,
+    );
   });
 });

package/src/resources/extensions/gsd/tests/error-success-mask.test.ts

@@ -8,30 +8,25 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "bootstrap", "agent-end-recovery.ts");
+import { resolveAgentEndErrorDisplay } from "../bootstrap/agent-end-recovery.ts";
 
 describe("error-success mask detection (#3664)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
-
-  test("detects useless errorMessage values with regex", () => {
-    assert.match(source, /success\|ok\|true\|error\|unknown/i);
-  });
-
-  test("extracts display message from content text block", () => {
-    assert.match(source, /textBlock/);
-    assert.match(source, /\.text\.slice\(0,\s*300\)/);
-  });
-
-  test("classifies using rawErrorMsg, not displayMsg", () => {
-    assert.match(source, /classifyError\(rawErrorMsg/);
+  test("falls back to assistant text when errorMessage is uninformative", () => {
+    assert.equal(
+      resolveAgentEndErrorDisplay("success", [
+        { type: "tool_use", name: "noop" },
+        { type: "text", text: "provider failed with a useful message" },
+      ]),
+      "provider failed with a useful message",
+    );
   });
 
-  test("references issue #3588 in comments", () => {
-    assert.match(source, /#3588/);
+  test("keeps informative raw error messages", () => {
+    assert.equal(
+      resolveAgentEndErrorDisplay("rate limit exceeded", [
+        { type: "text", text: "prose should not replace useful raw error" },
+      ]),
+      "rate limit exceeded",
+    );
   });
 });

package/src/resources/extensions/gsd/tests/est-annotation-timeout.test.ts

@@ -8,46 +8,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const timersSrcPath = join(import.meta.dirname, "..", "auto-timers.ts");
-const timersSrc = readFileSync(timersSrcPath, "utf-8");
-
-// ─── Source analysis: parseEstimateMinutes exists and is exported ────────────
-
-test("#2243: auto-timers.ts should export parseEstimateMinutes", () => {
-  assert.ok(
-    timersSrc.includes("export function parseEstimateMinutes"),
-    "parseEstimateMinutes should be exported from auto-timers.ts",
-  );
-});
-
-// ─── Inline unit test of parseEstimateMinutes logic ─────────────────────────
-// Since importing the module pulls in heavy deps, test the parsing logic inline.
-
-function parseEstimateMinutes(estimate: string): number | null {
-  if (!estimate || typeof estimate !== "string") return null;
-  const trimmed = estimate.trim();
-  if (!trimmed) return null;
-
-  let totalMinutes = 0;
-  let matched = false;
-
-  const hoursMatch = trimmed.match(/(\d+)\s*h/i);
-  if (hoursMatch) {
-    totalMinutes += Number(hoursMatch[1]) * 60;
-    matched = true;
-  }
-
-  const minutesMatch = trimmed.match(/(\d+)\s*m/i);
-  if (minutesMatch) {
-    totalMinutes += Number(minutesMatch[1]);
-    matched = true;
-  }
-
-  return matched ? totalMinutes : null;
-}
+import { parseEstimateMinutes, resolveUnitSupervisionTimeouts } from "../auto-timers.ts";
 
 test("#2243: parseEstimateMinutes parses '30m' correctly", () => {
   assert.equal(parseEstimateMinutes("30m"), 30);
@@ -73,48 +34,20 @@ test("#2243: parseEstimateMinutes returns null for invalid string", () => {
   assert.equal(parseEstimateMinutes("not a time"), null);
 });
 
-// ─── Source analysis: startUnitSupervision uses task estimates ───────────────
-
-test("#2243: startUnitSupervision should reference task estimates for timeout scaling", () => {
-  const usesEstimate =
-    timersSrc.includes("parseEstimateMinutes") &&
-    timersSrc.includes("estimateMinutes") &&
-    timersSrc.includes("taskEstimate");
-
-  assert.ok(
-    usesEstimate,
-    "startUnitSupervision should use task estimate annotations for timeout scaling",
+test("#2243: estimate scale affects soft and hard timeouts but not idle timeout", () => {
+  const result = resolveUnitSupervisionTimeouts(
+    "execute-task",
+    {
+      soft_timeout_minutes: 10,
+      idle_timeout_minutes: 5,
+      hard_timeout_minutes: 20,
+    },
+    3,
   );
-});
-
-test("#2243: SupervisionContext should accept an optional taskEstimate field", () => {
-  const ctxIdx = timersSrc.indexOf("SupervisionContext");
-  assert.ok(ctxIdx !== -1, "SupervisionContext interface exists");
 
-  const ctxEnd = timersSrc.indexOf("}", ctxIdx);
-  const ctxBlock = timersSrc.slice(ctxIdx, ctxEnd);
-
-  assert.ok(
-    ctxBlock.includes("taskEstimate"),
-    "SupervisionContext should include a taskEstimate field",
-  );
-});
-
-test("#2243: timeouts should be scaled by estimate (timeoutScale in source)", () => {
-  assert.ok(
-    timersSrc.includes("timeoutScale"),
-    "auto-timers.ts should use a timeoutScale factor derived from est: annotations",
-  );
-});
-
-test("#2243: idle timeout should NOT be scaled (idle is idle regardless of estimate)", () => {
-  // Find the idleTimeoutMs line
-  const idleIdx = timersSrc.indexOf("const idleTimeoutMs");
-  assert.ok(idleIdx !== -1, "idleTimeoutMs variable exists");
-  
-  const idleLine = timersSrc.slice(idleIdx, timersSrc.indexOf("\n", idleIdx));
-  assert.ok(
-    !idleLine.includes("timeoutScale"),
-    "idleTimeoutMs should NOT be scaled — idle is idle",
-  );
+  assert.deepEqual(result, {
+    softTimeoutMs: 30 * 60 * 1000,
+    idleTimeoutMs: 5 * 60 * 1000,
+    hardTimeoutMs: 60 * 60 * 1000,
+  });
 });

package/src/resources/extensions/gsd/tests/exec-history.test.ts

@@ -108,6 +108,21 @@ test('executeExecSearch: returns helpful empty-state message when no matches', (
   }
 });
 
+test('executeExecSearch: returns disabled error when context_mode.enabled=false', () => {
+  const base = freshBase();
+  try {
+    writeRun(base, 'should-not-surface', { stdout: 'hidden\n' });
+    const result = executeExecSearch(
+      { query: 'hidden' },
+      { baseDir: base, preferences: { context_mode: { enabled: false } } },
+    );
+    assert.equal(result.isError, true);
+    assert.equal((result.details as { error?: string }).error, 'context_mode_disabled');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('executeExecSearch: includes stdout_path and preview in details', () => {
   const base = freshBase();
   try {