mixdog 0.9.36 → 0.9.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.36",
+  "version": "0.9.38",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -46,7 +46,7 @@
     "smoke:tools": "node scripts/tool-smoke.mjs",
     "smoke:patch": "node scripts/apply-patch-edit-smoke.mjs",
     "smoke:output": "node scripts/output-style-smoke.mjs",
-    "smoke:tui": "node scripts/tui-render-smoke.mjs",
+    "smoke:tui": "node scripts/tui-render-smoke.mjs && npm run test:tui-queue",
     "smoke:freevars": "node scripts/freevar-smoke.mjs",
     "smoke:logguard": "node scripts/log-writer-guard-smoke.mjs",
     "test:toolcall": "node --test scripts/toolcall-args-test.mjs",
@@ -55,6 +55,7 @@
     "test:placeholder": "node --test scripts/compacted-placeholder-scrub-test.mjs",
     "test:providers": "node --test scripts/provider-toolcall-test.mjs",
     "test:atomiclock": "node --test scripts/atomic-lock-tryonce-test.mjs",
+    "test:tui-queue": "node --test scripts/submit-commandbusy-race-test.mjs scripts/steering-drain-buckets-test.mjs scripts/abort-recovery-test.mjs",
     "test:rebindtail": "node --test scripts/forwarder-rebind-tail-test.mjs",
     "failures": "node scripts/tool-failures.mjs",
     "trace:llm": "node scripts/llm-trace-summary.mjs",

package/scripts/abort-recovery-test.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+// Regression: bounded manual-abort recovery. Esc calls runtime.abort(), which
+// normally rejects the in-flight runtime.ask() so the turn's finally clears
+// busy. If that unwind is STARVED (provider abort never settles after a
+// post-tool fetch stall), busy must not stay true forever — a short grace timer
+// hard-releases the store and re-kicks drain. A normal abort that settles in
+// time must NOT be masked by the recovery.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createSessionFlow } from '../src/tui/engine/session-flow.mjs';
+import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
+
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// Minimal engine bag exercising only the abort() recovery path. `abortSettles`
+// models whether runtime.abort() actually unwinds the turn (clears busy) — the
+// starved case leaves busy=true so the recovery timer must fire.
+function makeEngine({ abortSettles = false, recoveryMs = 30 } = {}) {
+  let seq = 0;
+  const notices = [];
+  let drainCount = 0;
+  let state = { items: [], queued: [], busy: false, commandBusy: false, spinner: null, thinking: null, lastTurn: null };
+  const bag = {
+    runtime: {
+      id: null,
+      consumePendingSessionReset: () => null,
+      abort: () => {
+        if (abortSettles) bag.set({ busy: false, spinner: null, thinking: null, lastTurn: null });
+        return true;
+      },
+    },
+    nextId: () => `id_${++seq}`,
+    tuiDebug: () => {},
+    flags: { leadTurnEpoch: 1, disposed: false, draining: false, activePromptRestore: null, manualAbortRecoveryMs: recoveryMs },
+    pending: [],
+    listeners: new Set(),
+    getState: () => state,
+    set: (patch) => {
+      if (!patch || typeof patch !== 'object') return false;
+      state = { ...state, ...patch };
+      return true;
+    },
+    pushItem: () => {},
+    patchItem: () => {},
+    replaceItems: (x) => x,
+    pushNotice: (text, level) => { notices.push({ text, level }); },
+    pushUserOrSyntheticItem: () => {},
+    autoClearState: () => ({ enabled: false }),
+    agentStatusState: () => ({}),
+    routeState: () => ({}),
+    syncContextStats: () => {},
+    denyAllToolApprovals: () => {},
+    updateAgentJobCard: () => {},
+    requeueEntriesFront: () => {},
+    resetStatsAndSyncContext: () => {},
+    flushDeferredExecutionPendingResumeKick: () => {},
+    drain: async () => { drainCount += 1; },
+    runTurn: async () => 'ok',
+  };
+  Object.assign(bag, createSessionFlow(bag));
+  bag.drain = async () => { drainCount += 1; };
+  const api = createEngineApiA(bag);
+  return { api, bag, getNotices: () => notices, getDrainCount: () => drainCount };
+}
+
+test('starved abort → bounded recovery hard-releases busy and re-kicks drain', async () => {
+  const { api, bag, getNotices, getDrainCount } = makeEngine({ abortSettles: false, recoveryMs: 25 });
+  bag.set({ busy: true, spinner: { active: true } });
+  bag.pending.push({ kind: 'prompt', text: 'queued next' });
+  const res = api.abort();
+  assert.equal(res.aborted, true, 'abort dispatched to runtime');
+  assert.equal(bag.getState().busy, true, 'still busy immediately after abort (unwind pending)');
+  await wait(60);
+  assert.equal(bag.getState().busy, false, 'recovery timer force-releases busy');
+  assert.equal(bag.getState().spinner, null, 'spinner cleared on recovery');
+  assert.equal(bag.flags.leadTurnEpoch, 2, 'epoch bumped so stuck turn finally becomes a no-op');
+  assert.equal(getDrainCount() >= 1, true, 'drain re-kicked so queued prompt runs');
+  assert.equal(getNotices().some((n) => /did not settle/i.test(n.text)), true, 'user told input was restored');
+});
+
+test('starved abort abandons old drain owner before re-kicking drain', async () => {
+  const { api, bag, getDrainCount } = makeEngine({ abortSettles: false, recoveryMs: 25 });
+  bag.flags.draining = true;
+  bag.flags.drainEpoch = 10;
+  bag.set({ busy: true, spinner: { active: true } });
+  bag.pending.push({ kind: 'prompt', text: 'queued next' });
+
+  api.abort();
+  await wait(60);
+
+  assert.equal(bag.getState().busy, false);
+  assert.equal(bag.flags.draining, false, 'stuck drain lock was released only after epoch abandonment');
+  assert.equal(bag.flags.drainEpoch > 10, true, 'old drain owner invalidated');
+  assert.equal(getDrainCount() >= 1, true, 'new drain kick requested for pending work');
+});
+
+test('abort that settles in time is NOT masked by recovery', async () => {
+  const { api, bag, getNotices } = makeEngine({ abortSettles: true, recoveryMs: 25 });
+  bag.set({ busy: true, spinner: { active: true } });
+  const res = api.abort();
+  assert.equal(res.aborted, true);
+  assert.equal(bag.getState().busy, false, 'settled abort cleared busy synchronously');
+  const epochAfter = bag.flags.leadTurnEpoch;
+  await wait(60);
+  assert.equal(bag.flags.leadTurnEpoch, epochAfter, 'recovery no-ops (no epoch bump) when busy already cleared');
+  assert.equal(getNotices().some((n) => /did not settle/i.test(n.text)), false, 'no spurious recovery notice');
+});
+
+test('recovery no-ops if a newer turn already owns the store', async () => {
+  const { api, bag } = makeEngine({ abortSettles: false, recoveryMs: 25 });
+  bag.set({ busy: true });
+  api.abort();
+  bag.flags.leadTurnEpoch = 5;
+  bag.set({ busy: true, spinner: { active: true, verb: 'new turn' } });
+  await wait(60);
+  assert.equal(bag.flags.leadTurnEpoch, 5, 'recovery must not touch a newer turn epoch');
+  assert.equal(bag.getState().busy, true, 'newer turn stays busy — not force-released');
+});

package/scripts/compact-smoke.mjs

@@ -858,7 +858,7 @@ function chars4(text) {
   return Math.ceil(String(text ?? '').length / 4);
 }
 
-const koHeavy = '한국어 컴팩션 경계 테스트 '.repeat(200);
+const koHeavy = '\uD55C\uAD6D\uC5B4 \uCEF4\uD329\uC158 \uACBD\uACC4 \uD14C\uC2A4\uD2B8 '.repeat(200);
 const koEst = estimateMessagesTokens([{ role: 'user', content: koHeavy }]);
 assert(
   koEst > chars4(koHeavy) * 2,
@@ -892,8 +892,8 @@ assert(
 // also use the conservative estimator (>= chars/4 of the serialized JSON).
 const toolSchema = [{
   name: 'apply_patch',
-  description: '패치를 파일에 적용 (한국어 설명) — applies a patch',
-  parameters: { type: 'object', properties: { patch: { type: 'string', description: '패치 본문 텍스트' } } },
+  description: '\uD328\uCE58\uB97C \uD30C\uC77C\uC5D0 \uC801\uC6A9 (\uD55C\uAD6D\uC5B4 \uC124\uBA85) — applies a patch',
+  parameters: { type: 'object', properties: { patch: { type: 'string', description: '\uD328\uCE58 \uBCF8\uBB38 \uD14D\uC2A4\uD2B8' } } },
 }];
 const toolSchemaEst = estimateToolSchemaTokens(toolSchema);
 assert(
@@ -904,7 +904,7 @@ assert(
 // Strict-fit smoke: a Korean/CJK-heavy newest turn far larger than the preserve
 // budget must be summarized/truncated safely — never preserved verbatim — and
 // the final estimated tokens must stay within budget.
-const KO_HUGE_SENTINEL = 'KO_HUGE_SENTINEL_' + '압축경계테스트'.repeat(20_000);
+const KO_HUGE_SENTINEL = 'KO_HUGE_SENTINEL_' + '\uC555\uCD95\uACBD\uACC4\uD14C\uC2A4\uD2B8'.repeat(20_000);
 let strictFitPrompt = '';
 const strictFitProvider = {
   name: 'strict-fit-cjk-smoke',
@@ -915,9 +915,9 @@ const strictFitProvider = {
 };
 const strictFitMessages = [
   { role: 'system', content: 'system rules stay mandatory' },
-  { role: 'user', content: '이전 작은 요청' },
-  { role: 'assistant', content: '이전 작은 응답' },
-  { role: 'user', content: `최신 거대한 한국어 요청 ${KO_HUGE_SENTINEL}` },
+  { role: 'user', content: '\uC774\uC804 \uC791\uC740 \uC694\uCCAD' },
+  { role: 'assistant', content: '\uC774\uC804 \uC791\uC740 \uC751\uB2F5' },
+  { role: 'user', content: `\uCD5C\uC2E0 \uAC70\uB300\uD55C \uD55C\uAD6D\uC5B4 \uC694\uCCAD ${KO_HUGE_SENTINEL}` },
 ];
 const STRICT_FIT_BUDGET = 6_000;
 const strictFitResult = await semanticCompactMessages(strictFitProvider, strictFitMessages, 'fake-model', STRICT_FIT_BUDGET, {

package/scripts/dispatch-persist-recovery-test.mjs

@@ -0,0 +1,141 @@
+// Regression tests for recoverPending recovery bugs:
+//  (a) an entry must survive when notifyFn resolves false (not delivered) and
+//      only be removed after a confirmed (truthy) ack.
+//  (b) a scoped recovery that matches purely on clientHostPid must NOT stamp
+//      the reconnecting filter session's id onto another session's abort — it
+//      delivers to the true owner session, and leaves the entry persisted when
+//      there is no owner session to target.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  addPending,
+  recoverPending,
+} from '../src/runtime/agent/orchestrator/dispatch-persist.mjs';
+
+const FILE = 'pending-dispatches.json';
+
+function readMap(dir) {
+  try {
+    const raw = readFileSync(join(dir, FILE), 'utf8');
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch { return {}; }
+}
+
+async function waitFor(fn, { timeout = 3000, step = 20 } = {}) {
+  const deadline = Date.now() + timeout;
+  for (;;) {
+    if (fn()) return true;
+    if (Date.now() > deadline) return false;
+    await new Promise((r) => setTimeout(r, step));
+  }
+}
+
+function tmp() {
+  const dir = mkdtempSync(join(tmpdir(), 'dpersist-'));
+  return dir;
+}
+
+test('(a) only explicit false/0 keeps entry; undefined/void resolve deletes', async () => {
+  const dir = tmp();
+  try {
+    addPending(dir, 'h-a', 'recall', ['q'], 'sid-owner', 1111);
+    await waitFor(() => 'h-a' in readMap(dir));
+
+    // Explicit false → undelivered, entry MUST survive for retry.
+    recoverPending(dir, () => Promise.resolve(false), {});
+    await new Promise((r) => setTimeout(r, 200));
+    assert.ok('h-a' in readMap(dir), 'entry removed despite notifyFn=false');
+
+    // Explicit 0 → also undelivered, entry survives.
+    recoverPending(dir, () => Promise.resolve(0), {});
+    await new Promise((r) => setTimeout(r, 200));
+    assert.ok('h-a' in readMap(dir), 'entry removed despite notifyFn=0');
+
+    // undefined/void resolve from a delivered notifyFn → entry removed.
+    recoverPending(dir, () => Promise.resolve(undefined), {});
+    const gone = await waitFor(() => !('h-a' in readMap(dir)));
+    assert.ok(gone, 'entry not removed after undefined (delivered) resolve');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('(b) hostPid-only match delivers to true owner session, never the filter session', async () => {
+  const dir = tmp();
+  try {
+    addPending(dir, 'h-b', 'recall', ['q'], 'owner-A', 4242);
+    await waitFor(() => 'h-b' in readMap(dir));
+
+    let seen = null;
+    // Reconnect as a DIFFERENT session that only shares the host pid.
+    recoverPending(dir, (content, meta) => { seen = meta; return Promise.resolve(true); }, {
+      sessionId: 'session-B',
+      clientHostPid: 4242,
+    });
+    await waitFor(() => seen != null);
+    assert.equal(seen.caller_session_id, 'owner-A', 'stamped filter session instead of true owner');
+    assert.notEqual(seen.caller_session_id, 'session-B');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('(b) hostPid-only match with no owner session is left persisted, not injected', async () => {
+  const dir = tmp();
+  try {
+    addPending(dir, 'h-c', 'recall', ['q'], null, 5353);
+    await waitFor(() => 'h-c' in readMap(dir));
+
+    let called = false;
+    recoverPending(dir, () => { called = true; return Promise.resolve(true); }, {
+      sessionId: 'session-C',
+      clientHostPid: 5353,
+    });
+    await new Promise((r) => setTimeout(r, 250));
+    assert.equal(called, false, 'notifyFn fired for an entry with no owner session');
+    assert.ok('h-c' in readMap(dir), 'entry with no owner session was not left persisted');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('owner-session match still stamps the reconnecting session id', async () => {
+  const dir = tmp();
+  try {
+    addPending(dir, 'h-d', 'recall', ['q'], 'prior-sid', 6464);
+    await waitFor(() => 'h-d' in readMap(dir));
+
+    let seen = null;
+    recoverPending(dir, (content, meta) => { seen = meta; return Promise.resolve(true); }, {
+      sessionId: 'new-sid',
+      priorSessionId: 'prior-sid',
+      clientHostPid: 6464,
+    });
+    await waitFor(() => seen != null);
+    assert.equal(seen.caller_session_id, 'new-sid', 'owner match should stamp reconnecting session id');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('priorSessionId match with no current sessionId keeps the entry owner cid', async () => {
+  const dir = tmp();
+  try {
+    addPending(dir, 'h-e', 'recall', ['q'], 'prior-sid', 7575);
+    await waitFor(() => 'h-e' in readMap(dir));
+
+    let seen = null;
+    // priorSessionId matches the owner but no current sessionId is supplied →
+    // filterSid is null; must fall back to the entry's known owner cid.
+    recoverPending(dir, (content, meta) => { seen = meta; return Promise.resolve(true); }, {
+      priorSessionId: 'prior-sid',
+    });
+    await waitFor(() => seen != null);
+    assert.equal(seen.caller_session_id, 'prior-sid', 'dropped known owner cid when sessionId absent');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/scripts/explore-bench-tmp.mjs

@@ -1,4 +1,9 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
 import { runExplore } from '../src/standalone/explore-tool.mjs';
+// Attribute LLM send time (not just wall) for this high-fanout batch.
+process.env.MIXDOG_AGENT_TRACE_TIMING = '1';
 const queries = [
   'standalone explore tool implementation entry point',
   'V4A patch format parsing/conversion implementation',
@@ -14,4 +19,18 @@ const res = await runExplore({ query: queries, cwd: 'C:/Project/mixdog' }, { cal
 console.log('BATCH_ELAPSED_MS', Date.now() - t0);
 const txt = res.content?.[0]?.text || '';
 console.log('FAILED_COUNT', (txt.match(/EXPLORATION_FAILED/g) || []).length);
+// Sum send_ms from loop rows emitted since t0 → LLM time vs the wall above.
+const tracePath = process.env.MIXDOG_AGENT_TRACE_PATH
+  || join(process.env.MIXDOG_DATA_DIR || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data'), 'history', 'agent-trace.jsonl');
+let sendMs = 0, sends = 0; const sessions = new Set();
+if (existsSync(tracePath)) {
+  for (const line of readFileSync(tracePath, 'utf8').split('\n')) {
+    if (!line) continue;
+    try {
+      const r = JSON.parse(line);
+      if (r.ts >= t0 && r.kind === 'loop' && r.agent === 'explorer') { sendMs += Number(r.send_ms) || 0; sends++; sessions.add(r.session_id); }
+    } catch { /* skip */ }
+  }
+}
+console.log('LLM_SEND_MS_TOTAL', sendMs, 'sends', sends, 'sessions', sessions.size);
 process.exit(0);

package/scripts/explore-bench.mjs

@@ -6,13 +6,47 @@
 //   node scripts/explore-bench.mjs [roundLabel]
 // Fresh process per run = no in-memory result cache carryover.
 import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, isAbsolute } from 'node:path';
 import { homedir } from 'node:os';
 import { runExplore } from '../src/standalone/explore-tool.mjs';
 
 const ROUND = process.argv[2] || 'r0';
 const CWD = 'C:/Project/mixdog';
 
+// Anchor helpers: an anchor line carries a `path:line`. Strict quality =
+// expected token must land ON such a line (not merely somewhere in the text),
+// and anchors===0 is always a miss (except expectFail). Spot-accuracy verifies
+// the referenced file exists and the line number is within the file length.
+function anchorLinesOf(text) {
+  return text.split('\n').filter((l) => /:\d+/.test(l));
+}
+function checkAnchorLine(line, ctxTokens = []) {
+  const m = line.match(/([A-Za-z0-9_.\/\\-]+):(\d+)/);
+  if (!m) return null; // no parseable path:line
+  const p = m[1];
+  const ln = Number(m[2]);
+  const full = isAbsolute(p) ? p : join(CWD, p);
+  if (!existsSync(full)) return false;
+  try {
+    const fileLines = readFileSync(full, 'utf8').split('\n');
+    if (!(ln >= 1 && ln <= fileLines.length)) return false;
+    // Fabricated-line guard: the cited line's ±2 window must contain a
+    // query/expected token, so a plausible-but-wrong line number fails.
+    if (ctxTokens.length) {
+      // ±2 lines around the 1-based cited line (indices ln-3 .. ln+1 inclusive).
+      const win = fileLines.slice(Math.max(0, ln - 3), ln + 2).join('\n').toLowerCase();
+      if (!ctxTokens.some((t) => win.includes(t))) return false;
+    }
+    return true;
+  } catch { return false; }
+}
+
+// High-fanout timing attribution: emit lightweight per-iteration send_ms
+// loop rows (no verbose payload estimate) so we can split LLM send time
+// from tool time under the parallel round below. Trace-only; no behavior
+// or provider change.
+if (!process.env.MIXDOG_AGENT_TRACE_TIMING) process.env.MIXDOG_AGENT_TRACE_TIMING = '1';
+
 // Representative locator queries with ground truth: expect = substrings, at
 // least one must appear in the anchor output (quality hit). expectFail = the
 // correct answer is EXPLORATION_FAILED (miss discipline).
@@ -51,17 +85,24 @@ const QUERIES = [
     expect: ['agent-dispatch'],
   },
   {
-    q: '에이전트 세션의 최대 루프 반복 횟수는 어디서 정해져?', // korean concept query
+    q: '\uC5D0\uC774\uC804\uD2B8 \uC138\uC158\uC758 \uCD5C\uB300 \uB8E8\uD504 \uBC18\uBCF5 \uD69F\uC218\uB294 \uC5B4\uB514\uC11C \uC815\uD574\uC838?', // korean concept query
     expect: ['agent-loop-policy'],
   },
   {
     q: 'how does a fixed agent slot map to a workflow slot (explore/explorer)',
-    expect: ['mixdog-session-runtime', 'internal-agents'],
+    expect: ['session-runtime/workflow', 'FIXED_AGENT_SLOTS'],
   },
   {
     q: 'where is the mixdog config json file path resolved (data dir)',
     expect: ['config', 'plugin-paths'],
   },
+  {
+    // path-only class: the correct answer is a verified file/dir location on
+    // disk; a bare path (no :line) is an allowed HIT for this query.
+    q: 'where does mixdog store background shell job stdout logs on disk',
+    expect: ['shell-jobs', 'shell-job-paths', 'getShellJobsDir', 'shellJobStdout'],
+    pathOnly: true,
+  },
   {
     q: 'GraphQL schema stitching resolver implementation', // not in this repo
     expectFail: true,
@@ -81,7 +122,9 @@ function readTraceSince(ts) {
     if (!line) continue;
     try {
       const r = JSON.parse(line);
-      if (r.ts >= ts && r.agent === 'explorer') rows.push(r);
+      // Keep every row since ts; explorer-session attribution happens at
+      // aggregation time.
+      if (r.ts >= ts) rows.push(r);
     } catch { /* skip */ }
   }
   return rows;
@@ -90,24 +133,49 @@ function readTraceSince(ts) {
 const t0 = Date.now();
 // 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 results = await Promise.all(QUERIES.map(async ({ q, expect, expectFail, pathOnly }) => {
   const qt0 = Date.now();
   const res = await runExplore({ query: q, cwd: CWD }, { callerCwd: CWD });
   const text = res?.content?.[0]?.text || '';
-  const anchors = text.split('\n').filter((l) => /:\d+/.test(l)).length;
+  const aLines = anchorLinesOf(text);
+  const anchors = aLines.length;
   const failed = /EXPLORATION_FAILED/.test(text);
-  const lower = text.toLowerCase();
+  // Context tokens for the fabricated-line guard: expanded expected + query
+  // words, length>=4 to drop filler.
+  const ctxTokens = [
+    ...(expect || []).flatMap((e) => e.toLowerCase().split(/[^a-z0-9]+/)),
+    ...q.toLowerCase().split(/[^a-z0-9]+/),
+  ].filter((t) => t.length >= 4);
+  // Spot-check up to 2 anchors per query for file/line validity + line context.
+  let badAnchors = 0;
+  for (const l of aLines.slice(0, 2)) {
+    if (checkAnchorLine(l, ctxTokens) === false) badAnchors++;
+  }
+  const allLines = text.split('\n').filter((l) => l.trim());
+  // Strict hit: expected token must appear ON an anchor line (>=1 anchor). For
+  // the path-only class, an expected token on any verified path line HITs even
+  // without :line. expectFail wants EXPLORATION_FAILED with zero anchors.
   const hit = expectFail
     ? (failed && anchors === 0)
-    : (!failed && (expect || []).some((e) => lower.includes(e.toLowerCase())));
-  return { q: q.slice(0, 48), ms: Date.now() - qt0, anchors, failed, hit, bytes: text.length };
+    : pathOnly
+      ? (!failed && (expect || []).some(
+          (e) => allLines.some((l) => l.toLowerCase().includes(e.toLowerCase())),
+        ))
+      : (!failed && anchors > 0 && (expect || []).some(
+          (e) => aLines.some((l) => l.toLowerCase().includes(e.toLowerCase())),
+        ));
+  return { q: q.slice(0, 48), ms: Date.now() - qt0, anchors, failed, hit, badAnchors, bytes: text.length };
 }));
 
-// Attribute tool calls per explorer session spawned during this run.
+// Identify explorer sessions from trace rows, then attribute both tool calls
+// and LLM send time per session.
 const rows = readTraceSince(t0);
+const explorerSessions = new Set(
+  rows.filter((r) => r.agent === 'explorer').map((r) => r.session_id)
+);
 const bySession = new Map();
 for (const r of rows) {
-  if (r.kind !== 'tool') continue;
+  if (r.kind !== 'tool' || !explorerSessions.has(r.session_id)) continue;
   const s = bySession.get(r.session_id) || { calls: 0, tools: [] };
   s.calls++; s.tools.push(r.tool_name);
   bySession.set(r.session_id, s);
@@ -115,11 +183,30 @@ for (const r of rows) {
 const callCounts = [...bySession.values()].map((s) => s.calls).sort((a, b) => a - b);
 const p50 = callCounts[Math.floor(callCounts.length / 2)] ?? 0;
 
+// LLM send-time attribution from loop rows (kind='loop', send_ms), emitted
+// under MIXDOG_AGENT_TRACE_TIMING. Under the parallel round, sends overlap
+// wall time, so send/wall > 1 quantifies provider contention.
+const sendBySession = new Map();
+for (const r of rows) {
+  if (r.kind !== 'loop' || !explorerSessions.has(r.session_id)) continue;
+  const cur = sendBySession.get(r.session_id) || { sends: 0, ms: 0 };
+  cur.sends++; cur.ms += Number(r.send_ms) || 0;
+  sendBySession.set(r.session_id, cur);
+}
+const sendMsPer = [...sendBySession.values()].map((s) => s.ms).sort((a, b) => a - b);
+const sendTotal = sendMsPer.reduce((a, b) => a + b, 0);
+const sendP50 = sendMsPer[Math.floor(sendMsPer.length / 2)] ?? 0;
+const sendMax = sendMsPer[sendMsPer.length - 1] ?? 0;
+const sendCount = [...sendBySession.values()].reduce((a, s) => a + s.sends, 0);
+
 console.log(`\n=== explore-bench round=${ROUND} ===`);
 for (const r of results) {
-  console.log(`  [${String(r.ms).padStart(6)}ms] ${r.hit ? 'HIT ' : 'MISS'} anchors=${r.anchors} failed=${r.failed} bytes=${r.bytes}  ${r.q}`);
+  console.log(`  [${String(r.ms).padStart(6)}ms] ${r.hit ? 'HIT ' : 'MISS'} anchors=${r.anchors} bad=${r.badAnchors} failed=${r.failed} bytes=${r.bytes}  ${r.q}`);
 }
-console.log(`  quality: ${results.filter((r) => r.hit).length}/${results.length} hits`);
+const badTotal = results.reduce((a, r) => a + r.badAnchors, 0);
+console.log(`  quality: ${results.filter((r) => r.hit).length}/${results.length} hits (strict)  bad-anchors=${badTotal}`);
 console.log(`  sessions=${bySession.size} toolcalls p50=${p50} max=${callCounts[callCounts.length - 1] ?? 0} total=${callCounts.reduce((a, b) => a + b, 0)}`);
 for (const [id, s] of bySession) console.log(`    ${id.slice(-8)}: ${s.tools.join(',')}`);
-console.log(`  wall total=${((Date.now() - t0) / 1000).toFixed(1)}s`);
+const wallMs = Date.now() - t0;
+console.log(`  llm-send: sessions=${sendBySession.size} sends=${sendCount} ms/session p50=${sendP50} max=${sendMax} total=${sendTotal}`);
+console.log(`  wall total=${(wallMs / 1000).toFixed(1)}s  send/wall=${wallMs > 0 ? (sendTotal / wallMs).toFixed(2) : '0.00'}x`);

package/scripts/explore-prompt-policy-test.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { buildExplorerPrompt } from '../src/standalone/explore-tool.mjs';
+import { BUILTIN_TOOLS } from '../src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs';
+
+test('explore per-query prompt leaves path policy to tool schemas', () => {
+  const prompt = buildExplorerPrompt('display model usage show usage model_usage provider_usage session cache usage state');
+  assert.doesNotMatch(prompt, /Path policy:/i);
+  assert.doesNotMatch(prompt, /run find for that fragment before any grep\/glob/i);
+});
+
+test('grep glob find tool schemas carry unverified path policy', () => {
+  const byName = Object.fromEntries(BUILTIN_TOOLS.map((tool) => [tool.name, tool]));
+  // Conditional find-first: only genuinely guessed fragments route through
+  // find, and in the SAME turn — project root itself is a verified scope.
+  assert.match(byName.grep.description, /project root counts as verified/i);
+  assert.match(byName.grep.description, /guessed path fragment → find first, same turn/i);
+  assert.match(byName.grep.description, /no path "\." \+ guessed src\/\*\*/i);
+  assert.match(byName.glob.description, /project root is verified/i);
+  assert.match(byName.glob.description, /Guessed root\/name → find first, same turn/i);
+  assert.match(byName.find.description, /verify roots before grep\/glob/i);
+});
+
+test('explorer turn-1 contract includes batched find for unknown broad targets', () => {
+  const rule = readFileSync(new URL('../src/rules/agent/30-explorer.md', import.meta.url), 'utf8');
+  assert.match(rule, /Turn 1 is the whole search in ONE message/i);
+  assert.match(rule, /unknown\/broad\s+targets\)\s+find `query\[\]`/i);
+  assert.match(rule, /path\/name fragments from multiple tokens/i);
+});

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

@@ -46,7 +46,7 @@ const prefixedUser = {
     `${sessionBlock}\n\n` +
     '# Additional context\nsome context body line one\nline two\n\n' +
     '# Prefetch\nprefetched file snippet\n\n' +
-    '# Task\n실제 질문',
+    '# Task\n\uC2E4\uC81C \uC9C8\uBB38',
 }
 // (iii) Reference files synthetic row.
 const referenceRow = { role: 'user', content: 'Reference files:\n- a.mjs\n- b.mjs' }
@@ -76,8 +76,8 @@ const unquotedCompletionRow = {
     'Result:\nbackground task\ntask_id: task_456\nstatus: completed',
 }
 // (vii) normal human + normal assistant.
-const normalUser = { role: 'user', content: '안녕' }
-const normalAsst = { role: 'assistant', content: '네 안녕하세요' }
+const normalUser = { role: 'user', content: '\uC548\uB155' }
+const normalAsst = { role: 'assistant', content: '\uB124 \uC548\uB155\uD558\uC138\uC694' }
 
 const before = {
   asstWithTool: sessionMessageContent(asstWithTool),
@@ -111,7 +111,7 @@ assert(after.asstWithTool && !after.asstWithTool.includes('[tool_call'), 'ingest
 assert(after.asstWithTool.includes('Here is my plan for the refactor.'), 'assistant prose must survive')
 
 // (ii) prefixed user collapses to exactly the human prompt.
-assert(after.prefixedUser === '실제 질문', `prefixed user must shape to "실제 질문" (got: ${JSON.stringify(after.prefixedUser)})`)
+assert(after.prefixedUser === '\uC2E4\uC81C \uC9C8\uBB38', `prefixed user must shape to "\uC2E4\uC81C \uC9C8\uBB38" (got: ${JSON.stringify(after.prefixedUser)})`)
 assert(!/# Session|Cwd:|Model:|Additional context|Prefetch|# Task/.test(after.prefixedUser), 'no prefix residue may remain')
 
 // (iii)-(vi) synthetic rows excluded.
@@ -123,8 +123,8 @@ assert(after.completionWrapperRow === null, 'model-visible tool-completion wrapp
 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')
-assert(after.normalAsst === '네 안녕하세요', 'normal assistant text must survive intact')
+assert(after.normalUser === '\uC548\uB155', 'normal human text must survive intact')
+assert(after.normalAsst === '\uB124 \uC548\uB155\uD558\uC138\uC694', 'normal assistant text must survive intact')
 
 // Zero-loss guard: a human message that merely MENTIONS the markers mid-text is
 // NOT stripped (anchors only fire on the leading manager-produced prefix).
@@ -137,18 +137,18 @@ assert(ingestRow(humanMentionsMarkers) === 'please write a # Task section and a
 // buildSessionStartBlock emits (`# Session` then only Cwd/Model/Workflow lines).
 // Assert on the SHAPER directly so the check isolates the strip rule from
 // cleanMemoryText's normal markdown-header cleaning.
-const humanSessionDoc = { role: 'user', content: '# Session\n프로젝트 회의록입니다\n다음 안건' }
+const humanSessionDoc = { role: 'user', content: '# Session\n\uD504\uB85C\uC81D\uD2B8 \uD68C\uC758\uB85D\uC785\uB2C8\uB2E4\n\uB2E4\uC74C \uC548\uAC74' }
 assert(
-  sessionMessageContentForIngest(humanSessionDoc) === '# Session\n프로젝트 회의록입니다\n다음 안건',
+  sessionMessageContentForIngest(humanSessionDoc) === '# Session\n\uD504\uB85C\uC81D\uD2B8 \uD68C\uC758\uB85D\uC785\uB2C8\uB2E4\n\uB2E4\uC74C \uC548\uAC74',
   'human doc starting with `# Session` heading must be preserved verbatim (not wiped)',
 )
 // And through the full ingest row it must still carry the human words (the lone
 // `# ` heading marker is stripped by normal markdown cleaning — not data loss).
-assert(/프로젝트 회의록입니다/.test(ingestRow(humanSessionDoc) || ''), 'human session-doc words must survive ingest')
+assert(/\uD504\uB85C\uC81D\uD2B8 \uD68C\uC758\uB85D\uC785\uB2C8\uB2E4/.test(ingestRow(humanSessionDoc) || ''), 'human session-doc words must survive ingest')
 
 // Injected real session block (Cwd/Model) still strips to the human prompt.
-const injectedCwdModel = { role: 'user', content: '# Session\nCwd: /x\nModel: Y\n\n실제질문' }
-assert(sessionMessageContentForIngest(injectedCwdModel) === '실제질문', 'injected Cwd/Model session block must strip to the human prompt')
+const injectedCwdModel = { role: 'user', content: '# Session\nCwd: /x\nModel: Y\n\n\uC2E4\uC81C\uC9C8\uBB38' }
+assert(sessionMessageContentForIngest(injectedCwdModel) === '\uC2E4\uC81C\uC9C8\uBB38', 'injected Cwd/Model session block must strip to the human prompt')
 
 // Injected real session block incl. Workflow line still strips.
 const injectedWorkflow = { role: 'user', content: '# Session\nCwd: /x\nModel: Y\nWorkflow: Default\n\nq' }