mixdog 0.9.135 → 0.9.136

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.135",
+  "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/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

@@ -41,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 —
@@ -73,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/builtin-tools.mjs

@@ -89,11 +89,6 @@ export const BUILTIN_TOOLS = [
             type: 'object',
             properties: {
                 command: { type: 'string', description: `Command.${_shellSyntaxCheat}` },
-                timeout_ms: {
-                    type: 'integer',
-                    minimum: 0,
-                    description: 'Hard total deadline in milliseconds; omit or use 0 to allow unlimited runtime after task promotion.',
-                },
                 ...(_shellBackgroundDisabled ? {} : {
                     run_in_background: {
                         type: 'boolean',

package/src/runtime/agent/orchestrator/tools/builtin/cache-layers.mjs

@@ -359,9 +359,8 @@ export function getCachedReadOnlyStat(fullPath, loader = statSync, now = Date.no
     return stat;
 }
 
-export async function statPathsForMtime(paths, workDir, concurrency = Infinity, opts = {}) {
+async function visitPathStats(paths, workDir, concurrency, opts, visitor) {
     const items = Array.isArray(paths) ? paths : [];
-    const out = new Array(items.length);
     const now = Date.now();
     const inflight = new Map();
     let next = 0;
@@ -406,17 +405,31 @@ export async function statPathsForMtime(paths, workDir, concurrency = Infinity,
             if (index >= items.length) return;
             const p = items[index];
             const full = isAbsolute(p) ? p : resolveAgainstCwd(p, workDir);
+            let entry;
             try {
                 const stat = await resolveStat(full);
                 if (!stat) throw new Error('stat failed');
-                out[index] = { path: p, full, stat, size: stat.size, mtime: stat.mtimeMs, mtimeMs: stat.mtimeMs };
+                entry = { path: p, full, stat, size: stat.size, mtime: stat.mtimeMs, mtimeMs: stat.mtimeMs };
             } catch {
-                out[index] = { path: p, full, stat: null, size: 0, mtime: 0, mtimeMs: 0 };
+                entry = { path: p, full, stat: null, size: 0, mtime: 0, mtimeMs: 0 };
             }
+            visitor(entry, index);
         }
     }
     const workerCount = Math.min(Math.max(1, concurrency), Math.max(1, items.length));
     await Promise.all(Array.from({ length: workerCount }, worker));
+}
+
+export async function visitPathsForMtime(paths, workDir, concurrency = Infinity, opts = {}, visitor = () => {}) {
+    await visitPathStats(paths, workDir, concurrency, opts, visitor);
+}
+
+export async function statPathsForMtime(paths, workDir, concurrency = Infinity, opts = {}) {
+    const items = Array.isArray(paths) ? paths : [];
+    const out = new Array(items.length);
+    await visitPathStats(items, workDir, concurrency, opts, (entry, index) => {
+        out[index] = entry;
+    });
     return out;
 }
 

package/src/runtime/agent/orchestrator/tools/builtin/edit-sequential-occupation.test.mjs

@@ -8,7 +8,9 @@ import { mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { tryExecuteExternalToolAdapter } from './external-tool-adapters.mjs';
+import { executeBuiltinTool } from '../builtin.mjs';
 import { recordReadSnapshot } from './read-snapshot-runtime.mjs';
+import { executePatchTool } from '../patch.mjs';
 import { closeNativePatchServerForTests } from '../patch/native-server.mjs';
 
 const ANCHOR = '#if 0\n"""\n#endif';
@@ -57,6 +59,44 @@ test('count drift falls through to the strict ambiguity reject', async (t) => {
     assert.match(String(result), /current file excerpt lines/);
 });
 
+test('successful edit snapshot makes a follow-up read return unchanged', async (t) => {
+    const { dir, file } = makeTempFile('alpha\nkeep\n');
+    const sessionId = `edit-known-current-${process.pid}`;
+    t.after(() => { rmSync(dir, { recursive: true, force: true }); void closeNativePatchServerForTests?.(); });
+
+    const result = await tryExecuteExternalToolAdapter('edit', {
+        file_path: file,
+        old_string: 'alpha',
+        new_string: 'omega',
+    }, dir, { sessionId });
+    assert.match(String(result), /^Updated /);
+
+    const reread = await executeBuiltinTool('read', { path: file }, dir, { sessionId });
+    assert.equal(reread, `[file unchanged: ${file.replaceAll('\\', '/')}]`);
+});
+
+test('successful apply_patch snapshot makes a follow-up read return unchanged', async (t) => {
+    const { dir, file } = makeTempFile('alpha\nkeep\n');
+    const sessionId = `patch-known-current-${process.pid}`;
+    t.after(() => { rmSync(dir, { recursive: true, force: true }); void closeNativePatchServerForTests?.(); });
+
+    const result = await executePatchTool('apply_patch', {
+        base_path: dir,
+        patch: `*** Begin Patch
+*** Update File: poly.c
+@@
+-alpha
++omega
+ keep
+*** End Patch
+`,
+    }, dir, { sessionId });
+    assert.match(String(result), /^Applied 1 File \(Native\)/);
+
+    const reread = await executeBuiltinTool('read', { path: file }, dir, { sessionId });
+    assert.equal(reread, `[file unchanged: ${file.replaceAll('\\', '/')}]`);
+});
+
 test('stale read snapshot does not block a still-unique current old_string', async (t) => {
     const { dir, file } = makeTempFile('alpha\nkeep\n');
     const sessionId = `edit-stale-safe-${process.pid}`;