mixdog 0.9.45 → 0.9.46

package/scripts/compact-trigger-migration-smoke.mjs

@@ -55,8 +55,8 @@ function assert(condition, message) {
     `sub-boundary explicit limit should be preserved, got ${meta.autoCompactTokenLimit}`);
 }
 
-// 3) compactTriggerForSession: main/user (non-agent) recall-fasttrack keeps 5%
-//    headroom (95% trigger); a truly-explicit
+// 3) compactTriggerForSession: main/user (non-agent) recall-fasttrack keeps
+//    the default 5% headroom (95% trigger); a truly-explicit
 //    sub-boundary autoCompactTokenLimit still wins. Agent-owned semantic
 //    sessions keep the default 10% buffer (90%).
 {
@@ -71,14 +71,16 @@ function assert(condition, message) {
   assert(agentExplicit === 150000, `agent sub-boundary explicit limit should be the trigger, got ${agentExplicit}`);
 }
 
-// 4) A configured bufferPercent flows into the trigger for agent-owned sessions;
-//    main/user sessions use their fixed 5% headroom.
+// 4) Generic bufferPercent remains agent-only; main/user use their own
+//    configurable mainBufferPercent setting.
 {
   const boundary = 200000;
   const agentTrigger = compactTriggerForSession({ owner: 'agent', compaction: { bufferPercent: 5 } }, boundary);
   assert(agentTrigger === 190000, `agent bufferPercent 5 should yield trigger 190000, got ${agentTrigger}`);
   const userTrigger = compactTriggerForSession({ compaction: { bufferPercent: 5 } }, boundary);
-  assert(userTrigger === 190000, `main/user should keep 5% headroom and trigger at 190000, got ${userTrigger}`);
+  assert(userTrigger === 190000, `main/user should ignore agent bufferPercent and trigger at 190000, got ${userTrigger}`);
+  const userConfigured = compactTriggerForSession({ compaction: { mainBufferPercent: 15 } }, boundary);
+  assert(userConfigured === 170000, `main/user mainBufferPercent 15 should trigger at 170000, got ${userConfigured}`);
 }
 
 // 5) Legacy/zero buffer telemetry migration is an agent-path concern (the
@@ -106,7 +108,7 @@ function assert(condition, message) {
     compaction: { boundaryTokens: boundary, triggerTokens: 180000, bufferTokens: 20000, bufferRatio: 0.1 },
   }, boundary);
   assert(userTelemetry === 190000,
-    `main/user should ignore buffer telemetry and keep 5% headroom at 190000, got ${userTelemetry}`);
+    `main/user should ignore agent buffer telemetry and keep 5% headroom at 190000, got ${userTelemetry}`);
 }
 
 // 6) preserveBufferConfigFields copies only finite-positive percent/ratio fields.

package/scripts/compacted-placeholder-scrub-test.mjs

@@ -1,14 +1,11 @@
 #!/usr/bin/env node
-// Regression test for the pre-send compacted-placeholder invariant: no
-// provider-visible assistant toolCall may ship a `[mixdog compacted …]`
-// placeholder body that the model could copy back as apply_patch input.
-// scrubCompactedPlaceholderToolCalls is the single enforcement point invoked
-// by repairTranscriptBeforeProviderSend right before provider.send.
+// Regression tests for stable stored tool args: successful calls retain their
+// self-explanatory compacted marker, while failed calls can restore full bodies.
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
     compactToolCallsForHistory,
-    scrubCompactedPlaceholderToolCalls,
+    restoreToolCallBodyForId,
 } from '../src/runtime/agent/orchestrator/session/loop/stored-tool-args.mjs';
 import { repairTranscriptBeforeProviderSend } from '../src/runtime/agent/orchestrator/session/loop/transcript-repair.mjs';
 
@@ -26,52 +23,41 @@ test('compact leaves a placeholder patch body (precondition)', () => {
     assert.equal(msg.toolCalls[0].arguments.base_path, '/repo');
 });
 
-test('scrub drops the placeholder patch key, keeps other args', () => {
-    const msg = assistantWithCompactedPatch();
-    scrubCompactedPlaceholderToolCalls([msg]);
-    assert.equal('patch' in msg.toolCalls[0].arguments, false);
-    assert.equal(msg.toolCalls[0].arguments.base_path, '/repo');
-});
-
-test('scrub is recursive across nested batch body args', () => {
+test('nested body args retain their compacted markers', () => {
     const calls = [{
         id: 'call_2', name: 'edit',
         arguments: { edits: [{ path: 'a.js', old_string: BIG_PATCH, new_string: 'ok' }] },
     }];
     const msg = { role: 'assistant', content: '', toolCalls: compactToolCallsForHistory(calls) };
     assert.match(msg.toolCalls[0].arguments.edits[0].old_string, /^\[mixdog compacted /);
-    scrubCompactedPlaceholderToolCalls([msg]);
     const edit = msg.toolCalls[0].arguments.edits[0];
-    assert.equal('old_string' in edit, false);
     assert.equal(edit.path, 'a.js');
     assert.equal(edit.new_string, 'ok');
 });
 
-test('scrub leaves real (restored) patch bodies untouched', () => {
-    const real = '*** Begin Patch\n@@\n-a\n+b\n*** End Patch';
-    const msg = { role: 'assistant', content: '', toolCalls: [
-        { id: 'call_3', name: 'apply_patch', arguments: { patch: real } },
-    ] };
-    scrubCompactedPlaceholderToolCalls([msg]);
-    assert.equal(msg.toolCalls[0].arguments.patch, real);
-});
-
-test('scrub ignores non-assistant / non-toolCall messages', () => {
-    const msgs = [
-        { role: 'user', content: 'hi' },
-        { role: 'tool', content: 'x', toolCallId: 'call_1' },
-        { role: 'assistant', content: 'text only' },
-    ];
-    assert.doesNotThrow(() => scrubCompactedPlaceholderToolCalls(msgs));
+test('failed-call restore replaces the marker with the full original body', () => {
+    const originalCalls = [{
+        id: 'call_3', name: 'apply_patch', arguments: { patch: BIG_PATCH, base_path: '/repo' },
+    }];
+    const msg = {
+        role: 'assistant',
+        content: '',
+        toolCalls: compactToolCallsForHistory(originalCalls),
+    };
+    restoreToolCallBodyForId(msg, originalCalls, 'call_3');
+    assert.equal(msg.toolCalls[0].arguments.patch, BIG_PATCH);
+    assert.equal(msg.toolCalls[0].arguments.base_path, '/repo');
 });
 
-test('repairTranscriptBeforeProviderSend enforces the invariant end-to-end', () => {
+test('pre-send transcript repair does not mutate compacted tool-call args', () => {
     const msgs = [
         { role: 'user', content: 'do it' },
         assistantWithCompactedPatch('call_9'),
         { role: 'tool', content: 'applied', toolCallId: 'call_9' },
     ];
+    const argsBefore = structuredClone(msgs[1].toolCalls[0].arguments);
     repairTranscriptBeforeProviderSend(msgs, null);
     const asst = msgs.find((m) => m.role === 'assistant');
-    assert.equal('patch' in asst.toolCalls[0].arguments, false);
+    assert.deepEqual(asst.toolCalls[0].arguments, argsBefore);
+    assert.match(asst.toolCalls[0].arguments.patch, /^\[mixdog compacted patch: \d+ chars, sha256:[a-f0-9]{16}\]$/);
 });

package/scripts/context-mcp-metering-test.mjs

@@ -0,0 +1,75 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  createContextStatus,
+  requestSerializedToolsForContext,
+} from '../src/session-runtime/context-status.mjs';
+import { splitToolStatusCounts } from '../src/session-runtime/session-turn-api.mjs';
+import { toolKind } from '../src/session-runtime/tool-catalog.mjs';
+
+const schema = (description) => ({
+  type: 'object',
+  properties: { value: { type: 'string', description } },
+});
+
+test('context meters Anthropic deferred MCP schemas and invalidates on catalog changes', () => {
+  const read = { name: 'read', description: 'Read a file', inputSchema: schema('path') };
+  const mcp = { name: 'mcp__demo__lookup', description: 'MCP lookup', inputSchema: schema('mcp payload '.repeat(100)) };
+  const session = {
+    id: 'deferred-mcp-context',
+    provider: 'anthropic',
+    contextWindow: 100_000,
+    messages: [{ role: 'user', content: 'hello' }],
+    tools: [read],
+    deferredNativeTools: true,
+    deferredToolCatalog: [read, mcp],
+    compaction: {},
+  };
+  const route = { provider: 'openai', model: 'test' };
+  const { contextStatus } = createContextStatus({
+    getSession: () => session,
+    getRoute: () => route,
+    getCurrentCwd: () => '',
+    getMode: () => 'default',
+  });
+
+  assert.deepEqual(requestSerializedToolsForContext(session, 'openai'), [read]);
+  assert.equal(requestSerializedToolsForContext(session, 'anthropic').length, 2);
+  const before = contextStatus();
+  assert.equal(before.request.toolSchemaBreakdown.mcp.count, 1);
+  assert.ok(before.request.toolSchemaBreakdown.mcp.tokens > 0);
+
+  session.provider = 'openai';
+  const switched = contextStatus();
+  assert.notEqual(switched, before);
+  assert.equal(switched.request.toolSchemaBreakdown.mcp, undefined);
+  assert.ok(switched.request.toolSchemaTokens < before.request.toolSchemaTokens);
+
+  session.provider = 'anthropic';
+  session.deferredToolCatalog.push({
+    name: 'mcp__demo__second',
+    description: 'Second MCP tool',
+    inputSchema: schema('second payload '.repeat(100)),
+  });
+  const after = contextStatus();
+  assert.notEqual(after, before);
+  assert.equal(after.request.toolSchemaBreakdown.mcp.count, 2);
+  assert.ok(after.request.toolSchemaTokens > before.request.toolSchemaTokens);
+  assert.ok(after.request.reserveTokens > before.request.reserveTokens);
+  assert.ok(after.usedTokens > before.usedTokens);
+});
+
+test('tool status counts exclude MCP and skills while exposing MCP tool count', () => {
+  const rows = [
+    { name: 'read', kind: toolKind({ name: 'read' }), active: true },
+    { name: 'mcp__demo__lookup', kind: toolKind({ name: 'mcp__demo__lookup' }), active: false },
+    { name: 'Skill', kind: toolKind({ name: 'Skill' }), active: true },
+  ];
+  assert.deepEqual(splitToolStatusCounts(rows), {
+    count: 1,
+    activeCount: 1,
+    mcpToolCount: 1,
+    activeMcpToolCount: 0,
+  });
+});

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

@@ -68,22 +68,21 @@ 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 = [
-    /Locator only:[\s\S]*WHERE \(`path:line`\), never WHY[\s\S]*You ARE `explore`; never[\s\S]*call it/i,
-    /ONLY grep\/find\/glob\/code_graph[\s\S]*`read`\/`list` are forbidden/i,
-    /Turn 1 \(`turn 1\/3`\)[\s\S]*gathers all known facets in ONE message[\s\S]*Broad\/uncertain is Explorer input[\s\S]*split it into concrete facets[\s\S]*apply the shared one-route\/batch contract[\s\S]*concept facets use grep[\s\S]*single-tool turn is valid[\s\S]*follow-up is only for unresolved pre-anchor\/\s*zero-hit facets/i,
-    /follow-up is only for unresolved pre-anchor\/\s*zero-hit facets under this budget/i,
-    /broad searches use `output_mode:"files_with_matches"`[\s\S]*`content_with_context` plus `head_limit` only on a path returned THIS session/i,
-    /Each pattern is one identifier or camel\/snake variant[\s\S]*spaces are only verbatim copied quoted\s*error\/log literals[\s\S]*Translate non-English queries to English identifiers first[\s\S]*non-ASCII only for quoted literals[\s\S]*Include concept synonyms[\s\S]*not prose phrases/i,
-    /Scope is session cwd; omit `path` freely[\s\S]*only from an exact find-returned path \(turn-2 recovery earliest\)[\s\S]*never guess or\s*invent directories[\s\S]*`path:"\."` with guessed `src\/\*\*`[\s\S]*After zero hits, change TOKENS\/scope, not wording\/guessed paths/i,
-    /anchor is any `path:line` with a query token\/synonym[\s\S]*code_graph hits[\s\S]*generic-only schema\/handler\/config\/resolver\/index\/error words are zero[\s\S]*Never re-locate an anchor[\s\S]*without `:line`[\s\S]*PRE-anchor/i,
-    /After every result[\s\S]*specific-token anchor means STOP and answer NOW[\s\S]*pre-anchors count as zero[\s\S]*Never re-confirm\/upgrade an anchor/i,
-    /sole legal follow-up[\s\S]*code-location query[\s\S]*only with pre-anchors[\s\S]*one scoped `content_with_context` grep with `head_limit` on those paths[\s\S]*If zero, remaining zero-anchor recovery turns are legal under the 3-turn budget but must change tokens\/scope[\s\S]*never a second minting hop, anchor upgrade, or fabricated\/estimated line/i,
-    /at most 3 turns \(expect 1\)[\s\S]*every tool message `turn N\/3`[\s\S]*normally two messages[\s\S]*third\/extra tool call[\s\S]*unless turn 1 has zero anchors[\s\S]*must change tokens\/scope/i,
-    /Single-hop exception[\s\S]*first matching entry\/definition anchors concept\/value\/\s*default[\s\S]*do not trace chains\/value-search[\s\S]*explicit flow or default-resolution query[\s\S]*entry anchor but not its resolved value[\s\S]*ONE resolving hop, then stop/i,
-    /Answer in ≤3 lines[\s\S]*`path:line — symbol — short reason`[\s\S]*Copy every cited `path:line` VERBATIM[\s\S]*THIS-session tool result[\s\S]*never estimate\/adjust\/recall/i,
-    /Code-location answers require `:line` on every line[\s\S]*`EXPLORATION_FAILED`[\s\S]*never a bare filename or vague prose/i,
-    /file\/dir-location queries[\s\S]*exact verified file\/dir path without `:line`[\s\S]*do not force a line\/failure/i,
-    /Emit `EXPLORATION_FAILED` only after the budget is spent with zero anchors[\s\S]*prefer a weak anchor to a false miss/i,
+    /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);

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

@@ -0,0 +1,345 @@
+#!/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');
+});