elanous 0.2.24 → 0.2.27

package/src/cli/tasks-cli.ts

@@ -1,20 +1,25 @@
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { loadRunLedger as loadRunLedgerSync } from '../self-implement/run-ledger.js';
+import { goalRunDbPath, loadGoalRunQuery } from '../self-implement/goal-run-store.js';
+import { loadGoalAskRecords } from '../self-implement/goal-ask-store.js';
 import { join, resolve } from 'node:path';
 import { InvalidArgumentError, Option, type Command } from 'commander';
 import { debug } from '../debug/log.js';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { readNexusRuntime } from '../nexus/runtime.js';
 import { checklistDevVersion } from '../release-loop/checklist.js';
+import { assignedVersions, releasedVersion, validateVersion } from '../release-loop/feature-store.js';
+import { compareVersions } from '../directives/version-at.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 { 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, 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, recordWiringLiveVerified, refreshCardRunBinding, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
 import { captureReviewResults } from '../task-agent/review-result-capture.js';
+import { replayRemoteCardMoves } from '../task-agent/shadow.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';
 
@@ -38,9 +43,13 @@ export interface TasksCliDeps {
   /** `task advance` 의 착지 근거 읽기(시험 주입). 기본 = `predecessorState`(gh · 런 원장). */
   pieceEvidence?: PieceEvidenceReader;
   /** `task board` 의 내부 팩 어댑터(시험 주입). 기본 = 현재 판(`checklistDevVersion()`)의 `releasePackBoard` — 읽기만. */
-  releaseBoard?: () => BoardNode[];
+  releaseBoard?: (version?: string) => BoardNode[];
+  /** `tasks hand --checklist` 판 목록(시험 주입). 기본은 발행 전 체크리스트가 있는 판 전부. */
+  releaseVersions?: () => string[];
   /** `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` 의 낡은 부모 보고 의존(시험 주입). */
@@ -52,10 +61,16 @@ export interface TasksCliDeps {
   coverLogs?: (query: LogQuery) => LogStoreRow[] | CoverLogRead;
   /** `tasks cover --by-card` 카드 원장 읽기 seam(읽기 전용). 플래그가 있을 때만 부른다. 기본 = TA 카드 원장(task-agent-actions.json). null = 못 읽음. */
   coverCards?: () => CoverCardRow[] | null | Promise<CoverCardRow[] | null>;
+  /** Read-only authored goal provenance; null means the authoring ledger could not be read. */
+  coverGoalAsks?: () => { authorRunId: string; goalId: string; createdAt: string }[] | null;
+  /** Read-only terminal goal records; null means the goal ledger could not be read. */
+  coverGoalRuns?: () => { goalId: string; outcome: string; stage?: string; startedAt: string; completedAt?: string }[] | null;
   /** TA-REJUDGE-ON-HEAD — `tasks rejudge` 의 판단 의존(시험 주입 · 기본 = 설정 liveMoves ⊕ 실물 gh·리뷰·재게이트·land). */
   rejudge?: Partial<import('../task-agent/rejudge-on-head.js').RejudgeDeps>;
   /** TA-REJUDGE-ON-HEAD — `tasks regate-run` 의 재게이트(시험 주입 · 기본 `runHostRegate`). */
   hostRegate?: (input: import('../self-implement/host-regate.js').HostRegateInput) => Promise<import('../self-implement/host-regate.js').HostRegateResult>;
+  /** Isolated regate-run tests can disable the asynchronous completion callback explicitly. */
+  regateCompletion?: false;
 }
 
 /** `<조각id>=<값>` 반복 인자. */
@@ -150,8 +165,8 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
     try { debug.log('task-agent', 'parent-host-fallback', { host: target.host, runId: context.runId, gaps, facts }); } catch { /* fail-soft */ }
     notice(`[parent-host] ${target.host} 로 못 띄움 — ${multi ? '다음 호스트 또는 로컬 발사로 간다' : '로컬 발사로 간다'}: ${gaps.join(' · ')}`);
   };
-  if (cwd || context.env[TA_LAND_ENV] === '1') {
-    failed(targets[0]!, [cwd ? 'project-target-is-local' : 'ta-land-needs-local-parent']);
+  if (cwd) {
+    failed(targets[0]!, ['project-target-is-local']);
     return null;
   }
   let launchHoldActive = false;
@@ -174,6 +189,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 +515,8 @@ export function readTaskAgentCover(
   window: { sinceMs?: number; untilMs?: number } = {},
   query: NonNullable<TasksCliDeps['coverLogs']> = queryCoverLogs,
   taskCards?: readonly { id: string }[] | null,
-): { rows: CoverRow[]; limitReached: boolean; unreadableStores: number } {
+  goalReaders: Pick<TasksCliDeps, 'coverGoalAsks' | 'coverGoalRuns'> = {},
+): { 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 {
@@ -514,16 +531,51 @@ export function readTaskAgentCover(
   const actions = actionRead?.rows ?? null;
   const lands = landRead?.rows ?? null;
   const truncated = { taskAgentActions: actionRead?.limitReached === true, allLands: landRead?.limitReached === true };
+  const inWindow = (value: string): boolean => {
+    const time = Date.parse(value);
+    return Number.isFinite(time) && (window.sinceMs === undefined || time >= window.sinceMs) && (window.untilMs === undefined || time <= window.untilMs);
+  };
+  let goalAsks: ReturnType<NonNullable<TasksCliDeps['coverGoalAsks']>> = null;
+  let goalRuns: ReturnType<NonNullable<TasksCliDeps['coverGoalRuns']>> = null;
+  let goalAsksTruncated = false;
+  let goalRunsTruncated = false;
+  try {
+    if (goalReaders.coverGoalAsks) goalAsks = goalReaders.coverGoalAsks();
+    else {
+      const asks = loadGoalAskRecords({ limit: COVER_QUERY_LIMIT }, goalRunDbPath());
+      goalAsksTruncated = asks.length >= COVER_QUERY_LIMIT;
+      goalAsks = asks;
+    }
+  } catch { goalAsks = null; }
+  try {
+    if (goalReaders.coverGoalRuns) goalRuns = goalReaders.coverGoalRuns();
+    else {
+      const runs = loadGoalRunQuery({ limit: COVER_QUERY_LIMIT }, goalRunDbPath());
+      goalRunsTruncated = runs?.truncated ?? false;
+      goalRuns = runs?.records.map(({ goalId, record }) => ({
+        goalId, outcome: record.outcome, stage: record.stage, startedAt: record.startedAt ?? '', completedAt: record.completedAt,
+      })) ?? null;
+    }
+  } catch { goalRuns = null; }
+  const authoredGoalIds = new Set(goalAsks?.map((ask) => ask.goalId) ?? []);
   const input: TaskAgentCoverInput = {
     taskAgentActions: actions === null ? null : coverEvents(actions, 'task-agent', 'action', (data) =>
       typeof data.kind === 'string' && typeof data.result === 'string'
         ? { kind: data.kind as NonNullable<TaskAgentCoverInput['taskAgentActions']>[number]['kind'], result: data.result, ...(typeof data.taskId === 'string' ? { taskId: data.taskId } : {}) } : null),
     allLands: lands === null ? null : coverEvents(lands, 'pr.land', 'step', (data) =>
       typeof data.step === 'string' && typeof data.ok === 'boolean' ? { step: data.step, ok: data.ok } : null),
-    truncated,
+    truncated: { ...truncated, goalAsks: goalAsksTruncated, goalRuns: goalRunsTruncated },
+    // Authoring may start before this window; completion is the event being counted.
+    goalAsks,
+    goalRuns: goalRuns && (window.sinceMs !== undefined || window.untilMs !== undefined)
+      ? goalRuns.some((run) => authoredGoalIds.has(run.goalId)
+          && run.stage === 'merged' && (run.outcome === 'completed' || run.outcome === 'merged')
+          && !Number.isFinite(Date.parse(run.completedAt ?? '')))
+        ? null : goalRuns.filter((run) => inWindow(run.completedAt ?? ''))
+      : goalRuns,
     ...(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 || goalAsksTruncated || goalRunsTruncated, unreadableStores };
 }
 
 export function registerTasksCommands(program: Command, deps: TasksCliDeps = {}): void {
@@ -565,12 +617,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, deps);
         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 ?? '-'}`);
@@ -618,6 +673,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .description('TASK-AGENT 에 과제 한 줄을 넘긴다 — 카드를 적고 첫 수(harness say --substrate pod --merge-by-host)를 고른다 · 기본 shadow(발사 0) · `--mission` 이면 조각 카드 ⊕ 선후로 쪼개 선행 없는 조각만 넘긴다')
     .addOption(new Option('--seat <seat>', `과제 자리 (${TASK_SEATS.join('|')})`).choices([...TASK_SEATS]))
     .option('--checklist <cellId>', '릴리스 체크리스트 칸 id')
+    .option('--version <version>', '체크리스트 판 고정(생략하면 발행 전 판을 가까운 순서로 탐색)')
     .addOption(new Option('--completion <kind>', `종결 종류 (${COMPLETION_KINDS.join('|')} · 기본 code-pr = PR 병합)`).choices([...COMPLETION_KINDS]))
     .option('--mission <text>', '미션 문면 — 조각(`- …`·`① …`·`1. …` ⊕ `after: 1`)으로 나열돼 있으면 결정론, 아니면 분해기로 쪼갠다')
     .option('--project <id>', '프로젝트 id — --target 과 함께')
@@ -629,7 +685,72 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .option('--child-llm <provider/model>', 'TASKS-HAND-CHILD-LLM — 구현 자식 LLM(예: grok/grok-4.7) → 발사 인자 --child-llm-provider <provider> --child-llm-model <model> · «첫» `/` 에서만 가른다(모델 id 의 `/` 는 보존) · openrouter 는 모델 id 가 openrouter/ 접두를 포함하므로 전체를 모델로(openrouter/z-ai/glm-5.3 → --child-llm-model openrouter/z-ai/glm-5.3) · 카드 childLlm · 안 주면 명령·카드 무변경')
     .option('--child-llm-effort <level>', '구현 자식 추론 노력 → 발사 인자 --child-llm-effort(검증은 하니스 · --child-llm 과 함께)')
     .option('--json', 'JSON 출력')
-    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; completion?: CompletionKind; mission?: string; project?: string; target?: string; goal?: string; milestone?: string; live?: boolean; taLand?: boolean; childLlm?: string; childLlmEffort?: string; json?: boolean }) => {
+    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; version?: string; completion?: CompletionKind; mission?: string; project?: string; target?: string; goal?: string; milestone?: string; live?: boolean; taLand?: boolean; childLlm?: string; childLlmEffort?: string; json?: boolean }) => {
+      const suppliedText = text !== undefined;
+      if (opts.version !== undefined && opts.checklist === undefined) {
+        out('--version 은 --checklist 와 함께 준다');
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.checklist !== undefined) {
+        const findTitle = (nodes: BoardNode[]): string | undefined => {
+          for (const node of nodes) {
+            if (node.level === 'task' && node.id === opts.checklist) return node.title;
+            const nested = node.children ? findTitle(node.children) : undefined;
+            if (nested !== undefined) return nested;
+          }
+          return undefined;
+        };
+        if (opts.version !== undefined) {
+          try { validateVersion(opts.version); }
+          catch (error) {
+            out(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+            return;
+          }
+        }
+        const versions = opts.version !== undefined ? [opts.version]
+          : [checklistDevVersion(), ...(deps.releaseVersions?.() ?? (deps.releaseBoard ? [] : (() => {
+            const released = releasedVersion();
+            return assignedVersions().filter((version) => !released || compareVersions(version, released) > 0);
+          })()))];
+        const current = checklistDevVersion();
+        const orderedVersions = [...new Set(versions)].sort((a, b) => {
+          if (a === current) return -1;
+          if (b === current) return 1;
+          const aFuture = compareVersions(a, current) > 0;
+          const bFuture = compareVersions(b, current) > 0;
+          if (aFuture !== bFuture) return aFuture ? -1 : 1;
+          return aFuture ? compareVersions(a, b) : compareVersions(b, a);
+        });
+        const matches: Array<{ version: string; title: string }> = [];
+        for (const version of orderedVersions) {
+          try {
+            const title = findTitle((deps.releaseBoard ?? releasePackBoard)(version));
+            if (title !== undefined) matches.push({ version, title });
+          } catch (error) {
+            if (opts.version !== undefined) {
+              out(`체크리스트 판 읽기 실패: ${version}`);
+              process.exitCode = 1;
+              return;
+            }
+            console.error(`⚠ 체크리스트 판 ${version} 읽기 실패 — 다른 판 계속 조회: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        const title = matches[0]?.title;
+        if (title === undefined) {
+          out(`체크리스트 칸 없음: ${opts.checklist}`);
+          process.exitCode = 1;
+          return;
+        }
+        if (matches.length > 1) console.error(`⚠ 체크리스트 칸 ${opts.checklist} 중복: ${matches.map((match) => match.version).join(', ')} — 가장 가까운 판 ${matches[0]!.version} 선택 (--version 으로 고정 가능)`);
+        if (opts.mission === undefined && text === undefined) text = title;
+      }
+      if (opts.checklist !== undefined && opts.mission === undefined && suppliedText && !text!.split(/\r?\n/, 1)[0]!.startsWith('대상 경로:')) {
+        out('칸 문면을 쓰려면 문면 인자를 빼라');
+        process.exitCode = 1;
+        return;
+      }
       await registerTaskAgentSink(deps.registerSink);
       if ((text === undefined) === (opts.mission === undefined)) {
         out('과제 한 줄 «또는» --mission <문면> 중 하나만 준다');
@@ -706,7 +827,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           out(`${result.card.id}\t${result.mode}\t${result.launched ? 'launched' : 'not launched'}`);
           out(`elanous ${result.move.command!.map(shellQuote).join(' ')}`);
           if (result.cwd) out(`(cwd: ${result.cwd})`);
-          if (result.card.taLand) out('(ta-land — 발사 env ELANOUS_TA_LAND=1 · 로컬 부모 · taskAgent.liveMoves 에 propose-land 가 있으면 병합은 TASK-AGENT 몫, 없으면 종전대로 호스트 병합)');
+          if (result.card.taLand) out('(ta-land — 발사 env ELANOUS_TA_LAND=1 · 원격 또는 로컬 부모 · taskAgent.liveMoves 에 propose-land 가 있으면 병합은 TASK-AGENT 몫, 없으면 종전대로 호스트 병합)');
           if (!result.launched) out('(shadow — 띄우지 않았다 · 띄우려면 --live)');
         }
       } catch (error) {
@@ -736,6 +857,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 <사유>', '닫는 사유(비면 거부)')
@@ -937,6 +1076,9 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           for (const cardId of bindable) {
             // HARNESS-PARENT-ON-MSB1: 원격 부모 런은 원장이 그 호스트에 있다 — HQ 거울로 먼저 당긴다(읽기 전용).
             await mirrorRemoteCardLedger(cardId, deps);
+            try { await replayRemoteCardMoves(cardId, deps.taskStatePath ?? taskStatePathDefault(), deps.cardRunEvidence ?? {}); } catch (error) {
+              try { debug.log('task-agent', 'card-binding-replay-failed', { card: cardId, reason: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+            }
             try { await refreshCardRunBinding(cardId, deps.taskStatePath ?? taskStatePathDefault(), deps.cardRunEvidence ?? {}); } catch (error) {
               // 근거 없음으로 보인다 — 원장 부재와 갈리게 실패는 남긴다.
               try { debug.log('task-agent', 'card-bind-failed', { card: cardId, via: 'show', error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
@@ -1016,6 +1158,10 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       const liveMoves = deps.rejudge?.liveMoves ?? await configuredTaskAgentLiveMoves();
       const all = [];
       for (const cardId of ids) {
+        await mirrorRemoteCardLedger(cardId, deps);
+        try { await replayRemoteCardMoves(cardId, statePath, deps.cardRunEvidence ?? {}); } catch (error) {
+          try { debug.log('task-agent', 'card-binding-replay-failed', { card: cardId, reason: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+        }
         let outcomes: Awaited<ReturnType<typeof rejudgeCardOnHead>>;
         try { outcomes = await rejudgeCardOnHead(cardId, { ...deps.rejudge, liveMoves, live: { ...deps.rejudge?.live, statePath } }); } catch (error) {
           // 카드 하나의 예외가 --all 의 나머지 카드 판단을 멈추지 않게 — 사유를 남기고 다음 카드로.
@@ -1049,6 +1195,14 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       try { debug.log('task-agent', 'regate-run', { card: opts.card, ...record, failures: result.failures.slice(0, 3) }); } catch { /* fail-soft */ }
       mkdir(dir(opts.out), { recursive: true });
       write(opts.out, JSON.stringify(record));
+      if (deps.regateCompletion !== false) {
+        try {
+          const { rejudgeCompletedTaskRegate } = await import('../task-agent/rejudge-on-head.js');
+          await rejudgeCompletedTaskRegate(opts.card, pr, opts.head, opts.out, deps.taskStatePath ?? taskStatePathDefault(), undefined, deps.rejudge);
+        } catch (error) {
+          try { debug.log('task-agent', 'regate-completion-rejudge-failed', { card: opts.card, pr, head: opts.head, reason: String(error).slice(-300) }, { level: 'warn' }); } catch { /* fail-soft */ }
+        }
+      }
       if (!result.passed) process.exitCode = 1;
     });
 

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/cell.ts

@@ -0,0 +1,40 @@
+import type { ContextCard } from './index.js';
+
+export interface CellCardItem {
+  readonly id: string;
+  readonly title: string;
+  readonly status: string;
+  readonly owner?: string | null;
+  readonly disposition?: string;
+  readonly evidence?: string;
+}
+
+const POINTER_PATTERN = /#\d+|run-[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/giu;
+
+function extractPointers(text: string): string[] {
+  return [...text.matchAll(POINTER_PATTERN)].map(([pointer]) => pointer);
+}
+
+/** Build a compact checklist-cell card; evidence is used only to derive stable source pointers. */
+export function buildCellCard(version: string, item: CellCardItem, asOf: string): ContextCard {
+  const pointers = [...new Set([
+    ...extractPointers(item.evidence ?? ''),
+    ...extractPointers(item.title),
+    `checklist:${version}/${item.id}`,
+  ])];
+  const reasons = [
+    item.owner ? `담당 ${item.owner}` : undefined,
+    item.disposition ? `처분 ${item.disposition}` : undefined,
+  ].filter((value): value is string => value !== undefined);
+  return {
+    id: `cell:${version}/${item.id}`,
+    kind: 'cell',
+    conclusion: (item.title.split(/[\r\n\u2028\u2029]/u, 1)[0] ?? '').trim(),
+    why: reasons.join(' · '),
+    verdict: item.status,
+    remaining: [],
+    pointers,
+    source: `release-checklist:${version}`,
+    updatedAt: asOf,
+  };
+}

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 () => {

package/src/dashboard/boot-timing.ts

@@ -0,0 +1,35 @@
+import { debug } from '../debug/log.js';
+
+export interface BootTimer {
+  begin(): void;
+  phase(name: string): void;
+  done(): void;
+}
+
+export function createBootTimer(now: () => number = performance.now): BootTimer {
+  const startedAt = now();
+  let phaseStartedAt = startedAt;
+  let lastPhase: string | undefined;
+  let slowest: { phase: string; ms: number } | undefined;
+  let completed = false;
+
+  return {
+    begin(): void {
+      phaseStartedAt = now();
+    },
+    phase(name: string): void {
+      const current = now();
+      const ms = current - phaseStartedAt;
+      phaseStartedAt = current;
+      lastPhase = name;
+      if (!slowest || ms > slowest.ms) slowest = { phase: name, ms };
+      try { debug.log('tui.boot', 'phase', { phase: name, ms }); } catch { /* logging must not block startup */ }
+    },
+    done(): void {
+      if (completed) return;
+      completed = true;
+      const totalMs = now() - startedAt;
+      try { debug.log('tui.boot', 'summary', { totalMs, slowest: slowest ?? (lastPhase ? { phase: lastPhase, ms: totalMs } : null) }); } catch { /* logging must not block startup */ }
+    },
+  };
+}