elanous 0.2.38 → 0.2.41

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/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/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}` : ''}`;

package/src/task-agent/judge.ts

@@ -76,6 +76,62 @@ export function mustFixSignature(mustFix?: readonly string[]): string | undefine
   return `fnv1a-${hash.toString(16).padStart(8, '0')}`;
 }
 
+/**
+ * 빈 구현 must-fix 신호(대상 3종) — 리뷰가 이 신호를 담은 must-fix 를 내면 같은 PR 수리(narrow-relaunch)로는 수렴하지 않는다.
+ * 결정론 분류만 한다(LLM 경로 없음). 판별은 문구 일치로 하되 오탐을 피해 좁게 잡는다.
+ */
+const EMPTY_IMPLEMENTATION_SIGNALS: readonly { name: string; patterns: readonly RegExp[] }[] = [
+  {
+    name: '구현 파일 변경 0',
+    patterns: [
+      /빈 구현/u,
+      /empty[- ]implementation/iu,
+      /구현 파일[^\n.]{0,8}(없음|없다|미변경)|구현 파일[^\n.]{0,24}변경[^\n.]{0,8}0(?!\d)/u,
+      /구현 (diff|변경|차분)[^\n.]{0,8}0(?!\d)/u,
+      /implementation files?[^\n.]{0,32}(unchanged|zero|no change)/iu,
+      /(no|zero) (implementation|code) (changes|diff)/iu,
+      /target diff (is )?0(?!\d)/iu,
+    ],
+  },
+  {
+    name: 'GOODHART/자기 문구 시험',
+    patterns: [/GOODHART/iu, /자기 ?문구/u, /골 문면/u, /goal[ -]?(text|wording)/iu],
+  },
+  {
+    name: '대상 경로 미배선',
+    patterns: [/미배선/u, /배선되지 않/u, /호출부[^\n.]{0,8}(없음|없다)/u, /not[ -]?wired/iu, /unwired/iu, /no caller/iu, /dead code/iu],
+  },
+];
+
+/** 빈 구현 must-fix 판정의 수 — 첫 회는 같은 칸 새 발사(재구현), 이미 두 번째면 칸 주인 이관(needs-owner). */
+export type EmptyImplementationMove = 'reimplement' | 'needs-owner';
+
+/** 판정 관측 한 줄 — `reason` 이 그대로 관측 로그 문면이다(줄바꿈 없음). */
+export interface EmptyImplementationJudgement {
+  move: EmptyImplementationMove;
+  signals: readonly string[];
+  reason: string;
+}
+
+/**
+ * 리뷰 must-fix 가 «빈 구현» 신호(구현 파일 변경 0 · GOODHART/자기 문구 시험 · 대상 경로 미배선)를 담는지 결정론 분류한다.
+ * 신호를 담으면 narrow-relaunch 대신 재구현 판정 — 같은 칸의 앞 런에서 이미 빈 구현 must-fix 였으면
+ * (priorEmptyImplementation ≥ 1) 두 번째이므로 needs-owner. 신호가 없으면 null — 일반 must-fix 는 종전대로 narrow-relaunch.
+ */
+export function judgeEmptyImplementation(
+  mustFix: readonly string[] | undefined,
+  priorEmptyImplementation = 0,
+): EmptyImplementationJudgement | null {
+  const signals: string[] = [];
+  for (const { name, patterns } of EMPTY_IMPLEMENTATION_SIGNALS) {
+    if ((mustFix ?? []).some(fix => typeof fix === 'string' && patterns.some(pattern => pattern.test(fix)))) signals.push(name);
+  }
+  if (!signals.length) return null;
+  const move: EmptyImplementationMove = priorEmptyImplementation >= 1 ? 'needs-owner' : 'reimplement';
+  const disposition = move === 'needs-owner' ? '두 번째 빈 구현 — 칸 주인에게 이관' : '같은 PR 수리로는 수렴 불가 — 같은 칸 새 발사(시험 먼저)';
+  return { move, signals, reason: `빈 구현 must-fix(${signals.join(' · ')}) — ${disposition}` };
+}
+
 export interface TaskJudgement {
   move: TaskMove;
   stage: 'observing' | 'closing' | 'reviewing' | 'repairing' | 'waiting' | 'escalated';

package/src/task-agent/parent-host.ts

@@ -43,6 +43,17 @@ export type ParentHostSetting = Partial<ParentHostConfig> | readonly Partial<Par
 export const PARENT_HOST_ENV = 'ELANOUS_TA_PARENT_HOST';
 const DEFAULT_REMOTE_ELANOUS = '$HOME/.local/share/elanous/bin/elanous';
 const DEFAULT_REMOTE_CONFIG_DIR = '$HOME/.elanous';
+/**
+ * 원격 부모 상태 루트의 출처 태그 — 루트(`ELANOUS_STATE_DIR`)와 «한 벌»로 넘긴다(src/agent/identity-env.ts).
+ * HQ 가 git worktree/`--test` 라면 그 env 에 `derived` 가 실린다. 루트만 원격 값으로 바꾸고 태그를 그대로
+ * 흘리면 원격 부모는 «명시한 운영 루트 + 파생 태그»를 받아 자기 우주를 test 로 오독한다 —
+ * `SOURCE === 'derived'` 를 보는 codexCredentialRoot(src/budget/codex-reset-credit-state.ts)·
+ * harnessLaunchPolicyConfig(src/harness/harness-substrate-default.ts) 가 그 자리다.
+ * 떼어 띄운 운영 부모의 기존 꼴(src/task-orchestrator/surfaces/pod-si-warm-runner.ts)과 같은 `explicit` 를 찍는다.
+ */
+const REMOTE_STATE_DIR_SOURCE = 'explicit';
+/** 원격 발사에서 HQ 값을 버리고 원격 기준으로 다시 찍는 상태 루트 env(한 벌). */
+const STATE_ROOT_ENV_KEYS: ReadonlySet<string> = new Set(['ELANOUS_STATE_DIR', 'ELANOUS_STATE_DIR_SOURCE']);
 const HOST_RE = /^[A-Za-z0-9][A-Za-z0-9._@-]{0,127}$/;
 /** A parent can wait for a child for tens of minutes; the two-minute HTTP refresh floor is too short here. */
 export const PARENT_CHILD_CREDENTIAL_MIN_REMAINING_MS = 60 * 60_000;
@@ -227,7 +238,9 @@ export function remoteLaunchScript(target: ParentHostConfig, args: readonly stri
   const log = remoteParentLogPath(target, env.ELANOUS_RUN_ID ?? 'unknown');
   // --config-dir keeps the parent's operational config/state; authStorePath()
   // reads XDG_CONFIG_HOME/elanous/auth.json first, as the entrypoint test proves.
-  const envPart = [...Object.entries(env).filter(([key]) => key !== 'ELANOUS_STATE_DIR' && /^[A-Z_][A-Z0-9_]*$/.test(key)).map(([key, value]) => `${key}=${key === 'XDG_CONFIG_HOME' || key === 'CODEX_HOME' || key === 'GH_CONFIG_DIR' ? remotePath(value) : shellQuote(value)}`), `ELANOUS_STATE_DIR=${remotePath(configDir)}`].join(' ');
+  // 상태 루트는 태그와 한 벌로 넘긴다(REMOTE_STATE_DIR_SOURCE 주석) — HQ 의 derived 태그가
+  // 함께 흐르면 방금 명시한 운영 루트를 원격 부모가 test 우주로 오독한다.
+  const envPart = [...Object.entries(env).filter(([key]) => !STATE_ROOT_ENV_KEYS.has(key) && /^[A-Z_][A-Z0-9_]*$/.test(key)).map(([key, value]) => `${key}=${key === 'XDG_CONFIG_HOME' || key === 'CODEX_HOME' || key === 'GH_CONFIG_DIR' ? remotePath(value) : shellQuote(value)}`), `ELANOUS_STATE_DIR=${remotePath(configDir)}`, `ELANOUS_STATE_DIR_SOURCE=${shellQuote(REMOTE_STATE_DIR_SOURCE)}`].join(' ');
   const argv = [remotePath(elanous), '--config-dir', remotePath(configDir), ...remoteParentArgs(args, target.podPool).map(shellQuote)].join(' ');
   // 준비가 실패하면 «확실히 안 띄웠다»(not-launched=…)를 찍고 끝낸다 — 그때만 호출부가 로컬로 돌아간다.
   // 띄운 뒤에는 짧게 살아 있는지 보고 pid 를 찍는다(조기 종료면 early-exit — 역시 «안 돈다»가 확실).