elanous 0.2.24 → 0.2.25

package/src/cli/release-cli.ts

@@ -1107,17 +1107,18 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .description('가벼운 RC 점검 — 직전 판 컷(또는 --base) 이후 변경 범위 self gate ⊕ 상시 목록(release/light-rc-always.txt)을 원격 게이트 호스트에서 · 새 회귀(introduced>0)면 exit 1')
     .requiredOption('--version <v>', '점검할 판(x.y.z)')
     .option('--base <ref>', '비교 기준(기본: git merge-base origin/main origin/release/<원장 직전 판>)')
+    .option('--head <ref>', '잴 커밋(기본: git fetch origin main 뒤 origin/main — 작업 트리 HEAD 가 아니다 · 다르면 분리 체크아웃에서 잰다)')
     .option('--remote <host>', '게이트 호스트(기본 config gateRemote.host)')
     .option('--local', '원격 대신 이 기계에서 돌린다(원격 자식이 이것으로 다시 불린다)')
     .option('--shards <n>', '시험 분할 수', '4')
     .option('--json', '결과 한 줄 JSON(stdout) · 사람 줄은 stderr')
-    .action(async (o: { version: string; base?: string; remote?: string; local?: boolean; shards: string; json?: boolean }) => {
+    .action(async (o: { version: string; base?: string; head?: string; remote?: string; local?: boolean; shards: string; json?: boolean }) => {
       // The root strips `--local` from argv (remote-bookmark attach) before Commander sees it — same read as `self gate`.
       const local = !!o.local || process.argv.slice(2).includes('--local');
       await jsonAction(o.json, async (log) => {
         if (o.remote !== undefined && local) throw new Error('release light-rc: --remote and --local cannot be combined');
         const shards = Number(o.shards);
-        const result = await runLightRc(o.version, { base: o.base, remote: o.remote, local, shards, ledgerRoot: releaseRunDeps.ledgerRoot, log: (l) => console.error(l) }, lightRcDeps);
+        const result = await runLightRc(o.version, { base: o.base, head: o.head, remote: o.remote, local, shards, ledgerRoot: releaseRunDeps.ledgerRoot, log: (l) => console.error(l) }, lightRcDeps);
         for (const line of formatLightRc(result)) log(line);
         return result;
       }, (r) => r.ok);
@@ -1126,7 +1127,8 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .description('실패한 릴리스 런을 이어 달린다 — cut-branch --append 로 고친 release/<v> 새 끝을 version-release 기록에 반영(빨리감기만·상태 백업) 뒤 --from 노드부터')
     .requiredOption('--run <runId>', '실패한 release-loop 런 ID')
     .requiredOption('--from <node>', '다시 시작할 노드(예: gate)')
-    .option('--partial', 'GATE-PARTIAL — --from gate 에서 앞 게이트 뒤 바뀐 시험 파일 ⊕ 앞 실패 파일만 다시 돈다(시험·문서만 바뀐 경우 · 아니면 전체 게이트로)')
+    .option('--partial', 'GATE-PARTIAL — --from gate 에서 바뀐 시험 ⊕ 앞 실패 ⊕ 바뀐 코드에 import 로 닿는 시험만 다시 돈다(끝이 움직인 --from gate 는 기본 · 의심이면 전체 게이트)')
+    .option('--no-partial', 'GATE-REUSE-BY-DIFF 기본 부분 재검을 끄고 전체 게이트')
     .option('--waive <node>', '저장된 실패 노드 한 개를 면제(--from 은 그 노드 그대로)')
     .option('--reason <text>', '면제 사유 — 공개 알려진 문제에 들어갈 사용자 영향 설명')
     .option('--accepted-regressions <json>', '알려진 문제 추가 입력 JSON 배열 [{"id":"…","note":"…"}]')
@@ -1153,7 +1155,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
         const override = result.state.inputOverrides?.at(-1);
         if (o.gateExecutor !== undefined && override) log(`⇄ gate 실행기 ${override.set.gateExecutor}${override.set.gateRemote ? ` @ ${override.set.gateRemote}` : ''} (런 입력에 기록 · 면제 아님)`);
         if (result.partial.requested) log(result.partial.applied
-          ? `◐ 부분 재검: ${result.partial.files}파일 · 나머지는 앞 게이트(${result.partial.priorCommit.slice(0, 12)}) 결과를 잇는다`
+          ? `◐ 부분 재검${result.partial.auto ? '(기본)' : ''}: ${result.partial.files}파일${result.partial.closure ? ` (코드 닿음 ${result.partial.closure.reached} · 닫힘 불투명 ${result.partial.closure.opaque})` : ''} · 나머지는 앞 게이트(${result.partial.priorCommit.slice(0, 12)}) 결과를 잇는다`
           : `● 전체 게이트로: ${result.partial.reason}`);
         log(`${result.tip.changed ? `↻ ${result.tip.branch} ${result.tip.from.slice(0, 12)} → ${result.tip.to.slice(0, 12)} (백업 ${result.tip.backup})` : `· ${result.tip.branch} 끝 그대로 ${result.tip.to.slice(0, 12)}`} · ${o.from} 부터 → ${result.state.status}`);
         return { tip: result.tip, partial: result.partial, status: result.state.status, runId: result.state.runId,
@@ -1184,14 +1186,14 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
         const result = await autoStartScheduledRelease({
           windowMinutes: Number(o.windowMinutes), apply: o.apply, ledgerRoot: scheduleLedgerRoot(),
           readiness: (version, ledgerRoot, now) => releaseReadiness(version, { ledgerRoot, now: () => now, checklist: releaseRunDeps.checklist }),
-          launch: async (version) => {
-            const ran = await runAction({ version, ifReady: true, json: false }, log);
+          launch: async (version, launchOptions) => {
+            const ran = await runAction({ version, ifReady: true, publishAt: launchOptions?.publishAt, json: false }, log);
             if (ran && typeof ran === 'object' && ran.deferred) return ran;
             if (ran !== true) throw new Error(`release run 미시작 또는 실패: ${version}`);
           },
         });
         if (result.status === 'planned') log(`· 미리 보기 ${result.version} · 컷 ${result.cutAt} · 실행하려면 --apply`);
-        else if (result.status === 'started') log(`▶ 릴리스 시작 ${result.version} · 컷 ${result.cutAt}`);
+        else if (result.status === 'started') log(`▶ 릴리스 시작 ${result.version} · 컷 ${result.cutAt}${result.publishAt ? ` · 발행 ${result.publishAt}` : ''}`);
         else if (result.status === 'skipped') log(`· 릴리스 연기 ${result.version} · ${result.reason}`);
         else log('· 선택할 컷 없음');
         return result;

package/src/cli/release-run-if-ready.ts

@@ -2,6 +2,8 @@ import { closeSync, mkdirSync, openSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { releaseLedgerRoot } from '../instance/resolve.js';
+import { adviseLaunch, compareLaunchAdvice } from '../harness/launch-advice.js';
+import type { QueuePool } from '../harness/harness-queue.js';
 import type { ReleaseReadiness } from '../../scripts/release-loop/release-readiness.js';
 
 export type ReleaseIfReadySkip = { skipped: true; reason: Exclude<ReleaseReadiness, { ready: true }>['reason']; detail: string };
@@ -12,6 +14,8 @@ export async function runReleaseIfReady<T>(version: string, deps: {
   ledgerRoot?: string;
   pid?: number;
   now?: () => Date;
+  advice?: typeof adviseLaunch;
+  pool?: () => QueuePool | undefined;
 }): Promise<ReleaseIfReadySkip | { skipped: false; result: T }> {
   const skip = (readiness: Exclude<ReleaseReadiness, { ready: true }>): ReleaseIfReadySkip => {
     const detail = readiness.reason === 'checklist-blocked'
@@ -40,6 +44,13 @@ export async function runReleaseIfReady<T>(version: string, deps: {
     const insideLock = await deps.readiness(version, { isPidAlive: () => false });
     if (!insideLock.ready) return skip(insideLock);
     debug.log('release-loop.readiness', 'ready', { version });
+    try {
+      const advice = (deps.advice ?? adviseLaunch)({ pool: deps.pool?.(), caller: 'release-run' });
+      const { kind } = compareLaunchAdvice(advice, 'launched');
+      debug.log('resource.advice', 'launch-advice', { caller: 'release-run', verdict: advice.verdict, why: advice.why, actual: 'launched', kind, version });
+    } catch {
+      // Shadow only: a throwing advice seam must never affect the launch decision or result.
+    }
     return { skipped: false, result: await deps.run() };
   } finally {
     closeSync(fd);

package/src/cli/resource-cli.ts

@@ -0,0 +1,48 @@
+import type { Command } from 'commander';
+import { debug } from '../debug/log.js';
+import { TRAFFIC_SEATS, type TrafficResult } from '../loops/orchestrator/traffic.js';
+import { observeLoopResources } from '../nexus/api/loop-resources.js';
+import { writeStdoutJson } from './stdout-json.js';
+
+/** 칸 제목은 여러 줄(«대상 경로:»·«신설:» …)이다 — 표의 한 칸에는 첫 줄만, 상한을 넘으면 «…» 로 자른 것을 표시한다. */
+export const RESOURCE_TITLE_MAX_CHARS = 60;
+export function oneLineTitle(title: string): string {
+  const first = (title.split(/\r?\n/).find((line) => line.trim()) ?? '').replace(/\s+/g, ' ').trim();
+  return first.length > RESOURCE_TITLE_MAX_CHARS ? `${first.slice(0, RESOURCE_TITLE_MAX_CHARS - 1)}…` : first;
+}
+
+/** Read-only CLI view of the same traffic snapshot returned by the Nexus resource GET. */
+export function registerResourceCommands(program: Command, observe: () => TrafficResult = observeLoopResources): void {
+  program.command('resource').description('자리별 루프 자원 관측 (읽기 전용)')
+    .command('status').description('자리별 공급·다음 칸·임대 상태')
+    .option('--json', '관측 스냅샷 JSON 출력')
+    .action(async (opts: { json?: boolean }) => {
+      let resource: TrafficResult;
+      try { resource = observe(); }
+      catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        debug.log('resource.loop', 'status-read', { readStatus: 'unreadable', seats: null, cells: null });
+        process.exitCode = 1;
+        if (opts.json) await writeStdoutJson(JSON.stringify({ readStatus: 'unreadable', reason }) + '\n');
+        else console.error(`resource status: 못 읽음 — ${reason}`);
+        return;
+      }
+      debug.log('resource.loop', 'status-read', {
+        readStatus: 'ok', seats: resource.seats.length,
+        cells: resource.seats.filter(row => row.nextCell !== null).length,
+      });
+      if (opts.json) {
+        await writeStdoutJson(JSON.stringify({ resource, readStatus: 'ok' }) + '\n');
+        return;
+      }
+      console.log('자리\t쓰는 자리/공급\t다음 칸\t임대(빌림/빌려줌)\t대기 이유');
+      for (const seat of TRAFFIC_SEATS) {
+        const row = resource.seats.find(item => item.seat === seat);
+        if (!row) { console.log(`${seat}\t못 읽음\t못 읽음\t못 읽음\t자리 관측 없음`); continue; }
+        const cell = row.nextCell;
+        const reason = !cell ? '다음 칸 없음' : row.launchCap <= row.running ? '발사 자리 없음' : '다음 칸 대기';
+        console.log(`${seat}\t${row.running}/${row.cap}\t${cell ? `1 · ${cell.id} ${oneLineTitle(cell.title)}` : '0'}\t${row.borrowed}/${row.lent}\t${reason}`);
+      }
+      if (resource.unassigned > 0) console.log(`미배정\t${resource.unassigned}`);
+    });
+}

package/src/cli/retro-cli.ts

@@ -1,8 +1,10 @@
 import { existsSync } from 'node:fs';
 import type { Command } from 'commander';
+import { readRunExits } from '../harness/harness-incidents.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { LogStore, logsDbPath } from '../mss/logging/log-store.js';
 
-type RetroFact = { store: string; at: string; category: string; event: string; kind: 'draft-birth' | 'draft-death' | 'stop-reason' | 'ta-outcome'; data: unknown };
+type RetroFact = { store: string; at: string; category: string; event: string; kind: 'draft-birth' | 'draft-death' | 'stop-reason' | 'ta-outcome' | 'incident'; data: unknown };
 
 const FACT_EVENTS = new Map<string, RetroFact['kind']>([
   ['rework-blocked-draft-pr', 'draft-birth'],
@@ -21,7 +23,7 @@ export function parseRetroSince(value: string, now = Date.now()): number {
   return now - duration;
 }
 
-export function collectRetroFacts(sinceMs: number, targets: readonly { name: string; dbPath: string }[] = [{ name: 'current', dbPath: logsDbPath() }]): { facts: RetroFact[]; unavailable: string[] } {
+export function collectRetroFacts(sinceMs: number, targets: readonly { name: string; dbPath: string }[] = [{ name: 'current', dbPath: logsDbPath() }], incidentRoot?: string): { facts: RetroFact[]; unavailable: string[] } {
   const facts: RetroFact[] = [];
   const unavailable: string[] = [];
   const untilMs = Date.now();
@@ -53,13 +55,20 @@ export function collectRetroFacts(sinceMs: number, targets: readonly { name: str
       } finally { store.close(); }
     } catch { unavailable.push(target.name); }
   }
+  try {
+    for (const row of readRunExits(incidentRoot ?? effectiveInstanceRoot())) {
+      if (Date.parse(row.at) < sinceMs) continue;
+      facts.push({ store: 'incidents', at: row.at, category: 'harness.incident', event: row.reason, kind: 'incident',
+        data: { runId: row.runId, seat: row.seat, entrance: row.entrance } });
+    }
+  } catch { unavailable.push('incidents'); }
   facts.sort((a, b) => b.at.localeCompare(a.at));
   return { facts, unavailable };
 }
 
 export function registerRetroCommands(program: Command): void {
   program.command('retro').description('Read-only retrospective facts from existing logs')
-    .command('facts').description('Draft births/deaths, stop reasons and task-agent outcomes')
+    .command('facts').description('Draft births/deaths, stop reasons, task-agent outcomes and run incidents')
     .option('--since <duration>', 'Lookback duration', '24h')
     .option('--json', 'JSON output')
     .action((opts: { since: string; json?: boolean }) => {

package/src/cli/seat-requests-cli.ts

@@ -2,6 +2,7 @@ import type { Command } from 'commander';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { hqCliWriteAllowed, type HqDeps } from '../hq/hq.js';
 import { isIsolatedLedgerWriteRoot } from '../hq/ledger-write-target.js';
+import { appendDuty, listDuties, type DutyStatus } from '../seat-loop/duty-ledger.js';
 import { closeSeatRequests, listSeatRequests, type SeatRequestStatus } from '../seat-dispatch/seat-request-ledger.js';
 
 function duration(value: string): number {
@@ -49,4 +50,28 @@ export function registerSeatRequestsCommands(seat: Command, deps: { root?: () =>
         for (const row of rows) console.log(`${opts.dryRun ? 'would close' : 'closed'} ${row.key} ${row.status}: ${row.reason}`);
       } catch (error) { console.error(`seat requests close: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
     });
+  const duty = seat.command('duty').description('자리 임무 원장 기록·조회');
+  duty.command('add <seat> <duty>').description('임무 한 줄을 원장에 덧붙임')
+    .requiredOption('--source <source>', '임무의 출처')
+    .option('--ref <ref>', '근거 참조')
+    .option('--status <status>', 'standing|done|missed', 'standing')
+    .action((seatId: string, dutyText: string, opts: { source: string; ref?: string; status: string }) => {
+      try {
+        const row = appendDuty((deps.root ?? effectiveInstanceRoot)(), {
+          seat: seatId, duty: dutyText, source: opts.source, status: opts.status as DutyStatus,
+          ...(opts.ref === undefined ? {} : { ref: opts.ref }),
+        }, deps.now);
+        console.log(`added ${row.seat} ${row.status}: ${row.duty}`);
+      } catch (error) { console.error(`seat duty add: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+    });
+  duty.command('ls').description('임무 원장 조회 (at 순서)')
+    .option('--seat <seat>', '자리 ID')
+    .option('--json', 'JSON 출력')
+    .action((opts: { seat?: string; json?: boolean }) => {
+      try {
+        const rows = listDuties((deps.root ?? effectiveInstanceRoot)(), { seat: opts.seat });
+        if (opts.json) console.log(JSON.stringify(rows));
+        else for (const row of rows) console.log(`${row.at} ${row.seat} ${row.status} ${row.duty} (${row.source}${row.ref ? ` ${row.ref}` : ''})`);
+      } catch (error) { console.error(`seat duty ls: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+    });
 }

package/src/cli/tasks-cli.ts

@@ -10,11 +10,11 @@ import { checklistDevVersion } from '../release-loop/checklist.js';
 import { cardsBoard, countBoardTasks, INTERNAL_PACK_PROJECT, mergeBoards, releasePackBoard, type BoardNode } from '../task-agent/board.js';
 import type { Task } from '../task-orchestrator/types.js';
 import { cardPrNumber, CLOSED_BY_HAND_EVENT, closeTaskCard, COMPLETION_KINDS, handTask, updateTaskCard, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, nextMoveFor, resolveHandText, readTaskAgentState, readTaskCard, taskAgentStatePath as taskStatePathDefault, shellQuote, TA_LAND_ENV, TASK_CARD_PREFIX, TASK_SEATS, type CompletionKind, type TaskCard, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
-import { readCardSalvageBranch, refreshCardRunBinding, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
+import { readCardSalvageBranch, recordWiringLiveVerified, refreshCardRunBinding, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
 import { captureReviewResults } from '../task-agent/review-result-capture.js';
 import { HAND_MOVE_KINDS, recordHandMove } from '../task-agent/live-move-history.js';
 import { advanceMission, handMission, MissionAdvanceError, openMissionIds, recordPieceRef, type AdvanceMissionResult, type MissionDecompose, type PieceEvidenceReader } from '../task-agent/mission.js';
-import { formatTaskAgentCover, measureTaskAgentCover, type CoverRow, type TaskAgentCoverInput } from '../task-agent/cover.js';
+import { formatSevenVerbLive, formatTaskAgentCover, measureSevenVerbLive, measureTaskAgentCover, type CoverRow, type SevenVerbLive, type TaskAgentCoverInput } from '../task-agent/cover.js';
 import { LogStore, STORE_SAFETY_MAX, type LogQuery, type LogStoreRow } from '../mss/logging/log-store.js';
 import { resolveLogTargets } from './logs-cli.js';
 
@@ -41,6 +41,8 @@ export interface TasksCliDeps {
   releaseBoard?: () => BoardNode[];
   /** `tasks show`·`advance` 의 런 근거 읽기(시험 주입) — 기본 = 런 원장(이 우주 ⊕ 연합) ⊕ 호스트 logs 의 Pod job-finished. */
   cardRunEvidence?: CardRunEvidenceDeps;
+  /** `tasks live-verified` 가 적는 런 원장 디렉터리(시험 주입). 기본 = `runLedgerDir()`. */
+  liveVerifiedLedgerDir?: string;
   /** HARNESS-PARENT-ON-MSB1 — 원격 부모 카드의 원장 거울(시험 주입). 기본 = ssh 로 `<prodRoot>/remote-parents/<host>/run-ledger`. */
   remoteLedgerMirror?: (card: TaskCard) => void;
   /** `tasks parents` 의 낡은 부모 보고 의존(시험 주입). */
@@ -174,6 +176,7 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
     try { preflight = parentHostModule.preflightParentHost({ target, localVersion: deps.localVersion ?? parentHostModule.localElanousVersion(), launchHoldActive, ...(deps.ssh ? { ssh: deps.ssh } : {}) }); }
     catch (error) { failed(target, [`preflight-error: ${error instanceof Error ? error.message : String(error)}`]); continue; }
     if (!preflight.ok) { failed(target, preflight.gaps, preflight.facts); continue; }
+    if (preflight.warnings.length) notice(`⚠ ${target.host} 자격: ${preflight.warnings.join(' · ')}`);
     try {
       const launched = parentHostModule.launchRemoteParent(target, args, context.env, deps.ssh);
       try { debug.log('task-agent', 'parent-host-launched', { host: target.host, runId: context.runId, pid: launched.pid, log: launched.log }); } catch { /* fail-soft */ }
@@ -499,7 +502,7 @@ export function readTaskAgentCover(
   window: { sinceMs?: number; untilMs?: number } = {},
   query: NonNullable<TasksCliDeps['coverLogs']> = queryCoverLogs,
   taskCards?: readonly { id: string }[] | null,
-): { rows: CoverRow[]; limitReached: boolean; unreadableStores: number } {
+): { rows: CoverRow[]; sevenVerbs: SevenVerbLive; limitReached: boolean; unreadableStores: number } {
   let unreadableStores = 0;
   const read = (category: 'task-agent' | 'pr.land', event: 'action' | 'step'): { rows: LogStoreRow[]; limitReached: boolean } | null => {
     try {
@@ -523,7 +526,7 @@ export function readTaskAgentCover(
     truncated,
     ...(taskCards === undefined ? {} : { taskCards }),
   };
-  return { rows: measureTaskAgentCover(input), limitReached: truncated.taskAgentActions || truncated.allLands, unreadableStores };
+  return { rows: measureTaskAgentCover(input), sevenVerbs: measureSevenVerbLive(input), limitReached: truncated.taskAgentActions || truncated.allLands, unreadableStores };
 }
 
 export function registerTasksCommands(program: Command, deps: TasksCliDeps = {}): void {
@@ -565,12 +568,15 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           }
           taskCards = coverCardsInWindow(cards, { sinceMs, untilMs });
         }
-        const { rows, limitReached, unreadableStores } = readTaskAgentCover({ sinceMs, untilMs }, deps.coverLogs, taskCards);
+        const { rows, sevenVerbs, limitReached, unreadableStores } = readTaskAgentCover({ sinceMs, untilMs }, deps.coverLogs, taskCards);
         const limitWarning = limitReached ? `조회 상한 ${COVER_QUERY_LIMIT} 도달 — 더 오래된 사건이 있을 수 있다(절단된 수를 전체로 읽지 말 것)` : null;
         const storeWarning = unreadableStores > 0 ? `logs.db ${unreadableStores}개를 못 읽었다 — 그 우주의 사건은 수에 없다(«없다»로 읽지 말 것)` : null;
-        if (opts.json) out(JSON.stringify({ rows, limitReached, unreadableStores, ...(limitWarning ? { warning: limitWarning } : {}), ...(storeWarning ? { storeWarning } : {}) }));
+        if (opts.json) out(JSON.stringify({ rows, sevenVerbs, limitReached, unreadableStores, ...(limitWarning ? { warning: limitWarning } : {}), ...(storeWarning ? { storeWarning } : {}) }));
         else {
-          if (opts.lines) for (const row of rows) out(formatTaskAgentCover(row));
+          if (opts.lines) {
+            for (const row of rows) out(formatTaskAgentCover(row));
+            out(formatSevenVerbLive(sevenVerbs));
+          }
           else {
             out('동사\t대신\t전체\t비율\t상태\t관측 사건');
             for (const row of rows) out(`${row.verb}\t${row.byTaskAgent ?? '-'}\t${row.total ?? '-'}\t${row.ratio ?? '-'}\t${row.state}\t${row.observedActions ?? '-'}`);
@@ -736,6 +742,24 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       out([id, 'hand-move', outcome.entry.kind, outcome.entry.by, outcome.entry.detail, ...(outcome.entry.pr !== undefined ? [`pr ${outcome.entry.pr}`] : [])].join('\t'));
     });
 
+  tasks.command('live-verified <card>')
+    .description('TA-WIRING-CHECK — 실물 1회를 돌린 뒤 그 카드 런 원장에 live-verified {pr, ref, ok, card} 한 줄을 남긴다 · --ref(실물로 돌린 명령·화면 근거)가 비면 거부')
+    .requiredOption('--pr <number>', '실물로 확인한 PR 번호')
+    .requiredOption('--ref <근거>', '실물로 돌린 명령·화면 근거 한 줄(비면 거부)')
+    .option('--fail', '실물이 실패했다(ok=false)')
+    .action(async (cardId: string, opts: { pr: string; ref: string; fail?: boolean }) => {
+      await registerTaskAgentSink(deps.registerSink);
+      const pr = Number(opts.pr);
+      if (!Number.isInteger(pr) || pr <= 0) { out(`--pr 은 자연수다: ${opts.pr}`); process.exitCode = 1; return; }
+      let card: TaskCard | undefined;
+      try { card = readTaskCard(cardId, deps.taskStatePath); } catch (error) { out(error instanceof Error ? error.message : '과제 카드 읽기 실패'); process.exitCode = 1; return; }
+      if (!card) { out(`과제 카드 없음: ${cardId}`); process.exitCode = 1; return; }
+      const outcome = recordWiringLiveVerified(card, { pr, ref: opts.ref, ok: !opts.fail }, deps.liveVerifiedLedgerDir ? { ledgerDir: deps.liveVerifiedLedgerDir } : {});
+      if (!outcome.written) { out(`live-verified 한 줄을 못 남겼다 — ${outcome.reason}`); process.exitCode = 1; return; }
+      try { debug.log('task-agent', 'wiring-live-verified', { card: card.id, runId: card.runId ?? null, pr, ok: outcome.entry.data.ok }); } catch { /* fail-soft */ }
+      out([card.id, 'live-verified', `pr ${pr}`, outcome.entry.data.ok ? 'ok' : 'fail', outcome.entry.data.ref].join('\t'));
+    });
+
   tasks.command('close <cardId>')
     .description('과제 카드를 손으로 닫는다 — 상태를 failed 로 두고 사유를 history(closed-by-hand)에 한 줄 남긴다 · 없는 카드 id 는 거부(exit 1)')
     .requiredOption('--reason <사유>', '닫는 사유(비면 거부)')

package/src/cli/usage-cli.ts

@@ -10,6 +10,7 @@ import type { Command } from 'commander';
 import { collectUnifiedUsage, formatUnifiedUsage } from '../budget/unified-usage.js';
 import { consumeCodexResetCredits, listCodexResetCredits } from '../budget/codex-reset-credits.js';
 import { rollupRunUsage, type RunUsageInput } from '../budget/run-usage-rollup.js';
+import { dedupePodRollupRows } from '../../scripts/usage-rollup.js';
 import { formatUsageOutcomes, outcomeTableHasCodexGrokUnknown, queryUsageOutcomes, type UsageOutcomesDeps, type UsageOutcomesReport } from '../budget/usage-outcomes.js';
 import { LogStore, logsDbPath, type LogQuery, type LogStoreRow } from '../mss/logging/log-store.js';
 import { LOGS_SINCE_OPTION, parseSince } from './logs-cli.js';
@@ -189,7 +190,8 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
         ...(sinceMs !== undefined ? { sinceMs } : {}),
       });
       const unwrapPod = opts.by === 'stage' || opts.by === 'model' || opts.by === 'account';
-      const inputs = rows.map((row) => usageData(row, unwrapPod)).filter((data): data is ExtendedRunUsageInput => data !== null)
+      // ⭐ METER-POD-ROLLUP-GAP-2 — Pod 사용량 재방출 행(podRollupKey)은 «더 완전한 한 행»만 센다(키 없는 행은 그대로).
+      const inputs = dedupePodRollupRows(rows.map((row) => usageData(row, unwrapPod)).filter((data): data is ExtendedRunUsageInput => data !== null))
         .filter((data) => opts.run === undefined || data.runId === opts.run);
       if (opts.by === 'stage' || opts.by === 'model' || opts.by === 'account') {
         const report = rollupByAxis(inputs, opts.by);

package/src/compact/verify-probe.ts

@@ -13,6 +13,7 @@
 
 import type { LLMMessage } from '../llm.js';
 import { streamLLM } from '../llm.js';
+import { debug } from '../debug/log.js';
 import { resolveSummarizerModel } from './provider.js';
 import { buildCompactTranscript, stripCompactScratchpad } from './summarize.js';
 
@@ -36,13 +37,26 @@ export interface VerifyProbeArgs {
   activeModelId?: string;
   summarizerModel?: string;
   timeoutMs?: number;
+  /** Injectable stream call — default `streamLLM` (byte-identical
+   *  behavior when omitted). Tests inject a stub so the probe can be
+   *  exercised with zero real LLM calls. */
+  stream?: typeof streamLLM;
 }
 
+export type VerifyProbeStatus = 'pass' | 'fail' | 'error';
+
 export interface VerifyProbeResult {
   /** True when the probe judged the summary acceptable. */
   ok: boolean;
   /** Probe's response text (free form). Empty when probe failed. */
   notes: string;
+  /** Outcome classification: 'pass' = probe accepted the summary,
+   *  'fail' = probe found a lost detail (ok:false), 'error' = probe
+   *  call failed/timed out (fail-open — ok stays true). */
+  status: VerifyProbeStatus;
+  /** The model the probe ran on (resolveSummarizerModel result);
+   *  null when unresolved. */
+  model: string | null;
 }
 
 export async function runVerifyProbe(
@@ -61,18 +75,24 @@ export async function runVerifyProbe(
     },
   ];
   const timeoutMs = args.timeoutMs ?? 30_000;
+  const stream = args.stream ?? streamLLM;
   try {
     const text = await Promise.race([
-      streamLLM(req, () => { /* silent */ }, model ? { model } : {}),
+      stream(req, () => { /* silent */ }, model ? { model } : {}),
       new Promise<string>((_, reject) =>
         setTimeout(() => reject(new Error('verify probe timeout')), timeoutMs),
       ),
     ]);
     const notes = stripCompactScratchpad(text).trim();
     const ok = /^none\b/i.test(notes) || notes.length === 0;
-    return { ok, notes };
+    const status: VerifyProbeStatus = ok ? 'pass' : 'fail';
+    const result: VerifyProbeResult = { ok, notes, status, model: model ?? null };
+    debug.log('compact.verify-probe', 'probe-result', { status, model });
+    return result;
   } catch {
     // Probe failure is non-fatal — accept the summary by default.
-    return { ok: true, notes: '' };
+    const result: VerifyProbeResult = { ok: true, notes: '', status: 'error', model: model ?? null };
+    debug.log('compact.verify-probe', 'probe-result', { status: result.status, model: result.model });
+    return result;
   }
 }

package/src/context-card/index.ts

@@ -43,3 +43,53 @@ export function serializeContextCard(card: ContextCard, maxChars = CONTEXT_CARD_
   if (length(text) > maxChars) throw new RangeError('card core and omission counts exceed maxChars');
   return text;
 }
+
+/** RFC context-diet §3a — exact fallback wording for a PR body that states no conclusion / could not be read. */
+export const PR_CONCLUSION_NONE = '없음(원문에 결론 없음)';
+export const PR_CONCLUSION_UNREADABLE = '확인 불가';
+
+export interface PrConclusionCardInput {
+  readonly id: string;
+  /** First paragraph of the original body; empty or omitted means the original states no conclusion. */
+  readonly firstParagraph?: string;
+  /** Set when the original body could not be read at all. */
+  readonly unreadable?: boolean;
+  readonly pointers: readonly string[];
+  readonly source: string;
+  readonly updatedAt: string;
+  readonly supersedes?: string;
+}
+
+/** First blank-line-delimited paragraph of the original body, or '' when the body is blank. */
+export function firstParagraphOf(body: string): string {
+  const trimmed = body.trim();
+  return trimmed ? (trimmed.split(/\n\s*\n/)[0] ?? '') : '';
+}
+
+const oneLine = (text: string): string => text.replace(/\s+/g, ' ').trim();
+
+/** kind-'pr' conclusion card on the existing ContextCard schema; why/verdict/remaining stay empty unless grounded. */
+export function buildPrConclusionCard(input: PrConclusionCardInput): ContextCard {
+  const conclusion = input.unreadable
+    ? PR_CONCLUSION_UNREADABLE
+    : oneLine(input.firstParagraph ?? '') || PR_CONCLUSION_NONE;
+  return {
+    id: input.id,
+    kind: 'pr',
+    conclusion,
+    why: '',
+    verdict: '',
+    remaining: [],
+    pointers: [...input.pointers],
+    source: input.source,
+    updatedAt: input.updatedAt,
+    ...(input.supersedes === undefined ? {} : { supersedes: input.supersedes }),
+  };
+}
+
+/** §3a display header; fallback conclusions keep the prescribed wording verbatim with no pointer suffix. */
+export function prConclusionCardHeader(card: ContextCard): string {
+  const fallback = card.conclusion === PR_CONCLUSION_NONE || card.conclusion === PR_CONCLUSION_UNREADABLE;
+  const pointers = card.pointers.join(' · ');
+  return `결론: ${card.conclusion}${fallback || !pointers ? '' : ` · 포인터: ${pointers}`}`;
+}

package/src/control/control-status.ts

@@ -1,5 +1,7 @@
 import { readHqLease } from '../hq/hq.js';
 import { fileLeaseStore } from '../hq/lease.js';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
@@ -20,6 +22,8 @@ export interface ControlStatusRow {
 export interface ControlStatusDeps {
   readLease?: () => ReturnType<typeof readHqLease> | Promise<ReturnType<typeof readHqLease>>;
   readVersion?: () => ControlStatusRow | Promise<ControlStatusRow>;
+  /** Prefix that holds this machine's install.json. Defaults to ~/.local/share/elanous. */
+  installRoot?: string;
   readResources?: () => ControlStatusRow | Promise<ControlStatusRow>;
   readCredentials?: () => ControlStatusRow | Promise<ControlStatusRow>;
   readFreeze?: () => ReturnType<typeof readLandingFreeze> | Promise<ReturnType<typeof readLandingFreeze>>;
@@ -31,6 +35,31 @@ export interface ControlStatusDeps {
 
 const missing = (row: ControlStatusRowName, reason: string): ControlStatusRow => ({ row, state: 'unmeasured', text: '못 쟀다', reason });
 
+function localInstallRoot(): string {
+  return join(homedir(), '.local', 'share', 'elanous');
+}
+
+/** This machine's install.json only — daemon and public versions stay unconnected. */
+function localInstallVersionRow(installRoot = localInstallRoot()): ControlStatusRow {
+  let raw: string;
+  try {
+    raw = readFileSync(join(installRoot, 'install.json'), 'utf8');
+  } catch (error) {
+    return missing('판', (error as NodeJS.ErrnoException).code === 'ENOENT' ? '이 기계 install.json 없음' : '이 기계 install.json 읽기 실패');
+  }
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return missing('판', '이 기계 install.json 파싱 실패');
+    const record = parsed as { version?: unknown; commit?: unknown };
+    const version = typeof record.version === 'string' ? record.version.trim() : '';
+    const sha = typeof record.commit === 'string' ? record.commit.trim() : '';
+    if (!version || !sha) return missing('판', '이 기계 install.json에 판·sha 없음');
+    return { row: '판', state: 'ok', text: `설치본 ${version} · ${sha}` };
+  } catch {
+    return missing('판', '이 기계 install.json 파싱 실패');
+  }
+}
+
 /** Read-only snapshot: each source fails independently; no lease renewal, freeze mutation or config sync. */
 export async function collectControlStatus(deps: ControlStatusDeps = {}): Promise<ControlStatusRow[]> {
   const rows: ControlStatusRow[] = [];
@@ -55,7 +84,7 @@ export async function collectControlStatus(deps: ControlStatusDeps = {}): Promis
     return { row: '집', state: expired ? 'warn' : 'ok',
       text: `본부 ${record.holder} · 세대 ${record.generation} · ${ageSeconds}초 전 · ${expired ? '만료' : '유효'}` };
   });
-  await add('판', deps.readVersion ?? (() => missing('판', '기계별 install.json·데몬 판·공개 판 원천 미연결')));
+  await add('판', deps.readVersion ?? (() => localInstallVersionRow(deps.installRoot)));
   await add('자원', deps.readResources ?? (() => missing('자원', '기계별 Pod 실행/대기/실패·풀 상한·호스트 부하 원천 미연결')));
   await add('자격', deps.readCredentials ?? (() => missing('자격', '계정별 만료·쿼터·갱신자 원천 미연결')));
   await add('동결·몫', async () => {