mixdog 0.9.134 → 0.9.136

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.134",
+  "version": "0.9.136",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -86,6 +86,8 @@
     "bench:session-context": "node scripts/session-context-bench.mjs",
     "bench:session-transport": "node scripts/session-transport-bench.mjs",
     "bench:tool-overhead": "node scripts/tool-overhead-microbench.mjs",
+    "bench:search-tools": "node scripts/tool-search-bench.mjs",
+    "bench:io-tools": "node scripts/tool-io-bench.mjs",
     "bench:internal-comms": "node scripts/internal-comms-bench.mjs",
     "audit:models": "node scripts/model-catalog-audit.mjs",
     "patch:replay": "node scripts/patch-replay.mjs",

package/scripts/tool-stress.mjs

@@ -2,7 +2,9 @@
 // concurrent multi-session waves and checks that results stay correct and
 // bounded under load (no unhandled rejections, no resource-pressure failures,
 // patch/read integrity preserved, cancellation clean). One-shot script:
-// `node scripts/tool-stress.mjs`. Exit 0 = stable, 1 = instability found.
+// `node scripts/tool-stress.mjs --unsafe-live`. Exit 0 = stable, 1 = instability found.
+// This intentionally exercises shell cancellation and concurrent mutations.
+// Use tool-search-bench.mjs for routine, read-only exploration diagnostics.
 import '../src/runtime/shared/uv-threadpool-boot.mjs';
 import './native-spawn-test-runtime.mjs';
 import { mkdtempSync, rmSync } from 'node:fs';
@@ -17,6 +19,11 @@ import { warmNativeSpawnServer } from '../src/runtime/agent/orchestrator/tools/l
 import { warmNativeSearchServer } from '../src/runtime/agent/orchestrator/tools/builtin/native-search-client.mjs';
 import { prewarmFindEnumeration } from '../src/runtime/agent/orchestrator/tools/builtin/list-tool.mjs';
 
+if (!process.argv.includes('--unsafe-live')) {
+  console.error('Refusing high-impact tool stress without --unsafe-live; run `node scripts/tool-search-bench.mjs` for safe exploration diagnostics.');
+  process.exit(2);
+}
+
 const root = join(fileURLToPath(new URL('.', import.meta.url)), '..');
 const SESSIONS = 8;
 const WAVES = 5;

package/src/agents/maintainer/agent.json

@@ -1,6 +1,6 @@
 {
   "id": "maintainer",
   "name": "Maintainer",
-  "description": "Use for memory upkeep and long-running maintenance work.",
+  "description": "Use for internal Git operations, memory upkeep, session naming, and other Mixdog background operations.",
   "entry": "AGENT.md"
 }

package/src/defaults/skills/setup/SKILL.md

@@ -18,7 +18,7 @@ description: Use this skill only to inspect or modify a Mixdog user's persisted
 - 프로젝트 config: `<cwd>/.mcp.json`, `<cwd>/.mixdog/skills/`, `<cwd>/.mixdog/hooks.json`
 - TUI 명령 목록: `src/tui/app/slash-commands.mjs`
 - TUI 설정 허브: `/setting` (별칭 `/settings`, `/config`) → `src/tui/app/settings-picker.mjs`
-- Desktop 설정: `Ctrl+,` → General / Context / Output style / Providers / Git / Skills / MCP / Plugins / Hooks / Channels / Connection / System / Shortcuts / About
+- Desktop 설정: `Ctrl+,` → General / Context / Output style / Providers / Git / Skills / MCP / Plugins / Hooks / Connection / System / Shortcuts / About
 - Desktop rail: **Projects / Workflows / Schedules / Webhooks / Utilities**
 
 사용자 경로와 지원 여부는 **현재 Desktop 구현을 최신 기준**으로 판정한다. TUI는 Desktop에 없는 고급 경로를 보완할 때만 사용하며, 저장만 왕복되고 실제 소비되지 않는 key는 사용자 옵션으로 설명하지 않는다.
@@ -34,10 +34,9 @@ description: Use this skill only to inspect or modify a Mixdog user's persisted
 | Search 모델 | `agent.searchRoute` |
 | Provider·MCP·프로필·스킬·업데이트·셸·autoClear·compaction | `agent.*` |
 | Web search 도구 | `agent.modules.search.enabled` |
-| Channels messaging | `agent.modules.channels.enabled` |
 | Recap(배경 사이클) | `agent.recap.enabled` |
 | 출력 스타일 | 루트 `outputStyle` |
-| Discord/Telegram provider·target·webhook server | `channels.*` (`channels.provider`) |
+| Webhook server | `channels.webhook.*` |
 | 메모리 cycle interval | `memory.cycle1.interval`, `memory.cycle2.interval` |
 | 음성 전사 | `voice.enabled` |
 | TUI 테마 | `ui.theme` |
@@ -51,7 +50,7 @@ API 키·토큰·OAuth 자격은 config에 쓰지 않는다.
 - MCP: `/mcp`, Desktop **Settings → MCP**, 또는 `mcpStatus()`
 - Skills: `/skills`, Desktop **Settings → Skills**, 또는 `skillsStatus()`
 - Providers: `/providers`, Desktop **Settings → Providers**, 또는 `getProviderSetup()`
-- Channels: `/channels`, Desktop **Settings → Channels**, 또는 `getChannelSetup()`
+- Webhooks: Desktop **Webhooks** 뷰, 또는 `getChannelSetup()` (webhook enabled/port)
 - 비밀 존재 여부: `hasStoredSecret(account)`만 사용하고 값은 출력하지 않는다.
 
 ---
@@ -175,8 +174,6 @@ API 키·토큰·OAuth 자격은 config에 쓰지 않는다.
 | `agent.<provider>.apiKey` | Provider API key |
 | `agent.openai.usageSessionKey` | OpenAI usage |
 | `agent.opencode-go.authCookie` | OpenCode Go usage |
-| `discord.token` | Discord bot |
-| `telegram.token` | Telegram bot |
 
 값은 출력하지 않고 `hasStoredSecret()`으로 존재만 확인한다. MCP `env`는 keychain이 아니라 자식 프로세스 환경이다.
 
@@ -335,21 +332,9 @@ Plugins 화면에는 일반적인 “plugin 활성/비활성” toggle이 없다
 
 ---
 
-## 5. Channels·Voice·Automation·Remote
+## 5. Voice·Automation
 
-### Discord / Telegram
-
-1. **확인**: `/channels`, `/setting → Channel / Setting`, Desktop **Settings → Channels**, `getChannelSetup()`.
-2. **변경**:
-   - provider: Discord/Telegram 선택 → `setChannelProvider()`
-   - token: Bot token → OS keychain
-   - main target: Discord channel ID / Telegram chat ID → `setChannel({ provider, channelId })`
-3. **저장**: provider·target은 `channels.provider`, `channels.channel.discordChannelId` / `telegramChatId`. token은 `discord.token` / `telegram.token`.
-4. **검증**: active provider, authenticated, main target의 Ready 상태.
-
-`Channels enabled`는 messaging만 제어하며 디스크 경로는 `agent.modules.channels.enabled`다. schedules/webhooks는 이 toggle과 독립적으로 계속 실행된다.
-
-`channels.backend`와 `channels.channel.channelId`는 쓰지 않는다. canonicalize가 제거하고 `provider` / per-provider id만 남긴다.
+Discord/Telegram messaging은 제거됐다. schedules/webhooks 자동화와 voice transcription만 남는다.
 
 ### Voice transcription
 
@@ -383,16 +368,7 @@ Plugins 화면에는 일반적인 “plugin 활성/비활성” toggle이 없다
 
 기존 파일형 schedules는 최초 DB init 때 import 후 `schedules.migrated`로 보존한다. 기존 webhook 디렉터리는 성공적으로 모두 import된 경우 삭제한다.
 
-활성 schedule/webhook이 있으면 automation worker가 messaging·remote와 독립적으로 자동 시작한다.
-
-### Remote session
-
-1. **강제 claim**: TUI `/remote`는 항상 현재 세션을 ON으로 만들고 기존 owner를 넘겨받는다.
-2. **TUI toggle**: `/channels → Remote Runtime` 또는 `/setting → Remote Runtime`.
-3. **Desktop**: Settings에 Remote 행이 없다. session header의 remote toggle만 사용한다. draft의 New-task remote는 일회성이며 설정 기본값이 아니다.
-4. **시작 시 ON**: CLI `mixdog --remote`.
-5. **중요**: config `remote.autoStart`는 사용하지 않는다. 자동화 worker의 자동 시작과 remote session claim은 별개다.
-6. **검증**: `isRemoteEnabled()`, owner session ID, channel worker status.
+활성 schedule/webhook이 있으면 automation worker가 자동 시작한다.
 
 ---
 
@@ -436,13 +412,12 @@ Desktop과 현재 runtime에서 소비되지 않는 아래 key는 사용자 옵
 | `agent.agentMaintenance`, `agent.runtime` | 제거 |
 | `remote.autoStart` | 제거; Remote는 session header에서 수동 claim |
 | `ui.mouseMode` | 제거; `ui.theme`은 TUI 현행 설정 |
-| `channels.backend` | 제거 (이관 없음; `channels.provider`만 유효) |
-| `channels.channel.channelId` | 제거; `discordChannelId` / `telegramChatId`만 유지 |
+| `channels.backend`, `channels.provider`, `channels.channel.*` | 제거; Discord/Telegram messaging 은퇴로 전부 데드 key |
 | `channels.quiet`, `channels.schedules` | 제거; schedule은 PG가 단일 저장소 |
 | `channels.webhook.ngrokDomain`, `channels.webhook.respectQuiet` | 제거; endpoint URL은 Desktop Webhooks가 발급 |
 | `agent.outputStyle` | 제거 (이관 없음; 루트 `outputStyle`만 유효) |
 
-다음 항목은 레거시처럼 보여도 현행이므로 유지한다: 루트 `outputStyle`, `agent.shell`, `agent.modules`, `channels.channel.discordChannelId/telegramChatId`, compaction의 `type/compactType`과 recall tuning fields.
+다음 항목은 레거시처럼 보여도 현행이므로 유지한다: 루트 `outputStyle`, `agent.shell`, `agent.modules`, compaction의 `type/compactType`과 recall tuning fields.
 
 ---
 
@@ -478,21 +453,11 @@ URL transport는 `type` + `url` + 선택 `headers`를 사용한다.
 ```json
 {
   "channels": {
-    "provider": "discord",
-    "channel": {
-      "discordChannelId": "",
-      "telegramChatId": ""
-    },
     "webhook": {
       "enabled": true,
       "port": 3333
     }
   },
-  "agent": {
-    "modules": {
-      "channels": { "enabled": true }
-    }
-  },
   "voice": { "enabled": false }
 }
 ```

package/src/headless-exec.mjs

@@ -583,6 +583,7 @@ export async function runHeadlessExec({
   let runtime = null;
   let signalCleanup = null;
   let unsubscribeNotification = null;
+  let completionPending = false;
   let cleanupPromise = null;
   let result = null;
   let resultText = '';
@@ -644,18 +645,25 @@ export async function runHeadlessExec({
       toolMode: 'full',
       approvalMode: 'implicit',
       disallowDelegation: true,
+      autoWakeCompletions: false,
       initialConfig: boundary.loadConfig(),
     });
     if (lifecycle && !clean(runtime?.id) && typeof runtime?.reserveSessionId === 'function') {
       runtime.reserveSessionId(lifecycle.threadId);
     }
     lifecycle?.start(runtime);
-    if (lifecycle && typeof runtime?.onNotification === 'function') {
+    if (typeof runtime?.onNotification === 'function') {
       unsubscribeNotification = runtime.onNotification(
-        (event) => lifecycle.onNotification(event),
+        (event) => {
+          lifecycle?.onNotification(event);
+          const status = clean(event?.meta?.status).toLowerCase();
+          if (['completed', 'failed', 'cancelled', 'canceled', 'timed_out'].includes(status)) {
+            completionPending = true;
+          }
+        },
       );
     }
-    ({ result } = await runtime.ask(prompt, {
+    const askOptions = {
       onTextReset: () => true,
       onUsageDelta: (delta) => {
         applyUsageDelta(stats, delta);
@@ -672,13 +680,22 @@ export async function runHeadlessExec({
         onToolPhaseCompleted: (detail) => lifecycle.onToolBatchCompleted(detail),
         onStageChange: (stage, detail) => lifecycle.onStageChange(stage, detail),
       } : {}),
-    }));
-    await waitForTrackedTasks({
-      sessionId: runtime.id,
+    };
+    ({ result } = await runtime.ask(prompt, askOptions));
+    const taskScope = {
+      ...(clean(runtime.id) ? { callerSessionId: clean(runtime.id) } : {}),
       clientHostPid: runtime.clientHostPid,
-      hasActiveTasks,
-      pollMs: idlePollMs,
-    });
+    };
+    while (completionPending || hasActiveTasks(taskScope)) {
+      await waitForTrackedTasks({
+        sessionId: runtime.id,
+        clientHostPid: runtime.clientHostPid,
+        hasActiveTasks,
+        pollMs: idlePollMs,
+      });
+      completionPending = false;
+      ({ result } = await runtime.ask('', askOptions));
+    }
     resultText = String(result?.content ?? result?.text ?? '');
     if (!json && resultText) {
       write(resultText.endsWith('\n') ? resultText : `${resultText}\n`);

package/src/headless-exec.test.mjs

@@ -90,7 +90,7 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
       hasActiveTasks: (scope) => {
         activeScopes.push(scope);
         activeChecks += 1;
-        return activeChecks === 1;
+        return false;
       },
       installSignalCleanupFn: () => ({ uninstall() {} }),
     });
@@ -100,6 +100,7 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
     assert.deepEqual(errors, []);
     assert.equal(runtimeOptions[0].approvalMode, 'implicit');
     assert.equal(runtimeOptions[0].disallowDelegation, true);
+    assert.equal(runtimeOptions[0].autoWakeCompletions, false);
     assert.equal(runtimeOptions[0].toolMode, 'full');
     assert.deepEqual(activeScopes[0], {
       callerSessionId: 'sess_exec_test',
@@ -121,6 +122,58 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
   }
 });
 
+test('headless exec drains tracked work and returns the completion follow-up answer', async () => {
+  const output = [];
+  const errors = [];
+  const prompts = [];
+  let active = true;
+  let notificationListener = null;
+  const code = await runHeadlessExec({
+    message: 'start the long task',
+    provider: 'openai-oauth',
+    model: 'gpt-test',
+    usageLogPath: '',
+    idlePollMs: 1,
+    write: (text) => output.push(text),
+    writeErr: (text) => errors.push(text),
+    boundaryFactory: () => ({
+      loadConfig: () => ({ providers: { 'openai-oauth': { enabled: true } } }),
+      cleanup() {},
+    }),
+    runtimeFactory: async () => ({
+      id: 'sess_headless_drain',
+      model: 'gpt-test',
+      clientHostPid: 123,
+      onNotification(listener) {
+        notificationListener = listener;
+        return () => { notificationListener = null; };
+      },
+      async ask(prompt) {
+        prompts.push(prompt);
+        if (prompts.length === 1) {
+          setTimeout(() => {
+            active = false;
+            notificationListener?.({
+              content: 'background task completed',
+              meta: { status: 'completed', execution_id: 'job_drain' },
+            });
+          }, 10);
+          return { result: { content: 'task started' } };
+        }
+        return { result: { content: 'final result' } };
+      },
+      async close() {},
+    }),
+    hasActiveTasks: () => active,
+    installSignalCleanupFn: () => ({ uninstall() {} }),
+  });
+
+  assert.equal(code, 0);
+  assert.deepEqual(errors, []);
+  assert.deepEqual(prompts, ['start the long task', '']);
+  assert.deepEqual(output, ['final result\n']);
+});
+
 test('headless exec emits a timestamped JSONL lifecycle and exact tool count', async () => {
   const root = mkdtempSync(join(tmpdir(), 'mixdog-headless-json-test-'));
   const usageLogPath = join(root, 'usage.json');
@@ -199,7 +252,7 @@ test('headless exec emits a timestamped JSONL lifecycle and exact tool count', a
           options.onToolPhaseCompleted({ iteration: 1, calls: 1, elapsedMs: 2 });
           notificationListener?.({
             content: 'background task completed',
-            meta: { status: 'completed' },
+            meta: { status: 'progress' },
           });
           options.onProviderSendStarted();
           options.onAssistantText('done');

package/src/help.mjs

@@ -46,8 +46,6 @@ export const HELP_LINES = [
   '  /plugins                      manage local plugin integrations',
   '  /hooks                        manage before-tool hook rules and events',
   '  /providers                    manage auth, API keys, OAuth, and local endpoints',
-  '  /channels                     manage Discord, Telegram, and voice',
-  '  /remote                       claim remote for this session',
   '  /setting                      open runtime settings (aliases: /settings, /config)',
   '  /profile                      set your title and response language',
   '  /update                       check version and update mixdog',

package/src/rules/lead/01-general.md

@@ -7,10 +7,6 @@
 - Confirm destructive/hard-to-reverse actions against explicit validated paths;
   never `~`, a root, or unresolved variables/globs; report material deletion
   recoverability.
-- After required work, run final verification only when the outcome needs
-  evidence the successful tool result does not already give, and run only
-  affected blocking invariants. Combine commands when dependency or
-  atomicity requires it.
 - Mid-task: replacement supersedes; addition folds in; status gets a brief
   answer while work continues. After compaction, resume the summary.
 - Final text ends the turn only when done.

package/src/rules/shared/01-tool.md

@@ -1,5 +1,7 @@
 # Tool Use
 
+- When an internal Mixdog rule conflicts with the user's latest explicit
+  request, follow the user's request.
 - Baseline routing assigns each facet directly by the evidence needed to
   determine the complete answer or edit:
   path/name only→`find`; wildcard/recursive paths→`glob` (including known-root
@@ -39,7 +41,12 @@
   a file to rebuild context or confirm an edit, no rerun of a passed check.
   A hole (needed content absent and not reconstructable) is fetched once;
   a change re-opens only that hole. Returned output is fully mined before the
-  next round. `code_graph references` supplies the declaration and scoped
+  next round. A successful edit establishes the resulting source as known
+  state: do not inspect or query changed source with `read`, `grep`,
+  `code_graph`, `glob`, or `list`; proceed directly to final verification.
+  Reopen only a specific hole reported by a failed or partial edit, or by a
+  failed verification.
+  `code_graph references` supplies the declaration and scoped
   usages and ends that facet; values/locations end at the context grep
   returns; `read` covers only what returned spans cannot, as an anchored
   offset/limit window. Already obtained hunk text is any visible span —
@@ -71,9 +78,10 @@
   and buildability invariants. Treat mutable behavior, UX, exact text,
   snapshots, and implementation shape as advisory specifications; update them
   when the requested behavior changes instead of preserving obsolete behavior.
-- A successful verification closes the task unless later changes affect it.
-  Rerun a failed action only after its inputs or subject changes; otherwise
-  report it unresolved.
+- When the applied changes require verification, run all applicable checks as
+  one final batch only after every planned edit is complete — never after
+  individual edits. If that verification fails, fully collect the failures,
+  batch all determinable fixes, then rerun only the affected failed checks once.
 - If inspection can change evidence or durable state, use read-only means;
   mutate only when the deliverable requires it, first preserving evidence
   at risk. Never mutate merely to clear an obstacle or unexpected state;

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

@@ -423,11 +423,36 @@ function traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolM
     }
 }
 
-function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, agent, resultKind, model, resultText, localSearchTelemetry = null, resultTelemetry = null, cwd }) {
+function summarizeToolTiming(toolTiming) {
+    if (!toolTiming || typeof toolTiming !== 'object') return null;
+    const number = (key) => {
+        const value = Number(toolTiming[key]);
+        return Number.isFinite(value) ? value : null;
+    };
+    const dispatchStartedAt = number('dispatchStartedAt');
+    const executionStartedAt = number('executionStartedAt');
+    const executionCompletedAt = number('executionCompletedAt');
+    const postprocessStartedAt = number('postprocessStartedAt');
+    const resultCompletedAt = number('resultCompletedAt');
+    const timing = {};
+    const duration = (key, start, end) => {
+        if (start === null || end === null) return;
+        timing[key] = Math.max(0, Math.round(end - start));
+    };
+    duration('dispatch_wait_ms', dispatchStartedAt, executionStartedAt);
+    duration('execution_ms', executionStartedAt, executionCompletedAt);
+    duration('result_collection_wait_ms', executionCompletedAt, postprocessStartedAt);
+    duration('postprocess_ms', postprocessStartedAt, resultCompletedAt);
+    duration('total_ms', dispatchStartedAt, resultCompletedAt);
+    return Object.keys(timing).length > 0 ? timing : null;
+}
+
+function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, agent, resultKind, model, resultText, localSearchTelemetry = null, resultTelemetry = null, toolTiming = null, cwd }) {
     const nextCallCount = countJsonNextCalls(resultText);
     const resultBytesEst = typeof resultText === 'string' ? Buffer.byteLength(resultText, 'utf8') : 0;
     const resultLinesEst = typeof resultText === 'string' && resultText.length > 0 ? resultText.split('\n').length : 0;
     const numericToolMs = Number(toolMs);
+    const summarizedTiming = summarizeToolTiming(toolTiming);
     const summarizedArgs = summarizeToolArgs(toolName, toolArgs);
     const grepCoverage = parseGrepCoverage(resultText, toolName, toolArgs, resultKind);
     // Hash the FULL args, not the summary: summaries drop payload fields
@@ -474,9 +499,10 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
         local_search: localSearchTelemetry && Object.keys(localSearchTelemetry).length > 0
             ? { ...localSearchTelemetry }
             : null,
-        payload: resultTelemetry?.integrity
-            ? { integrity: { ...resultTelemetry.integrity } }
-            : {},
+        payload: {
+            ...(summarizedTiming ? { timing: summarizedTiming } : {}),
+            ...(resultTelemetry?.integrity ? { integrity: { ...resultTelemetry.integrity } } : {}),
+        },
         cwd: cwd || null,
     });
     if (

package/src/runtime/agent/orchestrator/agent-trace-timing.test.mjs

@@ -0,0 +1,57 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+test('tool traces expose dispatch, execution, collection, and postprocess timing', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'mixdog-tool-timing-'));
+  try {
+    const tracePath = join(dir, 'agent-trace.jsonl');
+    const child = spawnSync(process.execPath, ['--input-type=module', '-e', `
+      import { readFileSync } from 'node:fs';
+      import { traceAgentTool } from './src/runtime/agent/orchestrator/agent-trace-format.mjs';
+      import { drainAgentTrace } from './src/runtime/agent/orchestrator/agent-trace-io.mjs';
+      traceAgentTool({
+        sessionId: 'timing-test',
+        iteration: 1,
+        toolName: 'grep',
+        toolKind: 'builtin',
+        toolMs: 50,
+        resultKind: 'normal',
+        resultText: 'ok',
+        toolTiming: {
+          dispatchStartedAt: 100,
+          executionStartedAt: 110,
+          executionCompletedAt: 160,
+          postprocessStartedAt: 175,
+          resultCompletedAt: 190,
+        },
+      });
+      await drainAgentTrace();
+      const row = JSON.parse(readFileSync(process.env.MIXDOG_AGENT_TRACE_PATH, 'utf8').trim());
+      process.stdout.write(JSON.stringify(row.payload.timing));
+    `], {
+      cwd: process.cwd(),
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        MIXDOG_AGENT_TRACE_PATH: tracePath,
+        MIXDOG_AGENT_TRACE_DISABLE: '',
+        MIXDOG_AGENT_TRACE_LOCAL_DISABLE: '',
+        MIXDOG_RUNTIME_ROOT: join(dir, 'no-service'),
+      },
+    });
+    assert.equal(child.status, 0, child.stderr);
+    assert.deepEqual(JSON.parse(child.stdout), {
+      dispatch_wait_ms: 10,
+      execution_ms: 50,
+      result_collection_wait_ms: 15,
+      postprocess_ms: 15,
+      total_ms: 90,
+    });
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/runtime/agent/orchestrator/session/cache/prefetch-cache.mjs

@@ -50,7 +50,7 @@ function _maybeSweepDiskCache() {
     void _sweepDiskCache();
 }
 function _diskPath(absPath) {
-    const hash = createHash('sha256').update(absPath).digest('hex').slice(0, 16);
+    const hash = createHash('sha256').update(absPath).digest('hex');
     return join(DISK_CACHE_DIR, `${hash}.json`);
 }
 function _readDiskEntry(absPath) {
@@ -58,7 +58,7 @@ function _readDiskEntry(absPath) {
     if (!existsSync(p)) return null;
     try {
         const parsed = JSON.parse(readFileSync(p, 'utf8'));
-        if (!parsed || typeof parsed.content !== 'string' || !parsed.stat) return null;
+        if (!parsed || parsed.absPath !== absPath || typeof parsed.content !== 'string' || !parsed.stat) return null;
         return { content: parsed.content, stat: parsed.stat, ts: parsed.ts };
     } catch { return null; }
 }
@@ -157,7 +157,7 @@ export function invalidatePrefetchCache(path, cwd) {
     _deleteDiskEntry(abs);
 }
 
-function drainPrefetchDiskWrites() {
+export function drainPrefetchDiskWrites() {
     if (_diskWriteTimer !== null) {
         clearTimeout(_diskWriteTimer);
         _diskWriteTimer = null;

package/src/runtime/agent/orchestrator/session/cache/prefetch-cache.test.mjs

@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+import {
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+
+test('prefetch disk cache uses a full hash and rejects a mismatched path identity', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-prefetch-cache-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = root;
+  const source = join(root, 'source.txt');
+  writeFileSync(source, 'source');
+  try {
+    const first = await import(`./prefetch-cache.mjs?writer=${Date.now()}`);
+    first.setPrefetchCached(source, 'cached output');
+    first.drainPrefetchDiskWrites();
+    const cacheDir = join(root, 'cache', 'prefetch');
+    const [cacheFile] = readdirSync(cacheDir);
+    assert.match(cacheFile, /^[0-9a-f]{64}\.json$/);
+
+    const path = join(cacheDir, cacheFile);
+    const payload = JSON.parse(readFileSync(path, 'utf8'));
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(path, JSON.stringify({ ...payload, absPath: `${source}.other` }));
+
+    const second = await import(`./prefetch-cache.mjs?reader=${Date.now()}`);
+    assert.equal(second.tryPrefetchCached(source), null);
+  } finally {
+    if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/runtime/agent/orchestrator/session/tool-batch.mjs

@@ -726,6 +726,13 @@ export async function processToolBatch(ctx) {
                     resultText: result,
                     localSearchTelemetry: completed.localSearchTelemetry,
                     resultTelemetry: completed.resultTelemetry,
+                    toolTiming: {
+                        dispatchStartedAt,
+                        executionStartedAt: executionStartedAt ?? toolStartedAt,
+                        executionCompletedAt: toolEndedAt,
+                        postprocessStartedAt,
+                        resultCompletedAt: Date.now(),
+                    },
                     cwd,
                 });
                 // Deferred writes that predate a later mutation are skipped;

package/src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs

@@ -655,10 +655,10 @@ function guardRead(a) {
 }
 
 function guardShell(a) {
-    const allowed = new Set(['command', 'timeout_ms']);
+    const allowed = new Set(['command', 'timeout_ms', 'run_in_background']);
     const unsupported = Object.keys(a).find((key) => !allowed.has(key));
     if (unsupported) {
-        return `Error: shell arg "${unsupported}" is unsupported; use only command and timeout_ms`;
+        return `Error: shell arg "${unsupported}" is unsupported; use only command, timeout_ms, and run_in_background`;
     }
     if (!hasOwn(a, 'command')) {
         return 'Error: shell requires "command"';
@@ -672,6 +672,9 @@ function guardShell(a) {
     if (hasOwn(a, 'timeout_ms') && (typeof a.timeout_ms !== 'number' || !Number.isFinite(a.timeout_ms) || a.timeout_ms < 0)) {
         return `Error: shell arg "timeout_ms" must be a non-negative number (got ${describeType(a.timeout_ms)})`;
     }
+    if (hasOwn(a, 'run_in_background') && typeof a.run_in_background !== 'boolean') {
+        return `Error: shell arg "run_in_background" must be a boolean (got ${describeType(a.run_in_background)})`;
+    }
     return null;
 }
 

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -469,6 +469,10 @@ export async function executeBashTool(args, workDir, options = {}) {
     const _bgTasksDisabled = /^(1|true|yes|on)$/i.test(
         String(process.env.MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS || '').trim(),
     );
+    const runInBackground = args.run_in_background === true;
+    if (runInBackground && _bgTasksDisabled) {
+        return formatShellToolFailure('background tasks are disabled for this process');
+    }
 
     let shellEffects;
     let combinedBashAbort = null;
@@ -603,6 +607,7 @@ export async function executeBashTool(args, workDir, options = {}) {
             timeoutMs: timeout,
             abortSignal: combinedBashAbort.signal,
             autoBackgroundMs,
+            startInBackground: runInBackground,
             // On a foreground timeout, promote the still-running child to a
             // tracked background job only when an explicit deadline has
             // remaining budget; omitted deadlines may stay unlimited.