mixdog 0.8.0 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/boot-smoke.mjs

@@ -54,15 +54,15 @@ const rows = [
     try {
       const status = runtime.toolsStatus();
       const active = new Set(status.activeTools || []);
-      for (const name of ['read','code_graph','grep','glob','list','apply_patch','explore','bridge','tool_search']) {
+      for (const name of ['read','code_graph','grep','glob','list','apply_patch','explore','bridge','tool_search','shell']) {
         if (!active.has(name)) throw new Error('missing ' + name + ' in ' + [...active].join(','));
       }
-      for (const name of ['bash','edit','write']) {
+      for (const name of ['bash','task']) {
         if (active.has(name)) throw new Error('unexpected ' + name + ' in ' + [...active].join(','));
       }
       const result = runtime.selectTools('shell');
-      if (!result.added.includes('shell') || !result.added.includes('task')) {
-        throw new Error('shell alias should add shell/task: ' + JSON.stringify(result));
+      if (!result.already.includes('shell') || !result.added.includes('task')) {
+        throw new Error('shell alias should keep shell active and add task: ' + JSON.stringify(result));
       }
       const nextActive = new Set(result.status.activeTools || []);
       for (const name of ['shell','task']) {

package/scripts/session-context-bench.mjs

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadConfig, getDefaultPreset, getPreset } from '../src/runtime/agent/orchestrator/config.mjs';
+import { initProviders, getProvider } from '../src/runtime/agent/orchestrator/providers/registry.mjs';
+import { loadSession } from '../src/runtime/agent/orchestrator/session/store.mjs';
+import { semanticCompactMessages } from '../src/runtime/agent/orchestrator/session/compact.mjs';
+import { estimateMessagesTokens } from '../src/runtime/agent/orchestrator/session/context-utils.mjs';
+import * as memory from '../src/runtime/memory/index.mjs';
+
+const ROOT = resolve(fileURLToPath(new URL('..', import.meta.url)));
+
+function arg(name, fallback = null) {
+  const prefix = `--${name}=`;
+  const found = process.argv.find((item) => item.startsWith(prefix));
+  if (found) return found.slice(prefix.length);
+  const idx = process.argv.indexOf(`--${name}`);
+  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
+  return fallback;
+}
+
+function flag(name) {
+  return process.argv.includes(`--${name}`);
+}
+
+function textOfResult(result) {
+  if (result && typeof result === 'object' && Array.isArray(result.content)) {
+    return result.content.map((part) => part?.type === 'text' ? part.text || '' : JSON.stringify(part)).join('\n');
+  }
+  if (typeof result === 'string') return result;
+  return JSON.stringify(result ?? '', null, 2);
+}
+
+function messageText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (typeof part === 'string') return part;
+      if (part?.type === 'text') return part.text || '';
+      if (part?.type === 'image') return '[image]';
+      return part?.text || '';
+    }).filter(Boolean).join('\n');
+  }
+  try { return JSON.stringify(content ?? ''); } catch { return String(content ?? ''); }
+}
+
+function renderMessages(messages) {
+  return (messages || [])
+    .map((m, i) => `# message ${i + 1} role=${m.role}\n${messageText(m.content)}`.trim())
+    .join('\n\n');
+}
+
+function coverageScore(sourceText, candidateText) {
+  const terms = [...new Set(String(sourceText || '').toLowerCase().match(/[\p{L}\p{N}_./:-]{4,}/gu) || [])]
+    .filter((term) => !/^(https?|that|this|with|from|have|there|would|could|should)$/i.test(term))
+    .slice(0, 5000);
+  if (!terms.length) return 0;
+  const hay = String(candidateText || '').toLowerCase();
+  let hit = 0;
+  for (const term of terms) if (hay.includes(term)) hit += 1;
+  return Number((hit / terms.length).toFixed(4));
+}
+
+async function providerFromConfig(config, { providerName, modelName }) {
+  await initProviders(config.providers || {});
+  let provider = providerName;
+  let model = modelName;
+  if (!provider || !model) {
+    const presetName = arg('preset', null);
+    const preset = presetName ? getPreset(config, presetName) : getDefaultPreset(config);
+    provider ||= preset?.provider;
+    model ||= preset?.model;
+  }
+  if (!provider || !model) throw new Error('provider/model required; pass --provider and --model or configure a default preset');
+  const impl = getProvider(provider);
+  if (!impl) throw new Error(`provider not available: ${provider}`);
+  return { provider, model, impl };
+}
+
+async function judgePair(provider, model, sourceText, semanticText, recallText) {
+  const prompt = `You are judging two context-compression strategies for continuing a coding session.\n\nEvaluate which preserves actionable state better for the next assistant turn. Prefer factual coverage, exact constraints, file paths, decisions, and current task continuity.\n\nReturn strict JSON: {"winner":"semantic"|"recall_roots"|"tie","semantic_score":1-10,"recall_roots_score":1-10,"reason":"short"}.\n\n# Original session excerpt\n${sourceText.slice(0, 30000)}\n\n# Candidate A: semantic compact\n${semanticText.slice(0, 30000)}\n\n# Candidate B: recall root/raw chunks\n${recallText.slice(0, 30000)}`;
+  const response = await provider.send([
+    { role: 'system', content: 'Judge compression quality. Output JSON only.' },
+    { role: 'user', content: prompt },
+  ], model, undefined, { effort: 'low', fast: true, maxOutputTokens: 800 });
+  const text = String(response?.content || '').trim();
+  try { return JSON.parse(text.replace(/^```json\s*/i, '').replace(/```$/i, '').trim()); }
+  catch { return { raw: text }; }
+}
+
+async function main() {
+  if (flag('help') || flag('h')) {
+    process.stdout.write('usage: node scripts/session-context-bench.mjs --session <sessionId> [--provider p --model m] [--preset name] [--budget n] [--judge]\n');
+    return;
+  }
+  const sessionId = arg('session');
+  if (!sessionId) throw new Error('usage: node scripts/session-context-bench.mjs --session <sessionId> [--provider p --model m] [--judge]');
+  const session = loadSession(sessionId);
+  if (!session) throw new Error(`session not found: ${sessionId}`);
+  const messages = Array.isArray(session.messages) ? session.messages : [];
+  if (!messages.length) throw new Error(`session has no messages: ${sessionId}`);
+
+  const config = loadConfig();
+  const { provider, model, impl } = await providerFromConfig(config, {
+    providerName: arg('provider', session.provider || null),
+    modelName: arg('model', session.model || null),
+  });
+
+  await memory.init();
+  await memory.handleToolCall('memory', {
+    action: 'ingest_session',
+    sessionId,
+    cwd: session.cwd || ROOT,
+    messages,
+    limit: Number(arg('ingest-limit', 500)) || 500,
+  });
+  await memory.handleToolCall('memory', {
+    action: 'cycle1',
+    min_batch: 1,
+    session_cap: 1,
+    batch_size: Math.max(1, Math.min(200, Number(arg('batch-size', messages.length)) || messages.length)),
+  });
+  const recallDumpResult = await memory.handleToolCall('memory', {
+    action: 'dump_session_roots',
+    sessionId,
+    includeRaw: true,
+    limit: Number(arg('limit', 1000)) || 1000,
+  });
+  const recallText = textOfResult(recallDumpResult);
+
+  const budget = Number(arg('budget', 16000)) || 16000;
+  const semantic = await semanticCompactMessages(impl, messages, model, budget, {
+    force: true,
+    sessionId,
+    providerName: provider,
+    tailTurns: Number(arg('tail-turns', 2)) || 2,
+    timeoutMs: Number(arg('timeout-ms', 60000)) || 60000,
+  });
+  const semanticText = renderMessages(semantic.messages);
+  const sourceText = renderMessages(messages);
+
+  const report = {
+    sessionId,
+    provider,
+    model,
+    source: { messages: messages.length, tokens: estimateMessagesTokens(messages), chars: sourceText.length },
+    semantic: { messages: semantic.messages.length, tokens: estimateMessagesTokens(semantic.messages), chars: semanticText.length, lexicalCoverage: coverageScore(sourceText, semanticText), usage: semantic.usage || null },
+    recallRoots: { chars: recallText.length, lexicalCoverage: coverageScore(sourceText, recallText) },
+    judge: null,
+  };
+  if (flag('judge')) {
+    report.judge = await judgePair(impl, model, sourceText, semanticText, recallText);
+  }
+
+  const outDir = resolve(arg('out', join(ROOT, '.mixdog-bench', `session-context-${sessionId}`)));
+  mkdirSync(outDir, { recursive: true });
+  writeFileSync(join(outDir, 'source.txt'), sourceText, 'utf8');
+  writeFileSync(join(outDir, 'semantic.txt'), semanticText, 'utf8');
+  writeFileSync(join(outDir, 'recall-roots.txt'), recallText, 'utf8');
+  writeFileSync(join(outDir, 'report.json'), JSON.stringify(report, null, 2), 'utf8');
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\noutputs: ${outDir}\n`);
+}
+
+main()
+  .catch((err) => {
+    process.stderr.write(`${err?.stack || err?.message || err}\n`);
+    process.exitCode = 1;
+  })
+  .finally(async () => {
+    try { await memory.stop?.(); } catch {}
+  });

package/scripts/tool-smoke.mjs

@@ -275,13 +275,13 @@ const smokeCatalog = [
 ].filter(Boolean);
 
 const fullDefaults = defaultDeferredToolNames(smokeCatalog, 'full');
-if (fullDefaults.size !== 12) {
-  throw new Error(`full default surface should stay 12 tools, got ${fullDefaults.size}: ${[...fullDefaults].join(', ')}`);
+if (fullDefaults.size !== 13) {
+  throw new Error(`full default surface should stay 13 tools, got ${fullDefaults.size}: ${[...fullDefaults].join(', ')}`);
 }
-for (const name of ['read', 'code_graph', 'grep', 'glob', 'list', 'apply_patch', 'explore', 'bridge', 'recall', 'search', 'web_fetch', 'tool_search']) {
+for (const name of ['read', 'code_graph', 'grep', 'glob', 'list', 'apply_patch', 'explore', 'bridge', 'shell', 'recall', 'search', 'web_fetch', 'tool_search']) {
   assertHas(fullDefaults, name);
 }
-for (const name of ['shell', 'edit', 'write']) {
+for (const name of ['task']) {
   assertLacks(fullDefaults, name);
 }
 
@@ -292,10 +292,6 @@ if (leadDefaults.size !== 14) {
 for (const name of ['read', 'code_graph', 'grep', 'glob', 'list', 'shell', 'task', 'apply_patch', 'explore', 'bridge', 'recall', 'search', 'web_fetch', 'tool_search']) {
   assertHas(leadDefaults, name);
 }
-for (const name of ['edit', 'write']) {
-  assertLacks(leadDefaults, name);
-}
-
 function toolSchemaSize(tool) {
   const desc = String(tool?.description || '');
   const schema = JSON.stringify(tool?.input_schema || tool?.inputSchema || {});
@@ -306,8 +302,8 @@ const surfaceSize = [...fullDefaults].reduce((sum, name) => {
   const tool = smokeCatalog.find((item) => item?.name === name);
   return sum + toolSchemaSize(tool);
 }, 0);
-if (surfaceSize > 14000) {
-  throw new Error(`full default tool surface too large: ${surfaceSize} chars (cap 14000)`);
+if (surfaceSize > 17000) {
+  throw new Error(`full default tool surface too large: ${surfaceSize} chars (cap 17000)`);
 }
 for (const [name, cap] of [
   ['apply_patch', 1300],
@@ -330,7 +326,7 @@ if (readonlyDefaults.size !== 7) {
 for (const name of ['read', 'code_graph', 'grep', 'glob', 'list', 'explore', 'tool_search']) {
   assertHas(readonlyDefaults, name);
 }
-for (const name of ['apply_patch', 'bridge', 'shell', 'edit', 'write']) {
+for (const name of ['apply_patch', 'bridge', 'shell']) {
   assertLacks(readonlyDefaults, name);
 }
 

package/src/mixdog-session-runtime.mjs

@@ -86,6 +86,40 @@ function messageContextText(message) {
   return text;
 }
 
+function stripSystemReminder(text) {
+  return String(text || '')
+    .replace(/^\s*<system-reminder>\s*/i, '')
+    .replace(/\s*<\/system-reminder>\s*$/i, '')
+    .trim();
+}
+
+function splitMarkdownSections(text) {
+  const sections = [];
+  let current = [];
+  for (const line of String(text || '').split(/\r?\n/)) {
+    if (/^#\s+/.test(line) && current.length) {
+      const body = current.join('\n').trim();
+      if (body) sections.push(body);
+      current = [line];
+    } else {
+      current.push(line);
+    }
+  }
+  const tail = current.join('\n').trim();
+  if (tail) sections.push(tail);
+  return sections;
+}
+
+function reminderSectionBucket(section) {
+  const heading = String(section.match(/^#\s+([^\n]+)/)?.[1] || '').trim().toLowerCase();
+  if (heading.includes('core memory')) return 'memory';
+  if (heading.includes('mixdog-project-context') || heading.includes('project-context')) return 'project';
+  if (heading.includes('active workflow') || heading.includes('available agents') || heading.includes('workflow')) return 'workflow';
+  if (heading.includes('workspace') || heading === 'role' || heading.includes('role-identity') || heading.includes('task-brief')) return 'workspace';
+  if (heading.includes('environment')) return 'environment';
+  return 'other';
+}
+
 function summarizeContextMessages(messages) {
   const rows = {
     system: { count: 0, tokens: 0 },
@@ -94,15 +128,55 @@ function summarizeContextMessages(messages) {
     tool: { count: 0, tokens: 0 },
     other: { count: 0, tokens: 0 },
   };
+  const semantic = {
+    system: { count: 0, tokens: 0 },
+    chat: { count: 0, tokens: 0 },
+    assistant: { count: 0, tokens: 0 },
+    toolResults: { count: 0, tokens: 0 },
+    reminders: { count: 0, tokens: 0, otherTokens: 0 },
+    project: { tokens: 0 },
+    workflow: { tokens: 0 },
+    memory: { tokens: 0 },
+    workspace: { tokens: 0 },
+    environment: { tokens: 0 },
+    other: { tokens: 0 },
+  };
   let toolCallCount = 0;
   let toolCallTokens = 0;
   let toolResultCount = 0;
   let toolResultTokens = 0;
   for (const message of messages || []) {
     const role = rows[message?.role] ? message.role : 'other';
-    const tokens = roughTokenCount(messageContextText(message)) + 4;
+    const text = messageContextText(message);
+    const tokens = roughTokenCount(text) + 4;
     rows[role].count += 1;
     rows[role].tokens += tokens;
+    if (role === 'system') {
+      semantic.system.count += 1;
+      semantic.system.tokens += tokens;
+    } else if (role === 'user') {
+      if (String(text || '').trim().startsWith('<system-reminder>')) {
+        semantic.reminders.count += 1;
+        semantic.reminders.tokens += tokens;
+        let sectionTokens = 0;
+        for (const section of splitMarkdownSections(stripSystemReminder(text))) {
+          const bucket = reminderSectionBucket(section);
+          const sectionTokenCount = roughTokenCount(section);
+          semantic[bucket].tokens += sectionTokenCount;
+          sectionTokens += sectionTokenCount;
+        }
+        semantic.reminders.otherTokens += Math.max(0, tokens - sectionTokens);
+      } else {
+        semantic.chat.count += 1;
+        semantic.chat.tokens += tokens;
+      }
+    } else if (role === 'assistant') {
+      semantic.assistant.count += 1;
+      semantic.assistant.tokens += tokens;
+    } else if (role === 'tool') {
+      semantic.toolResults.count += 1;
+      semantic.toolResults.tokens += tokens;
+    }
     if (message?.role === 'assistant' && Array.isArray(message.toolCalls) && message.toolCalls.length) {
       toolCallCount += message.toolCalls.length;
       try { toolCallTokens += roughTokenCount(JSON.stringify(message.toolCalls)); }
@@ -117,6 +191,7 @@ function summarizeContextMessages(messages) {
     count: Array.isArray(messages) ? messages.length : 0,
     estimatedTokens: Array.isArray(messages) ? estimateMessagesTokens(messages) : 0,
     roles: rows,
+    semantic,
     toolCallCount,
     toolCallTokens,
     toolResultCount,
@@ -254,12 +329,13 @@ export const TOOL_SEARCH_TOOL = {
     destructiveHint: false,
     idempotentHint: true,
     openWorldHint: false,
+    bridgeHidden: true,
   },
   description: 'Search the current standalone tool surface and select deferred tools/skills for the task. Use before unfamiliar or currently inactive tools.',
   inputSchema: {
     type: 'object',
     properties: {
-      query: { type: 'string', description: 'Optional search text, e.g. edit, bridge, memory, skill, mcp.' },
+      query: { type: 'string', description: 'Optional search text, e.g. shell, bridge, memory, skill, mcp.' },
       select: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Tool/skill names to activate, as comma-separated text or an array.' },
       limit: { type: 'number', description: 'Maximum matches to return.' },
     },
@@ -330,7 +406,7 @@ const DEFERRED_ALWAYS_ACTIVE_TOOLS = new Set([
   'web_fetch',
 ]);
 const LEAD_DISALLOWED_TOOLS = Object.freeze(['diagnostics', 'open_config']);
-const DEFERRED_DEFAULT_FULL_LIMIT = 8;
+const DEFERRED_DEFAULT_FULL_LIMIT = 9;
 const DEFERRED_DEFAULT_READONLY_TOOLS = Object.freeze([
   'read',
   'code_graph',
@@ -1168,10 +1244,37 @@ function toolKind(tool) {
   if (name.startsWith('mcp__')) return 'mcp';
   if (name.startsWith('skill_') || name === 'skills_list') return 'skill';
   if (tool?.annotations?.bridgeHidden) return 'control';
-  if (['edit', 'write', 'apply_patch', 'shell'].includes(name)) return 'write';
+  if (['apply_patch', 'shell'].includes(name)) return 'mutation';
   return 'tool';
 }
 
+function toolSchemaBucket(tool) {
+  const name = clean(tool?.name);
+  const kind = toolKind(tool);
+  if (kind === 'mcp') return 'mcp';
+  if (kind === 'skill') return 'skills';
+  if (name === 'memory' || name === 'recall' || name.includes('memory')) return 'memory';
+  if (name === 'search' || name === 'web_fetch') return 'web';
+  if (['read', 'grep', 'glob', 'list', 'code_graph', 'explore'].includes(name)) return 'code';
+  if (['shell', 'apply_patch'].includes(name)) return 'mutation';
+  if (name === 'bridge' || name === 'delegate' || name.includes('bridge')) return 'agents';
+  if (name.includes('channel') || name.includes('discord') || name.includes('webhook')) return 'channels';
+  if (name.includes('provider') || name === 'tool_search' || name === 'cwd') return 'setup';
+  return 'other';
+}
+
+function estimateToolSchemaBreakdown(tools) {
+  const out = {};
+  for (const tool of Array.isArray(tools) ? tools : []) {
+    const bucket = toolSchemaBucket(tool);
+    const row = out[bucket] || { count: 0, tokens: 0 };
+    row.count += 1;
+    row.tokens += estimateToolSchemaTokens([tool]);
+    out[bucket] = row;
+  }
+  return out;
+}
+
 function measuredToolUsage(name) {
   return MEASURED_TOOL_USAGE[clean(name)] || 0;
 }
@@ -2720,6 +2823,7 @@ function parsedProviderModelVersion(id) {
 
       const messageSummary = summarizeContextMessages(messages);
       const toolSchemaTokens = estimateToolSchemaTokens(tools);
+      const toolSchemaBreakdown = estimateToolSchemaBreakdown(tools);
       const requestReserveTokens = estimateRequestReserveTokens(tools);
       const requestOverheadTokens = Math.max(0, requestReserveTokens - toolSchemaTokens);
       const rawWindow = Number(session?.rawContextWindow || session?.contextWindow || 0);
@@ -2776,6 +2880,7 @@ function parsedProviderModelVersion(id) {
         messages: messageSummary,
         request: {
           toolSchemaTokens,
+          toolSchemaBreakdown,
           requestOverheadTokens,
           reserveTokens: requestReserveTokens,
         },
@@ -3647,21 +3752,25 @@ function parsedProviderModelVersion(id) {
           || (sourceType === 'cli' && (!sourceName || sourceName === 'main'))
           || (!sourceType && !sourceName && owner !== 'bridge');
         if (!leadish) return null;
-        const msgs = s.messages || [];
-        const userPreviews = msgs
-          .filter(m => m && m.role === 'user')
-          .map(m => cleanSessionPreview(sessionMessageText(m.content)))
-          .filter(text => !isSessionPreviewNoise(text));
-        const preview = userPreviews[userPreviews.length - 1] || userPreviews[0] || '';
+        let preview = cleanSessionPreview(s.preview || '');
+        let messageCount = Math.max(0, Number(s.messageCount) || 0);
+        if (!preview && Array.isArray(s.messages)) {
+          const msgs = s.messages || [];
+          const userPreviews = msgs
+            .filter(m => m && m.role === 'user')
+            .map(m => cleanSessionPreview(sessionMessageText(m.content)))
+            .filter(text => !isSessionPreviewNoise(text));
+          preview = userPreviews[userPreviews.length - 1] || userPreviews[0] || '';
+          messageCount = msgs.filter(m => m && (m.role === 'user' || m.role === 'assistant')).length;
+        }
         if (!preview) return null;
-        const userAsst = msgs.filter(m => m && (m.role === 'user' || m.role === 'assistant'));
         return {
           id: s.id,
           updatedAt: s.updatedAt,
           cwd: s.cwd || '',
           model: s.model,
           provider: s.provider,
-          messageCount: userAsst.length,
+          messageCount,
           preview,
         };
       }).filter(Boolean);

package/src/repl.mjs

@@ -261,10 +261,18 @@ async function handleSlash(line, ctx) {
           stdout.write(yellow('compact failed') + '\n');
           return;
         }
+        if (r.error) {
+          stdout.write(red('compact failed') + '\n');
+          return;
+        }
         if (r.changed === false && r.reason) {
           stdout.write(yellow(r.reason) + '\n');
           return;
         }
+        if (r.changed === false) {
+          stdout.write(yellow('nothing to compact') + '\n');
+          return;
+        }
         stdout.write(green(`✓ compacted context: ${r.beforeMessages}→${r.afterMessages} messages, context ${r.beforeTokens}→${r.afterTokens}`) + '\n');
       }
       return;

package/src/runtime/agent/orchestrator/context/collect.mjs

@@ -683,11 +683,11 @@ export function composeSystemPrompt(opts) {
         let permissionLabel = String(permission);
         let allow =
             permission === 'read'
-                ? 'read-only; write/edit/shell rejected'
+                ? 'read-only; apply_patch/shell rejected'
                 : permission === 'read-write'
-                    ? 'read + write/edit/shell'
+                    ? 'read + apply_patch/shell'
                     : permission === 'mcp'
-                        ? 'MCP/internal retrieval tools only; file/shell/edit tools rejected'
+                        ? 'MCP/internal retrieval tools only; file/shell mutation tools rejected'
                     : permission === 'full'
                         ? 'full — all tools'
                         : 'unknown — treat as read-only';

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

@@ -28,7 +28,7 @@
  *                     webhook). Receive only their own self section in BP2.
  *
  * Permission classification:
- *   - 'read'       : read-only — write/edit/bash blocked at loop.mjs runtime
+ *   - 'read'       : read-only — apply_patch/shell blocked at loop.mjs runtime
  *                    guard with the same error string public read-only roles see.
  *   - 'read-write' : full tool surface — used by hidden roles that legitimately
  *                    mutate state (scheduler-task launches commands,

package/src/runtime/agent/orchestrator/session/cache/post-edit-marks.mjs

@@ -1,12 +1,12 @@
-// Post-edit advisory marks: one-shot sidecar on the next read after a write.
+// Post-patch advisory marks: one-shot sidecar on the next read after a patch.
 import { _normalizeAbs } from './util.mjs';
 
 // sessionId -> Map<absPath, { ts, toolName }>
 const _postEditBySession = new Map();
 
 /**
- * Mark `path` as just-edited for `sessionId`. Caller invokes this after a
- * successful write/edit/apply_patch so the next read on the same path can
+ * Mark `path` as just-patched for `sessionId`. Caller invokes this after a
+ * successful apply_patch so the next read on the same path can
  * receive a one-shot advisory sidecar.
  */
 export function markPostEdit({ sessionId, path, cwd, toolName }) {
@@ -15,7 +15,7 @@ export function markPostEdit({ sessionId, path, cwd, toolName }) {
     if (!abs) return;
     let m = _postEditBySession.get(sessionId);
     if (!m) { m = new Map(); _postEditBySession.set(sessionId, m); }
-    m.set(abs, { ts: Date.now(), toolName: String(toolName || 'edit') });
+    m.set(abs, { ts: Date.now(), toolName: String(toolName || 'apply_patch') });
 }
 
 /**

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

@@ -222,7 +222,7 @@ export function setReadCached({ sessionId, args, cwd, content, toolUseId }) {
 
 /**
  * Invalidate all cache entries for `path` in the given session. Called when
- * a write-class tool (write/edit/apply_patch) touches the path.
+ * a mutation tool (apply_patch) touches the path.
  */
 export function invalidatePathForSession(sessionId, path, cwd) {
     if (!sessionId) return;