axmap-cli 1.3.2 → 1.4.0

package/app/eval/edges.mjs

@@ -1,242 +0,0 @@
-#!/usr/bin/env node
-/**
- * 모델 비교 하네스 — 엣지 독해만 잰다.
- *
- * "모델을 바꾸면 이득이 있나" 에 감상 대신 숫자로 답하기 위한 것이다.
- * 요약문 품질은 기계로 잴 수 없다. 엣지 독해는 잴 수 있는데, 정답 세트가 없어도
- * 서로 독립된 판정 기준이 이미 두 개 있기 때문이다.
- *
- *   · verified   — 모델이 말한 채널이 파일에 문자열로 실재하는가 (llm.mjs, D5)
- *   · 정적 추출  — analyze.mjs 의 channelsOf 가 같은 채널을 찾았는가, 방향은 뭐라 했는가
- *
- * 그래서 이 하네스가 재는 것은 "모델이 똑똑한가" 가 아니라
- * **정적 파싱 위에 모델이 무엇을 더 얹어주는가** 다. README 의 표현대로
- * 모델이 더해주는 것은 방향과 문서에만 적힌 흐름이고, 그 둘이 여기서 숫자가 된다.
- *
- * 사용:
- *   AXMAP_MODEL=qwen2.5-coder:7b node app/eval/edges.mjs <대상저장소>
- *   AXMAP_MODEL=<다른모델>        node app/eval/edges.mjs <대상저장소>
- *   node app/eval/edges.mjs --compare
- *
- * 캐시는 모델별로 갈리므로(llm.mjs 의 key) 같은 모델을 다시 돌리면 즉시 끝난다.
- * 모델이 다르면 캐시가 겹치지 않는다 — 비교가 오염되지 않는 이유다.
- */
-
-import fs from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { scan, channelsOf } from '../lib/analyze.mjs'
-import { status, warmup, readEdges } from '../lib/llm.mjs'
-
-const OUT_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'out')
-
-const slug = (model) => model.replace(/[^A-Za-z0-9._-]/g, '_')
-
-// ---------------------------------------------------------------------------
-// 한 파일의 측정
-// ---------------------------------------------------------------------------
-
-/**
- * @param st  Map<channel, 'pub'|'sub'|'unknown'|'both'>  정적 추출 결과
- * @param res readEdges 의 반환
- */
-function measure(file, st, res, ms) {
-  const edges = res.edges ?? []
-  const verified = edges.filter((e) => e.verified)
-  const seen = new Set(verified.map((e) => e.channel))
-
-  let dirResolved = 0 // 정적이 방향을 확정 못 한 채널에 모델이 방향을 준 것 ← 부가가치
-  let dirAgree = 0 // 정적도 확신했고 모델도 같은 방향
-  let dirConflict = 0 // 정적은 확신했는데 모델이 반대 ← 둘 중 하나는 틀렸다
-  let beyondStatic = 0 // 정적이 아예 못 본 채널인데 파일에 실재 ← 부가가치
-
-  for (const e of verified) {
-    if (!st.has(e.channel)) {
-      beyondStatic++
-      continue
-    }
-    const sd = st.get(e.channel)
-    // 'both' 은 정적이 한 방향으로 확정하지 못한 상태이므로 unknown 과 같이 센다
-    if (sd === 'unknown' || sd === 'both') dirResolved++
-    else if (sd === e.direction) dirAgree++
-    else dirConflict++
-  }
-
-  return {
-    path: file.path,
-    lines: file.lines,
-    staticCount: st.size,
-    claimed: edges.length,
-    verified: verified.length,
-    hallucinated: edges.length - verified.length,
-    dirResolved,
-    dirAgree,
-    dirConflict,
-    beyondStatic,
-    staticMissed: [...st.keys()].filter((ch) => !seen.has(ch)).length,
-    parseFailed: res.parseFailed === true,
-    cached: res.cached === true,
-    ms,
-  }
-}
-
-const SUM_KEYS = [
-  'staticCount', 'claimed', 'verified', 'hallucinated',
-  'dirResolved', 'dirAgree', 'dirConflict', 'beyondStatic', 'staticMissed',
-]
-
-function totalsOf(rows) {
-  const t = Object.fromEntries(SUM_KEYS.map((k) => [k, 0]))
-  for (const r of rows) for (const k of SUM_KEYS) t[k] += r[k]
-  t.files = rows.length
-  t.parseFailedFiles = rows.filter((r) => r.parseFailed).length
-  const fresh = rows.filter((r) => !r.cached)
-  t.freshFiles = fresh.length
-  t.msMedian = fresh.length
-    ? fresh.map((r) => r.ms).sort((a, b) => a - b)[Math.floor(fresh.length / 2)]
-    : null
-  return t
-}
-
-// ---------------------------------------------------------------------------
-// 실행
-// ---------------------------------------------------------------------------
-
-async function run(root, nFiles) {
-  const s = await status()
-  // 여기서 통과시키면 "0개 찾음" 이 모델 탓인지 Ollama 탓인지 영영 구분되지 않는다.
-  if (!s.available) {
-    console.error(`Ollama 에 연결할 수 없습니다 (${s.host}). 켜고 다시 실행하세요.`)
-    process.exit(1)
-  }
-  if (!s.modelReady) {
-    console.error(`모델 ${s.model} 이 없습니다. 받은 것: ${s.models.join(', ') || '(없음)'}`)
-    console.error(`  ollama pull ${s.model}`)
-    process.exit(1)
-  }
-
-  const all = scan(root).filter((f) => !f.backup)
-  if (!all.length) {
-    console.error(`${root} 에서 분석할 파일을 찾지 못했습니다.`)
-    process.exit(1)
-  }
-
-  // 채널이 많은 파일부터 본다. 재는 대상이 엣지 독해이므로 채널이 0인 파일을
-  // 아무리 돌려도 판정에 기여하지 않는다. 대신 몇 개를 안 봤는지 반드시 찍는다.
-  const ranked = all
-    .map((f) => ({ f, st: channelsOf(f) }))
-    .sort((a, b) => b.st.size - a.st.size || a.f.path.localeCompare(b.f.path))
-  const picked = ranked.slice(0, nFiles)
-
-  console.log(`모델   ${s.model}`)
-  console.log(`대상   ${root}`)
-  console.log(`파일   ${picked.length}개 (전체 ${ranked.length}개 중 채널 많은 순, ${ranked.length - picked.length}개 안 봄)\n`)
-
-  await warmup() // 콜드 스타트 44초를 첫 파일의 측정치에 섞지 않는다
-
-  const rows = []
-  for (const { f, st } of picked) {
-    const t0 = performance.now()
-    const res = await readEdges(f.path, f.text)
-    rows.push(measure(f, st, res, Math.round(performance.now() - t0)))
-    process.stderr.write(`\r  ${rows.length}/${picked.length} ${f.path}`.padEnd(78).slice(0, 78))
-  }
-  process.stderr.write('\r'.padEnd(79) + '\r')
-
-  report(rows, s.model, root)
-}
-
-function report(rows, model, root) {
-  const t = totalsOf(rows)
-
-  const head = ['파일', '정적', '주장', '실재', '환각', '방향+', '일치', '충돌', '정적밖', '누락', 'ms']
-  const w = [38, 4, 4, 4, 4, 5, 4, 4, 6, 4, 6]
-  const line = (cells) => cells.map((c, i) => (i === 0 ? String(c).padEnd(w[i]) : String(c).padStart(w[i]))).join(' ')
-
-  console.log(line(head))
-  console.log('-'.repeat(w.reduce((a, b) => a + b + 1, -1)))
-  for (const r of rows) {
-    const name = r.path.length > w[0] ? '…' + r.path.slice(-(w[0] - 1)) : r.path
-    console.log(line([
-      name, r.staticCount, r.claimed, r.verified, r.hallucinated,
-      r.dirResolved, r.dirAgree, r.dirConflict, r.beyondStatic, r.staticMissed,
-      r.cached ? 'cache' : r.ms,
-    ]) + (r.parseFailed ? '  ← 형식위반' : ''))
-  }
-
-  const pct = (n, d) => (d ? `${((n / d) * 100).toFixed(1)}%` : '—')
-  console.log(`\n합계 ${t.files}개 파일`)
-  console.log(`  주장 ${t.claimed} · 실재 ${t.verified} · 환각 ${t.hallucinated} (${pct(t.hallucinated, t.claimed)})`)
-  console.log(`  정적 위에 더한 것 : 방향 채움 ${t.dirResolved} + 정적 밖 채널 ${t.beyondStatic} = ${t.dirResolved + t.beyondStatic}`)
-  console.log(`  정적과 충돌      : ${t.dirConflict}`)
-  console.log(`  정적이 찾은 걸 놓침: ${t.staticMissed} / ${t.staticCount} (${pct(t.staticMissed, t.staticCount)})`)
-  console.log(`  새로 추론한 파일 ${t.freshFiles}개, 중앙값 ${t.msMedian ?? '—'}ms`)
-
-  if (t.parseFailedFiles) {
-    console.log(`\n⚠ JSON 형식 위반 ${t.parseFailedFiles}개 파일.`)
-    console.log(`  위 숫자는 믿을 수 없다. 모델이 사고 토큰을 뱉거나 num_predict 한도에 잘렸을 가능성이 크다.`)
-    console.log(`  프롬프트/num_predict 를 그 모델에 맞추기 전까지는 품질 비교가 아니라 배관 문제다.`)
-  }
-
-  fs.mkdirSync(OUT_DIR, { recursive: true })
-  const file = path.join(OUT_DIR, `${slug(model)}.json`)
-  fs.writeFileSync(file, JSON.stringify({ model, root, at: new Date().toISOString(), totals: t, rows }, null, 2))
-  console.log(`\n기록 ${path.relative(process.cwd(), file)}`)
-}
-
-// ---------------------------------------------------------------------------
-// 비교
-// ---------------------------------------------------------------------------
-
-function compare() {
-  let names = []
-  try {
-    names = fs.readdirSync(OUT_DIR).filter((n) => n.endsWith('.json'))
-  } catch {
-    /* 아래에서 안내한다 */
-  }
-  if (names.length < 2) {
-    console.error(`비교하려면 리포트가 2개 이상 필요합니다 (지금 ${names.length}개).`)
-    console.error(`  AXMAP_MODEL=<모델> node app/eval/edges.mjs <대상저장소>  를 모델별로 돌리세요.`)
-    process.exit(1)
-  }
-
-  const reps = names.map((n) => JSON.parse(fs.readFileSync(path.join(OUT_DIR, n), 'utf8')))
-  const roots = new Set(reps.map((r) => r.root))
-  if (roots.size > 1) {
-    // 대상이 다르면 숫자를 나란히 놓는 것 자체가 거짓말이다
-    console.error(`대상 저장소가 서로 다릅니다: ${[...roots].join(' / ')}`)
-    console.error(`같은 대상으로 다시 돌리거나 app/eval/out/ 을 비우세요.`)
-    process.exit(1)
-  }
-
-  const rows = reps.map((r) => ({
-    model: r.model,
-    환각률: r.totals.claimed ? `${((r.totals.hallucinated / r.totals.claimed) * 100).toFixed(1)}%` : '—',
-    부가가치: r.totals.dirResolved + r.totals.beyondStatic,
-    충돌: r.totals.dirConflict,
-    누락: r.totals.staticMissed,
-    형식위반: r.totals.parseFailedFiles,
-    'ms(중앙)': r.totals.msMedian ?? '—',
-  }))
-  console.log(`대상 ${reps[0].root} · 파일 ${reps[0].totals.files}개\n`)
-  console.table(rows)
-  console.log(`부가가치 = 정적이 방향을 확정 못 한 채널에 방향을 준 수 + 정적이 못 본 실재 채널 수`)
-  console.log(`형식위반이 0이 아닌 모델의 숫자는 품질이 아니라 배관 문제를 보고 있는 것이다.`)
-}
-
-// ---------------------------------------------------------------------------
-
-const args = process.argv.slice(2)
-if (args.includes('--compare')) {
-  compare()
-} else {
-  const root = args.find((a) => !a.startsWith('--'))
-  if (!root) {
-    console.error('사용: AXMAP_MODEL=<모델> node app/eval/edges.mjs <대상저장소> [--files N]')
-    console.error('      node app/eval/edges.mjs --compare')
-    process.exit(1)
-  }
-  const i = args.indexOf('--files')
-  await run(root, i >= 0 ? Number(args[i + 1]) : 20)
-}

package/app/lib/adjacent.mjs

@@ -1,125 +0,0 @@
-/**
- * 기능 인접 경고 — 파일은 안 겹치는데 **기능이 겹칠 때**.
- *
- * v0 프로토콜은 경로가 겹치는지만 본다. 그것으로 못 잡는 상황이 있다.
- *
- *   에이전트 A 가 `album.controller.ts` 를 잡는다   (API 쪽, 앞에서부터)
- *   에이전트 B 가 `album.repository.ts` 를 잡는다   (DB 쪽, 뒤에서부터)
- *
- * 경로가 안 겹치므로 **둘 다 통과한다.** 그런데 같은 기능이다.
- * A 가 응답 형태를 바꾸고 B 가 스키마를 바꾸면, 머지 시점에 텍스트 충돌은
- * 하나도 없는데 기능이 깨진다. 이것이 파일 단위 락의 한계다.
- *
- * 🔴 이것은 **경고이지 거부가 아니다.** 프로토콜을 건드리지 않는다.
- *
- * checkOverlap 은 그대로 두고, 뷰어가 옆에서 알려주기만 한다. 이유가 있다 —
- *
- *   1. 거부로 만들면 통과가 **줄어드는** 게 아니라 판정 기준이 달라진다.
- *      "경로가 겹치면 거부" 는 결정론이고 증명 가능하지만(I1), "기능이 겹치면
- *      거부" 는 lift 문턱이라는 조절 가능한 숫자에 기댄다. 그 숫자를 정당화할
- *      근거가 아직 없다 (DECISIONS.md 열린 질문 Q5).
- *   2. 히스토리가 없는 새 저장소에서는 이 신호가 아예 없다. 락이 그런 것에
- *      의존하면 "어떤 저장소에서는 락이 약해진다" 는 상태가 된다.
- *
- * 그래서 게이트는 그대로, 사람에게 정보만 준다 — D4 가 LLM 을 게이트 밖에
- * 둔 것과 같은 배치다.
- */
-
-/** 경로 접두사 포함. protocol.mjs 의 겹침 판정과 같은 '/' 경계 규칙을 쓴다. */
-const covers = (claimPath, file) => file === claimPath || file.startsWith(`${claimPath}/`)
-
-/** 이 claim 이 덮는 실제 파일들 */
-function filesOf(claim, allPaths) {
-  const out = new Set()
-  for (const c of claim.paths ?? []) {
-    for (const f of allPaths) if (covers(c, f)) out.add(f)
-  }
-  return out
-}
-
-/**
- * 활성 claim 들 사이에서 "경로는 안 겹치는데 공변경으로 이어진" 쌍을 찾는다.
- *
- * @param {object[]} claims    활성 claim (agent, paths, task, intent…)
- * @param {object[]} coEdges   공변경 엣지 (source, target, support, lift)
- * @param {string[]} allPaths  그래프에 있는 파일 전체
- * @param {object} opts
- * @returns {{pairs: object[], byAgent: object}}
- */
-export function featureAdjacency(claims, coEdges, allPaths, {
-  minLift = 3, minSupport = 4, maxEvidence = 8,
-} = {}) {
-  const live = (claims ?? []).filter((c) => !c.broken && (c.paths?.length ?? 0) > 0)
-  if (live.length < 2) return { pairs: [], checked: live.length }
-
-  const owned = live.map((c) => ({ claim: c, files: filesOf(c, allPaths) }))
-
-  // 파일 → 그 파일을 덮는 claim 들. 같은 파일을 둘이 덮고 있으면 그건
-  // 프로토콜이 이미 막았어야 하는 상황이므로 여기서 다루지 않는다.
-  const ownerOf = new Map()
-  owned.forEach((o, i) => { for (const f of o.files) ownerOf.set(f, i) })
-
-  const pairKey = (i, j) => (i < j ? `${i}\0${j}` : `${j}\0${i}`)
-  const acc = new Map()
-
-  for (const e of coEdges) {
-    if ((e.lift ?? 0) < minLift || (e.support ?? 0) < minSupport) continue
-    const a = ownerOf.get(e.source)
-    const b = ownerOf.get(e.target)
-    if (a === undefined || b === undefined || a === b) continue
-
-    const k = pairKey(a, b)
-    if (!acc.has(k)) acc.set(k, { a: Math.min(a, b), b: Math.max(a, b), evidence: [] })
-    acc.get(k).evidence.push({
-      from: e.source, to: e.target, lift: e.lift, support: e.support,
-    })
-  }
-
-  const pairs = [...acc.values()].map((p) => {
-    const A = owned[p.a].claim
-    const B = owned[p.b].claim
-    const ev = p.evidence.sort((x, y) => y.lift - x.lift).slice(0, maxEvidence)
-    return {
-      agents: [A.agent, B.agent],
-      tasks: [A.task ?? null, B.task ?? null],
-      intents: [A.intent ?? null, B.intent ?? null],
-      paths: [A.paths, B.paths],
-      // 세기는 "몇 개의 공변경 엣지가 두 영역을 가로지르나" + 가장 강한 lift.
-      // 하나의 점수로 합치지 않는다 — 둘은 다른 것을 뜻한다.
-      // (엣지 수 = 얼마나 넓게 얽혔나 / 최고 lift = 얼마나 강하게 얽혔나)
-      crossings: p.evidence.length,
-      topLift: ev[0]?.lift ?? 0,
-      evidence: ev,
-    }
-  }).sort((x, y) => y.crossings - x.crossings || y.topLift - x.topLift)
-
-  return { pairs, checked: live.length }
-}
-
-/**
- * 사람이 읽을 경고문.
- *
- * 거부 메시지와 **같은 모양**으로 만든다. 이 저장소의 거부 메시지는
- * "누가·무엇을·언제까지" 를 말해서 에이전트가 스스로 방향을 틀 수 있게 한다.
- * 경고도 같은 재료를 줘야 같은 판단을 할 수 있다.
- */
-export function formatAdjacency(pair) {
-  const [a, b] = pair.agents
-  const lines = [
-    `⚠ 경로는 안 겹치지만 같은 기능일 수 있습니다`,
-    ``,
-    `  ${a}  (${pair.tasks[0] ?? '작업 미지정'})`,
-    `    ${pair.paths[0].join(', ')}`,
-    pair.intents[0] ? `    의도: ${pair.intents[0]}` : null,
-    ``,
-    `  ${b}  (${pair.tasks[1] ?? '작업 미지정'})`,
-    `    ${pair.paths[1].join(', ')}`,
-    pair.intents[1] ? `    의도: ${pair.intents[1]}` : null,
-    ``,
-    `  근거 — 두 영역을 가로지르는 공변경 ${pair.crossings}건 (최고 lift ${pair.topLift})`,
-    ...pair.evidence.slice(0, 4).map((e) => `    ${e.from}  ↔  ${e.to}   lift ${e.lift} · n=${e.support}`),
-    ``,
-    `  이것은 거부가 아닙니다. 두 사람이 서로의 의도를 아는 것으로 충분할 수 있습니다.`,
-  ]
-  return lines.filter((l) => l !== null).join('\n')
-}

package/app/lib/agentcli.mjs

@@ -1,153 +0,0 @@
-/**
- * 어떤 AI CLI 가 이 PC 에 있고, 로그인돼 있는가.
- *
- * 🔴 왜 필요한가.
- *
- * 화면에서는 "새 대화" 지만 실제로는 **CLI 프로세스를 하나 띄우는 것**이다.
- * 그 CLI 에 로그인이 안 돼 있으면 프롬프트를 보낸 뒤에야 로그인 화면이 뜨는데,
- * 우리는 터미널을 감춰 놨으므로 사용자에게는 그냥 **아무 일도 안 일어난 것**으로
- * 보인다. 그래서 대화를 시작하기 전에 먼저 물어본다.
- *
- * 세 CLI 모두 같은 모양의 비대화형 모드를 갖고 있어서 한 겹으로 덮을 수 있다.
- *
- *   -p / --print                     한 번 묻고 끝낸다
- *   --output-format stream-json      JSONL 로 흘려준다 → 채팅 말풍선으로 다시 그린다
- *   --resume / --conversation <id>   앞 대화에 이어붙인다
- */
-
-import { spawnSync } from 'node:child_process'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-
-const HOME = os.homedir()
-const hasHome = (rel) => { try { return fs.existsSync(path.join(HOME, rel)) } catch { return false } }
-
-/**
- * 🔴 `claude` 는 세션 id 를 **받고**, `agy` 는 **주기만 한다.**
- *
- * 그래서 이어붙이는 방법이 둘로 갈린다.
- *   받는 쪽 — 우리가 uuid 를 만들어 첫 턴에 박고, 그 값으로 resume 한다
- *   주는 쪽 — 첫 턴 응답에서 id 를 주워 두었다가 다음 턴에 쓴다
- * 둘 다 `pickId()` 로 응답에서 id 를 줍는다. 받는 쪽도 주워 두면 우리가 만든
- * 값과 CLI 가 실제로 쓴 값이 어긋났을 때 CLI 쪽을 따라갈 수 있다.
- */
-export const AGENTS = [
-  {
-    id: 'claude',
-    name: 'Claude Code',
-    bin: 'claude',
-    creds: ['.claude/.credentials.json', '.claude.json'],
-    takesId: true,
-    start: (id) => ['-p', '--output-format', 'stream-json', '--verbose', '--session-id', id],
-    resume: (cid) => ['-p', '--output-format', 'stream-json', '--verbose', '--resume', cid],
-  },
-  {
-    id: 'agy',
-    name: 'agy',
-    bin: 'agy',
-    /**
-     * 🔴 여기에 `AppData/Local/agy` 를 넣었다가 뺐다.
-     *
-     * 그건 **실행 파일이 있는 자리**이지 자격증명이 아니다. 넣어 두면 설치만
-     * 해도 "로그인됨" 으로 뜬다 — 확신 있게 틀린 답이고, 이 저장소가 가장
-     * 싫어하는 종류의 실패다(D5). 모르면 `unknown` 이 맞는 답이다.
-     */
-    creds: ['.agy/auth.json', '.agy/credentials.json', '.config/agy/auth.json'],
-    takesId: false,
-    start: () => ['-p', '--output-format', 'stream-json'],
-    resume: (cid) => ['-p', '--output-format', 'stream-json', '--conversation', cid],
-  },
-  {
-    id: 'codex',
-    name: 'Codex CLI',
-    bin: 'codex',
-    creds: ['.codex/auth.json'],
-    takesId: false,
-    start: () => ['exec', '--json', '-'],
-    resume: (cid) => ['exec', 'resume', cid, '--json', '-'],
-    /**
-     * 🔴 이 PC 에 codex 가 없어서 **실물로 확인하지 못했다.**
-     * 확인 안 된 것을 확인된 것처럼 화면에 내보내지 않는다 — 화면이 이 표시를
-     * 그대로 띄운다. 실제 codex 가 있는 PC 에서 한 번 돌려보고 이 줄을 지운다.
-     */
-    unverified: true,
-  },
-]
-
-export const agentById = (id) => AGENTS.find((a) => a.id === id) ?? null
-
-/**
- * 실행 파일의 실제 경로.
- *
- * 🔴 윈도우의 `spawn('claude', …)` 은 확장자 없는 이름을 못 찾는다.
- * `shell: true` 로 우회하면 프롬프트 안의 따옴표가 셸에 먹혀 **조용히 잘린다** —
- * 사용자가 쓴 말이 반쯤 사라진 채로 AI 에게 간다는 뜻이라 최악이다.
- * 그래서 경로를 먼저 풀어서 그 경로로 직접 띄운다. 프롬프트는 stdin 으로 준다.
- */
-export function resolveBin(bin) {
-  const cmd = process.platform === 'win32' ? 'where' : 'which'
-  try {
-    const r = spawnSync(cmd, [bin], { encoding: 'utf8', windowsHide: true })
-    if (r.status !== 0) return null
-    return r.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0] ?? null
-  } catch { return null }
-}
-
-/**
- * 로그인 여부는 **모르면 모른다고 한다.**
- *
- * 자격증명이 있는 자리는 CLI 버전마다 바뀌고, macOS 는 키체인에 넣어서 파일이
- * 아예 없다. 없다고 단정하면 멀쩡한 CLI 를 못 쓰게 막고, 있다고 단정하면 첫
- * 프롬프트에서 로그인 화면이 떠 대화가 그냥 멈춘다. 둘 다 조용한 실패다.
- * 그래서 `yes` · `no` · `unknown` 셋으로 답하고, 화면이 그 셋을 다르게 그린다.
- *
- * 🔴 그러므로 `unknown` 을 "아마 되겠지" 로 접지 마라. 그 값이 화면에
- * "로그인 상태를 확인하지 못했습니다" 로 그대로 나가는 것이 설계다 —
- * 터미널을 감춰 놨기 때문에 침묵이 곧 미궁이 된다.
- */
-function signedIn(a, installed) {
-  if (!installed) return 'no'
-  return a.creds.some(hasHome) ? 'yes' : 'unknown'
-}
-
-/** 이 PC 에서 쓸 수 있는 CLI 목록. 화면이 시작할 때 한 번 묻는다. */
-export function detect() {
-  return AGENTS.map((a) => {
-    const bin = resolveBin(a.bin)
-    return {
-      id: a.id,
-      name: a.name,
-      installed: !!bin,
-      path: bin,
-      signedIn: signedIn(a, !!bin),
-      unverified: !!a.unverified,
-    }
-  })
-}
-
-/** 설치돼 있는 것 중 첫 번째. 화면이 기본값으로 쓴다. */
-export function preferred(found = detect()) {
-  return found.find((a) => a.installed && a.signedIn !== 'no') ?? found.find((a) => a.installed) ?? null
-}
-
-/**
- * 이번 턴에 띄울 인자.
- * `cid` 가 있으면 이어붙이고, 없으면 새로 시작한다.
- */
-export function argvFor(agent, { cid, newId }) {
-  return cid ? agent.resume(cid) : agent.start(newId)
-}
-
-/**
- * 응답 이벤트에서 대화 id 를 줍는다.
- * CLI 마다 이름이 달라서 아는 이름을 전부 본다. 못 찾으면 null 이고,
- * 그러면 다음 턴은 **이어붙지 않고 새 대화가 된다** — 조용히 섞이는 것보다 낫다.
- */
-export function pickId(ev) {
-  if (!ev || typeof ev !== 'object') return null
-  for (const k of ['session_id', 'sessionId', 'conversation_id', 'conversationId', 'thread_id']) {
-    if (typeof ev[k] === 'string' && ev[k]) return ev[k]
-  }
-  return null
-}