verbalcoding 0.2.11 → 0.2.13

package/app-node/plan_dispatcher.test.mjs

@@ -0,0 +1,101 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createPlanDispatcher } from './plan_dispatcher.mjs';
+import { createBridge } from './bridge_context.mjs';
+
+const noop = () => {};
+const noopAsync = async () => {};
+
+function makeDeps(overrides = {}) {
+  const bridge = createBridge();
+  return {
+    bridge,
+    settings: { voiceLanguage: 'ko', transcriptChannelId: 'tx-ch', agent: { backend: 'hermes', label: 'hermes' } },
+    sendText: noopAsync,
+    speakText: noopAsync,
+    routingStateFor: () => ({
+      activeRouting: { backend: 'hermes', sticky: false },
+      lastUsedBackend: 'hermes',
+      lastResolvedDecisions: {},
+      pendingFallbackPrompt: null,
+      recentUtterances: [],
+    }),
+    adapterForBackend: () => null,
+    adapterForProjectSession: () => ({ label: 'hermes', backend: 'hermes', ask: async () => '' }),
+    resolveProjectSessionForChannel: () => null,
+    isAgentRoutingDecision: () => false,
+    parseDecisionAnswer: () => ({ type: 'unknown' }),
+    parsePlanVoiceCommand: () => ({ type: 'unknown' }),
+    applyPlanCommand: s => s,
+    parsePlanOutput: () => ({ steps: [], decisions: [] }),
+    renderDecisionPrompt: d => d?.text || '',
+    renderResolvedDecisions: () => '',
+    renderFinalPlan: () => '',
+    planModePreamble: () => 'plan-preamble',
+    planExecutionPreamble: () => 'exec-preamble',
+    isPlanEntryUtterance: () => false,
+    ...overrides,
+  };
+}
+
+test('createPlanDispatcher exposes the expected functions', () => {
+  const d = createPlanDispatcher(makeDeps());
+  for (const name of ['planChannelKey', 'askNextDecision', 'finalizePlanReady', 'dispatchPlanModeUtterance', 'planNarrationLines']) {
+    assert.equal(typeof d[name], 'function', `${name} is exposed`);
+  }
+});
+
+test('planChannelKey prefers active voice channel, then transcript, then default', () => {
+  const deps = makeDeps();
+  const { planChannelKey } = createPlanDispatcher(deps);
+  assert.equal(planChannelKey(), 'tx-ch');
+  deps.bridge.activeVoiceChannelId = 'vc-1';
+  assert.equal(planChannelKey(), 'vc-1');
+  deps.bridge.activeVoiceChannelId = '';
+  deps.settings.transcriptChannelId = '';
+  assert.equal(planChannelKey(), 'default');
+});
+
+test('planNarrationLines numbers visible steps and skips dropped ones', () => {
+  const { planNarrationLines } = createPlanDispatcher(makeDeps());
+  const steps = [
+    { text: 'first', status: 'pending' },
+    { text: 'dropped', status: 'skipped' },
+    { text: 'third', status: 'pending' },
+  ];
+  const out = planNarrationLines(steps, 'en');
+  assert.match(out, /2 steps/, 'header counts visible only');
+  assert.match(out, /1\. first/);
+  assert.match(out, /2\. third/);
+  assert.doesNotMatch(out, /dropped/);
+});
+
+test('dispatchPlanModeUtterance returns handled:false when not a plan entry and no existing plan', async () => {
+  const deps = makeDeps({
+    isPlanEntryUtterance: () => false,
+  });
+  const { dispatchPlanModeUtterance } = createPlanDispatcher(deps);
+  const out = await dispatchPlanModeUtterance('hello world', new AbortController().signal);
+  assert.deepEqual(out, { handled: false, prompt: 'hello world' });
+});
+
+test('dispatchPlanModeUtterance handles cancel command on existing pending decision', async () => {
+  const deps = makeDeps({
+    parsePlanVoiceCommand: text => /cancel/.test(text) ? { type: 'cancel' } : { type: 'unknown' },
+  });
+  // Seed a plan with one pending decision so the cancel branch can fire.
+  const { dispatchPlanModeUtterance, planChannelKey } = createPlanDispatcher(deps);
+  const key = planChannelKey();
+  deps.bridge.planStates.set(key, {
+    steps: [{ text: 's1', status: 'pending' }],
+    decisions: [{ slot: 'oauth_provider', options: ['google', 'github'] }],
+    pendingDecisionIndex: 0,
+    resolvedDecisions: {},
+    language: 'en',
+    routingSnapshot: null,
+  });
+  const out = await dispatchPlanModeUtterance('cancel this', new AbortController().signal);
+  assert.equal(out.handled, true);
+  // Plan state should be cleared after cancel.
+  assert.equal(deps.bridge.planStates.has(key), false);
+});

package/app-node/plan_mode.mjs

@@ -0,0 +1,203 @@
+const PLAN_RE = /PLAN_BEGIN\s*\n([\s\S]*?)\nPLAN_END/g;
+const DECISIONS_RE = /DECISIONS_BEGIN\s*\n([\s\S]*?)\nDECISIONS_END/g;
+
+function lastMatch(text, regex) {
+  const matches = Array.from(String(text || '').matchAll(regex));
+  return matches.length ? matches[matches.length - 1] : null;
+}
+
+const SKIP_EN = /\bskip\s+step\s+(\d+)\b/i;
+const SKIP_KO = /step\s*(\d+)\s*건너뛰/i;
+const ADD_EN = /\badd\s+(.+?)\s+after\s+step\s+(\d+)\b/i;
+const ADD_KO = /step\s*(\d+)\s*다음에\s+(.+?)\s*추가/i;
+const APPROVE_EN = /\b(approve|go\s*ahead|let'?s\s+go|run\s+it|proceed)\b/i;
+const APPROVE_KO = /(실행|진행|승인)/i;
+const CANCEL_EN = /\b(cancel|stop|nevermind|never\s+mind)\b/i;
+const CANCEL_KO = /(취소|그만)/i;
+const ENTER_EN = /\b(plan\s+(it\s+)?first|make\s+a\s+plan)\b/i;
+const ENTER_KO = /(먼저\s*계획|계획\s*먼저|계획부터)/i;
+
+export function parsePlanOutput(text) {
+  const planMatch = lastMatch(text, PLAN_RE);
+  if (!planMatch) return { steps: [], decisions: [] };
+  const steps = planMatch[1]
+    .split(/\r?\n/)
+    .map(line => line.match(/^\s*(\d+)\.\s*(.+)$/))
+    .filter(Boolean)
+    .map(m => ({ id: Number(m[1]), text: m[2].trim(), status: 'pending' }));
+  const afterPlan = String(text || '').slice(planMatch.index + planMatch[0].length);
+  const decisions = parseDecisions(afterPlan);
+  return { steps, decisions };
+}
+
+export function parseDecisions(text) {
+  const match = lastMatch(text, DECISIONS_RE);
+  if (!match) return [];
+  const out = [];
+  let counter = 1;
+  for (const raw of match[1].split(/\r?\n/)) {
+    const line = raw.replace(/^\s*-\s*/, '').trim();
+    if (!line) continue;
+    const parts = line.split('|').map(s => s.trim()).filter(Boolean);
+    if (parts.length < 3) continue;
+    const [slot, question, ...options] = parts;
+    out.push({
+      slot: slot || `decision_${counter++}`,
+      question,
+      options: options.filter(Boolean),
+    });
+  }
+  return out;
+}
+
+const ORDINAL_EN = { first: 1, second: 2, third: 3, fourth: 4, fifth: 5, '1st': 1, '2nd': 2, '3rd': 3 };
+const ORDINAL_KO = { '첫': 1, '첫번째': 1, '첫 번째': 1, '두번째': 2, '두 번째': 2, '세번째': 3, '세 번째': 3, '네번째': 4 };
+const DEFER_RE = /\b(either|whatever|you\s+(decide|pick|choose)|agent\s+(decides|picks)|up\s+to\s+you|no\s+preference)\b|아무거나|네가\s*골라|마음대로|상관없|알아서/i;
+
+function escapeRegex(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function optionMatchesText(text, optionLower) {
+  if (!optionLower || optionLower.length < 2) return false;
+  const asciiOnly = /^[\x00-\x7f]+$/.test(optionLower);
+  if (asciiOnly) {
+    const pattern = new RegExp(`(^|\\W)${escapeRegex(optionLower)}(\\W|$)`, 'i');
+    return pattern.test(text);
+  }
+  return text.includes(optionLower);
+}
+
+export function parseDecisionAnswer(utterance, decision, language = 'en') {
+  const text = String(utterance || '').trim();
+  if (!text || !decision || !Array.isArray(decision.options) || decision.options.length === 0) {
+    return { type: 'unknown', choice: null };
+  }
+  const lower = text.toLowerCase();
+  if (DEFER_RE.test(text)) return { type: 'auto', choice: null };
+  for (const opt of decision.options) {
+    const optLower = String(opt).toLowerCase();
+    if (optionMatchesText(lower, optLower)) return { type: 'option', choice: opt };
+  }
+  const numMatch = text.match(/\b(\d+)\b/);
+  if (numMatch) {
+    const idx = Number(numMatch[1]);
+    if (idx >= 1 && idx <= decision.options.length) return { type: 'option', choice: decision.options[idx - 1] };
+  }
+  for (const [word, idx] of Object.entries(ORDINAL_EN)) {
+    if (lower.includes(word)) {
+      if (idx <= decision.options.length) return { type: 'option', choice: decision.options[idx - 1] };
+    }
+  }
+  for (const [word, idx] of Object.entries(ORDINAL_KO)) {
+    if (text.includes(word)) {
+      if (idx <= decision.options.length) return { type: 'option', choice: decision.options[idx - 1] };
+    }
+  }
+  return { type: 'unknown', choice: null };
+}
+
+export function renderDecisionPrompt(decision, language = 'en') {
+  if (!decision) return '';
+  const opts = decision.options.map((o, i) => `${i + 1}) ${o}`).join('  ');
+  if (/^en/i.test(String(language || ''))) {
+    return `${decision.question} Options: ${opts}. Or say "either" to let me pick.`;
+  }
+  return `${decision.question} 옵션: ${opts}. "아무거나"라고 하면 내가 고를게.`;
+}
+
+export function renderResolvedDecisions(resolved, language = 'en') {
+  const keys = Object.keys(resolved || {});
+  if (!keys.length) return '';
+  const parts = keys.map(k => `${k}=${resolved[k] === null ? '(agent picks)' : resolved[k]}`);
+  return /^en/i.test(String(language || ''))
+    ? `Resolved decisions: ${parts.join(', ')}.`
+    : `결정 사항: ${parts.join(', ')}.`;
+}
+
+export function isPlanEntryUtterance(text, language = 'en') {
+  const t = String(text || '');
+  if (language === 'ko') return ENTER_KO.test(t) || ENTER_EN.test(t);
+  return ENTER_EN.test(t) || ENTER_KO.test(t);
+}
+
+export function parseVoiceCommand(text, language = 'en') {
+  const t = String(text || '').trim();
+  let m = t.match(SKIP_EN) || t.match(SKIP_KO);
+  if (m) return { type: 'skip', index: Number(m[1]) };
+  m = t.match(ADD_EN);
+  if (m) return { type: 'insert', after: Number(m[2]), text: m[1].trim() };
+  m = t.match(ADD_KO);
+  if (m) return { type: 'insert', after: Number(m[1]), text: m[2].trim() };
+  if (APPROVE_EN.test(t) || APPROVE_KO.test(t)) return { type: 'approve' };
+  if (CANCEL_EN.test(t) || CANCEL_KO.test(t)) return { type: 'cancel' };
+  return { type: 'unknown' };
+}
+
+export function applyCommand(steps, cmd) {
+  if (!Array.isArray(steps)) return [];
+  if (cmd.type === 'skip') {
+    return steps.map(s => (s.id === cmd.index ? { ...s, status: 'skipped' } : s));
+  }
+  if (cmd.type === 'insert') {
+    const usedIds = new Set(steps.map(s => s.id));
+    let fraction = 0.5;
+    let proposed = cmd.after + fraction;
+    while (usedIds.has(proposed)) {
+      fraction /= 2;
+      proposed = cmd.after + fraction;
+    }
+    const out = [];
+    for (const s of steps) {
+      out.push(s);
+      if (s.id === cmd.after) {
+        out.push({ id: proposed, text: cmd.text, status: 'added' });
+      }
+    }
+    return out;
+  }
+  return steps;
+}
+
+export function renderFinalPlan(steps) {
+  const active = (steps || []).filter(s => s.status !== 'skipped');
+  return active.map((s, i) => `${i + 1}. ${s.text}`).join('\n');
+}
+
+export function planModePreamble(language = 'en') {
+  if (language === 'ko') {
+    return [
+      '지금은 PLAN MODE다. 파일을 절대 수정하지 마라.',
+      '아래 형식으로 짧은 계획을 답하고, 결정이 필요한 분기마다 DECISIONS 블록에 질문을 적어라.',
+      'PLAN_BEGIN',
+      '1. ...',
+      '2. ...',
+      'PLAN_END',
+      'DECISIONS_BEGIN',
+      '- <slot> | <한 문장 질문> | <옵션1> | <옵션2> | ...',
+      'DECISIONS_END',
+      '각 단계는 12단어 이하 한국어 한 줄. slot은 oauth_provider, session_store 같은 짧은 영문 키.',
+      'slot이 "which_agent"이면 다음에 답할 CLI 에이전트를 묻는 분기다 (options: codex, aider, claude, gemini, opencode, openclaw, cursor, hermes).',
+      '결정이 필요 없으면 DECISIONS 블록 자체를 생략해라.',
+    ].join('\n');
+  }
+  return [
+    'You are in PLAN MODE. Do NOT modify any files.',
+    'Reply with a short plan AND list any forks/decisions you would normally pick yourself.',
+    'PLAN_BEGIN',
+    '1. ...',
+    '2. ...',
+    'PLAN_END',
+    'DECISIONS_BEGIN',
+    '- <slot> | <one-sentence question> | <option1> | <option2> | ...',
+    'DECISIONS_END',
+    'Each step under 12 words. slot is a short snake_case key (e.g. oauth_provider).',
+    'Use slot "which_agent" when the choice is which CLI agent should answer next (options: codex, aider, claude, gemini, opencode, openclaw, cursor, hermes).',
+    'Omit the DECISIONS block entirely if there is nothing to ask.',
+  ].join('\n');
+}
+
+export function planExecutionPreamble(language = 'en') {
+  if (language === 'ko') return '아래 계획에 따라 작업을 실행해라. 각 단계가 끝나면 다음으로 진행해라.';
+  return 'Execute the following plan. Move to the next step as each one completes.';
+}

package/app-node/plan_mode.test.mjs

@@ -0,0 +1,231 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  parsePlanOutput,
+  parseDecisions,
+  parseDecisionAnswer,
+  renderDecisionPrompt,
+  renderResolvedDecisions,
+  parseVoiceCommand,
+  applyCommand,
+  renderFinalPlan,
+  isPlanEntryUtterance,
+  planModePreamble,
+} from './plan_mode.mjs';
+import { isAgentRoutingDecision } from './agent_routing.mjs';
+
+test('parsePlanOutput extracts numbered steps between markers', () => {
+  const out = parsePlanOutput('intro\nPLAN_BEGIN\n1. Read auth.ts\n2. Add login route\n3. Write test\nPLAN_END\nthanks');
+  assert.deepEqual(out.steps.map(s => s.text), ['Read auth.ts', 'Add login route', 'Write test']);
+  assert.equal(out.steps[0].status, 'pending');
+  assert.equal(out.steps[0].id, 1);
+  assert.deepEqual(out.decisions, []);
+});
+
+test('parsePlanOutput returns empty steps when markers missing', () => {
+  assert.deepEqual(parsePlanOutput('no plan here'), { steps: [], decisions: [] });
+});
+
+test('parsePlanOutput extracts decisions block', () => {
+  const text = [
+    'PLAN_BEGIN',
+    '1. Add OAuth',
+    '2. Wire callback',
+    'PLAN_END',
+    'DECISIONS_BEGIN',
+    '- oauth_provider | Which OAuth provider? | google | github | both',
+    '- session_store | Where to store sessions? | redis | memory',
+    'DECISIONS_END',
+  ].join('\n');
+  const out = parsePlanOutput(text);
+  assert.equal(out.steps.length, 2);
+  assert.equal(out.decisions.length, 2);
+  assert.equal(out.decisions[0].slot, 'oauth_provider');
+  assert.deepEqual(out.decisions[0].options, ['google', 'github', 'both']);
+  assert.equal(out.decisions[1].slot, 'session_store');
+});
+
+test('parseDecisions skips malformed lines', () => {
+  const text = 'DECISIONS_BEGIN\n- bad line\n- ok | question | a | b\nDECISIONS_END';
+  const out = parseDecisions(text);
+  assert.equal(out.length, 1);
+  assert.equal(out[0].slot, 'ok');
+});
+
+test('parseDecisionAnswer matches option by name', () => {
+  const decision = { slot: 'x', question: 'Pick one', options: ['redis', 'memory'] };
+  assert.deepEqual(parseDecisionAnswer('use redis', decision), { type: 'option', choice: 'redis' });
+  assert.deepEqual(parseDecisionAnswer('go with memory', decision), { type: 'option', choice: 'memory' });
+});
+
+test('parseDecisionAnswer matches by number and ordinal', () => {
+  const decision = { slot: 'x', question: 'Pick one', options: ['alpha', 'beta', 'gamma'] };
+  assert.deepEqual(parseDecisionAnswer('option 2', decision), { type: 'option', choice: 'beta' });
+  assert.deepEqual(parseDecisionAnswer('the first one', decision), { type: 'option', choice: 'alpha' });
+  assert.deepEqual(parseDecisionAnswer('세번째', decision), { type: 'option', choice: 'gamma' });
+});
+
+test('parseDecisionAnswer detects defer phrases', () => {
+  const decision = { slot: 'x', question: 'q', options: ['a', 'b'] };
+  assert.equal(parseDecisionAnswer('either is fine', decision).type, 'auto');
+  assert.equal(parseDecisionAnswer('you decide', decision).type, 'auto');
+  assert.equal(parseDecisionAnswer('아무거나', decision).type, 'auto');
+});
+
+test('parseDecisionAnswer returns unknown on no match', () => {
+  const decision = { slot: 'x', question: 'q', options: ['alpha', 'beta'] };
+  assert.equal(parseDecisionAnswer('hello world', decision).type, 'unknown');
+});
+
+test('parseDecisionAnswer requires word boundaries for ASCII options', () => {
+  const decision = { slot: 'x', question: 'q', options: ['go', 'wait'] };
+  assert.equal(parseDecisionAnswer('go ahead', decision).choice, 'go');
+  // "go" should not match inside "ago" or "google"
+  const trickier = { slot: 'x', question: 'q', options: ['go', 'wait'] };
+  assert.equal(parseDecisionAnswer('a long time ago', trickier).type, 'unknown');
+  assert.equal(parseDecisionAnswer('let me google that', trickier).type, 'unknown');
+});
+
+test('renderDecisionPrompt formats question with numbered options', () => {
+  const decision = { slot: 'x', question: 'Pick auth?', options: ['google', 'github'] };
+  assert.match(renderDecisionPrompt(decision, 'en'), /Pick auth\?\s+Options:\s+1\) google\s+2\) github/);
+});
+
+test('renderResolvedDecisions handles auto choices', () => {
+  const resolved = { provider: 'github', store: null };
+  const out = renderResolvedDecisions(resolved, 'en');
+  assert.match(out, /provider=github/);
+  assert.match(out, /store=\(agent picks\)/);
+});
+
+test('parseVoiceCommand recognizes skip in en and ko', () => {
+  assert.deepEqual(parseVoiceCommand('skip step 3', 'en'), { type: 'skip', index: 3 });
+  assert.deepEqual(parseVoiceCommand('step 2 건너뛰어', 'ko'), { type: 'skip', index: 2 });
+});
+
+test('parseVoiceCommand recognizes insert in en', () => {
+  assert.deepEqual(parseVoiceCommand('add write a test after step 1', 'en'), { type: 'insert', after: 1, text: 'write a test' });
+});
+
+test('parseVoiceCommand recognizes insert in ko', () => {
+  assert.deepEqual(parseVoiceCommand('step 2 다음에 테스트 작성 추가', 'ko'), { type: 'insert', after: 2, text: '테스트 작성' });
+});
+
+test('parseVoiceCommand recognizes approve in both languages', () => {
+  assert.deepEqual(parseVoiceCommand('approve', 'en'), { type: 'approve' });
+  assert.deepEqual(parseVoiceCommand('go ahead', 'en'), { type: 'approve' });
+  assert.deepEqual(parseVoiceCommand('실행', 'ko'), { type: 'approve' });
+});
+
+test('parseVoiceCommand recognizes cancel', () => {
+  assert.deepEqual(parseVoiceCommand('cancel', 'en'), { type: 'cancel' });
+  assert.deepEqual(parseVoiceCommand('취소', 'ko'), { type: 'cancel' });
+});
+
+test('parseVoiceCommand falls through to unknown', () => {
+  assert.deepEqual(parseVoiceCommand('what is the meaning of life', 'en'), { type: 'unknown' });
+});
+
+test('applyCommand skip marks status', () => {
+  const steps = [{ id: 1, text: 'a', status: 'pending' }, { id: 2, text: 'b', status: 'pending' }];
+  const after = applyCommand(steps, { type: 'skip', index: 2 });
+  assert.equal(after[1].status, 'skipped');
+});
+
+test('applyCommand insert places new step after target', () => {
+  const steps = [{ id: 1, text: 'a', status: 'pending' }, { id: 2, text: 'b', status: 'pending' }];
+  const after = applyCommand(steps, { type: 'insert', after: 1, text: 'extra' });
+  assert.equal(after.length, 3);
+  assert.equal(after[1].text, 'extra');
+  assert.equal(after[1].status, 'added');
+  assert.equal(after[2].text, 'b');
+});
+
+test('applyCommand two inserts after the same step get unique ids', () => {
+  let steps = [{ id: 1, text: 'a', status: 'pending' }, { id: 2, text: 'b', status: 'pending' }];
+  steps = applyCommand(steps, { type: 'insert', after: 1, text: 'first extra' });
+  steps = applyCommand(steps, { type: 'insert', after: 1, text: 'second extra' });
+  const ids = steps.map(s => s.id);
+  assert.equal(new Set(ids).size, ids.length, `expected unique ids, got ${ids.join(',')}`);
+});
+
+test('parsePlanOutput drops stale draft DECISIONS that precede the final PLAN', () => {
+  const text = [
+    'DECISIONS_BEGIN',
+    '- stale_slot | Old question? | a | b',
+    'DECISIONS_END',
+    '',
+    'PLAN_BEGIN',
+    '1. real step',
+    'PLAN_END',
+  ].join('\n');
+  const out = parsePlanOutput(text);
+  assert.deepEqual(out.steps.map(s => s.text), ['real step']);
+  assert.deepEqual(out.decisions, []);
+});
+
+test('parsePlanOutput picks the last PLAN/DECISIONS block when duplicates exist', () => {
+  const text = [
+    'PLAN_BEGIN',
+    '1. example step',
+    'PLAN_END',
+    'DECISIONS_BEGIN',
+    '- example_slot | Pick? | a | b',
+    'DECISIONS_END',
+    '',
+    'PLAN_BEGIN',
+    '1. real step one',
+    '2. real step two',
+    'PLAN_END',
+    'DECISIONS_BEGIN',
+    '- real_slot | Real question? | yes | no',
+    'DECISIONS_END',
+  ].join('\n');
+  const out = parsePlanOutput(text);
+  assert.deepEqual(out.steps.map(s => s.text), ['real step one', 'real step two']);
+  assert.equal(out.decisions.length, 1);
+  assert.equal(out.decisions[0].slot, 'real_slot');
+});
+
+test('renderFinalPlan skips skipped steps and renumbers', () => {
+  const steps = [
+    { id: 1, text: 'a', status: 'pending' },
+    { id: 2, text: 'b', status: 'skipped' },
+    { id: 3, text: 'c', status: 'pending' },
+  ];
+  assert.equal(renderFinalPlan(steps), '1. a\n2. c');
+});
+
+test('isPlanEntryUtterance detects entry phrases', () => {
+  assert.equal(isPlanEntryUtterance('plan it first', 'en'), true);
+  assert.equal(isPlanEntryUtterance('make a plan', 'en'), true);
+  assert.equal(isPlanEntryUtterance('먼저 계획 짜줘', 'ko'), true);
+  assert.equal(isPlanEntryUtterance('just do it', 'en'), false);
+});
+
+test('planModePreamble contains PLAN_BEGIN marker', () => {
+  assert.match(planModePreamble('en'), /PLAN_BEGIN/);
+  assert.match(planModePreamble('ko'), /PLAN_BEGIN/);
+});
+
+test('parsePlanOutput tags which_agent decision via isAgentRoutingDecision', () => {
+  const text = [
+    'PLAN_BEGIN',
+    '1. Survey the codebase',
+    'PLAN_END',
+    'DECISIONS_BEGIN',
+    '- which_agent | Who should answer? | codex | aider',
+    'DECISIONS_END',
+  ].join('\n');
+  const out = parsePlanOutput(text);
+  assert.equal(out.decisions[0].slot, 'which_agent');
+  assert.equal(isAgentRoutingDecision(out.decisions[0]), true);
+});
+
+test('planModePreamble in English mentions which_agent', () => {
+  assert.match(planModePreamble('en'), /which_agent/);
+});
+
+test('planModePreamble in Korean mentions which_agent', () => {
+  assert.match(planModePreamble('ko'), /which_agent/);
+});