elanous 0.2.9 → 0.2.10

package/skills/explainer-video/engine/stitch.mjs

@@ -0,0 +1,145 @@
+// Pre-render field cards once; render only the photo composition on subsequent runs.
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const W = 1080, H = 1920, FPS = 30, CARD_VERSION = 1;
+const cacheRoot = () => process.env.EXPLAINER_CACHE || join(homedir(), '.cache', 'elanous-explainer');
+const valid = (path) => { try { const stat = statSync(path); return stat.isFile() && stat.size > 0; } catch { return false; } };
+function run(bin, args, cwd) {
+  const result = spawnSync(bin, args, { cwd, encoding: 'utf8', maxBuffer: 4 * 1024 * 1024 });
+  if (result.error || result.status !== 0) throw new Error(`${bin}: ${result.error?.message ?? result.stderr?.slice(-2000) ?? `exit ${result.status}`}`);
+  return result.stdout;
+}
+
+async function renderCards({ title, sub, intro, end, cacheDir }) {
+  for (const [part, output] of [['intro', intro], ['end', end]]) {
+    if (valid(output)) continue;
+    const project = join(cacheDir, `project-${part}`);
+    mkdirSync(project, { recursive: true });
+    run('node', [join(here, 'reel.mjs'), project, '--part', part, '--title', title, '--sub', sub]);
+    run('npx', ['-y', `hyperframes@${process.env.HYPERFRAMES_VERSION || '0.8.95'}`, 'render', '--fps', String(FPS), '--workers', '4', '--output', output], join(project, 'reel', 'hf'));
+  }
+}
+
+export const normalizeCardTitle = (title) => !title || /^[a-z0-9]+(?:-[a-z0-9]+)*$/i.test(title) ? '현장 스케치' : title;
+
+function ownerGone(lock) {
+  let pid;
+  try { pid = JSON.parse(readFileSync(join(lock, 'owner.json'), 'utf8')).pid; }
+  catch (error) {
+    if (error.code !== 'ENOENT' && !(error instanceof SyntaxError)) throw error;
+    // A new owner may still be writing its identity. Never reclaim that window.
+    try { return Date.now() - statSync(lock).mtimeMs > 5_000; } catch { return false; }
+  }
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  try { process.kill(pid, 0); return false; }
+  catch (error) { return error.code === 'ESRCH'; }
+}
+
+// A single reaper checks identity again under this claim before moving an orphan.
+function recoverLock(lock) {
+  const recovery = `${lock}.recovery`;
+  try { mkdirSync(recovery); }
+  catch (error) {
+    if (error.code !== 'EEXIST') throw error;
+    if (ownerGone(recovery)) rmSync(recovery, { recursive: true, force: true });
+    return;
+  }
+  try {
+    writeFileSync(join(recovery, 'owner.json'), JSON.stringify({ pid: process.pid }));
+    if (!ownerGone(lock)) return;
+    const abandoned = `${lock}.abandoned-${randomUUID()}`;
+    try { renameSync(lock, abandoned); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; return; }
+    rmSync(abandoned, { recursive: true, force: true });
+  } finally { rmSync(recovery, { recursive: true, force: true }); }
+}
+
+export async function ensureCards({ title, sub, cacheDir = join(cacheRoot(), 'cards'), render = renderCards }) {
+  title = normalizeCardTitle(title);
+  const key = createHash('sha256').update(JSON.stringify([title, sub, W, H, CARD_VERSION])).digest('hex').slice(0, 16);
+  const dir = join(cacheDir, key);
+  const intro = join(dir, 'intro.mp4'), end = join(dir, 'end.mp4');
+  const ready = () => valid(intro) && valid(end);
+  if (ready()) return { intro, end, cardsCache: 'hit' };
+  mkdirSync(cacheDir, { recursive: true });
+  const lock = `${dir}.lock`;
+  const deadline = Date.now() + 10 * 60_000;
+  for (;;) {
+    try {
+      mkdirSync(lock);
+      try { writeFileSync(join(lock, 'owner.json'), JSON.stringify({ pid: process.pid })); }
+      catch (error) { rmSync(lock, { recursive: true, force: true }); throw error; }
+      break;
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      if (ready()) return { intro, end, cardsCache: 'hit' };
+      recoverLock(lock);
+      if (Date.now() >= deadline) throw new Error(`timed out waiting for card render: ${lock}`);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  let staging;
+  try {
+    if (ready()) return { intro, end, cardsCache: 'hit' };
+    staging = mkdtempSync(join(cacheDir, `.${key}-`));
+    await render({ title, sub, intro: join(staging, 'intro.mp4'), end: join(staging, 'end.mp4'), cacheDir: staging });
+    if (!valid(join(staging, 'intro.mp4')) || !valid(join(staging, 'end.mp4'))) throw new Error(`card renderer did not produce both cards: ${dir}`);
+    rmSync(dir, { recursive: true, force: true });
+    renameSync(staging, dir);
+    return { intro, end, cardsCache: 'miss' };
+  } finally {
+    if (staging) rmSync(staging, { recursive: true, force: true });
+    rmSync(lock, { recursive: true, force: true });
+  }
+}
+
+function duration(file) {
+  const seconds = Number(run('ffprobe', ['-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', file]).trim());
+  if (!Number.isFinite(seconds) || seconds <= 0) throw new Error(`invalid duration: ${file}`);
+  return seconds;
+}
+
+export function stitch({ intro, body, end, bgm, out }) {
+  const first = duration(intro), middle = duration(body), last = duration(end);
+  if (Math.min(first, middle, last) <= 0.3) throw new Error('xfade requires clips longer than 0.3s');
+  const total = first + middle + last - 0.6;
+  const args = ['-v', 'error', '-y', '-i', intro, '-i', body, '-i', end];
+  const music = bgm && existsSync(bgm);
+  if (music) args.push('-stream_loop', '-1', '-i', bgm);
+  const filters = [
+    ...[0, 1, 2].map((i) => `[${i}:v]fps=${FPS},scale=${W}:${H},setsar=1,format=yuv420p,settb=AVTB,setpts=PTS-STARTPTS[v${i}]`),
+    `[v0][v1]xfade=transition=fade:duration=0.3:offset=${(first - 0.3).toFixed(3)}[v01]`,
+    `[v01][v2]xfade=transition=fade:duration=0.3:offset=${(first + middle - 0.6).toFixed(3)}[v]`,
+  ];
+  if (music) filters.push(`[3:a]atrim=duration=${total.toFixed(3)},asetpts=PTS-STARTPTS,afade=t=in:d=0.4,afade=t=out:st=${Math.max(0, total - 1.6).toFixed(3)}:d=1.6,loudnorm=I=-16:TP=-1.5:LRA=9[a]`);
+  else filters.push(`anullsrc=r=48000:cl=stereo,atrim=duration=${total.toFixed(3)}[a]`);
+  mkdirSync(dirname(out), { recursive: true });
+  run('ffmpeg', [...args, '-filter_complex', filters.join(';'), '-map', '[v]', '-map', '[a]', '-t', total.toFixed(3), '-r', String(FPS), '-c:v', 'libx264', '-preset', 'veryfast', '-pix_fmt', 'yuv420p', '-c:a', 'aac', '-ar', '48000', '-ac', '2', '-movflags', '+faststart', out]);
+  return out;
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const args = process.argv.slice(2);
+  const value = (name) => { const i = args.indexOf(name); return i < 0 ? undefined : args[i + 1]; };
+  const folder = args[1] && resolve(args[1]);
+  if (args[0] === '--warm-cards') {
+    const title = value('--title'), sub = value('--sub');
+    if (title === undefined || sub === undefined) throw new Error('--warm-cards requires --title and --sub');
+    const cards = await ensureCards({ title, sub });
+    console.log(`reel: cards ${cards.cardsCache} · ${dirname(cards.intro)}`);
+  } else if (args[0] === '--instant' && folder) {
+    const timelineFile = join(folder, 'reel', 'timeline.json');
+    const timeline = JSON.parse(readFileSync(timelineFile, 'utf8'));
+    const cards = await ensureCards({ title: timeline.title, sub: timeline.sub });
+    const bgm = process.env.FIELD_REEL_BGM || join(cacheRoot(), 'bgm', 'field.wav');
+    stitch({ intro: cards.intro, body: join(folder, 'reel', 'body.mp4'), end: cards.end, bgm, out: join(folder, 'reel', 'reel-9x16.mp4') });
+    writeFileSync(timelineFile, JSON.stringify({ ...timeline, cardsCache: cards.cardsCache, music: existsSync(bgm) }, null, 2));
+    console.log(`reel: cards ${cards.cardsCache}`);
+  } else throw new Error('usage: stitch.mjs --warm-cards --title … --sub … | --instant <folder>');
+}

package/skills/pitch-deck/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: pitch-deck
+description: "회사나 제품의 한국어 피치덱·투자 소개 슬라이드를 사실 출처와 함께 만들 때 사용한다. 피치덱, 발표 덱, pitch deck 요청에 대응한다."
+category: knowledge
+sideEffects: write
+triggers:
+  - 피치덱
+  - pitch deck
+requires: []
+---
+
+# Pitch deck — 근거를 지닌 짧은 발표
+
+## 언제 / 입력
+
+회사 또는 제품을 5~10분에 소개할 때 쓴다. 입력은 **회사 한 줄 정의**, 저장소의 **사실 원천 파일들**(읽은 판본과 줄 위치), **발표 길이**다. 독자·구매자·공개 가능 범위를 먼저 정한다. 확인되지 않은 값은 매출·고객·시장 실적처럼 말하지 않는다.
+
+## 장 구성
+
+기본 뼈대 **일곱**: **정의**(한 줄로 무엇을 하나) → **문제**(누가 왜 멈추나) → **시장**(TAM·SAM·SOM, 출처 없으면 가정) → **기술/BM**(해결법·경쟁력·BM·누가 지불하나) → **성과**(검증된 사례·측정 또는 «아직 검증 전») → **성장 전략**(어떤 순서로 누구에게 닿나) → **팀**(누가 실행하나). **계획**은 기본 일곱과 *별도 마지막 장*: 제목·표지에 «계획 · 순서와 시기는 바뀔 수 있습니다»를 쓰고 월 단위 약속은 쓰지 않는다. 발표 길이에 맞게 기본 장 하나를 둘로 나누거나 오프닝을 더해 최종 8~12장으로 만든다.
+
+첫 장은 **3초 안에 뜻이 전해지는 쉬운 한 줄**, 전문 용어 0. 다음 장에는 **실물 증거**를 둔다: 실제 화면의 자리와 시연할 행동을 명시하고, 이미지가 없으면 «화면 자리»라고 표기한다. 화면·시연은 검증 전이면 «계획»으로 구분하며 이미 된 일로 그리지 않는다. 사이트와 데모 대본의 메시지 순서(약속 → 증거 → 작동 원리 → 다음 행동)를 따른다. 설득 문장은 빠르고 쉬워도 기술적 아우라는 검증 가능한 실물로 뒷받침한다. 남의 이름·제휴 암시·«곧»·미측정 성과는 넣지 않는다.
+
+각 장: **한 장 한 메시지**, 제목은 명사 나열이 아니라 **주장 문장**. 본문·제목을 합쳐 **공백 기준 45낱말 이하**(출처 ID·진행표시·접근성 라벨 제외). 넘치면 장을 나누고 핵심을 고른다. 수치·날짜·비율은 읽은 파일의 **파일:줄** 또는 공개 링크를 SOURCES의 개별 주장과 짝짓는다. 출처가 없는 시장 규모·추정 TAM/SAM/SOM은 장에 **«가정»** 표시하고 SOURCES의 가정 목록에도 적는다. 근거가 없으면 수치를 만들지 말고 측정 방법을 제시한다. 고객·매출·계약·기술 성숙도를 과장하지 않는다.
+
+### 누구에게 파나 — ECP / ICP
+
+ECP(early customer profile)의 **시급한 문제·사건/구매 트리거·현재 우회 비용·도입 준비**를 묻고, ICP(ideal customer profile)의 **조직/업종·규모·구매자·사용자·의사결정 권한·도입 제약**을 적는다. 시장 장에서는 ECP → ICP → 접근 가능한 구매자(SOM) 순서로 좁힌다. 기술/BM 장에는 구매자와 사용자, 값이 생기는 순간, 과금 가설을 서로 구분한다. 인터뷰 전인 칸은 «가정»이라고 쓰며 공개되지 않은 연락처·고객사 내부 수치를 옮기지 않는다.
+
+## 작성 · 출력
+
+1. 참고본은 `.eml`의 본문·첨부를 파싱해 **슬라이드 구조만**, docx/xlsx에서는 **칸 이름만** 참고한다. 참고본의 사람 이름·연락처·주소·내부 수치·원문 문구는 전재하지 않는다. 저장소의 브랜드 정본과 공개 가능한 기능 근거를 읽고 계획을 현재 성과로 바꾸지 않는다.
+2. `template.html`의 CSS·JS를 각 덱 HTML에 **인라인 복사**하고 `<section class="slide" data-claim="…">`마다 하나의 메시지를 넣는다. 파일 밖 폰트·이미지·스크립트 의존성 없이 로컬 파일로 직접 연다. 제목의 주장 ID마다 SOURCES 표에 **같은 ID**, 출처와 그 줄에서 확인할 내용, 상태(사실/가정/계획)를 기록한다. 숫자 하나라도 별도 근거가 필요하면 같은 행에서 항목별로 대응한다.
+3. 출력은 **한 파일 HTML 덱**, 키보드 방향키/스페이스로 넘김(화면 버튼도 제공), 16:9, 인쇄하면 한 쪽 한 장. 버튼·입력 요소에 초점이 있을 때는 슬라이드 단축키를 건너뛰어 기본 키보드 조작(«이전» 버튼에서 스페이스)을 보존한다. 인쇄 미리보기·첫/끝 넘김·숫자/개인 연락처를 확인한다. 디자인 시스템을 새로 만들지 않고 `내부 문서 `BRAND-CANON-elanvital-and-elanous-2026-09-30``의 색·서체 사용 기준을 따른다.
+
+기존 연결: `src/skills/index.ts`의 `buildSkillIndex` → `listSkillNames`/`parseSkillMd`가 이 폴더의 SKILL.md를 발견한다. 덱은 스킬이 작성해 직접 여는 **독립 문서**이며 HTML을 위한 신규 런타임 라우트는 만들지 않는다.

package/skills/pitch-deck/template.html

@@ -0,0 +1,80 @@
+<!doctype html>
+<html lang="ko">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>피치덱 — 회사명</title>
+<style>
+  :root { color-scheme: dark; font-family: Geist, "G sans", "Noto Sans KR", system-ui, sans-serif; background: #0c0c0e; color: #f2f1ee; }
+  * { box-sizing: border-box; }
+  body { margin: 0; }
+  main { min-height: 100svh; display: grid; place-items: center; padding: 4rem 1rem; }
+  .slide { display: none; width: min(100%, calc((100svh - 8rem) * 16 / 9)); aspect-ratio: 16 / 9; padding: clamp(1.4rem, 5vw, 5rem); background: #0c0c0e; border: 1px solid #f2f1ee; flex-direction: column; justify-content: space-between; overflow: hidden; }
+  .slide.active { display: flex; }
+  .eyebrow, .marker { color: #e95047; font-size: clamp(.8rem, 1.3vw, 1rem); font-weight: 650; letter-spacing: .08em; }
+  h1, h2 { max-width: 20ch; font-size: clamp(2rem, 4.4vw, 4.9rem); line-height: 1.15; letter-spacing: -.045em; margin: .4em 0; text-wrap: balance; }
+  p, li { max-width: 54ch; font-size: clamp(1rem, 1.7vw, 1.6rem); line-height: 1.55; }
+  ul { padding-left: 1.2em; }
+  .accent { color: #e95047; }
+  .screen-slot { border: 1px dashed #e95047; padding: .6rem 1rem; color: #f2f1ee; font-size: clamp(.9rem, 1.4vw, 1.2rem); }
+  .foot { display: flex; justify-content: space-between; align-items: end; gap: 1rem; color: #f2f1ee; font-size: .85rem; }
+  nav { position: fixed; bottom: 1rem; right: 1rem; display: flex; align-items: center; gap: .7rem; background: #0c0c0e; padding: .4rem; }
+  button { background: #0c0c0e; color: #f2f1ee; border: 1px solid #e95047; padding: .6rem .9rem; font: inherit; cursor: pointer; }
+  button:focus-visible { outline: 3px solid #e95047; outline-offset: 3px; }
+  button:disabled { opacity: .42; cursor: not-allowed; }
+  @media print {
+    @page { size: 16in 9in; margin: 0; }
+    body { width: 16in; }
+    :root { print-color-adjust: exact; -webkit-print-color-adjust: exact; }
+    main { display: block; padding: 0; min-height: 0; }
+    .slide, .slide.active { display: flex; width: 16in; height: 9in; aspect-ratio: auto; border: 0; break-after: page; page-break-after: always; }
+    .slide:last-child { break-after: auto; page-break-after: auto; }
+    nav { display: none; }
+  }
+</style>
+</head>
+<body>
+<main id="deck" aria-label="피치덱">
+  <section class="slide active" data-claim="T1" aria-label="정의" aria-hidden="false">
+    <span class="eyebrow">브랜드 · 정의</span>
+    <div><h1>한 줄로 무엇을 하는지 말합니다.</h1><p>검증 가능한 회사 한 줄 정의를 여기에 넣습니다.</p></div>
+    <div class="foot"><span>출처: SOURCES · T1</span><span class="marker">회사명</span></div>
+  </section>
+  <section class="slide" data-claim="T2" aria-label="계획" aria-hidden="true">
+    <span class="eyebrow">계획 · 순서와 시기는 바뀔 수 있습니다</span>
+    <div><h2>다음 걸음은 검증하며 정합니다.</h2><p>이 칸은 현재 제공 기능이 아니라 앞으로의 계획입니다.</p></div>
+    <div class="foot"><span>출처: SOURCES · T2</span><span class="marker">계획</span></div>
+  </section>
+</main>
+<nav aria-label="슬라이드 이동"><button id="prev" type="button" aria-label="이전 장">← 이전</button><output id="position" aria-live="polite"></output><button id="next" type="button" aria-label="다음 장">다음 →</button></nav>
+<script>
+(() => {
+  const slides = [...document.querySelectorAll('section.slide')];
+  const prev = document.getElementById('prev');
+  const next = document.getElementById('next');
+  const position = document.getElementById('position');
+  let current = 0;
+  function show(index) {
+    current = Math.max(0, Math.min(slides.length - 1, index));
+    slides.forEach((slide, i) => {
+      slide.classList.toggle('active', i === current);
+      slide.setAttribute('aria-hidden', String(i !== current));
+    });
+    prev.disabled = current === 0;
+    next.disabled = current === slides.length - 1;
+    position.textContent = `${current + 1} / ${slides.length}`;
+  }
+  prev.addEventListener('click', () => show(current - 1));
+  next.addEventListener('click', () => show(current + 1));
+  document.addEventListener('keydown', event => {
+    if (event.target instanceof Element && event.target.closest('button, a, input, textarea, select, [contenteditable="true"]')) return;
+    if (['ArrowRight', 'ArrowDown', ' ', 'PageDown'].includes(event.key)) { event.preventDefault(); show(current + 1); }
+    if (['ArrowLeft', 'ArrowUp', 'PageUp'].includes(event.key)) { event.preventDefault(); show(current - 1); }
+    if (event.key === 'Home') show(0);
+    if (event.key === 'End') show(slides.length - 1);
+  });
+  show(0);
+})();
+</script>
+</body>
+</html>

package/src/acp/codex-approval-adapter.ts

@@ -103,6 +103,12 @@ export interface CodexApprovalAdapter {
   onMcpToolCall(req: CodexMcpToolCallRequest): Promise<CodexApprovalDecision>;
 }
 
+/** The 3-way approval question's id and labels — exported so a surface that
+ *  answers approvals by yes/no (an ACP turn's client) can recognise it. */
+export const CODEX_APPROVAL_QUESTION_ID = 'codex_approval';
+export const CODEX_APPROVAL_OPT_ONCE = 'Allow once';
+export const CODEX_APPROVAL_OPT_REJECT = 'Reject';
+
 /** Build a CodexApprovalAdapter. Intentionally minimal in Phase 3.A —
  *  the handlers degrade gracefully when no approver is attached, and
  *  the Phase 3.B app-server client will hook these methods up with real
@@ -131,10 +137,10 @@ export function createCodexApprovalAdapter(
   // multi-option question path is used. "Allow for session" maps to codex
   // `acceptForSession` so the sub-agent stops re-prompting for the rest of
   // the run.
-  const OPT_ONCE = 'Allow once';
+  const OPT_ONCE = CODEX_APPROVAL_OPT_ONCE;
   const OPT_SESSION = 'Allow for session';
-  const OPT_REJECT = 'Reject';
-  const APPROVAL_QID = 'codex_approval';
+  const OPT_REJECT = CODEX_APPROVAL_OPT_REJECT;
+  const APPROVAL_QID = CODEX_APPROVAL_QUESTION_ID;
 
   /** Ask the user via the MULTI-OPTION question channel: Allow once /
    *  Allow for session / Reject. Returns the scoped decision. Only called

package/src/acp/core-turn-bridge.ts

@@ -46,7 +46,11 @@ import { getUserConfig } from '../user-config.js';
 import { getModelFamily } from '../models/prompts.js';
 import { resolveModelContextWindow } from '../models/context-window.js';
 import type { AcpServerOptions, AcpTurnContext } from './server.js';
+import { acpToolDenialResult } from './tool-approval.js';
 import { readOriginSessionMeta } from './origin-session-meta.js';
+import { isFactQuestion } from './fact-question.js';
+
+const FACT_QUESTION_INSTRUCTION = '사실·최신 정보 질문이다. WebSearch 를 1~2회 쓰고 검색 결과(제목·스니펫·URL)로 답하라. 출처 링크를 붙여라. 셸·브라우저·파일 도구는 검색 결과로 부족할 때만. 도구 예산에 닿으면 지금까지 근거로 답하고 끝에 «더 찾아볼까요?»를 붙여라.';
 
 export interface CoreTurnBridgeDeps {
   /** Build the seed message list for this ACP prompt. Implementations
@@ -112,6 +116,28 @@ export interface CoreTurnBridgeDeps {
  *  pegging the event loop. */
 export const DEFAULT_BRIDGE_ABORT_POLL_MS = 50;
 
+/** PCH-2b — ask the ACP client before a write/shell tool runs. A denied,
+ *  cancelled or timed-out tool is not run; the LLM gets a «not run» result. */
+export function acpApprovalGatedDispatch(
+  turnCtx: AcpTurnContext,
+  dispatchTool: CoreTurnDispatchTool,
+  signal: AbortSignal,
+): CoreTurnDispatchTool {
+  const approveTool = turnCtx.approveTool;
+  if (!approveTool) return dispatchTool;
+  return async (name, args, dispatchCtx) => {
+    if (signal.aborted || turnCtx.isAborted()) return acpToolDenialResult(name, 'cancelled');
+    const approval = await approveTool({
+      toolCallId: dispatchCtx?.callId ?? `${name}-${Date.now().toString(36)}`,
+      toolName: name,
+      toolArgs: args,
+    });
+    if (!approval.allowed) return acpToolDenialResult(name, approval.reason);
+    if (signal.aborted || turnCtx.isAborted()) return acpToolDenialResult(name, 'cancelled');
+    return dispatchTool(name, args, dispatchCtx);
+  };
+}
+
 /** Extract the trailing assistant message text from runCoreTurn's
  *  `newMessages` array. emitTurnComplete (src/llm.ts:3835) appends
  *  `{role:'assistant', content:[{type:'text', text:finalAssistantText}]}`
@@ -173,7 +199,23 @@ export function bridgeCoreTurnToAcp(
         }),
       );
       const modelOverride = deps.resolveModel?.({ sessionId: turnCtx.sessionId, userText: turnCtx.userText });
-      const maxToolTurns = deps.resolveMaxToolTurns?.({ sessionId: turnCtx.sessionId });
+      const factQuestion = isFactQuestion(turnCtx.userText);
+      const explicitMaxToolTurns = deps.resolveMaxToolTurns?.({ sessionId: turnCtx.sessionId });
+      const maxToolTurns = explicitMaxToolTurns ?? (factQuestion ? getUserConfig().chat.factQuestion.maxToolTurns : undefined);
+      const turnMessages: LLMMessage[] = factQuestion
+        ? [{ role: 'system', content: FACT_QUESTION_INSTRUCTION }, ...messages]
+        : messages;
+      let toolCallCount = 0;
+      const toolKinds = new Set<string>();
+      const observeToolBudget = () => {
+        try {
+          debug.log('chat.turn', 'tool-budget', {
+            factQuestion, maxToolTurns: maxToolTurns ?? null,
+            count: toolCallCount, kinds: [...toolKinds],
+          });
+        } catch { /* observation cannot interrupt a turn */ }
+      };
+      observeToolBudget();
 
       // 2026-05-03 PM++ — Track streamed text so onTurnComplete can
       // detect runtime-injected synthesis (W5-E/W5-F/W5-G) and surface
@@ -235,17 +277,29 @@ export function bridgeCoreTurnToAcp(
       } catch {
         // Observability must not prevent the turn from reaching its dispatcher.
       }
+      const approvedDispatch = acpApprovalGatedDispatch(turnCtx, deps.dispatchTool, ctrl.signal);
+      const dispatchTool: CoreTurnDispatchTool = factQuestion && maxToolTurns !== undefined && maxToolTurns > 0
+        ? async (name, args, dispatchCtx) => {
+            if (toolCallCount >= maxToolTurns) {
+              return { error: 'Tool budget reached. Answer using the evidence already collected.' };
+            }
+            toolCallCount += 1;
+            toolKinds.add(name);
+            observeToolBudget();
+            return approvedDispatch(name, args, dispatchCtx);
+          }
+        : approvedDispatch;
       await runTurnDispatch({
         sessionId: turnCtx.sessionId,
         ...(originSessionId ? { originSessionId } : {}),
         ...(turnCtx.userText ? { userText: turnCtx.userText } : {}),
-        messages,
+        messages: turnMessages,
         tools,
-        dispatchTool: deps.dispatchTool,
+        dispatchTool,
         signal: ctrl.signal,
         ...(modelOverride !== undefined ? { modelOverride } : {}),
         ...(maxToolTurns !== undefined ? { maxToolTurns } : {}),
-        ...(deps.budgetGrant !== undefined ? { budgetGrant: deps.budgetGrant } : {}),
+        ...((!factQuestion || explicitMaxToolTurns !== undefined) && deps.budgetGrant !== undefined ? { budgetGrant: deps.budgetGrant } : {}),
         callbacks: {
           onText: (delta) => {
             // Fire-and-forget: ACP `push` is async but the core-turn
@@ -262,7 +316,14 @@ export function bridgeCoreTurnToAcp(
           // callers see today. Fire-and-forget for the same reason
           // onText is: callbacks are synchronous, `turnCtx.push*` is
           // async, ordering is preserved by the SDK.
-          onToolCall: (call) => { void turnCtx.pushToolCall(call); },
+          onToolCall: (call) => {
+            if (!factQuestion || maxToolTurns === undefined || maxToolTurns <= 0) {
+              toolCallCount += 1;
+              toolKinds.add(call.name);
+              observeToolBudget();
+            }
+            void turnCtx.pushToolCall(call);
+          },
           onToolResult: (call) => { void turnCtx.pushToolResult(call); },
           onUsage: (usage) => { void turnCtx.pushUsage(usage); },
           // Codex Responses API reasoning summary stream. Currently
@@ -301,26 +362,64 @@ export function bridgeCoreTurnToAcp(
             // re-emit would cause the "displayed then deleted then
             // re-displayed" flicker the user reported.
             const finalAssistantText = extractLastAssistantText(newMessages);
-            const synthesisAlreadyStreamed =
-              finalAssistantText !== null
-              && finalAssistantText.length > 0
+            const budgetReached = factQuestion && maxToolTurns !== undefined
+              && maxToolTurns > 0 && toolCallCount >= maxToolTurns;
+            const followup = '더 찾아볼까요?';
+            const needsFollowup = budgetReached && finalAssistantText !== null
+              && finalAssistantText.trim().length > 0
+              && !finalAssistantText.trimEnd().endsWith(followup);
+            let lastAssistantIndex = -1;
+            for (let i = newMessages.length - 1; i >= 0; i--) {
+              if (newMessages[i]?.role === 'assistant') { lastAssistantIndex = i; break; }
+            }
+            const followupSuffix = `\n${followup}`;
+            const completedMessages: LLMMessage[] = needsFollowup
+              ? newMessages.map((message, index) => {
+                if (index !== lastAssistantIndex) return message;
+                if (typeof message.content === 'string') {
+                  return { ...message, content: message.content + followupSuffix };
+                }
+                if (Array.isArray(message.content)) {
+                  let lastTextIndex = -1;
+                  for (let blockIndex = message.content.length - 1; blockIndex >= 0; blockIndex--) {
+                    if (message.content[blockIndex]?.type === 'text') { lastTextIndex = blockIndex; break; }
+                  }
+                  if (lastTextIndex >= 0) {
+                    return { ...message, content: message.content.map((block, blockIndex) =>
+                      blockIndex === lastTextIndex && block.type === 'text'
+                        ? { ...block, text: block.text + followupSuffix }
+                        : block) };
+                  }
+                }
+                return message;
+              })
+              : newMessages;
+            const visibleFinalText = needsFollowup ? extractLastAssistantText(completedMessages) : finalAssistantText;
+            const originalFinalStreamed = needsFollowup && finalAssistantText !== null
               && streamedTextSum.endsWith(finalAssistantText);
+            const synthesisAlreadyStreamed =
+              visibleFinalText !== null
+              && visibleFinalText.length > 0
+              && streamedTextSum.endsWith(visibleFinalText);
             const needsReSurface =
-              finalAssistantText !== null
-              && finalAssistantText !== streamedTextSum
-              && !synthesisAlreadyStreamed;
-            if (debug.enabled && finalAssistantText !== null) {
+              visibleFinalText !== null
+              && visibleFinalText !== streamedTextSum
+              && !synthesisAlreadyStreamed
+              && !originalFinalStreamed;
+            if (debug.enabled && visibleFinalText !== null) {
               debug.log('llm.synthesis-surface', 'acp-bridge.surface-final-text', {
                 streamedChars: streamedTextSum.length,
-                finalChars: finalAssistantText.length,
-                delta: finalAssistantText.length - streamedTextSum.length,
+                finalChars: visibleFinalText.length,
+                delta: visibleFinalText.length - streamedTextSum.length,
                 startsWithStreamed: streamedTextSum.length > 0
-                  && finalAssistantText.startsWith(streamedTextSum),
+                  && visibleFinalText.startsWith(streamedTextSum),
                 endsWithStreamedTail: synthesisAlreadyStreamed,
                 needsReSurface,
               });
             }
-            if (needsReSurface) {
+            if (originalFinalStreamed) {
+              void turnCtx.push(followupSuffix);
+            } else if (needsReSurface) {
               // Emit a clear-then-replace pair so clients that follow
               // the empty-chunk-as-clear convention (dashboard plain
               // chat) reset their per-round buffer before receiving
@@ -329,12 +428,12 @@ export function bridgeCoreTurnToAcp(
               // would only have the new finalAssistantText delta to
               // work with anyway).
               void turnCtx.push('');
-              void turnCtx.push(finalAssistantText!);
+              void turnCtx.push(visibleFinalText!);
             }
             if (deps.onTurnComplete) {
               await deps.onTurnComplete({
                 sessionId: turnCtx.sessionId,
-                newMessages,
+                newMessages: completedMessages,
               });
             }
           },

package/src/acp/fact-question.ts

@@ -0,0 +1,11 @@
+export function isFactQuestion(userText: string): boolean {
+  const text = userText.trim();
+  if (!text || text.length > 120 || /[\r\n]/.test(text)) return false;
+  if (/`|\bsrc\/|(?:^|[\s/])[^\s/]+\.(?:ts|tsx|js|jsx|json|md|py|sh|yaml|yml)\b|고쳐|구현|실행|만들어|수정|디버그|파일|읽어|열어|저장|작성|삭제|편집|검색해|찾아줘|보여줘|\/cc\b|delegate_code_agent/i.test(text)) return false;
+  // A request («…해줘?», «재시작해», «restart …») is work, not a fact question — even with a «?» or «지금»(round 3: «지금 서버를 재시작해줘?»).
+  const request = text.replace(/알려\s*(?:줘|주세요|줄래|주실래요)[?？]?$/, '');
+  if (/(?:해|해\s*줘|해\s*주세요|하세요|해라|하자|줘|주세요|줄래|주실래요|봐|봐줘)[?？]?$/.test(request)) return false;
+  if (/재시작|시작|중지|멈춰|꺼|켜|설치|배포|돌려|보내|올려|지워|바꿔|추가|업데이트|재부팅|재실행|정리|등록|\b(?:restart|start|stop|run|install|deploy|delete|remove|create|update|fix|kill|reboot)\b/i.test(text)) return false;
+  if (!/[?？]$|(?:뭐야|무엇인가요|인가요|나요|입니까|얼마야|언제야|누구야|알려줘|알려주세요)$/.test(text)) return false;
+  return /최근|최신|지금|현재|몇|언제|누가|누구|얼마|가격|버전|출시|최저시급|\b(?:latest|current|when|who|how many|how much|price|version|release)\b/i.test(text);
+}