mixdog 0.9.35 → 0.9.37

package/package.json

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

@@ -13,6 +13,12 @@ import { runExplore } from '../src/standalone/explore-tool.mjs';
 const ROUND = process.argv[2] || 'r0';
 const CWD = 'C:/Project/mixdog';
 
+// 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,12 +57,12 @@ 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)',
@@ -81,7 +87,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;
@@ -103,11 +111,15 @@ const results = await Promise.all(QUERIES.map(async ({ q, expect, expectFail })
   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.
+// 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,6 +127,22 @@ 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}`);
@@ -122,4 +150,6 @@ for (const r of results) {
 console.log(`  quality: ${results.filter((r) => r.hit).length}/${results.length} hits`);
 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,27 @@
+#!/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]));
+  assert.match(byName.grep.description, /Unknown path\/name → find first/i);
+  assert.match(byName.grep.description, /no path "\." \+ guessed src\/\*\*/i);
+  assert.match(byName.glob.description, /Unknown root\/name → find first/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' }

package/scripts/openai-ws-early-settle-test.mjs

@@ -0,0 +1,176 @@
+// Regression: OpenAI OAuth WS early tool-call settle.
+//
+// A tool-call response can be fully formed (function_call_arguments.done +
+// output_item.done) yet the server never emits the terminal
+// response.completed/response.done frame. Before the fix _streamResponse
+// coasted on that silence until a stall error (gated out of the loop via
+// pendingToolUse) or the 30-min agent watchdog, and -- because the socket was
+// still pooled -- the missing terminal frame later leaked onto the NEXT request
+// as orphan bytes (http_status=0 wedge). The fix resolves early with the
+// captured tool call and flags `closeSocket` so the pool discards the socket.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { _streamResponse } from '../src/runtime/agent/orchestrator/providers/openai-ws-stream.mjs';
+
+// Minimal fake WS: matches the .on/.off/.close/.ping surface _streamResponse
+// uses. close() is a no-op here -- the early-settle path sets done=true before
+// calling it, so the real closeHandler would short-circuit anyway.
+class FakeSocket extends EventEmitter {
+    constructor() {
+        super();
+        this.readyState = 1;
+        this.closed = null;
+    }
+    close(code, reason) { this.closed = { code, reason }; }
+    ping() {}
+    feed(events) { for (const e of events) this.emit('message', JSON.stringify(e)); }
+}
+
+const FAST_TIMEOUTS = { interChunkMs: 40, preResponseCreatedMs: 5000, firstMeaningfulMs: 5000 };
+
+const TOOL_CALL_EVENTS = [
+    { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
+    { type: 'response.output_item.added', item: { type: 'function_call', id: 'fc_1', name: 'explore', call_id: 'call_1' } },
+    { type: 'response.function_call_arguments.delta', item_id: 'fc_1', delta: '{"query"' },
+    { type: 'response.function_call_arguments.done', item_id: 'fc_1', arguments: '{"query":"x"}', call_id: 'call_1', name: 'explore' },
+    { type: 'response.output_item.done', item: { type: 'function_call', id: 'fc_1', name: 'explore', call_id: 'call_1', arguments: '{"query":"x"}' } },
+];
+
+test('ws early settle: complete tool call resolves without response.completed and flags closeSocket', async () => {
+    const socket = new FakeSocket();
+    const state = {};
+    const emitted = [];
+    const p = _streamResponse({
+        entry: { socket },
+        state,
+        onToolCall: (c) => emitted.push(c),
+        _timeouts: FAST_TIMEOUTS,
+    });
+    socket.feed(TOOL_CALL_EVENTS);
+    const result = await p;
+    assert.equal(result.closeSocket, true, 'socket must be dropped, not pooled');
+    assert.ok(Array.isArray(result.toolCalls) && result.toolCalls.length === 1);
+    assert.equal(result.toolCalls[0].id, 'call_1');
+    assert.equal(result.toolCalls[0].name, 'explore');
+    assert.deepEqual(result.toolCalls[0].arguments, { query: 'x' });
+    assert.equal(emitted.length, 1, 'tool call dispatched exactly once');
+    assert.equal(state.wsEarlySettle, 'inter_chunk');
+    assert.ok(socket.closed, 'socket.close() invoked so it is never reused');
+});
+
+test('ws early settle: normal response.completed path keeps the socket (no closeSocket)', async () => {
+    const socket = new FakeSocket();
+    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
+    socket.feed([
+        ...TOOL_CALL_EVENTS,
+        {
+            type: 'response.completed',
+            response: {
+                id: 'resp_1',
+                model: 'gpt-5.5',
+                output: [{ type: 'function_call', id: 'fc_1', name: 'explore', call_id: 'call_1', arguments: '{"query":"x"}' }],
+            },
+        },
+    ]);
+    const result = await p;
+    assert.equal(result.closeSocket, undefined, 'normal completion must not mark closeSocket');
+    assert.equal(result.toolCalls.length, 1);
+});
+
+test('ws early settle: deferred salvage still pending does NOT early-settle (fails as stall)', async () => {
+    const socket = new FakeSocket();
+    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
+    // No output_item.added -> pendingCalls empty; args.done carries no call_id/name
+    // -> a deferred placeholder that only response.completed could salvage.
+    socket.feed([
+        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
+        { type: 'response.function_call_arguments.delta', item_id: 'fc_1', delta: '{"query"' },
+        { type: 'response.function_call_arguments.done', item_id: 'fc_1', arguments: '{"query":"x"}' },
+    ]);
+    await assert.rejects(p, /inter-chunk inactivity/);
+});
+
+test('ws early settle: complete tool then partial second tool does NOT early-settle', async () => {
+    const socket = new FakeSocket();
+    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
+    socket.feed([
+        ...TOOL_CALL_EVENTS,
+        { type: 'response.output_item.added', item: { type: 'function_call', id: 'fc_2', name: 'grep', call_id: 'call_2' } },
+        { type: 'response.function_call_arguments.delta', item_id: 'fc_2', delta: '{"pattern"' },
+    ]);
+    await assert.rejects(p, /inter-chunk inactivity/);
+    assert.equal(socket.closed?.reason, 'inter_chunk_timeout', 'partial second tool must use stall path, not early settle');
+});
+
+test('ws early settle: complete tool_search_call clears in-flight and can early-settle', async () => {
+    const socket = new FakeSocket();
+    const state = {};
+    const p = _streamResponse({ entry: { socket }, state, _timeouts: FAST_TIMEOUTS });
+    socket.feed([
+        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
+        { type: 'response.output_item.added', item: { type: 'tool_search_call', id: 'ts_1' } },
+        { type: 'response.output_item.done', item: { type: 'tool_search_call', id: 'ts_1', arguments: '{"query":"fetch"}' } },
+    ]);
+    const result = await p;
+    assert.equal(result.closeSocket, true);
+    assert.equal(result.toolCalls[0].id, 'ts_1');
+    assert.equal(result.toolCalls[0].name, 'load_tool');
+    assert.deepEqual(result.toolCalls[0].arguments, { query: 'fetch' });
+    assert.equal(state.wsEarlySettle, 'inter_chunk');
+});
+
+test('ws early settle: complete tool_search_call plus partial custom tool does NOT early-settle', async () => {
+    const socket = new FakeSocket();
+    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
+    socket.feed([
+        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
+        { type: 'response.output_item.added', item: { type: 'tool_search_call', id: 'ts_1' } },
+        { type: 'response.output_item.done', item: { type: 'tool_search_call', id: 'ts_1', arguments: '{"query":"fetch"}' } },
+        { type: 'response.output_item.added', item: { type: 'custom_tool_call', id: 'ct_2', call_id: 'call_custom_2', name: 'apply_patch' } },
+        { type: 'response.custom_tool_call_input.delta', item_id: 'ct_2', delta: '*** Begin Patch' },
+    ]);
+    await assert.rejects(p, /inter-chunk inactivity/);
+    assert.equal(socket.closed?.reason, 'inter_chunk_timeout', 'partial custom tool must keep stall path');
+});
+
+test('ws early settle: output_item.done salvages deferred function_call and can early-settle', async () => {
+    const socket = new FakeSocket();
+    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
+    socket.feed([
+        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
+        { type: 'response.function_call_arguments.delta', item_id: 'fc_salvage', delta: '{"query"' },
+        { type: 'response.function_call_arguments.done', item_id: 'fc_salvage', arguments: '{"query":"x"}' },
+        { type: 'response.output_item.done', item: { type: 'function_call', id: 'fc_salvage', name: 'explore', call_id: 'call_salvage', arguments: '{"query":"x"}' } },
+    ]);
+    const result = await p;
+    assert.equal(result.closeSocket, true);
+    assert.equal(result.toolCalls[0].id, 'call_salvage');
+    assert.equal(result.toolCalls[0].name, 'explore');
+    assert.deepEqual(result.toolCalls[0].arguments, { query: 'x' });
+});
+
+test('ws early settle: call_id-only tool_search done clears id-tracked active item', async () => {
+    const socket = new FakeSocket();
+    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
+    socket.feed([
+        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
+        { type: 'response.output_item.added', item: { type: 'tool_search_call', id: 'ts_added', call_id: 'ts_call' } },
+        { type: 'response.output_item.done', item: { type: 'tool_search_call', call_id: 'ts_call', arguments: '{"query":"fetch"}' } },
+    ]);
+    const result = await p;
+    assert.equal(result.closeSocket, true);
+    assert.equal(result.toolCalls[0].id, 'ts_call');
+});
+
+test('ws early settle: function args.done without item.done does NOT early-settle', async () => {
+    const socket = new FakeSocket();
+    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
+    socket.feed([
+        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
+        { type: 'response.output_item.added', item: { type: 'function_call', id: 'fc_empty', name: 'explore', call_id: 'call_empty' } },
+        { type: 'response.function_call_arguments.done', item_id: 'fc_empty', arguments: '{}', call_id: 'call_empty', name: 'explore' },
+    ]);
+    await assert.rejects(p, /inter-chunk inactivity/);
+    assert.equal(socket.closed?.reason, 'inter_chunk_timeout', 'function item must stay active until output_item.done');
+});