mixdog 0.9.15 → 0.9.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.15",
+  "version": "0.9.17",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -46,6 +46,7 @@
     "smoke:freevars": "node scripts/freevar-smoke.mjs",
     "test:toolcall": "node --test scripts/toolcall-args-test.mjs",
     "test:providers": "node --test scripts/provider-toolcall-test.mjs",
+    "test:atomiclock": "node --test scripts/atomic-lock-tryonce-test.mjs",
     "failures": "node scripts/tool-failures.mjs",
     "trace:llm": "node scripts/llm-trace-summary.mjs",
     "diag:sessions": "node scripts/session-diag.mjs",

package/scripts/atomic-lock-tryonce-test.mjs

@@ -0,0 +1,66 @@
+// Proves try-once (timeoutMs:0) lock behavior: when the lock is already held,
+// withFileLockSync/withFileLock return IMMEDIATELY with ELOCKCONTENDED and
+// never sleep (no Atomics.wait / setTimeout backoff). Also asserts sync+async
+// lock interop: neither can enter the critical section while the other holds.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  withFileLockSync,
+  withFileLock,
+} from '../src/runtime/shared/atomic-file.mjs';
+
+function tmpLock() {
+  const dir = mkdtempSync(join(tmpdir(), 'mixlock-'));
+  return { dir, lockPath: join(dir, 't.lock') };
+}
+
+test('try-once sync throws ELOCKCONTENDED without sleeping when held', () => {
+  const { dir, lockPath } = tmpLock();
+  try {
+    withFileLockSync(lockPath, () => {
+      const started = Date.now();
+      assert.throws(
+        () => withFileLockSync(lockPath, () => 'unreachable', { timeoutMs: 0 }),
+        (e) => e?.code === 'ELOCKCONTENDED',
+      );
+      assert.ok(Date.now() - started < 20, `try-once slept ${Date.now() - started}ms`);
+    });
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('try-once async rejects ELOCKCONTENDED without sleeping when held', async () => {
+  const { dir, lockPath } = tmpLock();
+  try {
+    await withFileLockSync(lockPath, async () => {
+      const started = Date.now();
+      await assert.rejects(
+        withFileLock(lockPath, () => 'unreachable', { timeoutMs: 0 }),
+        (e) => e?.code === 'ELOCKCONTENDED',
+      );
+      assert.ok(Date.now() - started < 20, `try-once slept ${Date.now() - started}ms`);
+    });
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('async holder blocks sync try-once, then sync acquires after release', async () => {
+  const { dir, lockPath } = tmpLock();
+  try {
+    await withFileLock(lockPath, () => {
+      assert.throws(
+        () => withFileLockSync(lockPath, () => 'unreachable', { timeoutMs: 0 }),
+        (e) => e?.code === 'ELOCKCONTENDED',
+      );
+    });
+    const val = withFileLockSync(lockPath, () => 7, { timeoutMs: 0 });
+    assert.equal(val, 7);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/scripts/explore-bench.mjs

@@ -88,8 +88,9 @@ function readTraceSince(ts) {
 }
 
 const t0 = Date.now();
-const results = [];
-for (const { q, expect, expectFail } of QUERIES) {
+// Parallel round: all queries fire at once. Per-session trace attribution is
+// by session_id so counts stay correct; per-query ms includes queueing.
+const results = await Promise.all(QUERIES.map(async ({ q, expect, expectFail }) => {
   const qt0 = Date.now();
   const res = await runExplore({ query: q, cwd: CWD }, { callerCwd: CWD });
   const text = res?.content?.[0]?.text || '';
@@ -99,8 +100,8 @@ for (const { q, expect, expectFail } of QUERIES) {
   const hit = expectFail
     ? (failed && anchors === 0)
     : (!failed && (expect || []).some((e) => lower.includes(e.toLowerCase())));
-  results.push({ q: q.slice(0, 48), ms: Date.now() - qt0, anchors, failed, hit, bytes: text.length });
-}
+  return { q: q.slice(0, 48), ms: Date.now() - qt0, anchors, failed, hit, bytes: text.length };
+}));
 
 // Attribute tool calls per explorer session spawned during this run.
 const rows = readTraceSince(t0);

package/scripts/ingest-pure-conversation-smoke.mjs

@@ -56,6 +56,25 @@ const summaryRow = { role: 'user', content: `${SUMMARY_PREFIX}\nmessages=10 sha2
 const ackRow = { role: 'assistant', content: '.' }
 // (vi) internal runtime nudge user row.
 const nudgeRow = { role: 'user', content: '[mixdog-runtime] Your previous response was empty. Continue.' }
+// (vi-b) model-visible tool-completion wrapper row (mgr.enqueuePendingMessage
+// mirror of modelVisibleToolCompletionMessage — the transcript-watcher bug
+// this change fixes: these were previously persisted verbatim).
+const completionWrapperRow = {
+  role: 'user',
+  content:
+    'The async shell task task_123 has finished (completed) - review this result in your next step.\n\n' +
+    'Result:\n> background task\n> task_id: task_123\n> status: completed',
+}
+// (vi-c) UNQUOTED persisted form — taken from a real DB row. No `> ` prefix
+// on the Result body; isModelVisibleToolCompletionWrapper alone misses this
+// shape, so shouldExcludeIngestMessage falls back to the instruction-head
+// regex (isUnquotedToolCompletionHead).
+const unquotedCompletionRow = {
+  role: 'user',
+  content:
+    'The async shell task task_456 has finished (completed, exit 0) - review this result in your next step.\n' +
+    'Result:\nbackground task\ntask_id: task_456\nstatus: completed',
+}
 // (vii) normal human + normal assistant.
 const normalUser = { role: 'user', content: '안녕' }
 const normalAsst = { role: 'assistant', content: '네 안녕하세요' }
@@ -67,6 +86,8 @@ const before = {
   summaryRow: summaryRow.content,
   ackRow: ackRow.content,
   nudgeRow: nudgeRow.content,
+  completionWrapperRow: completionWrapperRow.content,
+  unquotedCompletionRow: unquotedCompletionRow.content,
   normalUser: normalUser.content,
   normalAsst: normalAsst.content,
 }
@@ -78,6 +99,8 @@ const after = {
   summaryRow: ingestRow(summaryRow),
   ackRow: ingestRow(ackRow),
   nudgeRow: ingestRow(nudgeRow),
+  completionWrapperRow: ingestRow(completionWrapperRow),
+  unquotedCompletionRow: ingestRow(unquotedCompletionRow),
   normalUser: ingestRow(normalUser),
   normalAsst: ingestRow(normalAsst),
 }
@@ -96,6 +119,8 @@ assert(after.referenceRow === null, 'Reference files row must be excluded')
 assert(after.summaryRow === null, 'SUMMARY_PREFIX row must be excluded')
 assert(after.ackRow === null, '`.` ack row must be excluded')
 assert(after.nudgeRow === null, '[mixdog-runtime] nudge row must be excluded')
+assert(after.completionWrapperRow === null, 'model-visible tool-completion wrapper row must be excluded')
+assert(after.unquotedCompletionRow === null, 'unquoted tool-completion wrapper row (real DB shape) must be excluded')
 
 // (vii) normal conversation survives intact.
 assert(after.normalUser === '안녕', 'normal human text must survive intact')
@@ -136,6 +161,8 @@ const rows = [
   ['(iv) SUMMARY_PREFIX', before.summaryRow, after.summaryRow],
   ['(v) `.` ack', before.ackRow, after.ackRow],
   ['(vi) [mixdog-runtime] nudge', before.nudgeRow, after.nudgeRow],
+  ['(vi-b) tool-completion wrapper', before.completionWrapperRow, after.completionWrapperRow],
+  ['(vi-c) unquoted tool-completion (real DB shape)', before.unquotedCompletionRow, after.unquotedCompletionRow],
   ['(vii) normal human', before.normalUser, after.normalUser],
   ['(vii) normal assistant', before.normalAsst, after.normalAsst],
 ]

package/scripts/output-style-smoke.mjs

@@ -69,7 +69,7 @@ for (const required of [
   'Outcome-first concise handoffs for coding work',
   'Practical concise — outcome-first handoffs',
   'file_path:line_number',
-  'controlled detail',
+  'Controlled detail',
   'Synthesize agent or retrieval results',
   'Do not hide blockers',
   'verification was not run, say so once',
@@ -106,9 +106,9 @@ try {
   assert(!customRules.includes('Mixdog default — the most detailed of the three styles'), 'custom outputStyle should not append default style');
   const profileMeta = rulesBuilder.buildLeadMetaContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
   assert(profileMeta.includes('Use "재영님" when directly addressing the user'), 'profile title must inject into Lead BP3 meta');
-  assert(profileMeta.includes('Do not repeat it in routine progress updates or pre-tool preambles'), 'profile title must not encourage title in preambles');
+  assert(profileMeta.includes('do not repeat it in routine progress updates or pre-tool preambles'), 'profile title must not encourage title in preambles');
   assert(/Default user-facing response language from system locale/.test(profileMeta), 'system profile language must resolve from system locale');
-  assert(profileMeta.includes('including pre-tool preambles'), 'profile language must cover pre-tool preambles');
+  assert(profileMeta.includes('pre-tool preambles (even single-line)'), 'profile language must cover pre-tool preambles');
 } finally {
   rmSync(dataDir, { recursive: true, force: true });
 }

package/scripts/provider-toolcall-test.mjs

@@ -366,6 +366,81 @@ test('anthropic(-oauth): text-only stream → no toolCalls', async () => {
     assert.equal(result.content, 'hello');
 });
 
+test('anthropic(-oauth): thinking + signature deltas → ordered thinkingBlocks before tool_use', async () => {
+    const events = [
+        { type: 'message_start', message: { model: 'claude', usage: { input_tokens: 1 } } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'thinking', thinking: '' } },
+        { type: 'content_block_delta', index: 0, delta: { type: 'thinking_delta', thinking: 'step ' } },
+        { type: 'content_block_delta', index: 0, delta: { type: 'thinking_delta', thinking: 'one' } },
+        { type: 'content_block_delta', index: 0, delta: { type: 'signature_delta', signature: 'sig123' } },
+        { type: 'content_block_stop', index: 0 },
+        { type: 'content_block_start', index: 1, content_block: { type: 'tool_use', id: 'toolu_9', name: 'shell' } },
+        { type: 'content_block_delta', index: 1, delta: { type: 'input_json_delta', partial_json: '{"command":"ls"}' } },
+        { type: 'content_block_stop', index: 1 },
+        { type: 'message_delta', delta: { stop_reason: 'tool_use' }, usage: { output_tokens: 1 } },
+        { type: 'message_stop' },
+    ];
+    const result = await anthropicParseSSEStream(
+        anthropicSseResponse(events),
+        null, () => {}, () => {}, () => {}, {}, null,
+    );
+    assert.equal(result.hasThinkingContent, true);
+    assert.deepEqual(result.thinkingBlocks, [
+        { type: 'thinking', thinking: 'step one', signature: 'sig123' },
+    ]);
+    assert.deepEqual(result.toolCalls, [{ id: 'toolu_9', name: 'shell', arguments: { command: 'ls' } }]);
+});
+
+test('anthropic(-oauth): signature-only block (display omitted) → empty thinking kept with signature', async () => {
+    const events = [
+        { type: 'message_start', message: { model: 'claude', usage: { input_tokens: 1 } } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'thinking' } },
+        { type: 'content_block_delta', index: 0, delta: { type: 'signature_delta', signature: 'sigABC' } },
+        { type: 'content_block_stop', index: 0 },
+        { type: 'message_delta', delta: { stop_reason: 'end_turn' }, usage: { output_tokens: 1 } },
+        { type: 'message_stop' },
+    ];
+    const result = await anthropicParseSSEStream(
+        anthropicSseResponse(events),
+        null, () => {}, () => {}, () => {}, {}, null,
+    );
+    assert.deepEqual(result.thinkingBlocks, [
+        { type: 'thinking', thinking: '', signature: 'sigABC' },
+    ]);
+});
+
+test('anthropic(-oauth): redacted_thinking round-trips exactly as {type,data} (no extra fields)', async () => {
+    const events = [
+        { type: 'message_start', message: { model: 'claude', usage: { input_tokens: 1 } } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'redacted_thinking', data: 'ENCRYPTED_PAYLOAD' } },
+        { type: 'content_block_stop', index: 0 },
+        { type: 'message_delta', delta: { stop_reason: 'end_turn' }, usage: { output_tokens: 1 } },
+        { type: 'message_stop' },
+    ];
+    const result = await anthropicParseSSEStream(
+        anthropicSseResponse(events),
+        null, () => {}, () => {}, () => {}, {}, null,
+    );
+    assert.deepEqual(result.thinkingBlocks, [
+        { type: 'redacted_thinking', data: 'ENCRYPTED_PAYLOAD' },
+    ]);
+});
+
+test('anthropic effort: legacy claude-3-7-sonnet gets NO adaptive thinking / effort beta', () => {
+    const model = 'claude-3-7-sonnet-20250219';
+    assert.equal(modelSupportsEffort(model), false);
+    const body = _buildRequestBodyForCacheSmoke(
+        [{ role: 'user', content: 'hi' }],
+        model,
+        [],
+        { effort: 'high' },
+    );
+    assert.equal(body.output_config, undefined);
+    // Legacy path uses the budget_tokens shape, never thinking:adaptive.
+    assert.notEqual(body.thinking?.type, 'adaptive');
+    assert.equal(shouldIncludeEffortBeta(model, { effort: 'high' }), false);
+});
+
 // --- Leaked tool-call recovery (shared parseSSEStream guard) ----------------
 // The model sometimes emits a tool call as plain text tags inside text_delta
 // instead of a native tool_use block. The guard (8th arg = known tool names)
@@ -933,7 +1008,9 @@ test('anthropic effort: sonnet-4-6 uses output_config + effort beta, not thinkin
         { effort: 'high' },
     );
     assert.deepEqual(body.output_config, { effort: 'high' });
-    assert.equal(body.thinking, undefined);
+    // Adaptive-thinking models also carry thinking:{type:'adaptive'} — the
+    // legacy budget_tokens shape 400s on these models.
+    assert.deepEqual(body.thinking, { type: 'adaptive', display: 'summarized' });
     assert.equal(shouldIncludeEffortBeta(model, { effort: 'high' }), true);
     const beta = buildAnthropicBetaHeaders({ effort: true });
     assert.ok(beta.includes(EFFORT_BETA_HEADER));
@@ -967,7 +1044,7 @@ test('anthropic effort: xhigh on opus-4-8 is a first-class level (not downgraded
         { effort: 'xhigh' },
     );
     assert.deepEqual(body.output_config, { effort: 'xhigh' });
-    assert.equal(body.thinking, undefined);
+    assert.deepEqual(body.thinking, { type: 'adaptive', display: 'summarized' });
 });
 
 test('anthropic effort: explicit thinkingBudgetTokens wins over effort', () => {

package/scripts/termio-input-smoke.mjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/**
+ * termio-input-smoke.mjs — throwaway smoke for the vendored termio input
+ * pipeline. Feeds synthetic chunk sequences through createInputParser() and
+ * asserts the typed event kinds / channel routing decisions.
+ *
+ * Run: node scripts/termio-input-smoke.mjs
+ */
+import { createInputParser } from '../vendor/ink/build/input-parser.js';
+
+let failures = 0;
+function check(name, cond, detail) {
+  if (cond) {
+    console.log(`ok   - ${name}`);
+  } else {
+    failures++;
+    console.log(`FAIL - ${name}${detail ? ' :: ' + detail : ''}`);
+  }
+}
+
+// Helper: push a list of chunks, collect all emitted events.
+function run(chunks) {
+  const p = createInputParser();
+  const events = [];
+  for (const c of chunks) events.push(...p.push(c));
+  return { p, events };
+}
+
+// 1. ESC split across two chunks -> single arrow-up key, no lone escape.
+{
+  const { events } = run(['\x1b', '[A']);
+  check('split ESC -> one up key',
+    events.length === 1 && events[0].kind === 'key' && events[0].name === 'up',
+    JSON.stringify(events));
+}
+
+// 2. SGR mouse click (button 0 press) -> ParsedMouse.
+{
+  const { events } = run(['\x1b[<0;12;34M']);
+  const m = events[0];
+  check('SGR click -> mouse press',
+    events.length === 1 && m.kind === 'mouse' && m.action === 'press' &&
+      m.col === 12 && m.row === 34 && m.button === 0,
+    JSON.stringify(events));
+}
+
+// 3. SGR wheel-up (button 64) -> key wheelup (stays a key, routes to mouse chan).
+{
+  const { events } = run(['\x1b[<64;5;5M']);
+  const k = events[0];
+  check('SGR wheel -> wheelup key',
+    events.length === 1 && k.kind === 'key' && k.name === 'wheelup',
+    JSON.stringify(events));
+}
+
+// 4. X10 mouse: CSI M + 3 payload bytes (wheel-up: Cb = 0x40+32 = 96 = '`').
+{
+  const { events } = run(['\x1b[M\x60\x30\x30']);
+  const k = events[0];
+  check('X10 wheel -> wheelup key',
+    events.length === 1 && k.kind === 'key' && k.name === 'wheelup',
+    JSON.stringify(events));
+}
+
+// 5. Bracketed paste split across 3 chunks -> one pasted key with full body.
+{
+  const { events } = run(['\x1b[200~hel', 'lo wor', 'ld\x1b[201~']);
+  const paste = events.find((e) => e.isPasted);
+  check('split paste -> one pasted key "hello world"',
+    events.length === 1 && paste && paste.sequence === 'hello world',
+    JSON.stringify(events));
+}
+
+// 6. Paste whose body ends with an X10 mouse tail `\x1b[M` — the ESC in the
+//    payload slot must NOT be consumed as X10 mouse; it stays paste content and
+//    PASTE_END still terminates the paste.
+{
+  const { events } = run(['\x1b[200~abc\x1b[M12\x1b[201~']);
+  const paste = events.find((e) => e.isPasted);
+  check('paste with \\x1b[M tail stays paste',
+    events.length === 1 && paste && paste.sequence === 'abc\x1b[M12',
+    JSON.stringify(events));
+}
+
+// 7. Terminal response (DA1) -> ParsedResponse.
+{
+  const { events } = run(['\x1b[?62;1c']);
+  const r = events[0];
+  check('DA1 -> response',
+    events.length === 1 && r.kind === 'response' && r.response.type === 'da1',
+    JSON.stringify(events));
+}
+
+// 8. Lone ESC buffered -> hasPendingEscape true; flushPendingEscape -> escape key.
+{
+  const p = createInputParser();
+  const first = p.push('\x1b');
+  check('lone ESC buffers (no immediate events)', first.length === 0, JSON.stringify(first));
+  check('hasPendingEscape true for lone ESC', p.hasPendingEscape() === true);
+  const flushed = p.flushPendingEscape();
+  check('flushPendingEscape -> escape key',
+    Array.isArray(flushed) && flushed.length === 1 && flushed[0].name === 'escape',
+    JSON.stringify(flushed));
+}
+
+// 9. Incomplete paste-start marker must NOT arm the escape flush timer.
+{
+  const p = createInputParser();
+  p.push('\x1b[200');
+  check('partial paste-start does not arm flush', p.hasPendingEscape() === false);
+}
+
+// 9b. Generic partial CSI (`\x1b[`, `\x1b[2`, `\x1b[20`) — none of these are
+//     paste-start prefixes/penultimate, so hasPendingEscape MUST arm to avoid
+//     buffering indefinitely.
+{
+  for (const partial of ['\x1b[', '\x1b[2', '\x1b[20']) {
+    const p = createInputParser();
+    p.push(partial);
+    check(`generic partial CSI ${JSON.stringify(partial)} arms flush`,
+      p.hasPendingEscape() === true);
+  }
+}
+
+// 9c. `\x1b[200` and `\x1b[200~`-prefixed pending must NOT arm the flush
+//     (paste-start marker / its penultimate prefix complete on their own).
+{
+  const p1 = createInputParser();
+  p1.push('\x1b[200');
+  check('"\\x1b[200" does not arm flush', p1.hasPendingEscape() === false);
+
+  const p2 = createInputParser();
+  p2.push('\x1b[200~hel'); // still inside paste body once PASTE_START token completes
+  check('paste-start-prefixed pending does not arm flush', p2.hasPendingEscape() === false);
+}
+
+// 9d. Held-backspace chunk splits into individual key events; `\r`/`\t` in
+//     text are NOT split.
+{
+  const { events } = run(['abc\x7f\x7f\x7f']);
+  const names = events.map((e) => e.name || e.sequence);
+  check('abc + 3x backspace -> text key(s) + 3 separate backspace keys',
+    events.length === 4 &&
+      events[0].sequence === 'abc' &&
+      events.slice(1).every((e) => e.name === 'backspace' || e.sequence === '\x7f'),
+    JSON.stringify(names));
+}
+{
+  const { events } = run(['a\rb\tc']);
+  check('\\r and \\t inside text are not split (single key for whole run)',
+    events.length === 1 && events[0].sequence === 'a\rb\tc',
+    JSON.stringify(events));
+}
+
+// 10. Plain text -> key events, sequence carries the character.
+{
+  const { events } = run(['a']);
+  check('plain char -> key "a"',
+    events.length === 1 && events[0].kind === 'key' && events[0].sequence === 'a',
+    JSON.stringify(events));
+}
+
+// 11. Consumer-level routing: synthetic 'mouse' channel events reach the
+//     use-mouse-input dispatch decisions exactly once each. We replicate the
+//     hook's branch keys (kind:'key' wheel with ctrl-mask from sequence vs.
+//     kind:'mouse' press) to guard against double-handling / mis-routing.
+//     MOUSE_CTRL_MASK = 16; wheel ctrl bit is read from the SGR button in
+//     the ParsedKey.sequence via /\x1b\[<(\d+);/ (no button field on wheel).
+{
+  const MOUSE_CTRL_MASK = 16;
+  const WHEEL_SGR = /\x1b\[<(\d+);/;
+  // Feed real parser output so field shapes match production.
+  const wheelPlain = run(['\x1b[<64;5;5M']).events[0];      // wheelup, no ctrl
+  const wheelCtrl = run(['\x1b[<80;5;5M']).events[0];        // 64|16 -> ctrl wheelup
+  const click = run(['\x1b[<0;12;34M']).events[0];           // left press
+
+  const routes = { zoom: 0, scroll: 0, press: 0, ignored: 0 };
+  function route(event) {
+    if (!event || typeof event !== 'object') return;
+    if (event.kind === 'key') {
+      if (event.name !== 'wheelup' && event.name !== 'wheeldown') { routes.ignored++; return; }
+      const wm = WHEEL_SGR.exec(typeof event.sequence === 'string' ? event.sequence : '');
+      const ctrl = wm ? ((Number(wm[1]) & MOUSE_CTRL_MASK) !== 0) : false;
+      if (ctrl) routes.zoom++; else routes.scroll++;
+      return;
+    }
+    if (event.kind !== 'mouse') { routes.ignored++; return; }
+    const button = Number(event.button);
+    if ((button & 3) === 0 && event.action === 'press' && (button & 32) === 0) routes.press++;
+  }
+  for (const e of [wheelPlain, wheelCtrl, click]) route(e);
+  check('mouse routing: plain wheel -> scroll x1', routes.scroll === 1, JSON.stringify(routes));
+  check('mouse routing: ctrl wheel -> zoom x1', routes.zoom === 1, JSON.stringify(routes));
+  check('mouse routing: left press -> press x1 (no double)', routes.press === 1, JSON.stringify(routes));
+  check('mouse routing: nothing mis-routed', routes.ignored === 0, JSON.stringify(routes));
+}
+
+console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILURE(S)`);
+process.exit(failures === 0 ? 0 : 1);

package/scripts/tool-efficiency-diag.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+// Tool-usage efficiency diag for worker/heavy-worker (before/after rule changes).
+// Usage: node scripts/tool-efficiency-diag.mjs [--since 24h|<epoch-ms>|ISO]
+import { readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+
+function sinceArg() {
+  const i = process.argv.indexOf('--since');
+  const raw = i >= 0 ? process.argv[i + 1] : '24h';
+  const rel = String(raw).match(/^(\d+(?:\.\d+)?)(h|m|d)$/i);
+  if (rel) {
+    const mult = { m: 60_000, h: 3_600_000, d: 86_400_000 }[rel[2].toLowerCase()];
+    return Date.now() - Number(rel[1]) * mult;
+  }
+  if (/^\d+$/.test(raw)) return Number(raw);
+  const p = Date.parse(raw);
+  return Number.isFinite(p) ? p : Date.now() - 86_400_000;
+}
+
+const dataDir = process.env.MIXDOG_DATA_DIR || resolve(homedir(), '.mixdog', 'data');
+const files = [resolve(dataDir, 'history', 'agent-trace.jsonl.1'), resolve(dataDir, 'history', 'agent-trace.jsonl')];
+const since = sinceArg();
+const rows = [];
+for (const f of files) {
+  if (!existsSync(f)) continue;
+  for (const line of readFileSync(f, 'utf8').split(/\r?\n/)) {
+    if (!line) continue;
+    try { const r = JSON.parse(line); if ((r.ts || 0) >= since) rows.push(r); } catch {}
+  }
+}
+const F = (r, n) => (r[n] != null ? r[n] : (r.payload && r.payload[n] != null ? r.payload[n] : null));
+const bySess = new Map();
+for (const r of rows) {
+  const k = r.sessionId || r.session_id || '?';
+  if (!bySess.has(k)) bySess.set(k, []);
+  bySess.get(k).push(r);
+}
+console.log(`window since ${new Date(since).toISOString()}`);
+for (const target of ['heavy-worker', 'worker']) {
+  let batch1 = 0, batchTot = 0, llmCalls = 0, sessions = 0, toolCalls = 0;
+  let grepContent = 0, grepContentWithCtx = 0, grepThenRead = 0, rereads = 0, outTok = 0;
+  for (const [, rs] of bySess) {
+    let agent = null;
+    for (const r of rs) { const x = F(r, 'agent'); if (x) { agent = x; break; } }
+    if (agent !== target) continue;
+    sessions++;
+    rs.sort((a, b) => (a.ts || 0) - (b.ts || 0));
+    for (const b of rs.filter((r) => r.kind === 'batch')) {
+      const c = Number(F(b, 'tool_call_count')) || 0;
+      batchTot++; if (c === 1) batch1++;
+    }
+    const usage = rs.filter((r) => r.kind === 'usage_raw');
+    llmCalls += usage.length;
+    outTok += usage.reduce((s, r) => s + (Number(F(r, 'output_tokens')) || 0), 0);
+    const tools = rs.filter((r) => r.kind === 'tool');
+    toolCalls += tools.length;
+    const seenRead = new Map();
+    for (let i = 0; i < tools.length; i++) {
+      const t = tools[i];
+      const n = String(F(t, 'tool_name'));
+      const a = F(t, 'tool_args_summary') || {};
+      if (n === 'read') {
+        const p = typeof a.path === 'string' ? a.path : JSON.stringify(a.path);
+        seenRead.set(p, (seenRead.get(p) || 0) + 1);
+      }
+      if (n === 'grep' && ['content', 'content_with_context'].includes(String(a.output_mode || ''))) {
+        grepContent++;
+        if (a['-C'] != null || a['-A'] != null || a['-B'] != null) grepContentWithCtx++;
+        const gpath = typeof a.path === 'string' ? a.path : JSON.stringify(a.path || '');
+        for (let j = i + 1; j < Math.min(i + 4, tools.length); j++) {
+          const u = tools[j];
+          if (String(F(u, 'tool_name')) !== 'read') continue;
+          const ra = F(u, 'tool_args_summary') || {};
+          const rpath = typeof ra.path === 'string' ? ra.path : JSON.stringify(ra.path || '');
+          if (rpath && gpath && (rpath.includes(gpath) || gpath.includes(rpath))) { grepThenRead++; break; }
+        }
+      }
+    }
+    for (const [, c] of seenRead) if (c >= 3) rereads++;
+  }
+  const pct = (a, b) => (b ? Math.round((a / b) * 100) : 0);
+  console.log(`\n${target}: sessions=${sessions} llmCalls=${llmCalls} toolCalls=${toolCalls} outTok=${outTok}`);
+  console.log(`  llmCalls/session=${sessions ? Math.round(llmCalls / sessions) : 0}  tools/llmCall=${llmCalls ? (toolCalls / llmCalls).toFixed(2) : '-'}`);
+  console.log(`  single-call batches: ${batch1}/${batchTot} (${pct(batch1, batchTot)}%)`);
+  console.log(`  content greps with -C/-A/-B: ${grepContentWithCtx}/${grepContent} (${pct(grepContentWithCtx, grepContent)}%)  grep->read follow-ups: ${grepThenRead}`);
+  console.log(`  same-path re-reads >=3x: ${rereads}`);
+}