mixdog 0.9.50 → 0.9.52

package/scripts/tui-transcript-perf-test.mjs

@@ -5,6 +5,11 @@ import { createEngineItemMutators, replaceEngineItemsState } from '../src/tui/en
 import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
 import { createRunTurn } from '../src/tui/engine/turn.mjs';
 import { buildTranscriptRowIndexIncremental } from '../src/tui/app/transcript-window.mjs';
+import {
+  isCompletedTranscriptTail,
+  isCompletedTranscriptTailAppendedThisCommit,
+  isLiveSpinnerMetaVisible,
+} from '../src/tui/app/live-spinner-visibility.mjs';
 
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
@@ -91,6 +96,7 @@ function makeTurnHarness(ask, stateOverrides = {}, bagOverrides = {}) {
 
 test('successful mid-turn compact trims history but preserves live turn references', async () => {
   let preservedTail = false;
+  let compactKeepsSpinnerVisible = false;
   let contextSyncs = 0;
   const harness = makeTurnHarness(async (_text, options) => {
     options.onTextDelta('before compact\n');
@@ -98,6 +104,8 @@ test('successful mid-turn compact trims history but preserves live turn referenc
     options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
     assert.equal(contextSyncs, 1, 'compact event must refresh context before returning');
     preservedTail = harness.getState().streamingTail?.text === 'before compact\n';
+    compactKeepsSpinnerVisible = harness.getState().spinner?.active === true
+      && harness.getState().items.at(-1)?.kind === 'statusdone';
     options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
     assert.equal(contextSyncs, 2, 'each compact event refreshes context immediately');
     options.onTextDelta('after compact\n');
@@ -113,6 +121,7 @@ test('successful mid-turn compact trims history but preserves live turn referenc
 
   assert.equal(await harness.runTurn('go', { submittedIds: ['current-user'] }), 'done');
   assert.equal(preservedTail, true);
+  assert.equal(compactKeepsSpinnerVisible, true, 'a compact status leaves the active turn spinner in place');
   assert.equal(harness.getState().items.some((item) => item.id === 'old'), false);
   assert.equal(harness.getState().items.some((item) => item.id === 'current-user'), true);
   assert.equal(
@@ -125,6 +134,35 @@ test('successful mid-turn compact trims history but preserves live turn referenc
   );
 });
 
+test('live spinner remains visible across compact status and follows turn teardown', () => {
+  const activeTurnSpinner = { active: true };
+  const visible = (liveSpinner, liveSpinnerIsCommand, kind) => isLiveSpinnerMetaVisible({
+    inputBoxHidden: false,
+    slashPaletteOpen: false,
+    liveSpinner,
+    liveSpinnerIsCommand,
+    latestTranscriptItem: kind ? { kind } : null,
+  });
+
+  assert.equal(visible(activeTurnSpinner, false, 'statusdone'), true);
+  assert.equal(visible(activeTurnSpinner, false, 'turndone'), false);
+  assert.equal(visible(null, false, 'turndone'), false);
+  assert.equal(visible({ active: true }, true, 'turndone'), true);
+});
+
+test('completed transcript tail masking requires a new done tail', () => {
+  assert.equal(isCompletedTranscriptTail({ id: 'turn', kind: 'turndone' }), true);
+  assert.equal(isCompletedTranscriptTail({ id: 'status', kind: 'statusdone' }), true);
+  assert.equal(isCompletedTranscriptTail({ id: 'assistant', kind: 'assistant' }), false);
+  assert.equal(isCompletedTranscriptTail({ id: 'user', kind: 'user' }), false);
+  assert.equal(isCompletedTranscriptTail(null), false);
+  assert.equal(isCompletedTranscriptTailAppendedThisCommit({ id: 'turn', kind: 'turndone' }, 'turn'), false);
+  assert.equal(isCompletedTranscriptTailAppendedThisCommit({ id: 'status', kind: 'statusdone' }, 'status'), false);
+  assert.equal(isCompletedTranscriptTailAppendedThisCommit({ id: 'next', kind: 'turndone' }, 'previous'), true);
+  assert.equal(isCompletedTranscriptTailAppendedThisCommit({ id: 'next-status', kind: 'statusdone' }, 'previous'), true);
+  assert.equal(isCompletedTranscriptTailAppendedThisCommit({ id: 'assistant', kind: 'assistant' }, 'previous'), false);
+});
+
 test('failed mid-turn compact leaves prior transcript items untouched', async () => {
   const harness = makeTurnHarness(async (_text, options) => {
     options.onCompactEvent({ status: 'failed' });
@@ -175,8 +213,7 @@ test('abort after stream progress settles the tail and leaves no orphan', async
   assert.match(assistants[0].text, /partial line/);
 });
 
-// Codifies pre-existing parity: text had no item/currentAssistantId before its first completed line.
-test('abort before a newline has no tail id and preserves prior text-drop parity', async () => {
+test('abort before a newline settles the accumulated partial response', async () => {
   const harness = makeTurnHarness(async (_text, options) => {
     options.onTextDelta('partial without newline');
     await wait(30);
@@ -187,11 +224,10 @@ test('abort before a newline has no tail id and preserves prior text-drop parity
 
   assert.equal(await harness.runTurn('go'), 'cancelled');
   assert.equal(harness.getState().streamingTail, null);
-  assert.equal(
-    harness.getState().items.filter((item) => item.kind === 'assistant').length,
-    0,
-    'without a visible tail id, pre-newline text keeps the existing drop-on-abort behavior',
-  );
+  const assistants = harness.getState().items.filter((item) => item.kind === 'assistant');
+  assert.equal(assistants.length, 1);
+  assert.equal(assistants[0].streaming, false);
+  assert.equal(assistants[0].text, 'partial without newline');
 });
 
 // Codifies pre-existing parity: the old in-items completed-line snapshot survived starved recovery.

package/scripts/web-fetch-routing-test.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import {
+  isLoopbackHttpUrl,
+  preDispatchDenyForSession,
+} from '../src/runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs';
+import { executeTool } from '../src/runtime/agent/orchestrator/session/loop/tool-exec.mjs';
+import {
+  getInternalTools,
+  setInternalToolsProvider,
+} from '../src/runtime/agent/orchestrator/internal-tools.mjs';
+import { previewSessionTools } from '../src/runtime/agent/orchestrator/session/manager/tool-resolution.mjs';
+import { TOOL_DEFS as SEARCH_TOOL_DEFS } from '../src/runtime/search/tool-defs.mjs';
+import { dispatchSearchRuntimeTool } from '../src/session-runtime/runtime-core.mjs';
+import {
+  fetchLoopbackText,
+  fetchPublicImage,
+} from '../src/runtime/search/lib/http-fetch.mjs';
+
+test('pre-dispatch keeps hook-facing web_fetch name unchanged', () => {
+  const local = { name: 'web_fetch', arguments: { url: 'http://127.0.0.1:4321/status' } };
+  const image = { name: 'web_fetch', arguments: { url: 'https://cdn.example.com/a.png?x=1' } };
+  const document = { name: 'web_fetch', arguments: { url: 'https://example.com/docs' } };
+  assert.equal(preDispatchDenyForSession({}, local), null);
+  assert.equal(preDispatchDenyForSession({}, image), null);
+  assert.equal(preDispatchDenyForSession({}, document), null);
+  assert.equal(local.name, 'web_fetch');
+  assert.equal(image.name, 'web_fetch');
+  assert.equal(document.name, 'web_fetch');
+  assert.equal(isLoopbackHttpUrl('http://localhost:80/'), true);
+  assert.equal(isLoopbackHttpUrl('http://192.168.1.2/'), false);
+});
+
+test('hidden routed tools remain dispatchable but absent from every model schema', () => {
+  setInternalToolsProvider({
+    tools: SEARCH_TOOL_DEFS,
+    executor: async () => '',
+  });
+  const registered = getInternalTools().map((tool) => tool.name);
+  assert.equal(registered.includes('local_fetch'), true);
+  assert.equal(registered.includes('image_fetch'), true);
+  for (const spec of ['full', 'mcp', 'readonly', ['tools:mcp']]) {
+    const visible = previewSessionTools(spec, []).map((tool) => tool.name);
+    assert.equal(visible.includes('local_fetch'), false, `local_fetch leaked for ${JSON.stringify(spec)}`);
+    assert.equal(visible.includes('image_fetch'), false, `image_fetch leaked for ${JSON.stringify(spec)}`);
+    assert.equal(visible.includes('web_fetch'), true, `web_fetch missing for ${JSON.stringify(spec)}`);
+  }
+});
+
+test('hook sees public name before routed dispatch and can change routing inputs', async () => {
+  const observed = [];
+  setInternalToolsProvider({
+    tools: SEARCH_TOOL_DEFS,
+    executor: async (name, args) => {
+      observed.push({ stage: 'dispatch', name, args });
+      return { content: [{ type: 'text', text: name }] };
+    },
+  });
+  const result = await executeTool(
+    'web_fetch',
+    { url: 'https://example.com/document' },
+    process.cwd(),
+    'routing-order-test',
+    {
+      beforeToolHook: async ({ name, args }) => {
+        observed.push({ stage: 'hook', name, args });
+        return { action: 'modify', args: { url: 'http://127.0.0.1:4321/status' } };
+      },
+    },
+    { toolCallId: 'routing-order-call' },
+  );
+  assert.equal(result, 'local_fetch');
+  assert.deepEqual(observed.map(({ stage, name }) => ({ stage, name })), [
+    { stage: 'hook', name: 'web_fetch' },
+    { stage: 'dispatch', name: 'local_fetch' },
+  ]);
+});
+
+test('cancellation signal propagates across executeTool and runtime search dispatch', async () => {
+  const received = [];
+  setInternalToolsProvider({
+    tools: SEARCH_TOOL_DEFS,
+    executor: (name, args, callerCtx) => dispatchSearchRuntimeTool(name, args, callerCtx, {
+      getSearchModule: async () => ({
+        handleToolCall: async (_name, _args, options) => {
+          received.push({ name: _name, signal: options.signal });
+          await new Promise((resolve, reject) => {
+            if (options.signal.aborted) reject(options.signal.reason);
+            else options.signal.addEventListener('abort', () => reject(options.signal.reason), { once: true });
+          });
+        },
+      }),
+      getCurrentCwd: () => process.cwd(),
+      getSession: () => null,
+      notifyFnForSession: () => null,
+      runNativeWebSearch: async () => null,
+    }),
+  });
+  for (const [index, testCase] of [
+    { url: 'https://example.com/document', expectedName: 'web_fetch' },
+    { url: 'http://127.0.0.1:4321/status', expectedName: 'local_fetch' },
+  ].entries()) {
+    const controller = new AbortController();
+    const running = executeTool(
+      'web_fetch',
+      { url: testCase.url },
+      process.cwd(),
+      `cancel-test-${index}`,
+      {},
+      { toolCallId: `cancel-call-${index}`, signal: controller.signal },
+    );
+    controller.abort(new Error(`cancelled-by-test-${index}`));
+    await assert.rejects(running, new RegExp(`cancelled-by-test-${index}`));
+    assert.equal(received[index].name, testCase.expectedName);
+    assert.equal(received[index].signal, controller.signal);
+  }
+});
+
+test('local_fetch reads loopback and rejects redirect escape', async (t) => {
+  const server = http.createServer((req, res) => {
+    if (req.url === '/escape') {
+      res.writeHead(302, { location: 'http://169.254.169.254/latest/meta-data/' });
+      res.end();
+      return;
+    }
+    res.writeHead(200, { 'content-type': 'text/plain' });
+    res.end('local-ok');
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  t.after(() => server.close());
+  const { port } = server.address();
+  assert.equal(await fetchLoopbackText(`http://127.0.0.1:${port}/ok`), 'local-ok');
+  await assert.rejects(fetchLoopbackText(`http://127.0.0.1:${port}/escape`), /non-loopback/);
+  await assert.rejects(fetchLoopbackText('http://10.0.0.1/'), /non-loopback/);
+});
+
+test('public image fetch is bounded, media-shaped, and blocks private redirect targets', async () => {
+  const png = Buffer.from('89504e470d0a1a0a', 'hex');
+  const okFetch = async () => new Response(png, {
+    status: 200,
+    headers: { 'content-type': 'image/png', 'content-length': String(png.length) },
+  });
+  const image = await fetchPublicImage('https://images.example.com/a.png', { fetchImpl: okFetch });
+  assert.deepEqual(image, { mimeType: 'image/png', data: png.toString('base64'), bytes: png.length });
+
+  let calls = 0;
+  const redirectFetch = async () => {
+    calls++;
+    return new Response(null, { status: 302, headers: { location: 'http://169.254.169.254/latest/meta-data/' } });
+  };
+  await assert.rejects(
+    fetchPublicImage('https://images.example.com/a.png', { fetchImpl: redirectFetch }),
+    /private address/,
+  );
+  assert.equal(calls, 1);
+});

package/src/cli.mjs

@@ -2,12 +2,20 @@
 
 import { fileURLToPath } from 'node:url';
 import { classifyCliInvocation } from './headless-command.mjs';
+import {
+  beginProcessLifecycle,
+  finishProcessLifecycle,
+} from './runtime/shared/process-lifecycle.mjs';
+import { stagedChildExitCode } from './runtime/shared/staged-child-result.mjs';
 
 const argv = process.argv.slice(2);
 
 let swapped = false;
 const invocation = classifyCliInvocation(argv);
 const skipHostPrelude = invocation.kind === 'headless' || invocation.skipHostPrelude === true;
+if (!skipHostPrelude) {
+  beginProcessLifecycle({ safeCommandLine: argv.length === 0 });
+}
 if (!skipHostPrelude) {
   // Interactive/general sessions retain the staged-update and live-session
   // semantics. Headless role commands skip both because those helpers touch the
@@ -37,7 +45,9 @@ async function main() {
         env: { ...process.env, MIXDOG_SWAP_REEXEC: '1' },
         windowsHide: true,
       });
-      if (!r.error) return Number.isInteger(r.status) ? r.status : 0;
+      if (!r.error) {
+        return stagedChildExitCode(r);
+      }
     } catch { /* fall through to in-place run */ }
   }
   const { run } = await import('./app.mjs');
@@ -45,8 +55,11 @@ async function main() {
 }
 
 main().then((code) => {
-  process.exit(Number.isInteger(code) ? code : 0);
+  const exitCode = Number.isInteger(code) ? code : 0;
+  finishProcessLifecycle('clean-shutdown', exitCode);
+  process.exit(exitCode);
 }).catch((error) => {
   process.stderr.write(`${error?.stack || error?.message || String(error)}\n`);
+  finishProcessLifecycle('catchable-fatal-error', 1);
   process.exit(1);
 });

package/src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs

@@ -41,6 +41,7 @@ import {
     watchdogPartialHandoffFromError,
     AgentStallAbortError,
 } from './agent-progress-watchdog.mjs';
+import { resourceAdmission } from '../../../shared/resource-admission.mjs';
 
 // Cap agent role synthesis to ~3000 tokens (~12 KB at the 4 B/tok
 // working average). Pool B explore/recall/search answers occasionally land
@@ -300,7 +301,27 @@ export function makeAgentDispatch(opts = {}) {
         if (typeof prompt !== 'string' || !prompt) {
             throw new Error(`[agent-dispatch] prompt required for agent "${agent}"`);
         }
+        const admission = opts.resourceAdmission || resourceAdmission;
+        const admissionAbortLink = composeAgentDispatchAbortSignal([
+            opts.parentSignal,
+            callParentSignal,
+        ]);
+        let lease;
+        try {
+            lease = await admission.acquire('agent', {
+                signal: admissionAbortLink.signal,
+                label: agent,
+            });
+        } catch (error) {
+            admissionAbortLink.dispose();
+            throw error;
+        }
+        try {
 
+        const runAdmitted = (task) => typeof admission.runWithLease === 'function'
+            ? admission.runWithLease(lease, task)
+            : task();
+        return await runAdmitted(async () => {
         const config = opts.config || loadConfig({ secrets: false });
         const routeOrName = resolveMaintenanceRoute({
             preset: presetArg,
@@ -535,5 +556,10 @@ export function makeAgentDispatch(opts = {}) {
             // try/catch falls through in unexpected ways.
             try { await updateSessionStatus(session.id, terminalStatus); } catch { /* ignore */ }
         }
+        });
+        } finally {
+            await lease.release();
+            admissionAbortLink.dispose();
+        }
     };
 }

package/src/runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs

@@ -259,7 +259,10 @@ export function resolveAgentWatchdogPolicy(agent, overrides = {}) {
 export function evaluateAgentWatchdogAbort(snapshot, now, policy) {
     if (!snapshot || !policy) return null;
 
-    const startedAt = snapshot.modelRequestStartedAt || snapshot.askStartedAt;
+    const startedAt = snapshot.modelRequestStartedAt || 0;
+    // stage=connecting with no request timestamp means the provider request is
+    // still in the admission queue. Queue wait is outside every watchdog.
+    if (!startedAt && snapshot.stage === 'connecting') return null;
     const firstTransportMs = policy.firstTransportMs ?? policy.firstResponseMs ?? 0;
     const firstSemanticMs = policy.firstSemanticMs ?? policy.firstVisibleCeilingMs ?? 0;
     // Independent fixed deadlines from request start. Transport can satisfy

package/src/runtime/agent/orchestrator/agent-trace-format.mjs

@@ -247,6 +247,7 @@ export function parseGrepCoverage(resultText, toolName, toolArgs, resultKind) {
 function classifyToolFailure(resultText, toolName) {
     const raw = String(resultText ?? '');
     const text = raw.toLowerCase();
+    if (isExpectedToolCancellation(raw)) return 'expected-cancellation';
     // Shell renderers put the machine-readable status on the leading line.
     // Only inspect that marker: command text and stderr frequently contain
     // words such as "timeout" or "aborted" and must not rewrite a real exit
@@ -273,11 +274,22 @@ function classifyToolFailure(resultText, toolName) {
     return 'runtime/failure';
 }
 
+function isExpectedToolCancellation(resultText) {
+    const leading = String(resultText ?? '').split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line && !line.startsWith('⚠️ '))
+        ?.replace(/^Error:\s*/i, '') || '';
+    return /^Session\s+"[^"]+"\s+closed:\s*(?:aborted|closed)\s+during call\b/i.test(leading);
+}
+
 function traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, agent, model, cwd, resultText, resultKind = 'error' }) {
     if (process.env.MIXDOG_AGENT_TRACE_DISABLE === '1') return;
     if (!_resolveToolFailurePath()) return;
     try {
         const cleanText = _redactLogText(String(resultText ?? ''));
+        // A session close is deliberate orchestration, not a tool failure.
+        // traceAgentTool still records the error/category on the normal trace.
+        if (isExpectedToolCancellation(cleanText)) return;
         const row = {
             ts: Date.now(),
             session_id: normalizeSessionId(sessionId),

package/src/runtime/agent/orchestrator/internal-tools.mjs

@@ -69,6 +69,8 @@ function _normalize(result) {
         });
     }
     if (result && typeof result === 'object' && Array.isArray(result.content)) {
+        const hasStructuredMedia = result.content.some((part) => part && typeof part === 'object' && part.type !== 'text');
+        if (hasStructuredMedia && result.isError !== true) return result;
         const text = result.content
             .map((c) => (c?.type === 'text' ? c.text || '' : JSON.stringify(c)))
             .join('\n');