elanous 0.2.37 → 0.2.40

package/src/steward/directive-audit.ts

@@ -0,0 +1,354 @@
+// COORD-DIRECTIVE-AUDIT — 지시 원장 행마다 «로직 점검» 을 실제로 실행하는 감사기.
+//
+// 입력: seat-state/OP/directives/CEO-VERBATIM-*.jsonl (ts·kind·원문·상황)
+//       ⊕ seat-state/OP/directives/DIRECTIVES-LEDGER-*.md (지시마다 «로직 점검» 열)
+// 로직: 행마다 점검(원장 · 로그 · config · 원문 hash 조회) 실행 → 거짓이면 «지시 미이행» 경보 ⊕ 수리 칸 제안.
+// 기록: debug.log('coordinator.directive-audit') · 경보·제안 JSONL.
+// 지침 문서 확인으로 갈음하지 않는다 — 판정은 이 코드가 돌려 만든 값이다.
+
+import { appendFileSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { directiveHash } from './directive.js';
+
+export const AUDIT_LOG_CATEGORY = 'coordinator.directive-audit';
+export const VERBATIM_PREFIX = 'CEO-VERBATIM-';
+export const LEDGER_PREFIX = 'DIRECTIVES-LEDGER-';
+export const ALERTS_FILE = 'DIRECTIVE-AUDIT-ALERTS.jsonl';
+export const PROPOSALS_FILE = 'DIRECTIVE-REPAIR-PROPOSALS.jsonl';
+
+const HASH_MARKER = /\[directive-hash:([0-9a-f]{64})\]/;
+
+export interface VerbatimDirective {
+  ts: string;
+  kind: string;
+  text: string;
+  situation?: string;
+  hash: string;
+}
+
+export interface LedgerRow {
+  id: string;
+  text: string;
+  /** «로직 점검» 열 원문 — 예: `log:coordinator.tick`, `config:a.b`, `file:path`. */
+  check: string;
+  hash: string | null;
+}
+
+export interface CheckResult {
+  check: string;
+  ok: boolean;
+  detail: string;
+}
+
+export interface DirectiveFinding {
+  directive: string;
+  hash: string | null;
+  status: 'ok' | 'mismatch';
+  reasons: string[];
+  checks: CheckResult[];
+}
+
+export interface DirectiveAlert {
+  kind: 'directive-unfulfilled';
+  directive: string;
+  hash: string | null;
+  reasons: string[];
+  at: string;
+}
+
+export interface RepairProposal {
+  id: string;
+  title: string;
+  body: string;
+  source: 'directive-audit';
+  at: string;
+}
+
+export interface DirectiveAuditReport {
+  at: string;
+  directives: number;
+  checked: number;
+  passed: number;
+  findings: DirectiveFinding[];
+  alerts: DirectiveAlert[];
+  proposals: RepairProposal[];
+  logged: boolean;
+}
+
+export interface DirectiveAuditDeps {
+  /** 격리 root — `file:` 점검의 기준점 겸 기본 원장 위치의 부모. */
+  root?: string;
+  /** 원장·원문 로그가 있는 디렉터리(생략 시 `<root>/seat-state/OP/directives`). */
+  dir?: string;
+  now?: () => Date;
+  readFile?: (path: string) => string | null;
+  listFiles?: (path: string) => string[];
+  /** config 조회(점 표기 키). 기본은 환경 변수 조회. */
+  config?: (key: string) => string | undefined;
+  /** 로그 조회. 기본은 debug 링 버퍼 꼬리. */
+  logLines?: () => string[];
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  recordAlert?: (alert: DirectiveAlert) => void;
+  proposeRepair?: (proposal: RepairProposal) => void;
+}
+
+const readFileOrNull = (path: string): string | null => {
+  try { return readFileSync(path, 'utf8'); } catch { return null; }
+};
+
+const listFilesIn = (path: string): string[] => {
+  try { return readdirSync(path).sort(); } catch { return []; }
+};
+
+/** 원문 jsonl → 지시 행. 행 식별자는 기존 `directiveHash` 규약(NFKC·공백압축·소문자)을 그대로 쓴다. */
+export function parseVerbatimJsonl(body: string): VerbatimDirective[] {
+  const out: VerbatimDirective[] = [];
+  for (const raw of body.split('\n')) {
+    const line = raw.trim();
+    if (line === '') continue;
+    let row: Record<string, unknown>;
+    try { row = JSON.parse(line) as Record<string, unknown>; } catch { continue; }
+    const text = typeof row.text === 'string' ? row.text : typeof row['원문'] === 'string' ? (row['원문'] as string) : '';
+    const ts = typeof row.ts === 'string' ? row.ts : '';
+    if (text.trim() === '') continue;
+    out.push({
+      ts,
+      kind: typeof row.kind === 'string' ? row.kind : 'directive',
+      text,
+      ...(typeof row.situation === 'string' ? { situation: row.situation } : {}),
+      hash: directiveHash(text),
+    });
+  }
+  return out;
+}
+
+const cells = (line: string): string[] =>
+  line.replace(/^\|/, '').replace(/\|$/, '').split('|').map(cell => cell.trim());
+
+const isSeparator = (line: string): boolean => {
+  const parts = cells(line);
+  return parts.length > 0 && parts.every(part => /^:?-{2,}:?$/.test(part));
+};
+
+/** 원장 마크다운 → 행. «로직 점검» 열과 `[directive-hash:<hash>]` 표기를 그대로 읽는다. */
+export function parseDirectivesLedger(body: string): LedgerRow[] {
+  const lines = body.split('\n');
+  const headerAt = lines.findIndex(line => line.trim().startsWith('|') && line.includes('로직 점검'));
+  if (headerAt < 0) return [];
+  const header = cells(lines[headerAt]!);
+  const checkIdx = header.findIndex(cell => cell.includes('로직 점검'));
+  const textIdx = header.findIndex(cell => cell.includes('원문'));
+  const hashIdx = header.findIndex(cell => /해시|hash/i.test(cell));
+  const idIdx = header.findIndex(cell => cell !== '' && !cell.includes('로직 점검') && !cell.includes('원문') && !/해시|hash/i.test(cell));
+
+  const rows: LedgerRow[] = [];
+  for (const line of lines.slice(headerAt + 1)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('|')) {
+      if (rows.length > 0) break;
+      continue;
+    }
+    if (isSeparator(trimmed)) continue;
+    const parts = cells(trimmed);
+    if (parts.every(part => part === '')) continue;
+    const marker = HASH_MARKER.exec(trimmed);
+    const hashCell = hashIdx >= 0 ? parts[hashIdx] ?? '' : '';
+    const cellMarker = HASH_MARKER.exec(hashCell);
+    const hash = cellMarker ? cellMarker[1]! : marker ? marker[1]! : null;
+    const id = (idIdx >= 0 ? parts[idIdx] ?? '' : '').replace(HASH_MARKER, '').trim();
+    const textCell = (textIdx >= 0 ? parts[textIdx] ?? '' : '').replace(/<!--[\s\S]*?-->/g, '').trim();
+    rows.push({
+      id: id !== '' ? id : textCell,
+      text: textCell !== '' ? textCell : id,
+      check: (parts[checkIdx] ?? '').replace(/<!--[\s\S]*?-->/g, '').trim(),
+      hash,
+    });
+  }
+  return rows;
+}
+
+const envConfig = (key: string): string | undefined => {
+  const direct = process.env[key];
+  if (direct !== undefined && direct !== '') return direct;
+  const mangled = `ELANOUS_${key.replace(/[^A-Za-z0-9]+/g, '_').toUpperCase()}`;
+  const viaEnv = process.env[mangled];
+  return viaEnv !== undefined && viaEnv !== '' ? viaEnv : undefined;
+};
+
+interface CheckContext {
+  baseDir: string;
+  dir: string;
+  read: (path: string) => string | null;
+  config: (key: string) => string | undefined;
+  logLines: () => string[];
+  verbatimHashes: Set<string>;
+}
+
+/** 점검 한 줄 실행 — 원장·로그·config·원문 hash 조회. */
+export function runCheck(check: string, ctx: CheckContext): CheckResult {
+  const spec = check.trim();
+  if (spec === '') return { check, ok: false, detail: '점검 없음 — 로직 점검 열이 비어 있다' };
+
+  const [kind, ...rest] = spec.split(':');
+  const arg = rest.join(':').trim();
+
+  if (kind === 'log') {
+    if (arg === '') return { check, ok: false, detail: 'log 점검에 카테고리가 없다' };
+    const hit = ctx.logLines().some(line => line.includes(arg));
+    return { check, ok: hit, detail: hit ? `로그에 ${arg} 발견` : `로그에 ${arg} 없음` };
+  }
+
+  if (kind === 'config') {
+    const [key, expected] = arg.split('=');
+    const value = ctx.config((key ?? '').trim());
+    const absent = value === undefined || value === '';
+    const ok = !absent && (expected === undefined || value === expected.trim());
+    return { check, ok, detail: absent ? `config ${key} 없음` : `config ${key}=${value}` };
+  }
+
+  if (kind === 'file') {
+    const body = ctx.read(arg.startsWith('/') ? arg : join(ctx.baseDir, arg));
+    const ok = body !== null && body.trim() !== '';
+    return { check, ok, detail: ok ? `파일 ${arg} 존재` : `파일 ${arg} 없음` };
+  }
+
+  if (kind === 'hash') {
+    const ok = ctx.verbatimHashes.has(arg);
+    return { check, ok, detail: ok ? `원문 hash ${arg.slice(0, 12)} 확인` : `원문 hash ${arg.slice(0, 12)} 없음` };
+  }
+
+  return { check, ok: false, detail: `알 수 없는 점검 형식: ${spec}` };
+}
+
+const defaultDir = (root: string | undefined): string =>
+  join(root ?? process.cwd(), 'seat-state', 'OP', 'directives');
+
+function buildContext(deps: DirectiveAuditDeps, dir: string, verbatimHashes: Set<string>): CheckContext {
+  return {
+    baseDir: deps.root ?? dir,
+    dir,
+    read: deps.readFile ?? readFileOrNull,
+    config: deps.config ?? envConfig,
+    logLines: deps.logLines ?? (() => debug.tail(400)),
+    verbatimHashes,
+  };
+}
+
+const proposalId = (hash: string | null, directive: string): string =>
+  `DIRREPAIR-${(hash ?? directiveHash(directive)).slice(0, 8)}`;
+
+/** 부작용 없는 점검 — 보고서만 만든다. */
+export function inspectDirectives(deps: DirectiveAuditDeps = {}): DirectiveAuditReport {
+  const at = (deps.now?.() ?? new Date()).toISOString();
+  const dir = deps.dir ?? defaultDir(deps.root);
+  const list = deps.listFiles ?? listFilesIn;
+  const read = deps.readFile ?? readFileOrNull;
+
+  const names = list(dir);
+  const verbatim = names
+    .filter(name => name.startsWith(VERBATIM_PREFIX) && name.endsWith('.jsonl'))
+    .flatMap(name => parseVerbatimJsonl(read(join(dir, name)) ?? ''));
+  const rows = names
+    .filter(name => name.startsWith(LEDGER_PREFIX) && name.endsWith('.md'))
+    .flatMap(name => parseDirectivesLedger(read(join(dir, name)) ?? ''));
+
+  const verbatimHashes = new Set(verbatim.map(row => row.hash));
+  const ctx = buildContext(deps, dir, verbatimHashes);
+  const findings: DirectiveFinding[] = [];
+  const alerts: DirectiveAlert[] = [];
+  const proposals: RepairProposal[] = [];
+
+  const alert = (directive: string, hash: string | null, reasons: string[], checks: CheckResult[]) => {
+    findings.push({ directive, hash, status: 'mismatch', reasons, checks });
+    alerts.push({ kind: 'directive-unfulfilled', directive, hash, reasons, at });
+    proposals.push({
+      id: proposalId(hash, directive),
+      title: `[수리 칸 제안] 지시 미이행 — ${directive}`,
+      body: [
+        `지시: ${directive}`,
+        hash === null ? 'directive-hash: (없음)' : `directive-hash: ${hash}`,
+        `불일치: ${reasons.join(' / ')}`,
+        '조치: 원장 «로직 점검» 열을 실제 근거(로그·config·산출물)로 고치거나, 지시를 이행한 뒤 근거를 남긴다.',
+      ].join('\n'),
+      source: 'directive-audit',
+      at,
+    });
+  };
+
+  for (const row of rows) {
+    const checks: CheckResult[] = [];
+    const reasons: string[] = [];
+    if (row.check === '') {
+      reasons.push('로직 점검 열이 비어 있다');
+    } else {
+      const result = runCheck(row.check, ctx);
+      checks.push(result);
+      if (!result.ok) reasons.push(`로직 점검 실패: ${row.check}`);
+    }
+    if (row.hash !== null && !verbatimHashes.has(row.hash)) {
+      reasons.push(`원문 로그에 없는 directive-hash: ${row.hash}`);
+    }
+    if (reasons.length > 0) {
+      alert(row.id, row.hash, reasons, checks);
+    } else {
+      findings.push({ directive: row.id, hash: row.hash, status: 'ok', reasons, checks });
+    }
+  }
+
+  for (const verbatimRow of verbatim) {
+    const covered = rows.some(row => row.hash === verbatimRow.hash);
+    if (covered) continue;
+    alert(verbatimRow.text, verbatimRow.hash, ['원장 행 없음 — 로직 점검 열이 없다'], []);
+  }
+
+  const checked = findings.filter(finding => finding.checks.length > 0).length;
+  const passed = findings.filter(finding => finding.status === 'ok').length;
+
+  return {
+    at,
+    directives: findings.length,
+    checked,
+    passed,
+    findings,
+    alerts,
+    proposals,
+    logged: false,
+  };
+}
+
+const appendJsonl = (path: string, row: unknown): void => {
+  mkdirSync(join(path, '..'), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(row)}\n`);
+};
+
+/**
+ * 조율자 틱마다 부르는 감사 진입점 — 점검 실행 → 경보·수리 제안 기록 →
+ * debug.log('coordinator.directive-audit').
+ */
+export function runDirectiveAudit(deps: DirectiveAuditDeps = {}): DirectiveAuditReport {
+  const report = inspectDirectives(deps);
+  if (report.directives === 0) return report;
+
+  const dir = deps.dir ?? defaultDir(deps.root);
+  const recordAlert = deps.recordAlert ?? ((alert: DirectiveAlert) => appendJsonl(join(dir, ALERTS_FILE), alert));
+  const proposeRepair = deps.proposeRepair ?? ((proposal: RepairProposal) => appendJsonl(join(dir, PROPOSALS_FILE), proposal));
+
+  for (const alert of report.alerts) recordAlert(alert);
+  for (const proposal of report.proposals) proposeRepair(proposal);
+
+  const data = {
+    directives: report.directives,
+    checked: report.checked,
+    passed: report.passed,
+    alerts: report.alerts.length,
+  };
+  const message = report.alerts.length === 0
+    ? `지시 원장 점검 ${report.directives}행 · 불일치 0`
+    : `지시 원장 점검 ${report.directives}행 · 불일치 ${report.alerts.length}`;
+
+  const log = deps.log ?? ((category: string, event: string, payload: Record<string, unknown>) => debug.log(category, event, payload));
+  log(AUDIT_LOG_CATEGORY, message, data);
+
+  return { ...report, logged: true };
+}

package/src/storage/file-lock.ts

@@ -70,13 +70,26 @@ export function acquireLockSync(lockPath: string, opts: LockOpts = {}): ReleaseL
   for (let attempt = 0; attempt < maxTries; attempt += 1) {
     try {
       const fd = openSync(lockPath, 'wx');
-      try { writeSync(fd, `${process.pid}\n`); }
-      catch { /* metadata only · not fatal */ }
-      const acquired = fstatSync(fd);
+      try {
+        writeSync(fd, `${process.pid}\n`);
+      } catch (writeErr) {
+        // 보유자 PID 를 못 쓰면 holderIsDead·onWait 독자 계약이 깨진다 — 방금 'wx' 로 만든 파일을 정리하고 올린다.
+        try { closeSync(fd); } catch { /* ignore */ }
+        try { unlinkSync(lockPath); } catch { /* ignore */ }
+        throw writeErr;
+      }
+      // ⭐ 소유 증명은 파일 «내용»이 아니라 «정체»다 — 내용은 보유자 PID 한 줄 계약(test/storage-file-lock ·
+      //   goal-author supersession 잠금)이라 구분 토큰을 심을 수 없고, rm+즉시 재생성은 inode 번호를
+      //   재사용하므로 inode 만으로는 교체를 못 가린다(실측). dev·ino·mtimeNs 셋이 같을 때만 우리가 만든
+      //   그 파일로 본다 — 재사용된 inode 도 새 mtime 을 가지므로 교체 자물쇠는 mtimeNs 에서 갈린다.
+      const acquired = fstatSync(fd, { bigint: true });
       closeSync(fd);
       return () => {
         try {
-          if (statSync(lockPath).ino === acquired.ino) unlinkSync(lockPath);
+          const current = statSync(lockPath, { bigint: true });
+          if (current.dev === acquired.dev && current.ino === acquired.ino && current.mtimeNs === acquired.mtimeNs) {
+            unlinkSync(lockPath);
+          }
         } catch { /* stale recovery or replacement won the path */ }
       };
     } catch (err) {

package/src/surface/child-process.ts

@@ -0,0 +1,31 @@
+/** Forward a piped child stderr stream through the current surface's stderr
+ *  owner. TUI boot captures this stream into logs and one-line notices. */
+export function forwardChildStderr(stream: NodeJS.ReadableStream | null | undefined): void {
+  stream?.on('data', (chunk: Buffer | string) => process.stderr.write(chunk));
+}
+
+/** Shared child-process boundary for commands that need terminal progress.
+ *  stdin is closed, stdout/stderr are piped, and stderr is forwarded through
+ *  the owning surface's stderr stream, so TUI boot can turn it into a log
+ *  entry and a one-line notice. */
+export function spawnWithOwnedStderr(
+  command: string[],
+  options: Omit<Bun.SpawnOptions.OptionsObject<'ignore', 'pipe', 'pipe'>, 'cmd' | 'stdin' | 'stdout' | 'stderr'> = {},
+): ReturnType<typeof Bun.spawn> {
+  const child = Bun.spawn(command, { ...options, stdin: 'ignore', stdout: 'pipe', stderr: 'pipe' });
+  if (child.stderr) {
+    const reader = child.stderr.getReader();
+    void (async () => {
+      try {
+        while (true) {
+          const next = await reader.read();
+          if (next.done) break;
+          process.stderr.write(next.value);
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    })();
+  }
+  return child;
+}

package/src/surface/tui-stderr-owner.ts

@@ -0,0 +1,48 @@
+import { debug } from '../debug/log.js';
+
+export type TuiStderrNotice = (line: string) => void;
+
+/** Take ownership of writes made through the TUI process' stderr stream.
+ *  Raw bytes go to the normal debug log; the presentation surface receives
+ *  bounded one-line notices. Child processes must still use piped stderr:
+ *  an OS-level fd 2 inherited by a child bypasses this JavaScript stream. */
+export function installTuiStderrOwner(notice: TuiStderrNotice): () => void {
+  const stderr = process.stderr;
+  const originalWrite = stderr.write;
+  let pending = '';
+  let active = true;
+
+  const emit = (raw: string): void => {
+    if (!raw) return;
+    try {
+      debug.log('tui.stderr', 'captured', { text: raw, byteLength: Buffer.byteLength(raw, 'utf8') });
+    } catch { /* capture must not re-open the physical stderr path */ }
+    const compact = raw.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '').replace(/\s+/g, ' ').trim();
+    if (compact) {
+      try { notice(compact.length > 240 ? `${compact.slice(0, 239)}…` : compact); }
+      catch { /* renderer failure must not overwrite the prompt */ }
+    }
+  };
+
+  const write = ((chunk: string | Uint8Array, encodingOrCallback?: BufferEncoding | ((error?: Error | null) => void), callback?: (error?: Error | null) => void): boolean => {
+    const text = typeof chunk === 'string'
+      ? chunk
+      : Buffer.from(chunk).toString(typeof encodingOrCallback === 'string' ? encodingOrCallback : 'utf8');
+    pending += text;
+    const lines = pending.split(/\r?\n/);
+    pending = lines.pop() ?? '';
+    for (const line of lines) emit(line);
+    if (typeof encodingOrCallback === 'function') encodingOrCallback();
+    else callback?.();
+    return true;
+  }) as typeof stderr.write;
+
+  stderr.write = write;
+  return () => {
+    if (!active) return;
+    active = false;
+    if (stderr.write === write) stderr.write = originalWrite;
+    emit(pending);
+    pending = '';
+  };
+}

package/src/task-agent/adopt-pr.ts

@@ -3,7 +3,7 @@ import { randomBytes } from 'node:crypto';
 import { loadRunLedger, runLedgerDir, type RunLedgerEntry } from '../self-implement/run-ledger.js';
 import { remoteLedgerMirrorDir } from './parent-host.js';
 import { prodInstanceRoot } from '../instance/resolve.js';
-import { cardPrNumber, updateTaskCard, type TaskCard } from './task-hand.js';
+import { cardPrNumber, updateTaskCard, updateTaskCardsAtomically, type TaskCard } from './task-hand.js';
 
 export interface AdoptPrView {
   number: number; url: string; state: string; baseRefName: string; headRefOid: string;
@@ -20,6 +20,9 @@ export interface AdoptPrInput {
   unlinkedTerminal?: boolean;
   observedRun?: { runId?: string; runChildId?: string; parentHost?: string; launchId?: string };
   observedChecklist?: { id: string; version: string; status: string; cardVersion?: string };
+  /** --rebind: source snapshot and terminal proof (computed before taking the state lock). */
+  rebindSource?: { card: Pick<TaskCard, 'id' | 'status' | 'runId' | 'runChildId' | 'launchId' | 'parentHost' | 'checklistId' | 'checklistVersion' | 'pr'>;
+    terminalRunEvidence: boolean };
   checklistAtWrite?: () => { id: string; status: string } | undefined;
 }
 
@@ -60,7 +63,7 @@ export function adoptedRunTerminal(card: TaskCard, pr: AdoptPrView,
 }
 
 /** The PR is read from the selected repository before this call; rejudge checks it again before every live move. */
-export function adoptExistingPr(input: AdoptPrInput): { card: TaskCard; created: boolean; changed: boolean } {
+export function adoptExistingPr(input: AdoptPrInput): { card: TaskCard; created: boolean; changed: boolean; previousCardId?: string } {
   const { pr } = input;
   const slug = pr.url.match(/^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/\d+\/?$/)?.[1];
   if (!Number.isSafeInteger(pr.number) || pr.number < 1 || pr.state !== 'OPEN' || pr.baseRefName !== 'main'
@@ -68,6 +71,11 @@ export function adoptExistingPr(input: AdoptPrInput): { card: TaskCard; created:
     || Number(pr.url.match(/\/pull\/(\d+)/)?.[1]) !== pr.number
     || !/^[a-f0-9]{40}$/i.test(pr.headRefOid)) throw new Error('입양할 PR은 현재 저장소의 OPEN/main PR 번호·URL·head SHA40이어야 한다');
   if ((input.cardId === undefined) === (input.checklist === undefined)) throw new Error('--card 또는 --checklist/--version 중 하나만 준다');
+  if (input.rebindSource) {
+    if (input.cardId || !input.checklist || !input.version || input.checklist.version !== input.version)
+      throw new Error('--rebind는 --checklist와 같은 --version을 지정하고 --card는 생략한다');
+    return rebindExistingPr(input, input.rebindSource);
+  }
   if (input.cardId && !input.version) throw new Error('기존 카드는 체크리스트 판을 확정해야 한다');
   if (input.checklist && (!input.checklist.id || !input.checklist.title || !input.checklist.version
     || ['green', 'done'].includes(input.checklist.status))) throw new Error('입양할 체크리스트 칸은 미완 판·id·제목이어야 한다');
@@ -138,3 +146,56 @@ export function adoptExistingPr(input: AdoptPrInput): { card: TaskCard; created:
   if (!result) throw new Error(`카드 쓰기 실패: ${id}`);
   return { card: result, created, changed };
 }
+
+function rebindExistingPr(input: AdoptPrInput, sourceSnapshot: NonNullable<AdoptPrInput['rebindSource']>)
+  : { card: TaskCard; created: true; changed: true; previousCardId: string } {
+  const { pr, checklist, version } = input;
+  if (!checklist || !version) throw new Error('--rebind 대상 체크리스트 판이 없다');
+  const at = (input.now ?? new Date()).toISOString();
+  const id = `ta-${at.slice(0, 10).replaceAll('-', '')}-${randomBytes(3).toString('hex')}`;
+  const replacements = updateTaskCardsAtomically(input.statePath, (tasks) => {
+    if (tasks[id]) throw new Error(`새 카드 id 충돌: ${id}`);
+    const matches = Object.values(tasks).filter((card) => cardPrNumber(card) === pr.number);
+    if (matches.length !== 1) throw new Error(matches.length
+      ? `PR #${pr.number}가 여러 카드에 묶였다 — 임의로 rebind하지 않는다`
+      : `PR #${pr.number}가 기존 카드에 묶이지 않았다 — --rebind 대상 없음`);
+    const current = matches[0]!;
+    const observed = sourceSnapshot.card;
+    if (current.id !== observed.id || current.status !== observed.status || current.runId !== observed.runId
+      || current.runChildId !== observed.runChildId || current.launchId !== observed.launchId
+      || current.checklistId !== observed.checklistId || current.checklistVersion !== observed.checklistVersion
+      || current.parentHost?.host !== observed.parentHost?.host || cardPrNumber(current) !== cardPrNumber(observed)
+      || (typeof current.pr === 'object' ? current.pr.url : undefined) !== (typeof observed.pr === 'object' ? observed.pr.url : undefined))
+      throw new Error(`rebind 중 원본 카드가 바뀌었다: ${observed.id}`);
+    if (typeof current.pr === 'object' && current.pr.url && current.pr.url !== pr.url)
+      throw new Error(`원본 카드의 PR URL이 조회 결과와 다르다: ${current.id}`);
+    if (current.status !== 'failed' && (current.checklistVersion === version && current.checklistId === checklist.id))
+      throw new Error(`같은 판·칸의 failed 카드만 rebind할 수 있다: ${current.id}`);
+    if (current.status !== 'failed' && (current.status !== 'launched' || sourceSnapshot.terminalRunEvidence !== true))
+      throw new Error(`원본 런 종결·정확한 PR 근거가 없다: ${current.id}`);
+    if (Object.values(tasks).some((card) => card.id !== current.id && card.status === 'launched' && card.taLand === true
+      && cardPrNumber(card) !== undefined && card.checklistId === checklist.id && card.checklistVersion === version))
+      throw new Error(`칸 ${checklist.id}에 이미 TA 착지 후보 카드가 있다`);
+    const liveCell = input.checklistAtWrite?.();
+    if (input.checklistAtWrite && (!liveCell || liveCell.id !== checklist.id || ['green', 'done'].includes(liveCell.status)))
+      throw new Error(`입양 중 체크리스트 칸이 바뀌거나 완료됐다: ${checklist.id}`);
+
+    const { pr: _pr, adoptedPr: _adoptedPr, prTerminal: _prTerminal, taLand: _taLand, ...oldCard } = current;
+    const released: TaskCard = { ...oldCard, history: [...current.history, {
+      at, event: 'pr-rebound-out', pr: pr.number, head: pr.headRefOid,
+      detail: `PR 결속을 ${version}/${checklist.id} 새 카드 ${id}로 이동 · ${pr.url}`,
+    }] };
+    const adopted: TaskCard = {
+      id, text: checklist.title, checklistId: checklist.id, checklistVersion: version,
+      createdAt: at, status: 'launched', taLand: true, pr: { number: pr.number, url: pr.url },
+      adoptedPr: { pr: pr.number, url: pr.url, head: pr.headRefOid, at },
+      history: [{ at, event: 'pr-adopted', pr: pr.number, head: pr.headRefOid,
+        detail: `기존 PR rebind · 원본 카드 ${current.id} · ${pr.url} · 새 구현 발사 0` }],
+    };
+    return [released, adopted];
+  });
+  const card = replacements?.find((replacement) => replacement.id === id);
+  const previous = replacements?.find((replacement) => replacement.id !== id);
+  if (!card || !previous) throw new Error('PR rebind 원자 갱신 결과가 없다');
+  return { card, created: true, changed: true, previousCardId: previous.id };
+}

package/src/task-agent/cover.ts

@@ -34,7 +34,11 @@ export interface TaskAgentCoverInput {
   /** null means the pending-landing age source could not be read; [] means no pending landings. */
   pendingLandingAgeSeconds?: readonly number[] | null;
   /** A source reached the query safety limit; its aggregate is not known to be complete. */
-  truncated?: { taskAgentActions: boolean; allLands: boolean; liveLandMoves?: boolean; goalAsks?: boolean; goalRuns?: boolean; implementCardRuns?: boolean; implementRunMerges?: boolean };
+  truncated?: { taskAgentActions: boolean; allLands: boolean; liveLandMoves?: boolean; goalAsks?: boolean; goalRuns?: boolean; implementCardRuns?: boolean; implementRunMerges?: boolean; cleanupCards?: boolean };
+  /** The physical read failed, as distinct from a reader explicitly returning null. */
+  implementReadFailure?: 'card-ledger-unreadable' | 'run-ledger-unreadable';
+  /** Confirmed post-land outcomes from the TA card ledger. undefined = not wired; null = unreadable. */
+  cleanupCards?: readonly { cardId: string; outcome: 'complete' | 'partial' }[] | null;
   /** Completed authoring provenance and terminal goal records. undefined = not wired; null = unreadable. */
   goalAsks?: readonly { authorRunId: string; goalId: string }[] | null;
   goalRuns?: readonly { goalId: string; outcome: string; stage?: string }[] | null;
@@ -205,10 +209,10 @@ export type SevenVerbState = 'live' | 'shadow-only' | 'none' | 'no-source' | 'un
 /** 7동사 출처 표의 한 칸 — source 는 그 동사를 관측하는 원천, null 이면 출처가 아직 없다. */
 export interface SevenVerbSource {
   verb: SevenVerbName;
-  source: Exclude<NextActionKind, 'decision' | 'deliver'> | 'goal-ask+goal-run' | 'card-run+merged' | null;
+  source: Exclude<NextActionKind, 'decision' | 'deliver'> | 'goal-ask+goal-run' | 'card-run+merged' | 'card:postland-card+postLand' | null;
 }
 
-/** TA-THEME-VERBS-LIVE — 저작은 완료 골 조인; 구현은 카드 런 결합 ⊕ 원장 merged 조인; 정리는 아직 출처가 없다. */
+/** TA-THEME-VERBS-LIVE — 저작은 완료 골 조인; 구현은 카드 런 ⊕ merged 원장; 정리는 카드 postland 이력. */
 export const SEVEN_VERB_SOURCES: readonly SevenVerbSource[] = [
   { verb: '리뷰', source: 'review' },
   { verb: '착지', source: 'land' },
@@ -216,7 +220,7 @@ export const SEVEN_VERB_SOURCES: readonly SevenVerbSource[] = [
   { verb: '검증', source: 'green' },
   { verb: '저작', source: 'goal-ask+goal-run' },
   { verb: '구현', source: 'card-run+merged' },
-  { verb: '정리', source: null },
+  { verb: '정리', source: 'card:postland-card+postLand' },
 ];
 
 /** 동사 하나의 관측 — 원장을 못 읽었으면 liveDone·shadow 는 null(0 이 아니다). */
@@ -226,6 +230,8 @@ export interface SevenVerbLiveRow {
   liveDone: number | null;
   shadow: number | null;
   state: SevenVerbState;
+  /** Present only for an unreadable implementation source. */
+  reason?: 'card-ledger-null' | 'run-ledger-null' | 'card-ledger-truncated' | 'run-ledger-truncated' | 'card-ledger-unreadable' | 'run-ledger-unreadable' | 'card-binding-invalid';
 }
 
 /** 합계 — liveVerbs 는 원장을 못 읽었으면 null(0 으로 쓰지 않는다) · measuredVerbs 는 출처 있는 동사 수. */
@@ -244,15 +250,17 @@ export function measureSevenVerbLive(input: TaskAgentCoverInput): SevenVerbLive
       if (input.implementCardRuns === undefined && input.implementRunMerges === undefined) {
         return { verb, source: null, liveDone: null, shadow: null, state: 'no-source' };
       }
-      if (input.implementCardRuns == null || input.implementRunMerges == null
-        || input.truncated?.implementCardRuns === true || input.truncated?.implementRunMerges === true) {
-        return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
-      }
-      const merges = input.implementRunMerges;
+      const reason = input.implementReadFailure
+        ?? (input.implementCardRuns == null ? 'card-ledger-null'
+          : input.implementRunMerges == null ? 'run-ledger-null'
+            : input.truncated?.implementCardRuns ? 'card-ledger-truncated'
+              : input.truncated?.implementRunMerges ? 'run-ledger-truncated' : null);
+      if (reason) return { verb, source, liveDone: null, shadow: null, state: 'unreadable', reason };
+      const merges = input.implementRunMerges ?? new Map();
       const cards = new Set<string>();
-      for (const binding of input.implementCardRuns) {
+      for (const binding of input.implementCardRuns ?? []) {
         // 카드 신원 없이는 중복 없는 분자를 낼 수 없다 — 그 원장은 못 읽은 것으로 한다.
-        if (!binding.cardId) return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+        if (!binding.cardId) return { verb, source, liveDone: null, shadow: null, state: 'unreadable', reason: 'card-binding-invalid' };
         const bound = [binding.runId, binding.runChildId];
         if (bound.some((runId) => typeof runId === 'string' && runId && merges.get(runId)?.merged === true)) {
           cards.add(binding.cardId);
@@ -261,6 +269,12 @@ export function measureSevenVerbLive(input: TaskAgentCoverInput): SevenVerbLive
       const liveDone = cards.size;
       return { verb, source, liveDone, shadow: 0, state: liveDone >= 1 ? 'live' : 'none' };
     }
+    if (source === 'card:postland-card+postLand') {
+      if (input.cleanupCards === undefined) return { verb, source: null, liveDone: null, shadow: null, state: 'no-source' };
+      if (input.cleanupCards === null || input.truncated?.cleanupCards) return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+      const liveDone = new Set(input.cleanupCards.filter((card) => card.outcome === 'complete').map((card) => card.cardId)).size;
+      return { verb, source, liveDone, shadow: 0, state: liveDone > 0 ? 'live' : 'none' };
+    }
     if (source === null) return { verb, source: null, liveDone: null, shadow: null, state: 'no-source' };
     if (source !== 'goal-ask+goal-run' && (unreadable || (source === 'land'
       && (input.liveLandMoves == null || input.truncated?.liveLandMoves)))) {
@@ -296,14 +310,18 @@ export function formatSevenVerbLive(measurement: SevenVerbLive): string {
     const landUnreadable = measurement.verbs.some((row) => row.source === 'land' && row.state === 'unreadable');
     const authorUnreadable = measurement.verbs.some((row) => row.source === 'goal-ask+goal-run' && row.state === 'unreadable');
     const implementUnreadable = measurement.verbs.some((row) => row.source === 'card-run+merged' && row.state === 'unreadable');
+    const cleanupUnreadable = measurement.verbs.some((row) => row.source === 'card:postland-card+postLand' && row.state === 'unreadable');
     const failures = [
       actionUnreadable ? '행동' : landUnreadable ? '착지' : null,
       authorUnreadable ? '저작·골' : null,
       implementUnreadable ? '구현 카드·런' : null,
+      cleanupUnreadable ? '정리 카드' : null,
     ].filter((part): part is string => part !== null);
     const reason = `${failures.join('·') || '저작·골'} 원장 null·절단`;
+    const physicalFailure = measurement.verbs.find((row) => row.verb === '구현')?.reason;
+    const detail = physicalFailure?.endsWith('-unreadable') ? ` · 구현 원인 ${physicalFailure}` : '';
     const noSource = measurement.verbs.filter((row) => row.state === 'no-source').map((row) => row.verb).join('·');
-    return `${total}동사 live -/${total} · 못 잼(${reason})${noSource ? ` · 출처 없음 ${noSource}` : ''}`;
+    return `${total}동사 live -/${total} · 못 잼(${reason})${detail}${noSource ? ` · 출처 없음 ${noSource}` : ''}`;
   }
   const noSource = measurement.verbs.filter((row) => row.state === 'no-source').map((row) => row.verb).join('·');
   return `${total}동사 live ${measurement.liveVerbs}/${total}${noSource ? ` · 출처 없음 ${noSource}` : ''}`;