elanous 0.2.34 → 0.2.36

package/src/cli/tasks-cli.ts

@@ -1,33 +1,40 @@
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync } from 'node:fs';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { execFileSync, spawnSync } from 'node:child_process';
-import { loadRunLedger as loadRunLedgerSync, loadRunLedgerWithMetadata, runLedgerDir, resolveFederatedRunLedgerDirectories } from '../self-implement/run-ledger.js';
+import { createHash } from 'node:crypto';
+import { loadRunLedger as loadRunLedgerSync, loadRunLedgerWithMetadata, runLedgerDir, resolveFederatedRunLedgerDirectories, type RunLedgerEntry } 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 { dirname, 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 { readRunExits } from '../harness/harness-incidents.js';
 import { checklistDevVersion, listChecklist } 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, runTagChange, taskAgentStatePath as taskStatePathDefault, taskCardLabelContext, 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 { RUN_TAG_KEYS, runIdentityFieldText, runPriorityClass } from '../task-agent/run-identity.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 { remoteLedgerMirrorDirs } from '../task-agent/parent-host.js';
+import type { BoardNode } from '../task-agent/board.js';
+import { boundPrTerminal, cardPrNumber, CLOSED_BY_HAND_EVENT, closeTaskCard, COMPLETION_KINDS, defaultDraftClaimGhPorts, handDraftClaim, HAND_MOVE_HISTORY_EVENT, updateTaskCard, resolveHandText, readTaskAgentState, readTaskCard, runTagChange, taskAgentStatePath as taskStatePathDefault, shellQuote, TASK_SEATS, type CompletionKind, type DraftClaimGhPorts, type TaskCard, type TaskCardEvent, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
+import { recordWiringLiveVerified, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
+import { remoteLedgerMirrorDir, remoteLedgerMirrorDirs } from '../task-agent/parent-host.js';
+import { buildWorkOrder } from '../task-agent/work-order-build.js';
+import { cellIdFromBody } from '../pr-tool/census.js';
 import { ambiguousGreenSweepPrs, decideGreenSweep, greenSweepCandidates, observeGreenSweep, type GreenSweepPr } from '../task-agent/green-sweep.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 type { TierSizedDecompose } from '../task-agent/tier-split.js';
+import type { AdvanceMissionResult, MissionDecompose, PieceEvidenceReader } from '../task-agent/mission.js';
 import { formatSevenVerbLive, formatTaskAgentCover, measureSevenVerbLive, measureTaskAgentCover, type CoverRow, type ImplementCardRunBinding, type ImplementRunMergeEvent, type SevenVerbLive, type TaskAgentCoverInput } from '../task-agent/cover.js';
+import { measureRepairOutcomes } from '../task-agent/repair-outcomes.js';
 import { LogStore, STORE_SAFETY_MAX, type LogQuery, type LogStoreRow } from '../mss/logging/log-store.js';
 import { resolveLogTargets } from './logs-cli.js';
+import { createTasksCliContext, handleError, NEXUS_DOWN, NexusUnavailable, registerTaskAgentSink, registerTaskListCommand, registerTaskShowCommand, registerTasksRoot, request, responseJson, TASK_AGENT_SINK_SURFACE } from './tasks-read-cli.js';
 
-type TaskRow = Pick<Task, 'id' | 'title' | 'priority' | 'status' | 'createdAt' | 'approval' | 'generatedBy'>;
+// CLI-ENTRY-LAZY — 가벼운 읽기 경로(`tasks-read-cli.ts`)로 옮긴 공용 표면은 옛 import 경로 그대로 남긴다.
+export { registerTaskAgentSink, TASK_AGENT_SINK_SURFACE };
+
+function headLine(text: string): string {
+  const first = text.split('\n')[0]!.trim();
+  return first.length > 100 ? `${first.slice(0, 100)}…` : first;
+}
 
 export interface TasksCliDeps {
   baseUrl?: string;
@@ -45,10 +52,14 @@ export interface TasksCliDeps {
   taskStatePath?: string;
   /** 조합 선택 시험에서만 그래프 저장소 루트를 바꾼다. */
   taskCompositionRoot?: string;
+  /** DRAFT-CLAIM-AUTO-2-FU — `tasks hand --draft-claim <pr>` 의 관측·게시·수확 리뷰 포트(시험 주입). 기본 = `defaultDraftClaimGhPorts()`(gh CLI ⊕ 생산 리뷰 러너). */
+  draftClaimGh?: DraftClaimGhPorts;
   /** logs.db 싱크 등록(시험 주입). 기본 = `registerStandaloneLogSink`. `hand`·`show` 가 부른다. */
   registerSink?: (surface: string) => Promise<unknown>;
   /** `task hand --mission` 의 분해기(시험 주입). 기본 = 나열형은 결정론 · 아니면 `decomposeSelfDevGoal`. */
   missionDecompose?: MissionDecompose;
+  /** TIER-SPLIT-BEFORE-LAUNCH — `tasks hand --tier 상|특 --live` 의 분해기(시험 주입). 키가 없으면 `DEFAULT_TIER_SIZED_DECOMPOSE`. */
+  tierSizedDecompose?: TierSizedDecompose;
   /** `task advance` 의 착지 근거 읽기(시험 주입). 기본 = `predecessorState`(gh · 런 원장). */
   pieceEvidence?: PieceEvidenceReader;
   /** `task board` 의 내부 팩 어댑터(시험 주입). 기본 = 현재 판(`checklistDevVersion()`)의 `releasePackBoard` — 읽기만. */
@@ -57,6 +68,8 @@ export interface TasksCliDeps {
   releaseVersions?: () => string[];
   /** Isolated checklist read for PR adoption. */
   adoptChecklist?: typeof listChecklist;
+  /** Isolated checklist read for work-order build. */
+  workOrderChecklist?: typeof listChecklist;
   /** `tasks adopt-pr` live PR read seam; default is gh in this repository. */
   adoptPrView?: (number: number, cwd: string) => import('../task-agent/adopt-pr.js').AdoptPrView;
   /** Isolated ledger proof for a launched card being adopted. */
@@ -85,6 +98,19 @@ export interface TasksCliDeps {
   coverImplementRunMerges?: () => ReadonlyMap<string, ImplementRunMergeEvent> | null;
   /** Read test-universe ledgers only when --include-test was requested. */
   coverIncludeTest?: boolean;
+  /** `tasks outcomes` 의 «지금» — 상대 기간(`--since 24h`)을 푸는 기준(시험 주입). 기본 = `Date.now()`. */
+  outcomesNow?: () => number;
+  /** `tasks outcomes` 페이지 상한(시험 주입). 기본 = `OUTCOMES_QUERY_LIMIT`. */
+  outcomesLimit?: number;
+  /** `tasks doctor` read-only adapters; tests inject L1 evidence without calling gh or the operating ledger. */
+  doctorVersion?: () => string;
+  doctorChecklist?: typeof listChecklist;
+  doctorRun?: (command: string, args: string[]) => { status: number | null; stdout: string };
+  /** `tasks hand --live --checklist` checks open PRs before creating another implementation run. */
+  handOpenPrRun?: (command: string, args: string[]) => { status: number | null; stdout: string };
+  /** Repository selected for the open-PR census; the same origin is used by PR adoption. */
+  handOriginRepo?: () => string;
+  doctorLedger?: (runId: string, statePath: string) => import('../self-implement/run-ledger.js').RunLedgerEntry[] | 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`). */
@@ -111,21 +137,6 @@ function advanceLines(result: AdvanceMissionResult): string[] {
   ];
 }
 
-/** `tasks hand`·`show` 가 남기는 `task-agent` 관측의 logs.db surface 라벨. */
-export const TASK_AGENT_SINK_SURFACE = 'task-agent';
-
-/**
- * 독립 CLI 프로세스는 데몬의 logs.db 싱크를 상속하지 않는다 — 등록하지 않으면 `debug.log('task-agent', …)` 가
- * 파일 트레일에만 남고 `elanous logs --category task-agent` 에 0건으로 보인다(10-06 실측: 카드 3장 · 이벤트 0).
- * fail-open — 등록 실패가 과제 넘기기를 막지 않는다.
- */
-export async function registerTaskAgentSink(register?: (surface: string) => Promise<unknown>): Promise<void> {
-  try {
-    const fn = register ?? (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink;
-    await fn(TASK_AGENT_SINK_SURFACE);
-  } catch { /* fail-open — 파일 트레일이 진실원 */ }
-}
-
 /**
  * 기본 발사기 — 지금 도는 진입점으로 `--config-dir <운영 config>` 를 붙여 떼어 띄운다.
  * config-dir 은 명시(`--config-dir`/`--test`)가 있으면 그것, 없으면 운영 루트(`prodInstanceRoot()`)다.
@@ -163,10 +174,17 @@ export interface DefaultTaskLauncherDeps {
   /** HQ 판(시험 주입). */
   localVersion?: string;
   /** HQ-owned, refresh-less Codex access mirror to install before a remote parent launch. */
-  codexAccessMirror?: () => Promise<{ elanousAuth: string; codexAuth: string; account?: string; usedPercent?: number; thresholdPercent?: number } | null>;
+  codexAccessMirror?: () => Promise<{ elanousAuth: string; codexAuth: string; account?: string; usedPercent?: number; thresholdPercent?: number; mirrors?: Array<{ elanousAuth: string; codexAuth: string; account: string; usedPercent?: number; thresholdPercent: number; expiresAt: number }> } | null>;
+  /** HQ-owned Grok subscription access mirror; resolved before the first remote SSH call. */
+  grokAccessMirror?: () => import('../task-agent/parent-host.js').OwnerGrokAccessMirror;
+  /** Clock used to recheck mirror freshness immediately before installation. */
+  now?: () => number;
   /** Isolated integration seam; production still reads the HQ rotation snapshot and config directly. */
   ownerCodexRotation?: () => ReturnType<typeof import('../oauth/codex-account-store.js').inspectCodexRotation>;
-  ownerCodexRotationConfig?: { accountOrder?: readonly string[]; thresholdPercentByAccount?: Readonly<Record<string, unknown>> };
+  ownerCodexRotationConfig?: { accountOrder?: readonly string[]; thresholdPercentByAccount?: Readonly<Record<string, unknown>>;
+    creditsAllowed?: boolean; creditReserve?: number };
+  /** The HQ owner fence is checked before any token refresh. */
+  ownerCodexLeaseHolder?: () => boolean;
   /** 원격 → 로컬 되돌림 알림(시험 주입). 기본 = stderr 한 줄. */
   notice?: (line: string) => void;
 }
@@ -187,13 +205,17 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
   const multi = Array.isArray(configured);
   const targets = configured === null ? [] : parentHostModule.resolveParentHosts(configured, deps.parentHost === undefined ? process.env : { ...process.env, ELANOUS_TA_PARENT_HOST: undefined });
   if (!targets.length) return null;
+  const providerFromArgs = args.find((arg) => arg.startsWith('--child-llm-provider='))?.slice('--child-llm-provider='.length)
+    ?? (args.includes('--child-llm-provider') ? args[args.indexOf('--child-llm-provider') + 1] : undefined);
+  const effectiveChildProvider = context.effectiveChildProvider ?? providerFromArgs;
   const notice = deps.notice ?? ((line: string) => { try { process.stderr.write(`${line}\n`); } catch { /* ignore */ } });
   const failed = (target: typeof targets[number], gaps: string[], facts: Record<string, string> = {}): void => {
     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(' · ')}`);
   };
-  let accessMirror: { elanousAuth: string; codexAuth: string; account?: string; usedPercent?: number; thresholdPercent?: number } | null | undefined;
-  const getAccessMirror = async (): Promise<{ elanousAuth: string; codexAuth: string; account?: string; usedPercent?: number; thresholdPercent?: number } | null> => {
+  type OwnerMirror = { elanousAuth: string; codexAuth: string; account?: string; usedPercent?: number; thresholdPercent?: number; mirrors?: Array<{ elanousAuth: string; codexAuth: string; account: string; usedPercent?: number; thresholdPercent: number; expiresAt: number }> };
+  let accessMirror: OwnerMirror | null | undefined;
+  const getAccessMirror = async (): Promise<OwnerMirror | null> => {
     if (accessMirror !== undefined) return accessMirror;
     if (deps.codexAccessMirror) {
       accessMirror = await deps.codexAccessMirror();
@@ -205,37 +227,66 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
       import('../oauth/codex.js'),
       import('../hq/hq.js'),
     ]);
-    const { inspectCodexRotation } = await import('../oauth/codex-account-store.js');
+    const { inspectCodexRotation, codexQuotaPolicyFromConfig } = await import('../oauth/codex-account-store.js');
+    const { codexPolicyAllowsCredits } = await import('../oauth/codex-quota-policy.js');
     const { planOwnerCodexMirrorCandidates, podAccountThresholdPercent } = await import('../task-orchestrator/surfaces/pod-account-broker.js');
     const { getUserConfig } = await import('../user-config.js');
     const rotation = deps.ownerCodexRotation?.() ?? inspectCodexRotation();
     const config = getUserConfig();
     const ownerConfig = deps.ownerCodexRotationConfig;
     const candidates = [...rotation.candidates];
+    // No local credential preserves the established local-launch fallback.
+    if (candidates.length === 0) { accessMirror = null; return null; }
+    const ownerLeaseHeld = deps.ownerCodexLeaseHolder?.() ?? hq.hqFenceDecision('ledger-cli').run;
+    if (!ownerLeaseHeld) throw new NoEligibleOwnerCodexAccountError('HQ Codex 토큰 주인 임대가 없어 원격 미러 발사를 거부한다');
     const eligible = planOwnerCodexMirrorCandidates(candidates, {
       accountOrder: ownerConfig?.accountOrder ?? config.llm?.codexAccountOrder ?? [],
       thresholdPercentByAccount: ownerConfig?.thresholdPercentByAccount ?? config.llm?.codexAccountRotationThresholdPercentByAccount,
+      creditsAllowed: ownerConfig?.creditsAllowed ?? codexPolicyAllowsCredits(codexQuotaPolicyFromConfig()),
+      creditReserve: ownerConfig?.creditReserve ?? config.llm?.codexCreditReserve,
     });
     if (candidates.length > 0 && eligible.length === 0) throw new NoEligibleOwnerCodexAccountError('HQ 소유 Codex 계정이 모두 사용 임계에 도달해 원격 부모 발사를 거부한다');
     const prerefreshDeps = {
       credentials: (account: string) => pod.hostCredentials(account, authStore.authStorePath(), () => '', { requireExplicitChatgptAuthMode: true }),
       refresh: (account: string) => codex.refreshCodexAccountHome(account),
-      isLeaseHolder: () => hq.hqFenceDecision('ledger-cli').run,
+      isLeaseHolder: () => deps.ownerCodexLeaseHolder?.() ?? hq.hqFenceDecision('ledger-cli').run,
     };
-    for (const candidate of eligible) {
-      // The account's refresh token stays on HQ. Only the selected account's access-only mirror crosses SSH.
+    const mirrors: NonNullable<OwnerMirror['mirrors']> = [];
+    for (const [index, candidate] of eligible.entries()) {
+      const usedPercent = candidate.usedPercent;
+      const thresholdPercent = podAccountThresholdPercent(candidate.name, {
+        thresholdPercentByAccount: ownerConfig?.thresholdPercentByAccount ?? config.llm?.codexAccountRotationThresholdPercentByAccount,
+      });
+      // HQ is the sole refresh owner. Send every usable account as an access-only snapshot
+      // so the remote Pod broker can rotate instead of pinning all jobs to one account.
       let credential: Awaited<ReturnType<typeof pod.podCodexCredentialWithPrerefresh>> = null;
       try { credential = await pod.podCodexCredentialWithPrerefresh(candidate.name, prerefreshDeps); }
-      catch { continue; }
-      if (!credential) continue;
-      accessMirror = { elanousAuth: credential.elanousAuth, codexAuth: credential.codexAuth, account: candidate.name,
-        ...(candidate.usedPercent !== undefined ? { usedPercent: candidate.usedPercent } : {}),
-        thresholdPercent: podAccountThresholdPercent(candidate.name, {
-          thresholdPercentByAccount: ownerConfig?.thresholdPercentByAccount ?? config.llm?.codexAccountRotationThresholdPercentByAccount,
-        }) };
-      return accessMirror;
+      catch {
+        try { debug.log('task-agent.parent-host', 'codex-access-mirror-account-skipped', { account: candidate.name, reason: 'credential-error' }); } catch { /* fail-soft */ }
+        continue;
+      }
+      if (!credential) {
+        try { debug.log('task-agent.parent-host', 'codex-access-mirror-account-skipped', { account: candidate.name, reason: 'expiring-or-refresh-failed' }); } catch { /* fail-soft */ }
+        continue;
+      }
+      const expiresAt = (JSON.parse(credential.elanousAuth) as { providers?: { 'openai-codex'?: { tokens?: { expiresAt?: unknown } } } }).providers?.['openai-codex']?.tokens?.expiresAt;
+      if (typeof expiresAt !== 'number' || !Number.isFinite(expiresAt) || expiresAt <= (deps.now?.() ?? Date.now()) + 3 * 60 * 60 * 1000) {
+        try { debug.log('task-agent.parent-host', 'codex-access-mirror-account-skipped', { account: candidate.name, reason: 'access-expiring' }); } catch { /* fail-soft */ }
+        continue;
+      }
+      mirrors.push({ elanousAuth: credential.elanousAuth, codexAuth: credential.codexAuth, account: candidate.name,
+        expiresAt,
+        ...(usedPercent !== undefined ? { usedPercent } : {}), thresholdPercent });
+      // The receiving marker parser accepts at most 16 distinct accounts.
+      // Apply the same bound before writing credentials on the remote parent.
+      if (mirrors.length === 16) {
+        for (const skipped of eligible.slice(index + 1)) {
+          try { debug.log('task-agent.parent-host', 'codex-access-mirror-account-skipped', { account: skipped.name, reason: 'snapshot-limit-16' }); } catch { /* fail-soft */ }
+        }
+        break;
+      }
     }
-    accessMirror = null;
+    accessMirror = mirrors.length ? { ...mirrors[0]!, mirrors } : null;
     return accessMirror;
   };
   if (cwd) {
@@ -248,6 +299,11 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
   //   그 앞의 readParentHostCapacity 도 ssh). 가드를 아래로 내리면 hold 경로에서 시험이 실 ssh 를 쏜다(R7 사고 모양).
   //   hold 경로를 재는 시험은 deps.ssh 가짜 또는 parentHost:null 을 주입한다(real-launch-guard.test 가 이 순서를 문다).
   if (!deps.ssh) (await import('../task-agent/real-launch-guard.js')).refuseRealLaunchUnderTest('remote-parent-ssh', targets.map((target) => target.host).join(','));
+  // Grok access is selected/refreshed on HQ before preflight performs any SSH call. A missing or stale
+  // subscription must fail closed without touching the remote host or falling back to a local launch.
+  const grokAccessMirror = effectiveChildProvider === 'grok'
+    ? (deps.grokAccessMirror?.() ?? parentHostModule.resolveOwnerGrokAccessMirror())
+    : undefined;
   let launchHoldActive = false;
   try {
     if (deps.launchHoldActive) launchHoldActive = deps.launchHoldActive();
@@ -264,6 +320,8 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
   delete remoteEnv.ELANOUS_REMOTE_CODEX_ACCOUNT;
   delete remoteEnv.ELANOUS_REMOTE_CODEX_USED_PERCENT;
   delete remoteEnv.ELANOUS_REMOTE_CODEX_THRESHOLD_PERCENT;
+  delete remoteEnv.ELANOUS_REMOTE_CODEX_ACCOUNTS;
+  delete remoteEnv.ELANOUS_REMOTE_CODEX_ACCESS_ONLY;
   if (podGoal) for (const key of ['ELANOUS_POD_MEMORY_TIER', 'ELANOUS_POD_MEMORY', 'ELANOUS_POD_MEMORY_HIGH', 'ELANOUS_POD_MEMORY_LITE', 'ELANOUS_POD_GOAL_TYPE'] as const) {
     const value = context.env[key] ?? process.env[key];
     if (value !== undefined) remoteEnv[key] = value;
@@ -300,30 +358,63 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
     if (preflight.warnings.length) notice(`⚠ ${target.host} 자격: ${preflight.warnings.join(' · ')}`);
     try {
       if (parentHostModule.shouldInstallRemoteCodexAccess(context.effectiveChildProvider)) {
-        let mirror: { elanousAuth: string; codexAuth: string; account?: string; usedPercent?: number; thresholdPercent?: number } | null = null;
+        let mirror: OwnerMirror | null = null;
         let mirrorReason = 'credential-source-empty';
         try { mirror = await getAccessMirror(); }
         catch (error) {
           if (error instanceof NoEligibleOwnerCodexAccountError) throw error;
           mirrorReason = 'credential-source-error';
         }
-        if (mirror) parentHostModule.installRemoteCodexAccess(target, mirror, deps.ssh);
+        // The receiver accepts at most 16 accounts. Use this same bounded
+        // snapshot for installation, the launch marker, and the selected account,
+        // including mirrors supplied by the injected credential source.
+        const mirrors = mirror?.mirrors?.slice(0, 16);
+        const selected = mirrors?.[0] ?? mirror;
+        if (mirror) {
+          // Snapshot construction can outlive the HQ owner lease. Fresh tokens
+          // bypass prerefresh's lock, so recheck before any credential leaves HQ.
+          if (!(deps.ownerCodexLeaseHolder?.() ?? (await import('../hq/hq.js')).hqFenceDecision('ledger-cli').run)) {
+            try { debug.log('task-agent.parent-host', 'codex-access-mirror-owner-lease-lost', { host: target.host, runId: context.runId, reason: 'owner-lease-lost-before-install' }); } catch { /* fail-soft */ }
+            throw new NoEligibleOwnerCodexAccountError('HQ Codex 토큰 주인 임대가 설치 직전에 사라져 원격 미러 발사를 거부한다');
+          }
+          if (mirror.mirrors && mirror.mirrors.length > 16) {
+            for (const skipped of mirror.mirrors.slice(16)) {
+              try { debug.log('task-agent.parent-host', 'codex-access-mirror-account-skipped', { account: skipped.account, reason: 'snapshot-limit-16' }); } catch { /* fail-soft */ }
+            }
+          }
+          // Each detached parent keeps its own auth store and Codex homes for
+          // its full lifetime, including the legacy single-account source.
+          const identity = createHash('sha256').update(`${context.runId}\0${context.launchId}`).digest('hex').slice(0, 20);
+          const xdgRoot = `${target.configDir ?? '$HOME/.elanous'}/remote-parent-credentials/${identity}`;
+          const mirrorDir = `${xdgRoot}/elanous`;
+          const installed = mirrors ?? [{ ...mirror, account: mirror.account ?? 'default' }];
+          parentHostModule.installRemoteCodexAccessBatch({ ...target, configDir: mirrorDir }, installed, deps.ssh);
+          remoteEnv.XDG_CONFIG_HOME = xdgRoot;
+          remoteEnv.CODEX_HOME = `${mirrorDir}/codex-default`;
+          // XDG isolation is for Codex credentials only. gh otherwise loses
+          // the remote host's existing login before a Pod can be created.
+          remoteEnv.GH_CONFIG_DIR = '$HOME/.config/gh';
+        }
         else {
           try { debug.log('task-agent.parent-host', 'codex-access-mirror-unavailable', { host: target.host, runId: context.runId, reason: mirrorReason }); } catch { /* fail-soft */ }
           failed(target, ['codex-access-mirror-unavailable']);
           return null;
         }
-        if (mirror.account) {
-          remoteEnv.ELANOUS_REMOTE_CODEX_ACCOUNT = mirror.account;
-          remoteEnv.ELANOUS_REMOTE_CODEX_USED_PERCENT = mirror.usedPercent === undefined ? 'unknown' : String(mirror.usedPercent);
-          if (mirror.thresholdPercent !== undefined) remoteEnv.ELANOUS_REMOTE_CODEX_THRESHOLD_PERCENT = String(mirror.thresholdPercent);
+        if (selected?.account) {
+          remoteEnv.ELANOUS_REMOTE_CODEX_ACCOUNT = selected.account;
+          remoteEnv.ELANOUS_REMOTE_CODEX_USED_PERCENT = selected.usedPercent === undefined ? 'unknown' : String(selected.usedPercent);
+          if (selected.thresholdPercent !== undefined) remoteEnv.ELANOUS_REMOTE_CODEX_THRESHOLD_PERCENT = String(selected.thresholdPercent);
         }
+        if (mirrors) remoteEnv.ELANOUS_REMOTE_CODEX_ACCOUNTS = JSON.stringify(mirrors.map(({ account, usedPercent, thresholdPercent, expiresAt }) => ({ account, usedPercent: usedPercent ?? null, thresholdPercent, expiresAt })));
+        remoteEnv.ELANOUS_REMOTE_CODEX_ACCESS_ONLY = '1';
       }
-      const launched = parentHostModule.launchRemoteParent(target, args, remoteEnv, deps.ssh);
+      const launched = parentHostModule.launchRemoteParent(target, args, remoteEnv, deps.ssh,
+        grokAccessMirror ? () => grokAccessMirror : undefined, effectiveChildProvider, deps.now);
       try { debug.log('task-agent', 'parent-host-launched', { host: target.host, runId: context.runId, pid: launched.pid, log: launched.log }); } catch { /* fail-soft */ }
       return { runId: context.runId, parentHost: { host: target.host, ...(target.configDir ? { configDir: target.configDir } : {}), pid: launched.pid, log: launched.log } };
     } catch (error) {
       if (error instanceof parentHostModule.RemoteParentNotLaunchedError) { failed(target, [error.message]); continue; }
+      if (error instanceof NoEligibleOwnerCodexAccountError) throw error;
       try { debug.log('task-agent', 'parent-host-launch-uncertain', { host: target.host, runId: context.runId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
       throw error;
     }
@@ -344,6 +435,7 @@ function firstStderrLine(path: string): string {
 }
 
 export async function defaultTaskLauncher(args: string[], cwd?: string, context?: TaskLaunchContext, deps: DefaultTaskLauncherDeps = {}): Promise<void | TaskLaunchReceipt> {
+  if (context) context = (await import('../harness/launch-utterance-ledger.js')).withHandLaunchPairContext(args, context); // LAUNCH-UTTERANCE-LEDGER hand→say pair env
   if (context) {
     const remote = await tryRemoteParent(args, cwd, context, deps);
     if (remote) return remote;
@@ -446,159 +538,6 @@ export function spawnDetachedConfirmed(spawnFn: DetachedSpawn, command: string,
   });
 }
 
-/** HARNESS-PARENT-ON-MSB1 — 카드가 원격 부모면 그 런 원장(⊕ Pod 자식)을 HQ 거울로 당긴다. 실패는 관측만(«없음»으로 읽히지 않게). */
-async function mirrorRemoteCardLedger(cardId: string, deps: TasksCliDeps): Promise<void> {
-  let card: TaskCard | undefined;
-  try { card = readTaskCard(cardId, deps.taskStatePath); } catch { return; }
-  if (!card?.parentHost || !card.runId) return;
-  try {
-    if (deps.remoteLedgerMirror) { deps.remoteLedgerMirror(card); return; }
-    const { mirrorRemoteRunLedgers } = await import('../task-agent/parent-host.js');
-    const { effectiveInstanceRoot } = await import('../instance/resolve.js');
-    mirrorRemoteRunLedgers(card.parentHost, card.runId, effectiveInstanceRoot(), deps.cardRunEvidence?.ssh);
-  } catch (error) {
-    try { debug.log('task-agent', 'remote-ledger-mirror-failed', { card: cardId, host: card.parentHost.host, runId: card.runId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
-  }
-}
-
-function moveLine(card: TaskCard): string {
-  const move = nextMoveFor(card);
-  return `${move.kind}${move.command ? ` — elanous ${move.command.map(shellQuote).join(' ')}` : ''} (${move.reason})`;
-}
-
-function headLine(text: string): string {
-  const first = text.split('\n')[0]!.trim();
-  return first.length > 100 ? `${first.slice(0, 100)}…` : first;
-}
-
-/** 런 연결 한 줄 — 런 id 가 없으면 없다(옛 카드 · shadow). */
-function runLinkLine(card: TaskCard): string[] {
-  if (!card.runId) return [];
-  const number = cardPrNumber(card);
-  const url = typeof card.pr === 'object' ? card.pr.url : undefined;
-  const pr = number !== undefined ? `#${number}${url ? ` ${url}` : ''}` : '-';
-  return [`런: ${card.runId} · 골: ${card.goalId ?? '-'} · PR: ${pr}${card.runChildId ? ` · 자식 런: ${card.runChildId}` : ''}`];
-}
-
-/** RUN-IDENTITY-TAGS — 신분 한 줄 + Pod 라벨 한 줄(원장 정본 2줄 렌더 · 신분 없는 카드는 «미기록»으로 적고 기본값 정책을 밝힌다). */
-function cardIdentityLines(card: TaskCard): string[] {
-  const identity = card.identity;
-  const { labels } = taskCardLabelContext({ id: card.id });
-  // 경계: Pod 에 실제로 붙는 라벨은 카드 id 하나뿐이다 — 신분 값은 Pod 라벨에 아직 안 실린다(RUN-IDENTITY-ADMIT 몫). 화면도 그렇게 말한다.
-  const podLine = `Pod 라벨 ${Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(' ')} (신분 값은 Pod 라벨 미탑재 — RUN-IDENTITY-ADMIT)`;
-  if (!identity) return [`신분 미기록 — 원장에 identity 없음 · 승인·선점은 기본 class=${runPriorityClass(identity)} 로 읽는다`, podLine];
-  // ⛔ 모르는 칸을 기본값으로 보이지 않는다 — 원장에 없는 칸은 «미기록»으로 적는다(확인된 칸만 값으로).
-  const identityText = RUN_TAG_KEYS.map((key) => `${key}=${runIdentityFieldText(identity, key)}`).join(' · ');
-  const originParts = [identity.origin?.checklistId, identity.origin?.version, identity.origin?.seat, identity.origin?.launcher].filter((part) => part !== undefined);
-  return [
-    `신분 ${identityText}${originParts.length > 0 ? ` — 출생 ${originParts.join(' · ')}` : ''}`,
-    podLine,
-  ];
-}
-
-function taskCardLines(card: TaskCard): string[] {
-  return [
-    [card.id, card.status, card.seat ?? '-', card.checklistId ?? '-', card.createdAt, card.text].join('\t'),
-    ...cardIdentityLines(card),
-    ...(card.targetPaths !== undefined ? [`대상 경로: ${card.targetPaths.length ? card.targetPaths.join(' · ') : '(유효한 경로 없음)'}`] : []),
-    ...(card.mission ? [`미션: ${card.mission} · after: ${card.after?.length ? card.after.join(', ') : '-'}`] : []),
-    ...runLinkLine(card),
-    ...liveMoveLines(card),
-    `다음 수: ${moveLine(card)}`,
-  ];
-}
-
-/** TA-LIVE-MOVE-CARD-HISTORY — 카드 history 의 live-move 줄(실행·그림자)을 한 줄씩. 없으면 없다(옛 카드 그대로). */
-function liveMoveLines(card: TaskCard): string[] {
-  return (card.history ?? []).filter((item) => item.event === LIVE_MOVE_HISTORY_EVENT || item.event === LIVE_MOVE_RESULT_EVENT).map((item) => item.event === LIVE_MOVE_RESULT_EVENT ? [
-    // TA-REVIEW-RESULT-CAPTURE — 회수한 리뷰 결과(또는 «결과 없음») 줄.
-    `결과: ${item.at}`, `${item.kind ?? '?'}`, `PR ${item.pr !== undefined ? `#${item.pr}` : '-'}${item.head ? ` head ${item.head.slice(0, 12)}` : ''}`,
-    `verdict=${item.verdict ?? '—'} reviewed=${item.reviewed ?? '—'} must-fix=${item.mustFix ?? '—'} route=${item.reviewRoute ?? '—'}`,
-    `효과: ${item.effect ?? 'unknown'}`, (item.detail ?? '').replace(/\r\n|\r|\n/g, (match) => (match === '\r' ? '\\r' : '\\n')),
-  ].join(' · ') : [
-    `수: ${item.at}`, `${item.kind ?? '?'} ${item.executorResult ?? '?'}`, `executed=${item.executed === true} ok=${item.ok === undefined ? '—' : item.ok}`,
-    `PR ${item.pr !== undefined ? `#${item.pr}` : '-'}${item.head ? ` head ${item.head.slice(0, 12)}` : ''}`,
-    `효과: ${item.effect ?? 'unknown'}`, (item.detail ?? '').replace(/\r\n|\r|\n/g, (match) => (match === '\r' ? '\\r' : '\\n')),
-  ].join(' · '));
-}
-
-/** 미션 카드 — 머리 한 줄 ⊕ 조각 한 줄씩(상태·다음 수·선행) ⊕ 간선 한 줄씩. */
-function missionLines(mission: TaskCard, pieces: TaskCard[]): string[] {
-  const edges = pieces.flatMap((piece) => (piece.after ?? []).map((before) => `간선: ${before} -> ${piece.id}`));
-  return [
-    [mission.id, 'mission', mission.seat ?? '-', mission.checklistId ?? '-', mission.createdAt, `조각 ${pieces.length} · 간선 ${edges.length} · 출처 ${mission.splitSource ?? '-'}`, headLine(mission.text)].join('\t'),
-    ...pieces.map((piece) => [`조각: ${piece.id}`, piece.status, nextMoveFor(piece).kind, `after: ${piece.after?.length ? piece.after.join(',') : '-'}`, headLine(piece.text),
-      ...(piece.runId ? [`런: ${piece.runId}${cardPrNumber(piece) !== undefined ? ` · PR #${cardPrNumber(piece)}` : ''}`] : [])].join('\t')),
-    ...edges,
-    ...(mission.greenProposal ? [`green 제안: ${mission.greenProposal.at} · 칸 ${mission.greenProposal.checklistId ?? '-'} · 근거 ${Object.entries(mission.greenProposal.evidence).map(([id, ref]) => `${id}=${ref}`).join(', ')}`] : []),
-  ];
-}
-
-const PRIORITY_RANK: Record<Task['priority'], number> = { urgent: 0, high: 1, medium: 2, low: 3 };
-const NEXUS_DOWN = '넥서스가 안 떠 있다 — `elanous nexus run`';
-
-function taskOrder(a: TaskRow, b: TaskRow): number {
-  return PRIORITY_RANK[a.priority] - PRIORITY_RANK[b.priority]
-    || a.createdAt - b.createdAt || a.id.localeCompare(b.id);
-}
-
-function taskSource(task: TaskRow): string {
-  return task.generatedBy?.kind === 'external'
-    ? `${task.generatedBy.provider}:${task.generatedBy.ref}` : '-';
-}
-
-function taskLine(task: TaskRow): string {
-  return [task.id, task.priority, task.status, task.approval?.state ?? '-', taskSource(task), task.title].join('\t');
-}
-
-function credentials(deps: TasksCliDeps): { baseUrl: string; token?: string } | null {
-  const port = deps.baseUrl !== undefined ? undefined : readNexusRuntime()?.httpPort;
-  const baseUrl = deps.baseUrl ?? (port ? `http://127.0.0.1:${port}` : undefined);
-  if (!baseUrl) return null;
-  // Same as `connector linear sync`: an isolated (--test) universe has no acp-token and its
-  // daemon accepts loopback callers without one — send the bearer only when there is one.
-  let token = deps.bearerToken;
-  if (token === undefined) {
-    try { token = readFileSync(join(getElanousConfigDir(), 'acp-token'), 'utf8').trim() || undefined; }
-    catch { token = undefined; }
-  }
-  return { baseUrl, ...(token ? { token } : {}) };
-}
-
-class NexusUnavailable extends Error {}
-
-async function request(deps: TasksCliDeps, auth: { baseUrl: string; token?: string }, path: string, method = 'GET'): Promise<Response> {
-  try {
-    return await (deps.fetch ?? fetch)(`${auth.baseUrl}${path}`, {
-      method,
-      headers: auth.token ? { Authorization: `Bearer ${auth.token}` } : {},
-    });
-  } catch {
-    // Fetch exceptions can include the URL or credentials; never forward their text.
-    throw new NexusUnavailable();
-  }
-}
-
-async function responseJson(response: Response): Promise<unknown> {
-  try { return await response.json(); }
-  catch { throw new Error('넥서스 응답 JSON이 유효하지 않다'); }
-}
-
-function httpError(response: Response): Error {
-  // Do not echo server-supplied error bodies: they may contain credentials.
-  return new Error(`HTTP ${response.status}`);
-}
-
-function handleError(error: unknown, out: (line: string) => void): void {
-  if (error instanceof NexusUnavailable) {
-    out(NEXUS_DOWN);
-    process.exitCode = 2;
-  } else {
-    out(error instanceof Error ? error.message : '태스크 요청 실패');
-    process.exitCode = 1;
-  }
-}
-
 const COVER_QUERY_LIMIT = STORE_SAFETY_MAX;
 
 /** Federated read: rows from every store, whether any single store hit the bound, and how many stores could not be read. */
@@ -897,17 +836,736 @@ export function readTaskAgentCover(
     limitReached: truncated.taskAgentActions || truncated.allLands || moveRead?.limitReached === true || orderRead?.limitReached === true || goalAsksTruncated || goalRunsTruncated, unreadableStores };
 }
 
-export function registerTasksCommands(program: Command, deps: TasksCliDeps = {}): void {
-  let activeToken: string | undefined;
-  const output = deps.output ?? console.log;
-  const out = (line: string) => output(activeToken ? line.replaceAll(activeToken, '[redacted]') : line);
-  const authenticate = () => {
-    const auth = credentials(deps);
-    activeToken = auth?.token;
-    if (!auth) throw new NexusUnavailable();
-    return auth;
+const OUTCOMES_QUERY_LIMIT = STORE_SAFETY_MAX;
+
+/** «끝났다»로 읽는 카드 상태 — 이 밖(handed·launched)은 PR 종결 관측이 있어야 끝난 것으로 센다. */
+const OUTCOME_TERMINAL_STATUSES: ReadonlySet<TaskCard['status']> = new Set(['failed', 'launch-failed', 'landed', 'landed-by-hand', 'done']);
+
+/** 카드 원장에서 «종결»로 읽는 사건 — 이 줄의 시각만 종료 시각으로 쓴다(run-bound · launch 같은 끝나기 전 사건은 종료 시각이 아니다). */
+const OUTCOME_TERMINAL_HISTORY_EVENTS: ReadonlySet<string> = new Set([
+  'failed', 'launch-failed', 'closed-by-hand', 'landed-via-train', 'postland-card', 'postland',
+]);
+const OUTCOME_SUCCESS_HISTORY_EVENTS: ReadonlySet<string> = new Set(['landed-via-train', 'postland-card', 'postland']);
+
+/** `--since`/`--until` 의 상대 기간 — `24h` · `90m` · `3d`. */
+const OUTCOMES_RELATIVE_WINDOW = /^\d+(?:\.\d+)?(?:m|h|d)$/;
+
+/** `--since`/`--until` — ISO 시각 또는 상대 기간. 그 밖의 모양은 창을 지어내지 않고 거부한다. */
+function parseOutcomeTime(value: string | undefined, flag: string, now: number): number | undefined {
+  if (value === undefined) return undefined;
+  const text = value.trim();
+  if (OUTCOMES_RELATIVE_WINDOW.test(text)) {
+    const amount = Number(text.slice(0, -1));
+    const unit = text.slice(-1);
+    const hours = unit === 'd' ? amount * 24 : unit === 'm' ? amount / 60 : amount;
+    return now - hours * 3_600_000;
+  }
+  const time = Date.parse(text);
+  if (!/^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d\d:\d\d)$/.test(text) || !Number.isFinite(time)) {
+    throw new Error(`${flag} 는 ISO 시각 또는 상대 기간(24h·3d)이어야 한다`);
+  }
+  return time;
+}
+
+/** `tasks outcomes` 한 줄 — 카드 하나의 결과. 모르는 칸은 null(지어내지 않는다). */
+export interface TaskOutcomeRow {
+  /** 칸(체크리스트 id) — 칸 없이 넘긴 카드는 null. */
+  cell: string | null;
+  card: string;
+  runId: string | null;
+  /** 사유 원장을 실제로 읽은 자식 런(부모 pod-child-run 매핑). */
+  childRunId: string | null;
+  /** 부모 호스트 원격 이름 — HQ 로컬 발사면 null. */
+  host: string | null;
+  /** 이 행의 카드 또는 PR 종결 사건 시각(ISO). */
+  endedAt: string;
+  cardTerminalAt: string | null;
+  /** 카드가 결속 PR의 종단을 관측한 시각. GitHub 원본 mergedAt/closedAt 와 동일하다고 추정하지 않는다. */
+  prTerminalAt: string | null;
+  /** 이 카드 원장은 GitHub 원본 terminal timestamp 를 보존하지 않는다. */
+  ghTerminalAt: null;
+  ghTerminalMissing: 'not-stored-in-card';
+  /** 이 행이 들어가는 독립 분모. 같은 카드의 카드·PR 종결은 별도 행이다. */
+  terminalKind: 'card' | 'pr';
+  /** 이 사건을 센 근거 — 카드 상태·이력 사건 또는 결속된 PR 상태를 그대로 적는다. */
+  countReason: string;
+  /** 원시 카드 상태. board가 PR 종결로 투영한 상태와 구별한다. */
+  cardStatus: TaskCard['status'];
+  /** PR 결속 — 번호 ⊕ 종결 상태(종결을 못 봤으면 state null). */
+  pr: { number: number; state: 'MERGED' | 'CLOSED' | null } | null;
+  /** 종결 사유 원문 — 자식 원장의 마지막 pr-open-failed/child-error data.error 꼬리(없으면 null). */
+  reason: string | null;
+  /** 종결 사유를 읽은 곳(`child-ledger:<event>` · 못 읽었으면 null). */
+  reasonFrom: string | null;
+  /** 원본 증거 또는 그 증거를 못 실은 이유. */
+  evidence: { childLedger: { event: string; error: string } | null; childLedgerMissing: string | null;
+    lastLines: string[] | null; lastLinesMissing: string | null };
+}
+
+export interface TaskOutcomeReport {
+  since: string | null;
+  until: string | null;
+  rows: TaskOutcomeRow[];
+  /** 사유별 집계 — 사유 분모는 실패 카드 종단뿐이다(PR/성공 종단은 포함하지 않는다). */
+  aggregate: { cards: number; cardTerminals: number; prTerminals: number; failedCardTerminals: number;
+    reasons: Array<{ reason: string; count: number }>; missingReason: number };
+  /** 조회 상한에 닿아 절단됐나 — 그때 집계는 «이 창 안에서 센 행»만 센다. */
+  limitReached: boolean;
+  /** 절단 사유 — 카드 조회 상한. */
+  stopReason: 'page-limit' | null;
+  /** 자식 원장(자식 런 원장 파일)을 실제로 읽었나. */
+  childLedgerObserved: boolean;
+  /** 종결 사유 원문을 하나라도 관측했나. */
+  reasonObserved: boolean;
+  /** 끝났는데 종료 시각을 몰라 창에 넣지 못한 카드 수. */
+  undatedCards: number;
+  /** 시각 없는 카드의 기간 귀속은 계산할 수 없다. undatedCards 는 창 밖까지 포함한 수다. */
+  undatedPeriodAttribution: 'unknown';
+  /** 두 종결 사건이 모두 창 안에 있는 카드 ID. --by 축 필터에서도 같은 목록을 낸다. */
+  overlapCardIds: string[];
+  /** 아직 끝나지 않은 카드 수(창 대상 아님). */
+  openCards: number;
+  warning?: string;
+}
+
+/** 마지막 실제 종결 사건. 후보·발사·run-bound·관측 줄은 종료 증거가 아니다. */
+function outcomeTerminalHistoryLine(card: TaskCard): TaskCardEvent | undefined {
+  return (card.history ?? []).filter((item) => OUTCOME_TERMINAL_HISTORY_EVENTS.has(item.event)).at(-1);
+}
+
+/** 종결 사유 원문을 주는 자식 원장 이벤트 — 뒤에서부터 마지막 것을 쓴다. */
+const OUTCOME_REASON_LEDGER_EVENTS = new Set(['pr-open-failed', 'child-error']);
+
+/** 부모 runId 원장의 마지막 pod-child-run 매핑이 가리키는 자식 런. 매핑이 없으면 null. */
+function outcomeChildRunId(card: TaskCard, ledgerDir: string): string | null {
+  if (typeof card.runId !== 'string' || card.runId === '') return null;
+  const parent = loadRunLedgerSync(card.runId, ledgerDir);
+  if (parent === null) return null;
+  for (let i = parent.length - 1; i >= 0; i -= 1) {
+    const entry = parent[i]!;
+    if (entry.event !== 'pod-child-run') continue;
+    const childRunId = entry.data?.childRunId;
+    return typeof childRunId === 'string' && childRunId !== '' ? childRunId : null;
+  }
+  return null;
+}
+
+/** 자식 원장의 마지막 pr-open-failed/child-error data.error 꼬리 — 없으면 null. */
+function outcomeChildLedgerReason(childEntries: readonly RunLedgerEntry[]): { reason: string; reasonFrom: string } | null {
+  for (let i = childEntries.length - 1; i >= 0; i -= 1) {
+    const entry = childEntries[i]!;
+    if (!OUTCOME_REASON_LEDGER_EVENTS.has(entry.event)) continue;
+    const error = entry.data?.error;
+    if (typeof error !== 'string' || error === '') continue;
+    return { reason: error, reasonFrom: `child-ledger:${entry.event}` };
+  }
+  return null;
+}
+
+/**
+ * TA 카드·PR 종결 사실을 기간으로 센다(읽기 전용). 창은 «종료 시각»에 걸린다.
+ * 종결 사유 원문은 부모 runId → pod-child-run 매핑 → 자식 원장의 마지막
+ * pr-open-failed/child-error data.error 꼬리에서 읽는다.
+ */
+export function readTaskOutcomes(
+  window: { sinceMs?: number; untilMs?: number; terminalKind?: 'card' | 'pr' } = {},
+  deps: Pick<TasksCliDeps, 'taskStatePath' | 'outcomesLimit'> = {},
+  snapshot?: Record<string, TaskCard>,
+): Omit<TaskOutcomeReport, 'since' | 'until'> {
+  const statePath = deps.taskStatePath ?? taskStatePathDefault();
+  const cards = snapshot ?? readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath).tasks ?? {};
+  const limit = deps.outcomesLimit ?? OUTCOMES_QUERY_LIMIT;
+  const candidates: Array<{ card: TaskCard; terminal: TaskCard['prTerminal']; endedAt: string;
+    cardTerminalAt: string | null; prTerminalAt: string | null; terminalKind: 'card' | 'pr'; countReason: string }> = [];
+  let undatedCards = 0;
+  let openCards = 0;
+  for (const card of Object.values(cards)) {
+    if (!card || typeof card.id !== 'string') continue;
+    const terminal = boundPrTerminal(card);
+    // 결과란 «끝난 카드»다 — 종결 상태이거나 PR 이 종결로 관측된 카드. 아직 도는 카드는 창 대상이 아니다(따로 센다).
+    if (!OUTCOME_TERMINAL_STATUSES.has(card.status) && terminal === undefined) { openCards++; continue; }
+    const terminalHistory = outcomeTerminalHistoryLine(card);
+    const successfulStatus = card.status === 'done' || card.status === 'landed' || card.status === 'landed-by-hand';
+    const manualClosure = (card.status === 'done' || card.status === 'landed-by-hand')
+      && terminalHistory?.event === CLOSED_BY_HAND_EVENT;
+    const failedStatus = card.status === 'failed' || card.status === 'launch-failed';
+    const history = successfulStatus
+      ? (OUTCOME_SUCCESS_HISTORY_EVENTS.has(terminalHistory?.event ?? '') || manualClosure ? terminalHistory : undefined)
+      : failedStatus && (terminalHistory?.event === 'failed' || terminalHistory?.event === 'launch-failed')
+        ? terminalHistory : undefined;
+    const validAt = (at: string | undefined): string | null => at && Number.isFinite(Date.parse(at)) ? at : null;
+    const cardTerminalAt = validAt(history?.at);
+    const prTerminalAt = validAt(terminal?.at);
+    if (cardTerminalAt === null && prTerminalAt === null) { undatedCards++; continue; }
+    const inWindow = (at: string | null): at is string => at !== null
+      && (window.sinceMs === undefined || Date.parse(at) >= window.sinceMs)
+      && (window.untilMs === undefined || Date.parse(at) <= window.untilMs);
+    if (inWindow(cardTerminalAt)) {
+      candidates.push({ card, terminal, endedAt: cardTerminalAt, cardTerminalAt, prTerminalAt,
+        terminalKind: 'card', countReason: `card:${card.status}:${history!.event}@${cardTerminalAt}` });
+    }
+    if (inWindow(prTerminalAt)) {
+      candidates.push({ card, terminal, endedAt: prTerminalAt, cardTerminalAt, prTerminalAt,
+        terminalKind: 'pr', countReason: `pr:${terminal!.state}:#${terminal!.pr}@${prTerminalAt}` });
+    }
+  }
+  const overlap = new Map<string, Set<'card' | 'pr'>>();
+  for (const item of candidates) {
+    const kinds = overlap.get(item.card.id) ?? new Set<'card' | 'pr'>();
+    kinds.add(item.terminalKind);
+    overlap.set(item.card.id, kinds);
+  }
+  const overlapCardIds = [...overlap].filter(([, kinds]) => kinds.size === 2).map(([id]) => id).sort();
+  const visible = window.terminalKind ? candidates.filter((item) => item.terminalKind === window.terminalKind) : candidates;
+  visible.sort((a, b) => Date.parse(b.endedAt) - Date.parse(a.endedAt) || a.card.id.localeCompare(b.card.id)
+    || a.terminalKind.localeCompare(b.terminalKind));
+  const limitReached = visible.length > limit;
+  const selected = limitReached ? visible.slice(0, limit) : visible;
+  const stateRoot = dirname(statePath);
+  const localLedgerDirs = implementLedgerDirectories(statePath, false);
+  const runExits = readRunExits(stateRoot);
+  let childLedgerObserved = false;
+  let reasonObserved = false;
+  const rows = selected.map(({ card, terminal, endedAt, cardTerminalAt, prTerminalAt, terminalKind, countReason }): TaskOutcomeRow => {
+    const number = cardPrNumber(card);
+    // 종결 사유 원문 — 부모 runId → pod-child-run 매핑 → 자식 원장 꼬리. 원장을 못 찾으면 null.
+    const remoteDir = card.parentHost ? remoteLedgerMirrorDir(stateRoot, card.parentHost.host) : null;
+    // 원격 부모는 해당 호스트 거울에서만 결속한다. 로컬 동명 런을 원격 증거로 오인하지 않는다.
+    const ledgerDirs = remoteDir ? [remoteDir] : localLedgerDirs;
+    const ledgerDir = card.runId ? ledgerDirs.find((dir) => loadRunLedgerSync(card.runId!, dir) !== null) : undefined;
+    const mappedChildRunId = ledgerDir ? outcomeChildRunId(card, ledgerDir) : null;
+    const childBindingMismatch = card.runChildId && mappedChildRunId && card.runChildId !== mappedChildRunId;
+    const childRunId = childBindingMismatch ? null : mappedChildRunId;
+    const childEntries = childRunId === null || !ledgerDir ? null : loadRunLedgerSync(childRunId, ledgerDir);
+    if (childEntries !== null) childLedgerObserved = true;
+    const reasonTail = childEntries === null ? null : outcomeChildLedgerReason(childEntries);
+    const cardReason = terminalKind === 'card' && (card.status === 'failed' || card.status === 'launch-failed') ? reasonTail : null;
+    if (cardReason !== null) reasonObserved = true;
+    const exit = card.runId ? runExits.find((row) => row.runId === card.runId) : undefined;
+    const lastLines = exit?.lastLines?.length ? exit.lastLines : null;
+    return {
+      cell: card.checklistId ?? null,
+      card: card.id,
+      runId: card.runId ?? null,
+      childRunId,
+      host: card.parentHost?.host ?? null,
+      endedAt,
+      cardTerminalAt,
+      prTerminalAt,
+      ghTerminalAt: null,
+      ghTerminalMissing: 'not-stored-in-card',
+      terminalKind,
+      countReason,
+      cardStatus: card.status,
+      pr: number === undefined ? null : { number, state: terminal?.state ?? null },
+      reason: cardReason?.reason ?? null,
+      reasonFrom: cardReason?.reasonFrom ?? null,
+      evidence: {
+        childLedger: reasonTail ? { event: reasonTail.reasonFrom.slice('child-ledger:'.length), error: reasonTail.reason } : null,
+        childLedgerMissing: reasonTail ? null : !card.runId ? 'run-id-missing'
+          : remoteDir && !existsSync(remoteDir) ? 'remote-ledger-mirror-missing'
+            : !ledgerDir ? (remoteDir ? 'remote-parent-ledger-missing' : 'parent-ledger-missing')
+          : childBindingMismatch ? 'parent-child-binding-mismatch'
+            : childRunId === null ? 'parent-child-binding-missing'
+            : childEntries === null ? (remoteDir ? 'remote-child-ledger-missing' : 'child-ledger-missing') : 'child-ledger-error-tail-missing',
+        lastLines,
+        lastLinesMissing: lastLines ? null : !card.runId ? 'run-id-missing'
+          : !exit ? 'run-exit-missing' : 'run-exit-last-lines-missing',
+      },
+    };
+  });
+  const reasonTally = new Map<string, number>();
+  for (const row of rows) {
+    if (row.reason === null) continue;
+    reasonTally.set(row.reason, (reasonTally.get(row.reason) ?? 0) + 1);
+  }
+  const reasons = [...reasonTally.entries()]
+    .map(([reason, count]) => ({ reason, count }))
+    .sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason));
+  const failedCardRows = rows.filter((row) => row.terminalKind === 'card'
+    && (row.cardStatus === 'failed' || row.cardStatus === 'launch-failed'));
+  const missingReason = failedCardRows.filter((row) => row.reason === null).length;
+  const warnings = [
+    limitReached ? `사건 조회 상한 ${limit} 도달 — 창 안 ${visible.length}행 중 ${rows.length}행만 셌다(집계도 이 행들만 센다)` : null,
+    missingReason > 0 ? `실패 카드 종결 사유 원문 없음 — ${missingReason}/${failedCardRows.length}행(증거 부재 이유는 행별 evidence 참조)` : null,
+    undatedCards > 0 ? `종결 시각 미보존 ${undatedCards}장 — 기간 귀속 불가(창 밖 카드 포함)` : null,
+  ].filter((line): line is string => line !== null);
+  return {
+    rows,
+    aggregate: { cards: new Set(rows.map((row) => row.card)).size,
+      cardTerminals: rows.filter((row) => row.terminalKind === 'card').length,
+      prTerminals: rows.filter((row) => row.terminalKind === 'pr').length,
+      failedCardTerminals: failedCardRows.length, reasons, missingReason },
+    limitReached,
+    stopReason: limitReached ? 'page-limit' : null,
+    childLedgerObserved,
+    reasonObserved,
+    undatedCards,
+    undatedPeriodAttribution: 'unknown',
+    overlapCardIds,
+    openCards,
+    ...(warnings.length ? { warning: warnings.join(' · ') } : {}),
+  };
+}
+
+type DoctorTruth = true | false | 'unknown';
+type DoctorCondition = { value: DoctorTruth; source: string; detail: string };
+type DoctorPr = { number: number; state: string | null; draft: boolean | null; head: string | null; changedFiles: number | null };
+
+export interface TaskDoctorReport {
+  card: string;
+  cell: string | null;
+  version: string;
+  runId: string | null;
+  childRunId: string | null;
+  host: string | null;
+  head: string | null;
+  terminalReason: string | null;
+  terminalReasonSource: string | null;
+  lastGate: { passed: boolean | null; status: string | null; head: string | null; at: string | null; source: string } | null;
+  pr: DoctorPr | null;
+  conditions: { currentYellowUnheldNoOtherPr: DoctorCondition; noPreservedImplementation: DoctorCondition;
+    environmentFailure: DoctorCondition; failureRoundsBelowTwo: DoctorCondition };
+  unknownSources: string[];
+  nextAction: 'relaunch' | 'harvest' | 'reauthor' | 'human';
+}
+
+function doctorCondition(value: DoctorTruth, source: string, detail: string): DoctorCondition { return { value, source, detail }; }
+function doctorObject(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null;
+}
+function doctorString(value: unknown): string | null { return typeof value === 'string' && value.trim() ? value : null; }
+function doctorTerminal(entry: import('../self-implement/run-ledger.js').RunLedgerEntry): boolean {
+  if (entry.event === 'stop') return true;
+  if (entry.event === 'run-status') return ['failed', 'completed', 'cancelled', 'parked'].includes(String(entry.data.runStatus));
+  return entry.event === 'terminal' && (typeof entry.data.ok === 'boolean' || typeof entry.data.terminal === 'string');
+}
+function doctorTerminalFailed(entry: import('../self-implement/run-ledger.js').RunLedgerEntry): boolean {
+  if (entry.event === 'stop') return true;
+  if (entry.event === 'run-status') return entry.data.runStatus === 'failed';
+  return entry.data.ok === false || ['failed', 'aborted', 'gate-failed', 'review-blocked', 'timed-out'].includes(String(entry.data.terminal));
+}
+function defaultDoctorLedger(runId: string, statePath: string): import('../self-implement/run-ledger.js').RunLedgerEntry[] | null {
+  let found: import('../self-implement/run-ledger.js').RunLedgerEntry[] | null = null;
+  for (const dir of implementLedgerDirectories(statePath, false)) {
+    const loaded = loadRunLedgerWithMetadata(runId, dir);
+    if (!loaded) continue;
+    if (loaded.skippedTrailingBytes) throw new Error(`incomplete run ledger: ${runId}`);
+    if (found && JSON.stringify(found) !== JSON.stringify(loaded.entries)) throw new Error(`conflicting run ledgers: ${runId}`);
+    found = loaded.entries;
+  }
+  return found;
+}
+
+/** Read-only relaunch preflight. Each decision names its evidence, and a missing adapter remains unknown. */
+export function readTaskDoctor(target: string, opts: { traffic?: string } = {}, deps: TasksCliDeps = {}): TaskDoctorReport {
+  const statePath = deps.taskStatePath ?? taskStatePathDefault();
+  const state = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath);
+  const cards = Object.values(state.tasks ?? {});
+  const matches = cards.filter((item) => item?.id === target || item?.runId === target || item?.runChildId === target);
+  if (matches.length !== 1) throw new Error(matches.length ? `카드 결속 모호: ${target}` : `카드·런 없음: ${target}`);
+  const card = matches[0]!;
+  const version = (deps.doctorVersion ?? checklistDevVersion)();
+  const cell = card.checklistId ?? null;
+  const run = deps.doctorRun ?? ((command: string, args: string[]) => spawnSync(command, args,
+    { cwd: process.cwd(), encoding: 'utf8', timeout: 20_000, maxBuffer: 4 * 1024 * 1024 }));
+
+  let yellow: DoctorCondition = doctorCondition('unknown', 'checklist', '카드의 칸을 모른다');
+  if (cell) {
+    try {
+      const snapshot = (deps.doctorChecklist ?? listChecklist)(version);
+      const item = snapshot.items.find((entry) => entry.id === cell);
+      const versionMatches = !card.checklistVersion || card.checklistVersion === version;
+      yellow = doctorCondition(item ? item.status === 'yellow' && versionMatches : false, `checklist:${version}:${cell}`,
+        item ? `status=${item.status}${versionMatches ? '' : `, cardVersion=${card.checklistVersion}`}` : '현재 판에 칸 없음');
+    } catch { yellow = doctorCondition('unknown', `checklist:${version}:${cell}`, '체크리스트 조회 실패'); }
+  }
+  let unheld: DoctorCondition = doctorCondition('unknown', 'traffic', 'traffic 경로 없음 (--traffic 필요)');
+  if (opts.traffic) {
+    try {
+      const traffic = doctorObject(JSON.parse(readFileSync(opts.traffic, 'utf8')));
+      const holds = traffic?.hold;
+      unheld = Array.isArray(holds) && holds.every((id) => typeof id === 'string') && cell
+        ? doctorCondition(!holds.includes(cell), `traffic:${opts.traffic}`, holds.includes(cell) ? 'hold 활성' : 'hold 없음')
+        : doctorCondition('unknown', `traffic:${opts.traffic}`, 'hold 배열 또는 칸 결속 불명');
+    } catch { unheld = doctorCondition('unknown', `traffic:${opts.traffic}`, 'traffic 읽기 실패'); }
+  }
+  let noOtherPr: DoctorCondition = doctorCondition('unknown', 'gh:open-pr-list', '열린 PR 조회 실패');
+  try {
+    const result = run('gh', ['pr', 'list', '--state', 'open', '--limit', '500', '--json', 'number,body']);
+    if (result.status === 0) {
+      const rows: unknown = JSON.parse(result.stdout);
+      if (Array.isArray(rows) && rows.length < 500 && rows.every((row) =>
+        Number.isSafeInteger(doctorObject(row)?.number) && typeof doctorObject(row)?.body === 'string')) {
+        const conflicts = rows.filter((row) => {
+          const pr = doctorObject(row)!;
+          return cellIdFromBody(pr.body as string) === cell && pr.number !== cardPrNumber(card);
+        }).map((row) => doctorObject(row)!.number as number);
+        noOtherPr = doctorCondition(conflicts.length === 0, 'gh:open-pr-list:cell-marker',
+          conflicts.length ? `다른 열린 PR: ${conflicts.map((id) => `#${id}`).join(',')}` : '같은 칸의 다른 열린 PR 없음');
+      } else noOtherPr = doctorCondition('unknown', 'gh:open-pr-list', 'PR 목록 형식 불명 또는 500건 상한');
+    }
+  } catch { /* unknown stays explicit */ }
+  const firstParts = [yellow, unheld, noOtherPr];
+  const firstValue: DoctorTruth = firstParts.some((part) => part.value === 'unknown') ? 'unknown'
+    : firstParts.every((part) => part.value === true);
+  const currentYellowUnheldNoOtherPr = doctorCondition(firstValue,
+    firstParts.map((part) => part.source).join(' + '), firstParts.map((part) => part.detail).join('; '));
+
+  const prNumber = cardPrNumber(card);
+  let pr: DoctorPr | null = prNumber === undefined ? null
+    : { number: prNumber, state: null, draft: null, head: null, changedFiles: null };
+  let prFiles: Array<{ path: string; additions: number; deletions: number }> | null = null;
+  let prSource = 'gh:bound-pr';
+  if (prNumber !== undefined) {
+    try {
+      const result = run('gh', ['pr', 'view', String(prNumber), '--json', 'number,state,isDraft,headRefOid,changedFiles,files']);
+      if (result.status === 0) {
+        const view = doctorObject(JSON.parse(result.stdout));
+        const files = view?.files;
+        const changedFiles = view?.changedFiles;
+        if (view?.number === prNumber && typeof view.state === 'string' && typeof view.isDraft === 'boolean'
+          && Number.isSafeInteger(changedFiles) && (changedFiles as number) >= 0 && Array.isArray(files)
+          && files.every((file) => typeof doctorObject(file)?.path === 'string'
+            && Number.isSafeInteger(doctorObject(file)?.additions) && Number.isSafeInteger(doctorObject(file)?.deletions))) {
+          pr = { number: prNumber, state: view.state, draft: view.isDraft,
+            head: doctorString(view.headRefOid), changedFiles: changedFiles as number };
+          prFiles = files.map((file) => doctorObject(file) as { path: string; additions: number; deletions: number });
+        } else prSource = 'gh:bound-pr:malformed';
+      } else prSource = 'gh:bound-pr:unreadable';
+    } catch { prSource = 'gh:bound-pr:unreadable'; }
+  } else prSource = 'card:pr-unbound';
+  let noPreservedImplementation = doctorCondition('unknown', prSource, 'PR diff를 못 읽었다');
+  if (pr && prFiles && pr.changedFiles === prFiles.length) {
+    const docsOnly = prFiles.length > 0 && prFiles.every((file) => /(?:^|\/)[^/]+\.md$/i.test(file.path));
+    const empty = pr.changedFiles === 0;
+    noPreservedImplementation = doctorCondition(empty || docsOnly, `gh:pr-${pr.number}:files`,
+      empty ? 'diff 0' : docsOnly ? 'docs-only diff' : '보존할 구현 diff 있음');
+  } else if (pr && prFiles) noPreservedImplementation = doctorCondition('unknown', `gh:pr-${pr.number}:files`, 'changedFiles와 파일 목록 수 불일치');
+
+  const ledgerId = card.runChildId;
+  let entries: import('../self-implement/run-ledger.js').RunLedgerEntry[] | null = null;
+  let ledgerSource = ledgerId ? `run-ledger:${ledgerId}` : 'card:child-run-unbound';
+  if (ledgerId) {
+    try { entries = (deps.doctorLedger ?? defaultDoctorLedger)(ledgerId, statePath); }
+    catch { ledgerSource += ':unreadable'; }
+  }
+  let parentEntries: import('../self-implement/run-ledger.js').RunLedgerEntry[] | null = null;
+  let parentLedgerSource = card.runId ? `run-ledger:${card.runId}` : 'card:parent-run-unbound';
+  if (card.runId) {
+    try { parentEntries = (deps.doctorLedger ?? defaultDoctorLedger)(card.runId, statePath); }
+    catch { parentLedgerSource += ':unreadable'; }
+  }
+  const terminal = entries?.slice().reverse().find(doctorTerminal);
+  const terminalData = doctorObject(terminal?.data);
+  const parentTerminal = parentEntries?.slice().reverse().find(doctorTerminal);
+  const parentData = doctorObject(parentTerminal?.data);
+  const parentChildEvidence = doctorObject(parentData?.childEvidence);
+  const prFailure = doctorObject(terminalData?.prFailure);
+  const childTerminalReason = doctorString(terminalData?.terminationReason) ?? doctorString(terminalData?.cause)
+    ?? doctorString(terminalData?.reason) ?? doctorString(terminalData?.error)
+    ?? doctorString(prFailure?.errorTail);
+  const childReasonSource = childTerminalReason ? `${ledgerSource}:${terminal?.event}` : null;
+  const parentTerminalReason = doctorString(parentData?.terminationReason) ?? doctorString(parentData?.cause)
+    ?? doctorString(parentData?.reason) ?? doctorString(parentChildEvidence?.terminationReason)
+    ?? doctorString(parentChildEvidence?.error) ?? null;
+  const cardTerminal = card.history?.slice().reverse().find((item) =>
+    (item.event === 'failed' || item.event === 'launch-failed') && (!item.runId || item.runId === card.runId));
+  const terminalReason = childTerminalReason ?? parentTerminalReason ?? doctorString(cardTerminal?.detail);
+  const reauthorPattern = /scope[- ]escape|UNCONVERGEABLE|goal[- ]revision[- ]required/i;
+  const environmentPattern = /worktree add.{0,100}(?:timed? ?out|timeout)|(?:timed? ?out|timeout).{0,100}worktree add|model catalog.{0,100}unknown|unknown.{0,100}model catalog|stale pod image|pod image.{0,100}stale/i;
+  const childEvidence = doctorObject(terminalData?.childEvidence);
+  const structuredReauthorSource = terminalData?.scopeEscape === true ? `${ledgerSource}:${terminal?.event}:scopeEscape`
+    : childEvidence?.scopeEscape === true ? `${ledgerSource}:${terminal?.event}:childEvidence.scopeEscape`
+      : reauthorPattern.test(doctorString(terminalData?.supervisorVerdict) ?? '')
+        ? `${ledgerSource}:${terminal?.event}:supervisorVerdict`
+        : parentData?.scopeEscape === true ? `${parentLedgerSource}:${parentTerminal?.event}:scopeEscape`
+          : parentChildEvidence?.scopeEscape === true ? `${parentLedgerSource}:${parentTerminal?.event}:childEvidence.scopeEscape`
+            : reauthorPattern.test(doctorString(parentChildEvidence?.supervisorVerdict) ?? '')
+              ? `${parentLedgerSource}:${parentTerminal?.event}:childEvidence.supervisorVerdict` : null;
+  const structuredReauthor = structuredReauthorSource !== null;
+  const scopeSignals = [terminalData?.scopeEscape, childEvidence?.scopeEscape,
+    parentData?.scopeEscape, parentChildEvidence?.scopeEscape].filter((value): value is boolean => typeof value === 'boolean');
+  const scopeSignalConflict = scopeSignals.includes(true) && scopeSignals.includes(false);
+  let environmentFailure = doctorCondition('unknown', ledgerSource, '자식 종결 원장 또는 원문 없음');
+  if (!terminal) environmentFailure = doctorCondition('unknown', ledgerSource, '자식 종결 원장 결손');
+  else if (!parentTerminal) environmentFailure = doctorCondition('unknown', parentLedgerSource,
+    '부모 종결 원장 결손·충돌 — scopeEscape 재확인 불가');
+  else if (!doctorTerminalFailed(parentTerminal)) environmentFailure = doctorCondition('unknown',
+    `${parentLedgerSource}:${parentTerminal.event}`, '부모 런이 실패로 종결되지 않음');
+  else if (childTerminalReason && parentTerminalReason
+    && !parentTerminalReason.includes(childTerminalReason) && !childTerminalReason.includes(parentTerminalReason)) {
+    environmentFailure = doctorCondition('unknown', `${ledgerSource} + ${parentLedgerSource}`,
+      '부모·자식 종결 사유 불일치');
+  } else if (scopeSignalConflict) environmentFailure = doctorCondition('unknown', `${ledgerSource} + ${parentLedgerSource}`,
+    '부모·자식 scopeEscape 신호 불일치');
+  else if (structuredReauthor) environmentFailure = doctorCondition(false, structuredReauthorSource!, '구조화된 재저작 신호');
+  else if (childTerminalReason) environmentFailure = doctorCondition(
+    !doctorTerminalFailed(terminal) || reauthorPattern.test(childTerminalReason) ? false : environmentPattern.test(childTerminalReason),
+    childReasonSource ?? ledgerSource,
+    !doctorTerminalFailed(terminal) ? '자식 런이 실패로 종결되지 않음' : reauthorPattern.test(childTerminalReason)
+      ? '골 재저작 필요' : environmentPattern.test(childTerminalReason) ? '허용된 환경 실패' : '허용된 환경 실패 아님');
+  if (card.status !== 'failed' && card.status !== 'launch-failed') environmentFailure = doctorCondition(false,
+    `card:${card.id}:status`, `현재 카드 status=${card.status} — 재발사 대상 실패 카드 아님`);
+  if (pr?.state === 'MERGED') environmentFailure = doctorCondition(false,
+    `gh:pr-${pr.number}:state`, '결속 PR이 이미 병합됨');
+
+  const roundCards = cell ? cards.filter((item) => item?.checklistId === cell) : [];
+  const knownFailureRuns = new Set<string>();
+  let unboundFailureCards = 0;
+  let ambiguousRounds = false;
+  for (const item of roundCards) {
+    const failures = (item.history ?? []).filter((entry) => entry.event === 'failed' || entry.event === 'launch-failed');
+    const itemRuns = new Set(failures.map((entry) => doctorString(entry.runId)).filter((id): id is string => id !== null));
+    const statusFailed = item.status === 'failed' || item.status === 'launch-failed';
+    if (statusFailed && item.runId) itemRuns.add(item.runId);
+    for (const id of itemRuns) knownFailureRuns.add(id);
+    const unbound = failures.some((entry) => !doctorString(entry.runId));
+    if (unbound && itemRuns.size) ambiguousRounds = true;
+    else if (!itemRuns.size && (unbound || statusFailed)) unboundFailureCards++;
+  }
+  const failureRounds = knownFailureRuns.size + unboundFailureCards;
+  const failureRoundsBelowTwo = doctorCondition(cell && !ambiguousRounds ? failureRounds < 2 : 'unknown',
+    'card-status+history:same-cell-failures', !cell ? '같은 칸 실패 이력 불명'
+      : ambiguousRounds ? 'runId 없는 실패 사건과 결속된 런이 섞여 라운드 중복 불명' : `실패 라운드 ${failureRounds}`);
+  const lastRegate = card.regates?.at(-1);
+  const childGate = entries?.slice().reverse().find((entry) => entry.event === 'gated');
+  const useRegate = lastRegate && (!childGate || Date.parse(lastRegate.at) >= Date.parse(childGate.timestamp ?? ''));
+  const lastGate = useRegate && lastRegate ? { passed: lastRegate.passed ?? null, status: lastRegate.status ?? null,
+    head: lastRegate.head, at: lastRegate.at, source: 'card:regates' }
+    : childGate ? { passed: typeof childGate.data.passed === 'boolean' ? childGate.data.passed : null,
+      status: childGate.data.gateExecuted === false ? 'skipped' : 'executed',
+      head: doctorString(childGate.data.head),
+      at: childGate.timestamp ?? null, source: `${ledgerSource}:gated` } : null;
+  const conditions = { currentYellowUnheldNoOtherPr, noPreservedImplementation, environmentFailure, failureRoundsBelowTwo };
+  const unknownSources = Object.entries(conditions).filter(([, part]) => part.value === 'unknown')
+    .map(([name, part]) => `${name}:${part.source}`);
+  const nextAction = unknownSources.length ? 'human'
+    : structuredReauthor || (terminalReason && reauthorPattern.test(terminalReason)) || failureRoundsBelowTwo.value === false
+      ? 'reauthor' : noPreservedImplementation.value === false ? 'harvest'
+        : Object.values(conditions).every((part) => part.value === true) ? 'relaunch' : 'human';
+  return { card: card.id, cell, version, runId: card.runId ?? null, childRunId: card.runChildId ?? null,
+    host: card.parentHost?.host ?? null, head: pr?.head ?? lastRegate?.head ?? card.adoptedPr?.head ?? card.prTerminal?.head ?? null,
+    terminalReason, terminalReasonSource: childReasonSource
+      ?? (parentTerminalReason && parentTerminal ? `run-ledger:${card.runId}:${parentTerminal.event}`
+        : cardTerminal ? `card-history:${cardTerminal.event}` : null),
+    lastGate, pr, conditions, unknownSources, nextAction };
+}
+
+/** MODEL-SIZE-OUTCOME-MEASURE — `tasks outcomes --by` 가 아는 집계 축. */
+export const TASK_OUTCOME_BY_DIMENSIONS = ['model', 'size'] as const;
+
+/** 못 읽은 값의 이름 — 0 이나 빈 문자열로 지어내지 않는다. */
+export const TASK_OUTCOME_UNKNOWN = 'unknown';
+
+/** 카드 하나의 결과 — PR 착지 · 범위 이탈 · 수렴 실패 · 결과 줄 없음. */
+export type TaskOutcomeModelSizeResult = 'landed' | 'scope-escape' | 'convergence-failure' | 'no-result-line';
+
+/** 카드 하나의 측정 줄 — 자식 모델 · 등급 · 조각 크기(대상 경로 수 · 바꿀 동작 수) · 결과. */
+export interface TaskOutcomeModelSizeCard {
+  card: string;
+  /** `provider/model`(카드 childLlm) · 못 읽으면 `unknown`. */
+  model: string;
+  /** 디스패처 난이도(하|중|상|특) · 못 읽으면 `unknown`. */
+  tier: string;
+  size: { targetPaths: number | typeof TASK_OUTCOME_UNKNOWN; behaviors: number | typeof TASK_OUTCOME_UNKNOWN };
+  result: TaskOutcomeModelSizeResult;
+}
+
+/** 모델×크기 칸 하나 — 성공률 · 표본 수 · unknown 수. */
+export interface TaskOutcomeModelSizeCell {
+  model: string;
+  /** 크기 칸 이름(`paths=<n>·behaviors=<n>`) · 못 읽은 칸은 `unknown`. */
+  size: string;
+  samples: number;
+  landed: number;
+  /** landed / samples. */
+  successRate: number | null;
+  /** 이 칸에서 한 축이라도 못 읽은 카드 수. */
+  unknown: number;
+  results: Record<TaskOutcomeModelSizeResult, number>;
+}
+
+export interface TaskOutcomeModelSizeReport {
+  dimensions: readonly ['model', 'size'];
+  cells: TaskOutcomeModelSizeCell[];
+  cards: TaskOutcomeModelSizeCard[];
+  /** 축별 «못 읽음» 수 — 카드 합계가 아니라 축마다 센다(한 카드가 둘을 못 읽을 수 있다). */
+  unknown: { model: number; tier: number; size: number };
+  samples: number;
+  limitReached: boolean;
+}
+
+const OUTCOME_MODEL_SIZE_RESULTS: readonly TaskOutcomeModelSizeResult[] = ['landed', 'scope-escape', 'convergence-failure', 'no-result-line'];
+
+/** `--by` 인자 — 지금은 `model,size` 하나뿐이다(순서 무관 · 그 밖은 거부). */
+function parseOutcomeDimensions(value: string | undefined): readonly ['model', 'size'] | undefined {
+  if (value === undefined) return undefined;
+  const parts = [...new Set(value.split(',').map((part) => part.trim().toLowerCase()).filter(Boolean))];
+  if (parts.length !== TASK_OUTCOME_BY_DIMENSIONS.length || !TASK_OUTCOME_BY_DIMENSIONS.every((dimension) => parts.includes(dimension))) {
+    throw new Error(`--by 는 ${TASK_OUTCOME_BY_DIMENSIONS.join(',')} 다(모델×조각 크기): ${value}`);
+  }
+  return ['model', 'size'];
+}
+
+/** 카드 문면의 «바꿀 동작 수» — `바꿀` 선언 줄 ⊕ 그 아래 항목. 선언이 없으면 null(0 으로 지어내지 않는다). */
+function declaredChangeCount(text: string): number | null {
+  let declared = 0;
+  let explicitlyNone = false;
+  let insideChangeList = false;
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (/^바꿀(?:\s|:|것|동작)/.test(trimmed)) {
+      const at = trimmed.indexOf(':');
+      const inline = at < 0 ? '' : trimmed.slice(at + 1).trim();
+      if (/^바꿀\s*(?:것|동작)?\s*:?[\s]*(?:없음|없다)$/u.test(trimmed)) {
+        explicitlyNone = true;
+        insideChangeList = false;
+        continue;
+      }
+      // «바꿀 것: 하나» 처럼 한 줄에 적었으면 그 줄이 한 동작이고, 목록이 뒤따르지 않는다.
+      // «바꿀 것: 다음» 처럼 목록을 가리키는 선언은 그 줄이 동작이 아니고, 뒤따르는 목록을 센다.
+      insideChangeList = inline.length === 0 || /^다음[.!?]?$/.test(inline);
+      if (!insideChangeList) declared++;
+      continue;
+    }
+    if (!insideChangeList) continue;
+    if (/^[-*·]\s+\S/.test(trimmed)) { declared++; continue; }
+    if (trimmed.length > 0) insideChangeList = false;
+  }
+  return declared > 0 ? declared : explicitlyNone ? 0 : null;
+}
+
+/** 조각 크기 — 대상 경로 수(카드가 적은 목록) ⊕ 바꿀 동작 수(문면의 바꿀 선언). */
+function outcomeCardSize(card: TaskCard | undefined): TaskOutcomeModelSizeCard['size'] {
+  const targetPaths = Array.isArray(card?.targetPaths) ? card.targetPaths.length : TASK_OUTCOME_UNKNOWN;
+  const behaviors = card && typeof card.text === 'string' ? declaredChangeCount(card.text) ?? TASK_OUTCOME_UNKNOWN : TASK_OUTCOME_UNKNOWN;
+  return { targetPaths, behaviors };
+}
+
+function outcomeCardModel(card: TaskCard | undefined): string {
+  const llm = card?.childLlm;
+  if (!llm || typeof llm.provider !== 'string' || !llm.provider || typeof llm.model !== 'string' || !llm.model) return TASK_OUTCOME_UNKNOWN;
+  return `${llm.provider}/${llm.model}`;
+}
+
+function outcomeCardTier(card: TaskCard | undefined): string {
+  const tier = card?.tier;
+  return tier === '하' || tier === '중' || tier === '상' || tier === '특' ? tier : TASK_OUTCOME_UNKNOWN;
+}
+
+/**
+ * 결과 판정 — 카드 원장에 있는 사실만 쓴다(문면 추측 없음).
+ * ① 실제 실행·성공한 손 범위 자르기 hand-move(trim-scope)가 있으면 «범위 이탈» — 실행·성공 값이
+ *    없거나 false인 조정 · post-land partial(남은 작업)만으로는 범위 이탈이 아니다.
+ * ② PR MERGED 종결 증거(row.pr ⊕ 원장 prTerminal) 또는 손 착지 종결 기록(closed-by-hand)이 있으면 «PR 착지» —
+ *    카드 상태(landed·done)만으로는 착지로 단정하지 않는다.
+ * ③ 실패 종결 줄이 있으면 «수렴 실패» ④ 그 밖은 «결과 줄 없음».
+ */
+function classifyOutcomeResult(card: TaskCard | undefined, row: TaskOutcomeRow): TaskOutcomeModelSizeResult {
+  if ((card?.history ?? []).some((item) => item.event === HAND_MOVE_HISTORY_EVENT && item.kind === 'trim-scope'
+    && item.executed === true && item.ok === true)) return 'scope-escape';
+  const terminal = card ? boundPrTerminal(card) : undefined;
+  const landedByHand = row.cardStatus === 'landed-by-hand'
+    && (card?.history ?? []).some((item) => item.event === CLOSED_BY_HAND_EVENT);
+  if (row.pr?.state === 'MERGED' || terminal?.state === 'MERGED' || landedByHand) return 'landed';
+  const terminalLine = card ? outcomeTerminalHistoryLine(card) : undefined;
+  if (terminalLine?.event === 'failed' || terminalLine?.event === 'launch-failed') return 'convergence-failure';
+  if (row.cardStatus === 'failed' || row.cardStatus === 'launch-failed') return 'convergence-failure';
+  return 'no-result-line';
+}
+
+/**
+ * MODEL-SIZE-OUTCOME-MEASURE — `tasks outcomes --by model,size`(읽기 전용).
+ * 창 안에서 «끝난» 카드(readTaskOutcomes 와 같은 판정)를 모델×조각 크기 칸으로 묶어 성공률·표본 수·unknown 수를 낸다.
+ * `report` 와 `snapshot` 을 함께 주면 같은 원장 시점으로 창·크기·결과를 센다.
+ */
+export function readTaskOutcomeModelSize(
+  window: { sinceMs?: number; untilMs?: number } = {},
+  deps: Pick<TasksCliDeps, 'taskStatePath' | 'outcomesLimit'> = {},
+  report?: Omit<TaskOutcomeReport, 'since' | 'until'>,
+  snapshot?: Record<string, TaskCard>,
+): TaskOutcomeModelSizeReport {
+  const cards = snapshot ?? readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(deps.taskStatePath ?? taskStatePathDefault()).tasks ?? {};
+  const observed = report ?? readTaskOutcomes(window, deps, cards);
+  const unknown = { model: 0, tier: 0, size: 0 };
+  const cells = new Map<string, TaskOutcomeModelSizeCell>();
+  // 종단 사건 행은 카드·PR로 둘일 수 있어도 모델×크기 표본은 카드 한 장이다.
+  const seenCards = new Set<string>();
+  const rows = observed.rows.filter((row) => {
+    if (seenCards.has(row.card)) return false;
+    seenCards.add(row.card);
+    return true;
+  }).map((row): TaskOutcomeModelSizeCard => {
+    const card = cards[row.card];
+    const model = outcomeCardModel(card);
+    const tier = outcomeCardTier(card);
+    const size = outcomeCardSize(card);
+    const result = classifyOutcomeResult(card, row);
+    if (model === TASK_OUTCOME_UNKNOWN) unknown.model++;
+    if (tier === TASK_OUTCOME_UNKNOWN) unknown.tier++;
+    const sizeKey = size.targetPaths === TASK_OUTCOME_UNKNOWN || size.behaviors === TASK_OUTCOME_UNKNOWN
+      ? TASK_OUTCOME_UNKNOWN : `paths=${size.targetPaths}·behaviors=${size.behaviors}`;
+    if (sizeKey === TASK_OUTCOME_UNKNOWN) unknown.size++;
+    // Cell unknown belongs to its two grouping axes; tier is reported separately per card and in unknown.tier.
+    const unresolved = model === TASK_OUTCOME_UNKNOWN || sizeKey === TASK_OUTCOME_UNKNOWN;
+    const key = `${model}\u0000${sizeKey}`;
+    const cell = cells.get(key) ?? { model, size: sizeKey, samples: 0, landed: 0, successRate: null, unknown: 0,
+      results: Object.fromEntries(OUTCOME_MODEL_SIZE_RESULTS.map((name) => [name, 0])) as Record<TaskOutcomeModelSizeResult, number> };
+    cell.samples++;
+    if (result === 'landed') cell.landed++;
+    if (unresolved) cell.unknown++;
+    cell.results[result]++;
+    cell.successRate = cell.landed / cell.samples;
+    cells.set(key, cell);
+    return { card: row.card, model, tier, size, result };
+  });
+  return {
+    dimensions: ['model', 'size'],
+    cells: [...cells.values()].sort((a, b) => a.model.localeCompare(b.model) || a.size.localeCompare(b.size)),
+    cards: rows,
+    unknown,
+    samples: rows.length,
+    limitReached: observed.limitReached,
   };
-  const tasks = program.command('tasks').alias('task').description('TOX 태스크 조회 및 승인 · TASK-AGENT 과제 넘기기(hand)');
+}
+
+export function registerTasksCommands(program: Command, deps: TasksCliDeps = {}): void {
+  const ctx = createTasksCliContext(deps);
+  const { out, authenticate } = ctx;
+  const tasks = registerTasksRoot(program);
+
+  tasks.command('work-order').description('TASK-AGENT 작업 지시서')
+    .command('build')
+    .description('체크리스트 칸으로 작업 지시서를 만들어 파일에 쓴다')
+    .requiredOption('--checklist <cellId>', '체크리스트 칸 id')
+    .requiredOption('--version <version>', '체크리스트 판')
+    .requiredOption('--out <path>', '작업 지시서 출력 파일')
+    .action((opts: { checklist: string; version: string; out: string }) => {
+      try {
+        validateVersion(opts.version);
+        const item = (deps.workOrderChecklist ?? listChecklist)(opts.version).items.find((cell) => cell.id === opts.checklist);
+        if (!item) throw new Error(`체크리스트 칸 없음: ${opts.checklist}`);
+        const targets = /^대상 경로:[ \t]*(.*)$/.exec(item.title.split(/\r?\n/, 1)[0]!)?.[1]?.split(' · ').map((path) => path.trim()).filter(Boolean) ?? [];
+        const missing = targets.filter((path) => !existsSync(resolve(process.cwd(), path)));
+        const boundary = [
+          ...(targets.length ? [`대상 경로: ${targets.join(' · ')}`] : []),
+          ...(missing.length ? [`boundary.missing: ${missing.join(' · ')}`] : []),
+        ].join('\n');
+        const order = buildWorkOrder({
+          cellId: item.id,
+          version: opts.version,
+          priority: item.priority,
+          boundary: boundary || undefined,
+        });
+        mkdirSync(dirname(opts.out), { recursive: true });
+        writeFileSync(opts.out, `${JSON.stringify(order, null, 2)}\n`);
+        out(opts.out);
+      } catch (error) {
+        out(error instanceof Error ? error.message : '작업 지시서 작성 실패');
+        process.exitCode = 1;
+      }
+    });
 
   tasks.command('green-sweep')
     .description('병합된 과제 PR 과 칸 근거를 대조해 green/기록만/건너뜀을 미리 본다 (항상 dry-run)')
@@ -923,6 +1581,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           { cwd: process.cwd(), encoding: 'utf8', timeout: 20_000 }));
         const cards = Object.values(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(deps.taskStatePath ?? taskStatePathDefault()).tasks ?? {});
         let holds: Set<string> | null = null;
+        let holdDiagnostic: string | undefined;
         if (opts.traffic) {
           try {
             const traffic: unknown = JSON.parse(readFileSync(opts.traffic, 'utf8'));
@@ -930,8 +1589,13 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
               && Array.isArray((traffic as { hold?: unknown }).hold)
               && (traffic as { hold: unknown[] }).hold.every((id) => typeof id === 'string'))
               holds = new Set((traffic as { hold: string[] }).hold);
-          } catch { /* unknown is not an empty hold set */ }
-        }
+            else holdDiagnostic = `invalid-traffic-shape: ${opts.traffic} must contain hold: string[]`;
+          } catch (error) {
+            const code = error && typeof error === 'object' && 'code' in error && typeof error.code === 'string'
+              ? error.code : error instanceof SyntaxError ? 'invalid-json' : 'read-error';
+            holdDiagnostic = `${code}: ${opts.traffic}`;
+          }
+        } else holdDiagnostic = 'traffic-path-not-provided: pass --traffic ~/elanous-hq/seat-state/OP/traffic.json';
         const prCache = new Map<number, GreenSweepPr | null>();
         const ambiguousPrs = ambiguousGreenSweepPrs(snapshot.items, opts.version, cards);
         const origin = run('git', ['remote', 'get-url', 'origin']);
@@ -981,7 +1645,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
               return check.status === 0 ? true : check.status === 1 ? false : null;
             })();
             const decision = decideGreenSweep({ item, candidate, candidateCount: candidates.length,
-              pr: landingPr ?? null, ancestor, hold: holds === null ? null : holds.has(item.id), repositoryMatches,
+              pr: landingPr ?? null, ancestor, hold: holds === null ? null : holds.has(item.id), holdDiagnostic, repositoryMatches,
               ambiguousAcrossCells: ambiguousPrs.has(candidate.pr) });
             observeGreenSweep(decision);
             return decision;
@@ -993,8 +1657,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         if (opts.json) out(JSON.stringify({ dryRun: true, version: opts.version, counts, decisions }));
         else {
           out(`dry-run · ${opts.version} · 후보 ${counts.candidate} · green ${counts.green} · 기록만 ${counts.recordOnly} · 건너뜀 ${counts.skipped}`);
-          for (const d of decisions) out(`${d.verdict}\t${d.cell}\t#${d.pr}\t${d.mergeSha ?? '-'}\t${d.reason}\t${d.evidence}\tbefore=${JSON.stringify(d.existingEvidence)}\tafter=${JSON.stringify(d.plannedEvidence)}`);
-          if (holds === null) out('⚠ hold 원장을 읽지 못해 green 없이 기록만 판정');
+          for (const d of decisions) out(`${d.verdict}\t${d.cell}\t#${d.pr}\t${d.mergeSha ?? '-'}\t${d.reason}\t${d.evidence}\tbefore=${JSON.stringify(d.existingEvidence)}\tafter=${JSON.stringify(d.plannedEvidence)}\tholdDiagnostic=${d.holdDiagnostic ?? ''}`);
         }
       } catch (error) { out(`green-sweep 조회 실패: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
     });
@@ -1051,39 +1714,75 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       } catch (error) { out(error instanceof Error ? error.message : '커버 조회 실패'); process.exitCode = 1; }
     });
 
-  tasks.command('list')
-    .description('우선순위와 생성 시각 순으로 태스크 보기')
-    .option('--status <s>', '상태로 필터')
-    .option('--provider <p>', '외부 출처로 필터')
+  tasks.command('repair-outcomes')
+    .description('TA 카드 원장의 repair-result 집계(읽기 전용 · 기간 내 runId별 최신 결과, 기간 밖의 정정은 제외)')
+    .requiredOption('--since <iso>', '시작 시각(ISO, 포함)')
+    .option('--until <iso>', '끝 시각(ISO, 미포함 · 기본 현재)')
     .option('--json', 'JSON 출력')
-    .action(async (opts: { status?: string; provider?: string; json?: boolean }) => {
+    .action((opts: { since: string; until?: string; json?: boolean }) => {
       try {
-        activeToken = undefined;
-        const auth = authenticate();
-        const response = await request(deps, auth, '/v1/tasks');
-        if (!response.ok) throw httpError(response);
-        const body = await responseJson(response) as { tasks?: Array<Pick<TaskRow, 'id' | 'status'>> };
-        if (!Array.isArray(body?.tasks)) throw new Error('넥서스 태스크 목록 형식이 유효하지 않다');
-        const cards = body.tasks.filter((task) => !opts.status || task.status === opts.status);
-        // The list endpoint returns board cards without approval or provenance.
-        // Obtain those fields from the detail endpoint rather than displaying guesses.
-        const rows: TaskRow[] = [];
-        for (const card of cards) {
-          const detail = await request(deps, auth, `/v1/tasks/${encodeURIComponent(card.id)}`);
-          if (!detail.ok) throw httpError(detail);
-          const data = await responseJson(detail) as { task?: TaskRow };
-          if (!data?.task || data.task.id !== card.id) throw new Error('넥서스 태스크 상세 형식이 유효하지 않다');
-          if (!opts.provider || (data.task.generatedBy?.kind === 'external' && data.task.generatedBy.provider === opts.provider)) rows.push(data.task);
-        }
-        rows.sort(taskOrder);
-        if (opts.json) out(JSON.stringify(rows));
-        else {
-          out('id\t우선순위\t상태\t승인\t출처\t제목');
-          for (const row of rows) out(taskLine(row));
-        }
-      } catch (error) { handleError(error, out); }
+        const since = Date.parse(opts.since);
+        const until = opts.until === undefined ? Date.now() : Date.parse(opts.until);
+        const valid = (value: string) => /^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d\d:\d\d)$/.test(value);
+        if (!valid(opts.since) || !Number.isFinite(since) || opts.until !== undefined && (!valid(opts.until) || !Number.isFinite(until)) || since >= until)
+          throw new Error('--since/--until 는 순서가 맞는 ISO 시각이어야 한다');
+        const path = deps.taskStatePath ?? taskStatePathDefault();
+        if (!existsSync(path)) throw new Error('TA 카드 원장 없음 — 수리 0건으로 판정 불가');
+        const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(path).tasks;
+        if (!tasks || typeof tasks !== 'object' || Array.isArray(tasks)) throw new Error('TA 카드 원장 tasks 없음 — 수리 0건으로 판정 불가');
+        const report = measureRepairOutcomes(Object.values(tasks), { since, until });
+        if (opts.json) out(JSON.stringify(report));
+        else out(`수리 결과(카드 원장) ${report.applied} 적용 · ${report.failed} 실패 · ${report.unconfirmed} 미확정 · 카드 ${report.cards} · 결과 ${report.results} · runId 결손 ${report.missingRunId} · 미지 효과 ${report.unknownEffect} (기간 내 최신 결과 · 판단 로그 아님)`);
+      } catch (error) { out(error instanceof Error ? error.message : '수리 결과 원장 읽기 실패'); process.exitCode = 1; }
     });
 
+  tasks.command('outcomes')
+    .description('TA 카드·PR 종결 사건을 별도 분모로 센다 — 결속 자식 원장·종료 꼬리 원문과 부재 이유 포함(읽기 전용 · 사건 페이지 상한)')
+    .option('--since <기간>', '시작 시각 — ISO 또는 상대 기간(24h · 3d)')
+    .option('--until <기간>', '끝 시각 — ISO 또는 지금에서 뺀 상대 기간(24h · 3d)')
+    .option('--by <축>', '집계 축 — card-terminal | pr-terminal | model,size(읽기 전용)')
+    .option('--json', 'JSON 출력(기본값)')
+    .action((opts: { since?: string; until?: string; by?: string; json?: boolean }) => {
+      try {
+        const now = deps.outcomesNow?.() ?? Date.now();
+        const sinceMs = parseOutcomeTime(opts.since, '--since', now);
+        const untilMs = parseOutcomeTime(opts.until, '--until', now) ?? now;
+        // 창이 뒤집혔으면 아무것도 읽지 않는다(«빈 결과»로 속이지 않는다).
+        if (sinceMs !== undefined && untilMs !== undefined && sinceMs > untilMs) throw new Error('--since 가 --until 보다 늦다');
+        // 축 이름이 틀렸으면 원장도 읽지 않는다(지어낸 집계를 내지 않게).
+        const terminalKind = opts.by === 'card-terminal' ? 'card' : opts.by === 'pr-terminal' ? 'pr' : undefined;
+        const dimensions = terminalKind ? null : parseOutcomeDimensions(opts.by);
+        const snapshot = dimensions
+          ? readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(deps.taskStatePath ?? taskStatePathDefault()).tasks ?? {}
+          : undefined;
+        const observed = readTaskOutcomes({ sinceMs, untilMs, terminalKind }, deps, snapshot);
+        const report: TaskOutcomeReport = {
+          since: sinceMs === undefined ? null : new Date(sinceMs).toISOString(),
+          until: untilMs === undefined ? null : new Date(untilMs).toISOString(),
+          ...observed,
+        };
+        try { debug.log('task-agent', 'card-outcomes', { since: report.since, until: report.until, rows: report.rows.length,
+          missingReason: report.aggregate.missingReason, stopReason: report.stopReason,
+          childLedgerObserved: report.childLedgerObserved, reasonObserved: report.reasonObserved }); } catch { /* fail-soft */ }
+        // `--by model,size` 는 지금 JSON 에 «한 칸»을 더할 뿐 — 없으면 종전 JSON 그대로다.
+        out(JSON.stringify(dimensions ? { ...report, byModelSize: readTaskOutcomeModelSize({ sinceMs, untilMs }, deps, observed, snapshot) } : report));
+      } catch (error) {
+        out(JSON.stringify({ error: error instanceof Error ? error.message : '결과 조회 실패' }));
+        process.exitCode = 1;
+      }
+    });
+
+  tasks.command('doctor <cardIdOrRunId>')
+    .description('카드·런의 재발사 조건과 출처를 읽기 전용으로 판정한다')
+    .option('--traffic <path>', 'hold 원장 traffic.json — 생략·판독 실패 시 hold=unknown')
+    .option('--json', '한 줄 JSON 출력(기본값)')
+    .action((target: string, opts: { traffic?: string; json?: boolean }) => {
+      try { out(JSON.stringify(readTaskDoctor(target, { traffic: opts.traffic }, deps))); }
+      catch (error) { out(JSON.stringify({ error: error instanceof Error ? error.message : 'doctor 조회 실패' })); process.exitCode = 1; }
+    });
+
+  registerTaskListCommand(tasks, ctx);
+
   tasks.command('hand [text]')
     .description('TASK-AGENT 에 과제 한 줄을 넘긴다 — 카드를 적고 첫 수(harness say --substrate pod --merge-by-host)를 고른다 · 기본 shadow(발사 0) · `--mission` 이면 조각 카드 ⊕ 선후로 쪼개 선행 없는 조각만 넘긴다')
     .addOption(new Option('--seat <seat>', `과제 자리 (${TASK_SEATS.join('|')})`).choices([...TASK_SEATS]))
@@ -1099,10 +1798,12 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .option('--ta-land', 'TA-LIVE-LAND-2 — 호스트는 재게이트만 하고 병합은 TASK-AGENT 의 propose-land(`pr land --expected-head`)에 맡긴다 · 카드 taLand ⊕ 발사 env ELANOUS_TA_LAND=1 · taskAgent.liveMoves 에 propose-land 가 없으면 종전대로 호스트가 병합')
     .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('--role-llm <role=provider[/tier]>', 'TA 부모 역할 LLM(반복 가능 · planning|classify|audit|review만). 정확한 모델은 role={"provider":"openrouter","model":"openrouter/z-ai/glm-5.3"}; 자식 모델은 --child-llm', (value: string, previous: string[] = []) => [...previous, value])
     .addOption(new Option('--tier <level>', '디스패처 난이도(하|중|상|특) — 카드에 보존해 수리 모델 정책에 사용').choices(['하', '중', '상', '특']))
     .option('--tag <k=v>', 'RUN-IDENTITY-TAGS — 출생 신분을 덮는다(class|care|rights|protect 의 k=v · 반복: --tag class=gate --tag protect=true) — 카드 원장 identity 에 남는다', (value: string, previous: string[] | undefined) => [...(previous ?? []), value])
+    .option('--draft-claim <pr>', 'DRAFT-CLAIM-AUTO-2-FU — PR 를 관측(gh pr view)해 draftClaim 을 조립해 넘긴다 · 관측한 PR 머리에서 `elanous self review <pr> --json` 로 손 수확을 먼저 확정한다(확정 못 하면 claim 문면을 만들지 않는다) · claim 문면을 실제 PR 댓글로 게시(gh pr comment)한다 · 같은 PR 의 살아 있는 claim 기록(카드 draftClaim)이 있으면 거부한다')
     .option('--json', 'JSON 출력')
-    .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; tier?: TaskCard['tier']; tag?: 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; roleLlm?: string[]; tier?: TaskCard['tier']; tag?: string[]; draftClaim?: string; json?: boolean }) => {
       const suppliedText = text !== undefined;
       /** RUN-IDENTITY-TAGS — 칸을 찾은 판(출생 신분이 그 판의 칸 우선순위를 읽는다 · 개발 판 밖 칸도). */
       let birthBoardVersion: string | undefined;
@@ -1143,9 +1844,11 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           return aFuture ? compareVersions(a, b) : compareVersions(b, a);
         });
         const matches: Array<{ version: string; title: string }> = [];
+        // CLI-ENTRY-LAZY — board(전이 폐포가 가장 크다)는 칸을 찾을 때만 싣는다.
+        const packBoard = deps.releaseBoard ?? (await import('../task-agent/board.js')).releasePackBoard;
         for (const version of orderedVersions) {
           try {
-            const title = findTitle((deps.releaseBoard ?? releasePackBoard)(version));
+            const title = findTitle(packBoard(version));
             if (title !== undefined) matches.push({ version, title });
           } catch (error) {
             if (opts.version !== undefined) {
@@ -1182,13 +1885,14 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         process.exitCode = 1;
         return;
       }
-      if (opts.mission !== undefined && (opts.completion !== undefined || opts.project !== undefined || opts.goal !== undefined || opts.milestone !== undefined || opts.taLand === true || opts.childLlm !== undefined || opts.childLlmEffort !== undefined || opts.tier !== undefined || opts.tag !== undefined)) {
-        out('--completion/--project/--target/--goal/--milestone/--ta-land/--child-llm/--tier/--tag 는 과제 한 줄에만 준다 — --mission 조각은 종전처럼 code-pr 이다');
+      if (opts.mission !== undefined && (opts.completion !== undefined || opts.project !== undefined || opts.goal !== undefined || opts.milestone !== undefined || opts.taLand === true || opts.childLlm !== undefined || opts.childLlmEffort !== undefined || opts.roleLlm !== undefined || opts.tier !== undefined || opts.tag !== undefined)) {
+        out('--completion/--project/--target/--goal/--milestone/--ta-land/--child-llm/--role-llm/--tier/--tag 는 과제 한 줄에만 준다 — --mission 조각은 종전처럼 code-pr 이다');
         process.exitCode = 1;
         return;
       }
       if (opts.mission !== undefined) {
         try {
+          const { handMission } = await import('../task-agent/mission.js');
           const result = await handMission({
             text: opts.mission,
             ...(opts.seat ? { seat: opts.seat } : {}),
@@ -1227,7 +1931,61 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         if (resolved.kind === 'inlined') {
           try { debug.log('task-agent.hand', 'goal-file-inlined', { path: resolved.path, chars: resolved.chars, sha256: resolved.sha256 }); } catch { /* fail-soft */ }
         }
-        const result = await handTask({
+        if (opts.live && opts.checklist && birthBoardVersion) {
+          const origin = deps.handOriginRepo?.() ?? execFileSync('git', ['remote', 'get-url', 'origin'],
+            { cwd: process.cwd(), encoding: 'utf8' }).trim().replace(/\.git\/?$/, '');
+          const repo = origin.match(/^(?:git@github\.com:|https:\/\/github\.com\/|ssh:\/\/git@github\.com\/)?([^/\s]+\/[^/\s]+)\/?$/)?.[1];
+          if (!repo) throw new Error(`현재 worktree origin이 GitHub 저장소가 아니다: ${origin}`);
+          const run = deps.handOpenPrRun ?? ((command: string, args: string[]) => spawnSync(command, args,
+            { cwd: process.cwd(), encoding: 'utf8', timeout: 20_000, maxBuffer: 16 * 1024 * 1024 }));
+          const listed = run('gh', ['pr', 'list', '--repo', repo, '--state', 'open', '--limit', '500', '--json', 'number,body']);
+          if (listed.status !== 0) throw new Error(`같은 칸 OPEN PR 조회 실패 — 구현 발사 0: ${opts.checklist}`);
+          let rows: unknown;
+          try { rows = JSON.parse(listed.stdout); } catch { throw new Error(`OPEN PR 목록 해석 실패 — 구현 발사 0: ${opts.checklist}`); }
+          if (!Array.isArray(rows) || rows.length >= 500 || !rows.every((row) =>
+            Number.isSafeInteger(doctorObject(row)?.number) && typeof doctorObject(row)?.body === 'string')) {
+            throw new Error(`OPEN PR 목록 불완전 — 구현 발사 0: ${opts.checklist}`);
+          }
+          const openPrs = rows.filter((row) => cellIdFromBody(doctorObject(row)!.body as string) === opts.checklist)
+            .map((row) => doctorObject(row)!.number as number);
+          if (openPrs.length > 1) throw new Error(`같은 칸 OPEN PR 복수 — 구현 발사 0: ${opts.checklist} ${openPrs.map((pr) => `#${pr}`).join(', ')}`);
+          if (openPrs.length === 1) {
+            const number = openPrs[0]!;
+            const view = (deps.adoptPrView ?? ((pr: number, cwd: string) => JSON.parse(execFileSync('gh',
+              ['pr', 'view', String(pr), '--repo', repo, '--json', 'number,url,state,baseRefName,headRefOid'], { cwd, encoding: 'utf8' }))))(number, process.cwd());
+            if (view.number !== number) throw new Error(`조회 PR 번호가 다르다: 요청 #${number} · 응답 #${view.number}`);
+            const viewedRepo = typeof view.url === 'string'
+              ? view.url.match(/^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)\/?$/) : null;
+            if (view.state !== 'OPEN' || view.baseRefName !== 'main' || !/^[a-f0-9]{40}$/i.test(view.headRefOid)
+              || viewedRepo?.[1]?.toLowerCase() !== repo.toLowerCase() || Number(viewedRepo?.[2]) !== number) {
+              throw new Error(`OPEN/main PR 신원 불일치: #${number} — 구현 발사 0`);
+            }
+            const statePath = deps.taskStatePath ?? taskStatePathDefault();
+            const boundCards = Object.values(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath).tasks ?? {})
+              .filter((card) => card.checklistId === opts.checklist && cardPrNumber(card) === number);
+            if (boundCards.length) {
+              const bound = boundCards.length === 1 ? boundCards[0] : undefined;
+              const same = bound?.status === 'launched' && bound.taLand === true
+                && typeof bound.pr === 'object' && bound.pr.url === view.url
+                && (!bound.checklistVersion || bound.checklistVersion === birthBoardVersion);
+              if (!same) throw new Error(`같은 칸 OPEN PR #${number}에 기존 카드 ${boundCards.map((card) => card.id).join(', ')}가 있다 — 구현 발사 0; tasks adopt-pr ${number} --card <카드> --version ${birthBoardVersion} 확인`);
+              if (opts.json) out(JSON.stringify({ card: bound.id, pr: number, head: view.headRefOid, launched: false, next: `tasks rejudge ${bound.id}` }));
+              else out(`${bound.id}\tPR #${number} already-bound\t구현 발사 0 · 다음: tasks rejudge ${bound.id}`);
+              return;
+            }
+            const { adoptExistingPr } = await import('../task-agent/adopt-pr.js');
+            const current = (deps.adoptChecklist ?? listChecklist)(birthBoardVersion).items.find((item) => item.id === opts.checklist);
+            if (!current || current.status === 'green' || current.status === 'done') throw new Error(`입양할 미완 칸 없음: ${birthBoardVersion}/${opts.checklist}`);
+            const adopted = adoptExistingPr({ pr: view, repo, statePath,
+              checklist: { version: birthBoardVersion, id: current.id, title: current.title, status: current.status },
+              checklistAtWrite: () => (deps.adoptChecklist ?? listChecklist)(birthBoardVersion).items.find((item) => item.id === opts.checklist) });
+            try { debug.log('task-agent.hand', 'open-pr-adopted', { card: adopted.card.id, pr: number, head: view.headRefOid, launched: false }); } catch { /* fail-soft */ }
+            if (opts.json) out(JSON.stringify({ card: adopted.card.id, pr: number, head: view.headRefOid, launched: false, next: `tasks rejudge ${adopted.card.id}` }));
+            else out(`${adopted.card.id}\tPR #${number} adopted\t구현 발사 0 · 다음: tasks rejudge ${adopted.card.id}`);
+            return;
+          }
+        }
+        const handOpts = {
           text: resolved.text,
           ...(opts.project !== undefined && opts.target !== undefined ? { project: { id: opts.project, target: opts.target } } : {}),
           ...(opts.goal !== undefined ? { goal: opts.goal } : {}),
@@ -1236,18 +1994,55 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           ...(opts.checklist ? { checklistId: opts.checklist } : {}),
           ...(opts.completion ? { completion: opts.completion } : {}),
           live: opts.live === true,
+          preflightGoalDoneBoundary: opts.live === true && deps.taskLauncher === undefined,
           ...(opts.taLand === true ? { taLand: true } : {}),
           ...(opts.childLlm !== undefined ? { childLlm: opts.childLlm } : {}),
           ...(opts.childLlmEffort !== undefined ? { childLlmEffort: opts.childLlmEffort } : {}),
+          ...(opts.roleLlm?.length ? { parentRoleLlm: opts.roleLlm } : {}),
           ...(opts.tier !== undefined ? { tier: opts.tier } : {}),
           ...(opts.tag !== undefined ? { tags: opts.tag } : {}),
           ...(birthBoardVersion !== undefined ? { checklistVersion: birthBoardVersion } : {}),
           ...(deps.taskStatePath ? { statePath: deps.taskStatePath } : {}),
           ...(deps.taskCompositionRoot ? { compositionRoot: deps.taskCompositionRoot } : {}),
           launcher: deps.taskLauncher ?? defaultTaskLauncher,
-        });
+        };
+        // DRAFT-CLAIM-AUTO-2-FU — 생산 배선: `--draft-claim <pr>` 로 관측·게시·수확 리뷰 포트를 끼워 draftClaim(⊕ 손 수확)을
+        // «조립해» 넘긴다 — handDraftClaim 이 관측한 PR 머리와 리뷰 러너로 수확을 확정한 뒤에만 claim 문면을 게시한다.
+        const draftClaimPr = opts.draftClaim === undefined ? undefined : Number(opts.draftClaim);
+        if (opts.draftClaim !== undefined && (!Number.isInteger(draftClaimPr) || (draftClaimPr ?? 0) <= 0)) {
+          out(`--draft-claim 은 PR 번호다: ${opts.draftClaim}`);
+          process.exitCode = 1;
+          return;
+        }
+        if (draftClaimPr !== undefined && opts.live && (opts.tier === '상' || opts.tier === '특')) {
+          try { debug.log('task-agent.hand', 'tier-split-bypassed', { reason: 'draft-claim', pr: draftClaimPr, tier: opts.tier }); } catch { /* fail-soft */ }
+        }
+        const handed = draftClaimPr !== undefined
+          ? { kind: 'whole' as const, result: await handDraftClaim({ ...handOpts, pr: draftClaimPr, gh: deps.draftClaimGh ?? defaultDraftClaimGhPorts() }) }
+          : await (await import('../task-agent/tier-split.js')).handTaskWithTierSplit({ ...handOpts, ...('tierSizedDecompose' in deps ? { decompose: deps.tierSizedDecompose } : {}) });
+        if (handed.kind === 'split') {
+          // TIER-SPLIT-BEFORE-LAUNCH — 상·특 hand 를 조각으로 나눠 쐈다: 첫 줄 = 묶음 · 조각마다 한 줄(미션 출력과 같은 꼴).
+          if (opts.json) out(JSON.stringify(handed));
+          else {
+            // 디스패처 계약(ta-dispatcher.sh · `grep -E '^ta-' | head -1`): 줄 머리 `ta-` 는 «카드 id» 만 — 조각 카드 줄이 먼저, 묶음 줄은 끝에 `tier-split` 머리로.
+            for (const piece of handed.slices) {
+              out([piece.result?.card.id ?? '-', piece.result?.launched ? 'launched' : piece.error ? 'failed' : 'not launched', `tier ${piece.slice.tier} · 파일 ${piece.slice.files} · 행동 ${piece.slice.behaviours}`, headLine(piece.slice.goal)].join('\t'));
+              if (piece.slice.unavoidable) out(`  불가피: ${piece.slice.unavoidable}`);
+              if (piece.error) out(`  ${piece.error}`);
+            }
+            out(`tier-split\t${handed.group}\t${handed.fromTier} → 조각 ${handed.slices.length}`);
+          }
+          if (handed.slices.some((piece) => piece.error)) process.exitCode = 1;
+          return;
+        }
+        const result = handed.result;
+        if (handed.kind === 'blocked') process.exitCode = 1;
         if (opts.json) out(JSON.stringify(result));
-        else {
+        else if (handed.kind === 'blocked') {
+          // 발사 0 — 디스패처가 «넘김 실패» 로 읽도록 어느 줄도 `ta-` 로 시작하지 않는다.
+          out(`tier-split-failed\t${result.card.id}\tnot launched`);
+          out(`(tier-split-failed — 발사 0 · 카드 failed · ${handed.reason})`);
+        } else {
           out(`${result.card.id}\t${result.mode}\t${result.launched ? 'launched' : 'not launched'}`);
           if (result.move.command) out(`elanous ${result.move.command.map(shellQuote).join(' ')}`);
           else out(result.move.reason);
@@ -1267,7 +2062,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .option('--by <seat>', '바꾼 자리(예: OP·MK·TC·UX) — 안 주면 호출 자리 ELANOUS_TRACK, 그것도 없으면 «unknown» 으로 감사 줄에 적는다(지어내지 않는다)')
     .option('--reason <text>', '왜 바꾸나 — 감사 줄에 남긴다')
     .option('--json', '바뀐 카드를 JSON 으로 출력')
-    .action((id: string, kv: string, opts: { by?: string; reason?: string; json?: boolean }) => {
+    .action(async (id: string, kv: string, opts: { by?: string; reason?: string; json?: boolean }) => {
       try {
         const by = opts.by?.trim() || process.env.ELANOUS_TRACK?.trim() || 'unknown';
         const card = runTagChange(id, { tag: kv, by, ...(opts.reason !== undefined ? { reason: opts.reason } : {}) }, deps.taskStatePath ?? taskStatePathDefault());
@@ -1281,6 +2076,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           return;
         }
         out(`${card.id}\t${kv}`);
+        const { cardIdentityLines } = await import('./tasks-card-show.js');
         for (const line of cardIdentityLines(card)) out(line);
       } catch (error) {
         out(error instanceof Error ? error.message : '태그 바꾸기 실패');
@@ -1475,6 +2271,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       await registerTaskAgentSink(deps.registerSink);
       try {
         // 내부 팩은 elanous 프로젝트만 낸다 — 다른 프로젝트로 거르면 릴리스 원장을 열지 않는다(그 원장의 오류가 카드 보드를 막지 않게).
+        const { cardsBoard, countBoardTasks, INTERNAL_PACK_PROJECT, mergeBoards, releasePackBoard } = await import('../task-agent/board.js');
         const wantsPack = opts.project === undefined || opts.project === INTERNAL_PACK_PROJECT;
         const board = mergeBoards(
           cardsBoard(deps.taskStatePath ?? taskStatePathDefault()),
@@ -1507,6 +2304,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .option('--json', 'JSON 출력')
     .action(async (missionId: string | undefined, opts: { all?: boolean; pr?: Array<[string, string]>; goal?: Array<[string, string]>; live?: boolean; json?: boolean }) => {
       await registerTaskAgentSink(deps.registerSink);
+      const { advanceMission, MissionAdvanceError, openMissionIds, recordPieceRef } = await import('../task-agent/mission.js');
       const started = Date.now();
       if ((missionId === undefined) === (opts.all !== true)) {
         const reason = '미션 id «또는» --all 중 하나만 준다';
@@ -1582,84 +2380,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       }
     });
 
-  tasks.command('show <id>')
-    .description(`태스크 상세 보기 (id 가 \`${TASK_CARD_PREFIX}\` 로 시작하면 TASK-AGENT 과제 카드 ⊕ 다음 수)`)
-    .option('--json', 'JSON 출력')
-    .action(async (id: string, opts: { json?: boolean }) => {
-      if (id.startsWith(TASK_CARD_PREFIX)) {
-        await registerTaskAgentSink(deps.registerSink);
-        let card: TaskCard | undefined;
-        try {
-          card = readTaskCard(id, deps.taskStatePath);
-          // 런 id 가 있으면 원장에서 골 id · PR 을 묶는다(찾았을 때만 적는다 · 실패는 그대로 보인다).
-          const bindable = card?.pieces ? card.pieces : card ? [card.id] : [];
-          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 */ }
-            }
-            // TA-REVIEW-RESULT-CAPTURE — 떼어 띄운 live review 의 결과 파일을 이 카드 history 로 회수한다(대기 중인 요청이 있을 때만 쓴다 · 던지지 않는다).
-            captureReviewResults(deps.taskStatePath ?? taskStatePathDefault(), { cardIds: [cardId], ...(deps.reviewResultNow ? { now: deps.reviewResultNow } : {}) });
-          }
-          if (card) card = readTaskCard(id, deps.taskStatePath);
-        } catch (error) {
-          out(error instanceof Error ? error.message : '과제 카드 읽기 실패');
-          process.exitCode = 1;
-          return;
-        }
-        if (!card) { out(`과제 카드 없음: ${id}`); process.exitCode = 1; return; }
-        if (card.pieces) {
-          let all: Record<string, TaskCard>;
-          try { all = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(deps.taskStatePath ?? taskStatePathDefault()).tasks ?? {}; } catch (error) {
-            out(error instanceof Error ? error.message : '과제 카드 읽기 실패');
-            process.exitCode = 1;
-            return;
-          }
-          const pieces = card.pieces.map((pieceId) => all[pieceId]).filter((piece): piece is TaskCard => piece !== undefined);
-          const missingPieces = card.pieces.filter((pieceId) => !all[pieceId]);
-          if (opts.json) {
-            out(JSON.stringify({ card, nextMove: nextMoveFor(card), pieces: pieces.map((piece) => ({ card: piece, nextMove: nextMoveFor(piece) })), missingPieces }));
-            if (missingPieces.length) process.exitCode = 1;
-          }
-          else {
-            for (const line of missionLines(card, pieces)) out(line);
-            for (const missing of missingPieces) { out(`조각 카드 없음: ${missing} — 선후 기록이 불완전하다`); process.exitCode = 1; }
-          }
-          return;
-        }
-        // DRAFT-NOT-ARCHIVE: 멈춘 런이 draft PR 대신 남긴 수확 가지(원장 `salvaged`). 못 읽었으면 «못 읽음»(⛔ 없음 아님).
-        let salvage: Awaited<ReturnType<typeof readCardSalvageBranch>> = { salvageBranch: null };
-        try { salvage = await readCardSalvageBranch(card, deps.cardRunEvidence ?? {}); }
-        catch (error) { salvage = { salvageBranch: null, readErrors: [error instanceof Error ? error.message : String(error)] }; }
-        const salvageUnread = !salvage.salvageBranch && !!salvage.readErrors?.length;
-        if (opts.json) out(JSON.stringify({ card, nextMove: nextMoveFor(card), salvageBranch: salvage.salvageBranch, ...(salvageUnread ? { salvageBranchUnread: true } : {}) }));
-        else {
-          for (const line of taskCardLines(card)) out(line);
-          if (card.parentHost) out(`부모 호스트: ${card.parentHost.host}${card.parentHost.pid ? ` (pid ${card.parentHost.pid})` : ''} · PR 까지만 — 병합은 HQ${card.parentHost.log ? ` · 로그 ${card.parentHost.host}:${card.parentHost.log}` : ''}`);
-          if (salvage.salvageBranch) out(`수확 가지: ${salvage.salvageBranch} (draft PR 대신)`);
-          else if (salvageUnread) out('수확 가지: 못 읽음(원장 읽기 실패)');
-        }
-        return;
-      }
-      try {
-        activeToken = undefined;
-        const auth = authenticate();
-        const response = await request(deps, auth, `/v1/tasks/${encodeURIComponent(id)}`);
-        if (!response.ok) throw httpError(response);
-        const data = await responseJson(response) as { task?: TaskRow };
-        if (!data?.task) throw new Error('넥서스 태스크 상세 형식이 유효하지 않다');
-        if (opts.json) out(JSON.stringify(data));
-        else {
-          out(taskLine(data.task));
-          out(JSON.stringify(data, null, 2));
-        }
-      } catch (error) { handleError(error, out); }
-    });
+  registerTaskShowCommand(tasks, ctx);
 
   tasks.command('rejudge [id]')
     .description('TA-REJUDGE-ON-HEAD — 런 멈춤 뒤 카드 PR 머리가 바뀌었으면 재게이트(떼어 띄움)·리뷰 재요청·land(재게이트 통과 ⊕ 지금 머리 pass ⊕ must-fix 0 · 겹침 증거)를 다시 판단한다 · 허용은 설정 taskAgent.liveMoves 그대로')
@@ -1730,7 +2451,9 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       const reviewBudget = opts.all ? { max: 1, requested: 0 } : undefined;
       const landBudget = opts.all ? { max: 1, requested: 0 } : undefined;
       const all = [];
+      const { replayRemoteCardMoves } = await import('../task-agent/shadow.js');
       for (const cardId of ids) {
+        const { mirrorRemoteCardLedger } = await import('./tasks-card-show.js');
         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 */ }
@@ -1786,9 +2509,11 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .requiredOption('--card <id>').requiredOption('--pr <n>').requiredOption('--head <sha>')
     .requiredOption('--repo <root>').requiredOption('--out <path>').requiredOption('--goal-file <path>')
     .requiredOption('--run-id <id>').requiredOption('--model-provider <provider>').requiredOption('--model-id <id>')
+    .option('--role-llm <role=provider[/tier]>', 'TA 부모 역할 고정(task hand와 같은 문법 · 반복 가능)', (value: string, previous: string[] = []) => [...previous, value])
     .option('--seat <seat>')
+    .option('--move-id <id>', 'HARNESS-FULL-GRAPH-NEXTMOVE — 이 발사를 고른 next-move 결정의 수 id(결과 파일·완료 사건에 그대로 싣는다)')
     .action(async (opts: { card: string; pr: string; head: string; repo: string; out: string; goalFile: string;
-      runId: string; modelProvider: string; modelId: string; seat?: string }) => {
+      runId: string; modelProvider: string; modelId: string; seat?: string; moveId?: string; roleLlm?: string[] }) => {
       const { readFileSync } = await import('node:fs');
       const { getElanousConfigDirOverride } = await import('../elanous-config-dir.js');
       const { effectiveInstanceRoot } = await import('../instance/resolve.js');
@@ -1797,6 +2522,8 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         repo: opts.repo, resultPath: opts.out, entry: ELANOUS_CLI_ENTRY,
         configDir: getElanousConfigDirOverride() ?? effectiveInstanceRoot(), runId: opts.runId,
         model: { provider: opts.modelProvider, model: opts.modelId }, seat: opts.seat,
+        ...(opts.roleLlm?.length ? { parentRoleLlm: opts.roleLlm } : {}),
+        ...(opts.moveId ? { moveId: opts.moveId } : {}),
         goal: readFileSync(opts.goalFile, 'utf8') });
       if (!result.ok) process.exitCode = 1;
     });
@@ -1805,7 +2532,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .description('외부 태스크 승인')
     .action(async (ids: string[]) => {
       try {
-        activeToken = undefined;
+        ctx.clearToken();
         const auth = authenticate();
         let failed = false;
         for (const id of ids) {