reverbo 0.1.0

package/src/render.js

@@ -0,0 +1,164 @@
+// 상태줄 렌더 — 스펙 D2.
+//
+// 사실 ④ 로 COLUMNS·LINES 를 알 수 있으니 자르지 않고 접는다. 다만 한글은
+// 터미널에서 두 칸을 먹어서, 글자 수로 접으면 화면을 넘는다. 의존성 0 이라
+// East Asian Wide/Fullwidth 범위를 직접 판정한다.
+
+const WIDE = [
+  [0x1100, 0x115f], [0x2e80, 0x303e], [0x3041, 0x33ff],
+  [0x3400, 0x4dbf], [0x4e00, 0x9fff], [0xa000, 0xa4cf],
+  [0xac00, 0xd7a3], [0xf900, 0xfaff], [0xfe30, 0xfe6f],
+  [0xff00, 0xff60], [0xffe0, 0xffe6],
+  [0x1f300, 0x1f64f], [0x1f900, 0x1f9ff], [0x20000, 0x3fffd],
+]
+
+function codeWidth(cp) {
+  for (const [lo, hi] of WIDE) if (cp >= lo && cp <= hi) return 2
+  return 1
+}
+
+export function stringWidth(s) {
+  let w = 0
+  for (const ch of String(s)) w += codeWidth(ch.codePointAt(0))
+  return w
+}
+
+// COLUMNS 는 실제로 글자가 보이는 폭보다 크다 — 테두리와 여백이 있다.
+// 실측(2026-09-07): COLUMNS 로 124칸을 채운 줄이 화면에서 `…` 로 잘렸고
+// 123칸은 살아남았다. 그 차이만큼 미리 비워 두면 어느 창 크기에서도
+// 안 잘린다(창을 줄여도 테두리 폭은 그대로라 여백은 상수다).
+//
+// 덜 채우는 대가는 줄당 몇 칸이고, 안 비웠을 때의 대가는 문장 끝이
+// 먹혀 배울 것이 사라지는 것이다. 비대칭이 크니 넉넉한 쪽으로 기운다.
+const SAFE_MARGIN = 4
+
+// wrap 은 「이 폭에 맞춰 접어라」만 안다. 여백은 화면 경계를 아는
+// buildLines 의 몫이다 — 층을 섞으면 wrap(text, 4) 가 4칸으로 안 접힌다.
+function fit(columns) {
+  return Number.isFinite(columns) && columns > 0 ? Math.floor(columns) : 80
+}
+
+// 접두 두 칸과 안전 여백을 뺀, 글자가 실제로 들어갈 폭.
+// 아주 좁은 창에서 다 먹어버리면 아무것도 못 내므로 최소는 남긴다.
+function usableWidth(columns, color) {
+  const prefix = color ? 0 : SOURCE_PREFIX.length // 색이 켜지면 접두가 없다
+  return Math.max(4, fit(columns) - SAFE_MARGIN - prefix)
+}
+
+// 폭보다 긴 낱말은 글자에서 자른다. 자르지 않으면 무한루프가 난다.
+function breakWord(word, width) {
+  const out = []
+  let cur = ''
+  let w = 0
+  for (const ch of word) {
+    const cw = codeWidth(ch.codePointAt(0))
+    if (w + cw > width && cur) { out.push(cur); cur = ''; w = 0 }
+    cur += ch
+    w += cw
+  }
+  if (cur) out.push(cur)
+  return out
+}
+
+export function wrap(text, columns) {
+  const width = fit(columns)
+  const out = []
+  for (const para of String(text || '').split('\n')) {
+    let cur = ''
+    for (const word of para.split(/\s+/).filter(Boolean)) {
+      const pieces = stringWidth(word) > width ? breakWord(word, width) : [word]
+      for (const piece of pieces) {
+        const next = cur ? `${cur} ${piece}` : piece
+        if (stringWidth(next) > width && cur) { out.push(cur); cur = piece }
+        else cur = next
+      }
+    }
+    if (cur) out.push(cur)
+  }
+  return out
+}
+
+const SOURCE_PREFIX = '─ '
+const TARGET_PREFIX = '  '
+// 접힌 줄에 표시를 다시 찍으면 한 문장이 여러 문장처럼 보인다. 이 표시는
+// 「여기서 한 덩어리가 시작한다」는 뜻이라 첫 행에만 있어야 하고, 이어지는
+// 행은 같은 폭만큼 들여써 글자가 세로로 맞게 한다.
+const CONT_PREFIX = ' '.repeat(SOURCE_PREFIX.length)
+
+// 줄임표가 붙을 한 칸을 비워 준다 — 안 그러면 그 한 칸 때문에 폭을 넘는다.
+function clip(line, width) {
+  if (stringWidth(line) < width) return line
+  let out = ''
+  for (const ch of line) {
+    if (stringWidth(out + ch) > width - 1) break
+    out += ch
+  }
+  return out.trimEnd()
+}
+
+const withPrefix = (lines, first, cont) =>
+  lines.map((l, i) => (i === 0 ? first : cont) + l)
+
+// DESIGN.md — 중성색 + 신호색 하나, accent 는 화면에 한 번.
+// 색조를 늘리지 않고 명암으로 가른다: 원문은 방금 자기가 친 것이라 흐리게,
+// 번역은 배우는 것이라 기본 밝기. 상태줄에 이미 다른 색이 있어도 안 싸운다.
+//
+// **색은 접은 뒤에 입힌다.** ANSI 코드가 폭 계산에 섞이면 줄이 화면을 넘는다.
+const DIM = '\x1b[2m'
+const ACCENT = '\x1b[33m'
+const RESET = '\x1b[0m'
+
+function paint(lines, { dim, accentFirst }) {
+  return lines.map((l, i) => {
+    // 첫 행의 표시만 accent 다 — 나머지는 본문과 같은 밝기로 둔다.
+    // 표시가 없으면 칠할 accent 도 없다 — 명암이 그 일을 대신한다.
+    if (i === 0 && accentFirst && l.startsWith(SOURCE_PREFIX)) {
+      const mark = l.slice(0, SOURCE_PREFIX.length)
+      const rest = l.slice(SOURCE_PREFIX.length)
+      return `${ACCENT}${mark}${RESET}${dim ? DIM : ''}${rest}${RESET}`
+    }
+    return `${dim ? DIM : ''}${l}${RESET}`
+  })
+}
+
+export function buildLines({ source, translated, columns, rows, showSource, maxRatio, color }) {
+  if (!translated) return [] // 번역이 없으면 원문만 띄우지 않는다. 화면만 먹는다.
+  // 색이 켜져 있으면 명암이 이미 원문과 번역을 가른다. 표시까지 두면
+  // 중복이고, 그 두 칸 때문에 모든 줄이 밀려 좁은 창에서 손해를 본다.
+  // 색이 꺼지면 표시가 유일한 단서라 남긴다.
+  const marks = color
+    ? { source: '', target: '', cont: '' }
+    : { source: SOURCE_PREFIX, target: TARGET_PREFIX, cont: CONT_PREFIX }
+  const width = usableWidth(columns, color)
+  // 원문을 띄우는 방식 셋. 예전 설정의 true/false 도 그대로 받는다.
+  //   full  — 전부. 대조하기 좋지만 화면을 제일 많이 먹는다
+  //   first — 한 행만. 원문은 방금 입력창에서 본 것이라 「어느 문장인지」만
+  //           알면 되는 사람에겐 이게 충분하고 화면이 절반으로 준다
+  //   off   — 번역만
+  const mode = showSource === true ? 'full' : showSource === false ? 'off' : showSource
+
+  let lines = []
+  if (mode === 'full') {
+    lines.push(...withPrefix(wrap(source, width), marks.source, marks.cont))
+  } else if (mode === 'first') {
+    const all = wrap(source, width)
+    // 뒤에 더 있다는 것을 알려야 한다 — 안 그러면 원문이 저게 전부인 줄 안다.
+    lines.push(marks.source + (all.length > 1 ? clip(all[0], width) + '…' : all[0] || ''))
+  }
+  const srcCount = lines.length
+  lines.push(...withPrefix(wrap(translated, width), marks.target, marks.cont))
+
+  const height = Number.isFinite(rows) && rows > 0 ? rows : 24
+  const ratio = Number.isFinite(maxRatio) && maxRatio > 0 && maxRatio <= 1 ? maxRatio : 0.25
+  const cap = Math.max(1, Math.floor(height * ratio))
+  if (lines.length > cap) {
+    lines = lines.slice(0, cap)
+    lines[lines.length - 1] = `${lines[lines.length - 1]}…`
+  }
+  if (!color) return lines
+  // 자를 자리를 정한 뒤에 칠한다 — 잘린 행에도 초기화가 붙어야 한다.
+  return [
+    ...paint(lines.slice(0, srcCount), { dim: true, accentFirst: true }),
+    ...paint(lines.slice(srcCount), { dim: false, accentFirst: false }),
+  ]
+}

package/src/settings.js

@@ -0,0 +1,56 @@
+// ~/.claude/settings.json 을 우리가 고칠 수 있는지 판정한다.
+//
+// **이건 우리 파일이 아니다.** 사람이 공들여 고쳐둔 파일이고, 이미 다른
+// 상태줄이 붙어 있을 수 있다(kickbacks 를 쓰거나 자기 스크립트를 붙여둔
+// 사람). 그래서 이 모듈은 「쓴다」가 아니라 「써도 되는지」만 정하고,
+// 실제 쓰기는 호출부가 한다 — 판정을 테스트에서 전부 돌려볼 수 있게.
+
+export const COMMAND = 'reverbo statusline'
+
+// 이 값이 바뀌면 이미 붙여둔 사람의 설정과 어긋나 uninstall 이 그걸 남의
+// 것으로 오인하고 안 떼어낸다. 바꾸려면 마이그레이션을 같이 생각해야 한다.
+export const STATUS_LINE = {
+  type: 'command',
+  command: COMMAND,
+  // 갱신 트리거가 이벤트 기반이라 세션이 조용하면 안 돈다. 번역이 늦게
+  // 도착했을 때 화면에 반영될 기회를 이걸로 보장한다.
+  refreshInterval: 5,
+}
+
+// 없는 파일과 빈 파일은 같게 본다. 그 외에는 객체로 파싱돼야만 손댄다 —
+// 주석이 있거나 손상된 파일을 우리가 다시 쓰면 사람 설정이 사라진다.
+function read(rawText) {
+  const text = String(rawText || '').trim()
+  if (!text) return { empty: true }
+  try {
+    const json = JSON.parse(text)
+    if (!json || typeof json !== 'object' || Array.isArray(json)) return { bad: true }
+    return { json }
+  } catch {
+    return { bad: true }
+  }
+}
+
+const isOurs = (line) => line?.command === COMMAND
+
+// 남의 상태줄이 무엇인지 사람에게 보여주려고 한 줄로 요약한다.
+const describe = (line) => (typeof line === 'string' ? line : line?.command || JSON.stringify(line))
+
+export function planInstall(rawText) {
+  const { empty, bad, json } = read(rawText)
+  if (bad) return { status: 'unparsable' }
+  if (empty) return { status: 'create', json: { statusLine: STATUS_LINE } }
+  if (isOurs(json.statusLine)) return { status: 'already' }
+  if (json.statusLine !== undefined) return { status: 'conflict', existing: describe(json.statusLine) }
+  return { status: 'add', json: { ...json, statusLine: STATUS_LINE } }
+}
+
+export function planUninstall(rawText) {
+  const { empty, bad, json } = read(rawText)
+  if (bad) return { status: 'unparsable' }
+  if (empty || json.statusLine === undefined) return { status: 'nothing' }
+  // 우리가 안 붙인 것을 우리가 떼면 안 된다.
+  if (!isOurs(json.statusLine)) return { status: 'foreign', existing: describe(json.statusLine) }
+  const { statusLine, ...rest } = json
+  return { status: 'remove', json: rest }
+}

package/src/statusline.js

@@ -0,0 +1,62 @@
+// 읽는 쪽 — 스펙 D4.
+//
+// 아무것도 기다리지 않는다. 사실 ⑤ 대로 실행 중에 새 트리거가 오면
+// Claude Code 가 이 프로세스를 죽인다. 캐시 파일 하나를 읽고 끝낸다.
+
+import { paths } from './paths.js'
+import { buildLines } from './render.js'
+
+export async function statusline({ input, env, deps }) {
+  try {
+    // I2 — session_id 로는 절대 못 찾는다. transcript.js 는 entry.promptId
+    // 로만 대조하고, session_id 는 그 값과 무관하다. 예전엔 이 자리에서
+    // session_id 로 떨어져 매번 워커를 띄우고 트랜스크립트를 읽어 놓고
+    // (최대 ~21MB) 결국 못 찾아 허탕만 쳤다. prompt_id 는 Claude Code
+    // v2.1.196 이상에서만 온다 — 그보다 낮은 버전에서는 여기서 조용히
+    // 빈 줄로 끝난다(M4 — status 가 이걸 안내한다).
+    const key = input?.prompt_id
+    if (!key) return ''
+
+    const p = paths(env)
+    const cfg = await deps.config(p.configFile)
+
+    const hit = await deps.readEntry({ dir: p.cacheDir, promptId: key })
+    // I1 — 우편함에 항목이 있다는 것 자체가 「이미 처리됐다」는 뜻이다.
+    // translated 가 빈 문자열(SAME, 이미 목표어)이어도 다시 워커를 띄우면
+    // 안 된다 — 그러면 잠금 TTL 이 지날 때마다 같은 프롬프트를 유료로
+    // 다시 번역하게 된다. null(실패)만 재시도 대상이고, 그건 애초에
+    // 캐시되지 않는다.
+    if (hit) {
+      if (!hit.translated) return ''
+      return buildLines({
+        source: hit.source,
+        translated: hit.translated,
+        columns: Number(env?.COLUMNS),
+        rows: Number(env?.LINES),
+        showSource: cfg.showSource,
+        maxRatio: cfg.maxRatio,
+        // NO_COLOR 는 관례다 — 설정보다 환경이 이긴다.
+        color: cfg.color && !env?.NO_COLOR,
+      }).join('\n')
+    }
+
+    // 부를 곳이 없으면 워커를 띄우지 않는다. 「키를 넣어주세요」를 작업
+    // 화면에 띄우지도 않는다 — 상태는 `status` 로 본다.
+    if (!cfg.apiKey) return ''
+    if (!input?.transcript_path) return ''
+    if (await deps.acquireLock({ dir: p.cacheDir, promptId: key, now: deps.now() })) {
+      deps.spawnWorker({
+        prompt_id: key,
+        transcript_path: input.transcript_path,
+        // 서버에 쌓을 때 어디서 친 것인지 알려면 여기서 넘겨야 한다.
+        // 워커는 stdin JSON 을 못 본다.
+        repo: input && input.workspace && input.workspace.repo && input.workspace.repo.name,
+        // 제외 디렉터리 판정에만 쓴다. 기기를 안 떠난다.
+        cwd: (input && input.cwd) || (input && input.workspace && input.workspace.current_dir),
+      })
+    }
+    return ''
+  } catch {
+    return '' // 스펙 D8
+  }
+}

package/src/transcript.js

@@ -0,0 +1,88 @@
+// 트랜스크립트에서 「사람이 친 문장」만 꺼낸다.
+//
+// 실측(2026-09-06, 85MB 파일): type:"user" 줄 1676개 중 사람이 친 것은
+// 285개뿐이다. 도구 결과 1337 · isMeta 40 · 중단 12 · 슬래시 확장 2.
+// 「마지막 user 줄」을 집으면 대부분 도구 출력 JSON 을 번역하게 된다.
+//
+// promptId 는 사람이 친 285개 전부에 있었다. 그래서 마지막을 집지 않고
+// statusLine 이 준 prompt_id 로 정확히 찾는다.
+
+// 사람이 안 쳤는데 사람 턴처럼 보이는 것들. 실측(2026-09-07, 트랜스크립트
+// 12개 926줄)에서 53줄이 여기 걸린다 — 슬래시 명령 확장, `!` 로 친 셸
+// 명령과 그 출력, 그리고 백그라운드 작업 알림.
+//
+// 이걸 안 거르면 도구 출력이 상태줄에 영어로 떠 있고, 그만큼 번역 비용도
+// 나간다. 접두만 보고 판단하는 이유는 본문 어디에나 나올 수 있는 말이
+// 아니라 **줄 맨 앞에 오는 표시**라서다. 닫는 `>` 까지 요구하는 이유는
+// `<bash-input-format> 이건 무슨 뜻이야?` 같은 진짜 질문을 안 삼키려는 것이다.
+const NOT_HUMAN_TAGS = [
+  'command-message', 'command-name', 'command-args',
+  'local-command-stdout', 'local-command-stderr',
+  'bash-input', 'bash-stdout', 'bash-stderr',
+  'task-notification', 'system-reminder',
+]
+const NOT_HUMAN_PREFIX = new RegExp(`^<(${NOT_HUMAN_TAGS.join('|')})>`)
+const INTERRUPTED = /^\[Request interrupted/
+const SYSTEM_REMINDER = /<system-reminder>[\s\S]*?<\/system-reminder>/g
+
+export function textOf(entry) {
+  const c = entry?.message?.content
+  const raw = typeof c === 'string'
+    ? c
+    : Array.isArray(c)
+      ? c.filter((p) => p?.type === 'text').map((p) => p.text || '').join('')
+      : ''
+  return raw.replace(SYSTEM_REMINDER, '').trim()
+}
+
+export function isHumanTurn(entry) {
+  if (!entry || entry.type !== 'user') return false
+  if (entry.isMeta || entry.isSidechain) return false
+  if (entry.toolUseResult !== undefined) return false
+  const c = entry.message?.content
+  if (Array.isArray(c) && c.some((p) => p?.type === 'tool_result')) return false
+  const t = textOf(entry)
+  if (!t) return false
+  if (NOT_HUMAN_PREFIX.test(t) || INTERRUPTED.test(t)) return false
+  return true
+}
+
+export function findInChunk(chunk, promptId) {
+  const lines = chunk.split('\n')
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]
+    // 값싼 사전 검사. 대부분의 줄은 여기서 걸러져 JSON.parse 를 안 탄다.
+    if (!line || !line.includes(promptId)) continue
+    let entry
+    try { entry = JSON.parse(line) } catch { continue } // 앞이 잘린 첫 줄이 정상이다
+    if (entry.promptId !== promptId) continue
+    if (!isHumanTurn(entry)) continue
+    return textOf(entry)
+  }
+  return null
+}
+
+const FIRST = 256 * 1024
+const CAP = 16 * 1024 * 1024
+
+export async function findPrompt({ path, promptId, open }) {
+  if (!path || !promptId) return null
+  let fh
+  try {
+    fh = await open(path, 'r')
+    const { size } = await fh.stat()
+    for (let want = FIRST; ; want *= 4) {
+      const len = Math.min(want, size)
+      const pos = size - len
+      const buf = Buffer.alloc(len)
+      await fh.read(buf, 0, len, pos)
+      const hit = findInChunk(buf.toString('utf8'), promptId)
+      if (hit) return hit
+      if (len >= size || want >= CAP) return null
+    }
+  } catch {
+    return null // 못 읽으면 빈 줄로 간다. 상태줄은 사람의 작업 화면이다.
+  } finally {
+    try { await fh?.close() } catch {}
+  }
+}

package/src/translate.js

@@ -0,0 +1,144 @@
+// 번역 어댑터 — 스펙 D3.
+//
+// 아는 곳을 표로 둔다. 셋째(로컬 `claude -p`, 로컬 모델)를 붙일 때
+// translate 의 제어 흐름을 고치는 게 아니라 PROVIDERS 에 한 줄을 더하면 된다.
+//
+// **어디로 보내는지가 이 파일의 유일한 개인정보 결정이다.** 프롬프트에는
+// 코드·파일 경로·회사 맥락이 들어 있고, 그게 통째로 나간다.
+// Anthropic 은 Claude Code 가 이미 그 문장을 보낸 곳이라 새 노출이 아니지만,
+// **OpenAI 는 그 문장이 처음 가는 곳이다.** 기본을 OpenAI 로 둔 것은 사람의
+// 결정이고, 그래서 `init` 이 그 사실을 말한다 — 고르는 건 사람이되 모르고
+// 고르지는 않게.
+
+const DEFAULT_TIMEOUT = 8000
+// M3 — 긴 입력에 좁은 출력 상한을 물리면 번역이 중간에서 잘리고, 잘린 채로
+// 캐시돼 영구화된다(다시 안 부른다). 입력을 줄이고 출력 여유를 늘린다.
+const MAX_INPUT = 2000
+const MAX_OUTPUT = 2048
+
+// 이미 목표어로 쓴 문장에 이 약속어를 받아 빈 줄로 지나간다. 별도 언어
+// 감지기를 두지 않는다.
+const SAME = 'SAME'
+
+function prompt(text, from, to) {
+  return [
+    `Translate the following text from ${from} to ${to}.`,
+    `Reply with the translation only — no preface, no quotes, no explanation.`,
+    `If the text is already written in ${to}, reply with exactly ${SAME}.`,
+    '',
+    text,
+  ].join('\n')
+}
+
+// 두 곳이 같은 판정을 한다 — 응답에서 뽑아낸 글자를 무엇으로 볼 것인가.
+// null ⟸ 모양이 이상하거나 비었다(실패로 보고 재시도 가능하게 둔다)
+// ''   ⟸ SAME(목표어라 번역이 없다는 확답, 다시 안 묻는다)
+function verdict(raw) {
+  const text = String(raw || '').trim()
+  if (!text) return null
+  return text.toUpperCase() === SAME ? '' : text
+}
+
+// ─── Anthropic ──────────────────────────────────────────────────────────
+
+const ANTHROPIC_ENDPOINT = 'https://api.anthropic.com/v1/messages'
+const ANTHROPIC_VERSION = '2023-06-01'
+
+export function buildAnthropicRequest({ text, from, to, model, apiKey }) {
+  return {
+    url: ANTHROPIC_ENDPOINT,
+    init: {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': ANTHROPIC_VERSION,
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: MAX_OUTPUT,
+        messages: [{ role: 'user', content: prompt(text, from, to) }],
+      }),
+    },
+  }
+}
+
+export function parseAnthropicResponse(json) {
+  const parts = json?.content
+  if (!Array.isArray(parts)) return null
+  return verdict(parts.filter((p) => p?.type === 'text').map((p) => p.text || '').join(''))
+}
+
+// ─── OpenAI ─────────────────────────────────────────────────────────────
+
+const OPENAI_ENDPOINT = 'https://api.openai.com/v1/chat/completions'
+
+export function buildOpenAIRequest({ text, from, to, model, apiKey }) {
+  return {
+    url: OPENAI_ENDPOINT,
+    init: {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: MAX_OUTPUT,
+        messages: [{ role: 'user', content: prompt(text, from, to) }],
+      }),
+    },
+  }
+}
+
+export function parseOpenAIResponse(json) {
+  const content = json?.choices?.[0]?.message?.content
+  if (typeof content !== 'string') return null
+  return verdict(content)
+}
+
+// ─── 표 ─────────────────────────────────────────────────────────────────
+
+export const PROVIDERS = {
+  anthropic: {
+    buildRequest: buildAnthropicRequest,
+    parseResponse: parseAnthropicResponse,
+    truncated: (json) => json?.stop_reason === 'max_tokens',
+  },
+  openai: {
+    buildRequest: buildOpenAIRequest,
+    parseResponse: parseOpenAIResponse,
+    truncated: (json) => json?.choices?.[0]?.finish_reason === 'length',
+  },
+}
+
+// 반환값은 셋 중 하나다 — string(번역문) · ''(SAME, 목표어라 번역이 없다는
+// 확답) · null(무엇이든 실패, 잠금 TTL 이 지나면 재시도해야 한다).
+// ''와 null 을 섞으면(과거 버전처럼) 「목표어라 다시 안 부른다」와
+// 「실패했으니 다시 불러야 한다」를 워커가 구분할 수 없다 — I1.
+export async function translate({
+  text, from, to, provider, model, apiKey, fetchImpl,
+  timeoutMs = DEFAULT_TIMEOUT,
+}) {
+  const body = String(text || '').trim()
+  if (!body || !apiKey) return null
+  const impl = PROVIDERS[provider]
+  if (!impl) return null
+
+  const ac = new AbortController()
+  const timer = setTimeout(() => ac.abort(), timeoutMs)
+  try {
+    const { url, init } = impl.buildRequest({ text: body.slice(0, MAX_INPUT), from, to, model, apiKey })
+    const res = await fetchImpl(url, { ...init, signal: ac.signal })
+    if (!res?.ok) return null
+    const json = await res.json()
+    // 잘린 번역을 캐시하면 영구히 잘린 채로 남는다(M3) — 실패로 취급해
+    // 재시도 가능하게 둔다.
+    if (impl.truncated(json)) return null
+    return impl.parseResponse(json)
+  } catch {
+    return null // 느리든 끊기든 — 실패는 재시도 가능해야 한다
+  } finally {
+    clearTimeout(timer)
+  }
+}

package/src/wizard.js

@@ -0,0 +1,93 @@
+// 설정 마법사의 판정부. p10k 가 스타일을 그려놓고 고르게 하듯,
+// 말로 설명하지 말고 **고른 값이 실제로 어떻게 보이는지** 그려준다.
+//
+// 화면·키 입력은 cli 가 맡고 여기는 순수 함수만 둔다 — 미리보기가
+// 실제 렌더러를 그대로 쓰는지 테스트로 확인할 수 있어야 한다.
+
+import { buildLines } from './render.js'
+
+// 미리보기에 쓰는 예문. 짧으면 셋의 차이가 안 보이므로 접힐 만큼 길게 둔다.
+// 언어쌍마다 예문이 달라야 고르는 의미가 있다. 방향까지 열쇠로 쓴다 —
+// from 만 보면 ko→en 과 ko→ja 가 같은 그림이 된다.
+const SENTENCES = {
+  ko: '코치 오프닝이 되묻지 않게 고치자. 몰아보기 영상에서만 회귀하는 것 같아',
+  en: "Let's fix the coach's opening so it stops asking back. It seems to regress only on compilation videos.",
+  ja: 'コーチの冒頭が聞き返さないように直そう。まとめ動画でだけ戻るようだ',
+}
+const FALLBACK = { from: 'ko', to: 'en' }
+
+export const QUESTIONS = [
+  {
+    key: 'showSource',
+    title: '원문을 어떻게 띄울까요',
+    note: '원문은 방금 입력창에서 본 것이라, 안 띄우면 화면이 절반으로 줄어요.',
+    options: [
+      { value: 'full', label: '전부' },
+      { value: 'first', label: '첫 행만' },
+      { value: 'off', label: '안 띄움' },
+    ],
+  },
+  {
+    key: 'color',
+    title: '색으로 가를까요',
+    note: '원문은 흐리게, 번역은 기본 밝기예요. 색을 끄면 원문 앞에 줄표가 붙어요.',
+    options: [
+      { value: true, label: '색으로 가르기' },
+      { value: false, label: '색 없이' },
+    ],
+  },
+  {
+    key: 'langs',
+    title: '어느 쪽으로 번역할까요',
+    note: '',
+    options: [
+      { value: 'ko:en', label: '한국어 → 영어' },
+      { value: 'en:ko', label: '영어 → 한국어' },
+      { value: 'ko:ja', label: '한국어 → 일본어' },
+      { value: 'ja:ko', label: '일본어 → 한국어' },
+    ],
+  },
+]
+
+// 고른 값을 얹은 설정으로 실제 렌더러를 돌린다. 설명이 아니라 실물이라
+// 렌더러가 바뀌면 미리보기도 같이 바뀐다.
+export function previewOf(question, value, config, columns) {
+  const cfg = applyAnswer(config, question.key, value)
+  const from = SENTENCES[cfg.from] ? cfg.from : FALLBACK.from
+  const to = SENTENCES[cfg.to] ? cfg.to : FALLBACK.to
+  return buildLines({
+    source: SENTENCES[from],
+    translated: SENTENCES[to],
+    columns,
+    rows: 200, // 미리보기는 세로 상한에 안 걸리게 — 차이를 다 보여준다
+    maxRatio: 1,
+    showSource: cfg.showSource,
+    color: cfg.color,
+  })
+}
+
+export function applyAnswer(config, key, value) {
+  if (key === 'langs') {
+    const [from, to] = String(value).split(':')
+    if (!from || !to) return { ...config }
+    return { ...config, from, to }
+  }
+  if (!QUESTIONS.some((q) => q.key === key)) return { ...config }
+  return { ...config, [key]: value }
+}
+
+// 방향키는 raw 모드에서 여러 바이트로 오고 터미널마다 다르다. 스페이스로
+// 다음 값으로 넘기고 엔터로 고르는 편이 어디서나 같게 동작한다.
+export function nextValue(question, current) {
+  const i = question.options.findIndex((o) => o.value === current)
+  return question.options[(i + 1) % question.options.length].value
+}
+
+// 지금 설정에서 이 물음의 값이 무엇인지.
+export function currentValue(question, config) {
+  if (question.key === 'langs') return `${config.from}:${config.to}`
+  const v = config[question.key]
+  // 예전 설정의 true/false 를 새 이름으로 옮겨 준다.
+  if (question.key === 'showSource') return v === true ? 'full' : v === false ? 'off' : v
+  return v
+}

package/src/worker.js

@@ -0,0 +1,58 @@
+// 쓰는 쪽 — 스펙 D4.
+//
+// 별도 프로세스로 돈다. 죽어도 상태줄과 무관하고, 상태줄이 죽어도
+// 이쪽은 계속 돈다(detached).
+
+import { paths } from './paths.js'
+
+export async function work({ input, env, deps }) {
+  try {
+    const p = paths(env)
+    const cfg = await deps.config(p.configFile)
+
+    const source = await deps.findPrompt({ path: input.transcript_path, promptId: input.prompt_id })
+    if (!source) return
+
+    // 관문 G2 — 걸리면 제공처에도 안 보낸다. 번역·캐시·전송 전부 건너뛴다.
+    // 반드시 번역 호출 앞이어야 한다 — 순서가 뒤바뀌면 비밀값이 이미
+    // 번역 제공처(OpenAI·Anthropic)로 나간 뒤라 안전장치가 의미가 없다.
+    if (deps.shouldSkip({ text: source, cwd: input.cwd, exclude: cfg.exclude })) return
+
+    const translated = await deps.translate({
+      text: source, from: cfg.from, to: cfg.to,
+      provider: cfg.provider, model: cfg.model, apiKey: cfg.apiKey,
+    })
+    // I1 — null 은 「실패」다. 캐시에 안 남겨야 잠금 TTL 이 지난 뒤 다시
+    // 시도된다. ''(SAME)는 「이미 목표어라 번역이 없다」는 확답이라 아래로
+    // 내려가 캐시에 남는다 — 그래야 매 새로고침마다 같은 유료 호출이
+    // 반복되지 않는다.
+    if (translated === null) return
+
+    await deps.writeEntry({ dir: p.cacheDir, promptId: input.prompt_id, entry: { source, translated } })
+
+    try {
+      // A안 채택 — 서버는 from·to 를 필수로 보고 없으면 400, outbox 의
+      // classify 는 400 을 'discard' 로 봐서 조용히 사라진다. 여기서
+      // 비우지 않고 「기본값으로 채운다」쪽을 골랐다: cfg 는 config.js 의
+      // normalize 를 거쳐 나오고, normalize 는 raw.from/raw.to 가 빈
+      // 문자열이거나 없으면 DEFAULTS.from='ko'/DEFAULTS.to='en' 으로
+      // 채워 넣는다 — 그래서 cfg.from·cfg.to 는 이 시점에 절대 비지 않는다.
+      //
+      // D2(리뷰) — cfg 를 통째로 안 실어 보낸다. cfg 에는 exclude(사람의
+      // 절대 디렉터리 경로 목록)와 apiKey(번역 제공처 키)가 들어 있는데
+      // 그건 서버가 알 필요도, 알아서도 안 되는 값이다. 훅이 받을 수 있는
+      // 값을 여기서 좁혀 두면 Task 6 이 uploadPrompt 를 그대로 이어 붙여도
+      // 실수로 태울 값 자체가 없다.
+      await deps.upload({
+        promptId: input.prompt_id, source, translated, repo: input.repo,
+        from: cfg.from, to: cfg.to, token: cfg.token,
+      })
+    } catch {
+      // 전송이 실패해도 상태줄 학습은 이미 성립했다.
+    }
+
+    await deps.prune({ dir: p.cacheDir })
+  } catch {
+    // 스펙 D8 — 워커도 조용히 죽는다
+  }
+}