elanous 0.2.37 → 0.2.40

package/src/cli/review-carry.ts

@@ -0,0 +1,77 @@
+/** Prove that a PR's new head is exactly a clean merge of main into its reviewed head. */
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { delimiter, join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const SHA = /^[0-9a-f]{40}$/i;
+const MAX = 32 * 1024 * 1024;
+
+export type ReviewCarryProof = { ok: true; oldBase: string; newBase: string; patchId: string; pathsModesHash: string }
+  | { ok: false; reason: string };
+
+/** No refs, index, or worktree are changed. merge-tree objects live in a disposable directory. */
+export function proveReviewCarry(cwd: string, oldHead: string, newHead: string, remote = 'origin', branch = 'main'): ReviewCarryProof {
+  if (!SHA.test(oldHead) || !SHA.test(newHead) || oldHead === newHead) return { ok: false, reason: 'carry-invalid-head' };
+  const run = (args: string[], env?: NodeJS.ProcessEnv, input?: string) => spawnSync('git', args,
+    { cwd, env, input, encoding: 'utf8', maxBuffer: MAX });
+  const read = (args: string[], env?: NodeJS.ProcessEnv): string | null => {
+    const result = run(args, env);
+    return result.status === 0 && !result.error ? result.stdout.trim() : null;
+  };
+  const parents = read(['rev-list', '--parents', '-n', '1', newHead])?.split(/\s+/);
+  if (!parents || parents.length !== 3 || parents[0]?.toLowerCase() !== newHead.toLowerCase()
+    || parents[1]?.toLowerCase() !== oldHead.toLowerCase() || !SHA.test(parents[2] ?? '')) {
+    return { ok: false, reason: 'carry-not-direct-main-merge' };
+  }
+  const newBase = parents[2]!.toLowerCase();
+  const main = read(['rev-parse', '--verify', `refs/remotes/${remote}/${branch}`]);
+  if (!main || !SHA.test(main) || run(['merge-base', '--is-ancestor', newBase, main]).status !== 0) {
+    return { ok: false, reason: 'carry-main-parent-unmeasured' };
+  }
+  const oldBase = read(['merge-base', oldHead, newBase]);
+  if (!oldBase || !SHA.test(oldBase)) return { ok: false, reason: 'carry-old-base-unmeasured' };
+  if (oldBase.toLowerCase() === oldHead.toLowerCase()) return { ok: false, reason: 'carry-no-pr-patch' };
+  const objects = read(['rev-parse', '--git-path', 'objects']);
+  if (!objects) return { ok: false, reason: 'carry-object-directory-unmeasured' };
+  let temporary: string;
+  try { temporary = mkdtempSync(join(tmpdir(), 'elanous-review-carry-')); }
+  catch { return { ok: false, reason: 'carry-temp-directory-unmeasured' }; }
+  const env = { ...process.env, GIT_OBJECT_DIRECTORY: temporary,
+    GIT_ALTERNATE_OBJECT_DIRECTORIES: [resolve(cwd, objects), process.env.GIT_ALTERNATE_OBJECT_DIRECTORIES].filter(Boolean).join(delimiter) };
+  try {
+    const mergedTree = read(['merge-tree', '--write-tree', oldHead, newBase], env);
+    if (!mergedTree || !SHA.test(mergedTree)) return { ok: false, reason: 'carry-merge-conflict-or-unmeasured' };
+    const actualTree = read(['rev-parse', '--verify', `${newHead}^{tree}`]);
+    if (!actualTree || actualTree.toLowerCase() !== mergedTree.toLowerCase()) {
+      return { ok: false, reason: 'carry-merge-tree-changed' };
+    }
+    const changed = (from: string, to: string, objectEnv?: NodeJS.ProcessEnv) => {
+      const raw = run(['diff', '--raw', '--no-renames', '--no-abbrev', '-z', from, to], objectEnv);
+      const numstat = read(['diff', '--numstat', from, to], objectEnv);
+      const diff = read(['diff', '--no-ext-diff', '--no-renames', '--binary', from, to], objectEnv);
+      if (raw.status !== 0 || raw.error || numstat === null || !diff) return null;
+      if (numstat.split('\n').some((line) => /^-\t-\t/.test(line))) return null;
+      const fields = raw.stdout.split('\0').filter(Boolean);
+      if (!fields.length || fields.length % 2 !== 0) return null;
+      const pathsModes: string[] = [];
+      for (let i = 0; i < fields.length; i += 2) {
+        const match = /^:([0-7]{6}) ([0-7]{6}) [0-9a-f]{40,64} [0-9a-f]{40,64} ([A-Z])$/i.exec(fields[i]!);
+        if (!match || !fields[i + 1] || !['A', 'M', 'D', 'T'].includes(match[3]!)) return null;
+        pathsModes.push(`${match[3]}\0${match[1]}\0${match[2]}\0${fields[i + 1]}`);
+      }
+      const patched = run(['patch-id', '--stable'], objectEnv, `${diff}\n`);
+      const patchId = patched.status === 0 && !patched.error ? patched.stdout.trim().split(/\s+/)[0] : null;
+      return patchId && SHA.test(patchId) ? { patchId: patchId.toLowerCase(), pathsModes: pathsModes.sort() } : null;
+    };
+    const before = changed(oldBase, oldHead);
+    const after = changed(newBase, newHead);
+    if (!before || !after) return { ok: false, reason: 'carry-patch-unmeasured' };
+    if (before.patchId !== after.patchId || JSON.stringify(before.pathsModes) !== JSON.stringify(after.pathsModes)) {
+      return { ok: false, reason: 'carry-patch-or-path-mode-changed' };
+    }
+    return { ok: true, oldBase: oldBase.toLowerCase(), newBase, patchId: before.patchId,
+      pathsModesHash: createHash('sha256').update(JSON.stringify(before.pathsModes)).digest('hex') };
+  } finally { rmSync(temporary, { recursive: true, force: true }); }
+}

package/src/cli/self-update.ts

@@ -496,7 +496,7 @@ export function assessRailSafe(input: AssessRailSafeInput): {
   const heldVersions = plan.removed.filter((name) => {
     const path = join(input.versionsDir, name);
     try {
-      return listedProcessCommands(listProcesses(pgrepPathPattern(path)), readCommand).some((argv) => argv.includes(path));
+      return listedProcessCommands(listProcesses(pgrepPathPattern(path)), readCommand).some((argv) => argvReferencesVersion(argv, path));
     } catch { return false; }
   });
   let releaseRunActive = false;

package/src/cli/tasks-card-show.ts

@@ -5,6 +5,8 @@ import { readCardSalvageBranch, refreshCardRunBinding } from '../task-agent/card
 import { captureReviewResults } from '../task-agent/review-result-capture.js';
 import type { TasksCliDeps } from './tasks-cli.js';
 import { registerTaskAgentSink } from './tasks-read-cli.js';
+import { readFileSync } from 'node:fs';
+import { loadGoalAskRecords } from '../self-implement/goal-ask-store.js';
 
 /**
  * CLI-ENTRY-LAZY — `tasks show ta-…`(TASK-AGENT 과제 카드) 상세. `tasks-read-cli.ts` 가 카드 id 일 때만 싣는다.
@@ -30,6 +32,34 @@ function moveLine(card: TaskCard): string {
   return `${move.kind}${move.command ? ` — elanous ${move.command.map(shellQuote).join(' ')}` : ''} (${move.reason})`;
 }
 
+const GOAL_BODY_SUMMARY_LIMIT = 8_000;
+
+function cardGoalEvidence(card: TaskCard, deps: TasksCliDeps): {
+  goalFile: string | null; goalBody: string | null; hasTddPlan: boolean | null;
+  hasBoundary: boolean | null; knowhowInjected: boolean | null;
+} {
+  let document: { goalFile: string; goalBody: string } | null = null;
+  try {
+    if (card.goalId && deps.cardGoalDocument) document = deps.cardGoalDocument(card.goalId);
+    else if (card.goalId) {
+      const record = loadGoalAskRecords({ goalId: card.goalId, limit: 1 })[0];
+      if (record) document = { goalFile: record.goalFile, goalBody: readFileSync(record.goalFile, 'utf8') };
+    }
+  } catch (error) {
+    try { debug.log('task-agent', 'card-goal-read-failed', { cardId: card.id, goalId: card.goalId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+  }
+  if (!document) return { goalFile: null, goalBody: null, hasTddPlan: null, hasBoundary: null, knowhowInjected: null };
+  const body = document.goalBody;
+  const hasTddPlan = /^#{1,6}\s+.*(?:TDD|test[- ]driven|테스트 주도).*$/im.test(body);
+  const hasBoundary = /(?:완료 경계|완료 조건|acceptance criteria|completion boundary)/i.test(body);
+  const knowhowInjected = /\[KNOWHOW-PACK\b[^\]]*\]/i.test(body);
+  return {
+    goalFile: document.goalFile,
+    goalBody: body.length <= GOAL_BODY_SUMMARY_LIMIT ? body : `${body.slice(0, GOAL_BODY_SUMMARY_LIMIT)}… [truncated]`,
+    hasTddPlan, hasBoundary, knowhowInjected,
+  };
+}
+
 export function headLine(text: string): string {
   const first = text.split('\n')[0]!.trim();
   return first.length > 100 ? `${first.slice(0, 100)}…` : first;
@@ -152,7 +182,7 @@ export async function showTaskCard(id: string, opts: { json?: boolean }, deps: T
   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 } : {}) }));
+  if (opts.json) out(JSON.stringify({ card, nextMove: nextMoveFor(card), ...cardGoalEvidence(card, deps), 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}` : ''}`);

package/src/cli/tasks-cli.ts

@@ -90,6 +90,8 @@ export interface TasksCliDeps {
   adoptRunTerminal?: typeof import('../task-agent/adopt-pr.js').adoptedRunTerminal;
   /** `tasks show`·`advance` 의 런 근거 읽기(시험 주입) — 기본 = 런 원장(이 우주 ⊕ 연합) ⊕ 호스트 logs 의 Pod job-finished. */
   cardRunEvidence?: CardRunEvidenceDeps;
+  /** `tasks show --json` 의 저작 골 파일 조회(시험 주입). null 은 골 연결을 확인하지 못한 상태다. */
+  cardGoalDocument?: (goalId: string) => { goalFile: string; goalBody: string } | null;
   /** `tasks live-verified` 가 적는 런 원장 디렉터리(시험 주입). 기본 = `runLedgerDir()`. */
   liveVerifiedLedgerDir?: string;
   /** HARNESS-PARENT-ON-MSB1 — 원격 부모 카드의 원장 거울(시험 주입). 기본 = ssh 로 `<prodRoot>/remote-parents/<host>/run-ledger`. */
@@ -189,8 +191,6 @@ export interface DefaultTaskLauncherDeps {
   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; 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. */
@@ -205,6 +205,18 @@ export interface DefaultTaskLauncherDeps {
 
 class NoEligibleOwnerCodexAccountError extends Error {}
 
+/** Only declared Pod launch switches cross from HQ to the remote parent. */
+export function podParentLaunchSelectors(contextEnv: Record<string, string>, inheritedEnv: NodeJS.ProcessEnv): Record<string, string> {
+  const selectors: Record<string, string> = {};
+  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 = contextEnv[key] ?? inheritedEnv[key];
+    if (value !== undefined) selectors[key] = value;
+  }
+  const inplace = contextEnv.ELANOUS_POD_INPLACE_WORKTREE ?? inheritedEnv.ELANOUS_POD_INPLACE_WORKTREE;
+  if (inplace !== undefined) selectors.ELANOUS_POD_INPLACE_WORKTREE = inplace === '1' ? '1' : '0';
+  return selectors;
+}
+
 /**
  * HARNESS-PARENT-ON-MSB1 — 켜져 있고 발사 전 점검이 통과하면 원격(ssh)에서 부모를 띄운다(PR 까지만 · 병합은 HQ).
  * 막히면 null — 호출부가 종전 로컬 발사로 간다(관측: task-agent parent-host-fallback).
@@ -223,9 +235,21 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
     ?? (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 provisionRequests = new Set<string>();
+  const provision = (host: string, reason: string): void => {
+    const key = `${host}:${reason}`;
+    if (provisionRequests.has(key)) return;
+    provisionRequests.add(key);
+    try { debug.log('task-agent.parent-host', 'provision-requested', { host, runId: context.runId, provider: effectiveChildProvider ?? 'openai-codex', reason }); } catch { /* fail-soft */ }
+    notice(`[parent-host] ${host} provision 요청 — ${reason}; 준비 완료 전 배정 대기`);
+  };
   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(' · ')}`);
+    // grok-credential-* 은 호스트가 스스로 보고한 자체 자격 상태다 — 무효면 OP 재로그인 요청이 나간다.
+    const provisionGaps = ['grok-cli-missing', 'codex-cli-missing', 'grok-credential-missing', 'grok-credential-expiring', 'grok-credential-expired', 'codex-access-mirror-unavailable'];
+    const missing = gaps.every((gap) => provisionGaps.includes(gap)) ? gaps : [];
+    notice(`[parent-host] ${target.host} 로 못 띄움 — ${missing.length ? '공급자 준비 뒤 재시도' : multi ? '다음 호스트 또는 로컬 발사로 간다' : '로컬 발사로 간다'}: ${gaps.join(' · ')}`);
+    for (const gap of missing) provision(target.host, gap);
   };
   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;
@@ -313,11 +337,9 @@ 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;
+  // GROK-MIRROR-REAL-SCOPE: HQ does not select or copy its own Grok access for a remote parent. Each host keeps
+  // its own device-auth session, and the preflight below blocks the Grok child when the host reports it invalid
+  // (grok-credential-*) — that gap drives the OP re-login request instead of a silent local fallback.
   let launchHoldActive = false;
   try {
     if (deps.launchHoldActive) launchHoldActive = deps.launchHoldActive();
@@ -328,7 +350,7 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
     }
   } catch { launchHoldActive = true; /* 못 읽으면 막힌 것으로(fail-closed) */ }
   const podGoal = context.substrate === 'pod' ? context.podGoal : undefined;
-  // 부모에서 잰 메모리 선택자만 원격 자식에도 넘긴다. 로컬의 나머지 환경·자격은 SSH 로 복사하지 않는다.
+  // Pod 선택자만 원격 부모에 넘긴다. 로컬의 나머지 환경·자격은 SSH 로 복사하지 않는다.
   const remoteEnv = { ...context.env };
   // These labels describe an HQ-selected Codex access mirror; never forward an inherited label by itself.
   delete remoteEnv.ELANOUS_REMOTE_CODEX_ACCOUNT;
@@ -336,10 +358,7 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
   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;
-  }
+  if (podGoal) Object.assign(remoteEnv, podParentLaunchSelectors(context.env, process.env));
   const memoryLimit = podGoal ? (await import('../task-orchestrator/surfaces/self-implement-pod.js')).podMemoryLimitFor(podGoal, remoteEnv).limit : undefined;
   const fits = Object.fromEntries(targets.map((target) => {
     const fit = memoryLimit
@@ -354,7 +373,9 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
     const details = targets.map((target) => `${target.host}: Pod ${fits[target.host]!.memoryLimit} (${fits[target.host]!.requiredBytes} bytes) > node allocatable ${fits[target.host]!.allocatableBytes} bytes`).join(' · ');
     throw new Error(`parent-host memory-never-fits — ${details}; local fallback refused`);
   }
-  const capacities = Object.fromEntries(multi ? eligible.map((target) => [target.host, parentHostModule.readParentHostCapacity(target, deps.ssh)]) : []);
+  const capacities: Record<string, import('../task-agent/parent-host.js').ParentHostCapacity | null> = Object.fromEntries(
+    multi ? eligible.map((target) => [target.host, parentHostModule.readParentHostCapacity(target, deps.ssh)]) : [],
+  );
   const measured = eligible.filter((target) => fits[target.host]?.state === 'fits');
   const unknown = eligible.filter((target) => fits[target.host]?.state !== 'fits');
   const ranked = multi
@@ -372,11 +393,14 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
   };
   for (const target of ordered) {
     if (multi && (!capacities[target.host] || capacities[target.host]!.approvalHeadroom <= 0)) {
-      failed(target, ['capacity-unavailable']);
+      const capacity = capacities[target.host];
+      failed(target, [`capacity-unavailable · ${capacity
+        ? `host active=${capacity.active} waiting=${capacity.waiting} limit=${capacity.limit} headroom=${capacity.headroom}`
+        : 'measurement=unknown'}`]);
       continue;
     }
     let preflight: ReturnType<typeof parentHostModule.preflightParentHost>;
-    try { preflight = parentHostModule.preflightParentHost({ target, localVersion: deps.localVersion ?? parentHostModule.localElanousVersion(), launchHoldActive, ...(deps.ssh ? { ssh: deps.ssh } : {}) }); }
+    try { preflight = parentHostModule.preflightParentHost({ target, localVersion: deps.localVersion ?? parentHostModule.localElanousVersion(), launchHoldActive, childProvider: effectiveChildProvider ?? 'openai-codex', ...(deps.ssh ? { ssh: deps.ssh } : {}) }); }
     catch (error) { failed(target, [`preflight-error: ${error instanceof Error ? error.message : String(error)}`]); continue; }
     if (!preflight.ok) { failed(target, preflight.gaps, preflight.facts); continue; }
     if (preflight.warnings.length) notice(`⚠ ${target.host} 자격: ${preflight.warnings.join(' · ')}`);
@@ -422,8 +446,7 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
         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']);
-          recordHostRanking(null);
-          return null;
+          continue;
         }
         if (selected?.account) {
           remoteEnv.ELANOUS_REMOTE_CODEX_ACCOUNT = selected.account;
@@ -433,8 +456,7 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
         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,
-        grokAccessMirror ? () => grokAccessMirror : undefined, effectiveChildProvider, deps.now);
+      const launched = parentHostModule.launchRemoteParent(target, args, remoteEnv, deps.ssh, effectiveChildProvider);
       recordHostRanking(target.host);
       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 } };
@@ -447,6 +469,7 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
     }
   }
   recordHostRanking(null);
+  if (provisionRequests.size > 0) throw new Error(`parent-host-provision-pending: ${[...provisionRequests].join(', ')}; no child provider host launched`);
   return null;
 }
 
@@ -820,7 +843,7 @@ export function coverCardsInWindow(cards: readonly CoverCardRow[] | null, window
 }
 
 /** Read the card ledger itself. A missing file or malformed row makes the aggregate unknown. */
-function readImplementCardBindings(statePath: string): ImplementCardRunBinding[] {
+function readImplementCardBindings(statePath: string): { bindings: ImplementCardRunBinding[]; cleanup: Array<{ cardId: string; outcome: 'complete' | 'partial'; at: string }> | null } {
   if (!existsSync(statePath)) throw new Error('TASK-AGENT card ledger is missing');
   const state = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath);
   if (state.tasks !== undefined && (!state.tasks || typeof state.tasks !== 'object' || Array.isArray(state.tasks))) {
@@ -828,14 +851,38 @@ function readImplementCardBindings(statePath: string): ImplementCardRunBinding[]
   }
   const cards = Object.entries(state.tasks ?? {});
   if (cards.length >= COVER_QUERY_LIMIT) throw new Error('TASK-AGENT card ledger reached query bound');
-  return cards.map(([key, card]) => {
+  const bindings: ImplementCardRunBinding[] = [];
+  const cleanup: Array<{ cardId: string; outcome: 'complete' | 'partial'; at: string }> = [];
+  let cleanupUnreadable = false;
+  for (const [key, card] of cards) {
     if (!card || typeof card !== 'object' || Array.isArray(card) || typeof card.id !== 'string' || !card.id
       || card.id !== key || (card.runId != null && typeof card.runId !== 'string')
       || (card.runChildId != null && typeof card.runChildId !== 'string')) {
       throw new Error('TASK-AGENT card binding is malformed');
     }
-    return { cardId: card.id, runId: card.runId, runChildId: card.runChildId };
-  });
+    bindings.push({ cardId: card.id, runId: card.runId, runChildId: card.runChildId });
+    if (card.postLand === undefined) continue;
+    const post = card.postLand;
+    if (!post || (post.outcome !== 'complete' && post.outcome !== 'partial')
+      || !Number.isSafeInteger(post.pr) || typeof post.head !== 'string' || !post.head
+      || typeof post.at !== 'string' || !Number.isFinite(Date.parse(post.at))
+      || !Array.isArray(card.history)) { cleanupUnreadable = true; continue; }
+    if (card.history.some((event) => !event || typeof event !== 'object')) { cleanupUnreadable = true; continue; }
+    if (card.status !== 'done' || card.prTerminal?.state !== 'MERGED'
+      || card.prTerminal.pr !== post.pr || typeof card.prTerminal.head !== 'string'
+      || card.prTerminal.head.toLowerCase() !== post.head.toLowerCase()) continue;
+    // A same-outcome reconciliation refreshes postLand.at without appending another history event.
+    const sourceEvents = card.history.filter((event) => event.event === 'postland-card' && event.pr === post.pr
+      && typeof event.head === 'string' && event.head.toLowerCase() === post.head.toLowerCase());
+    if (sourceEvents.length === 0) continue;
+    if (sourceEvents.some((event) => typeof event.at !== 'string' || !Number.isFinite(Date.parse(event.at)))) {
+      cleanupUnreadable = true;
+      continue;
+    }
+    const sourceAt = sourceEvents[sourceEvents.length - 1]!.at;
+    cleanup.push({ cardId: card.id, outcome: post.outcome, at: sourceAt });
+  }
+  return { bindings, cleanup: cleanupUnreadable ? null : cleanup };
 }
 
 function implementLedgerDirectories(statePath: string, includeTest: boolean): string[] {
@@ -964,10 +1011,13 @@ export function readTaskAgentCover(
   };
   // A supplied reader overrides only its own source. The ordinary CLI always reads both physical ledgers.
   try {
-    input.implementCardRuns = goalReaders.coverImplementCardRuns
-      ? goalReaders.coverImplementCardRuns()
-      : readImplementCardBindings(goalReaders.taskStatePath ?? taskStatePathDefault());
-  } catch { input.implementCardRuns = null; }
+    if (goalReaders.coverImplementCardRuns) input.implementCardRuns = goalReaders.coverImplementCardRuns();
+    else {
+      const { bindings, cleanup } = readImplementCardBindings(goalReaders.taskStatePath ?? taskStatePathDefault());
+      input.implementCardRuns = bindings;
+      input.cleanupCards = cleanup?.filter((card) => inWindow(card.at)) ?? null;
+    }
+  } catch { input.implementCardRuns = null; input.cleanupCards = null; input.implementReadFailure = 'card-ledger-unreadable'; }
   try {
     input.implementRunMerges = goalReaders.coverImplementRunMerges
       ? goalReaders.coverImplementRunMerges()
@@ -978,7 +1028,7 @@ export function readTaskAgentCover(
           implementLedgerDirectories(goalReaders.taskStatePath ?? taskStatePathDefault(), goalReaders.coverIncludeTest === true),
           window,
         );
-  } catch { input.implementRunMerges = null; }
+  } catch { input.implementRunMerges = null; input.implementReadFailure ??= 'run-ledger-unreadable'; }
   const orders = orderRead && !orderRead.limitReached ? coverEvents(orderRead.rows, 'task-agent.land-order', 'appended', (data) =>
     Number.isSafeInteger(data.pr) ? { pr: data.pr as number } : null) : null;
   const landSignals: CoverLandSignals = {
@@ -2486,14 +2536,17 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .option('--card <id>', '기존 launched 카드(미바인딩 또는 같은 PR이 등록부에서 바인딩됨)')
     .option('--checklist <id>', '새 카드에 붙일 체크리스트 칸')
     .option('--version <version>', '체크리스트 판(기존 카드에도 고정 가능)')
+    .option('--rebind', '옛 판 또는 failed 카드의 기존 PR 결속을 풀고 지정 판의 새 카드로 원자 이동')
     .option('--unlinked-terminal', '기존 카드의 모든 구현 자식이 종결되고 PR 사건이 전혀 없을 때만 별도로 열린 PR을 명시적으로 입양')
     .option('--json', 'JSON 출력')
-    .action(async (value: string, opts: { card?: string; checklist?: string; version?: string; unlinkedTerminal?: boolean; json?: boolean }) => {
+    .action(async (value: string, opts: { card?: string; checklist?: string; version?: string; rebind?: boolean; unlinkedTerminal?: boolean; json?: boolean }) => {
       await registerTaskAgentSink(deps.registerSink);
       try {
         if (!/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value))) throw new Error(`PR 번호가 아니다: ${value}`);
         if ((opts.card === undefined) === (opts.checklist === undefined))
           throw new Error('--card 또는 --checklist [--version] 중 하나만 준다');
+        if (opts.rebind && (opts.card || !opts.checklist || !opts.version || opts.unlinkedTerminal))
+          throw new Error('--rebind는 --checklist와 --version을 지정하고 --card/--unlinked-terminal은 생략한다');
         if (opts.unlinkedTerminal && !opts.card) throw new Error('--unlinked-terminal은 --card와 함께 준다');
         if (opts.version) validateVersion(opts.version);
         let cardVersion = opts.version;
@@ -2534,15 +2587,28 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         const linkedEvidence = targetCard ? checkRun(targetCard, view) : undefined;
         const terminalRunEvidence = linkedEvidence || (opts.unlinkedTerminal && targetCard ? checkRun(targetCard, view, undefined, true) : false);
         const unlinkedTerminalUsed = opts.unlinkedTerminal === true && linkedEvidence !== true;
+        let rebindSource: { card: TaskCard; terminalRunEvidence: boolean } | undefined;
+        if (opts.rebind) {
+          const statePath = deps.taskStatePath ?? taskStatePathDefault();
+          const bound = Object.values(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath).tasks ?? {})
+            .filter((card) => cardPrNumber(card) === number);
+          if (bound.length !== 1) throw new Error(bound.length
+            ? `PR #${number}가 여러 카드에 묶였다 — 임의로 rebind하지 않는다`
+            : `PR #${number}가 기존 카드에 묶이지 않았다 — --rebind 대상 없음`);
+          const source = bound[0]!;
+          rebindSource = { card: source, terminalRunEvidence: source.status === 'launched' ? checkRun(source, view) : false };
+        }
         const chosen = observedChecklist ?? checklist;
         const result = adoptExistingPr({ pr: view, repo, statePath: deps.taskStatePath ?? taskStatePathDefault(),
           ...(opts.card ? { cardId: opts.card, version: cardVersion, terminalRunEvidence, unlinkedTerminal: unlinkedTerminalUsed, observedChecklist,
             observedRun: { runId: targetCard?.runId, runChildId: targetCard?.runChildId, parentHost: targetCard?.parentHost?.host, launchId: targetCard?.launchId } } : {}),
+          ...(rebindSource ? { rebindSource } : {}),
+          ...(opts.rebind && opts.version ? { version: opts.version } : {}),
           ...(chosen ? { checklistAtWrite: () => (deps.adoptChecklist ?? listChecklist)(chosen.version).items.find((item) => item.id === chosen.id) } : {}),
           ...(checklist ? { checklist } : {}) });
         try { debug.log('task-agent', 'pr-adopted', { card: result.card.id, pr: number, head: view.headRefOid, created: result.created, changed: result.changed, launched: false }); } catch { /* fail-soft */ }
-        if (opts.json) out(JSON.stringify({ card: result.card.id, pr: number, head: view.headRefOid, created: result.created, changed: result.changed, next: `tasks rejudge ${result.card.id}` }));
-        else out(`${result.card.id}\tPR #${number}\t${result.changed ? 'adopted' : 'already-adopted'}\t구현 발사 0 · 다음: tasks rejudge ${result.card.id}`);
+        if (opts.json) out(JSON.stringify({ card: result.card.id, ...(result.previousCardId ? { previousCard: result.previousCardId } : {}), pr: number, head: view.headRefOid, created: result.created, changed: result.changed, next: `tasks rejudge ${result.card.id}` }));
+        else out(`${result.card.id}\tPR #${number}\t${result.changed ? 'adopted' : 'already-adopted'}${result.previousCardId ? ` · 이전 카드 ${result.previousCardId} 결속 해제` : ''}\t구현 발사 0 · 다음: tasks rejudge ${result.card.id}`);
       } catch (error) {
         out(error instanceof Error ? error.message : String(error));
         process.exitCode = 1;

package/src/cli/tasks-read-cli.ts

@@ -6,6 +6,7 @@ import { readNexusRuntime } from '../nexus/runtime.js';
 import { TASK_CARD_PREFIX } from '../task-agent/task-card-prefix.js';
 import type { Task } from '../task-orchestrator/types.js';
 import type { TasksCliDeps } from './tasks-cli.js';
+import { writeStdoutFully } from './stdout-flush.js';
 
 /**
  * CLI-ENTRY-LAZY — `tasks list`·`tasks show` 의 등록과 넥서스 조회 보조.
@@ -100,6 +101,7 @@ export function handleError(error: unknown, out: (line: string) => void): void {
 export interface TasksCliContext {
   deps: TasksCliDeps;
   out: (line: string) => void;
+  outFully: (line: string) => Promise<void>;
   authenticate: () => { baseUrl: string; token?: string };
   clearToken: () => void;
 }
@@ -107,9 +109,15 @@ export interface TasksCliContext {
 export function createTasksCliContext(deps: TasksCliDeps): TasksCliContext {
   let activeToken: string | undefined;
   const output = deps.output ?? console.log;
+  const maskToken = (line: string) => activeToken ? line.replaceAll(activeToken, '[redacted]') : line;
   return {
     deps,
-    out: (line: string) => output(activeToken ? line.replaceAll(activeToken, '[redacted]') : line),
+    out: (line: string) => output(maskToken(line)),
+    outFully: async (line: string) => {
+      const safeLine = maskToken(line);
+      if (deps.output) output(safeLine);
+      else await writeStdoutFully(safeLine);
+    },
     authenticate: () => {
       const auth = credentials(deps);
       activeToken = auth?.token;
@@ -126,7 +134,7 @@ export function registerTasksRoot(program: Command): Command {
 }
 
 export function registerTaskListCommand(tasks: Command, ctx: TasksCliContext): void {
-  const { deps, out, authenticate } = ctx;
+  const { deps, out, outFully, authenticate } = ctx;
   tasks.command('list')
     .description('우선순위와 생성 시각 순으로 태스크 보기')
     .option('--status <s>', '상태로 필터')
@@ -152,7 +160,7 @@ export function registerTaskListCommand(tasks: Command, ctx: TasksCliContext): v
           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));
+        if (opts.json) await outFully(JSON.stringify(rows));
         else {
           out('id\t우선순위\t상태\t승인\t출처\t제목');
           for (const row of rows) out(taskLine(row));
@@ -162,7 +170,7 @@ export function registerTaskListCommand(tasks: Command, ctx: TasksCliContext): v
 }
 
 export function registerTaskShowCommand(tasks: Command, ctx: TasksCliContext): void {
-  const { deps, out, authenticate } = ctx;
+  const { deps, out, outFully, authenticate } = ctx;
   tasks.command('show <id>')
     .description(`태스크 상세 보기 (id 가 \`${TASK_CARD_PREFIX}\` 로 시작하면 TASK-AGENT 과제 카드 ⊕ 다음 수)`)
     .option('--json', 'JSON 출력')
@@ -179,7 +187,7 @@ export function registerTaskShowCommand(tasks: Command, ctx: TasksCliContext): v
         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));
+        if (opts.json) await outFully(JSON.stringify(data));
         else {
           out(taskLine(data.task));
           out(JSON.stringify(data, null, 2));

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

@@ -16,7 +16,7 @@ import { filterPublicDemoContext } from './context-now-public.js';
 
 export type ContextFact =
   | { kind: 'version'; version: string; source: string }
-  | { kind: 'cell'; version: string; id: string; title: string; status: string; owner: string | null; source: string }
+  | { kind: 'cell'; version: string; id: string; title: string; status: string; owner: string | null; source: string; priority?: string | null }
   | { kind: 'decision'; id: string; title: string; status: string; dueAt: string | null; source: string }
   | { kind: 'seat'; seat: string; at: string; status: string; id: string | null; title: string | null; source: string }
   | { kind: 'run'; goal: string; phase: string; elapsed: string; source: string; unreadable?: string }
@@ -157,7 +157,8 @@ export function contextNow(options: { topic?: string; limit?: number; audience?:
     for (const item of checklist.items) {
       if (item.status === 'done') continue;
       facts.push({ kind: 'cell', version: v, id: item.id, title: redactSecretText(item.title.split(/\r?\n/, 1)[0] ?? '').slice(0, 120),
-        status: item.status, owner: item.owner ?? null, source: `elanous://release/${v}/checklist#${encodeURIComponent(item.id)}` });
+        status: item.status, owner: item.owner ?? null, priority: item.priority ?? null,
+        source: `elanous://release/${v}/checklist#${encodeURIComponent(item.id)}` });
     }
   }
   for (const item of (deps.decisions ?? (() => new DecisionLedger().list({ status: 'open' })))()) {
@@ -218,6 +219,89 @@ export function contextNow(options: { topic?: string; limit?: number; audience?:
   return options.audience === 'public-demo' ? filterPublicDemoContext(answer, deps.brandCheck) : answer;
 }
 
+export type AskOpContextTopic = 'release' | 'required' | 'train' | 'incident' | 'decision' | 'general';
+export type AskOpContextBundle = {
+  queriedAt: string;
+  topic: AskOpContextTopic;
+  facts: Array<{ kind: string; summary: string; source: string; observedAt: string }>;
+  gaps: Array<{ kind: string; reason: string }>;
+};
+
+function askOpTopic(question: string): AskOpContextTopic {
+  const text = question.toLocaleLowerCase();
+  if (/열차|착지|병합|merge|train|pull request|\bpr\b/.test(text)) return 'train';
+  if (/사고|장애|incident|failure|실패|에러|오류/.test(text)) return 'incident';
+  if (/결정|승인|decision|approval/.test(text)) return 'decision';
+  if (/필수|p0|must|required|우선순위/.test(text)) return 'required';
+  if (/발행|출시|릴리스|release|컷|cut|게이트|gate|이번 판|다음 판|판 진도|\b\d+\.\d+\.\d+\b/.test(text)) return 'release';
+  return 'general';
+}
+
+/** A small evidence packet for an OP answer. A missing source stays a gap, never an inferred fact. */
+export function buildAskOpContextBundle(
+  question: string,
+  snapshot: ContextNowAnswer,
+  options: { audience?: 'operator' | 'public-demo'; limit?: number } = {},
+): AskOpContextBundle {
+  const answer = options.audience === 'public-demo' ? filterPublicDemoContext(snapshot) : snapshot;
+  const topic = askOpTopic(question);
+  const limit = typeof options.limit === 'number' && Number.isFinite(options.limit)
+    ? Math.max(1, Math.min(20, Math.floor(options.limit))) : 8;
+  const facts: AskOpContextBundle['facts'] = [];
+  const gaps: AskOpContextBundle['gaps'] = [];
+  const pushFact = (kind: string, summary: string, source: string, observedAt: string) => {
+    if (facts.length < limit) facts.push({ kind, summary: oneLine(summary), source, observedAt });
+  };
+  const relevant = (kind: ContextFact['kind']) => topic === 'general'
+    || (topic === 'release' && (kind === 'release' || kind === 'version'))
+    || (topic === 'required' && kind === 'cell')
+    || (topic === 'decision' && kind === 'decision')
+    || (topic === 'incident' && kind === 'run');
+  for (const fact of answer.facts) {
+    if (!relevant(fact.kind)) continue;
+    if ('unreadable' in fact && fact.unreadable) {
+      gaps.push({ kind: fact.kind, reason: fact.unreadable });
+      continue;
+    }
+    if (topic === 'required' && fact.kind === 'cell' && fact.priority !== 'P0') continue;
+    if (topic === 'incident' && fact.kind === 'run' && !/fail|error|timeout|실패|오류|정지|중단/i.test(`${fact.phase} ${fact.goal}`)) continue;
+    if (topic === 'train') continue;
+    const summary = fact.kind === 'version' ? `판 ${fact.version}`
+      : fact.kind === 'cell' ? `${fact.id} ${fact.status} ${fact.title}`
+      : fact.kind === 'decision' ? `${fact.id} ${fact.status} ${fact.title}`
+      : fact.kind === 'seat' ? `${fact.seat} ${fact.status} ${fact.id ?? ''}`
+      : fact.kind === 'run' ? `${fact.goal} ${fact.phase} ${fact.elapsed}`
+      : fact.kind === 'release' ? `${fact.version} ${fact.node} ${fact.status}`
+      : `${fact.count ?? '미관측'}건 ${fact.names.join(', ')}`;
+    pushFact(fact.kind, summary, fact.source, fact.kind === 'seat' ? fact.at : answer.at);
+  }
+  const eventMatches = (kind: string, summary: string) => topic === 'general'
+    || (topic === 'train' && /train|열차|착지|병합|merge|\bpr\b/i.test(`${kind} ${summary}`))
+    || (topic === 'incident' && /incident|사고|장애|failure|실패|에러|오류|timeout/i.test(`${kind} ${summary}`));
+  for (const event of answer.events) {
+    if (eventMatches(event.kind, event.summary)) pushFact(event.kind, event.summary, event.source, event.at);
+  }
+  if (topic === 'required' && !facts.length) {
+    const cells = answer.facts.filter(fact => fact.kind === 'cell');
+    if (cells.some(fact => fact.priority == null)) gaps.push({ kind: 'cell', reason: '우선순위 미관측' });
+    else if (cells.length) gaps.push({ kind: 'cell', reason: '조회 범위에서 일치하는 P0 없음' });
+  }
+  if (!facts.length && !gaps.length) gaps.push({ kind: topic, reason: '미관측' });
+  if (topic === 'release' && !answer.facts.some(fact => fact.kind === 'release' && !('unreadable' in fact && fact.unreadable))
+    && !gaps.some(gap => gap.kind === 'release')) gaps.push({ kind: 'release', reason: '미관측' });
+  return { queriedAt: answer.at, topic, facts, gaps: gaps.slice(0, 3) };
+}
+
+/** Worker scan keeps ledger IO away from the OP inbox turn; the packet itself is bounded. */
+export async function askOpContextBundle(
+  question: string,
+  options: { audience?: 'operator' | 'public-demo'; limit?: number } = {},
+  readSnapshot: () => Promise<ContextNowAnswer> = () => contextNowInWorker({ audience: 'operator', limit: 100 }),
+): Promise<AskOpContextBundle> {
+  try { return buildAskOpContextBundle(question, await readSnapshot(), { ...options, audience: options.audience ?? 'public-demo' }); }
+  catch { return { queriedAt: new Date().toISOString(), topic: askOpTopic(question), facts: [], gaps: [{ kind: 'context', reason: '조회 실패' }] }; }
+}
+
 const workerAnswers = new Map<string, { promise: Promise<ContextNowAnswer>; expiresAt: number }>();
 const WORKER_ANSWER_TTL_MS = 5_000;
 const WORKER_SCAN_TIMEOUT_MS = 60_000;