mixdog 0.9.34 → 0.9.36

package/scripts/agent-live-arg-guard-smoke.mjs

@@ -0,0 +1,20 @@
+// Standalone regression smoke for validateBuiltinArgs guard behavior.
+// Mirrors arg-guard-test.mjs style; runs with `node --test`.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { validateBuiltinArgs } from '../src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs';
+
+test('smoke: valid read args pass and numeric strings coerce', () => {
+    const a = { path: 'x.mjs', offset: '2', limit: '10' };
+    assert.equal(validateBuiltinArgs('read', a), null);
+    assert.equal(a.offset, 2);
+    assert.equal(a.limit, 10);
+});
+
+test('smoke: non-numeric arg still errors', () => {
+    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', limit: 'nope' }), /must be an integer/);
+});
+
+test('smoke: below-min arg still errors', () => {
+    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', offset: -1 }), /must be >= 0/);
+});

package/scripts/agent-live-path-suffix-smoke.mjs

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { findBySuffixStrip } from '../src/runtime/agent/orchestrator/tools/builtin/path-diagnostics.mjs';
+
+function makeRepo() {
+    const root = mkdtempSync(join(tmpdir(), 'mixdog-suffix-smoke-'));
+    mkdirSync(join(root, 'src', 'tui'), { recursive: true });
+    writeFileSync(join(root, 'src', 'tui', 'input-editing.mjs'), '// real file\n');
+    return root;
+}
+
+test('smoke: hallucinated absolute prefix resolves to the real repo-relative file', () => {
+    const root = makeRepo();
+    try {
+        const hallucinated = '/Users/nobody/Elsewhere/Project/ink/src/tui/input-editing.mjs';
+        const hit = findBySuffixStrip(root, hallucinated);
+        assert.equal(hit, 'src/tui/input-editing.mjs');
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('smoke: a non-existent tail resolves to null', () => {
+    const root = makeRepo();
+    try {
+        const hit = findBySuffixStrip(root, '/Users/nobody/Elsewhere/Project/does/not/here.mjs');
+        assert.equal(hit, null);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/scripts/agent-live-toolcall-args-smoke.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// Standalone regression smoke pinning the tool_call arguments contract used by
+// the native providers (see scripts/toolcall-args-test.mjs for the full suite).
+// Same unit-test style: synthetic inputs fed to the exported parser, asserting
+// the outcome — no network, no model. Kept minimal so it can run in isolation
+// via `node --test scripts/agent-live-toolcall-args-smoke.mjs`.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    parseCompletedToolCallArgumentsJson,
+    isInvalidToolArgsMarker,
+    formatInvalidToolArgsResult,
+} from '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs';
+
+test('smoke: valid arguments JSON parses to the intended object', () => {
+    const out = parseCompletedToolCallArgumentsJson(
+        '{"pattern":"x","path":"src"}', 'smoke', { finishReason: 'stop' });
+    assert.deepEqual(out, { pattern: 'x', path: 'src' });
+});
+
+test('smoke: empty/missing arguments default to {}', () => {
+    assert.deepEqual(parseCompletedToolCallArgumentsJson('', 'smoke', { finishReason: 'stop' }), {});
+    assert.deepEqual(parseCompletedToolCallArgumentsJson(undefined, 'smoke'), {});
+});
+
+test('smoke: malformed args with finishReason → invalid-args marker (no throw)', () => {
+    const bareword = '{"pattern": dispatchAiWrapped, "path": "src/agent"}';
+    const out = parseCompletedToolCallArgumentsJson(bareword, 'smoke', { finishReason: 'stop' });
+    assert.equal(isInvalidToolArgsMarker(out), true);
+    assert.equal(out.__rawArguments, bareword);
+    const msg = formatInvalidToolArgsResult({ name: 'grep', arguments: out });
+    assert.match(msg, /Re-issue this tool call with valid JSON arguments/);
+});
+
+test('smoke: malformed args without finishReason → retryable TruncatedStreamError', () => {
+    let threw;
+    try {
+        parseCompletedToolCallArgumentsJson('{', 'smoke');
+    } catch (err) {
+        threw = err;
+    }
+    assert.ok(threw instanceof Error, 'must throw on mid-stream truncation');
+    assert.equal(threw.code, 'TRUNCATED_STREAM');
+    assert.equal(threw.truncatedStream, true);
+});

package/scripts/apply-patch-edit-smoke.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.mjs';
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function assertOk(label, result) {
+  const text = String(result || '');
+  if (!text || /^Error[\s:]/.test(text)) {
+    throw new Error(`${label} failed:\n${text}`);
+  }
+  return text;
+}
+
+const tmp = mkdtempSync(join(tmpdir(), 'mixdog-apply-patch-smoke-'));
+
+try {
+  writeFileSync(join(tmp, 'target.txt'), 'alpha\nbeta\ngamma\n', 'utf8');
+
+  const editResult = await executePatchTool('apply_patch', {
+    base_path: tmp,
+    patch: `*** Begin Patch
+*** Update File: target.txt
+@@
+ alpha
+-beta
++bravo
+ gamma
+*** Add File: created.txt
++created by apply_patch smoke
++second line
+*** End Patch
+`,
+  }, tmp, {});
+  assertOk('apply_patch edit', editResult);
+
+  assert(
+    readFileSync(join(tmp, 'target.txt'), 'utf8') === 'alpha\nbravo\ngamma\n',
+    'apply_patch update did not write the expected target.txt contents',
+  );
+  assert(
+    readFileSync(join(tmp, 'created.txt'), 'utf8') === 'created by apply_patch smoke\nsecond line\n',
+    'apply_patch add did not write the expected created.txt contents',
+  );
+
+  const deleteResult = await executePatchTool('apply_patch', {
+    base_path: tmp,
+    patch: `*** Begin Patch
+*** Delete File: created.txt
+*** End Patch
+`,
+  }, tmp, {});
+  assertOk('apply_patch delete', deleteResult);
+
+  let deleteMissing = false;
+  try {
+    readFileSync(join(tmp, 'created.txt'), 'utf8');
+  } catch (err) {
+    if (err?.code === 'ENOENT') deleteMissing = true;
+    else throw err;
+  }
+  assert(deleteMissing, 'apply_patch delete left created.txt on disk');
+
+  process.stdout.write('apply_patch edit smoke passed\n');
+} finally {
+  rmSync(tmp, { recursive: true, force: true });
+}

package/scripts/async-notify-settlement-test.mjs

@@ -0,0 +1,99 @@
+// A Promise-returning notifyFn must only *mark* a background-task completion
+// delivered after the promise settles. When it rejects/declines AND the
+// enqueueFallback rescue also fails, the task must be left UN-marked so a later
+// reconcile can retry — never silently marked delivered before settlement.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  registerBackgroundTask,
+  completeBackgroundTask,
+  getBackgroundTask,
+  setBackgroundTaskEnqueueFallback,
+  reconcileBackgroundTask,
+} from '../src/runtime/shared/background-tasks.mjs';
+
+const tick = () => new Promise((r) => setImmediate(r));
+
+test('async notifyFn rejection with no rescue does not mark delivered', async () => {
+  setBackgroundTaskEnqueueFallback(null); // no fallback channel → nothing lands
+  const task = registerBackgroundTask({
+    surface: 'tool',
+    operation: 'run',
+    resultType: 'tool_task_result',
+    context: { notifyFn: () => Promise.reject(new Error('boom')) },
+  });
+  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
+
+  // Optimistic marks were applied synchronously; settlement must clear them.
+  await tick();
+  await tick();
+  const t = getBackgroundTask(task.taskId);
+  assert.equal(t.notifiedWithBody, false, 'body delivery un-marked after async failure');
+  assert.equal(t.notified, false, 'notified un-marked after async failure');
+});
+
+test('async notifyFn success keeps the completion marked delivered', async () => {
+  setBackgroundTaskEnqueueFallback(null);
+  const task = registerBackgroundTask({
+    surface: 'tool',
+    operation: 'run',
+    resultType: 'tool_task_result',
+    context: { notifyFn: () => Promise.resolve(true) },
+  });
+  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
+
+  await tick();
+  await tick();
+  const t = getBackgroundTask(task.taskId);
+  assert.equal(t.notifiedWithBody, true, 'successful async delivery stays marked');
+  assert.equal(t.notified, true, 'successful async delivery stays notified');
+});
+
+test('async notifyFn rejection is rescued by fallback and stays marked', async () => {
+  const enqueued = [];
+  setBackgroundTaskEnqueueFallback((sessionId, text) => { enqueued.push({ sessionId, text }); return 1; });
+  const task = registerBackgroundTask({
+    surface: 'tool',
+    operation: 'run',
+    resultType: 'tool_task_result',
+    context: { notifyFn: () => Promise.reject(new Error('boom')), callerSessionId: 'sess_rescue' },
+  });
+  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
+
+  await tick();
+  await tick();
+  const t = getBackgroundTask(task.taskId);
+  assert.equal(enqueued.length, 1, 'fallback rescued the completion once');
+  assert.equal(t.notifiedWithBody, true, 'rescued delivery stays marked exactly once');
+});
+
+test('reconcile retries an un-marked completion on an already-terminal task', async () => {
+  // First completion: async notifyFn rejects and there is NO fallback, so the
+  // task is driven terminal but the body notification un-marks itself.
+  setBackgroundTaskEnqueueFallback(null);
+  const task = registerBackgroundTask({
+    surface: 'tool',
+    operation: 'run',
+    resultType: 'tool_task_result',
+    context: { notifyFn: () => Promise.reject(new Error('boom')), callerSessionId: 'sess_reconcile' },
+  });
+  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
+  await tick();
+  await tick();
+  const before = getBackgroundTask(task.taskId);
+  assert.equal(before.notifiedWithBody, false, 'body un-marked after the failed async notify');
+
+  // A later reconcile on the (already-terminal) task must retry the delivery
+  // rather than returning early. With a working fallback now in place it lands.
+  const enqueued = [];
+  setBackgroundTaskEnqueueFallback((sessionId, text) => { enqueued.push({ sessionId, text }); return 1; });
+  reconcileBackgroundTask(task.taskId, { status: 'completed', terminalReason: 'reconciled' });
+  await tick();
+  await tick();
+  const after = getBackgroundTask(task.taskId);
+  assert.equal(enqueued.length, 1, 'reconcile re-fired the completion once on the terminal task');
+  assert.equal(after.notifiedWithBody, true, 'reconcile retry marks the body delivered');
+});
+
+test.after(() => { setBackgroundTaskEnqueueFallback(null); });

package/scripts/forwarder-rebind-tail-test.mjs

@@ -0,0 +1,67 @@
+// Regression: on channel connect/change/rebind, OutputForwarder.setContext must
+// NOT pull the read cursor back to a prior/unrelated transcript's tail. Only a
+// genuinely-unsynced tail of the SAME transcript (crash recovery) is recovered;
+// a fresh binding to a DIFFERENT transcript stays at EOF so only outputs created
+// after the new binding are forwarded (never the old tail).
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { OutputForwarder } from '../src/runtime/channels/lib/output-forwarder.mjs';
+
+function jsonl(...entries) {
+  return entries.map((e) => JSON.stringify(e)).join('\n') + '\n';
+}
+
+const USER = { type: 'user', message: { content: [{ type: 'text', text: 'hi' }] } };
+const ASSISTANT = { type: 'assistant', message: { content: [{ type: 'text', text: 'old reply tail' }] } };
+
+function makeForwarder(persisted) {
+  // statusState stub: setContext only reads via this.statusState.read().
+  return new OutputForwarder(() => {}, { read: () => persisted });
+}
+
+test('rebind to a DIFFERENT transcript never recovers the old tail (cursor stays at EOF)', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'fwd-rebind-'));
+  try {
+    const bound = join(dir, 'new-session.jsonl');
+    const prior = join(dir, 'prior-session.jsonl');
+    writeFileSync(bound, jsonl(USER, ASSISTANT));
+    const size = statSync(bound).size;
+    // Persisted status points at a DIFFERENT (prior) transcript, no send evidence.
+    const fwd = makeForwarder({
+      transcriptPath: prior,
+      lastFileSize: 0,
+      sentCount: 0,
+      lastSentTime: 0,
+      lastSentHash: '',
+    });
+    fwd.setContext('chan-1', bound, { catchUpFromPersisted: true, recoverUnsyncedTail: true });
+    assert.equal(fwd.lastFileSize, size, 'cursor must be at EOF — old tail of a fresh binding is not forwarded');
+    assert.equal(fwd.readFileSize, size);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SAME-transcript unsynced tail (no send evidence) is still recovered', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'fwd-same-'));
+  try {
+    const bound = join(dir, 'session.jsonl');
+    writeFileSync(bound, jsonl(USER, ASSISTANT));
+    const size = statSync(bound).size;
+    // Persisted status is the SAME transcript, fully synced size, no send evidence.
+    const fwd = makeForwarder({
+      transcriptPath: bound,
+      lastFileSize: size,
+      sentCount: 0,
+      lastSentTime: 0,
+      lastSentHash: '',
+    });
+    fwd.setContext('chan-1', bound, { catchUpFromPersisted: true, recoverUnsyncedTail: true });
+    assert.ok(fwd.lastFileSize < size, 'same-session unsynced tail must be recovered (cursor before EOF)');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/scripts/live-worker-smoke.mjs

@@ -37,7 +37,7 @@ async function main() {
   const workflowRules = readFileSync('src/workflows/default/WORKFLOW.md', 'utf8');
   assert(/Use `agent` for scoped implementation/i.test(leadToolRules), 'lead rules must direct scoped work to agents');
   assert(/PARALLEL across independent scopes/i.test(workflowRules), 'workflow rules must keep independent work parallel');
-  assert(/always start background tasks/i.test(AGENT_TOOL.description || '') && /distinct tags/i.test(AGENT_TOOL.description || '') && /completion notification/i.test(AGENT_TOOL.description || ''), 'agent tool description must expose async parallel tags');
+  assert(/always start background tasks/i.test(AGENT_TOOL.description || '') && /distinct tags?/i.test(AGENT_TOOL.description || '') && /completion notification/i.test(AGENT_TOOL.description || ''), 'agent tool description must expose async parallel tags');
 
   mkdirSync(dataDir, { recursive: true });
   await initProviders({ 'openai-oauth': { enabled: true } });

package/scripts/pending-completion-drop-test.mjs

@@ -1,7 +1,9 @@
-// Proves deferred agent/tool *completion* notifications are DROPPED on drain
-// (never replayed out-of-order on a later session resume) while genuine
-// user/steering messages in the same queue survive with order preserved.
-// Owner decision: out-of-order replay is worse than loss.
+// Deferred agent/tool *completion* notifications must:
+//   - SURVIVE a LIVE drain (they are the intended model-visible payload, e.g.
+//     the idle-resume kick delivering an async task body this process), and
+//   - be DROPPED on a RESUME drain (only the persisted copy remains after a
+//     restart, where replaying it would inject the body out-of-order).
+// Genuine user/steering messages survive with order preserved in both paths.
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
@@ -18,47 +20,64 @@ const {
   drainPendingMessages,
   COMPLETION_NOTIFICATION_KIND,
   markCompletionEntry,
+  _dropPendingMessageState,
 } = await import('../src/runtime/agent/orchestrator/session/manager/pending-messages.mjs');
 
-function completionEntry(text) {
-  return { content: text, text, notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: Date.now() };
-}
+test('live drain delivers the completion notification and keeps user order', () => {
+  const sid = 'sess_live_1';
+  enqueuePendingMessage(sid, 'user first');
+  enqueuePendingMessage(sid, markCompletionEntry('Async agent task xyz finished.\n\nResult:\n> done'));
+  enqueuePendingMessage(sid, 'user second');
+
+  // In-memory queue is populated (live, same process) → completion survives.
+  const drained = drainPendingMessages(sid).map((m) => (typeof m === 'string' ? m : m.text));
+  assert.ok(drained.includes('user first') && drained.includes('user second'), 'user messages kept');
+  assert.ok(drained.some((t) => /finished/.test(t)), 'live completion delivered, not dropped');
+  assert.ok(drained.indexOf('user first') < drained.indexOf('user second'), 'user order preserved');
+});
+
+test('live drain preserves interleaved [user, completion, user] order', () => {
+  // Buffered-persist copies of the live sends carry the same user texts but the
+  // completion is filtered out of the persisted path. The in-memory queue is
+  // authoritative, so the completion must stay BETWEEN the users and never be
+  // flattened to the tail as [user, user, completion].
+  const sid = 'sess_live_order';
+  enqueuePendingMessage(sid, 'user first');
+  enqueuePendingMessage(sid, markCompletionEntry('Async agent task zzz finished.\n\nResult:\n> done'));
+  enqueuePendingMessage(sid, 'user second');
+
+  const drained = drainPendingMessages(sid).map((m) => (typeof m === 'string' ? m : m.text));
+  const first = drained.indexOf('user first');
+  const second = drained.indexOf('user second');
+  const completion = drained.findIndex((t) => /finished/.test(t));
+  assert.ok(completion !== -1, 'completion present in live drain');
+  assert.ok(first < completion && completion < second, 'completion stays between the two users');
+});
 
-test('drain drops completion notifications, keeps user messages in order', async () => {
-  const sid = 'sess_drop_test_1';
+test('resume drain drops the completion notification, keeps user messages in order', async () => {
+  const sid = 'sess_resume_1';
   enqueuePendingMessage(sid, 'user first');
-  enqueuePendingMessage(sid, completionEntry('Async agent task xyz finished.\n\nResult:\n> done'));
+  enqueuePendingMessage(sid, markCompletionEntry('Async agent task xyz finished.\n\nResult:\n> done'));
   enqueuePendingMessage(sid, 'user second');
 
-  // Let the buffered persist flush to disk so we also verify the on-disk marker
-  // (the shape a later resume would drain).
+  // Flush the buffered persist to disk, then drop the in-memory queue → mimic a
+  // restart where only the persisted copy survives (the resume path).
   await new Promise((r) => setImmediate(r));
   await new Promise((r) => setTimeout(r, 30));
   const store = JSON.parse(readFileSync(join(dataDir, 'session-pending-messages.json'), 'utf8'));
   const persistedQueue = store.sessions[sid] || [];
   const marked = persistedQueue.filter((e) => e && typeof e === 'object' && e.notificationKind === COMPLETION_NOTIFICATION_KIND);
   assert.equal(marked.length, 1, 'completion notification persisted as a marked object');
-  assert.ok(persistedQueue.includes('user first') && persistedQueue.includes('user second'), 'user messages persisted as plain strings');
+  _dropPendingMessageState(sid, { clearPersisted: false });
 
   const drained = drainPendingMessages(sid).map((m) => (typeof m === 'string' ? m : m.text));
-  assert.deepEqual(drained, ['user first', 'user second'], 'completion dropped; user messages kept in order');
-  assert.ok(!drained.some((t) => /finished/.test(t)), 'no completion prose replayed');
+  assert.deepEqual(drained, ['user first', 'user second'], 'completion dropped on resume; user order kept');
+  assert.ok(!drained.some((t) => /finished/.test(t)), 'no completion prose replayed on resume');
 
-  // A second drain (post-resume) yields nothing — the completion was discarded,
-  // not deferred.
+  // A second drain yields nothing — the completion was discarded, not deferred.
   assert.deepEqual(drainPendingMessages(sid), []);
 });
 
 test.after(() => {
   try { rmSync(dataDir, { recursive: true, force: true }); } catch { /* ignore */ }
 });
-
-// Proves the shared tagger (used by notify.mjs, tool-exec.mjs, runtime-core.mjs)
-// yields entries drain drops, while a real user message survives in order.
-test('markCompletionEntry path is dropped on drain; user message survives', () => {
-  const sid = 'sess_drop_test_2';
-  enqueuePendingMessage(sid, 'real user question');
-  enqueuePendingMessage(sid, markCompletionEntry('Async agent task abc finished.\n\nResult:\n> ok'));
-  const drained = drainPendingMessages(sid).map((m) => (typeof m === 'string' ? m : m.text));
-  assert.deepEqual(drained, ['real user question']);
-});

package/scripts/provider-toolcall-test.mjs

@@ -332,6 +332,7 @@ test('gemini cache usage: official cached token fields are subsets of prompt tok
     assert.equal(sdkAlias.inputTokens, 1200);
     assert.equal(sdkAlias.reportedCachedTokens, 500);
     assert.equal(sdkAlias.cachedTokens, 500);
+    assert.notEqual(sdkAlias.inputTokens, 0, 'snake_case SDK aliases must remain visible to provider return usage');
 });
 
 test('gemini cache usage: clamps over-reported cache and falls back only for attached cachedContent', () => {

package/scripts/recall-bench-cases.json

@@ -1,5 +1,6 @@
 [
   { "id": "browse-last", "label": "query-less recent browse (period=last)", "args": { "period": "last", "limit": 10 }, "expect": "browse" },
+  { "id": "last-query-topic", "label": "topic inside recent sessions (period=last + query)", "args": { "query": "last", "period": "last", "limit": 5 }, "expect": { "kind": "results", "topNContains": ["last"], "topN": 10, "recencyOrdered": true } },
   { "id": "period-24h", "label": "period window 24h", "args": { "period": "24h", "limit": 10 }, "expect": "browse" },
   { "id": "period-7d", "label": "period window 7d", "args": { "period": "7d", "limit": 10 }, "expect": "browse" },
   { "id": "scope-all", "label": "all-scope query", "args": { "query": "recall", "projectScope": "all", "limit": 10 }, "expect": "results" },

package/scripts/session-bench.mjs

@@ -831,6 +831,39 @@ function buildToolDiagnostics(rows, failureRows = []) {
   }
   identicalCallRepeats.sort((a, b) => b.count - a.count);
 
+  const editFragmentation = [];
+  for (const [sid, srows] of groupBy(tools.filter((r) => sessionId(r)), sessionId).entries()) {
+    const patches = srows
+      .filter((r) => String(field(r, 'tool_name') || '') === 'apply_patch')
+      .sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
+    if (patches.length < 2) continue;
+    const byIter = countBy(patches, (r) => num(r, 'iteration'));
+    const multiPatchTurns = byIter.filter(([, c]) => c > 1).length;
+    let crossTurnPatch = 0;
+    for (let i = 1; i < patches.length; i++) {
+      const earlier = patches[i - 1];
+      const later = patches[i];
+      const ei = num(earlier, 'iteration');
+      const li = num(later, 'iteration');
+      if (ei == null || li == null || ei === li) continue;
+      const dt = Number(later.ts || 0) - Number(earlier.ts || 0);
+      if (li === ei + 1 || dt < 60_000) crossTurnPatch++;
+    }
+    const fragScore = multiPatchTurns + crossTurnPatch;
+    if (fragScore < 2) continue;
+    editFragmentation.push({
+      session_id: sid,
+      agent: field(patches[0], 'agent'),
+      patch_calls: patches.length,
+      multi_patch_turns: multiPatchTurns,
+      cross_turn_patch: crossTurnPatch,
+      frag_score: fragScore,
+      start_it: num(patches[0], 'iteration'),
+      end_it: num(patches[patches.length - 1], 'iteration'),
+    });
+  }
+  editFragmentation.sort((a, b) => b.frag_score - a.frag_score);
+
   return {
     total_tool_calls: tools.length,
     total_tool_ms: sum(tools.map((r) => num(r, 'tool_ms'))),
@@ -850,6 +883,7 @@ function buildToolDiagnostics(rows, failureRows = []) {
     sequential_tool_clusters: sequentialToolClusters,
     readonly_stalls: readonlyStalls.slice(0, 20),
     identical_call_repeats: identicalCallRepeats.slice(0, 20),
+    edit_fragmentation: editFragmentation.slice(0, 20),
   };
 }
 
@@ -1246,6 +1280,10 @@ function buildIssues(routeGroups, cache, tools) {
     const toolSummary = c.tools.map((x) => `${x.tool}×${x.count}`).join(', ');
     issues.push({ severity: 'low', type: 'tool_churn_cluster', message: `sequential single-tool cluster x${c.count} over ${fmtMs(c.span_ms)}: ${toolSummary}` });
   }
+  for (const e of (tools.edit_fragmentation || []).slice(0, 5)) {
+    if (e.frag_score < 2) continue;
+    issues.push({ severity: 'low', type: 'edit_fragmentation', message: `edit fragmentation x${e.frag_score} (multi-patch turns ${e.multi_patch_turns}, cross-turn ${e.cross_turn_patch}): ${e.agent || '-'}`, session_id: e.session_id });
+  }
   const rank = { high: 0, medium: 1, low: 2 };
   return issues.sort((a, b) => (rank[a.severity] ?? 9) - (rank[b.severity] ?? 9));
 }
@@ -1629,6 +1667,12 @@ function renderText(report) {
         if (c.examples?.length) lines.push(`  e.g. ${c.examples.join(' | ')}`);
       }
     }
+    if (report.tools.edit_fragmentation?.length) {
+      lines.push('edit fragmentation:');
+      for (const e of report.tools.edit_fragmentation.slice(0, 8)) {
+        lines.push(`- ${e.agent || '-'} it=${e.start_it}→${e.end_it} score=${e.frag_score} multi=${e.multi_patch_turns} cross=${e.cross_turn_patch}`);
+      }
+    }
     lines.push(`missed parallelism heuristic: ${report.tools.missed_parallelism_heuristic.consecutive_single_tool_batches} close single-tool batches`);
     lines.push('');
   }