mixdog 0.9.36 → 0.9.38

package/scripts/notify-completion-mirror-test.mjs

@@ -0,0 +1,73 @@
+// notifyFnForSession must not double-inject a background-task completion. The
+// mirror skip is gated on an EXPLICIT model-visible-delivery ack
+// (modelVisibleDelivered), set ONLY by the TUI execution-ui path that injects
+// the completion body into the active loop — never on a generic truthy
+// onNotification return. So: delivered ack → mirror suppressed; headless /
+// display-only / API listener (no ack) → mirror kept as the sole delivery.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { shouldMirrorCompletionToPendingQueue } from '../src/session-runtime/runtime-core.mjs';
+
+// A terminal agent completion with a Result body — accepted by
+// shouldPersistModelVisibleToolCompletion.
+const completionText = 'Async agent task task_1 completed finished.\n\nResult:\n> ok';
+const completionMeta = { type: 'agent_task_result', execution_id: 'task_1', status: 'completed' };
+
+test('delivered-live completion: no pending mirror (explicit model-visible ack)', () => {
+  const mirror = shouldMirrorCompletionToPendingQueue({
+    callerSessionId: 'sess_live',
+    modelVisibleDelivered: true,
+    hasEnqueue: true,
+    text: completionText,
+    meta: completionMeta,
+  });
+  assert.equal(mirror, false, 'live twin already injected → mirror suppressed');
+});
+
+test('headless completion: pending mirror kept (no ack)', () => {
+  const mirror = shouldMirrorCompletionToPendingQueue({
+    callerSessionId: 'sess_headless',
+    modelVisibleDelivered: false,
+    hasEnqueue: true,
+    text: completionText,
+    meta: completionMeta,
+  });
+  assert.equal(mirror, true, 'no listener delivered → queue copy is the sole delivery');
+});
+
+test('display-only listener returning true (no ack): pending mirror kept', () => {
+  // A generic display/API listener consumes the event (would return true) but
+  // never injects the model-visible body, so it sets NO modelVisibleDelivered
+  // ack. The mirror must stay, or the model never sees the completion body.
+  const mirror = shouldMirrorCompletionToPendingQueue({
+    callerSessionId: 'sess_display_only',
+    modelVisibleDelivered: false,
+    hasEnqueue: true,
+    text: completionText,
+    meta: completionMeta,
+  });
+  assert.equal(mirror, true, 'generic handled===true is NOT an ack → mirror kept');
+});
+
+test('unhandled but non-terminal notification is never mirrored', () => {
+  const mirror = shouldMirrorCompletionToPendingQueue({
+    callerSessionId: 'sess_headless',
+    modelVisibleDelivered: false,
+    hasEnqueue: true,
+    text: 'still running...',
+    meta: { status: 'running' },
+  });
+  assert.equal(mirror, false, 'only persistable terminal completions mirror');
+});
+
+test('missing session id or enqueue capability never mirrors', () => {
+  assert.equal(shouldMirrorCompletionToPendingQueue({
+    callerSessionId: '', modelVisibleDelivered: false, hasEnqueue: true,
+    text: completionText, meta: completionMeta,
+  }), false, 'no caller session → nothing to mirror into');
+  assert.equal(shouldMirrorCompletionToPendingQueue({
+    callerSessionId: 'sess_headless', modelVisibleDelivered: false, hasEnqueue: false,
+    text: completionText, meta: completionMeta,
+  }), false, 'no enqueue capability → cannot mirror');
+});

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');
+});

package/scripts/output-style-smoke.mjs

@@ -13,7 +13,7 @@ function assert(condition, message) {
   if (!condition) throw new Error(message);
 }
 
-const DEFAULT_REPORT_LABELS = new Set(['바뀐 점', '확인한 것', '남은 리스크/다음 단계', '다음 단계']);
+const DEFAULT_REPORT_LABELS = new Set(['\uBC14\uB010 \uC810', '\uD655\uC778\uD55C \uAC83', '\uB0A8\uC740 \uB9AC\uC2A4\uD06C/\uB2E4\uC74C \uB2E8\uACC4', '\uB2E4\uC74C \uB2E8\uACC4']);
 
 function assertCleanOutput(name, value, { maxLines = 3, maxBullets = 3, allowedLabels = new Set() } = {}) {
   const text = String(value || '').trim();
@@ -28,7 +28,7 @@ function assertCleanOutput(name, value, { maxLines = 3, maxBullets = 3, allowedL
   }
   assert(!/\b(?:tool trace|session metadata|model metadata|searched-path list)\b/i.test(text), `${name}: tool/meta trace found`);
   assert(!/\b(?:Mapped|Searched|Read|Called) for \d/i.test(text), `${name}: timing/tool status found`);
-  assert(!/^(?:네|예|맞아요|좋아요|알겠습니다|Sure|Okay|Understood)[,.\s]/i.test(text), `${name}: acknowledgment preface found`);
+  assert(!/^(?:\uB124|\uC608|\uB9DE\uC544\uC694|\uC88B\uC544\uC694|\uC54C\uACA0\uC2B5\uB2C8\uB2E4|Sure|Okay|Understood)[,.\s]/i.test(text), `${name}: acknowledgment preface found`);
   assert(!/(.+)(?:\n|\s{2,})\1/.test(text), `${name}: repeated conclusion found`);
 
   const lines = text.split(/\r?\n/).filter((line) => line.trim());
@@ -41,7 +41,7 @@ function assertCleanOutput(name, value, { maxLines = 3, maxBullets = 3, allowedL
   assert(lines.length <= maxLines, `${name}: too many lines`);
 
   const withoutCode = text.replace(/`[^`]*`/g, '');
-  const sentenceMarks = withoutCode.match(/[.!?。！？]|다\.|요\./g) || [];
+  const sentenceMarks = withoutCode.match(/[.!?。！？]|\uB2E4\.|\uC694\./g) || [];
   assert(sentenceMarks.length <= 2, `${name}: too many sentences`);
 }
 
@@ -52,7 +52,7 @@ for (const required of [
   'Mixdog default — the most detailed style',
   'State conclusions, not reasoning',
   'Use labels such as',
-  '`바뀐 점`, `확인한 것`,',
+  '`\uBC14\uB010 \uC810`, `\uD655\uC778\uD55C \uAC83`,',
   'Synthesize agent or retrieval results',
   'Do not hide blockers',
 ]) {
@@ -97,7 +97,7 @@ try {
 
   mkdirSync(join(dataDir, 'output-styles'), { recursive: true });
   writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({
-    agent: { profile: { title: '홍길동님', language: 'system' } },
+    agent: { profile: { title: '\uD64D\uAE38\uB3D9\uB2D8', language: 'system' } },
     outputStyle: 'custom-smoke',
   }));
   writeFileSync(join(dataDir, 'output-styles', 'custom-smoke.md'), '---\nname: custom-smoke\n---\n\n# Custom Output Style\n\ncustom smoke style\n');
@@ -105,7 +105,7 @@ try {
   assert(customRules.includes('# Custom Output Style'), 'configured outputStyle must select custom style');
   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('Use "\uD64D\uAE38\uB3D9\uB2D8" 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(/Default user-facing response language from system locale/.test(profileMeta), 'system profile language must resolve from system locale');
   assert(profileMeta.includes('pre-tool preambles (even single-line)'), 'profile language must cover pre-tool preambles');
@@ -115,26 +115,26 @@ try {
 
 // assertCleanOutput encodes the Simple style compact contract (not Default, which may be longer).
 const goodOutputs = {
-  explanation: 'Simple 스타일은 결과 한 줄과 근거 한 가지로 끝내고, 최종 handoff만 짧은 bullet 라벨을 씁니다.',
-  implementation: '- 바뀐 점: `scripts/output-style-smoke.mjs`의 default/simple 문자열 검증을 현재 프리셋에 맞췄습니다.\n- 확인한 것: `node scripts/output-style-smoke.mjs`를 실행했습니다.',
-  crowded: '- 바뀐 점: compact guardrail은 Simple handoff용 controlled detail을 검증합니다.\n- 확인한 것: bad 샘플 거부 규칙은 그대로입니다.',
-  blocker: '`scripts/output-style-smoke.mjs`를 찾을 수 없어 변경이 막혔습니다.',
-  semicolon: '스모크 스크립트를 갱신했고; Simple 계약에 맞는 예시 응답만 통과합니다.',
+  explanation: 'Simple \uC2A4\uD0C0\uC77C\uC740 \uACB0\uACFC \uD55C \uC904\uACFC \uADFC\uAC70 \uD55C \uAC00\uC9C0\uB85C \uB05D\uB0B4\uACE0, \uCD5C\uC885 handoff\uB9CC \uC9E7\uC740 bullet \uB77C\uBCA8\uC744 \uC501\uB2C8\uB2E4.',
+  implementation: '- \uBC14\uB010 \uC810: `scripts/output-style-smoke.mjs`\uC758 default/simple \uBB38\uC790\uC5F4 \uAC80\uC99D\uC744 \uD604\uC7AC \uD504\uB9AC\uC14B\uC5D0 \uB9DE\uCDC4\uC2B5\uB2C8\uB2E4.\n- \uD655\uC778\uD55C \uAC83: `node scripts/output-style-smoke.mjs`\uB97C \uC2E4\uD589\uD588\uC2B5\uB2C8\uB2E4.',
+  crowded: '- \uBC14\uB010 \uC810: compact guardrail\uC740 Simple handoff\uC6A9 controlled detail\uC744 \uAC80\uC99D\uD569\uB2C8\uB2E4.\n- \uD655\uC778\uD55C \uAC83: bad \uC0D8\uD50C \uAC70\uBD80 \uADDC\uCE59\uC740 \uADF8\uB300\uB85C\uC785\uB2C8\uB2E4.',
+  blocker: '`scripts/output-style-smoke.mjs`\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC5B4 \uBCC0\uACBD\uC774 \uB9C9\uD614\uC2B5\uB2C8\uB2E4.',
+  semicolon: '\uC2A4\uBAA8\uD06C \uC2A4\uD06C\uB9BD\uD2B8\uB97C \uAC31\uC2E0\uD588\uACE0; Simple \uACC4\uC57D\uC5D0 \uB9DE\uB294 \uC608\uC2DC \uC751\uB2F5\uB9CC \uD1B5\uACFC\uD569\uB2C8\uB2E4.',
 };
 for (const [name, output] of Object.entries(goodOutputs)) assertCleanOutput(name, output, { allowedLabels: DEFAULT_REPORT_LABELS });
 
 const badOutputs = {
   heading: '## Summary\nDone.',
   label: 'Changed: updated default style.',
-  koreanLabel: '변경: default 스타일을 수정했습니다.\n검증: 스모크를 통과했습니다.',
+  koreanLabel: '\uBCC0\uACBD: default \uC2A4\uD0C0\uC77C\uC744 \uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.\n\uAC80\uC99D: \uC2A4\uBAA8\uD06C\uB97C \uD1B5\uACFC\uD588\uC2B5\uB2C8\uB2E4.',
   numbered: '1. Updated style\n2. Ran smoke',
   paragraphs: 'Done.\n\nDone again.',
   nested: '- Updated\n  - Nested detail',
-  ack: '네, default 스타일을 수정했습니다.',
-  timing: 'Mapped for 2m 32s\n\ndefault 스타일을 수정했습니다.',
-  tooManySentences: '수정했습니다. 검증했습니다. 보고했습니다.',
-  mixed: '수정했습니다.\n- 검증했습니다.',
-  tooManyBullets: '- 바뀐 점: A\n- 확인한 것: B\n- 다음 단계: C\n- 남은 리스크/다음 단계: D',
+  ack: '\uB124, default \uC2A4\uD0C0\uC77C\uC744 \uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.',
+  timing: 'Mapped for 2m 32s\n\ndefault \uC2A4\uD0C0\uC77C\uC744 \uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.',
+  tooManySentences: '\uC218\uC815\uD588\uC2B5\uB2C8\uB2E4. \uAC80\uC99D\uD588\uC2B5\uB2C8\uB2E4. \uBCF4\uACE0\uD588\uC2B5\uB2C8\uB2E4.',
+  mixed: '\uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.\n- \uAC80\uC99D\uD588\uC2B5\uB2C8\uB2E4.',
+  tooManyBullets: '- \uBC14\uB010 \uC810: A\n- \uD655\uC778\uD55C \uAC83: B\n- \uB2E4\uC74C \uB2E8\uACC4: C\n- \uB0A8\uC740 \uB9AC\uC2A4\uD06C/\uB2E4\uC74C \uB2E8\uACC4: D',
 };
 for (const [name, output] of Object.entries(badOutputs)) {
   let failed = false;