elanous 0.2.4 → 0.2.6

package/scripts/daemon-port-baseline.txt

@@ -1,9 +1,8 @@
 # Daemon port literal baseline: non-comment lines in non-test src/**/*.ts, per file.
 # New files and increases fail. Migrate callers to the daemon endpoint resolver, then --update.
-# total=13 files=6
+# total=12 files=5
 1	src/autopilot/proposal/draft-plan.ts
 6	src/index.ts
-1	src/nexus/api/mcp-oauth-hint.ts
 1	src/nexus/default-port.ts
 2	src/task-orchestrator/surfaces/pod-command-job.ts
 2	src/task-orchestrator/surfaces/self-implement-pod.ts

package/scripts/eval-bot-vs-grok.ts

@@ -0,0 +1,79 @@
+// 봇 UX «그록봇 수준» 판별 — 같은 질문 묶음을 elanous chat(글자) · elanous agent(도구) · xAI Grok 에 던지고 원문·시간을 남긴다.
+// 사용: bun scripts/eval-bot-vs-grok.ts <outDir> <repoCwd> · Grok 모델 = 사다리 `budget` 칸(tierModel)   (키 값은 출력하지 않는다)
+import { spawnSync } from 'node:child_process';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tierModel } from '../src/llm/model-defaults.js';
+
+const [,, outDir, repoCwd] = process.argv;
+mkdirSync(outDir, { recursive: true });
+
+type Q = { id: string; axis: string; text: string; session?: string; needsTools?: boolean };
+const QUESTIONS: Q[] = [
+  { id: 'q01', axis: 'smalltalk', text: '안녕, 오늘 뭐 도와줄 수 있어? 세 줄 안으로.' },
+  { id: 'q02', axis: 'smalltalk', text: '요즘 좀 지쳤어. 짧게 한마디 해줘.' },
+  { id: 'q03', axis: 'fact', text: '서울에서 부산까지 KTX 로 대략 몇 시간 걸려? 한 줄로.' },
+  { id: 'q04', axis: 'fact', text: 'HWPX 파일 형식이 뭐야? 두 줄로.' },
+  { id: 'q05', axis: 'context', session: 'ctx', text: '내 프로젝트 이름은 elanous 야. 기억해 둬. «알겠다» 한 마디만.' },
+  { id: 'q06', axis: 'context', session: 'ctx', text: '우리 팀은 네 세션으로 나뉘어 있어: OP, MK, TC, UX. 이것도 기억해. 한 마디만.' },
+  { id: 'q07', axis: 'context', session: 'ctx', text: '내 프로젝트 이름이랑 팀 세션 약자 넷을 한 줄로 말해 봐.' },
+  { id: 'q08', axis: 'tools', needsTools: true, text: '지금 작업 폴더(git 저장소)에서 가장 최근 커밋 제목 세 개를 알려줘.' },
+  { id: 'q09', axis: 'tools', needsTools: true, text: 'apps/pwa 폴더에 파일이 대략 몇 개야? 숫자 하나로.' },
+  { id: 'q10', axis: 'tools', needsTools: true, text: '오늘 날짜를 한국 시간으로 알려줘.' },
+  { id: 'q11', axis: 'recovery', needsTools: true, text: 'docs/NOPE-does-not-exist-xyz.md 파일을 요약해줘.' },
+  { id: 'q12', axis: 'recovery', text: '내가 어제 너한테 부탁한 일 결과 알려줘.' },
+];
+
+type Row = { id: string; axis: string; target: string; ms: number; ok: boolean; reply: string; meta?: Record<string, unknown> };
+const rows: Row[] = [];
+
+function runElanous(mode: 'chat' | 'agent', q: Q, session?: string): Row {
+  const args = [mode, '--json', ...(session ? ['--session', session] : ['--new']), q.text];
+  const t0 = Date.now();
+  const r = spawnSync('elanous', args, { cwd: repoCwd, encoding: 'utf8', timeout: 240_000, maxBuffer: 64 << 20 });
+  const ms = Date.now() - t0;
+  const line = (r.stdout ?? '').trim().split('\n').reverse().find((l) => l.startsWith('{')) ?? '';
+  let parsed: Record<string, unknown> = {};
+  try { parsed = JSON.parse(line); } catch { /* keep empty */ }
+  const reply = typeof parsed.reply === 'string' ? parsed.reply : ((r.stderr ?? '').slice(-400) || '(no reply)');
+  return { id: q.id, axis: q.axis, target: `elanous-${mode}`, ms, ok: r.status === 0 && typeof parsed.reply === 'string', reply, meta: { sessionId: parsed.sessionId, provider: parsed.provider, model: parsed.model, status: r.status } };
+}
+
+function xaiKey(): string {
+  const env = readFileSync(join(process.env.HOME!, '.claude/skills/omni-crawl/.env'), 'utf8');
+  return /^XAI_API_KEY=(.*)$/m.exec(env)?.[1]?.trim().replace(/^['"]|['"]$/g, '') ?? '';
+}
+const grokHistory = new Map<string, Array<{ role: string; content: string }>>();
+async function runGrok(q: Q): Promise<Row> {
+  if (q.needsTools) return { id: q.id, axis: q.axis, target: 'grok', ms: 0, ok: false, reply: 'n/a — 작업 폴더·도구 없음(대조 제외)' };
+  const history = q.session ? (grokHistory.get(q.session) ?? []) : [];
+  const messages = [...history, { role: 'user', content: q.text }];
+  const t0 = Date.now();
+  const res = await fetch('https://api.x.ai/v1/chat/completions', {
+    method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${xaiKey()}` },
+    body: JSON.stringify({ model: tierModel('budget', 'grok'), messages }),
+  });
+  const ms = Date.now() - t0;
+  const body = await res.json().catch(() => ({})) as { choices?: Array<{ message?: { content?: string } }> };
+  const reply = body.choices?.[0]?.message?.content ?? `(http ${res.status})`;
+  if (q.session) grokHistory.set(q.session, [...messages, { role: 'assistant', content: reply }]);
+  return { id: q.id, axis: q.axis, target: 'grok', ms, ok: res.ok, reply };
+}
+
+for (const mode of ['chat', 'agent'] as const) {
+  const sessions = new Map<string, string>();
+  for (const q of QUESTIONS) {
+    const row = runElanous(mode, q, q.session ? sessions.get(q.session) : undefined);
+    if (q.session && !sessions.has(q.session) && typeof row.meta?.sessionId === 'string') sessions.set(q.session, row.meta.sessionId as string);
+    rows.push(row);
+    console.log(`${mode} ${q.id} ${row.ok ? 'ok' : 'FAIL'} ${(row.ms / 1000).toFixed(1)}s`);
+    writeFileSync(join(outDir, 'rows.json'), JSON.stringify(rows, null, 2));
+  }
+}
+for (const q of QUESTIONS) {
+  const row = await runGrok(q);
+  rows.push(row);
+  console.log(`grok ${q.id} ${row.ok ? 'ok' : 'skip/FAIL'} ${(row.ms / 1000).toFixed(1)}s`);
+}
+writeFileSync(join(outDir, 'rows.json'), JSON.stringify(rows, null, 2));
+console.log('done', rows.length);

package/scripts/eval-grok-live-baseline.ts

@@ -0,0 +1,36 @@
+// 대조군 v2 — xAI Responses API · 추론 모델(저장소 GROK_SEARCH_MODEL) · web_search ⊕ x_search 켬. 그록봇 «제품» 은 아니다.
+// 사용: bun eval-grok-live.ts <repo-checkout> <outDir>   (키 값은 출력하지 않는다)
+import { mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const [,, repo, outDir] = process.argv;
+mkdirSync(outDir, { recursive: true });
+const { grokAgentSearch, GROK_SEARCH_MODEL } = await import(join(repo, 'src/grok/agent-search.js'));
+const env = readFileSync(join(process.env.HOME!, '.claude/skills/omni-crawl/.env'), 'utf8');
+const apiKey = /^XAI_API_KEY=(.*)$/m.exec(env)?.[1]?.trim().replace(/^['"]|['"]$/g, '') ?? '';
+
+type Q = { id: string; text: string; session?: string };
+const QS: Q[] = [
+  { id: 'q01', text: '안녕, 오늘 뭐 도와줄 수 있어? 세 줄 안으로.' },
+  { id: 'q02', text: '요즘 좀 지쳤어. 짧게 한마디 해줘.' },
+  { id: 'q03', text: '서울에서 부산까지 KTX 로 대략 몇 시간 걸려? 한 줄로.' },
+  { id: 'q04', text: 'HWPX 파일 형식이 뭐야? 두 줄로.' },
+  { id: 'q05', session: 'ctx', text: '내 프로젝트 이름은 elanous 야. 기억해 둬. «알겠다» 한 마디만.' },
+  { id: 'q06', session: 'ctx', text: '우리 팀은 네 세션으로 나뉘어 있어: OP, MK, TC, UX. 이것도 기억해. 한 마디만.' },
+  { id: 'q07', session: 'ctx', text: '내 프로젝트 이름이랑 팀 세션 약자 넷을 한 줄로 말해 봐.' },
+  { id: 'q10', text: '오늘 날짜를 한국 시간으로 알려줘.' },
+  { id: 'q12', text: '내가 어제 너한테 부탁한 일 결과 알려줘.' },
+];
+const history: string[] = [];
+const rows: unknown[] = [];
+for (const q of QS) {
+  const systemPrompt = q.session && history.length ? `이전 대화:\n${history.join('\n')}` : undefined;
+  const t0 = Date.now();
+  const r = await grokAgentSearch(q.text, { apiKey, tools: ['web_search', 'x_search'], ...(systemPrompt ? { systemPrompt } : {}), timeoutMs: 90_000 });
+  const ms = Date.now() - t0;
+  if (q.session) history.push(`사용자: ${q.text}`, `어시스턴트: ${r.text}`);
+  rows.push({ id: q.id, target: 'grok-live', model: GROK_SEARCH_MODEL, ms, ok: r.ok, reply: r.text, citations: (r.citations ?? []).length, error: r.error });
+  console.log(`grok-live ${q.id} ${r.ok ? 'ok' : 'FAIL'} ${(ms / 1000).toFixed(1)}s cites=${(r.citations ?? []).length}`);
+}
+writeFileSync(join(outDir, 'grok-live.rows.json'), JSON.stringify(rows, null, 2));
+console.log('done', rows.length);

package/scripts/fixtures/front-route-corpus.sample.json

@@ -0,0 +1,17 @@
+{
+  "description": "손으로 쓴 개인정보 없는 앞 분류기 예시 — 규칙 미판정 문장",
+  "items": [
+    { "id": "absorb-1", "text": "이 기술 발표에서 핵심 논점이 뭔지 알고 싶어.", "expected": "absorb" },
+    { "id": "absorb-2", "text": "긴 글의 주요 주장만 파악하고 싶어.", "expected": "absorb" },
+    { "id": "absorb-3", "text": "이 자료는 어떤 배경에서 나왔는지 살펴봐.", "expected": "absorb" },
+    { "id": "tasks-1", "text": "문서 제목 확인하고 표 오타 검토한 다음 회의실 예약도 챙겨야 해.", "expected": "tasks" },
+    { "id": "tasks-2", "text": "청구서 확인, 일정 변경, 메일 답장 각각 챙기자.", "expected": "tasks" },
+    { "id": "tasks-3", "text": "오늘은 재고 파악하고 전등 교체 일정도 따로 잡아야겠어.", "expected": "tasks" },
+    { "id": "graph-1", "text": "이 입력부터 결과까지 이어지는 처리 과정을 자동화하고 싶어.", "expected": "graph" },
+    { "id": "graph-2", "text": "데이터가 들어오면 검사 후 분류해서 다음 단계로 넘기는 흐름이 필요해.", "expected": "graph" },
+    { "id": "graph-3", "text": "요청 접수부터 승인과 배포까지 한 흐름으로 묶자.", "expected": "graph" },
+    { "id": "ask-human-1", "text": "이거 어떻게 할까?", "expected": "ask-human" },
+    { "id": "ask-human-2", "text": "지금은 어느 방향이 좋을지 모르겠어.", "expected": "ask-human" },
+    { "id": "ask-human-3", "text": "그건 상황을 보고 결정하자.", "expected": "ask-human" }
+  ]
+}

package/scripts/fleet/node-setup.sh

@@ -71,11 +71,21 @@ else R "k3d registry create $REGISTRY --port 127.0.0.1:$REG_PORT >/tmp/fleet-reg
 #   `bridge` 에만 붙어 kubelet 이 `lookup k3d-elanous-registry: no such host` → Pod `ImagePullBackOff`(🅕 첫 Pod 사용에서 발견). 멱등.
 [ $CHECK = 1 ] || R "docker network inspect k3d-$CLUSTER >/dev/null 2>&1 && (docker network connect k3d-$CLUSTER k3d-$REGISTRY 2>/dev/null || true)" >/dev/null 2>&1
 fi
-# 클러스터가 그 레지스트리를 쓰나 — 안 쓰면(옛 클러스터) 돌고 있는 Job 이 없을 때만 다시 만든다.
+# 🪞 호스트 git 미러(대표 09-29) — Pod 는 GitHub 대신 이 미러에서 clone 한다(`ELANOUS_POD_HOST_MIRROR` · #21929).
+#   bare 미러 = 원격 ~/mirror/elanous-agent.git(없으면 만든다 · 갱신은 이 맥의 크론이 push). 클러스터 노드에 읽기 전용으로 붙인다.
+MIRROR_DIR='$HOME/mirror'; MIRROR_MOUNT=/mirror-host
+if R "test -d ~/mirror/elanous-agent.git"; then ok "호스트 git 미러 ~/mirror/elanous-agent.git"
+elif [ $CHECK = 1 ]; then todo "호스트 git 미러 ~/mirror/elanous-agent.git 생성(git init --bare) ⊕ 이 맥에서 첫 push"
+else R "mkdir -p ~/mirror && git init -q --bare ~/mirror/elanous-agent.git" && ok "호스트 git 미러 (생성 · 첫 push 는 이 맥 크론)" || { bad "미러 생성 실패"; exit 1; }; fi
+# 클러스터가 그 레지스트리를 쓰나 ⊕ 미러가 붙어 있나 — 둘 중 하나라도 아니면(옛 클러스터) 돌고 있는 Job 이 없을 때만 다시 만든다.
+#   ⛔ k3d 는 볼륨을 «클러스터 생성 때만» 붙인다 — 붙이려면 다시 만들 수밖에 없다.
 REG_WIRED=0; R "docker exec k3d-$CLUSTER-server-0 cat /etc/rancher/k3s/registries.yaml 2>/dev/null | grep -q k3d-$REGISTRY" && REG_WIRED=1
+MIRROR_WIRED=0; R "docker exec k3d-$CLUSTER-server-0 test -d $MIRROR_MOUNT/elanous-agent.git" && MIRROR_WIRED=1
+[ $MIRROR_WIRED = 1 ] || { [ $REG_WIRED = 1 ] && REG_WIRED=0 && MIRROR_ONLY=1; }
 if R "k3d cluster list $CLUSTER" >/dev/null 2>&1 && [ $REG_WIRED = 0 ]; then
-  RUNNING="$(R "KUBECONFIG=\$(k3d kubeconfig write $CLUSTER) kubectl get jobs -A --no-headers 2>/dev/null | grep -vc Complete || true" 2>/dev/null | tail -1)"; RUNNING="${RUNNING:-0}"
-  if [ $CHECK = 1 ]; then todo "클러스터 $CLUSTER 가 레지스트리를 안 쓴다 — 다시 만든다(도는 Job ${RUNNING:-?}개)"
+  # «실행 중»만 센다 — 실패로 끝난 Job 은 Complete 가 아니어도 도는 것이 아니다(09-29: `grep -vc Complete` 는 Failed 까지 세서 영원히 0 이 안 됐다).
+  RUNNING="$(R "KUBECONFIG=\$(k3d kubeconfig write $CLUSTER) kubectl get jobs -A -o jsonpath='{range .items[*]}{.status.active}{\"\\n\"}{end}' 2>/dev/null | awk '\$1>0' | wc -l | tr -d ' '" 2>/dev/null | tail -1)"; RUNNING="${RUNNING:-0}"
+  if [ $CHECK = 1 ]; then todo "클러스터 $CLUSTER 가 $([ "${MIRROR_ONLY:-0}" = 1 ] && echo "미러($MIRROR_MOUNT)를 안 붙였다" || echo "레지스트리를 안 쓴다") — 다시 만든다(도는 Job ${RUNNING:-?}개)"
   elif [ "${RUNNING:-0}" != "0" ]; then bad "클러스터 $CLUSTER 를 다시 만들어야 하는데 도는 Job 이 ${RUNNING}개 — 끝난 뒤 다시"; exit 1
   else R "k3d cluster delete $CLUSTER >/dev/null 2>&1" && ok "클러스터 $CLUSTER (레지스트리 연결 위해 지움)"; fi
 fi
@@ -83,7 +93,7 @@ if R "k3d cluster list $CLUSTER" >/dev/null 2>&1; then ok "클러스터 $CLUSTER
 elif [ $CHECK = 1 ]; then todo "클러스터 $CLUSTER 생성($K3S_IMAGE · API :$API_PORT · SAN $HOST ${TSNAME:-} · 레지스트리 k3d-$REGISTRY:$REG_PORT)"
 else
   SAN="--k3s-arg --tls-san=$HOST@server:0"; [ -n "$TSNAME" ] && SAN="$SAN --k3s-arg --tls-san=$TSNAME@server:0"
-  R "k3d cluster create $CLUSTER --image $K3S_IMAGE --no-lb --api-port 0.0.0.0:$API_PORT $SAN --registry-use k3d-$REGISTRY:$REG_PORT --wait --timeout 300s >/tmp/fleet-k3d-create.log 2>&1" && ok "클러스터 $CLUSTER (생성 · 레지스트리 k3d-$REGISTRY)" || { bad "클러스터 생성 실패 — 원격 /tmp/fleet-k3d-create.log"; exit 1; }
+  R "k3d cluster create $CLUSTER --image $K3S_IMAGE --no-lb --api-port 0.0.0.0:$API_PORT $SAN --registry-use k3d-$REGISTRY:$REG_PORT --volume $MIRROR_DIR:$MIRROR_MOUNT:ro@server:0 --wait --timeout 300s >/tmp/fleet-k3d-create.log 2>&1" && ok "클러스터 $CLUSTER (생성 · 레지스트리 k3d-$REGISTRY)" || { bad "클러스터 생성 실패 — 원격 /tmp/fleet-k3d-create.log"; exit 1; }
 fi
 # 7. 이 맥 kubeconfig 에 컨텍스트 pool-<호스트>
 # ⛔ «있다»로 끝내지 않는다 — 클러스터를 다시 만들면 인증서가 바뀌어 옛 컨텍스트가 x509 로 죽는다(2026-09-26 node-b:
@@ -114,9 +124,38 @@ PY
   KUBECONFIG=~/.kube/config:"$TMP/kc.yaml" kubectl config view --flatten > "$TMP/merged.yaml" && chmod 600 "$TMP/merged.yaml" && mv "$TMP/merged.yaml" ~/.kube/config && ok "kubeconfig 컨텍스트 $CTX (추가 · 현재 컨텍스트는 그대로)" || bad "kubeconfig 병합 실패"
 fi
 # 8. 네임스페이스 ⊕ 격리 정책
-if kubectl --context "$CTX" --request-timeout=10s get ns elanous-test >/dev/null 2>&1; then ok "elanous-test 네임스페이스"
-elif [ $CHECK = 1 ]; then todo "base.yaml ⊕ policy-internet.yaml 적용"
-else kubectl --context "$CTX" apply -f "$ROOT/docker/h1/base.yaml" -f "$ROOT/docker/h1/policy-internet.yaml" >/dev/null && ok "elanous-test 네임스페이스 ⊕ 정책 (적용)" || bad "적용 실패"; fi
+apply_base() {
+  if [ "$CHECK" = 1 ]; then
+    if ! kubectl --context "$CTX" --request-timeout=10s get ns elanous-test >/dev/null 2>&1; then
+      todo "base.yaml ⊕ policy-internet.yaml 적용"
+    elif kubectl --context "$CTX" diff -f "$ROOT/docker/h1/base.yaml" -f "$ROOT/docker/h1/policy-internet.yaml" >/dev/null 2>&1; then
+      ok "elanous-test 네임스페이스 ⊕ 정책"
+    else
+      local diff_status=$?
+      if [ "$diff_status" = 1 ]; then todo "base.yaml ⊕ policy-internet.yaml 적용"
+      else todo "base.yaml ⊕ policy-internet.yaml 적용 (못 쟀다)"; fi
+    fi
+    return
+  fi
+
+  local attempts=0 output retries
+  while [ "$attempts" -lt 6 ]; do
+    attempts=$((attempts+1))
+    if output=$(kubectl --context "$CTX" apply -f "$ROOT/docker/h1/base.yaml" -f "$ROOT/docker/h1/policy-internet.yaml" 2>&1); then
+      retries=$((attempts-1))
+      if [ "$retries" -eq 0 ]; then ok "elanous-test 네임스페이스 ⊕ 정책 (적용)"
+      else ok "elanous-test 네임스페이스 ⊕ 정책 (적용 · 재시도 $retries)"; fi
+      return
+    fi
+    if [[ "$output" != *'serviceaccount "default" not found'* ]] || [ "$attempts" -eq 6 ]; then
+      [ -z "$output" ] || printf '%s\n' "$output" >&2
+      bad "적용 실패 (재시도 $((attempts-1)))"
+      return
+    fi
+    sleep "${FLEET_APPLY_RETRY_SLEEP:-5}"
+  done
+}
+apply_base
 # 9. 판 대조 — k3s · 노드 준비
 v="$(kubectl --context "$CTX" --request-timeout=10s get nodes -o jsonpath='{.items[0].status.nodeInfo.kubeletVersion}' 2>/dev/null)"
 want="${K3S_IMAGE##*:}"; want="${want/-k3s/+k3s}"

package/scripts/landing-heal/must-fix-match.ts

@@ -1,4 +1,30 @@
+import { parse } from '../../src/agent-substrate/pr-comment-meta.js';
+
 export type MustFixVerdict = 'resolved' | 'unresolved' | 'unknown';
+export interface ReviewRoundMatch {
+  text: string;
+  verdict: 'rereviewed' | 'open';
+  run: string;
+  round: number;
+}
+
+/** A later reviewer round in the same run is evidence of rereview, not proof of repair. */
+const MUST_FIX_ROUND = /^Round \d+: reviewer requested \d+ must-fix change\(s\)\.$/m;
+
+export function classifyReviewRounds(comments: Array<{ body?: string }>): ReviewRoundMatch[] {
+  const reviews = comments.flatMap(({ body }) => {
+    if (!body) return [];
+    const meta = parse(body);
+    return meta?.role === 'reviewer' && meta.run && meta.round !== undefined
+      ? [{ body, run: meta.run, round: meta.round }] : [];
+  });
+  // 항목은 «must-fix 요청» 라운드에서만 센다 — «review completed (warn)» 의 요약 본문에도 «- » 글머리가 들어 있다(#21983 실물).
+  return reviews.flatMap(({ body, run, round }) => !MUST_FIX_ROUND.test(body) ? [] :
+    [...body.matchAll(/^- (.+)$/gm)].map((item) => ({
+      text: item[1]!, run, round,
+      verdict: reviews.some((review) => review.run === run && review.round > round) ? 'rereviewed' as const : 'open' as const,
+    })));
+}
 
 /** Match only named evidence in a PR's final patch, never an earlier review round. */
 export function matchMustFix(mustFix: string, finalDiff: string): MustFixVerdict {

package/scripts/landing-heal/run-mission.ts

@@ -1,9 +1,12 @@
 #!/usr/bin/env bun
 import { spawnSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { githubAutomationToken } from '../../src/auth/github-app-token.js';
 import { debug } from '../../src/debug/log.js';
 import { emitDecision } from '../../src/live/detail-switch.js';
-import { matchMustFix, type MustFixVerdict } from './must-fix-match.js';
+import { parse } from '../../src/agent-substrate/pr-comment-meta.js';
+import { classifyReviewRounds, matchMustFix, type MustFixVerdict } from './must-fix-match.js';
 
 interface PullRequest {
   number: number;
@@ -13,11 +16,45 @@ interface PullRequest {
   headRefName: string;
   files: Array<{ path: string }>;
 }
-interface Match { pr: number; text: string; verdict: MustFixVerdict }
-interface GraphContext { runId?: string; input?: { windowMinutes?: number; mustFixByPr?: Record<string, string[]> }; outputs?: Record<string, unknown> }
+interface Match { pr: number; text: string; verdict: MustFixVerdict | 'rereviewed' | 'open'; run?: string; round?: number; resolvedIn?: number[] }
+interface GraphContext { runId?: string; input?: { windowMinutes?: number; mustFixByPr?: Record<string, string[]> }; outputs?: Record<string, unknown>; decision?: typeof emitDecision }
 export type RunCommand = (args: string[]) => string;
+// 상주 루프(30분마다)는 사람 계정 한도를 쓰지 않는다 — 부른 쪽이 GH_TOKEN 을 주지 않았으면 GitHub App 설치 토큰으로(09-29 한도 소진).
+// 발급 함수마다 한 번(프로세스 전역 한 칸이면 앞선 호출의 진짜 토큰이 주입한 가짜를 이긴다 — 09-29 시험 실패 출력에 토큰이 찍혔다).
+const minted = new WeakMap<() => string | null, string | null>();
+export function ghEnv(env: NodeJS.ProcessEnv = process.env, mint: () => string | null = githubAutomationToken): NodeJS.ProcessEnv {
+  if (Object.hasOwn(env, 'GH_TOKEN')) return env;
+  if (!minted.has(mint)) minted.set(mint, mint());
+  const appToken = minted.get(mint);
+  debug.log('landing-heal', 'gh-token', { source: appToken ? 'github-app' : 'caller' });
+  return appToken ? { ...env, GH_TOKEN: appToken } : env;
+}
+// 상주 루프는 설치본 폴더(git 저장소 아님)에서 돈다 — `gh` 가 저장소를 추론 못 해 첫 cron 바퀴가 collect 에서 죽었다(09-29 21:00).
+// 부른 쪽이 GH_REPO 를 주지 않았고 cwd 가 git 저장소가 아니면, App 설치의 저장소가 «정확히 하나»일 때 그것을 쓴다(모르면 멈춘다).
+export async function ghRepoEnv(env: NodeJS.ProcessEnv, cwd: string, list: (token: string) => Promise<string[]> = installationRepos): Promise<NodeJS.ProcessEnv> {
+  if (Object.hasOwn(env, 'GH_REPO') || insideGitCheckout(cwd)) return env;
+  const token = env.GH_TOKEN;
+  if (!token) throw new Error('GitHub repository unknown outside a git checkout — set GH_REPO');
+  const repos = await list(token);
+  if (repos.length !== 1) throw new Error(`GitHub repository unknown outside a git checkout — App installation has ${repos.length} repositories; set GH_REPO`);
+  debug.log('landing-heal', 'gh-repo', { source: 'github-app-installation', repo: repos[0] });
+  return { ...env, GH_REPO: repos[0] };
+}
+function insideGitCheckout(cwd: string): boolean {
+  for (let dir = resolve(cwd); ; dir = dirname(dir)) {
+    if (existsSync(join(dir, '.git'))) return true;
+    if (dirname(dir) === dir) return false;
+  }
+}
+async function installationRepos(token: string): Promise<string[]> {
+  const response = await fetch('https://api.github.com/installation/repositories?per_page=2', { headers: { Authorization: `Bearer ${token}`, Accept: 'application/vnd.github+json' } });
+  if (!response.ok) throw new Error(`GitHub App installation repositories: HTTP ${response.status}`);
+  const body = await response.json() as { repositories?: Array<{ full_name?: string }> };
+  return (body.repositories ?? []).flatMap((repo) => repo.full_name ? [repo.full_name] : []);
+}
+let resolvedEnv: NodeJS.ProcessEnv | undefined;
 const gh: RunCommand = (args) => {
-  const result = spawnSync('gh', args, { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+  const result = spawnSync('gh', args, { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024, env: resolvedEnv ?? ghEnv() });
   if (result.error || result.status !== 0) throw new Error(`gh ${args.slice(0, 2).join(' ')} failed: ${result.stderr || String(result.error)}`);
   return result.stdout;
 };
@@ -44,6 +81,18 @@ function pullRequests(ctx: GraphContext): PullRequest[] {
   return value as PullRequest[];
 }
 
+/** 착지 뒤 검증 표식 — 코멘트 «첫 줄»이 `landing-verified:` 로 시작하고 뒤에 무엇이든 한 글자는 있어야 한다(빈 표식은 표식이 아니다). */
+export function isLandingVerified(body: string | undefined): boolean {
+  return /^landing-verified:\s*\S/.test((body ?? '').trimStart().split('\n')[0] ?? '');
+}
+
+/** 코멘트 «첫 줄»이 `must-fix resolved in #N[, #M]` 이면 그 PR 번호들. */
+export function resolvedInPrs(body: string | undefined): number[] {
+  const first = (body ?? '').trimStart().split('\n')[0] ?? '';
+  const match = /^must[-\s]?fix resolved in (#\d+(?:\s*,\s*#\d+)*)/i.exec(first);
+  return match ? [...match[1]!.matchAll(/#(\d+)/g)].map((m) => Number(m[1])) : [];
+}
+
 export function runMission(mission: string, ctx: GraphContext, run: RunCommand = gh, now = new Date()): Record<string, unknown> {
   switch (mission) {
     case 'collect': {
@@ -66,34 +115,79 @@ export function runMission(mission: string, ctx: GraphContext, run: RunCommand =
         const pages = JSON.parse(run(['api', `repos/{owner}/{repo}/pulls/${pr.number}/comments`, '--paginate', '--slurp'])) as Array<Array<{ body?: string }>>;
         if (!Array.isArray(pages) || !pages.every(Array.isArray)) throw new Error(`invalid review comments for PR #${pr.number}`);
         const inline = pages.flat();
+        const comments = [...(details.reviews ?? []), ...(details.comments ?? []), ...inline];
+        const reviewRounds = comments.filter(({ body }) => {
+          const meta = body ? parse(body) : null;
+          return meta?.role === 'reviewer' && !!meta.run && meta.round !== undefined;
+        });
+        // 뒤 PR 로 고친 must-fix 는 원래 PR 에 첫 줄 `must-fix resolved in #N` 코멘트를 남긴다(🅞·🅣 09-29 합의) — 그 PR 의 «열린» 항목을 풀고, 그 코멘트 자체는 must-fix 로 세지 않는다.
+        const resolvedNotes = comments.filter(({ body }) => resolvedInPrs(body).length > 0);
+        const resolvedIn = [...new Set(resolvedNotes.flatMap(({ body }) => resolvedInPrs(body)))].sort((a, b) => a - b);
+        const classified = classifyReviewRounds(reviewRounds).map((item) => item.verdict === 'open' && resolvedIn.length
+          ? { ...item, verdict: 'resolved' as const, resolvedIn } : item);
         const mustFixes = [...(ctx.input?.mustFixByPr?.[String(pr.number)] ?? []),
-          ...[...(details.reviews ?? []), ...(details.comments ?? []), ...inline]
-            .flatMap((review) => review.body && /must[-\s]?fix/i.test(review.body) ? [review.body] : [])];
-        if (!mustFixes.length) continue;
-        const diff = run(['pr', 'diff', String(pr.number), '--patch']);
-        for (const text of mustFixes) matches.push({ pr: pr.number, text, verdict: matchMustFix(text, diff) });
+          ...comments.filter((comment) => !reviewRounds.includes(comment) && !resolvedNotes.includes(comment))
+            .flatMap(({ body }) => body && /must[-\s]?fix/i.test(body) ? [body] : [])];
+        const diff = mustFixes.length ? run(['pr', 'diff', String(pr.number), '--patch']) : '';
+        const prMatches: Match[] = [
+          ...classified.map((item) => ({ pr: pr.number, ...item })),
+          ...mustFixes.map((text) => ({ pr: pr.number, text, verdict: matchMustFix(text, diff) })),
+        ];
+        matches.push(...prMatches);
+        debug.log('landing-heal', 'must-fix-classified', {
+          pr: pr.number,
+          rereviewed: prMatches.filter((item) => item.verdict === 'rereviewed').length,
+          open: prMatches.filter((item) => item.verdict === 'open').length,
+          unknown: prMatches.filter((item) => item.verdict === 'unknown').length,
+        });
       }
       return { outcome: 'ok', matches };
     }
-    case 'verify-needed':
-      return { outcome: 'ok', verifyNeeded: pullRequests(ctx)
-        .filter((pr) => pr.state === 'MERGED' && pr.files.some((file) => file.path.startsWith('apps/pwa/') || file.path.startsWith('src/')))
-        .map((pr) => pr.number) };
+    case 'verify-needed': {
+      const candidates = pullRequests(ctx)
+        .filter((pr) => pr.state === 'MERGED' && pr.files.some((file) => file.path.startsWith('apps/pwa/') || file.path.startsWith('src/')));
+      // 착지 뒤 검증을 끝낸 쪽은 PR 코멘트 첫 줄 `landing-verified: <sha> · <무엇을 쟀나>` 를 남긴다(🅞·🅣 09-29 합의) — 그 PR 은 뺀다.
+      const verified: number[] = [];
+      const verifyNeeded = candidates.filter((pr) => {
+        const { comments } = JSON.parse(run(['pr', 'view', String(pr.number), '--json', 'comments'])) as { comments?: Array<{ body?: string }> };
+        const done = (comments ?? []).some((comment) => isLandingVerified(comment.body));
+        if (done) verified.push(pr.number);
+        return !done;
+      }).map((pr) => pr.number);
+      return { outcome: 'ok', verifyNeeded, verified };
+    }
     case 'report': {
-      const prs = pullRequests(ctx).length;
+      const collected = pullRequests(ctx);
+      const prs = collected.length;
       const matches = output(ctx, 'must-fix-match').matches as Match[];
-      const mustFixUnresolved = matches.filter((item) => item.verdict === 'unresolved' || item.verdict === 'unknown').length;
+      const mustFixOpen = matches.filter((item) => item.verdict === 'open' || item.verdict === 'unresolved').length;
+      const mustFixUnknown = matches.filter((item) => item.verdict === 'unknown').length;
+      const mustFixRereviewed = matches.filter((item) => item.verdict === 'rereviewed').length;
+      const mustFixUnresolved = mustFixOpen + mustFixUnknown;
       const verifyNeeded = output(ctx, 'verify-needed').verifyNeeded as number[];
-      debug.log('landing-heal', 'tick', { prs, mustFixUnresolved, verifyNeeded });
-      emitDecision({ kind: 'VERIFY', what: `착지·치유 관측: PR ${prs}건`, reason: `must-fix 미해결/미상 ${mustFixUnresolved}건 · 착지 뒤 검증 필요 ${verifyNeeded.length}건`, purpose: '착지 후속 작업 관측', target: 'landing-heal', ...(ctx.runId ? { runId: ctx.runId } : {}) });
-      return { outcome: 'ok', prs, mustFixUnresolved, verifyNeeded };
+      const mergedPrs = new Set(collected.filter((pr) => pr.state === 'MERGED').map((pr) => pr.number));
+      const landedOpen = matches.filter((item) => item.verdict === 'open' && mergedPrs.has(item.pr));
+      const unresolved = matches.filter((item) => item.verdict === 'unresolved').length;
+      const openPrs = [...new Set(landedOpen.map((item) => item.pr))].sort((a, b) => a - b);
+      const open = landedOpen.length;
+      debug.log('landing-heal', 'tick', { prs, mustFixUnresolved, mustFixOpen, mustFixUnknown, mustFixRereviewed, verifyNeeded });
+      (ctx.decision ?? emitDecision)({
+        kind: 'VERIFY',
+        what: `착지·치유 관측: PR ${prs}건${open ? ` — 열린 must-fix ${open}건(PR ${openPrs.map((pr) => `#${pr}`).join(', ')})` : ''}`,
+        reason: `열린 채 착지 ${open}건 · 미해결 ${unresolved}건 · 미상 ${mustFixUnknown}건 · 다시 봄 ${mustFixRereviewed}건 · 착지 뒤 검증 필요 ${verifyNeeded.length}건`,
+        purpose: '착지 후속 작업 관측', target: 'landing-heal', ...(ctx.runId ? { runId: ctx.runId } : {}),
+      });
+      return { outcome: 'ok', prs, mustFixUnresolved, mustFixOpen, mustFixUnknown, mustFixRereviewed, verifyNeeded };
     }
     default: throw new Error(`unknown landing-heal mission: ${mission}`);
   }
 }
 
 if (import.meta.main) {
-  try { process.stdout.write(`${JSON.stringify(runMission(process.argv[2] ?? '', context()))}\n`); }
+  try {
+    resolvedEnv = await ghRepoEnv(ghEnv(), process.cwd());
+    process.stdout.write(`${JSON.stringify(runMission(process.argv[2] ?? '', context()))}\n`);
+  }
   catch (error) {
     process.stderr.write(`${String(error)}\n`);
     process.exitCode = 1;

package/scripts/lib/android-test-device.ts

@@ -0,0 +1,32 @@
+// 계측 시험(`connectedDebugAndroidTest`)을 «어느 기기»에서 돌리나.
+// ⛔ Gradle 은 시험이 끝나면 앱을 «지운다»(데이터까지). 실기기에서 돌면 대표 폰의 앱이 사라진다
+//    (2026-09-30 실측: pr land 의 android-gate 가 USB 로 꽂힌 폴드 8 에서 돌아 설치본이 지워졌다).
+// ⇒ 에뮬레이터(`emulator-*`)만 고른다. 실기기를 쓰려면 serial 을 «명시»해야 한다.
+
+export type TestDevicePick =
+  | { kind: 'use'; serial: string }
+  | { kind: 'skip'; reason: string };
+
+/** `adb devices` 출력에서 «device» 상태인 serial 들. */
+export function attachedSerials(adbDevicesOutput: string): string[] {
+  return adbDevicesOutput
+    .split('\n')
+    .slice(1)
+    .map((line) => line.trim().split(/\s+/))
+    .filter((cols) => cols.length >= 2 && cols[1] === 'device')
+    .map((cols) => cols[0]!);
+}
+
+export function pickInstrumentedTestDevice(adbDevicesOutput: string, explicitSerial?: string): TestDevicePick {
+  const serials = attachedSerials(adbDevicesOutput);
+  if (explicitSerial) {
+    return serials.includes(explicitSerial)
+      ? { kind: 'use', serial: explicitSerial }
+      : { kind: 'skip', reason: `지정한 기기 ${explicitSerial} 가 연결돼 있지 않다` };
+  }
+  const emulator = serials.find((s) => s.startsWith('emulator-'));
+  if (emulator) return { kind: 'use', serial: emulator };
+  return serials.length > 0
+    ? { kind: 'skip', reason: `에뮬레이터가 없다 — 실기기 ${serials.length}대에서는 돌리지 않는다(시험이 앱과 데이터를 지운다) · 실기기를 쓰려면 ELANOUS_ANDROID_TEST_SERIAL=<serial>` }
+    : { kind: 'skip', reason: '연결된 기기·에뮬레이터가 없다' };
+}

package/scripts/lib/front-route-measurement.ts

@@ -0,0 +1,131 @@
+import { classifyIntakeFrontRoute } from '../../src/intake-plane/front-route-classifier.js';
+import { INTAKE_FRONT_ROUTE_TRACKS, type IntakeFrontRouteDecision, type IntakeFrontRouteTrack } from '../../src/intake-plane/front-route-rules.js';
+import type { ResolveRoleProviderFn } from '../../src/intake-plane/runtime-callables.js';
+import { wilsonInterval, type WilsonInterval } from './nl-routing-measurement.js';
+
+export interface FrontRouteItem { id: string; text: string; expected: IntakeFrontRouteTrack }
+export interface FrontRouteCorpus { description: string; items: FrontRouteItem[] }
+export type FrontRouteConfusion = Record<IntakeFrontRouteTrack, Record<IntakeFrontRouteTrack, number>>;
+export interface FrontRouteProviderResult {
+  label: string;
+  runs: number;
+  agree: number;
+  agreement: number;
+  wilson: WilsonInterval | null;
+  askHuman: number;
+  confusion: FrontRouteConfusion;
+  meanLatencyMs: number;
+  perItem: { id: string; expected: IntakeFrontRouteTrack; got: IntakeFrontRouteTrack[] }[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isTrack(value: unknown): value is IntakeFrontRouteTrack {
+  return typeof value === 'string' && (INTAKE_FRONT_ROUTE_TRACKS as readonly string[]).includes(value);
+}
+
+export function loadFrontRouteCorpus(json: unknown): FrontRouteCorpus {
+  const parsed: unknown = typeof json === 'string' ? JSON.parse(json) : json;
+  if (!isRecord(parsed) || typeof parsed.description !== 'string' || !Array.isArray(parsed.items) || parsed.items.length === 0) {
+    throw new Error('Front-route corpus requires a description and nonempty items array');
+  }
+  const ids = new Set<string>();
+  const items: FrontRouteItem[] = parsed.items.map((raw: unknown, index: number) => {
+    if (!isRecord(raw) || typeof raw.id !== 'string' || !raw.id.trim() ||
+      typeof raw.text !== 'string' || !raw.text.trim() || !isTrack(raw.expected)) {
+      throw new Error(`Invalid front-route corpus item at index ${index} (id, text, expected track required)`);
+    }
+    if (ids.has(raw.id)) throw new Error(`Duplicate front-route corpus id at index ${index}`);
+    ids.add(raw.id);
+    return { id: raw.id, text: raw.text, expected: raw.expected };
+  });
+  return { description: parsed.description, items };
+}
+
+function emptyConfusion(): FrontRouteConfusion {
+  return Object.fromEntries(INTAKE_FRONT_ROUTE_TRACKS.map((expected) => [expected,
+    Object.fromEntries(INTAKE_FRONT_ROUTE_TRACKS.map((got) => [got, 0])),
+  ])) as FrontRouteConfusion;
+}
+
+export async function measureFrontRoute(
+  items: readonly FrontRouteItem[],
+  { providers, runs, classify = classifyIntakeFrontRoute, now = () => performance.now() }: {
+    providers: readonly { label: string; resolve: ResolveRoleProviderFn }[];
+    runs: number;
+    classify?: typeof classifyIntakeFrontRoute;
+    now?: () => number;
+  },
+): Promise<FrontRouteProviderResult[]> {
+  if (!Number.isSafeInteger(runs) || runs < 1) throw new Error('runs must be a positive integer');
+  if (!items.length || !providers.length) throw new Error('items and providers must not be empty');
+  if (new Set(providers.map(({ label }) => label)).size !== providers.length || providers.some(({ label }) => !label.trim())) {
+    throw new Error('provider labels must be unique and nonempty');
+  }
+  // An id can contain another item's text, too: sanitize against the whole corpus.
+  const texts = items.map(({ text }) => text);
+  const exposesText = (id: string) => texts.some((text) => id.includes(text));
+  const safeIds = new Set(items.filter(({ id }) => !exposesText(id)).map(({ id }) => id));
+  const reportIds = items.map(({ id }, index) => {
+    if (!exposesText(id)) return id;
+    let candidate = `item-${index + 1}`;
+    if (exposesText(candidate) || safeIds.has(candidate)) {
+      let codePoint = 0xe000;
+      while (texts.some((text) => text.includes(String.fromCodePoint(codePoint)))) codePoint++;
+      const unused = String.fromCodePoint(codePoint);
+      candidate = unused;
+      while (safeIds.has(candidate)) candidate += unused;
+    }
+    safeIds.add(candidate);
+    return candidate;
+  });
+  const results: FrontRouteProviderResult[] = [];
+  for (const { label, resolve } of providers) {
+    const confusion = emptyConfusion();
+    const perItem: FrontRouteProviderResult['perItem'] = [];
+    let agree = 0;
+    let askHuman = 0;
+    let latencyMs = 0;
+    for (const [index, item] of items.entries()) {
+      const got: IntakeFrontRouteTrack[] = [];
+      for (let repeat = 0; repeat < runs; repeat++) {
+        const started = now();
+        let decision: IntakeFrontRouteDecision;
+        try {
+          decision = await classify(item.text, { resolveRoleProvider: resolve });
+        } catch {
+          decision = { track: 'ask-human', confidence: 0, reason: 'classifier-failed:llm-error', decidedBy: 'classifier' };
+        } finally {
+          latencyMs += now() - started;
+        }
+        if (!isTrack(decision.track)) throw new Error(`Invalid classifier track for item ${reportIds[index]}`);
+        got.push(decision.track);
+        confusion[item.expected][decision.track]++;
+        if (decision.track === item.expected) agree++;
+        if (decision.track === 'ask-human' &&
+          (decision.reason.startsWith('classifier-low-confidence:') || decision.reason.startsWith('classifier-failed:'))) askHuman++;
+      }
+      perItem.push({ id: reportIds[index]!, expected: item.expected, got });
+    }
+    const total = items.length * runs;
+    results.push({ label, runs: total, agree, agreement: agree / total, wilson: wilsonInterval(agree, total), askHuman,
+      confusion, meanLatencyMs: latencyMs / total, perItem });
+  }
+  return results;
+}
+
+export function formatFrontRouteReport(result: readonly FrontRouteProviderResult[]): string {
+  const percent = (n: number) => `${(100 * n).toFixed(1)}%`;
+  const lines = ['Provider | Agreement | 95% Wilson | ask-human (low confidence/failure) | Mean latency ms'];
+  for (const provider of result) {
+    const interval = provider.wilson;
+    lines.push(`${provider.label} | ${provider.agree}/${provider.runs} (${percent(provider.agreement)}) | ${interval ? `${percent(interval.lower)}–${percent(interval.upper)}` : 'n/a'} | ${provider.askHuman} | ${provider.meanLatencyMs.toFixed(1)}`);
+    lines.push(`Confusion (${provider.label}): expected \\ got | ${INTAKE_FRONT_ROUTE_TRACKS.join(' | ')}`);
+    for (const expected of INTAKE_FRONT_ROUTE_TRACKS) {
+      lines.push(`${expected} | ${INTAKE_FRONT_ROUTE_TRACKS.map((got) => provider.confusion[expected][got]).join(' | ')}`);
+    }
+  }
+  return lines.join('\n');
+}