elanous 0.2.35 → 0.2.37

package/src/steward/ta-repair-event-collect.ts

@@ -7,6 +7,7 @@ import { acquireLockSync } from '../storage/file-lock.js';
 import { subscribeInsideEvent, type InsideLiveEvent } from '../nexus/api/inside-events.js';
 import type { NexusEventBus } from '../nexus/api/event-bus.js';
 import { parseRepairWorkerResult } from '../task-agent/repair-worker.js';
+import { pairMoveId } from '../task-agent/repair-next-move.js';
 import { readTaskCard, taskAgentStatePath } from '../task-agent/task-hand.js';
 
 const SHA40 = /^[0-9a-f]{40}$/i;
@@ -17,6 +18,8 @@ const OUTPUT_LIMIT = 1024 * 1024;
 export interface TaRepairCompleted {
   kind: 'ta.repair.completed'; schema: 1; card: string; pr: number; head: string;
   runId: string; resultPath: string; completedAt: string;
+  /** HARNESS-FULL-GRAPH-NEXTMOVE — worker 가 받은 수 id(옛 worker 는 없다 · 꼴이 틀려도 사건을 버리지 않고 짝짓기에서 «못 짝지음»으로 남긴다). */
+  moveId?: string;
 }
 
 export function parseTaRepairCompleted(value: unknown): TaRepairCompleted | null {
@@ -102,14 +105,22 @@ export async function collectTaRepairCompleted(input: unknown, deps: TaRepairCol
   let card;
   try { card = readTaskCard(event.card, statePath); } catch { emit('deferred', { reason: 'card unreadable' }); return 'deferred'; }
   const repair = Array.isArray(card?.repairs) ? card.repairs.find(entry => entry && typeof entry === 'object' && entry.runId === event.runId) : undefined;
+  // NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 사건의 수 id 를 카드(발사 순간 적은 값)와 짝짓는다. 결과는 관측 칸에만 싣는다(fail-soft · 수거 판단은 그대로).
+  const observedMoveId: unknown = (event as { moveId?: unknown }).moveId;
+  const pairing = pairMoveId(repair?.moveId, observedMoveId);
+  const moveFields: Record<string, unknown> = pairing.kind === 'legacy' ? {}
+    : { moveId: pairing.kind === 'paired' ? pairing.moveId : typeof observedMoveId === 'string' ? observedMoveId : null,
+      moveIdPaired: pairing.kind === 'paired', ...(pairing.kind === 'unpaired' ? { expectedMoveId: pairing.expected } : {}) };
+  const emitPaired = (outcome: string, extra: Record<string, unknown> = {}) => emit(outcome, { ...moveFields, ...extra });
   if (!repair || repair.pr !== event.pr || typeof repair.head !== 'string' || repair.head.toLowerCase() !== event.head.toLowerCase()
     || typeof repair.resultPath !== 'string' || !repair.resultPath.startsWith('/')
+    // 카드 귀속이 안 맞는 사건엔 짝짓기 칸을 싣지 않는다 — 남의 수리와 대조한 값이 관측에 섞이지 않게(r1 should-fix).
     || resolve(repair.resultPath) !== resolve(event.resultPath)) { emit('invalid', { reason: 'event differs from card binding' }); return 'invalid'; }
-  if (repair.status !== 'requested') { emit('duplicate', { reason: `repair ${repair.status}` }); return 'duplicate'; }
+  if (repair.status !== 'requested') { emitPaired('duplicate', { reason: `repair ${repair.status}` }); return 'duplicate'; }
   let result;
   try { result = parseRepairWorkerResult((deps.read ?? ((path) => readFileSync(path, 'utf8')))(repair.resultPath), event.pr, event.head, event.runId); }
   catch { /* periodic tick can recover a missing result */ }
-  if (!result) { emit('deferred', { reason: 'worker result missing or invalid' }); return 'deferred'; }
+  if (!result) { emitPaired('deferred', { reason: 'worker result missing or invalid' }); return 'deferred'; }
 
   // Existing PID-aware lock recovers a dead daemon without making later events wait forever.
   // A live holder keeps the lock through the child process; the card CAS covers periodic-tick races.
@@ -119,25 +130,25 @@ export async function collectTaRepairCompleted(input: unknown, deps: TaRepairCol
     mkdirSync(dirname(lock), { recursive: true });
     release = acquireLockSync(lock, { breakDeadHolder: true, staleMs: TIMEOUT_MS + 60_000, maxTries: 2 });
   }
-  catch { emit('deferred', { reason: 'collector busy; periodic fallback remains' }); return 'deferred'; }
+  catch { emitPaired('deferred', { reason: 'collector busy; periodic fallback remains' }); return 'deferred'; }
   try {
     // Recheck after claiming: another collector or the periodic tick may have consumed the file.
     const current = readTaskCard(event.card, statePath);
     const latest = Array.isArray(current?.repairs) ? current.repairs.find(entry => entry && typeof entry === 'object' && entry.runId === event.runId) : undefined;
     if (!latest || latest.status !== 'requested' || latest.pr !== event.pr || typeof latest.head !== 'string'
       || latest.head.toLowerCase() !== event.head.toLowerCase() || typeof latest.resultPath !== 'string'
-      || !latest.resultPath.startsWith('/') || resolve(latest.resultPath) !== resolve(event.resultPath)) { emit('duplicate'); return 'duplicate'; }
+      || !latest.resultPath.startsWith('/') || resolve(latest.resultPath) !== resolve(event.resultPath)) { emitPaired('duplicate'); return 'duplicate'; }
     const child = await (deps.run ?? ((card) => defaultRun(card, statePath, deps.cliBin)))(event.card);
     const after = readTaskCard(event.card, statePath)?.repairs?.find(entry => entry.runId === event.runId);
     const consumed = child.code === 0 && !child.truncated && after?.status !== 'requested' && after !== undefined
       && childConsumedRepair(child.output, event);
     const outcome = consumed ? 'collected' : child.truncated ? 'deferred' : after && after.status !== 'requested' ? 'duplicate' : 'deferred';
-    emit(outcome, { rc: child.code, repairStatus: after?.status,
+    emitPaired(outcome, { rc: child.code, repairStatus: after?.status,
       ...(child.truncated ? { reason: 'rejudge output exceeded 1 MiB; event attribution unmeasured' } : {}),
       detail: child.output.slice(-300) });
     return consumed ? 'collected' : outcome === 'duplicate' ? 'duplicate' : 'deferred';
   } catch (error) {
-    emit('deferred', { reason: String(error).slice(-300) });
+    emitPaired('deferred', { reason: String(error).slice(-300) });
     return 'deferred';
   } finally { release(); }
 }

package/src/task-agent/actions.ts

@@ -1,8 +1,12 @@
 import { copyFileSync, lstatSync, mkdirSync, realpathSync } from 'node:fs';
 import { join, relative, resolve, sep } from 'node:path';
+import { runGitCommand } from '../git-fs/runner.js';
 import { debug } from '../debug/log.js';
 import { judgeNextMove, retryMoveOf, SAME_MOVE_FAILURE_LIMIT } from './judge.js';
 import { checkCompletionEvidence } from './completion-evidence.js';
+import { appendGreenSweepEvidence, decideGreenSweep, greenSweepCandidates, observeGreenSweep, type GreenSweepPr, type GreenSweepVerdict } from './green-sweep.js';
+import type { TaskCard } from './task-hand.js';
+import type { ChecklistItem } from '../release-loop/checklist.js';
 
 export type DeliveryKind = 'research-report' | 'artifact' | 'content';
 export interface DeliveryEvidence { ok: boolean; files: string[]; reason: string }
@@ -44,13 +48,17 @@ export interface NextAction {
   original: string;
   checklistId: string;
   history?: string[];
+  /** Only a producer bound to this PR may mark its owner worktree commit as harvesting. */
+  harvestState?: { pr: number; source: 'owner-worktree-commit'; head: string };
   mustFix?: string[];
   cwd?: string;
   risk?: 'money' | 'security' | 'irreversible-publication';
   delivery?: { kind: DeliveryKind; worktreePath: string; projectTarget: string; files: string[] };
+  /** NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 이 재발사를 고른 next-move 결정의 수 id(결정 순간 한 번 · 다시 만들지 않는다). 있으면 `harness say --move-id` 로 싣는다. */
+  moveId?: string;
 }
 export interface ActionDeps {
-  command(args: string[]): Promise<{ status: number; stdout: string; stderr?: string }>;
+  command(args: string[], cwd?: string): Promise<{ status: number; stdout: string; stderr?: string }>;
   mode?: string;
   landingsToday?: number;
   landingDay?: string;
@@ -71,6 +79,14 @@ export interface ActionDeps {
   retryLaunches?: { count: number };
   /** mbp 부하 관문(OP 신호 `loadMax`) — 지금 1분 부하가 `loadMax` 이상이거나 못 읽으면 발사하지 않고 shadow. 없으면 관문 없음(종전). */
   loadGate?: { loadMax: number; load1(): number | null };
+  /** GREEN-FROM-LEDGER-FU — green live 쓰기 문맥(관측 probe ⊕ 칸 원문·판본·과제 카드). 실행부 green 경로가 소비자
+   *  `consumeGreenSweepForGreenWrite`를 지나 원문 대조가 모두 일치할 때만 checklist green 쓰기를 1회 한다.
+   *  없으면 종전 그대로 검증 안내 카드(fail-closed) — 문맥 없이 green 은 쓰지 않는다. */
+  greenSweep?: { probe: GreenSweepProbe; item: ChecklistItem; version: string; cards: readonly TaskCard[] };
+  /** Checklist green writes are a separate OP-authorized capability; default is observation only. */
+  greenWriteLive?: boolean;
+  /** Read-only owner checkout probe for review harvest verification. */
+  harvestGit?: (cwd: string, args: string[]) => { status: number | null; stdout: string };
 }
 
 /** 재발사는 한 판단 회차에 한 건만 발사한다. */
@@ -176,6 +192,28 @@ const RETRY_HINT: Record<Exclude<RetryVariant, 'wait'>, (action: NextAction) =>
   alternative: () => 'Alternative approach: the same move already failed twice. Choose a different approach than the previous runs.',
 };
 
+export function ownerWorktreeHarvestState(input: { pr: number; cwd: string; head: string; branch: string; state: string },
+  gitRun?: (cwd: string, args: string[]) => { status: number | null; stdout: string }): NextAction['harvestState'] {
+  if (!Number.isSafeInteger(input.pr) || input.pr < 1 || input.state !== 'OPEN' || !/^[a-f0-9]{40}$/i.test(input.head)) return undefined;
+  const git = gitRun ?? ((cwd: string, args: string[]) => {
+    const result = runGitCommand(cwd, args, { encoding: 'utf-8' });
+    return { status: result.status, stdout: String(result.stdout ?? '') };
+  });
+  try {
+    const cwd = realpathSync(input.cwd);
+    const [branch, local, registry] = [git(cwd, ['branch', '--show-current']), git(cwd, ['rev-parse', 'HEAD']), git(cwd, ['worktree', 'list', '--porcelain'])];
+    const name = branch.stdout.trim();
+    const commit = local.stdout.trim();
+    if (branch.status !== 0 || !name || local.status !== 0 || !/^[a-f0-9]{40}$/i.test(commit) || registry.status !== 0) return undefined;
+    const owners = registry.stdout.trim().split(/\n\s*\n/).filter(entry => entry.split('\n').includes(`branch refs/heads/${name}`));
+    const ownerPath = owners[0]?.split('\n').find(line => line.startsWith('worktree '))?.slice('worktree '.length);
+    if (owners.length !== 1 || !ownerPath || realpathSync(ownerPath) !== cwd) return undefined;
+    if (input.branch !== name || input.head.toLowerCase() === commit.toLowerCase()) return undefined;
+    if (git(cwd, ['merge-base', '--is-ancestor', input.head, commit]).status !== 0) return undefined;
+    return { pr: input.pr, source: 'owner-worktree-commit', head: commit };
+  } catch { return undefined; }
+}
+
 export async function executeNextAction(action: NextAction, deps: ActionDeps): Promise<string> {
   const record = (result: string, reason: string) => {
     if (result === 'failed' && (deps.failureCounts || deps.incrementFailure)) {
@@ -189,10 +227,16 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
   };
   const shadowReason = deps.mode === 'live' ? retryShadowReason(action, deps) : undefined;
   if (deps.mode !== 'live' || shadowReason) {
+    if (action.kind === 'green' && deps.greenSweep) {
+      const outcome = await consumeGreenSweepForGreenWrite({ deps, probe: deps.greenSweep.probe,
+        item: deps.greenSweep.item, version: deps.greenSweep.version, cards: deps.greenSweep.cards, writeLive: false });
+      return record(outcome.verdict === 'green' ? 'would-green' : 'refused', outcome.reason);
+    }
     const destination = action.delivery && action.kind === 'deliver'
       ? ` → ${join(action.delivery.projectTarget, 'elanous-out', action.taskId)}/${action.delivery.files.join(', ')}` : '';
     return record('shadow', `would ${action.kind}${action.variant ? `:${action.variant}` : ''}: ${action.rationale}${destination}${shadowReason ? ` · shadow: ${shadowReason}` : ''}`);
   }
+  const gh = (args: string[]) => deps.command(args, action.cwd);
   const card = async (reason: string) => {
     const evidence = JSON.stringify({ runId: action.runId, pr: action.pr, mustFix: action.mustFix ?? [], history: action.history ?? [], selected: action.kind, reason });
     const result = await deps.command(decisionRaiseArgs({ taskId: action.taskId, reason, ...(action.risk ? { risk: action.risk } : {}), evidence }));
@@ -202,7 +246,7 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
   if (sameMoveFailures(action, deps) >= SAME_MOVE_FAILURE_LIMIT) return card('same task/action failed twice');
   if (action.kind === 'land') {
     if (!action.cwd) return card('landing worktree unknown');
-    const view = await deps.command(['gh', 'pr', 'view', String(action.pr), '--json', 'labels']);
+    const view = await gh(['gh', 'pr', 'view', String(action.pr), '--json', 'labels']);
     if (view.status !== 0) return card('PR labels unavailable');
     let labels: unknown;
     try { labels = (JSON.parse(view.stdout) as { labels?: unknown }).labels; }
@@ -248,12 +292,45 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
     const judgement = judgeNextMove({ deliveryEvidence: evidence });
     return record(judgement.move === 'propose-green' ? 'done' : 'waiting', `${judgement.move}: ${judgement.reason}`);
   }
-  if (action.kind === 'green') return card('green requires a verified landing in this execution');
+  if (action.kind === 'green') {
+    // GREEN-FROM-LEDGER-FU 배선(shard 2) — 생산 진입점이 소비자를 지나 dry-run 판정 ⊕ 원문 대조 후 쓰기를 지킨다:
+    // 대조가 모두 일치하면 checklist green 명령 1회, 거부·unknown·mismatch 는 쓰기 0회 + 칸 상태 불변(fail-closed).
+    // 문맥(deps.greenSweep)이 없으면 종전 그대로 검증 안내 카드 — 호출부가 문맥을 안 싣는 동안 green 은 쓰지 않는다.
+    const greenSweep = deps.greenSweep;
+    if (!greenSweep) return card('green requires a verified landing in this execution');
+    const writeLive = deps.greenWriteLive === true;
+    const outcome = await consumeGreenSweepForGreenWrite({ deps, probe: greenSweep.probe, item: greenSweep.item,
+      version: greenSweep.version, cards: greenSweep.cards, writeLive });
+    return record(outcome.written ? 'done' : outcome.verdict === 'green-command-failed' ? 'failed'
+      : outcome.verdict === 'green' ? 'would-green' : 'refused', outcome.reason);
+  }
   // G1 — 기다림은 발사가 아니다: 대기 표지만 남기고 다음 틱이 다시 판단한다(카드로 올리지 않는다).
   if (action.kind === 'retry' && action.variant === 'wait') return record('waiting', `wait marker: ${action.rationale}`);
   // must-fix 없는 재발사가 카드로 가는 것은 갈래 없는(종전) retry 뿐이다 — narrow·salvage·alternative 는 갈래 문면으로 간다.
   if (action.kind === 'retry' && !action.variant && !action.mustFix?.length) return card('must-fix missing; cannot narrow retry');
   if (action.kind === 'review') {
+    let harvestState: NextAction['harvestState'];
+    if (action.harvestState?.source === 'owner-worktree-commit' && action.harvestState.pr === action.pr && action.cwd
+      && /^[a-f0-9]{40}$/i.test(action.harvestState.head)) {
+      try {
+        const response = await gh(['gh', 'pr', 'view', String(action.pr), '--json', 'state,headRefOid,headRefName']);
+        if (response.status === 0) {
+          const pr = JSON.parse(response.stdout) as { state?: unknown; headRefOid?: unknown; headRefName?: unknown };
+          if (typeof pr.headRefOid === 'string' && typeof pr.headRefName === 'string' && typeof pr.state === 'string') {
+            const current = ownerWorktreeHarvestState({ pr: action.pr, cwd: action.cwd, head: pr.headRefOid,
+              branch: pr.headRefName, state: pr.state }, deps.harvestGit);
+            if (current?.head.toLowerCase() === action.harvestState.head.toLowerCase()) harvestState = current;
+          }
+        }
+      } catch { /* Unverified caller signal preserves the review command. */ }
+    }
+    if (harvestState) {
+      action.harvestState = harvestState;
+      const reason = `review skipped: owner-worktree-commit PR #${action.pr} ${harvestState.head}`;
+      (action.history ??= []).push('review skipped: owner-worktree-commit');
+      record('skipped', reason);
+      return record('waiting', `${reason} · next: wait for exact-head review evidence`);
+    }
     const review = await deps.command(['self', 'review', String(action.pr), '--json']);
     if (review.status !== 0) return record('failed', 'review command failed');
     let parsed: { verdict?: string; mustFix?: string[]; reviewed?: boolean };
@@ -273,7 +350,7 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
     return card('review verdict or must-fix unavailable');
   }
   // 여기 닿는 종류는 land · retry 둘뿐이다(green·decision·review 는 위에서 끝난다).
-  const args = action.kind === 'land' ? ['pr', 'land', '--cwd', action.cwd!] : ['harness', 'say', retryText(action)];
+  const args = action.kind === 'land' ? ['pr', 'land', '--cwd', action.cwd!] : ['harness', 'say', retryText(action), ...(action.moveId ? ['--move-id', action.moveId] : [])];
   const day = deps.landingDay ?? new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
   if (action.kind === 'retry' && deps.retryLaunches) deps.retryLaunches.count++;
   const outcome = await deps.command(args);
@@ -282,7 +359,7 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
     return record('failed', `${action.kind} command failed: ${outcome.stderr ?? ''}`);
   }
   if (action.kind === 'land') {
-    const merged = await deps.command(['gh', 'pr', 'view', String(action.pr), '--json', 'state,mergeCommit']);
+    const merged = await gh(['gh', 'pr', 'view', String(action.pr), '--json', 'state,mergeCommit']);
     let sha: string | undefined;
     let notMerged = false;
     try {
@@ -307,6 +384,126 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
   return record('done', action.rationale);
 }
 
+/**
+ * GREEN-FROM-LEDGER-FU — green live 쓰기 소비자: `green-sweep.ts`(순수 판정 · checklist/card 쓰기 0)의
+ * dry-run 결정을 소비해 실제 checklist green 쓰기를 수행하는 유닛. 쓰기 책임은 전부 이 소비자가 진다.
+ * 판정이 green 이고 후보의 OP 원문 대조가 모두 일치할 때만 `release checklist set --status green`
+ * (executeNextAction 의 착지 green 쓰기와 같은 명령면)을 deps.command 로 수행한다.
+ * 판정 거부 · 원문 대조 불일치 · 명령 실패는 전부 쓰기 0 — 거짓 green 을 쓰지 않는다(fail-closed).
+ * 원문 대조는 세 다리다: ① observeGreenSweep 표준 출력이 판정과 정확히 같은가 ② plannedEvidence 가
+ * 판정 원문(existingEvidence + evidence 행)과 정확히 같은가 ③ 쓰기 직전 칸 원문이 판정이 본 것과 같은가.
+ * ③ 은 칸 원문 재독기(cellEvidence)가 실제 일치를 확인했을 때만 'cell ok' 로 남는다 — 미제공·재독 불가는
+ * 자기 자신(item.evidence)과의 공전 대조를 하지 않고 unknown 상태로 보존해 쓰기를 거부한다.
+ * 결과는 deps.observe('task-agent.action', { kind: 'green', … }) 로 관측면에 남긴다.
+ */
+export interface GreenSweepProbe {
+  /** 후보 PR 관측(gh pr view 상당). null = 못 읽었다(pr-unreadable). */
+  pr(pr: number): Promise<GreenSweepPr | null>;
+  /** 후보 merge sha 가 origin/main 조상인가. null = 못 읽었다. */
+  ancestor(sha: string): Promise<boolean | null>;
+  /** 트래픽 hold 여부. null = 못 읽었다. */
+  hold(): Promise<boolean | null>;
+  /** 후보 PR 이 이 칸의 저장소에 속하는가. 주지 않으면 판정이 record-only 로 거부한다. */
+  repositoryMatches?(pr: number): Promise<boolean | null>;
+  /** 다른 칸이 같은 PR 을 주장하나(ambiguousAcrossCells). */
+  ambiguousAcrossCells?(pr: number): boolean | null;
+  /** 칸 원문 재독기 — 판정이 본 증거(evidence)와 쓰기 직전 칸 원문이 같은지 대조한다. 못 읽으면 undefined(대조 불가 → 쓰기 거부).
+   *  필수 멤버다 — 미제공이면 소비자는 자기 자신(item.evidence)과의 공전 대조를 하지 않고 unknown 상태로 쓰기를 거부한다. */
+  cellEvidence(cell: string): Promise<string | undefined>;
+}
+
+export interface GreenSweepWriteOutcome {
+  cell: string;
+  pr: number | null;
+  /** true = `release checklist set --status green` 명령까지 성공했다. 그 외는 전부 쓰기 0. */
+  written: boolean;
+  /** green = 쓰기 성공 · evidence-unknown = 원문 대조를 수행할 수 없었다(칸 원문 미제공·재독 불가) · 그 외 판정·대조·명령 사유. */
+  verdict: GreenSweepVerdict | 'no-candidates' | 'evidence-mismatch' | 'evidence-unknown' | 'green-command-failed';
+  reason: string;
+}
+
+export async function consumeGreenSweepForGreenWrite(input: {
+  deps: Pick<ActionDeps, 'command' | 'observe'>;
+  probe: GreenSweepProbe;
+  item: ChecklistItem;
+  version: string;
+  cards: readonly TaskCard[];
+  writeLive?: boolean;
+}): Promise<GreenSweepWriteOutcome> {
+  const { deps, probe, item, version, cards, writeLive = false } = input;
+  const candidates = greenSweepCandidates(item, version, cards);
+  const record = (outcome: GreenSweepWriteOutcome): GreenSweepWriteOutcome => {
+    deps.observe('task-agent.action', {
+      taskId: item.id, kind: 'green', result: outcome.written ? 'done'
+        : outcome.verdict === 'green-command-failed' ? 'failed'
+          : outcome.verdict === 'green' && !writeLive ? 'would-green' : 'refused', reason: outcome.reason,
+    });
+    return outcome;
+  };
+  if (!candidates.length) {
+    return record({ cell: item.id, pr: null, written: false, verdict: 'no-candidates', reason: 'GREEN-FROM-LEDGER-FU: dry-run 후보 없음' });
+  }
+  let last: GreenSweepWriteOutcome | undefined;
+  for (const candidate of candidates) {
+    const pr = await probe.pr(candidate.pr);
+    const mergeSha = pr?.mergeSha && /^[a-f0-9]{40}$/i.test(pr.mergeSha) ? pr.mergeSha : null;
+    const [ancestor, hold, repositoryMatches] = await Promise.all([
+      probe.ancestor(mergeSha ?? ''),
+      probe.hold(),
+      probe.repositoryMatches ? probe.repositoryMatches(candidate.pr) : Promise.resolve(null),
+    ]);
+    const decision = decideGreenSweep({
+      item, candidate, candidateCount: candidates.length, pr, ancestor, hold,
+      ...(repositoryMatches === null ? {} : { repositoryMatches }),
+      ...(probe.ambiguousAcrossCells ? { ambiguousAcrossCells: probe.ambiguousAcrossCells(candidate.pr) ?? undefined } : {}),
+    });
+    // 원문 대조 ① — observeGreenSweep 표준 출력(«OP 원문» 관측)이 판정과 정확히 같은가.
+    let observed: { category: string; event: string; data?: unknown } | undefined;
+    observeGreenSweep(decision, (category, event, data) => { observed = { category, event, data }; });
+    const emitted = observed?.data as { cell?: unknown; pr?: unknown; mergeSha?: unknown; reason?: unknown } | undefined;
+    const emissionMatches = observed?.category === 'task-agent.green-sweep'
+      && observed.event === decision.verdict
+      && emitted?.cell === decision.cell
+      && emitted?.pr === decision.pr
+      && emitted?.mergeSha === decision.mergeSha
+      && emitted?.reason === decision.reason;
+    // 원문 대조 ② — plannedEvidence 가 판정 원문(existingEvidence + evidence 행)과 정확히 같은가.
+    const plannedMatches = decision.plannedEvidence === appendGreenSweepEvidence(decision.existingEvidence, decision.evidence);
+    if (decision.verdict !== 'green') {
+      last = record({
+        cell: item.id, pr: candidate.pr, written: false, verdict: decision.verdict,
+        reason: `GREEN-FROM-LEDGER-FU: 판정 거부 — ${decision.evidence}`,
+      });
+      continue;
+    }
+    // 원문 대조 ③ — 쓰기 직전 칸 원문이 판정이 본 것과 같은가(판정 중 칸 변경 방지). green 판정에만 재독한다.
+    // cellEvidence 미제공·재독 불가는 자기 자신(item.evidence)과 대조하지 않는다 — 그 대조는 공전이므로
+    // unknown 상태로 보존해 쓰기를 거부한다(fail-closed). 'cell ok' 는 실제 재독 ⊕ 일치 확인에만 나온다.
+    const cellProbe = probe.cellEvidence;
+    const currentEvidence = typeof cellProbe === 'function' ? await cellProbe(item.id) : undefined;
+    const cellState: 'ok' | 'mismatch' | 'unreadable' | 'unprovided'
+      = typeof cellProbe !== 'function' ? 'unprovided'
+      : typeof currentEvidence !== 'string' ? 'unreadable'
+      : currentEvidence === decision.existingEvidence ? 'ok' : 'mismatch';
+    if (!emissionMatches || !plannedMatches || cellState !== 'ok') {
+      const mismatched = !emissionMatches || !plannedMatches || cellState === 'mismatch';
+      return record({
+        cell: item.id, pr: candidate.pr, written: false,
+        verdict: mismatched ? 'evidence-mismatch' : 'evidence-unknown',
+        reason: `GREEN-FROM-LEDGER-FU: ${mismatched ? '원문 대조 불일치' : '원문 대조 불가(칸 원문 unknown)'} — emission ${emissionMatches ? 'ok' : 'mismatch'} · planned ${plannedMatches ? 'ok' : 'mismatch'} · cell ${cellState}`,
+      });
+    }
+    if (!writeLive) return record({ cell: item.id, pr: candidate.pr, written: false, verdict: 'green',
+      reason: `would-green: ${decision.evidence} · live write disabled` });
+    const green = await deps.command(['release', 'checklist', 'set', item.id, '--status', 'green', '--evidence', decision.evidence]);
+    if (green.status !== 0) {
+      return record({ cell: item.id, pr: candidate.pr, written: false, verdict: 'green-command-failed', reason: `green command failed: ${green.stderr ?? ''}` });
+    }
+    return record({ cell: item.id, pr: candidate.pr, written: true, verdict: 'green', reason: decision.evidence });
+  }
+  return last ?? record({ cell: item.id, pr: null, written: false, verdict: 'no-candidates', reason: 'GREEN-FROM-LEDGER-FU: dry-run 후보 없음' });
+}
+
 /** Execute the allowed candidates in a caller-supplied tick and emit one isolated denominator event. */
 export async function executeEntranceTick(candidates: readonly EntranceTickCandidate[], deps: ActionDeps): Promise<string[]> {
   const denominator = buildEntranceRefusalDenominator(candidates.map(({ action, refusal }) => ({

package/src/task-agent/boundary-proof-mapping.ts

@@ -0,0 +1,12 @@
+import { createHash } from 'node:crypto';
+
+/** Hash the exact typed mapping in the current title; ambiguity never inherits an old receipt. */
+export function boundaryMappingHash(title: string): string | null {
+  const matches = [...title.matchAll(/^\s*-?\s*완료 경계 실물 검증:\s*(.+)$/gm)];
+  if (matches.length !== 1) return null;
+  try {
+    const mapping: unknown = JSON.parse(matches[0]![1]!);
+    if (!Array.isArray(mapping) || mapping.length < 1 || mapping.length > 8) return null;
+    return createHash('sha256').update(JSON.stringify(mapping)).digest('hex');
+  } catch { return null; }
+}

package/src/task-agent/boundary-proof-producer.ts

@@ -0,0 +1,147 @@
+import { existsSync, linkSync, mkdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { spawnElanousSync } from '../instance/spawn-elanous.js';
+import { lastJsonObject } from '../graph-runner/runner.js';
+import { boundaryMappingHash } from './boundary-proof-mapping.js';
+import { parseGreenCloseEvidenceCommand, runGreenCloseEvidenceTest } from './green-close-recipe.js';
+
+type Assertion = { path: string; equals: string | number | boolean };
+type TestRun = { kind: 'test-run'; command: string };
+type GraphRun = { kind: 'graph-run'; graphId: string; runId: string; nodeId: string; assertion: Assertion };
+type CliJson = { kind: 'cli-json'; argv: string[]; assertion: Assertion };
+export type BoundaryCheck = TestRun | GraphRun | CliJson;
+export interface BoundaryProofInput {
+  title: string; cellId: string; mainSha: string; mapRunId: string; cardId: string;
+  graphRunId: string; stateRoot: string; repoRoot: string;
+}
+export interface BoundaryProofResult { outcome: 'pass' | 'hold'; reason: string; evidence: string[]; proofRef?: string }
+
+const safeId = /^[A-Za-z0-9_-]{1,160}$/;
+const sha = /^[a-f0-9]{40}$/i;
+const safePath = /^[A-Za-z_][A-Za-z0-9_.-]*$/;
+const safeGraphId = /^[A-Za-z0-9_-]+$/;
+
+function object(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null;
+}
+function assertion(value: unknown): Assertion | null {
+  const raw = object(value);
+  if (!raw || typeof raw.path !== 'string' || !safePath.test(raw.path)
+    || !['string', 'number', 'boolean'].includes(typeof raw.equals)) return null;
+  return { path: raw.path, equals: raw.equals as Assertion['equals'] };
+}
+function atPath(value: unknown, path: string): unknown {
+  return path.split('.').reduce<unknown>((current, key) =>
+    Array.isArray(current) && /^\d+$/.test(key) ? current[Number(key)] : object(current)?.[key], value);
+}
+
+/** Explicit finite mapping; prose alone never becomes executable shell. */
+export function parseBoundaryChecks(title: string): BoundaryCheck[] | null {
+  const line = /^\s*-?\s*완료 경계 실물 검증:\s*(.+)$/gm;
+  const matches = [...title.matchAll(line)];
+  if (matches.length !== 1) return null;
+  let parsed: unknown;
+  try { parsed = JSON.parse(matches[0]![1]!); } catch { return null; }
+  if (!Array.isArray(parsed) || parsed.length < 1 || parsed.length > 8) return null;
+  const checks: BoundaryCheck[] = [];
+  for (const value of parsed) {
+    const check = object(value);
+    if (!check) return null;
+    if (check.kind === 'test-run' && typeof check.command === 'string'
+      && parseGreenCloseEvidenceCommand(check.command).ok) {
+      checks.push({ kind: 'test-run', command: check.command });
+    } else if (check.kind === 'graph-run' && typeof check.graphId === 'string'
+      && safeGraphId.test(check.graphId) && typeof check.runId === 'string' && safeId.test(check.runId)
+      && typeof check.nodeId === 'string' && safeId.test(check.nodeId) && assertion(check.assertion)) {
+      checks.push({ kind: 'graph-run', graphId: check.graphId, runId: check.runId,
+        nodeId: check.nodeId, assertion: assertion(check.assertion)! });
+    } else if (check.kind === 'cli-json' && Array.isArray(check.argv)
+      && check.argv.every((arg) => typeof arg === 'string') && assertion(check.assertion)
+      && allowedReadOnlyCli(check.argv as string[])) {
+      checks.push({ kind: 'cli-json', argv: check.argv as string[], assertion: assertion(check.assertion)! });
+    } else return null;
+  }
+  return checks;
+}
+
+/** A deliberately small set of read-only production CLI calls. */
+export function allowedReadOnlyCli(argv: readonly string[]): boolean {
+  if (argv.length !== 7 || argv[0] !== 'bun' || argv[1] !== 'bin/elanous.mjs'
+    || argv[2] !== 'release' || argv[3] !== 'checklist' || argv[4] !== 'status'
+    || argv[5] !== '--version' || !/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/.test(argv[6] ?? '')) return false;
+  return true;
+}
+
+function checkGraphRun(input: BoundaryProofInput, check: GraphRun): boolean {
+  const path = resolve(input.stateRoot, 'graph-runs', check.graphId, `${check.runId}.json`);
+  const root = realpathSync(input.stateRoot);
+  if (!realpathSync(path).startsWith(root + '/')) return false;
+  const run = JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>;
+  const runInput = object(run.input);
+  const main = object(runInput?.main);
+  const node = Array.isArray(run.nodes) ? run.nodes.find((entry) => object(entry)?.nodeId === check.nodeId) : null;
+  const output = object(node)?.output;
+  const parsedOutput = typeof output === 'string' ? lastJsonObject(output) : output;
+  return run.graphId === check.graphId && run.runId === check.runId && run.status === 'done'
+    && runInput?.cellId === input.cellId && (runInput?.mainSha === input.mainSha || main?.sha === input.mainSha)
+    && object(node)?.ok === true && object(node)?.exit === 0
+    && atPath(parsedOutput, check.assertion.path) === check.assertion.equals;
+}
+
+function checkCliJson(input: BoundaryProofInput, check: CliJson): boolean {
+  const run = spawnElanousSync(['--config-dir', input.stateRoot, ...check.argv.slice(2), '--json'], {
+    bin: resolve(input.repoRoot, 'bin/elanous.mjs'), stateDir: input.stateRoot, cwd: input.repoRoot,
+    timeout: 30_000, maxBuffer: 2_000_000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (run.status !== 0) return false;
+  return atPath(JSON.parse(String(run.stdout)), check.assertion.path) === check.assertion.equals;
+}
+
+function checkTestRun(input: BoundaryProofInput, check: TestRun): boolean {
+  const command = parseGreenCloseEvidenceCommand(check.command);
+  if (!command.ok) return false;
+  const result = runGreenCloseEvidenceTest(input.repoRoot, input.mainSha, command.args);
+  return result.reason === 'completion-command-passed' && result.exitCode === 0;
+}
+
+/** Produce one immutable receipt for this map card's current graph run. */
+export function produceBoundaryProof(input: BoundaryProofInput): BoundaryProofResult {
+  const hold = (detail: string): BoundaryProofResult => ({ outcome: 'hold', reason: 'boundary-unproven', evidence: [detail] });
+  if (![input.cellId, input.mapRunId, input.cardId, input.graphRunId].every((id) => safeId.test(id))
+    || !sha.test(input.mainSha) || !input.title.includes('완료 경계 실물:')
+    || !isAbsolute(input.stateRoot) || !isAbsolute(input.repoRoot))
+    return hold('Boundary identity, absolute state root, or live clause missing');
+  const checks = parseBoundaryChecks(input.title);
+  const mappingHash = boundaryMappingHash(input.title);
+  if (!checks || !mappingHash) return hold('Live boundary has no supported, unambiguous verifier mapping');
+  try {
+    for (const check of checks) {
+      const pass = check.kind === 'test-run' ? checkTestRun(input, check)
+        : check.kind === 'graph-run' ? checkGraphRun(input, check) : checkCliJson(input, check);
+      if (!pass) return hold(`${check.kind} did not prove the live boundary`);
+    }
+    const live = /^\s*-?\s*완료 경계 실물:\s*(.+)$/m.exec(input.title)?.[1]?.trim();
+    if (!live) return hold('Live boundary line missing');
+    const proofRef = `boundary-proofs/${input.cellId}/${input.graphRunId}.json`;
+    const destination = resolve(input.stateRoot, proofRef);
+    if (existsSync(destination)) return hold('Existing boundary proof cannot be reused');
+    mkdirSync(dirname(destination), { recursive: true, mode: 0o700 });
+    const stateRoot = realpathSync(input.stateRoot);
+    if (!realpathSync(dirname(destination)).startsWith(stateRoot + '/'))
+      return hold('Boundary proof directory escapes the state root');
+    const temporary = `${destination}.${process.pid}.tmp`;
+    const proof = { schema: 'green-close-boundary-proof/v1', producer: 'green-close-boundary-producer/v1',
+      cellId: input.cellId, mainSha: input.mainSha, mapRunId: input.mapRunId, cardId: input.cardId,
+      graphRunId: input.graphRunId, runId: input.graphRunId, liveBoundary: live,
+      mappingHash,
+      outcome: 'pass', exitCode: 0, checks: checks.map((check) => ({ kind: check.kind, outcome: 'pass' })) };
+    try {
+      writeFileSync(temporary, `${JSON.stringify(proof)}\n`, { flag: 'wx', mode: 0o600 });
+      linkSync(temporary, destination); // atomic create; never replaces an existing receipt
+    } finally { if (existsSync(temporary)) unlinkSync(temporary); }
+    return { outcome: 'pass', reason: 'boundary-proof-produced', proofRef,
+      evidence: [`${checks.length} live boundary verifier(s) passed for ${input.graphRunId}`] };
+  } catch {
+    return hold('Live verifier failed or immutable proof could not be written');
+  }
+}

package/src/task-agent/completion-evidence.ts

@@ -148,7 +148,8 @@ export function checkCompletionEvidence(
     case 'decision-support': {
       if (!deps.ledger) { add('못 쟀다: 결정 원장'); break; }
       try {
-        if (!deps.ledger.list({ status: 'all' }).some((entry) => entry.id === input.ref)) add('결정 기록');
+        // 결정 카드는 그 과제를 `refs` 로 가리킨다 — 기록 id 든 카드 참조든 «그 과제의 기록»이다.
+        if (!deps.ledger.list({ status: 'all' }).some((entry) => entry.id === input.ref || entry.refs?.includes(input.ref))) add('결정 기록');
       } catch { add('못 쟀다: 결정 원장 읽기'); }
       break;
     }