elanous 0.2.21 → 0.2.23

package/src/cli/tasks-cli.ts

@@ -1,4 +1,4 @@
-import { closeSync, mkdirSync, openSync, readFileSync, readSync } from 'node:fs';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { loadRunLedger as loadRunLedgerSync } from '../self-implement/run-ledger.js';
 import { join, resolve } from 'node:path';
@@ -9,9 +9,13 @@ import { readNexusRuntime } from '../nexus/runtime.js';
 import { checklistDevVersion } from '../release-loop/checklist.js';
 import { cardsBoard, countBoardTasks, INTERNAL_PACK_PROJECT, mergeBoards, releasePackBoard, type BoardNode } from '../task-agent/board.js';
 import type { Task } from '../task-orchestrator/types.js';
-import { cardPrNumber, COMPLETION_KINDS, handTask, nextMoveFor, readTaskAgentState, readTaskCard, taskAgentStatePath as taskStatePathDefault, shellQuote, TASK_CARD_PREFIX, TASK_SEATS, type CompletionKind, type TaskCard, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
+import { cardPrNumber, COMPLETION_KINDS, handTask, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, nextMoveFor, resolveHandText, readTaskAgentState, readTaskCard, taskAgentStatePath as taskStatePathDefault, shellQuote, TA_LAND_ENV, TASK_CARD_PREFIX, TASK_SEATS, type CompletionKind, type TaskCard, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
 import { readCardSalvageBranch, refreshCardRunBinding, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
+import { captureReviewResults } from '../task-agent/review-result-capture.js';
 import { advanceMission, handMission, MissionAdvanceError, openMissionIds, recordPieceRef, type AdvanceMissionResult, type MissionDecompose, type PieceEvidenceReader } from '../task-agent/mission.js';
+import { formatTaskAgentCover, measureTaskAgentCover, type CoverRow, type TaskAgentCoverInput } from '../task-agent/cover.js';
+import { LogStore, STORE_SAFETY_MAX, type LogQuery, type LogStoreRow } from '../mss/logging/log-store.js';
+import { resolveLogTargets } from './logs-cli.js';
 
 type TaskRow = Pick<Task, 'id' | 'title' | 'priority' | 'status' | 'createdAt' | 'approval' | 'generatedBy'>;
 
@@ -22,6 +26,8 @@ export interface TasksCliDeps {
   output?: (line: string) => void;
   /** `task hand --live` 의 발사기(시험 주입). 기본은 운영 config-dir 로 `harness say` 를 떼어 띄운다. */
   taskLauncher?: TaskLauncher;
+  /** TA-REVIEW-RESULT-CAPTURE — `tasks show` 의 리뷰 결과 회수 시각(시험 주입 · 기본 지금). */
+  reviewResultNow?: () => Date;
   /** 과제 카드 상태 파일(시험 주입). 기본 = `effectiveInstanceRoot()/task-agent-actions.json`. */
   taskStatePath?: string;
   /** logs.db 싱크 등록(시험 주입). 기본 = `registerStandaloneLogSink`. `hand`·`show` 가 부른다. */
@@ -38,6 +44,13 @@ export interface TasksCliDeps {
   remoteLedgerMirror?: (card: TaskCard) => void;
   /** `tasks parents` 의 낡은 부모 보고 의존(시험 주입). */
   staleParents?: import('../task-agent/parent-host.js').StaleParentDeps;
+  /** `tasks cover` logs 조회 seam. 기본은 등록된 모든 우주(운영 ⊕ test)의 logs.db 를 read-only 로 연다 —
+   *  pr land 는 작업 트리마다 파생 test 우주에 기록되므로 현재 우주만 읽으면 분모가 늘 0 이다. */
+  coverLogs?: (query: LogQuery) => LogStoreRow[] | CoverLogRead;
+  /** TA-REJUDGE-ON-HEAD — `tasks rejudge` 의 판단 의존(시험 주입 · 기본 = 설정 liveMoves ⊕ 실물 gh·리뷰·재게이트·land). */
+  rejudge?: Partial<import('../task-agent/rejudge-on-head.js').RejudgeDeps>;
+  /** TA-REJUDGE-ON-HEAD — `tasks regate-run` 의 재게이트(시험 주입 · 기본 `runHostRegate`). */
+  hostRegate?: (input: import('../self-implement/host-regate.js').HostRegateInput) => Promise<import('../self-implement/host-regate.js').HostRegateResult>;
 }
 
 /** `<조각id>=<값>` 반복 인자. */
@@ -102,7 +115,7 @@ export interface DefaultTaskLauncherDeps {
   /** 이미 stop 이 있나(시험 주입). 기본 = 이 우주 런 원장 ⊕ 이 프로세스 기록. */
   hasStop?: (runId: string) => boolean;
   /** HARNESS-PARENT-ON-MSB1 — 원격 부모 대상(시험 주입). undefined = 설정·env 에서 푼다 · null = 끔. */
-  parentHost?: import('../task-agent/parent-host.js').ParentHostConfig | null;
+  parentHost?: import('../task-agent/parent-host.js').ParentHostConfig | readonly import('../task-agent/parent-host.js').ParentHostConfig[] | null;
   /** 원격 ssh(시험 주입). */
   ssh?: import('../task-agent/parent-host.js').SshRunner;
   /** HQ 발사 동결(holdLaunches) 여부(시험 주입). */
@@ -119,21 +132,23 @@ export interface DefaultTaskLauncherDeps {
  */
 async function tryRemoteParent(args: string[], cwd: string | undefined, context: TaskLaunchContext, deps: DefaultTaskLauncherDeps): Promise<TaskLaunchReceipt | null> {
   const parentHostModule = await import('../task-agent/parent-host.js');
-  let target = deps.parentHost;
-  if (target === undefined) {
+  let configured: import('../task-agent/parent-host.js').ParentHostSetting | null | undefined = deps.parentHost;
+  if (configured === undefined) {
     const { getUserConfig } = await import('../user-config.js');
-    let configured: Parameters<typeof parentHostModule.resolveParentHost>[0];
     try { configured = getUserConfig().taskAgent?.parentHost; } catch { configured = undefined; }
-    target = parentHostModule.resolveParentHost(configured);
   }
-  if (!target) return null;
+  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 notice = deps.notice ?? ((line: string) => { try { process.stderr.write(`${line}\n`); } catch { /* ignore */ } });
-  const fallback = (gaps: string[], facts: Record<string, string> = {}): null => {
-    try { debug.log('task-agent', 'parent-host-fallback', { host: target!.host, runId: context.runId, gaps, facts }); } catch { /* fail-soft */ }
-    notice(`[parent-host] ${target!.host} 로 못 띄움 — 로컬 발사로 간다: ${gaps.join(' · ')}`);
-    return null;
+  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(' · ')}`);
   };
-  if (cwd) return fallback(['project-target-is-local']);
+  if (cwd || context.env[TA_LAND_ENV] === '1') {
+    failed(targets[0]!, [cwd ? 'project-target-is-local' : 'ta-land-needs-local-parent']);
+    return null;
+  }
   let launchHoldActive = false;
   try {
     if (deps.launchHoldActive) launchHoldActive = deps.launchHoldActive();
@@ -143,18 +158,28 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
       launchHoldActive = readLandingFreeze(prodInstanceRoot())?.holdLaunches === true;
     }
   } catch { launchHoldActive = true; /* 못 읽으면 막힌 것으로(fail-closed) */ }
-  const preflight = parentHostModule.preflightParentHost({ target, localVersion: deps.localVersion ?? parentHostModule.localElanousVersion(), launchHoldActive, ...(deps.ssh ? { ssh: deps.ssh } : {}) });
-  if (!preflight.ok) return fallback(preflight.gaps, preflight.facts);
-  try {
-    const launched = parentHostModule.launchRemoteParent(target, args, context.env, deps.ssh);
-    try { debug.log('task-agent', 'parent-host-launched', { host: target.host, runId: context.runId, pid: launched.pid, log: launched.log }); } catch { /* fail-soft */ }
-    return { runId: context.runId, parentHost: { host: target.host, ...(target.configDir ? { configDir: target.configDir } : {}), pid: launched.pid, log: launched.log } };
-  } catch (error) {
-    // «확실히 안 떴다»일 때만 로컬로 — 불확실(ssh 끊김 등)은 던져 카드를 launch-failed 로 남긴다(중복 발사 방지).
-    if (error instanceof parentHostModule.RemoteParentNotLaunchedError) return fallback([error.message]);
-    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;
+  const capacities = Object.fromEntries(multi ? targets.map((target) => [target.host, parentHostModule.readParentHostCapacity(target, deps.ssh)]) : []);
+  const ordered = multi ? parentHostModule.orderParentHosts(targets, context.runId, capacities) : targets;
+  for (const target of ordered) {
+    if (multi && (!capacities[target.host] || capacities[target.host]!.approvalHeadroom <= 0)) {
+      failed(target, ['capacity-unavailable']);
+      continue;
+    }
+    let preflight: ReturnType<typeof parentHostModule.preflightParentHost>;
+    try { preflight = parentHostModule.preflightParentHost({ target, localVersion: deps.localVersion ?? parentHostModule.localElanousVersion(), launchHoldActive, ...(deps.ssh ? { ssh: deps.ssh } : {}) }); }
+    catch (error) { failed(target, [`preflight-error: ${error instanceof Error ? error.message : String(error)}`]); continue; }
+    if (!preflight.ok) { failed(target, preflight.gaps, preflight.facts); continue; }
+    try {
+      const launched = parentHostModule.launchRemoteParent(target, args, context.env, deps.ssh);
+      try { debug.log('task-agent', 'parent-host-launched', { host: target.host, runId: context.runId, pid: launched.pid, log: launched.log }); } catch { /* fail-soft */ }
+      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; }
+      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;
+    }
   }
+  return null;
 }
 
 /** stderr 파일의 첫 비어 있지 않은 줄(최대 4KB 만 읽는다 — 원 로그 꼬리를 싣지 않는다). */
@@ -309,10 +334,25 @@ function taskCardLines(card: TaskCard): string[] {
     [card.id, card.status, card.seat ?? '-', card.checklistId ?? '-', card.createdAt, card.text].join('\t'),
     ...(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}`));
@@ -390,6 +430,74 @@ function handleError(error: unknown, out: (line: string) => void): void {
   }
 }
 
+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. */
+export interface CoverLogRead { rows: LogStoreRow[]; limitReached: boolean; unreadableStores: number; storesRead: number }
+
+function queryCoverLogs(query: LogQuery): CoverLogRead {
+  const { targets, error } = resolveLogTargets({ all: true, includeTest: true });
+  if (error) throw new Error(error);
+  const read: CoverLogRead = { rows: [], limitReached: false, unreadableStores: 0, storesRead: 0 };
+  for (const target of targets) {
+    if (!existsSync(target.dbPath)) continue;
+    let store: LogStore | undefined;
+    try {
+      store = LogStore.openReadOnly(target.dbPath);
+      const rows = store.query(query);
+      if (query.limit !== undefined && rows.length >= query.limit) read.limitReached = true;
+      read.rows.push(...rows);
+      read.storesRead++;
+    } catch { read.unreadableStores++; }
+    finally { try { store?.close(); } catch { /* already closed */ } }
+  }
+  if (read.storesRead === 0) throw new Error('읽을 수 있는 logs.db 없음');
+  return read;
+}
+
+function coverEvents<T>(rows: readonly LogStoreRow[], category: string, event: string, parse: (data: Record<string, unknown>) => T | null): T[] {
+  const events: T[] = [];
+  for (const row of rows) {
+    if (row.category !== category || row.event !== event || !row.data) continue;
+    try {
+      const data: unknown = JSON.parse(row.data);
+      if (data === null || typeof data !== 'object' || Array.isArray(data)) continue;
+      const parsed = parse(data as Record<string, unknown>);
+      if (parsed !== null) events.push(parsed);
+    } catch { /* malformed log data is not evidence of an action */ }
+  }
+  return events;
+}
+
+export function readTaskAgentCover(
+  window: { sinceMs?: number; untilMs?: number } = {},
+  query: NonNullable<TasksCliDeps['coverLogs']> = queryCoverLogs,
+): { rows: CoverRow[]; limitReached: boolean; unreadableStores: number } {
+  let unreadableStores = 0;
+  const read = (category: 'task-agent' | 'pr.land', event: 'action' | 'step'): { rows: LogStoreRow[]; limitReached: boolean } | null => {
+    try {
+      const result = query({ ...window, limit: COVER_QUERY_LIMIT, exactCategories: [category], events: [event] });
+      if (Array.isArray(result)) return { rows: result, limitReached: result.length >= COVER_QUERY_LIMIT };
+      unreadableStores = Math.max(unreadableStores, result.unreadableStores);
+      return { rows: result.rows, limitReached: result.limitReached };
+    } catch { return null; }
+  };
+  const actionRead = read('task-agent', 'action');
+  const landRead = read('pr.land', 'step');
+  const actions = actionRead?.rows ?? null;
+  const lands = landRead?.rows ?? null;
+  const truncated = { taskAgentActions: actionRead?.limitReached === true, allLands: landRead?.limitReached === true };
+  const input: TaskAgentCoverInput = {
+    taskAgentActions: actions === null ? null : coverEvents(actions, 'task-agent', 'action', (data) =>
+      typeof data.kind === 'string' && typeof data.result === 'string'
+        ? { kind: data.kind as NonNullable<TaskAgentCoverInput['taskAgentActions']>[number]['kind'], result: data.result } : null),
+    allLands: lands === null ? null : coverEvents(lands, 'pr.land', 'step', (data) =>
+      typeof data.step === 'string' && typeof data.ok === 'boolean' ? { step: data.step, ok: data.ok } : null),
+    truncated,
+  };
+  return { rows: measureTaskAgentCover(input), limitReached: truncated.taskAgentActions || truncated.allLands, unreadableStores };
+}
+
 export function registerTasksCommands(program: Command, deps: TasksCliDeps = {}): void {
   let activeToken: string | undefined;
   const output = deps.output ?? console.log;
@@ -402,6 +510,39 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
   };
   const tasks = program.command('tasks').alias('task').description('TOX 태스크 조회 및 승인 · TASK-AGENT 과제 넘기기(hand)');
 
+  tasks.command('cover')
+    .description('TASK-AGENT 가 대신한 착지 비율과 리뷰·재발사·green 의 아직 없는 분모를 조회(읽기 전용)')
+    .option('--since <iso>', '시작 시각 (ISO)')
+    .option('--until <iso>', '끝 시각 (ISO)')
+    .option('--json', 'JSON 출력')
+    .option('--lines', '동사별 한 줄 요약 출력 (읽기 전용)')
+    .action((opts: { since?: string; until?: string; json?: boolean; lines?: boolean }) => {
+      const parseIso = (value: string | undefined, flag: string): number | undefined => {
+        if (value === undefined) return undefined;
+        const time = Date.parse(value);
+        if (!/^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d\d:\d\d)$/.test(value) || !Number.isFinite(time)) throw new Error(`${flag} 는 ISO 시각이어야 한다`);
+        return time;
+      };
+      try {
+        const sinceMs = parseIso(opts.since, '--since');
+        const untilMs = parseIso(opts.until, '--until');
+        if (sinceMs !== undefined && untilMs !== undefined && sinceMs > untilMs) throw new Error('--since 가 --until 보다 늦다');
+        const { rows, limitReached, unreadableStores } = readTaskAgentCover({ sinceMs, untilMs }, deps.coverLogs);
+        const limitWarning = limitReached ? `조회 상한 ${COVER_QUERY_LIMIT} 도달 — 더 오래된 사건이 있을 수 있다(절단된 수를 전체로 읽지 말 것)` : null;
+        const storeWarning = unreadableStores > 0 ? `logs.db ${unreadableStores}개를 못 읽었다 — 그 우주의 사건은 수에 없다(«없다»로 읽지 말 것)` : null;
+        if (opts.json) out(JSON.stringify({ rows, limitReached, unreadableStores, ...(limitWarning ? { warning: limitWarning } : {}), ...(storeWarning ? { storeWarning } : {}) }));
+        else {
+          if (opts.lines) for (const row of rows) out(formatTaskAgentCover(row));
+          else {
+            out('동사\t대신\t전체\t비율\t상태\t관측 사건');
+            for (const row of rows) out(`${row.verb}\t${row.byTaskAgent ?? '-'}\t${row.total ?? '-'}\t${row.ratio ?? '-'}\t${row.state}\t${row.observedActions ?? '-'}`);
+          }
+          if (limitWarning) out(`⚠ ${limitWarning}`);
+          if (storeWarning) out(`⚠ ${storeWarning}`);
+        }
+      } catch (error) { out(error instanceof Error ? error.message : '커버 조회 실패'); process.exitCode = 1; }
+    });
+
   tasks.command('list')
     .description('우선순위와 생성 시각 순으로 태스크 보기')
     .option('--status <s>', '상태로 필터')
@@ -446,8 +587,11 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .option('--milestone <id>', '보드 소속 이정표 id (task board)')
     .option('--target <dir>', '프로젝트 대상 디렉터리(있어야 한다 · 상대 경로는 절대로 · git 이 아니면 --completion 이 code-pr 밖이어야 한다) — 발사기를 이 디렉터리에서 띄운다')
     .option('--live', '실제로 발사한다(기본은 shadow — 명령만 출력)')
+    .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('--json', 'JSON 출력')
-    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; completion?: CompletionKind; mission?: string; project?: string; target?: string; goal?: string; milestone?: string; live?: boolean; json?: boolean }) => {
+    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; completion?: CompletionKind; mission?: string; project?: string; target?: string; goal?: string; milestone?: string; live?: boolean; taLand?: boolean; childLlm?: string; childLlmEffort?: string; json?: boolean }) => {
       await registerTaskAgentSink(deps.registerSink);
       if ((text === undefined) === (opts.mission === undefined)) {
         out('과제 한 줄 «또는» --mission <문면> 중 하나만 준다');
@@ -459,8 +603,8 @@ 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)) {
-        out('--completion/--project/--target/--goal/--milestone 은 과제 한 줄에만 준다 — --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)) {
+        out('--completion/--project/--target/--goal/--milestone/--ta-land/--child-llm 은 과제 한 줄에만 준다 — --mission 조각은 종전처럼 code-pr 이다');
         process.exitCode = 1;
         return;
       }
@@ -494,8 +638,18 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         return;
       }
       try {
+        const resolved = resolveHandText(text!);
+        if (resolved.kind === 'rejected') {
+          try { debug.log('task-agent.hand', 'goal-file-rejected', { path: resolved.path, reason: resolved.reason }); } catch { /* fail-soft */ }
+          out(`골 파일 ${resolved.path}: ${resolved.reason}`);
+          process.exitCode = 1;
+          return;
+        }
+        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({
-          text: text!,
+          text: resolved.text,
           ...(opts.project !== undefined && opts.target !== undefined ? { project: { id: opts.project, target: opts.target } } : {}),
           ...(opts.goal !== undefined ? { goal: opts.goal } : {}),
           ...(opts.milestone !== undefined ? { milestone: opts.milestone } : {}),
@@ -503,6 +657,9 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           ...(opts.checklist ? { checklistId: opts.checklist } : {}),
           ...(opts.completion ? { completion: opts.completion } : {}),
           live: opts.live === true,
+          ...(opts.taLand === true ? { taLand: true } : {}),
+          ...(opts.childLlm !== undefined ? { childLlm: opts.childLlm } : {}),
+          ...(opts.childLlmEffort !== undefined ? { childLlmEffort: opts.childLlmEffort } : {}),
           ...(deps.taskStatePath ? { statePath: deps.taskStatePath } : {}),
           launcher: deps.taskLauncher ?? defaultTaskLauncher,
         });
@@ -511,6 +668,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           out(`${result.card.id}\t${result.mode}\t${result.launched ? 'launched' : 'not launched'}`);
           out(`elanous ${result.move.command!.map(shellQuote).join(' ')}`);
           if (result.cwd) out(`(cwd: ${result.cwd})`);
+          if (result.card.taLand) out('(ta-land — 발사 env ELANOUS_TA_LAND=1 · 로컬 부모 · taskAgent.liveMoves 에 propose-land 가 있으면 병합은 TASK-AGENT 몫, 없으면 종전대로 호스트 병합)');
           if (!result.launched) out('(shadow — 띄우지 않았다 · 띄우려면 --live)');
         }
       } catch (error) {
@@ -678,6 +836,8 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
               // 근거 없음으로 보인다 — 원장 부재와 갈리게 실패는 남긴다.
               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) {
@@ -734,6 +894,59 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       } catch (error) { handleError(error, out); }
     });
 
+  tasks.command('rejudge [id]')
+    .description('TA-REJUDGE-ON-HEAD — 런 멈춤 뒤 카드 PR 머리가 바뀌었으면 재게이트(떼어 띄움)·리뷰 재요청·land(재게이트 통과 ⊕ 지금 머리 pass ⊕ must-fix 0 · 겹침 증거)를 다시 판단한다 · 허용은 설정 taskAgent.liveMoves 그대로')
+    .option('--all', '묶인 PR 로 TA 리뷰를 요청한 적이 있는 카드 전부')
+    .option('--json', 'JSON 출력')
+    .action(async (id: string | undefined, opts: { all?: boolean; json?: boolean }) => {
+      await registerTaskAgentSink(deps.registerSink);
+      if ((id === undefined) === (opts.all !== true)) { out('카드 id «또는» --all 중 하나만 준다'); process.exitCode = 1; return; }
+      const { rejudgeCandidates, rejudgeCardOnHead } = await import('../task-agent/rejudge-on-head.js');
+      const statePath = deps.taskStatePath ?? taskStatePathDefault();
+      let ids: string[];
+      try { ids = id ? [id] : rejudgeCandidates(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath).tasks ?? {}); } catch (error) {
+        out(error instanceof Error ? error.message : '과제 카드 읽기 실패'); process.exitCode = 1; return;
+      }
+      const { configuredTaskAgentLiveMoves } = await import('../task-agent/live-moves.js');
+      const liveMoves = deps.rejudge?.liveMoves ?? await configuredTaskAgentLiveMoves();
+      const all = [];
+      for (const cardId of ids) {
+        let outcomes: Awaited<ReturnType<typeof rejudgeCardOnHead>>;
+        try { outcomes = await rejudgeCardOnHead(cardId, { ...deps.rejudge, liveMoves, live: { ...deps.rejudge?.live, statePath } }); } catch (error) {
+          // 카드 하나의 예외가 --all 의 나머지 카드 판단을 멈추지 않게 — 사유를 남기고 다음 카드로.
+          const reason = (error instanceof Error ? error.message : String(error)).slice(-300);
+          try { debug.log('task-agent', 'rejudge-on-head', { card: cardId, pr: null, fromHead: null, toHead: null, step: 'target', decision: 'rejudge-threw', reason }, { level: 'warn' }); } catch { /* fail-soft */ }
+          outcomes = [{ card: cardId, pr: null, fromHead: null, toHead: null, step: 'target', decision: 'rejudge-threw', reason }];
+          process.exitCode = 1;
+        }
+        all.push(...outcomes);
+        if (!opts.json) for (const o of outcomes) out([o.card, `PR ${o.pr === null ? '-' : `#${o.pr}`}`, `${o.fromHead?.slice(0, 12) ?? '-'}→${o.toHead?.slice(0, 12) ?? '-'}`, o.step, o.decision, o.reason].join('\t'));
+      }
+      if (opts.json) out(JSON.stringify(all));
+    });
+
+  tasks.command('regate-run', { hidden: true })
+    .description('TA-REJUDGE-ON-HEAD 내부 — 카드 PR 머리 하나의 호스트 재게이트(병합 없음)를 돌리고 결과를 --out 파일로 쓴다(tasks rejudge 가 떼어 띄운다)')
+    .requiredOption('--card <id>').requiredOption('--pr <n>').requiredOption('--head <sha>').requiredOption('--repo <root>').requiredOption('--out <path>')
+    .action(async (opts: { card: string; pr: string; head: string; repo: string; out: string }) => {
+      await registerTaskAgentSink(deps.registerSink);
+      const pr = Number(opts.pr);
+      const { writeFileSync: write, mkdirSync: mkdir } = await import('node:fs');
+      const { dirname: dir } = await import('node:path');
+      let result: import('../self-implement/host-regate.js').HostRegateResult;
+      try {
+        const regate = deps.hostRegate ?? (await import('../self-implement/host-regate.js')).runHostRegate;
+        result = await regate({ prNumber: pr, headCommit: opts.head, repoRoot: opts.repo, noMerge: true });
+      } catch (error) {
+        result = { passed: false, failures: [{ step: 'host-regate', detail: (error instanceof Error ? error.message : String(error)).slice(-300) }], os: process.platform, status: 'unmeasured' };
+      }
+      const record = { pr, head: opts.head, passed: result.passed, ...(result.status ? { status: result.status } : {}), ...(result.baseCommit ? { baseCommit: result.baseCommit } : {}), failures: result.failures };
+      try { debug.log('task-agent', 'regate-run', { card: opts.card, ...record, failures: result.failures.slice(0, 3) }); } catch { /* fail-soft */ }
+      mkdir(dir(opts.out), { recursive: true });
+      write(opts.out, JSON.stringify(record));
+      if (!result.passed) process.exitCode = 1;
+    });
+
   tasks.command('approve <id...>')
     .description('외부 태스크 승인')
     .action(async (ids: string[]) => {

package/src/connectors/types.ts

@@ -1,5 +1,5 @@
-export interface ExternalTaskEvent {
-  provider: 'linear' | 'asana';
+export interface ExternalTaskEvent<Provider extends string = 'linear' | 'asana'> {
+  provider: Provider;
   eventId: string;
   kind: 'created' | 'updated';
   ref: string;
@@ -11,9 +11,9 @@ export interface ExternalTaskEvent {
   occurredAt: string;
 }
 
-export interface TaskConnector {
-  provider: ExternalTaskEvent['provider'];
+export interface TaskConnector<Provider extends string = ExternalTaskEvent['provider']> {
+  provider: Provider;
   verify(req: { rawBody: string | Uint8Array; signature: string; secret: string; now?: number }): { ok: true } | { ok: false; reason: string };
-  parse(body: unknown, deliveryId: string): ExternalTaskEvent | null;
-  idempotencyKey(event: ExternalTaskEvent): string;
+  parse(body: unknown, deliveryId: string): ExternalTaskEvent<Provider> | null;
+  idempotencyKey(event: ExternalTaskEvent<Provider>): string;
 }

package/src/context-bus/context-first.ts

@@ -1,17 +1,59 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { debug } from '../debug/log.js';
 import type { ContextNowAnswer, ContextNowDeps } from './context-now.js';
 
 const CONTEXT_FIRST_GAP_MS = 6 * 60 * 60 * 1000;
 const CONTEXT_UNREADABLE = '맥락 못 읽음';
 
+/** Where the last-utterance times survive a daemon restart, so a restart does not read as a first utterance. */
+export interface ContextFirstStore {
+  load(): Record<string, number>;
+  save(lastUtteranceAt: Record<string, number>): void;
+}
+
+/** JSON-file store; unreadable or malformed content loads as empty, write failures never block the turn.
+ *  Both are logged (`context-first.store`) so a gate that keeps re-arming after restarts can be traced. */
+export function createContextFirstFileStore(path: string): ContextFirstStore {
+  return {
+    load() {
+      try {
+        const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
+        if (!parsed || typeof parsed !== 'object') return {};
+        return Object.fromEntries(Object.entries(parsed).filter((entry): entry is [string, number] => Number.isFinite(entry[1])));
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException)?.code !== 'ENOENT') {
+          debug.log('context-first.store', 'load-failed', { path, error: err instanceof Error ? err.message : String(err) });
+        }
+        return {};
+      }
+    },
+    save(lastUtteranceAt) {
+      try {
+        mkdirSync(dirname(path), { recursive: true });
+        // Write-then-rename so a daemon killed mid-write never leaves a torn file (which would re-arm every opening).
+        const tmp = `${path}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify(lastUtteranceAt));
+        renameSync(tmp, path);
+      } catch (err) {
+        // Persistence must not block the conversation, but a failure is observed.
+        debug.log('context-first.store', 'save-failed', { path, error: err instanceof Error ? err.message : String(err) });
+      }
+    },
+  };
+}
+
 /** Track every allowed utterance, consuming a pending summary only on a normal turn. */
-export function createContextFirstGate({ now, gapMs = CONTEXT_FIRST_GAP_MS }: { now: () => number; gapMs?: number }) {
-  const lastUtteranceAt = new Map<string, number>();
+export function createContextFirstGate({ now, gapMs = CONTEXT_FIRST_GAP_MS, store }: { now: () => number; gapMs?: number; store?: ContextFirstStore }) {
+  const lastUtteranceAt = new Map<string, number>(Object.entries(store?.load() ?? {}));
   const pending = new Set<string>();
   return {
     note(key: string): void {
       const at = now();
       const previous = lastUtteranceAt.get(key);
       lastUtteranceAt.set(key, at);
+      // An entry older than the gap behaves like no entry, so it is dropped from the persisted state.
+      store?.save(Object.fromEntries([...lastUtteranceAt].filter(([, time]) => at - time < gapMs)));
       if (previous === undefined || at - previous >= gapMs) pending.add(key);
     },
     take(key: string): boolean {
@@ -20,6 +62,13 @@ export function createContextFirstGate({ now, gapMs = CONTEXT_FIRST_GAP_MS }: {
   };
 }
 
+const OPERATIONAL_QUERY = /발행|릴리[스즈]|배포|버전|상태|현황|스케줄|체크리스트|도는\s*런|돌고\s*있|\brelease\b|\bversion\b|\bstatus\b|\/now\b/i;
+
+/** A question about the operation or the release itself already asks for the ledger, so the opening would only push the answer down. */
+export function isOperationalQuery(text: string | undefined): boolean {
+  return !!text && OPERATIONAL_QUERY.test(text);
+}
+
 export function renderContextFirst(
   read: (options: {}, deps?: ContextNowDeps) => ContextNowAnswer,
   deps: ContextNowDeps | undefined,

package/src/context-bus/context-now-surfaces.ts

@@ -53,6 +53,35 @@ export function renderTelegramNow(input: ContextNowAnswer, audience: ContextNowA
   return lines.map(line => line.replace(/\s+/g, ' ').trim()).join('\n');
 }
 
+/** Context-first opening for chat connectors: up to three operational rows (live runs, an unfinished
+ *  release run, late schedules) ahead of the same `/now` body. `/now` itself stays unchanged. */
+export function renderContextFirstNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string {
+  const answer = forAudience(input, audience);
+  const { lines, total } = operationalLines(answer);
+  if (total > lines.length) lines.push(`… 운영 항목 ${total - lines.length}개 더 (/now)`);
+  return [...lines, renderTelegramNow(answer, 'operator')].join('\n');
+}
+
+/** Telegram opening: at most three operational rows and nothing else — no `/now` body, no «최근:» row.
+ *  Empty when nothing operational is running, so the caller sends no opening at all. */
+export function renderContextFirstOpening(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string {
+  return operationalLines(forAudience(input, audience)).lines.join('\n');
+}
+
+function operationalLines(answer: ContextNowAnswer): { lines: string[]; total: number } {
+  const labels = { run: '도는 런', release: '발행 런', 'schedule-late': '지연 스케줄' } as const;
+  const operational = answer.facts.filter(fact => fact.kind === 'run' ||
+    (fact.kind === 'release' && (fact.unreadable || fact.status !== 'done')) ||
+    (fact.kind === 'schedule-late' && (fact.unreadable || !!fact.count)));
+  // Run goals are whole asks (often thousands of characters); one line each keeps the opening to one screen.
+  const short = (text: string) => { const chars = Array.from(text); return chars.length > 60 ? `${chars.slice(0, 60).join('')}…` : text; };
+  const lines = operational.slice(0, 3).map(fact => {
+    const text = fact.kind === 'run' && !fact.unreadable ? `${short(fact.goal.replace(/\s+/g, ' ').trim())} · ${fact.phase} · ${fact.elapsed}` : factText(fact);
+    return `${labels[fact.kind as keyof typeof labels]}: ${text} — ${fact.source}`.replace(/\s+/g, ' ').trim();
+  });
+  return { lines, total: operational.length };
+}
+
 export function renderTuiNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string[] {
   const answer = forAudience(input, audience);
   const shortText = (text: string) => {

package/src/context-bus/coord-events.ts

@@ -2,7 +2,9 @@ import { Database } from 'bun:sqlite';
 import { readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { debug, redactSecretText } from '../debug/log.js';
+import { DecisionLedger, type Seat } from '../decisions/decision-ledger.js';
 import { openSurfaceEventsDb, recordEvent, surfaceEventsDbPath } from '../domains/surface-events.js';
+import { registeredSeats } from '../seat-address/seat-address.js';
 
 export interface CoordEventInput {
   seat: string;
@@ -31,6 +33,13 @@ function seatIds(): Set<string> {
 }
 const kinds = new Set(['요청', '결정', '사고', '보고', '정정']);
 
+function cleanCoordHeadline(value: string): string {
+  const first = value.split(/\r?\n/, 1)[0] ?? '';
+  const withoutPrefix = first.replace(/^\*\*\[[A-Z]+\]\*\*\s*/, '')
+    .replace(/^(?:📌안내\s*)?\d{4}-\d\d-\d\d\s+\d\d:\d\d\s+KST\s*/, '');
+  return redactSecretText(withoutPrefix).trim().slice(0, 120);
+}
+
 /** Mirror the sender's ordered envelope fields; only the first line enters this parser. */
 export function parseCoordHeader(seat: string, header: string): Omit<CoordEventInput, 'url' | 'at'> {
   const first = header.split(/\r?\n/, 1)[0] ?? '';
@@ -69,10 +78,7 @@ export function recordCoordEvent(input: CoordEventInput, deps: { db?: Database }
   try {
     db = deps.db ?? openSurfaceEventsDb();
     const at = input.at ?? new Date().toISOString();
-    const first = input.headline.split(/\r?\n/, 1)[0] ?? '';
-    const withoutPrefix = first.replace(/^\*\*\[[A-Z]+\]\*\*\s*/, '')
-      .replace(/^(?:📌안내\s*)?\d{4}-\d\d-\d\d\s+\d\d:\d\d\s+KST\s*/, '');
-    const headline = redactSecretText(withoutPrefix).trim().slice(0, 120);
+    const headline = cleanCoordHeadline(input.headline);
     const safe = (value: string) => redactSecretText(value.split(/\r?\n/, 1)[0] ?? '');
     const refs = { seat: safe(input.seat), recipients: input.recipients.map(safe), all: input.all,
       kind: input.kind === null ? null : safe(input.kind), slot: input.slot === null ? null : safe(input.slot),
@@ -98,6 +104,28 @@ export function recordCoordEvent(input: CoordEventInput, deps: { db?: Database }
   } finally { if (!deps.db) db?.close(); }
 }
 
+/** A failed decision mirror must never turn a successful channel/context record into a failure. */
+export function mirrorCoordDecision(input: CoordEventInput, deps: { ledger?: Pick<DecisionLedger, 'recordSeatDecision'> } = {}): void {
+  if (input.kind !== '결정') return;
+  try {
+    if (!registeredSeats().some(({ id }) => id === input.seat)) return;
+    const entry = (deps.ledger ?? new DecisionLedger()).recordSeatDecision({
+      seat: input.seat as Seat,
+      title: input.slot ? redactSecretText(input.slot.split(/\r?\n/, 1)[0] ?? '').trim() : cleanCoordHeadline(input.headline),
+      decision: cleanCoordHeadline(input.headline),
+      delegation: '조율 채널 — 자리 위임 범위',
+      ...(input.url ? { refs: [input.url] } : {}),
+      decidedAt: input.at ?? new Date().toISOString(),
+    });
+    try { debug.log('context.coord', 'decision-mirrored', { seat: entry.seat, id: entry.id }); }
+    catch { /* observation cannot turn a successful write into a failed send */ }
+  } catch (error) {
+    if (error instanceof Error && error.message === 'seat decision source already recorded') return;
+    try { debug.log('context.coord', 'decision-mirror-failed', { seat: redactSecretText(input.seat) }); }
+    catch { /* observation cannot turn a successful send into a failure */ }
+  }
+}
+
 /** Read-only chronological list; a missing store is an empty ledger, not a newly created one. */
 export function listCoordEvents(opts: { since: string; seat?: string; channelOnly?: boolean }, deps: { db?: Database } = {}): CoordEvent[] {
   if (!deps.db && !existsSync(surfaceEventsDbPath())) return [];