elanous 0.2.23 → 0.2.25

package/src/cli/rfc-status.ts

@@ -1,6 +1,6 @@
 import type { Command } from 'commander';
 import { readdirSync, readFileSync } from 'node:fs';
-import { join, relative, resolve } from 'node:path';
+import { dirname, join, relative, resolve } from 'node:path';
 import YAML from 'yaml';
 
 export const RFC_STATUSES = ['unknown', 'proposed', 'adopted', 'completed', 'superseded', 'rejected'] as const;
@@ -69,6 +69,49 @@ export function adoptedWithoutCard(rows: readonly RfcRow[]): RfcRow[] {
   return rows.filter((row) => row.status === 'adopted' && row.card === null);
 }
 
+const RFC_HUB_FILE = 'INDEX-loop-agents-and-harness-rfcs.md';
+
+function markdownLinks(markdown: string): string[] {
+  return [...markdown.matchAll(/\]\(([^)\s]+\.md)(?:#[^)]*)?\)/g)].map((match) => match[1]!);
+}
+
+function hasHubConnectionReference(text: string, documentPath: string, root: string): boolean {
+  const firstSection = text.search(/^##\s/m);
+  const header = firstSection < 0 ? text : text.slice(0, firstSection);
+  const hubPath = resolve(root, 'docs', RFC_HUB_FILE);
+  return header.split(/\r?\n/).some((line) => {
+    if (!line.includes('🔗') || !line.includes('연결 참조')) return false;
+    return markdownLinks(line).some((target) =>
+      resolve(dirname(resolve(root, documentPath)), target) === hubPath);
+  });
+}
+
+/** 허브를 못 읽으면 null — «0» 과 «못 셌음» 은 다른 값이다. */
+function hubConnectionCounts(root: string, rows: readonly RfcRow[]): { unconnected: number; unlisted: number } | null {
+  const hubPath = resolve(root, 'docs', RFC_HUB_FILE);
+  let hub: string;
+  try { hub = readFileSync(hubPath, 'utf8'); }
+  catch { return null; }
+
+  const hubDirectory = dirname(hubPath);
+  const listedPaths = new Set(markdownLinks(hub)
+    .filter((target) => /^RFC-.*\.md$/.test(target.split(/[?#]/, 1)[0]!))
+    .map((target) => relative(root, resolve(hubDirectory, target)).replaceAll('\\', '/')));
+  const rowsByPath = new Map(rows.map((row) => [row.path, row]));
+  const unconnected = [...listedPaths].filter((path) => {
+    const row = rowsByPath.get(path);
+    if (!row) return false;
+    return !hasHubConnectionReference(readFileSync(resolve(root, row.path), 'utf8'), row.path, root);
+  }).length;
+  const unlisted = rows.filter((row) => {
+    if (listedPaths.has(row.path)) return false;
+    const text = readFileSync(resolve(root, row.path), 'utf8');
+    const title = /^#\s+(.+)$/m.exec(text)?.[1] ?? '';
+    return /루프|하니스|그래프/.test(title);
+  }).length;
+  return { unconnected, unlisted };
+}
+
 export function runRfcStatus(options: { json?: boolean; missingCards?: boolean }, root = process.cwd(),
   write: (text: string) => void = (text) => process.stdout.write(text)): void {
   const all = scanRfcs(root);
@@ -77,9 +120,13 @@ export function runRfcStatus(options: { json?: boolean; missingCards?: boolean }
     write(`${JSON.stringify({ total: all.length, adoptedWithoutCard: adoptedWithoutCard(all).length, rows }, null, 2)}\n`);
     return;
   }
+  const hubCounts = hubConnectionCounts(root, all);
   write(`RFC ${all.length} · 채택·칸 없음 ${adoptedWithoutCard(all).length} · 표시 ${rows.length}\n`);
   write('상태\t담당\t칸\t대체 문서\t핸드북\t옛 상태\t옛 담당\t경로\t메타 오류\n');
   for (const row of rows) write(`${row.status}\t${row.owner ?? '모름'}\t${row.card ?? '모름'}\t${row.supersededBy ?? '모름'}\t${row.handbook ?? '모름'}\t${row.legacyStatus ?? '-'}\t${row.legacyOwner ?? '-'}\t${row.path}\t${row.issue ?? '-'}\n`);
+  write(hubCounts
+    ? `허브 연결: 되돌림 없음 ${hubCounts.unconnected} · 미등재 ${hubCounts.unlisted}\n`
+    : `허브 연결: 못 셈 — docs/${RFC_HUB_FILE} 를 못 읽었다\n`);
 }
 
 export function registerRfcStatusCommand(docs: Command): void {
@@ -87,5 +134,8 @@ export function registerRfcStatusCommand(docs: Command): void {
     .description('전체 RFC 생애주기 표 (RFC frontmatter만 읽음)')
     .option('--json', '기계가 읽을 JSON')
     .option('--missing-cards', '채택됐으나 칸이 기록되지 않은 RFC만')
-    .action((options: { json?: boolean; missingCards?: boolean }) => runRfcStatus(options));
+    .action((options: { json?: boolean; missingCards?: boolean }): void => {
+      // registerDocsCommands in docs-cli.ts calls registerRfcStatusCommand; this action calls runRfcStatus and its hub check.
+      runRfcStatus(options);
+    });
 }

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/self-update.ts

@@ -428,6 +428,80 @@ export interface VersionPruneOutcome {
   skipped?: string;
 }
 
+export interface RailSafeProcessListing {
+  status: number | null;
+  stdout: string;
+  stderr: string;
+  error?: Error;
+}
+
+export interface AssessRailSafeInput {
+  entries: ReadonlyArray<{ name: string; mtimeMs: number }>;
+  current: string;
+  daemonSha: string;
+  keep: number;
+  versionsDir: string;
+  listProcesses?: (pattern: string) => RailSafeProcessListing;
+  readProcessCommand?: (pid: string) => string | null;
+  isReleaseRunActive?: () => boolean;
+}
+
+/** Shadow probes must never stall the install: a hung pgrep/ps reads as «no process» (status null). */
+const RAIL_SAFE_PROBE_TIMEOUT_MS = 5_000;
+
+function pgrepProcesses(pattern: string): RailSafeProcessListing {
+  const result = spawnSync('pgrep', ['-f', pattern], { encoding: 'utf8', maxBuffer: SPAWN_MAX_BUFFER, timeout: RAIL_SAFE_PROBE_TIMEOUT_MS });
+  return { status: result.status, stdout: result.stdout ?? '', stderr: result.error?.message ?? result.stderr ?? '', ...(result.error ? { error: result.error } : {}) };
+}
+
+function processCommand(pid: string): string | null {
+  const result = spawnSync('ps', ['-p', pid, '-o', 'command='], { encoding: 'utf8', maxBuffer: SPAWN_MAX_BUFFER, timeout: RAIL_SAFE_PROBE_TIMEOUT_MS });
+  return result.status === 0 ? (result.stdout ?? '').trim() || null : null;
+}
+
+function listedProcessCommands(listing: RailSafeProcessListing, readCommand: (pid: string) => string | null): string[] {
+  if (listing.status !== 0) return [];
+  return listing.stdout.split(/\r?\n/).flatMap((line) => {
+    const entry = line.trim();
+    if (!entry) return [];
+    if (!/^\d+$/.test(entry)) return [entry];
+    const command = readCommand(entry);
+    return command ? [command] : [];
+  });
+}
+
+function pgrepPathPattern(path: string): string {
+  return path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** Shadow-only observation: determine whether a prune plan targets an argv-held version or a release run is active. */
+export function assessRailSafe(input: AssessRailSafeInput): {
+  wouldBlock: boolean;
+  reasons: Array<'held-version' | 'release-run-active'>;
+  heldVersions: string[];
+  releaseRunActive: boolean;
+} {
+  const plan = planVersionPrune(input.entries, input.current, input.daemonSha, input.keep);
+  const listProcesses = input.listProcesses ?? pgrepProcesses;
+  const readCommand = input.readProcessCommand ?? processCommand;
+  const heldVersions = plan.removed.filter((name) => {
+    const path = join(input.versionsDir, name);
+    try {
+      return listedProcessCommands(listProcesses(pgrepPathPattern(path)), readCommand).some((argv) => argv.includes(path));
+    } catch { return false; }
+  });
+  let releaseRunActive = false;
+  try {
+    releaseRunActive = input.isReleaseRunActive?.() ?? listedProcessCommands(
+      listProcesses('release[[:space:]]+(run|resume)'), readCommand,
+    ).some((argv) => /release\s+(?:run|resume)/.test(argv));
+  } catch { releaseRunActive = false; }
+  const reasons: Array<'held-version' | 'release-run-active'> = [];
+  if (heldVersions.length) reasons.push('held-version');
+  if (releaseRunActive) reasons.push('release-run-active');
+  return { wouldBlock: reasons.length > 0, reasons, heldVersions, releaseRunActive };
+}
+
 /**
  * 야간 자동 설치는 하룻밤에 한 판(약 641MB · 2026-09-24 실측)을 쌓는다. 설치기는 옛 판을 안 지운다.
  * 남기는 것: `current` 가 가리키는 판 · 지금 데몬이 도는 판(판정의 `from` sha) · 최근 `keep` 판(롤백용).
@@ -664,6 +738,12 @@ export interface ReleaseUpdateDeps {
   listPruneProcesses?: ProcessListing;
   /** Per-process cwd/executable probe; when absent the host's lsof is used. */
   scanPruneProcess?: ProcessScan;
+  /** Shadow-only rail-safe process listing override. */
+  listRailSafeProcesses?: (pattern: string) => RailSafeProcessListing;
+  /** Resolves pgrep's PID-only output to a command line; defaults to `ps -p <pid> -o command=`. */
+  readRailSafeProcessCommand?: (pid: string) => string | null;
+  /** Shadow-only release-run detector override. */
+  isReleaseRunActive?: () => boolean;
   /** 릴리스 기준 URL 주입 — 환경변수와 설치 출처보다 우선한다. */
   releaseBase?: string;
 }
@@ -740,10 +820,14 @@ export async function runReleaseUpdate(options: ReleaseUpdateOptions = {}, deps:
   }
   let previous = '';
   let previousBuild = '';
+  let previousCommit = '';
   let replacedDev: { from: string; to: string } | null = null;
   try {
     const metadata: unknown = JSON.parse(readFileSync(join(prefix, 'install.json'), 'utf8'));
     previousBuild = installedBuild(metadata);
+    if (typeof metadata === 'object' && metadata !== null && typeof (metadata as { commit?: unknown }).commit === 'string') {
+      previousCommit = (metadata as { commit: string }).commit;
+    }
     if (typeof metadata === 'object' && metadata !== null && (metadata as { channel?: unknown }).channel === 'dev') {
       const fromDir = typeof (metadata as { versionDir?: unknown }).versionDir === 'string' ? (metadata as { versionDir: string }).versionDir : '';
       replacedDev = { from: fromDir, to: '' };
@@ -757,6 +841,26 @@ export async function runReleaseUpdate(options: ReleaseUpdateOptions = {}, deps:
     const result = spawnSync(command, args, { cwd, encoding: 'utf8', input, maxBuffer: SPAWN_MAX_BUFFER, env: { ...process.env, ...env, PATH: childPath() } });
     return { status: result.status, stderr: result.error?.message ?? result.stderr ?? '' };
   });
+  let railSafeEntries: Array<{ name: string; mtimeMs: number }> = [];
+  try {
+    railSafeEntries = readdirSync(join(prefix, 'versions'), { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => ({ name: entry.name, mtimeMs: statSync(join(prefix, 'versions', entry.name)).mtimeMs }));
+  } catch { /* shadow observation cannot change the install decision */ }
+  let railSafe: ReturnType<typeof assessRailSafe> = { wouldBlock: false, reasons: [], heldVersions: [], releaseRunActive: false };
+  try {
+    railSafe = assessRailSafe({
+      entries: railSafeEntries,
+      current: previous,
+      daemonSha: previousCommit,
+      keep: options.keep ?? 3,
+      versionsDir: join(prefix, 'versions'),
+      ...(deps.listRailSafeProcesses ? { listProcesses: deps.listRailSafeProcesses } : {}),
+      ...(deps.readRailSafeProcessCommand ? { readProcessCommand: deps.readRailSafeProcessCommand } : {}),
+      ...(deps.isReleaseRunActive ? { isReleaseRunActive: deps.isReleaseRunActive } : {}),
+    });
+  } catch { /* shadow observation cannot change the install decision */ }
+  try { debug.log('self-update.rail-safe', 'shadow', railSafe); } catch { /* shadow observation never changes update decisions */ }
   try {
     const install = run('bash', ['-s', '--', '--no-modify-path', '--prefix', prefix], prefix, installer, envLiteral({ ELANOUS_VERSION: version ?? '', ELANOUS_INSTALL_SOURCE: '', ELANOUS_RELEASE_BASE: base }));
     if (install.status !== 0) return fail(1, `설치 실패: ${install.stderr.trim() || install.status}`);

package/src/cli/tasks-cli.ts

@@ -9,11 +9,12 @@ import { readNexusRuntime } from '../nexus/runtime.js';
 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, COMPLETION_KINDS, handTask, 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, 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, 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';
 
@@ -40,13 +41,19 @@ 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` 의 낡은 부모 보고 의존(시험 주입). */
   staleParents?: import('../task-agent/parent-host.js').StaleParentDeps;
+  /** `tasks adopt-runs` 의 백필 의존(시험 주입 · 등록부·상태 파일). */
+  adoptRuns?: import('../task-agent/run-adopt.js').RunAdoptDeps;
   /** `tasks cover` logs 조회 seam. 기본은 등록된 모든 우주(운영 ⊕ test)의 logs.db 를 read-only 로 연다 —
    *  pr land 는 작업 트리마다 파생 test 우주에 기록되므로 현재 우주만 읽으면 분모가 늘 0 이다. */
   coverLogs?: (query: LogQuery) => LogStoreRow[] | CoverLogRead;
+  /** `tasks cover --by-card` 카드 원장 읽기 seam(읽기 전용). 플래그가 있을 때만 부른다. 기본 = TA 카드 원장(task-agent-actions.json). null = 못 읽음. */
+  coverCards?: () => CoverCardRow[] | null | Promise<CoverCardRow[] | 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`). */
@@ -169,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 */ }
@@ -469,10 +477,32 @@ function coverEvents<T>(rows: readonly LogStoreRow[], category: string, event: s
   return events;
 }
 
+export interface CoverCardRow { id: string; createdAt: string }
+
+/**
+ * 분모 = TA 카드 원장(`task-agent-actions.json` · `ta-…` id) — 분자 `task-agent`/`action` 로그의 taskId 가 이 id 다.
+ * (task-cards CardStore 의 UUID 카드는 taskId 와 겹치지 않아 언제나 0/N 을 «잰 값처럼» 그린다 — 리뷰 must-fix.)
+ */
+function readCoverCards(statePath: string): CoverCardRow[] {
+  const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath).tasks ?? {};
+  return Object.values(tasks).filter((card) => typeof card?.id === 'string' && typeof card.createdAt === 'string')
+    .map(({ id, createdAt }) => ({ id, createdAt }));
+}
+
+/** Cards whose createdAt falls in the window; an unparsable createdAt is not placed in any window. */
+export function coverCardsInWindow(cards: readonly CoverCardRow[] | null, window: { sinceMs?: number; untilMs?: number }): { id: string }[] | null {
+  if (cards === null) return null;
+  return cards.filter(({ createdAt }) => {
+    const time = Date.parse(createdAt);
+    return Number.isFinite(time) && (window.sinceMs === undefined || time >= window.sinceMs) && (window.untilMs === undefined || time <= window.untilMs);
+  }).map(({ id }) => ({ id }));
+}
+
 export function readTaskAgentCover(
   window: { sinceMs?: number; untilMs?: number } = {},
   query: NonNullable<TasksCliDeps['coverLogs']> = queryCoverLogs,
-): { rows: CoverRow[]; limitReached: boolean; unreadableStores: number } {
+  taskCards?: readonly { id: string }[] | null,
+): { 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 {
@@ -490,12 +520,13 @@ export function readTaskAgentCover(
   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 } : null),
+        ? { 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,
+    ...(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 {
@@ -516,7 +547,8 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .option('--until <iso>', '끝 시각 (ISO)')
     .option('--json', 'JSON 출력')
     .option('--lines', '동사별 한 줄 요약 출력 (읽기 전용)')
-    .action((opts: { since?: string; until?: string; json?: boolean; lines?: boolean }) => {
+    .option('--by-card', 'review·retry·green 분모를 카드 원장(창 안 createdAt 카드 수)으로 센다 (읽기 전용)')
+    .action(async (opts: { since?: string; until?: string; json?: boolean; lines?: boolean; byCard?: boolean }) => {
       const parseIso = (value: string | undefined, flag: string): number | undefined => {
         if (value === undefined) return undefined;
         const time = Date.parse(value);
@@ -527,12 +559,24 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         const sinceMs = parseIso(opts.since, '--since');
         const untilMs = parseIso(opts.until, '--until');
         if (sinceMs !== undefined && untilMs !== undefined && sinceMs > untilMs) throw new Error('--since 가 --until 보다 늦다');
-        const { rows, limitReached, unreadableStores } = readTaskAgentCover({ sinceMs, untilMs }, deps.coverLogs);
+        let taskCards: { id: string }[] | null | undefined;
+        if (opts.byCard) {
+          let cards: CoverCardRow[] | null;
+          try { cards = await (deps.coverCards ?? (() => readCoverCards(deps.taskStatePath ?? taskStatePathDefault())))(); } catch (error) {
+            cards = null;
+            try { debug.log('task-agent.cover', 'by-card-unreadable', { error: String(error).slice(-200) }, { level: 'warn' }); } catch { /* fail-soft */ }
+          }
+          taskCards = coverCardsInWindow(cards, { sinceMs, untilMs });
+        }
+        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 ?? '-'}`);
@@ -677,6 +721,79 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       }
     });
 
+  tasks.command('hand-move <id>')
+    .description('HAND-MOVE-LEDGER — 자리가 손으로 마무리한 수(기존 실패 면제 · diff 재적용 · 범위 자르기 · 쪼개기 · 다른 모델 의견)를 그 카드 history 에 한 줄로 남긴다 — live-move 와 같은 원장 칸 · 기존 줄은 건드리지 않는다')
+    .requiredOption('--kind <kind>', `손으로 쓴 수 (${HAND_MOVE_KINDS.join('|')})`)
+    .requiredOption('--by <seat>', '남긴 자리(예: OP·MK·TC·UX)')
+    .requiredOption('--detail <text>', '무엇을 했나 — 한 줄')
+    .option('--pr <number>', '관련 PR 번호')
+    .action(async (id: string, opts: { kind: string; by: string; detail: string; pr?: string }) => {
+      await registerTaskAgentSink(deps.registerSink);
+      const pr = opts.pr === undefined ? undefined : Number(opts.pr);
+      if (pr !== undefined && (!Number.isInteger(pr) || pr <= 0)) { out(`--pr 은 자연수다: ${opts.pr}`); process.exitCode = 1; return; }
+      const outcome = recordHandMove(deps.taskStatePath ?? taskStatePathDefault(), id,
+        { kind: opts.kind, by: opts.by, detail: opts.detail, ...(pr !== undefined ? { pr } : {}) });
+      try {
+        debug.log('task-agent', 'hand-move', outcome.written
+          ? { card: id, kind: outcome.entry.kind, by: outcome.entry.by, ...(outcome.entry.pr !== undefined ? { pr: outcome.entry.pr } : {}) }
+          : { card: id, kind: opts.kind, by: opts.by, reason: outcome.reason });
+      } catch { /* fail-soft */ }
+      if (!outcome.written) { out(`hand-move 한 줄을 못 남겼다 — ${outcome.reason}`); process.exitCode = 1; return; }
+      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 <사유>', '닫는 사유(비면 거부)')
+    .option('--by <seat>', '닫은 자리(예: OP·MK·TC·UX)', 'operator')
+    .option('--json', 'JSON 출력')
+    .action(async (cardId: string, opts: { reason: string; by: string; json?: boolean }) => {
+      await registerTaskAgentSink(deps.registerSink);
+      const statePath = deps.taskStatePath ?? taskStatePathDefault();
+      try {
+        let found: TaskCard | undefined;
+        let changed = false;
+        const updated = updateTaskCard(statePath, cardId, (current) => {
+          if (!current) return undefined;
+          found = current;
+          const next = closeTaskCard(current, { reason: opts.reason, by: opts.by, at: new Date().toISOString() });
+          if (next === current) return undefined; // 이미 손으로 닫힘 — 다시 쓰지 않는다(멱등)
+          changed = true;
+          return next;
+        });
+        if (!found) { out(`과제 카드 없음: ${cardId}`); process.exitCode = 1; return; }
+        const card: TaskCard = updated ?? found;
+        const from = (found as TaskCard).status;
+        // 이미 닫힌 카드면 «저장된» 사유를 낸다 — 새로 준 사유는 원장에 없다.
+        const stored = [...card.history].reverse().find((item) => item.event === CLOSED_BY_HAND_EVENT);
+        const reason = changed ? opts.reason.trim() : (stored?.reason ?? stored?.detail ?? opts.reason.trim());
+        if (changed) { try { debug.log('task-agent', 'card-closed-by-hand', { id: cardId, from, by: opts.by, reason }); } catch { /* fail-soft */ } }
+        if (opts.json) out(JSON.stringify({ id: card.id, from, to: card.status, reason, ...(changed ? {} : { already: true }) }));
+        else out([card.id, card.status, changed ? 'closed-by-hand' : 'already-closed-by-hand', changed ? opts.by : (stored?.by ?? '-'), reason].join('\t'));
+      } catch (error) {
+        out(error instanceof Error ? error.message : '과제 카드 닫기 실패');
+        process.exitCode = 1;
+      }
+    });
+
   tasks.command('parents')
     .description('낡은 하니스 부모 보고(읽기 전용 · 죽이지 않는다) — 나이 ≥ N 시간이고 런 원장이 끝났거나(run-status) Pod 이 없는 `harness say|ask` 부모')
     .option('--older-than <hours>', '나이 하한(시간)', '6')
@@ -703,6 +820,18 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       for (const row of report.rows) out([row.pid, row.ageHours, row.seat ?? '-', row.version ?? '-', row.runId ?? '-', row.reasons.join(',')].join('\t'));
     });
 
+  tasks.command('adopt-runs')
+    .description('TA-OWN-ALL-RUNS 백필 — 발사 등록부의 이 우주 런 중 카드 없는 것에 `ta-<runId>` 카드를 만든다(발사 훅 이전 런 몫 · 있으면 건드리지 않는다)')
+    .option('--json', 'JSON 출력')
+    .action(async (opts: { json?: boolean }) => {
+      const { adoptUncardedRuns } = await import('../task-agent/run-adopt.js');
+      const report = adoptUncardedRuns({ ...(deps.taskStatePath ? { statePath: deps.taskStatePath } : {}), ...deps.adoptRuns });
+      try { debug.log('task-agent', 'run-adopt-backfill', report); } catch { /* fail-soft */ }
+      if (opts.json) { out(JSON.stringify(report)); return; }
+      const skipped = Object.entries(report.skipped).sort(([a], [b]) => a.localeCompare(b)).map(([reason, n]) => `${reason} ${n}`).join(' · ') || '없음';
+      out(`등록부 런 ${report.scanned} · 카드 만듦 ${report.adopted} · 건너뜀 ${skipped}`);
+    });
+
   tasks.command('board')
     .description('보드 — 프로젝트 › 목표 › 이정표 › 과제. 과제 카드(project·goal·milestone)와 내부 팩(릴리스 체크리스트 = elanous › 판 › 칸)을 합쳐 읽는다(쓰지 않는다)')
     .option('--project <id>', '이 프로젝트만')

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';
@@ -60,15 +61,87 @@ function readRunLogs(query: LogQuery): LogStoreRow[] {
   }
 }
 
-function usageData(row: LogStoreRow): RunUsageInput | null {
+type UsageAxis = 'stage' | 'model' | 'account';
+type ExtendedRunUsageInput = RunUsageInput & { stage?: string | null; account?: string | null };
+type AxisUsageRow = {
+  stage?: string;
+  model?: string;
+  account?: string;
+  hostIds: string[];
+  calls: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadInputTokens: number;
+  cacheCreationInputTokens: number;
+  reasoningOutputTokens: number;
+  usdKnown: number;
+  unknownCostCalls: number;
+  includedCalls: number;
+  apiEquivalentUsd: number;
+};
+
+function usageData(row: LogStoreRow, unwrapPod = false): ExtendedRunUsageInput | null {
   if (row.category !== 'llm.usage' || row.event !== 'llm-usage' || !row.data) return null;
   try {
-    const value: unknown = JSON.parse(row.data);
+    let value: unknown = JSON.parse(row.data);
     if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
-    return value as RunUsageInput;
+    const wrapper = value as { origin?: unknown; originalData?: unknown };
+    if (unwrapPod && wrapper.origin === 'pod') {
+      value = typeof wrapper.originalData === 'string' ? JSON.parse(wrapper.originalData) : wrapper.originalData;
+      if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+    }
+    return value as ExtendedRunUsageInput;
   } catch { return null; }
 }
 
+function stageForUsage(data: ExtendedRunUsageInput): string {
+  const stages = ['authoring', 'implement', 'review', 'gate'];
+  if (typeof data.stage === 'string' && data.stage.length > 0) return stages.includes(data.stage) ? data.stage : '기타';
+  // 역할 대체: 저작 호출은 role 'planning' 으로 실린다(ModelRole 에 authoring 이 없다) → authoring 단계로 센다.
+  const role = data.role === 'planning' ? 'authoring' : data.role;
+  if (typeof role === 'string' && role.length > 0) return stages.includes(role) ? role : '기타';
+  return '(none)';
+}
+
+function rollupByAxis(inputs: readonly ExtendedRunUsageInput[], axis: UsageAxis): AxisUsageRow[] {
+  const groups = new Map<string, ExtendedRunUsageInput[]>();
+  for (const data of inputs) {
+    const value = axis === 'stage' ? stageForUsage(data)
+      : axis === 'model' ? (data.model || '(none)')
+        : (data.account || '(none)');
+    const group = groups.get(value) ?? [];
+    group.push(data);
+    groups.set(value, group);
+  }
+  return [...groups].map(([value, group]) => {
+    const rows = rollupRunUsage(group);
+    const result: AxisUsageRow = {
+      [axis]: value,
+      hostIds: [...new Set(rows.flatMap((row) => row.hostIds))],
+      calls: rows.reduce((sum, row) => sum + row.calls, 0),
+      inputTokens: rows.reduce((sum, row) => sum + row.inputTokens, 0),
+      outputTokens: rows.reduce((sum, row) => sum + row.outputTokens, 0),
+      cacheReadInputTokens: rows.reduce((sum, row) => sum + row.cacheReadInputTokens, 0),
+      cacheCreationInputTokens: rows.reduce((sum, row) => sum + row.cacheCreationInputTokens, 0),
+      reasoningOutputTokens: rows.reduce((sum, row) => sum + row.reasoningOutputTokens, 0),
+      usdKnown: rows.reduce((sum, row) => sum + row.usdKnown, 0),
+      unknownCostCalls: rows.reduce((sum, row) => sum + row.unknownCostCalls, 0),
+      includedCalls: rows.reduce((sum, row) => sum + row.includedCalls, 0),
+      apiEquivalentUsd: rows.reduce((sum, row) => sum + row.apiEquivalentUsd, 0),
+    };
+    return result;
+  }).sort((a, b) => b.calls - a.calls);
+}
+
+function isUsageAxis(value: string): value is 'run' | 'role' | UsageAxis {
+  return value === 'run' || value === 'role' || value === 'stage' || value === 'model' || value === 'account';
+}
+
+function formatAxisUsage(row: AxisUsageRow, axis: UsageAxis): string {
+  const value = row[axis] ?? '(none)';
+  return `${axis}=${value}  hosts=${row.hostIds.join(',') || '(none)'}  calls=${row.calls}  input=${row.inputTokens}  output=${row.outputTokens}  cacheRead=${row.cacheReadInputTokens}  cacheCreation=${row.cacheCreationInputTokens}  reasoning=${row.reasoningOutputTokens}  usdKnown=${row.usdKnown}  unknownCostCalls=${row.unknownCostCalls}  includedCalls=${row.includedCalls}  apiEquivalentUsd=${row.apiEquivalentUsd}`;
+}
+
 function defaultCreditPlan(): CodexCreditPlan | null {
   try { return codexCreditPlanFromDisk(); } catch { return null; }
 }
@@ -94,15 +167,15 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
 
   usage
     .command('runs')
-    .description('저장된 llm-usage 로그를 런 또는 역할·호출 자리별로 집계한다')
+    .description('저장된 llm-usage 로그를 런·역할·단계·모델·계정별로 집계한다')
     .option('--run <runId>', '런 ID 정확 일치')
-    .option('--by <axis>', '집계 축 (run | role)', 'run')
+    .option('--by <axis>', '집계 축 (run | role | stage | model | account)', 'run')
     .option(...LOGS_SINCE_OPTION)
     .option('--json', '집계 행 JSON 출력')
     .action((opts: { run?: string; by: string; since?: string; json?: boolean }, command: Command) => {
       const json = opts.json || command.optsWithGlobals<{ json?: boolean }>().json;
-      if (opts.by !== 'run' && opts.by !== 'role') {
-        out.log('⛔ --by 는 run | role');
+      if (!isUsageAxis(opts.by)) {
+        out.log('⛔ --by 는 run | role | stage | model | account');
         exit(2);
         return;
       }
@@ -116,8 +189,20 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
         exactCategories: ['llm.usage'], events: ['llm-usage'],
         ...(sinceMs !== undefined ? { sinceMs } : {}),
       });
-      const inputs = rows.map(usageData).filter((data): data is RunUsageInput => data !== null)
+      const unwrapPod = opts.by === 'stage' || opts.by === 'model' || opts.by === 'account';
+      // ⭐ 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);
+        if (json) {
+          out.log(JSON.stringify(report, null, 2));
+          return;
+        }
+        if (report.length === 0) { out.log('(일치하는 런 사용량 없음)'); return; }
+        for (const row of report) out.log(formatAxisUsage(row, opts.by));
+        return;
+      }
       const report = rollupRunUsage(inputs, { by: opts.by });
       if (opts.by === 'role') report.sort((a, b) => b.calls - a.calls);
       if (json) {