mixdog 0.9.38 → 0.9.40

package/scripts/session-orphan-sweep-test.mjs

@@ -0,0 +1,83 @@
+/**
+ * session-orphan-sweep-test.mjs — proves the periodic sweep reclaims mature
+ * closed tombstones that exist ON DISK but are ABSENT from the summary index.
+ *
+ * Regression guard for the pre-fix bug where sweepStaleSessions iterated only
+ * listStoredSessionSummaries() rows, so on-disk session files missing from a
+ * stale index were never visited and their tombstones accumulated forever.
+ */
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+test('mature closed on-disk orphan absent from summary index gets tombstone-swept', async () => {
+    const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-orphan-sweep-'));
+    process.env.MIXDOG_DATA_DIR = dataDir;
+    try {
+        const store = await import('../src/runtime/agent/orchestrator/session/store.mjs');
+        const { sweepStaleSessions, _sessionSummary, _writeSummaryIndex } = store;
+
+        const sessionsDir = join(dataDir, 'sessions');
+        mkdirSync(sessionsDir, { recursive: true });
+
+        const now = Date.now();
+        const TWO_HOURS = 2 * 60 * 60 * 1000;
+        const ONE_HOUR = 60 * 60 * 1000;
+
+        // (1) An INDEXED, fresh, open agent session — present in the summary
+        //     index so the index is non-empty (blocking any rebuild) and must
+        //     survive the sweep.
+        const indexed = {
+            id: 'sess_indexed_keep',
+            closed: false,
+            status: 'idle',
+            owner: 'agent:test',
+            updatedAt: now,
+            createdAt: now,
+            lastHeartbeatAt: now,
+            messages: [],
+        };
+        writeFileSync(join(sessionsDir, `${indexed.id}.json`), JSON.stringify(indexed));
+
+        // (2) An ORPHAN closed+mature tombstone — on disk, NOT in the index,
+        //     closed >1h ago. Only reachable if the sweep reconciles the index
+        //     candidate set with a direct directory scan.
+        const orphan = {
+            id: 'sess_orphan_tombstone',
+            closed: true,
+            status: 'closed',
+            owner: 'agent:test',
+            updatedAt: now - TWO_HOURS,
+            createdAt: now - TWO_HOURS,
+            messages: [],
+        };
+        writeFileSync(join(sessionsDir, `${orphan.id}.json`), JSON.stringify(orphan));
+
+        // Index contains ONLY the indexed session — the orphan is absent.
+        const rows = _writeSummaryIndex([_sessionSummary(indexed)]);
+        assert.equal(rows.length, 1, 'index seeded with exactly one row');
+        assert.ok(!rows.some((r) => r.id === orphan.id), 'orphan is absent from the summary index');
+
+        // Tombstone-only pass (no idle sweep) with a 1h maturity threshold.
+        const result = sweepStaleSessions({ sweepIdle: false, tombstoneMaxAgeMs: ONE_HOUR });
+
+        assert.equal(result.tombstonesCleaned, 1, 'the orphan tombstone was reclaimed');
+        assert.ok(
+            result.tombstoneDetails.some((d) => d.id === orphan.id),
+            'sweep reports the orphan id among tombstone deletions',
+        );
+        assert.ok(
+            !existsSync(join(sessionsDir, `${orphan.id}.json`)),
+            'orphan session file was unlinked from disk',
+        );
+        assert.ok(
+            existsSync(join(sessionsDir, `${indexed.id}.json`)),
+            'fresh open indexed session was preserved',
+        );
+    } finally {
+        try { rmSync(dataDir, { recursive: true, force: true }); } catch { /* ignore */ }
+        delete process.env.MIXDOG_DATA_DIR;
+    }
+});

package/scripts/steering-drain-buckets-test.mjs

@@ -1,6 +1,9 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { createSessionFlow } from '../src/tui/engine/session-flow.mjs';
+import { createRunTurn } from '../src/tui/engine/turn.mjs';
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 // Minimal bag: drainPendingSteering only touches pending, the queue helpers,
 // and commitSteeringQueueEntries (which no-ops on disk when runtime.id is not
@@ -70,7 +73,7 @@ test('drainPendingSteering accepts runtime callback signature', () => {
   assert.equal(bag.pending.length, 0);
 });
 
-test('drained notification key remains deduped and displayed key is not cleared', () => {
+test('drained notification key is released while displayed key is not cleared', () => {
   const { flow, bag } = makeFlow();
   bag.getState().busy = true;
   assert.equal(flow.enqueue('task finished', { mode: 'task-notification', key: 'task-1' }), true);
@@ -79,7 +82,7 @@ test('drained notification key remains deduped and displayed key is not cleared'
   const out = flow.drainPendingSteering({ maxPriority: 'later' });
 
   assert.deepEqual(out, ['task finished']);
-  assert.equal(flow.enqueue('task duplicate', { mode: 'task-notification', key: 'task-1' }), false);
+  assert.equal(flow.enqueue('task duplicate', { mode: 'task-notification', key: 'task-1' }), true);
   assert.equal(bag.displayedExecutionNotificationKeys.has('task-1'), true);
 });
 
@@ -118,3 +121,314 @@ test('post-turn drain does not send queued slash command to model', async () =>
   assert.equal(bag.pending.length, 1, 'slash command remains for command dispatcher');
   assert.equal(bag.pending[0].content, '/clear');
 });
+
+// Minimal store bag for createRunTurn: only the surface the streaming/steering
+// finalize path touches. runtime.ask is a caller-supplied mock that drives the
+// text-delta / steer-message callbacks.
+function makeTurnBag(ask, {
+  timeoutMs = 300000,
+  getTurnLiveness,
+  abort,
+} = {}) {
+  let seq = 0;
+  const state = {
+    items: [],
+    stats: { turns: 0, inputTokens: 0, outputTokens: 0 },
+    busy: false,
+    spinner: null,
+    thinking: null,
+  };
+  const itemIndexById = new Map();
+  const findIndexById = (id) => state.items.findIndex((it) => it.id === id);
+  const runtime = { id: null, toolMode: 'auto', ask, abort: abort || (() => {}) };
+  if (typeof getTurnLiveness === 'function') runtime.getTurnLiveness = getTurnLiveness;
+  const bag = {
+    runtime,
+    nextId: () => `id_${++seq}`,
+    tuiDebug: () => {},
+    LEAD_TURN_TIMEOUT_MS: timeoutMs,
+    flags: { leadTurnEpoch: 0 },
+    pending: [],
+    itemIndexById,
+    getState: () => state,
+    set: (patch) => Object.assign(state, patch),
+    pushItem: (spec) => {
+      state.items = [...state.items, spec];
+      if (spec?.id != null) itemIndexById.set(spec.id, state.items.length - 1);
+    },
+    patchItem: (id, patch) => {
+      const idx = findIndexById(id);
+      if (idx < 0) return;
+      const items = state.items.slice();
+      items[idx] = { ...items[idx], ...patch };
+      state.items = items;
+    },
+    pushNotice: () => {},
+    pushUserOrSyntheticItem: (text) => {
+      state.items = [...state.items, { kind: 'user', id: `u_${++seq}`, text }];
+    },
+    markToolCallActive: () => {},
+    markToolCallDone: () => {},
+    clearActiveToolSummary: () => {},
+    agentStatusState: () => ({}),
+    routeState: () => ({}),
+    syncContextStats: () => {},
+    denyAllToolApprovals: () => {},
+    requestToolApproval: async () => ({ approved: false }),
+    patchToolCardResult: () => {},
+    flushToolResults: () => {},
+    flushDeferredExecutionPendingResumeKick: () => {},
+    drain: async () => {},
+    drainPendingSteering: () => [],
+  };
+  return { bag, getState: () => state };
+}
+
+test('watchdog accepts fresh runtime liveness without tripping', async () => {
+  let aborts = 0;
+  const ask = async () => {
+    await wait(45);
+    return { result: { content: '' }, session: { messages: [] } };
+  };
+  const { bag } = makeTurnBag(ask, {
+    timeoutMs: 15,
+    abort: () => { aborts += 1; },
+    getTurnLiveness: () => ({
+      stage: 'tool_running',
+      lastProgressAt: Date.now(),
+      toolStartedAt: Date.now(),
+      toolSelfDeadlineMs: 0,
+    }),
+  });
+
+  assert.equal(await createRunTurn(bag)('do a thing'), 'done');
+  assert.equal(aborts, 0, 'fresh orchestrator heartbeats defer the watchdog');
+});
+
+test('watchdog trips at the tool ceiling despite fresh liveness', async () => {
+  const previousMax = process.env.MIXDOG_LEAD_TOOL_MAX_MS;
+  const timeoutMs = 30;
+  const ceilingMs = 95;
+  process.env.MIXDOG_LEAD_TOOL_MAX_MS = String(ceilingMs);
+  let rejectAsk;
+  let heartbeatTimer = null;
+  let heartbeatStartTimer = null;
+  let aborts = 0;
+  let abortAt = 0;
+  let livenessCalls = 0;
+  const toolStartedAt = Date.now();
+  const ask = (_userText, options) => new Promise((_resolve, reject) => {
+    rejectAsk = reject;
+    // Let the first watchdog probe defer from orchestrator liveness, then keep
+    // the TUI's local progress fresh so the ceiling-bounded re-arm is exercised.
+    heartbeatStartTimer = setTimeout(() => {
+      heartbeatTimer = setInterval(() => options.onStreamDelta(), 5);
+    }, 40);
+  });
+  const { bag } = makeTurnBag(ask, {
+    timeoutMs,
+    abort: () => {
+      aborts += 1;
+      abortAt = Date.now();
+      clearTimeout(heartbeatStartTimer);
+      clearInterval(heartbeatTimer);
+      const error = new Error('interrupted');
+      error.name = 'SessionClosedError';
+      rejectAsk(error);
+    },
+    getTurnLiveness: () => {
+      livenessCalls += 1;
+      return {
+        stage: 'tool_running',
+        lastProgressAt: Date.now(),
+        toolStartedAt,
+        toolSelfDeadlineMs: 0,
+      };
+    },
+  });
+
+  try {
+    const result = await Promise.race([
+      createRunTurn(bag)('do a thing'),
+      wait(180).then(() => 'watchdog did not trip at the ceiling'),
+    ]);
+    assert.equal(result, 'cancelled');
+    assert.equal(aborts, 1);
+    assert.ok(livenessCalls >= 2, 'first probe deferred, then the ceiling probe rechecked liveness');
+    assert.ok(abortAt - toolStartedAt < ceilingMs + timeoutMs, 'ceiling trips before an unbounded watchdog interval');
+  } finally {
+    clearTimeout(heartbeatStartTimer);
+    clearInterval(heartbeatTimer);
+    if (previousMax === undefined) delete process.env.MIXDOG_LEAD_TOOL_MAX_MS;
+    else process.env.MIXDOG_LEAD_TOOL_MAX_MS = previousMax;
+  }
+});
+
+for (const [name, getTurnLiveness] of [
+  ['throws', () => { throw new Error('liveness unavailable'); }],
+  ['returns null', () => null],
+]) {
+  test(`watchdog ${name} probe falls back to abort`, async () => {
+    let rejectAsk;
+    let aborts = 0;
+    const ask = () => new Promise((_resolve, reject) => { rejectAsk = reject; });
+    const { bag } = makeTurnBag(ask, {
+      timeoutMs: 15,
+      getTurnLiveness,
+      abort: () => {
+        aborts += 1;
+        const error = new Error('interrupted');
+        error.name = 'SessionClosedError';
+        rejectAsk(error);
+      },
+    });
+
+    const [result] = await Promise.all([createRunTurn(bag)('do a thing'), wait(40)]);
+    assert.equal(result, 'cancelled');
+    assert.equal(aborts, 1);
+  });
+}
+
+test('stream-delta progress keeps the watchdog alive', async () => {
+  let aborts = 0;
+  let streamDeltas = 0;
+  const ask = async (_userText, options) => {
+    options.onStreamDelta();
+    streamDeltas += 1;
+    await wait(12);
+    options.onStreamDelta();
+    streamDeltas += 1;
+    await wait(12);
+    return { result: { content: '' }, session: { messages: [] } };
+  };
+  const { bag } = makeTurnBag(ask, {
+    timeoutMs: 20,
+    abort: () => { aborts += 1; },
+  });
+
+  assert.equal(await createRunTurn(bag)('do a thing'), 'done');
+  assert.equal(streamDeltas, 2);
+  assert.equal(aborts, 0);
+});
+
+test('onSteerMessage commits a streamed no-newline assistant tail into items', async () => {
+  // A terminal no-tool response streams a single line WITHOUT a trailing '\n',
+  // so no assistant row/currentAssistantId exists yet. A steering injection
+  // races finalization and must seal the pending tail instead of dropping it.
+  const TAIL = 'partial answer with no trailing newline';
+  const ask = async (_userText, opts) => {
+    opts.onTextDelta(TAIL);
+    opts.onSteerMessage('steer now');
+    return { result: { content: '' }, session: { messages: [] } };
+  };
+  const { bag, getState } = makeTurnBag(ask);
+  const runTurn = createRunTurn(bag);
+
+  await runTurn('do a thing');
+
+  const assistant = getState().items.find((it) => it.kind === 'assistant');
+  assert.ok(assistant, 'streamed no-newline tail must be committed as an assistant item');
+  assert.equal(assistant.text, TAIL);
+  assert.equal(assistant.streaming, false);
+});
+
+test('finalization does not duplicate a steer-committed tail when result.content repeats it', async () => {
+  // Same steer race, but the provider's final content equals the already-
+  // committed tail. Finalization must NOT re-emit it as a second item.
+  const TAIL = 'partial answer with no trailing newline';
+  const ask = async (_userText, opts) => {
+    opts.onTextDelta(TAIL);
+    opts.onSteerMessage('steer now');
+    return { result: { content: TAIL }, session: { messages: [] } };
+  };
+  const { bag, getState } = makeTurnBag(ask);
+  const runTurn = createRunTurn(bag);
+
+  await runTurn('do a thing');
+
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.equal(assistants.length, 1, 'the committed tail must not be duplicated at finalize');
+  assert.equal(assistants[0].text, TAIL);
+  assert.equal(assistants[0].streaming, false);
+});
+
+test('finalization appends only the uncommitted remainder past a steer-committed tail', async () => {
+  // Provider content extends past the committed tail: only the new remainder
+  // becomes a fresh item, ordered after the committed segment (+ steering row).
+  const TAIL = 'partial answer with no trailing newline';
+  const REMAINDER = '\nmore text arriving after the steer';
+  const ask = async (_userText, opts) => {
+    opts.onTextDelta(TAIL);
+    opts.onSteerMessage('steer now');
+    return { result: { content: TAIL + REMAINDER }, session: { messages: [] } };
+  };
+  const { bag, getState } = makeTurnBag(ask);
+  const runTurn = createRunTurn(bag);
+
+  await runTurn('do a thing');
+
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.equal(assistants.length, 2, 'committed tail + remainder are two distinct items');
+  assert.equal(assistants[0].text, TAIL, 'committed tail stays first, unchanged');
+  assert.equal(assistants[1].text, REMAINDER, 'only the uncommitted remainder is appended');
+  assert.equal(assistants[1].streaming, false);
+  const steerIdx = getState().items.findIndex((it) => it.kind === 'user' && it.text === 'steer now');
+  const remainderIdx = getState().items.findIndex((it) => it.kind === 'assistant' && it.text === REMAINDER);
+  assert.ok(steerIdx >= 0 && remainderIdx > steerIdx, 'remainder appends after the injected steering row');
+});
+
+// Two committed segments this turn: a prior preamble P, then a no-newline TAIL
+// sealed by the steer race. The provider's final content may OMIT P — the
+// per-segment strip must still peel BOTH out (a single concatenated 'P+TAIL'
+// prefix would fail to match and duplicate TAIL after the steering row).
+const P = 'preamble sealed before the tail';
+const TAIL2 = 'terminal tail with no trailing newline';
+function makeTwoSegmentAsk(finalContent) {
+  return async (_userText, opts) => {
+    opts.onTextDelta(P);
+    opts.onSteerMessage('steer one'); // seals P as its own item
+    opts.onTextDelta(TAIL2);
+    opts.onSteerMessage('steer two'); // seals TAIL2 as its own item
+    return { result: { content: finalContent }, session: { messages: [] } };
+  };
+}
+
+test('per-segment strip: final content = TAIL only (P omitted) → no new item', async () => {
+  const { bag, getState } = makeTurnBag(makeTwoSegmentAsk(TAIL2));
+  await createRunTurn(bag)('do a thing');
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.deepEqual(assistants.map((it) => it.text), [P, TAIL2], 'only the two committed segments exist');
+});
+
+test('per-segment strip: final content = P + newline + TAIL → no new item', async () => {
+  const { bag, getState } = makeTurnBag(makeTwoSegmentAsk(`${P}\n${TAIL2}`));
+  await createRunTurn(bag)('do a thing');
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.deepEqual(assistants.map((it) => it.text), [P, TAIL2], 'both segments stripped; nothing re-emitted');
+});
+
+test('per-segment strip: final content extends past both committed segments → only remainder', async () => {
+  const { bag, getState } = makeTurnBag(makeTwoSegmentAsk(`${P}\n${TAIL2}\nmore`));
+  await createRunTurn(bag)('do a thing');
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.equal(assistants.length, 3, 'committed P + TAIL + the new remainder');
+  assert.equal(assistants[2].text, '\nmore', 'only the uncommitted remainder is appended');
+  assert.equal(assistants[2].streaming, false);
+});
+
+test('per-segment strip: segment sealed WITH a leading newline still peels', async () => {
+  // The committed segment carries its own leading '\n' ('\nTAIL'); the provider
+  // returns the trimmed 'TAIL'. Trimming the segment before the compare lets it
+  // peel so it is not duplicated after the steering row.
+  const LEAD_TAIL = '\nterminal tail sealed with a leading newline';
+  const ask = async (_userText, opts) => {
+    opts.onTextDelta(LEAD_TAIL);
+    opts.onSteerMessage('steer now');
+    return { result: { content: LEAD_TAIL.replace(/^\s+/, '') }, session: { messages: [] } };
+  };
+  const { bag, getState } = makeTurnBag(ask);
+  await createRunTurn(bag)('do a thing');
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.equal(assistants.length, 1, 'leading-newline segment must not be duplicated at finalize');
+  assert.equal(assistants[0].text, LEAD_TAIL);
+});

package/scripts/tool-smoke.mjs

@@ -609,6 +609,19 @@ const graphOut = await executeCodeGraphTool('code_graph', {
   file: 'scripts/smoke.mjs',
 }, root);
 assertOk('code_graph', graphOut, /binding|spawnSync|symbol/i);
+const graphStringSymbolOut = await executeCodeGraphTool('code_graph', {
+  mode: 'symbols',
+  symbols: 'executeBuiltinTool',
+}, root);
+assertOk('code_graph string symbols', graphStringSymbolOut, /executeBuiltinTool|symbol_search/i);
+const graphRootAnchorOut = await executeCodeGraphTool('code_graph', {
+  mode: 'symbol_search',
+  symbol: 'executeBuiltinTool',
+  file: root,
+}, root);
+if (/file not found|outside cwd|arbitrary tree/i.test(String(graphRootAnchorOut))) {
+  throw new Error(`code_graph redundant root anchor was not normalized:\n${graphRootAnchorOut}`);
+}
 
 const graphSymbolBatchOut = await executeCodeGraphTool('code_graph', {
   mode: 'symbol_search',
@@ -1242,16 +1255,11 @@ if (normalizedExplore.length !== 2 || normalizedExplore[0] !== 'where is model s
 }
 if (MAX_FANOUT_QUERIES !== 8) throw new Error(`explore fanout cap changed: ${MAX_FANOUT_QUERIES}`);
 const explorerPrompt = buildExplorerPrompt('where is <agent> & status?');
-if (!explorerPrompt.includes('&lt;agent&gt;') || !explorerPrompt.includes('&amp;') || /verdicts, ratings, or recommendations/.test(explorerPrompt) === false) {
+if (explorerPrompt !== '<query>where is &lt;agent&gt; &amp; status?</query>') {
   throw new Error(`explorer prompt contract failed: ${explorerPrompt}`);
 }
-if (
-  !/STOP and answer NOW/.test(explorerPrompt)
-  || !/Turns 2-3 exist SOLELY as zero-hit recovery/.test(explorerPrompt)
-  || !/HARD max 3 tool turns/.test(explorerPrompt)
-  || !/turn 1\/3/.test(explorerPrompt)
-) {
-  throw new Error(`explorer prompt must force immediate answer on a specific-token anchor while preserving the 3-turn cap: ${explorerPrompt}`);
+if (/Reminder:|BUDGET|STOP and answer|verdicts|ratings|recommendations|grep|code_graph|find|glob/i.test(explorerPrompt)) {
+  throw new Error(`explorer prompt must not duplicate the system routing/fan-out contract: ${explorerPrompt}`);
 }
 setInternalToolsProvider({
   executor: async () => 'tool-smoke internal tool',
@@ -1358,7 +1366,7 @@ setInternalToolsProvider({
     if (!/Read-only retrieval role/i.test(visible) || /# environment/i.test(visible) || /git operations deferred to Lead/i.test(visible)) {
       throw new Error(`explorer hidden retrieval context should stay slim: ${visible.slice(0, 1200)}`);
     }
-    if (!/# Role: explorer/i.test(systemVisible) || /# Role: explorer/i.test(userReminderVisible) || !/Coordinate locator/i.test(systemVisible)) {
+    if (!/# Role: explorer/i.test(systemVisible) || /# Role: explorer/i.test(userReminderVisible) || !/deliver WHERE/i.test(systemVisible)) {
       throw new Error(`explorer role md must ride BP2 system, not BP3 user reminder: system=${systemVisible.slice(0, 600)} user=${userReminderVisible.slice(0, 600)}`);
     }
     // System layers (BP1 tool policy + BP2 role md) are shared/frozen and sized
@@ -1734,7 +1742,7 @@ const readArrayItemAnyOf = readArraySchema?.items?.anyOf || [];
 if (!readArrayItemAnyOf.some((entry) => entry?.type === 'object' && entry?.properties?.offset && entry?.properties?.limit)) {
   throw new Error('read schema must expose array-of-region objects for batched spans');
 }
-if (/line\+context/i.test(readDescription) || !/verified file path/i.test(readDescription) || !/Unknown path.*find first/i.test(readDescription) || !/Batch paths\/regions as real arrays/i.test(readDescription)) {
+if (/line\+context/i.test(readDescription) || !/verified file path/i.test(readDescription) || !/guessed path.*find first/i.test(readDescription) || !/Batch paths\/regions as real arrays/i.test(readDescription)) {
   throw new Error('read description must expose offset/limit as the single window form');
 }
 if (readProps.line || readProps.context) {
@@ -1834,7 +1842,7 @@ if (codeGraphSymbolSearchErr) {
 if (!/code structure\/flow/i.test(codeGraphDescription) || !/symbols\/references\/calls\/deps/i.test(codeGraphDescription)) {
   throw new Error('code_graph description must stay structure-oriented and name its symbol modes');
 }
-if (!/Known symbols or verified files only/i.test(codeGraphDescription) || !/Batch symbols\[\]\/files\[\]/i.test(codeGraphDescription)) {
+if (!/files\[\] must be verified paths/i.test(codeGraphDescription) || !/Batch symbols\[\]\/files\[\]/i.test(codeGraphDescription)) {
   throw new Error('code_graph description must route unknown file paths through locators first');
 }
 if (!/repo-local/i.test(codeGraphDescription) || !/NOT web search|not web/i.test(codeGraphDescription)) {
@@ -2150,7 +2158,7 @@ const grepHeadLimitDescription = grepTool?.inputSchema?.properties?.head_limit?.
 if (!/Array = variants in one call/i.test(grepPatternDescription) || !/Verified file\/dir/i.test(grepPathDescription)) {
   throw new Error('grep schema must keep compact pattern/path guidance');
 }
-if (!/verified scope/i.test(grepTool?.description || '') || !/Unknown path\/name.*find first/i.test(grepTool?.description || '')) {
+if (!/verified scope/i.test(grepTool?.description || '') || !/guessed path fragment.*find first/i.test(grepTool?.description || '')) {
   throw new Error('grep description must require verified scopes and locator-first unknown paths');
 }
 if (!/Glob filter/i.test(grepGlobDescription) || !/no guessed src\/\*\*/i.test(grepGlobDescription)) {
@@ -2174,7 +2182,7 @@ if (!/exact glob from verified roots/i.test(globTool?.description || '')) {
 if (!/Partial path\/name lookup/i.test(findTool?.description || '') || !/verify roots before grep\/glob/i.test(findTool?.description || '')) {
   throw new Error('find description must advertise unverified path/name lookup and verified outputs');
 }
-if (!/List verified directories/i.test(listTool?.description || '') || !/Unknown dir.*find first/i.test(listTool?.description || '') || !/Verified directory/i.test(listTool?.inputSchema?.properties?.path?.description || '')) {
+if (!/List verified directories/i.test(listTool?.description || '') || !/Guessed dir.*find first/i.test(listTool?.description || '') || !/Verified directory/i.test(listTool?.inputSchema?.properties?.path?.description || '')) {
   throw new Error('list description must require verified directories and locator-first unknown dirs');
 }
 if (!/Repo-local/i.test(codeGraphProps.mode?.description || '') || !/one call/i.test(codeGraphProps.symbols?.description || '')) {