mixdog 0.9.62 → 0.9.64

package/scripts/explore-prompt-policy-test.mjs

@@ -1,256 +0,0 @@
-#!/usr/bin/env node
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { buildExplorerPrompt } from '../src/standalone/explore-tool.mjs';
-import { EXPLORE_TOOL } from '../src/standalone/explore-tool.mjs';
-import { BUILTIN_TOOLS } from '../src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs';
-import { CODE_GRAPH_TOOL_DEFS } from '../src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs';
-import { TOOL_SEARCH_TOOL } from '../src/session-runtime/tool-defs.mjs';
-import { createEagerDispatcher } from '../src/runtime/agent/orchestrator/session/eager-dispatch.mjs';
-import { crossTurnSignature } from '../src/runtime/agent/orchestrator/session/loop/completion-guards.mjs';
-import {
-  isEagerDispatchable,
-  isToolCallDedupEligible,
-} from '../src/runtime/agent/orchestrator/session/loop/tool-helpers.mjs';
-import { assertCodeGraphDescriptionContract } from './code-graph-description-contract.mjs';
-
-test('explore per-query prompt contains only escaped query XML', () => {
-  const prompt = buildExplorerPrompt('display model usage show usage model_usage provider_usage session cache usage state');
-  assert.equal(prompt, '<query>display model usage show usage model_usage provider_usage session cache usage state</query>');
-  assert.doesNotMatch(prompt, /Reminder:|BUDGET|TURN 1|STOP and answer|verdicts|ratings|recommendations/i);
-  assert.equal(buildExplorerPrompt('where is <agent> & status?'), '<query>where is &lt;agent&gt; &amp; status?</query>');
-});
-
-test('builtin route descriptions carry the shortest verified-path policy', () => {
-  const byName = Object.fromEntries(BUILTIN_TOOLS.map((tool) => [tool.name, tool]));
-  // Conditional find-first: only genuinely guessed fragments route through
-  // find, and in the SAME turn — project root itself is a verified scope.
-  assert.match(byName.grep.description, /project root counts as verified/i);
-  assert.match(byName.grep.description, /guessed path fragment → find first/i);
-  assert.match(byName.grep.description, /no path "\." \+ guessed src\/\*\*/i);
-  assert.match(byName.glob.description, /project root is verified/i);
-  assert.match(byName.glob.description, /Guessed root\/name → find first/i);
-  assert.match(byName.find.description, /output paths are verified/i);
-  assert.match(byName.read.description, /guessed path\/name → find first/i);
-  assert.match(byName.read.description, /Batch paths\/regions as real arrays.*path\[\]/i);
-  assert.match(byName.shell.description, /Shell\/write calls are serial/i);
-  assert.doesNotMatch(byName.shell.description, /parallel calls/i);
-  assert.match(byName.find.description, /lookup only for unknown partial paths\/names/i);
-  assert.match(byName.find.description, /project root or already-verified roots/i);
-  assert.doesNotMatch(byName.grep.description, /find for that fragment before any grep\/glob/i);
-  assert.match(byName.grep.description, /nonzero content_with_context result resolves that search concept/i);
-  assert.match(byName.grep.description, /Only zero\/error results may change tokens or scope/i);
-  assert.match(`${byName.code_graph?.description || ''} ${CODE_GRAPH_TOOL_DEFS[0]?.inputSchema?.properties?.symbols?.description || ''}`, /multiple exact symbols use one symbols\[\] call/i);
-  assert.match(CODE_GRAPH_TOOL_DEFS[0]?.description || '', /verified source files only/i);
-});
-
-test('shared tool policy routes facets without duplicate content acquisition', () => {
-  const rule = readFileSync(new URL('../src/rules/shared/01-tool.md', import.meta.url), 'utf8');
-  const policy = rule.replace(/\s+/g, ' ');
-  assert.match(policy, /for each facet choose exactly one shortest locator route/i);
-  assert.match(policy, /broad\/uncertain→\s*`explore`.*partial path\/name→\s*`find`.*verified root\+wildcard→\s*`glob`.*quoted\/non-identifier literal or regex→\s*`grep`.*exact code identifier\/relation→\s*`code_graph` before grep/i);
-  assert.match(policy, /grep only for a requested literal occurrence or after graph zero\/error/i);
-  assert.match(policy, /batch compatible targets/i);
-  assert.match(policy, /parallelize distinct facets only, never alternative routes for one facet/i);
-  assert.match(policy, /put independent read-only calls in one turn; they may run concurrently regardless of tool/i);
-  assert.match(policy, /after locator results, collect all known candidate files\/regions before inspection/i);
-  assert.match(policy, /batch compatible reads.*same-file regions.*in one `path\[\]` call and graph targets in arrays/i);
-  assert.match(policy, /parallelize independent incompatible read-only inspections/i);
-  assert.match(policy, /do not start a singleton while a known compatible candidate remains/i);
-  assert.match(policy, /shell\/write calls are serial/i);
-  assert.match(policy, /later turns are only for targets dependent on prior results or unresolved facets/i);
-  assert.match(policy, /stop when evidence covers the deliverable/i);
-  assert.match(policy, /sufficient contextual grep means no overlapping `read`/i);
-  assert.match(policy, /files_with_matches.*count.*capped.*insufficient context.*inspect only missing content/i);
-  assert.match(policy, /known file\/span→`read` directly without `grep`/i);
-  assert.doesNotMatch(policy, /retrieval[^.]{0,120}\b(?:one|at most \d+)\s+(?:lookup|inspection|turn|call)/i);
-  assert.doesNotMatch(policy, /\bput independent calls in one turn\b/i);
-  assert.doesNotMatch(policy, /\b(?:all|every)\s+(?:independent\s+)?(?:calls|tool calls)\b[^.]{0,80}\bone turn\b/i);
-  assert.doesNotMatch(policy, /\bone lookup\b[^.]{0,80}\bat most\b[^.]{0,40}\binspection\b/i);
-  assert.doesNotMatch(policy, /all (?:independent )?(?:calls|tool calls|targets)[^.]{0,100}\bone (?:tool )?(?:message|call)/i);
-});
-
-test('explorer locator policy retains its compact behavioral contract', () => {
-  const rule = readFileSync(new URL('../src/rules/agent/30-explorer.md', import.meta.url), 'utf8');
-  const policy = rule.replace(/\s+/g, ' ');
-  const required = [
-    /Return only WHERE \(`path:line`\), never WHY[\s\S]*You ARE `explore`; never call it/i,
-    /only grep\/find\/glob\/code_graph[\s\S]*`read` and `list` are forbidden/i,
-    /Turn 1 \(`turn 1\/3`\) is the whole search[\s\S]*Split broad\/uncertain input into every known facet[\s\S]*one batch under the shared one-route contract[\s\S]*upstream producer\/derivation layer[\s\S]*SAME batch[\s\S]*Follow-up turns batch every unresolved facet in parallel[\s\S]*single-tool turn is allowed only when exactly one pre-anchor\/zero-hit facet remains/i,
-    /broad grep use `output_mode:"files_with_matches"`[\s\S]*`content_with_context` with `head_limit` only on paths returned this session/i,
-    /Each pattern is one identifier, camel\/snake variant, or concept synonym[\s\S]*never a prose phrase[\s\S]*Spaces and non-ASCII are allowed only in verbatim quoted error\/log literals[\s\S]*Translate other non-English queries to English identifiers/i,
-    /Scope is session cwd[\s\S]*For unverified `src` paths, use `find` first[\s\S]*never guess or invent directories[\s\S]*`path:"\."` with guessed `src\/\*\*`[\s\S]*exact find-returned path[\s\S]*no earlier than turn 2[\s\S]*After zero hits, change tokens or scope, never wording or guessed paths/i,
-    /anchor is a `path:line` containing a query token or synonym[\s\S]*code_graph hit[\s\S]*Generic terms without query specificity are zero[\s\S]*Never re-locate, reconfirm, or upgrade an anchor[\s\S]*path without `:line` is a pre-anchor and counts as zero/i,
-    /After every result, stop and answer on any specific-token anchor[\s\S]*mark a weak anchor `\?`/i,
-    /code-location query left only with pre-anchors[\s\S]*sole anchor-minting follow-up[\s\S]*one scoped `content_with_context` grep with `head_limit`[\s\S]*If it returns zero[\s\S]*changed tokens or scope[\s\S]*Never make a second minting hop or fabricate\/estimate a line/i,
-    /at most 3 turns[\s\S]*label every tool message `turn N\/3`[\s\S]*normally use one batch and one answer[\s\S]*Turns 2–3 are allowed only when turn 1 has zero anchors/i,
-    /first matching entry\/definition anchors a concept, value, or default[\s\S]*never trace its chain[\s\S]*explicit flow or default-resolution query[\s\S]*entry anchor but no resolved value[\s\S]*turn 2 for one resolving hop/i,
-    /Answer in at most 3 lines[\s\S]*`path:line — symbol — short reason`[\s\S]*Copy every cited `path:line` verbatim[\s\S]*tool result in this session[\s\S]*never estimate, adjust, or recall/i,
-    /Every code-location line requires `:line`[\s\S]*never return a bare filename or vague prose/i,
-    /file\/dir-location query may return an exact verified path without `:line`/i,
-    /Return `EXPLORATION_FAILED` only after spending the budget with zero anchors[\s\S]*prefer a weak anchor to a false miss/i,
-  ];
-  for (const behavior of required) assert.match(policy, behavior);
-  assert.doesNotMatch(policy, /grep[^.]{0,120}\band\b[^.]{0,120}code_graph[^.]{0,120}\band\b[^.]{0,120}find/i);
-});
-
-test('canonical schemas advertise safe batching without changing tool shapes', () => {
-  const graph = CODE_GRAPH_TOOL_DEFS[0];
-  const patch = readFileSync(new URL('../src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs', import.meta.url), 'utf8');
-  const mode = graph?.inputSchema?.properties?.mode?.description || '';
-  const description = graph?.description || '';
-  const symbols = graph?.inputSchema?.properties?.symbols?.description || '';
-  assert.doesNotThrow(() => assertCodeGraphDescriptionContract({
-    description,
-    modeDescription: mode,
-    symbolsDescription: symbols,
-  }));
-  assert.deepEqual(graph?.inputSchema?.required, ['mode']);
-  assert.equal(graph?.inputSchema?.properties?.file, undefined);
-  assert.equal(graph?.inputSchema?.properties?.symbol, undefined);
-  assert.match(patch, /one patch/i);
-  assert.match(patch, /one file block per target/i);
-});
-
-test('code graph and eager-dispatch boundaries preserve runtime shape', () => {
-  const schema = CODE_GRAPH_TOOL_DEFS[0]?.inputSchema?.properties || {};
-  const fileModes = ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols'];
-  const symbolModes = ['symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees'];
-  assert.deepEqual(new Set(schema.mode?.enum), new Set([...fileModes, ...symbolModes]));
-  const assertBatchShape = (field) => {
-    assert.equal(field?.anyOf?.length, 2);
-    assert.deepEqual(field.anyOf.map((entry) => entry.type), ['string', 'array']);
-    assert.equal(field.anyOf[1].items.type, 'string');
-    assert.equal(field.anyOf[1].minItems, 1);
-  };
-  assertBatchShape(schema.files);
-  assertBatchShape(schema.symbols);
-  assert.equal(schema.file, undefined);
-  assert.equal(schema.symbol, undefined);
-  assert.equal(schema.language, undefined);
-  const tools = [
-    ...BUILTIN_TOOLS,
-    { name: 'mcp_read', annotations: { readOnlyHint: true } },
-    { name: 'mcp_write', annotations: { readOnlyHint: false } },
-  ];
-  assert.equal(isEagerDispatchable('read', tools), true);
-  assert.equal(isEagerDispatchable('shell', tools), false);
-  assert.equal(isEagerDispatchable('mcp_read', tools), true);
-  assert.equal(isEagerDispatchable('mcp_write', tools), false);
-  assert.equal(isToolCallDedupEligible('read', tools), true);
-  assert.equal(isToolCallDedupEligible('mcp_read', tools), true);
-});
-
-test('same-batch load_tool and legacy tool_search repeats all execute eagerly', async () => {
-  const tools = [...BUILTIN_TOOLS, TOOL_SEARCH_TOOL];
-  assert.equal(isEagerDispatchable('load_tool', tools), true);
-  assert.equal(isEagerDispatchable('tool_search', tools), true);
-  assert.equal(isToolCallDedupEligible('load_tool', tools), false);
-  assert.equal(isToolCallDedupEligible('tool_search', tools), false);
-  assert.equal(isToolCallDedupEligible('read', tools), true);
-
-  const args = { names: ['shell'] };
-  const calls = [
-    { id: 'load-1', name: 'load_tool', arguments: args },
-    { id: 'load-2', name: 'load_tool', arguments: args },
-    { id: 'legacy-1', name: 'tool_search', arguments: args },
-    { id: 'legacy-2', name: 'tool_search', arguments: args },
-  ];
-  const executed = [];
-  const crossTurnCalls = new Map([
-    [crossTurnSignature('load_tool', args), { count: 1, firstIteration: 1 }],
-    [crossTurnSignature('tool_search', args), { count: 1, firstIteration: 1 }],
-  ]);
-  const dispatcher = createEagerDispatcher({
-    tools,
-    cwd: process.cwd(),
-    sessionId: null,
-    sessionRef: {},
-    signal: null,
-    opts: {},
-    crossTurnCalls,
-    getIterations: () => 2,
-    getNextIteration: () => 2,
-    repeatFailLimit: 3,
-    executeToolFn: async (name) => {
-      executed.push(name);
-      return '{}';
-    },
-  });
-  dispatcher.startEagerRun(calls, 0, new Set());
-  assert.equal(dispatcher.pending.size, 4);
-  await Promise.all([...dispatcher.pending.values()].map((entry) => entry.promise));
-  assert.deepEqual(executed, ['load_tool', 'load_tool', 'tool_search', 'tool_search']);
-
-  const normalExecuted = [];
-  const normalDispatcher = createEagerDispatcher({
-    tools,
-    cwd: process.cwd(),
-    sessionId: null,
-    sessionRef: {},
-    signal: null,
-    opts: {},
-    crossTurnCalls: new Map(),
-    getIterations: () => 1,
-    getNextIteration: () => 1,
-    repeatFailLimit: 3,
-    executeToolFn: async (name) => {
-      normalExecuted.push(name);
-      return 'ok';
-    },
-  });
-  normalDispatcher.startEagerRun([
-    { id: 'read-1', name: 'read', arguments: { path: 'same.txt' } },
-    { id: 'read-2', name: 'read', arguments: { path: 'same.txt' } },
-  ], 0, new Set());
-  await Promise.all([...normalDispatcher.pending.values()].map((entry) => entry.promise));
-  assert.deepEqual(normalExecuted, ['read']);
-});
-
-test('code graph descriptions partition file and symbol targets', () => {
-  const description = CODE_GRAPH_TOOL_DEFS[0]?.description || '';
-  const mode = CODE_GRAPH_TOOL_DEFS[0]?.inputSchema?.properties?.mode?.description || '';
-  assert.match(mode, /file modes=\{overview,imports,dependents,related,impact\}.*symbols with files.*files\[\].*file outline/i);
-  assert.match(mode, /symbol modes=\{find_symbol,symbol_search,search,references,callers,callees\}.*fileless symbols.*symbol_search keywords/i);
-  assert.match(description, /exact identifiers.*find_symbol\/references\/callers\/callees.*keywords.*symbol_search\/search/i);
-  assert.match(description, /IDs→graph; literal\/zero→grep/i);
-  assert.match(description, /unsupported target arrays.*omitted.*never silently mixed/i);
-  assert.match(CODE_GRAPH_TOOL_DEFS[0]?.inputSchema?.properties?.files?.description || '', /supported targets only/i);
-  assert.match(CODE_GRAPH_TOOL_DEFS[0]?.inputSchema?.properties?.symbols?.description || '', /exact identifiers.*keywords/i);
-  const grep = Object.fromEntries(BUILTIN_TOOLS.map((tool) => [tool.name, tool])).grep;
-  assert.match(grep.description, /quoted\/non-identifier literal or regex→grep/i);
-  assert.doesNotMatch(grep.inputSchema.properties.pattern.description, /code_graph/i);
-});
-
-test('retrieval schemas require their primary arguments and preserve region paths', () => {
-  const byName = Object.fromEntries(BUILTIN_TOOLS.map((tool) => [tool.name, tool]));
-  const read = byName.read.inputSchema;
-  assert.deepEqual(read.required, ['path']);
-  const region = read.properties.path.anyOf[1].items.anyOf[1];
-  assert.deepEqual(region.required, ['path']);
-  assert.deepEqual(byName.grep.inputSchema.anyOf, [{ required: ['pattern'] }, { required: ['glob'] }]);
-  assert.deepEqual(byName.grep.inputSchema.properties.output_mode.enum, ['content_with_context', 'files_with_matches', 'count']);
-  const grepSchema = byName.grep.inputSchema;
-  const valid = (value) => grepSchema.anyOf.some((branch) => branch.required.every((key) => Object.hasOwn(value, key)));
-  assert.equal(valid({ pattern: 'x' }), true);
-  assert.equal(valid({ glob: '*.mjs' }), true);
-  assert.equal(valid({}), false);
-});
-
-test('grep scopes do not masquerade as read regions', () => {
-  const pattern = Object.fromEntries(BUILTIN_TOOLS.map((tool) => [tool.name, tool])).grep.inputSchema.properties.pattern.description;
-  assert.match(pattern, /path\[\] batches verified scopes only/i);
-  assert.match(pattern, /file\/span reads use read path\[\] regions/i);
-  assert.doesNotMatch(pattern, /known files\/spans use path\[\]/i);
-});
-
-test('explore freezes returned facets and avoids re-location', () => {
-  assert.match(EXPLORE_TOOL.description, /freezes the LOCATION only/i);
-  assert.match(EXPLORE_TOOL.description, /read\/code_graph detail inspection is valid when content was not returned/i);
-  assert.match(EXPLORE_TOOL.description, /never re-locate it/i);
-  assert.match(EXPLORE_TOOL.description, /search only unresolved facets/i);
-  const rule = readFileSync(new URL('../src/rules/shared/01-tool.md', import.meta.url), 'utf8');
-  assert.match(rule, /freezes the LOCATION only[\s\S]*read or[\s\S]*code_graph detail inspection is valid[\s\S]*never re-locate it/i);
-  assert.match(rule, /nonzero[\s\S]*content_with_context[\s\S]*result resolves[\s\S]*act directly/i);
-});

package/scripts/explore-timeout-cancel-test.mjs

@@ -1,345 +0,0 @@
-#!/usr/bin/env node
-// Regression test for explore-tool wall-clock timeout + cancellation cleanup:
-//   - the default hard timeout is 60s (was 10min) and the
-//     MIXDOG_EXPLORE_HARD_TIMEOUT_MS override (including 0 = disabled) is kept;
-//   - a parent cancellation aborts every child compute AbortSignal immediately;
-//   - the wall-clock hard timeout aborts the compute AbortSignal (not just the
-//     race), so wedged compute tears down instead of running detached;
-//   - a canceled/timed-out compute purges its poisoned cache entry so a later
-//     call never awaits a dead promise and empties into "no tool output".
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import {
-    EXPLORE_COMPUTE_HARD_TIMEOUT_MS,
-    runExploreComputeWithAbort,
-    runExploreCached,
-    runExplore,
-    exploreStaggerDelay,
-    awaitExploreProviderReadyOrCancel,
-    ensureExploreProviderReady,
-    __exploreResultCacheForTest,
-} from '../src/standalone/explore-tool.mjs';
-
-const MODULE_URL = new URL('../src/standalone/explore-tool.mjs', import.meta.url).href;
-
-// A compute stub that rejects the moment its AbortSignal fires (mirrors a real
-// child dispatch tearing down on abort), and handles the already-aborted case.
-function abortAwareCompute(record) {
-    return (signal) => new Promise((_resolve, reject) => {
-        record?.(signal);
-        if (signal.aborted) { reject(signal.reason || new Error('aborted')); return; }
-        signal.addEventListener('abort', () => reject(signal.reason || new Error('aborted')), { once: true });
-    });
-}
-
-function readHardTimeoutWithEnv(value) {
-    const code = `import(${JSON.stringify(MODULE_URL)}).then((m) => process.stdout.write(String(m.EXPLORE_COMPUTE_HARD_TIMEOUT_MS)))`;
-    return execFileSync(process.execPath, ['--input-type=module', '-e', code], {
-        env: { ...process.env, MIXDOG_EXPLORE_HARD_TIMEOUT_MS: value },
-        encoding: 'utf8',
-    }).trim();
-}
-
-// The production hard-timeout timer is unref()'d (must never keep the host
-// process alive). In an otherwise-idle test that relies on that timer firing,
-// hold a ref'd timer so the event loop stays alive until the assertion settles.
-function keepEventLoopAlive(ms = 5_000) {
-    const t = setTimeout(() => {}, ms);
-    return () => clearTimeout(t);
-}
-
-test('default explore hard timeout is 60 seconds', () => {
-    // Only meaningful when the override is unset (the CI/default environment).
-    if (process.env.MIXDOG_EXPLORE_HARD_TIMEOUT_MS == null) {
-        assert.equal(EXPLORE_COMPUTE_HARD_TIMEOUT_MS, 60_000);
-    }
-});
-
-test('MIXDOG_EXPLORE_HARD_TIMEOUT_MS override is preserved (including 0 = disabled)', () => {
-    assert.equal(readHardTimeoutWithEnv('1234'), '1234');
-    assert.equal(readHardTimeoutWithEnv('0'), '0');
-    assert.equal(readHardTimeoutWithEnv('90000'), '90000');
-});
-
-test('hard timeout aborts the compute AbortSignal', async () => {
-    const release = keepEventLoopAlive();
-    try {
-        let received = null;
-        const p = runExploreComputeWithAbort((signal) => {
-            received = signal;
-            return new Promise(() => {}); // never settles on its own
-        }, null, 25);
-        await assert.rejects(p, /timed out/);
-        assert.ok(received, 'compute received a signal');
-        assert.equal(received.aborted, true);
-    } finally {
-        release();
-    }
-});
-
-test('parent cancellation aborts every child compute immediately', async () => {
-    const parent = new AbortController();
-    const seen = [];
-    const p1 = runExploreComputeWithAbort(abortAwareCompute((s) => seen.push(s)), parent.signal, 10_000);
-    const p2 = runExploreComputeWithAbort(abortAwareCompute((s) => seen.push(s)), parent.signal, 10_000);
-    parent.abort(new Error('user pressed ESC'));
-    await assert.rejects(p1);
-    await assert.rejects(p2);
-    assert.equal(seen.length, 2);
-    assert.ok(seen.every((s) => s.aborted), 'both child signals aborted');
-});
-
-test('an already-aborted parent signal aborts the compute up front', async () => {
-    const parent = new AbortController();
-    parent.abort(new Error('already canceled'));
-    let received = null;
-    const p = runExploreComputeWithAbort(abortAwareCompute((s) => { received = s; }), parent.signal, 10_000);
-    await assert.rejects(p);
-    assert.ok(received.aborted, 'compute signal was already aborted');
-});
-
-test('a canceled compute purges its poisoned cache entry', async () => {
-    // Force the result cache on so the in-flight promise is stored.
-    process.env.MIXDOG_EXPLORE_RESULT_CACHE = '1';
-    const cache = __exploreResultCacheForTest();
-    cache.clear();
-    const key = 'explore-cancel-poison-key';
-    const parent = new AbortController();
-    const promise = runExploreCached(key, abortAwareCompute(), parent.signal);
-    // Pending promise cached while the compute is in flight.
-    assert.equal(cache.has(key), true);
-    parent.abort(new Error('cancel'));
-    await assert.rejects(promise);
-    // The poisoned pending entry must be gone so a later call recomputes fresh
-    // instead of awaiting the dead promise.
-    assert.equal(cache.has(key), false);
-});
-
-test('a wedged never-resolving shared compute is purged by its real hard-timeout timer and recomputed', async () => {
-    process.env.MIXDOG_EXPLORE_RESULT_CACHE = '1';
-    const cache = __exploreResultCacheForTest();
-    cache.clear();
-    const key = 'shared-hard-timeout-wedged';
-    const seen = [];
-    let calls = 0;
-    const neverResolves = (signal) => { calls += 1; seen.push(signal); return new Promise(() => {}); };
-    const release = keepEventLoopAlive();
-    try {
-        await assert.rejects(runExploreCached(key, neverResolves, null, 25), /timed out/);
-        assert.equal(seen[0].aborted, true, 'the timer aborted the actual wedged compute');
-        assert.equal(cache.has(key), false, 'timed-out pending entry was purged');
-        assert.equal(await runExploreCached(key, () => { calls += 1; return Promise.resolve('fresh'); }, null, 100), 'fresh');
-        assert.equal(calls, 2, 'a later caller recomputes rather than reusing the rejected promise');
-    } finally {
-        release();
-    }
-});
-
-// A compute whose settlement the test controls, recording the AbortSignal it
-// received so shared-compute teardown can be asserted.
-function deferredCompute() {
-    const handle = { signal: null, resolve: null, reject: null };
-    handle.fn = (signal) => new Promise((resolve, reject) => {
-        handle.signal = signal;
-        handle.resolve = resolve;
-        handle.reject = reject;
-    });
-    return handle;
-}
-
-test('parent cancellation rejects immediately even for a non-cooperative compute', async () => {
-    // The compute IGNORES its AbortSignal (never settles on abort). Cancellation
-    // must still reject the returned promise right away — not hang until the
-    // wall-clock hard timeout.
-    const parent = new AbortController();
-    const p = runExploreComputeWithAbort(() => new Promise(() => {}), parent.signal, 10_000);
-    const t0 = Date.now();
-    parent.abort(new Error('user pressed ESC'));
-    await assert.rejects(p);
-    assert.ok(Date.now() - t0 < 500, 'rejected promptly, not after the hard timeout');
-});
-
-test('never-resolving compute is torn down by the hard timeout (real cleanup)', async () => {
-    const release = keepEventLoopAlive();
-    try {
-        let received = null;
-        const p = runExploreComputeWithAbort((signal) => {
-            received = signal;
-            return new Promise(() => {}); // never resolves, never observes abort
-        }, null, 30);
-        await assert.rejects(p, /timed out/);
-        assert.equal(received.aborted, true, 'compute signal aborted on timeout');
-    } finally {
-        release();
-    }
-});
-
-test('owner cancellation does not abort an unaffected later subscriber', async () => {
-    process.env.MIXDOG_EXPLORE_RESULT_CACHE = '1';
-    const cache = __exploreResultCacheForTest();
-    cache.clear();
-    const key = 'shared-owner-cancel';
-    const dc = deferredCompute();
-    const owner = new AbortController();
-    const later = new AbortController();
-    const ownerP = runExploreCached(key, dc.fn, owner.signal); // starts shared compute
-    const laterP = runExploreCached(key, dc.fn, later.signal); // subscribes to the same compute
-    owner.abort(new Error('owner ESC'));
-    await assert.rejects(ownerP);
-    // The shared compute must keep running for the still-active later subscriber.
-    assert.equal(dc.signal.aborted, false, 'shared compute not aborted by owner cancel');
-    assert.equal(cache.has(key), true);
-    dc.resolve('src/x.mjs:1 — shared hit');
-    assert.match(String(await laterP), /src\/x\.mjs:1/);
-});
-
-test('later subscriber cancellation releases itself without aborting the shared compute', async () => {
-    process.env.MIXDOG_EXPLORE_RESULT_CACHE = '1';
-    const cache = __exploreResultCacheForTest();
-    cache.clear();
-    const key = 'shared-later-cancel';
-    const dc = deferredCompute();
-    const owner = new AbortController();
-    const later = new AbortController();
-    const ownerP = runExploreCached(key, dc.fn, owner.signal);
-    const laterP = runExploreCached(key, dc.fn, later.signal);
-    later.abort(new Error('later ESC'));
-    await assert.rejects(laterP);
-    assert.equal(dc.signal.aborted, false, 'owner still waiting; compute alive');
-    assert.equal(cache.has(key), true);
-    dc.resolve('src/y.mjs:2 — owner result');
-    assert.match(String(await ownerP), /src\/y\.mjs:2/);
-});
-
-test('all subscribers canceling aborts the shared compute and purges the cache', async () => {
-    process.env.MIXDOG_EXPLORE_RESULT_CACHE = '1';
-    const cache = __exploreResultCacheForTest();
-    cache.clear();
-    const key = 'shared-all-cancel';
-    const dc = deferredCompute();
-    const a = new AbortController();
-    const b = new AbortController();
-    const pa = runExploreCached(key, dc.fn, a.signal);
-    const pb = runExploreCached(key, dc.fn, b.signal);
-    a.abort(new Error('a ESC'));
-    await assert.rejects(pa);
-    assert.equal(cache.has(key), true, 'b still subscribed; compute retained');
-    assert.equal(dc.signal.aborted, false);
-    b.abort(new Error('b ESC'));
-    await assert.rejects(pb);
-    assert.equal(dc.signal.aborted, true, 'last subscriber gone; shared compute torn down');
-    assert.equal(cache.has(key), false, 'purged so a future call recomputes');
-});
-
-test('a failed shared compute is purged so future calls recompute', async () => {
-    process.env.MIXDOG_EXPLORE_RESULT_CACHE = '1';
-    const cache = __exploreResultCacheForTest();
-    cache.clear();
-    const key = 'shared-recompute';
-    let calls = 0;
-    const compute = () => { calls += 1; return Promise.reject(new Error(`owner fail ${calls}`)); };
-    await assert.rejects(runExploreCached(key, compute, null));
-    assert.equal(cache.has(key), false);
-    await assert.rejects(runExploreCached(key, compute, null));
-    assert.equal(calls, 2, 'recomputed rather than deduping on the dead promise');
-});
-
-test('stagger delay is canceled before dispatch when the signal aborts', async () => {
-    const ctrl = new AbortController();
-    let dispatched = false;
-    const p = exploreStaggerDelay(10_000, ctrl.signal).then(() => { dispatched = true; return 'DISPATCHED'; });
-    ctrl.abort(new Error('cancel during stagger'));
-    await assert.rejects(p);
-    assert.equal(dispatched, false, 'child dispatch skipped after the stagger was canceled');
-});
-
-test('runtime-core forwards the caller signal into runExplore (plumbing)', () => {
-    const src = readFileSync(new URL('../src/session-runtime/runtime-core.mjs', import.meta.url), 'utf8');
-    const at = src.indexOf("name === 'explore'");
-    assert.ok(at >= 0, 'explore branch present in runtime-core');
-    const branch = src.slice(at, at + 1000);
-    assert.match(branch, /return await runExplore\(/);
-    assert.match(branch, /signal:\s*callerCtx\?\.signal\s*\|\|\s*session\?\.controller\?\.signal/);
-});
-
-test('runExplore short-circuits an already-canceled call without dispatching', async () => {
-    const ctrl = new AbortController();
-    ctrl.abort(new Error('canceled up front'));
-    const res = await runExplore({ query: 'anything at all' }, { signal: ctrl.signal });
-    assert.equal(res.isError, true);
-    assert.match(res.content?.[0]?.text || '', /cancel/i);
-});
-
-test('explore provider warmup is canceled immediately when the caller aborts mid-init', async () => {
-    const ctrl = new AbortController();
-    const ready = new Promise(() => {}); // warmup wedged (never resolves)
-    const t0 = Date.now();
-    const p = awaitExploreProviderReadyOrCancel(ready, ctrl.signal);
-    ctrl.abort(new Error('ESC during warmup'));
-    const canceled = await p;
-    assert.equal(canceled, true, 'reported canceled without waiting for warmup');
-    assert.ok(Date.now() - t0 < 500, 'returned promptly, did not block on warmup');
-});
-
-test('explore provider warmup aborts the real pending initializer work', async () => {
-    const ctrl = new AbortController();
-    let initializerAborted = false;
-    const pendingInit = (_providers, { signal }) => new Promise((_resolve, reject) => {
-        signal.addEventListener('abort', () => {
-            initializerAborted = true;
-            reject(signal.reason);
-        }, { once: true });
-    });
-    const ready = ensureExploreProviderReady({ providers: { fake: { enabled: true } } }, { provider: 'fake' }, ctrl.signal, pendingInit);
-    const waited = awaitExploreProviderReadyOrCancel(ready, ctrl.signal);
-    ctrl.abort(new Error('ESC during provider init'));
-    assert.equal(await waited, true);
-    assert.equal(initializerAborted, true, 'AbortSignal reached the pending initializer');
-});
-
-test('explore provider warmup resolves to not-canceled when the caller stays active', async () => {
-    const canceled = await awaitExploreProviderReadyOrCancel(Promise.resolve(), new AbortController().signal);
-    assert.equal(canceled, false, 'ready to dispatch');
-});
-
-test('explore provider warmup short-circuits an already-aborted caller before awaiting init', async () => {
-    const ctrl = new AbortController();
-    ctrl.abort(new Error('already canceled'));
-    let awaited = false;
-    const ready = Promise.resolve().then(() => { awaited = true; });
-    const canceled = await awaitExploreProviderReadyOrCancel(ready, ctrl.signal);
-    assert.equal(canceled, true, 'canceled without blocking on the warmup promise');
-});
-
-test('explore provider warmup propagates a genuine init failure (not a cancel)', async () => {
-    const ctrl = new AbortController(); // never aborted
-    const ready = Promise.reject(new Error('provider init failed'));
-    await assert.rejects(awaitExploreProviderReadyOrCancel(ready, ctrl.signal), /init failed/);
-});
-
-test('a retired shared compute success write is identity-guarded (no stale overwrite)', async () => {
-    process.env.MIXDOG_EXPLORE_RESULT_CACHE = '1';
-    const cache = __exploreResultCacheForTest();
-    cache.clear();
-    const key = 'identity-guard-success';
-    const dc = deferredCompute();
-    const p = runExploreCached(key, dc.fn, null);
-    p.catch(() => {});
-    // The compute executor runs on a microtask; let it install dc.resolve.
-    await new Promise((r) => setTimeout(r, 0));
-    const oldEntry = cache.get(key);
-    assert.ok(oldEntry?.promise, 'pending entry stored');
-    assert.equal(typeof dc.resolve, 'function', 'compute executor ran');
-    // Simulate the entry having been retired + replaced by a fresh one (e.g. a
-    // TTL eviction/recompute) WITHOUT touching the old in-flight compute.
-    const freshEntry = { ts: Date.now(), value: undefined, sentinel: true };
-    cache.set(key, freshEntry);
-    // The OLD compute now resolves successfully — its success handler must NOT
-    // overwrite the fresh entry (identity guard on every eventual write).
-    dc.resolve('src/stale.mjs:1 — retired winner');
-    await p;
-    await new Promise((r) => setTimeout(r, 0)); // flush the success microtask
-    assert.equal(cache.get(key), freshEntry, 'retired success write was identity-guarded');
-});