verbalcoding 0.2.11 → 0.2.13

package/app-node/research_mode.mjs

@@ -0,0 +1,282 @@
+const RESEARCH_EN = /^(?:please\s+)?(?:(?:ask|tell|have|let)\s+[a-z][a-z0-9 \-]{1,30}?\s+(?:to\s+)?)?(?:deep\s+)?(?:research|look\s+up|find\s+out\s+about)\s+(.+)$/i;
+const RESEARCH_KO = /^(.+?)\s*(?:리서치(?:해줘?)?|조사(?:해줘?)?|찾아봐)\s*$/;
+
+export function parseResearchCommand(text, language = 'en') {
+  const t = String(text || '').trim();
+  if (!t) return { type: 'none' };
+  const normalized = t.replace(/[.,!?]+$/u, '').trim();
+  const en = normalized.match(RESEARCH_EN);
+  if (en) {
+    const query = en[1].trim();
+    if (query.length >= 3) return { type: 'research', query, depth: /\bdeep\b/i.test(normalized) ? 'deep' : 'quick' };
+  }
+  const ko = normalized.match(RESEARCH_KO);
+  if (ko) {
+    const query = ko[1].trim();
+    if (query.length >= 2 && !/^(this|that|it|이거|저거|그거)$/i.test(query)) {
+      return { type: 'research', query, depth: 'quick' };
+    }
+  }
+  return { type: 'none' };
+}
+
+function ensureUrl(url) { try { return new URL(url).toString(); } catch { return null; } }
+
+async function tavilySearch(query, { apiKey, fetchImpl, signal, maxResults = 5 }) {
+  const res = await fetchImpl('https://api.tavily.com/search', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify({ query, max_results: maxResults, search_depth: 'basic', include_answer: true, include_raw_content: false }),
+    signal,
+  });
+  if (!res.ok) throw new Error(`tavily ${res.status}`);
+  const data = await res.json();
+  const results = Array.isArray(data?.results) ? data.results : [];
+  return {
+    answer: String(data?.answer || '').trim(),
+    sources: results.map(r => ({ title: String(r.title || '').slice(0, 120), url: ensureUrl(r.url), snippet: String(r.content || '').slice(0, 400) })).filter(r => r.url),
+  };
+}
+
+async function braveSearch(query, { apiKey, fetchImpl, signal, maxResults = 5 }) {
+  const url = new URL('https://api.search.brave.com/res/v1/web/search');
+  url.searchParams.set('q', query);
+  url.searchParams.set('count', String(maxResults));
+  const res = await fetchImpl(url.toString(), {
+    headers: { 'x-subscription-token': apiKey, accept: 'application/json' },
+    signal,
+  });
+  if (!res.ok) throw new Error(`brave ${res.status}`);
+  const data = await res.json();
+  const results = Array.isArray(data?.web?.results) ? data.web.results : [];
+  return {
+    answer: '',
+    sources: results.map(r => ({ title: String(r.title || '').slice(0, 120), url: ensureUrl(r.url), snippet: String(r.description || '').slice(0, 400) })).filter(r => r.url),
+  };
+}
+
+async function searxngSearch(query, { baseUrl, fetchImpl, signal, maxResults = 5 }) {
+  const u = new URL(String(baseUrl).replace(/\/$/, '') + '/search');
+  u.searchParams.set('q', query);
+  u.searchParams.set('format', 'json');
+  u.searchParams.set('safesearch', '1');
+  const res = await fetchImpl(u.toString(), { signal, headers: { accept: 'application/json' } });
+  if (!res.ok) throw new Error(`searxng ${res.status}`);
+  const data = await res.json();
+  const raw = Array.isArray(data?.results) ? data.results : [];
+  const seen = new Set();
+  const sources = [];
+  for (const r of raw) {
+    const u2 = ensureUrl(r?.url);
+    if (!u2 || seen.has(u2)) continue;
+    seen.add(u2);
+    sources.push({
+      title: String(r.title || '').slice(0, 120),
+      url: u2,
+      snippet: String(r.content || '').replace(/\s+/g, ' ').slice(0, 400),
+    });
+    if (sources.length >= maxResults) break;
+  }
+  return { answer: '', sources };
+}
+
+export function selectSearchBackend(env = process.env) {
+  const explicit = String(env.SEARCH_BACKEND || '').toLowerCase().trim();
+  if (explicit === 'agent') return { kind: 'agent' };
+  if (explicit === 'tavily' && env.TAVILY_API_KEY) return { kind: 'tavily', apiKey: env.TAVILY_API_KEY };
+  if (explicit === 'brave' && (env.BRAVE_SEARCH_API_KEY || env.BRAVE_API_KEY)) {
+    return { kind: 'brave', apiKey: env.BRAVE_SEARCH_API_KEY || env.BRAVE_API_KEY };
+  }
+  if (explicit === 'searxng' && env.SEARXNG_URL) return { kind: 'searxng', baseUrl: env.SEARXNG_URL };
+  if (env.TAVILY_API_KEY) return { kind: 'tavily', apiKey: env.TAVILY_API_KEY };
+  const braveKey = env.BRAVE_SEARCH_API_KEY || env.BRAVE_API_KEY;
+  if (braveKey) return { kind: 'brave', apiKey: braveKey };
+  if (env.SEARXNG_URL) return { kind: 'searxng', baseUrl: env.SEARXNG_URL };
+  if (/^1|true|yes|on$/i.test(String(env.SEARCH_BACKEND_AGENT_FALLBACK || ''))) return { kind: 'agent' };
+  return { kind: 'none' };
+}
+
+export async function performSearch(query, { env = process.env, fetchImpl = globalThis.fetch, signal, maxResults = 5 } = {}) {
+  if (!fetchImpl) throw new Error('fetch is not available');
+  const backend = selectSearchBackend(env);
+  if (backend.kind === 'tavily') return tavilySearch(query, { apiKey: backend.apiKey, fetchImpl, signal, maxResults });
+  if (backend.kind === 'brave') return braveSearch(query, { apiKey: backend.apiKey, fetchImpl, signal, maxResults });
+  if (backend.kind === 'searxng') return searxngSearch(query, { baseUrl: backend.baseUrl, fetchImpl, signal, maxResults });
+  if (backend.kind === 'agent') throw new Error('agent_delegated');
+  throw new Error('no_search_backend');
+}
+
+export function buildSynthesisPrompt({ query, sources, language = 'en' }) {
+  const en = /^en/i.test(String(language || ''));
+  const lines = [];
+  lines.push(en ? `You are summarizing web research for a voice answer. Be concise: 3 bullets total, each a single complete sentence, no markdown, no URLs in the spoken text.` : `웹 리서치 결과를 음성 답변용으로 요약해줘. 마크다운 없이 3개 불릿, 각 한 문장으로, 음성에는 URL 넣지 마.`);
+  lines.push(en ? `Query: ${query}` : `질문: ${query}`);
+  lines.push(en ? `Sources (numbered for your reference, do not read numbers aloud):` : `참고 자료 (번호는 참고용, 음성으로 읽지 마):`);
+  sources.slice(0, 5).forEach((s, i) => {
+    lines.push(`[${i + 1}] ${s.title} — ${s.snippet.replace(/\s+/g, ' ').slice(0, 240)}`);
+  });
+  lines.push(en
+    ? `Output exactly three bullet lines starting with "- ". Then a blank line. Then "SOURCES:" followed by each source on its own line as "[n] title".`
+    : `정확히 세 줄의 "- "로 시작하는 불릿을 출력해. 빈 줄 하나 후 "SOURCES:" 와 함께 각 자료를 "[n] 제목" 형식으로 한 줄씩.`);
+  return lines.join('\n');
+}
+
+export function parseSynthesisOutput(text) {
+  const t = String(text || '').replace(/\r/g, '');
+  const sourcesIdx = t.search(/^SOURCES:/m);
+  const head = sourcesIdx >= 0 ? t.slice(0, sourcesIdx) : t;
+  const tail = sourcesIdx >= 0 ? t.slice(sourcesIdx) : '';
+  const bullets = head.split(/\n/).map(l => l.trim()).filter(l => /^[-•]\s+/.test(l)).map(l => l.replace(/^[-•]\s+/, '').trim()).filter(Boolean).slice(0, 3);
+  const sourcesText = tail.replace(/^SOURCES:\s*/m, '').trim();
+  const sourceLines = sourcesText.split(/\n/).map(l => l.trim()).filter(Boolean);
+  return { bullets, sourceLines };
+}
+
+export function renderResearchSpeech(bullets, language = 'en') {
+  if (!bullets || !bullets.length) {
+    return /^en/i.test(String(language || ''))
+      ? 'Research finding: I could not find useful sources for that query.'
+      : '리서치 결과: 쓸 만한 자료를 찾지 못했어.';
+  }
+  const en = /^en/i.test(String(language || ''));
+  const intro = en ? 'Research finding: here is what I found.' : '리서치 결과: 찾은 내용 정리할게.';
+  return [intro, ...bullets].join(' ');
+}
+
+export function buildResearchEmbed({ query, bullets, sources, language = 'en' } = {}) {
+  const en = /^en/i.test(String(language || ''));
+  const description = (bullets || []).map(b => `• ${b}`).join('\n').slice(0, 4000) || (en ? '(no synthesis)' : '(요약 없음)');
+  const fields = (sources || []).slice(0, 5).map((s, i) => ({
+    name: `[${i + 1}] ${(s.title || 'source').slice(0, 240)}`,
+    value: (s.url || '').slice(0, 1000),
+    inline: false,
+  }));
+  return {
+    title: `${en ? '🔎 Research:' : '🔎 리서치:'} ${String(query || '').slice(0, 240)}`,
+    description,
+    color: 0x4F46E5,
+    fields,
+    footer: { text: en ? 'VerbalCoding research turn' : 'VerbalCoding 리서치 턴' },
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export function buildAgentDelegatedResearchPrompt({ query, language = 'en' } = {}) {
+  const en = /^en/i.test(String(language || ''));
+  const lines = [];
+  lines.push(en
+    ? 'You have web access. Research the topic below using your available tools (web_search, browser, fetch, etc.) and synthesize a voice-friendly answer.'
+    : '너는 웹에 접근할 수 있어. 아래 주제를 가용한 도구로 (web_search, browser, fetch 등) 리서치해서 음성용 답변으로 정리해줘.');
+  lines.push(en ? `Topic: ${query}` : `주제: ${query}`);
+  lines.push(en
+    ? 'Output format (strict):\n- Three bullet lines starting with "- ", each one complete sentence, no markdown inside the bullet, no URLs spoken.\n- One blank line.\n- "SOURCES:" header followed by up to 5 lines as "[n] Title | https://url"'
+    : '출력 형식 (엄수):\n- "- "로 시작하는 불릿 3개, 각 한 문장, 불릿 안에 마크다운/URL 금지.\n- 빈 줄 1개.\n- "SOURCES:" 헤더 후 최대 5줄, "[n] 제목 | https://url" 형식.');
+  lines.push(en ? 'Do not preface the answer with explanations or apologies. Just emit the bullets and SOURCES block.' : '답변에 설명이나 사과 문구 붙이지 마. 불릿과 SOURCES 블록만 출력.');
+  return lines.join('\n\n');
+}
+
+export function parseAgentDelegatedOutput(text) {
+  const t = String(text || '').replace(/\r/g, '');
+  const sourcesIdx = t.search(/^SOURCES:/m);
+  const head = sourcesIdx >= 0 ? t.slice(0, sourcesIdx) : t;
+  const tail = sourcesIdx >= 0 ? t.slice(sourcesIdx) : '';
+  const bullets = head.split(/\n/)
+    .map(l => l.trim())
+    .filter(l => /^[-•]\s+/.test(l))
+    .map(l => l.replace(/^[-•]\s+/, '').trim())
+    .filter(Boolean)
+    .slice(0, 3);
+  const sources = [];
+  const sourcesText = tail.replace(/^SOURCES:\s*/m, '');
+  for (const raw of sourcesText.split(/\n/)) {
+    const line = raw.trim();
+    if (!line) continue;
+    const m = line.match(/^\[\d+\]\s*(.+?)\s*(?:\||—|-)\s*(https?:\/\/\S+)/);
+    if (m) {
+      const url = ensureUrl(m[2]);
+      if (url) sources.push({ title: m[1].slice(0, 120), url, snippet: '' });
+      continue;
+    }
+    const urlMatch = line.match(/(https?:\/\/\S+)/);
+    if (urlMatch) {
+      const url = ensureUrl(urlMatch[1]);
+      if (url) sources.push({ title: line.replace(urlMatch[1], '').replace(/^\[\d+\]\s*/, '').replace(/[|—-]\s*$/, '').trim().slice(0, 120) || url, url, snippet: '' });
+    }
+  }
+  return { bullets, sources };
+}
+
+export function renderResearchMarkdown({ query, bullets, sources, language = 'en' }) {
+  const en = /^en/i.test(String(language || ''));
+  const lines = [];
+  lines.push(en ? `🔎 **Research:** ${query}` : `🔎 **리서치:** ${query}`);
+  if (bullets && bullets.length) {
+    lines.push('');
+    for (const b of bullets) lines.push(`- ${b}`);
+  }
+  if (sources && sources.length) {
+    lines.push('');
+    lines.push(en ? '**Sources**' : '**자료**');
+    sources.slice(0, 5).forEach((s, i) => lines.push(`${i + 1}. [${s.title || s.url}](${s.url})`));
+  }
+  return lines.join('\n');
+}
+
+export async function runResearchTurn({ query, language = 'en', env = process.env, fetchImpl = globalThis.fetch, signal, synthesize, maxResults = 5 } = {}) {
+  if (!query || typeof query !== 'string') throw new Error('query is required');
+  if (typeof synthesize !== 'function') throw new Error('synthesize callback is required');
+  let searchResult;
+  try {
+    searchResult = await performSearch(query, { env, fetchImpl, signal, maxResults });
+  } catch (e) {
+    if (e?.message === 'no_search_backend') {
+      return { status: 'no_backend', error: 'no_search_backend', query };
+    }
+    if (e?.message === 'agent_delegated') {
+      let agentOut;
+      try {
+        agentOut = await synthesize(buildAgentDelegatedResearchPrompt({ query, language }), { signal, task: true });
+      } catch (synthErr) {
+        return { status: 'synth_failed', error: synthErr?.message || String(synthErr), query, sources: [] };
+      }
+      const { bullets, sources } = parseAgentDelegatedOutput(agentOut);
+      if (!bullets.length && !sources.length) {
+        return {
+          status: 'empty',
+          query,
+          speech: renderResearchSpeech([], language),
+          markdown: renderResearchMarkdown({ query, bullets: [], sources: [], language }),
+        };
+      }
+      return {
+        status: 'ok',
+        query,
+        speech: renderResearchSpeech(bullets, language),
+        markdown: renderResearchMarkdown({ query, bullets, sources, language }),
+        embed: buildResearchEmbed({ query, bullets, sources, language }),
+        bullets,
+        sources,
+        backend: 'agent',
+      };
+    }
+    return { status: 'search_failed', error: e?.message || String(e), query };
+  }
+  if (!searchResult.sources.length) {
+    return { status: 'empty', query, speech: renderResearchSpeech([], language), markdown: renderResearchMarkdown({ query, bullets: [], sources: [], language }) };
+  }
+  const prompt = buildSynthesisPrompt({ query, sources: searchResult.sources, language });
+  let synthText;
+  try { synthText = await synthesize(prompt, { signal }); }
+  catch (e) { return { status: 'synth_failed', error: e?.message || String(e), query, sources: searchResult.sources }; }
+  const { bullets } = parseSynthesisOutput(synthText);
+  const useBullets = bullets.length ? bullets : (searchResult.answer ? [searchResult.answer] : []);
+  return {
+    status: 'ok',
+    query,
+    speech: renderResearchSpeech(useBullets, language),
+    markdown: renderResearchMarkdown({ query, bullets: useBullets, sources: searchResult.sources, language }),
+    embed: buildResearchEmbed({ query, bullets: useBullets, sources: searchResult.sources, language }),
+    bullets: useBullets,
+    sources: searchResult.sources,
+  };
+}

package/app-node/research_mode.test.mjs

@@ -0,0 +1,264 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  parseResearchCommand,
+  buildSynthesisPrompt,
+  parseSynthesisOutput,
+  renderResearchSpeech,
+  renderResearchMarkdown,
+  buildResearchEmbed,
+  runResearchTurn,
+  selectSearchBackend,
+  buildAgentDelegatedResearchPrompt,
+  parseAgentDelegatedOutput,
+} from './research_mode.mjs';
+
+test('parseResearchCommand picks up English "research X"', () => {
+  const c = parseResearchCommand('research the latest on STORM', 'en');
+  assert.equal(c.type, 'research');
+  assert.match(c.query, /STORM/);
+  assert.equal(c.depth, 'quick');
+});
+
+test('parseResearchCommand flags deep mode', () => {
+  const c = parseResearchCommand('deep research GraphRAG community detection', 'en');
+  assert.equal(c.type, 'research');
+  assert.equal(c.depth, 'deep');
+});
+
+test('parseResearchCommand recognizes Korean phrasing', () => {
+  const c = parseResearchCommand('Mem0 한번 리서치해줘', 'ko');
+  assert.equal(c.type, 'research');
+  assert.match(c.query, /Mem0/);
+});
+
+test('parseResearchCommand returns none for unrelated input', () => {
+  assert.equal(parseResearchCommand('write a unit test for parseDecisionAnswer', 'en').type, 'none');
+  assert.equal(parseResearchCommand('hi how are you', 'en').type, 'none');
+});
+
+test('parseResearchCommand does not hijack coding utterances containing the word "research"', () => {
+  assert.equal(parseResearchCommand('implement research mode', 'en').type, 'none');
+  assert.equal(parseResearchCommand('fix the research_mode regex', 'en').type, 'none');
+  assert.equal(parseResearchCommand('add docs about research turn', 'en').type, 'none');
+  assert.equal(parseResearchCommand('리서치 모드 코드 좀 봐', 'ko').type, 'none');
+  assert.equal(parseResearchCommand('리서치 코드 리팩토링해줘', 'ko').type, 'none');
+});
+
+test('parseResearchCommand still triggers on agent-routed forms', () => {
+  const c = parseResearchCommand('ask codex to research Node.js streams', 'en');
+  assert.equal(c.type, 'research');
+  assert.equal(c.query, 'Node.js streams');
+});
+
+test('parseResearchCommand preserves internal punctuation in technical queries', () => {
+  const cases = [
+    ['research Node.js streams', 'Node.js streams'],
+    ['look up GPT-4.1 vs Claude 4.7', 'GPT-4.1 vs Claude 4.7'],
+    ['research https://example.com/foo?bar=1', 'https://example.com/foo?bar=1'],
+    ['research what is 1.5 vs 2.0', 'what is 1.5 vs 2.0'],
+  ];
+  for (const [input, expected] of cases) {
+    const c = parseResearchCommand(input, 'en');
+    assert.equal(c.type, 'research', `failed parse for ${input}`);
+    assert.equal(c.query, expected, `expected '${expected}' from '${input}', got '${c.query}'`);
+  }
+});
+
+test('parseResearchCommand strips only trailing sentence punctuation', () => {
+  const c = parseResearchCommand('research Node.js streams.', 'en');
+  assert.equal(c.query, 'Node.js streams');
+  const q = parseResearchCommand('research GPT-4.1?', 'en');
+  assert.equal(q.query, 'GPT-4.1');
+});
+
+test('buildSynthesisPrompt embeds query and sources', () => {
+  const p = buildSynthesisPrompt({
+    query: 'STORM autoresearch',
+    sources: [{ title: 'STORM paper', url: 'https://arxiv.org/abs/2402.14207', snippet: 'Wikipedia-style writing' }],
+    language: 'en',
+  });
+  assert.match(p, /STORM autoresearch/);
+  assert.match(p, /\[1\] STORM paper/);
+});
+
+test('parseSynthesisOutput extracts bullets and sources block', () => {
+  const text = [
+    '- STORM uses perspective-grounded Q&A to draft long-form articles.',
+    '- It outperforms naive RAG on outline organization metrics.',
+    '- Known failure mode is over-association of unrelated facts.',
+    '',
+    'SOURCES:',
+    '[1] STORM paper',
+    '[2] STORM repo',
+  ].join('\n');
+  const { bullets, sourceLines } = parseSynthesisOutput(text);
+  assert.equal(bullets.length, 3);
+  assert.equal(sourceLines.length, 2);
+  assert.match(bullets[0], /STORM uses/);
+});
+
+test('renderResearchSpeech joins intro plus bullets and tags with prefix', () => {
+  const speech = renderResearchSpeech(['A.', 'B.', 'C.'], 'en');
+  assert.match(speech, /^Research finding:/);
+  assert.match(speech, /A\./);
+});
+
+test('renderResearchSpeech uses Korean prefix for ko', () => {
+  const speech = renderResearchSpeech(['ㄱ.', 'ㄴ.', 'ㄷ.'], 'ko');
+  assert.match(speech, /^리서치 결과:/);
+});
+
+test('renderResearchMarkdown numbers sources', () => {
+  const md = renderResearchMarkdown({
+    query: 'GraphRAG',
+    bullets: ['one'],
+    sources: [{ title: 'MS GraphRAG', url: 'https://example.com/g' }],
+    language: 'en',
+  });
+  assert.match(md, /1\. \[MS GraphRAG\]\(https:\/\/example\.com\/g\)/);
+});
+
+test('runResearchTurn happy path with mocked fetch and synth', async () => {
+  const env = { TAVILY_API_KEY: 'fake' };
+  const fetchImpl = async () => ({
+    ok: true,
+    json: async () => ({
+      answer: '',
+      results: [
+        { title: 'STORM Stanford', url: 'https://arxiv.org/abs/2402.14207', content: 'Wikipedia-style article generation.' },
+        { title: 'STORM Repo', url: 'https://github.com/stanford-oval/storm', content: 'Open-source implementation.' },
+      ],
+    }),
+  });
+  const synthesize = async () => '- STORM is a Wikipedia-style article writer.\n- Uses perspective-grounded Q&A.\n- Self-hostable and MIT-licensed.\n\nSOURCES:\n[1] STORM Stanford\n[2] STORM Repo';
+  const result = await runResearchTurn({ query: 'STORM autoresearch', env, fetchImpl, synthesize, language: 'en' });
+  assert.equal(result.status, 'ok');
+  assert.equal(result.bullets.length, 3);
+  assert.equal(result.sources.length, 2);
+  assert.match(result.speech, /STORM is a Wikipedia-style/);
+  assert.match(result.markdown, /arxiv\.org/);
+});
+
+test('runResearchTurn reports no_backend when both keys missing', async () => {
+  const result = await runResearchTurn({ query: 'x', env: {}, fetchImpl: async () => {}, synthesize: async () => '' });
+  assert.equal(result.status, 'no_backend');
+});
+
+test('buildResearchEmbed numbers source fields', () => {
+  const embed = buildResearchEmbed({
+    query: 'GraphRAG',
+    bullets: ['summary'],
+    sources: [
+      { title: 'MS GraphRAG', url: 'https://example.com/g' },
+      { title: 'LightRAG', url: 'https://example.com/l' },
+    ],
+    language: 'en',
+  });
+  assert.match(embed.title, /Research: GraphRAG/);
+  assert.equal(embed.fields.length, 2);
+  assert.match(embed.fields[0].name, /^\[1\] MS GraphRAG/);
+  assert.equal(embed.fields[1].value, 'https://example.com/l');
+});
+
+test('selectSearchBackend honors explicit SEARCH_BACKEND override', () => {
+  assert.equal(selectSearchBackend({ SEARCH_BACKEND: 'agent' }).kind, 'agent');
+  assert.equal(selectSearchBackend({ SEARCH_BACKEND: 'tavily', TAVILY_API_KEY: 'k' }).kind, 'tavily');
+  // explicit pick without matching key falls through to discovery order
+  assert.equal(selectSearchBackend({ SEARCH_BACKEND: 'brave' }).kind, 'none');
+  assert.equal(selectSearchBackend({ SEARCH_BACKEND: 'brave', TAVILY_API_KEY: 'k' }).kind, 'tavily');
+});
+
+test('selectSearchBackend default priority is tavily → brave → searxng → none', () => {
+  assert.equal(selectSearchBackend({}).kind, 'none');
+  assert.equal(selectSearchBackend({ SEARXNG_URL: 'http://localhost:8888' }).kind, 'searxng');
+  assert.equal(selectSearchBackend({ BRAVE_API_KEY: 'b', SEARXNG_URL: 'http://x' }).kind, 'brave');
+  assert.equal(selectSearchBackend({ TAVILY_API_KEY: 't', BRAVE_API_KEY: 'b' }).kind, 'tavily');
+});
+
+test('selectSearchBackend uses agent fallback opt-in when no key is present', () => {
+  assert.equal(selectSearchBackend({ SEARCH_BACKEND_AGENT_FALLBACK: '1' }).kind, 'agent');
+});
+
+test('runResearchTurn with SEARXNG_URL builds JSON request and synthesises bullets', async () => {
+  const env = { SEARXNG_URL: 'http://searx.local' };
+  const captured = [];
+  const fetchImpl = async (url) => {
+    captured.push(url);
+    return {
+      ok: true,
+      json: async () => ({
+        results: [
+          { title: 'LightRAG', url: 'https://arxiv.org/abs/2410.05779', content: 'LightRAG dual-level retrieval.' },
+          { title: 'HippoRAG', url: 'https://arxiv.org/abs/2405.14831', content: 'PPR-based memory.' },
+        ],
+      }),
+    };
+  };
+  const synthesize = async () => '- LightRAG is dual-level retrieval.\n- HippoRAG uses PPR.\n- GraphRAG uses Leiden clusters.\n\nSOURCES:\n[1] LightRAG\n[2] HippoRAG';
+  const result = await runResearchTurn({ query: 'GraphRAG family', env, fetchImpl, synthesize, language: 'en' });
+  assert.equal(result.status, 'ok');
+  assert.equal(result.sources.length, 2);
+  assert.equal(result.bullets.length, 3);
+  assert.match(captured[0], /searx\.local\/search\?.*q=GraphRAG/);
+  assert.match(captured[0], /format=json/);
+});
+
+test('runResearchTurn agent-delegated path skips performSearch and parses agent output', async () => {
+  const env = { SEARCH_BACKEND: 'agent' };
+  let fetchCalled = false;
+  const fetchImpl = async () => { fetchCalled = true; return { ok: false, json: async () => ({}) }; };
+  const synthCalls = [];
+  const synthesize = async (prompt, opts) => {
+    synthCalls.push({ prompt, opts });
+    return [
+      '- ACE evolves a per-project playbook that beats fine-tuning.',
+      '- It compounds across sessions without changing model weights.',
+      '- Open implementation available from the paper authors.',
+      '',
+      'SOURCES:',
+      '[1] ACE paper | https://arxiv.org/abs/2510.04618',
+      '[2] Project README | https://github.com/example/ace-repo',
+    ].join('\n');
+  };
+  const result = await runResearchTurn({ query: 'Agentic Context Engineering ACE', env, fetchImpl, synthesize, language: 'en' });
+  assert.equal(fetchCalled, false);
+  assert.equal(result.status, 'ok');
+  assert.equal(result.backend, 'agent');
+  assert.equal(result.bullets.length, 3);
+  assert.equal(result.sources.length, 2);
+  assert.equal(result.sources[0].url, 'https://arxiv.org/abs/2510.04618');
+  assert.equal(synthCalls[0].opts.task, true, 'agent-delegated synthesise call sets task=true for longer timeout');
+});
+
+test('parseAgentDelegatedOutput tolerates dash separators and missing brackets', () => {
+  const text = [
+    '- A.',
+    '- B.',
+    '- C.',
+    '',
+    'SOURCES:',
+    '[1] Foo paper — https://example.com/foo',
+    'Bar - https://example.com/bar',
+  ].join('\n');
+  const { bullets, sources } = parseAgentDelegatedOutput(text);
+  assert.equal(bullets.length, 3);
+  assert.equal(sources.length, 2);
+  assert.equal(sources[0].url, 'https://example.com/foo');
+  assert.equal(sources[1].url, 'https://example.com/bar');
+});
+
+test('buildAgentDelegatedResearchPrompt names the query and the strict format', () => {
+  const p = buildAgentDelegatedResearchPrompt({ query: 'STORM autoresearch', language: 'en' });
+  assert.match(p, /You have web access/);
+  assert.match(p, /STORM autoresearch/);
+  assert.match(p, /SOURCES:/);
+});
+
+test('runResearchTurn handles empty search gracefully', async () => {
+  const env = { TAVILY_API_KEY: 'fake' };
+  const fetchImpl = async () => ({ ok: true, json: async () => ({ results: [] }) });
+  const result = await runResearchTurn({ query: 'X', env, fetchImpl, synthesize: async () => '', language: 'en' });
+  assert.equal(result.status, 'empty');
+  assert.match(result.speech, /could not find/);
+});

package/app-node/restart_notice.mjs

@@ -15,6 +15,9 @@ export function cleanRestartDetail(detail = '', ttsVoice = '') {
       .trim();
   }
   return raw
+    .replace(/\bI applied this change:\s*/igu, '')
+    .replace(/\bRestarting now\b[.!?\s]*/igu, '')
+    .replace(/\bVoice may cut out briefly\b[.!?\s]*/igu, '')
     .replace(/이제\s*재시작할게[.!?。！？\s]*/gu, '')
     .replace(/잠깐\s*음성이\s*끊길\s*수\s*있어[.!?。！？\s]*/gu, '')
     .replace(/\s+/g, ' ')

package/app-node/restart_notice.test.mjs

@@ -35,3 +35,14 @@ test('restart detail strips restart boilerplate before formatting', () => {
     '재시작 완료. 다시 온라인이야. 에이전트 안내 고쳤어.',
   );
 });
+
+test('Korean restart detail strips stale English restart boilerplate', () => {
+  assert.equal(
+    cleanRestartDetail('I applied this change: OmniVoice 한국어 설정 반영. Restarting now. Voice may cut out briefly.', 'ko-KR-InJoonNeural'),
+    'OmniVoice 한국어 설정 반영.',
+  );
+  assert.equal(
+    formatRestartCompleteNotice('I applied this change: OmniVoice 한국어 설정 반영. Restarting now. Voice may cut out briefly.', 'ko-KR-InJoonNeural').speech,
+    '재시작 완료. 다시 온라인이야. OmniVoice 한국어 설정 반영.',
+  );
+});