elanous 0.2.36 → 0.2.37

package/src/task-agent/repair-cycle.ts

@@ -11,6 +11,8 @@ import { recordJourneyEdge } from '../self-dev/graph-journey-route.js';
 import { checklistHistory, listChecklist, parseOwner } from '../release-loop/checklist.js';
 import { applyRepairBundle, type RepairCasOutcome, type RepairCasRequest } from './repair-branch-cas.js';
 import { pairMoveId, repairNextMove } from './repair-next-move.js';
+import type { SupervisorGoalDeficit } from '../self-implement/goal-supervisor-fill.js';
+import { loadRunLedger, type RunLedgerEntry } from '../self-implement/run-ledger.js';
 import { parseRepairWorkerResult } from './repair-worker.js';
 import { TASK_SEATS, readTaskCard, updateTaskCard, type TaskCard, type TaskChildLlm, type TaskSeat } from './task-hand.js';
 
@@ -30,6 +32,9 @@ export interface RepairLaunchRequest {
 export interface RepairCycleInput {
   card: TaskCard; statePath: string; repo: string; pr: number; head: string; branch: string;
   mustFix: readonly string[]; liveMoves: ReadonlySet<string>; now: Date;
+  supervisorDeficit?: SupervisorGoalDeficit;
+  supervisorResult?: import('../self-implement/goal-supervisor-fill.js').SupervisorGoalFillResult;
+  readRunLedger?: (runId: string) => RunLedgerEntry[] | null;
   readFile?: (path: string) => string;
   request?: (input: RepairLaunchRequest) => Promise<void>;
   apply?: (input: RepairCasRequest) => RepairCasOutcome;
@@ -297,10 +302,46 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
   if (latest?.status === 'applied' && latest.head.toLowerCase() === head.toLowerCase())
     return { decision: 'repair-pending', reason: `repair pushed; await PR head ${latest.commit?.slice(0, 12) ?? '?'}` };
   const failedAttempts = attempts.filter((entry) => entry.status === 'failed');
+  let supervisorDeficit = input.supervisorDeficit;
+  let supervisorResult = input.supervisorResult;
+  if (!supervisorDeficit && card.runId) {
+    try {
+      const rows = (input.readRunLedger ?? loadRunLedger)(card.runId);
+      const recent = rows?.slice().reverse();
+      const latest = recent?.find((row) => row.event === 'goal-slot-fill' || row.event === 'supervisor-report-deficit');
+      const lastFill = recent?.find((row) => row.event === 'goal-slot-fill');
+      const lastDeficit = recent?.find((row) => row.event === 'supervisor-report-deficit');
+      const terminalClassification = lastDeficit?.data.classification;
+      const terminalReport = latest === lastDeficit && terminalClassification !== null && typeof terminalClassification === 'object'
+        && (terminalClassification as { classification?: unknown }).classification === 'report-deficit';
+      if (lastDeficit && (terminalReport || lastFill && latest === lastFill
+        && lastFill.data.result !== 'filled' && lastFill.data.result !== 'already-filled'
+        && lastFill.data.round === lastDeficit.data.round)
+        && lastDeficit.runId === card.runId && (terminalReport || lastFill?.runId === card.runId)
+        && typeof lastDeficit.data.evidenceId === 'string' && typeof lastDeficit.data.previousEvidence === 'string'
+        && typeof lastDeficit.data.round === 'number'
+        && (lastDeficit.data.kind === 'unmeasured' || lastDeficit.data.kind === 'unwired')) {
+        supervisorResult = terminalReport ? 'unverifiable' : lastFill?.data.result === 'rejected' ? 'rejected' : 'unverifiable';
+        supervisorDeficit = { evidenceId: lastDeficit.data.evidenceId, previousEvidence: lastDeficit.data.previousEvidence,
+          round: lastDeficit.data.round, kind: lastDeficit.data.kind,
+          ...(typeof lastDeficit.data.gateLog === 'string' ? { gateLog: lastDeficit.data.gateLog } : {}) };
+      }
+    } catch { /* unreadable ledger is not evidence of an unwired goal */ }
+  }
   const judged = repairNextMove({ pr, head, branch, mustFix: input.mustFix,
+    ...(supervisorDeficit ? { supervisorDeficit } : {}),
+    ...(supervisorResult ? { supervisorResult } : {}),
     priorNarrowAttempts: failedAttempts.filter((entry) => entry.move === 'narrow-relaunch' || entry.move === 'salvage-relaunch').length,
     priorAlternativeAttempts: failedAttempts.filter((entry) => entry.move === 'alternative').length },
     input.mintMoveId ? { mintMoveId: input.mintMoveId } : {});
+  if (judged.kind === 'grounding') {
+    const reason = `${judged.action} · evidence ${judged.supervisorDeficit.evidenceId}`;
+    updateTaskCard(statePath, card.id, (current) => current && !current.history?.some((entry) =>
+      entry.event === 'repair-grounding' && entry.runId === card.runId && entry.detail === reason)
+      ? { ...current, history: [...(current.history ?? []), { at: now.toISOString(), event: 'repair-grounding',
+        runId: card.runId, pr, head, detail: reason }] } : undefined);
+    return { decision: 'would-repair', reason };
+  }
   if (judged.kind === 'stop') {
     if (failedAttempts.length >= 2) {
       const detail = `수리 수렴 실패: PR #${pr} head ${head.slice(0, 12)} · 실패 ${failedAttempts.length}회 · ${judged.reason}`;

package/src/task-agent/repair-next-move.ts

@@ -1,5 +1,6 @@
 /** Existing TA retry judgement, routed through the declared recover → dispatch graph edge. */
 import { randomBytes } from 'node:crypto';
+import type { SupervisorGoalDeficit, SupervisorGoalFillResult } from '../self-implement/goal-supervisor-fill.js';
 import { judgeNextMove, type TaskJudgement } from './judge.js';
 import { readJourneyEdge, type JourneyRoute } from '../self-dev/graph-journey-route.js';
 
@@ -10,6 +11,8 @@ export interface RepairNextMoveInput {
   mustFix: readonly string[];
   priorNarrowAttempts: number;
   priorAlternativeAttempts: number;
+  supervisorDeficit?: SupervisorGoalDeficit;
+  supervisorResult?: SupervisorGoalFillResult;
 }
 
 /** HARNESS-FULL-GRAPH-NEXTMOVE — 수 한 건의 식별자. 결정 순간 «한 번» 만들고, 그 값을 결정·간선·발사에 그대로 내려보낸다(다시 계산 금지). */
@@ -40,9 +43,16 @@ export interface RepairNextMoveDeps {
 }
 
 export type RepairNextMove = { kind: 'dispatch'; judgement: TaskJudgement; route: JourneyRoute; source: `pr:${number}`; moveId: string }
-  | { kind: 'stop'; judgement: TaskJudgement; route: JourneyRoute; reason: string };
+  | { kind: 'stop'; judgement: TaskJudgement; route: JourneyRoute; reason: string }
+  | { kind: 'grounding'; action: 'remeasure' | 'connect-goal'; supervisorDeficit: SupervisorGoalDeficit };
 
-export function repairNextMove(input: RepairNextMoveInput, deps: RepairNextMoveDeps = {}): RepairNextMove {
+export function repairNextMove(input: RepairNextMoveInput | { supervisorDeficit: SupervisorGoalDeficit; supervisorResult?: 'unverifiable' | 'rejected' }, deps: RepairNextMoveDeps = {}): RepairNextMove {
+  const deficit = input.supervisorDeficit;
+  if (input.supervisorResult !== 'filled' && input.supervisorResult !== 'already-filled'
+    && (deficit?.kind === 'unmeasured' || deficit?.kind === 'unwired')) {
+    return { kind: 'grounding', action: deficit.kind === 'unmeasured' ? 'remeasure' : 'connect-goal', supervisorDeficit: deficit };
+  }
+  if (!('pr' in input)) throw new Error('grounding evidence is not an actionable repair move');
   const judged = judgeNextMove({ stopReason: 'needs-human', pr: input.pr, prState: 'OPEN', review: 'fail', mustFix: input.mustFix,
     failures: { 'narrow-relaunch': input.priorNarrowAttempts, alternative: input.priorAlternativeAttempts } });
   const route = readJourneyEdge('next-move', judged.move, { move: judged.move, source: `pr:${input.pr}`, head: input.head, branch: input.branch });

package/src/task-agent/review-prior-fix.ts

@@ -49,7 +49,14 @@ export function priorReviewRequest(requests: readonly ReviewRequest[] | undefine
  * 결과 파일에서 must-fix «문면»을 읽는다 — `self review --json` 의 결과 줄(뒤에서부터 첫 결과 모양)만.
  * 결과 모양 판정은 `parseReviewResultOutput` 과 같다(PR 번호 ⊕ (verdict ⊕ mustFix 배열 | error 문자열)).
  */
-export function readPriorMustFix(path: string | undefined, pr: number, read: (path: string) => string = (p) => readFileSync(p, 'utf8')): PriorMustFix {
+export function readPriorMustFix(
+  path: string | undefined,
+  pr: number,
+  expectedHeadOrRead?: string | ((path: string) => string),
+  readFile: (path: string) => string = (p) => readFileSync(p, 'utf8'),
+): PriorMustFix {
+  const expectedHead = typeof expectedHeadOrRead === 'string' ? expectedHeadOrRead : undefined;
+  const read = typeof expectedHeadOrRead === 'function' ? expectedHeadOrRead : readFile;
   if (!path) return { status: 'not-recovered', reason: 'no result path' };
   let text: string;
   try { text = read(path); } catch (error) {
@@ -68,6 +75,9 @@ export function readPriorMustFix(path: string | undefined, pr: number, read: (pa
     if (!isResult) continue;
     const prRaw = typeof v.pr === 'number' ? v.pr : typeof v.pr === 'string' ? Number(String(v.pr).replace(/^#/, '')) : NaN;
     if (prRaw !== pr) return { status: 'not-recovered', reason: `result PR ${Number.isFinite(prRaw) ? prRaw : 'unknown'} does not match #${pr}` };
+    if (expectedHead && (typeof v.headCommit !== 'string' || !SHA40.test(expectedHead) || v.headCommit.toLowerCase() !== expectedHead.toLowerCase())) {
+      return { status: 'not-recovered', reason: 'result head does not match prior review head' };
+    }
     if (typeof v.error === 'string') return { status: 'not-recovered', reason: `prior review error: ${v.error.slice(0, 200)}` };
     if (v.reviewed === false) return { status: 'not-recovered', reason: 'prior review did not run (reviewed:false)' };
     if (!Array.isArray(v.mustFix) || !v.mustFix.every((fix) => typeof fix === 'string')) return { status: 'not-recovered', reason: 'must-fix list unreadable' };
@@ -109,7 +119,7 @@ export function buildPriorFixContext(
   if (!prior) return null;
   let diff: PriorDiff | null;
   try { diff = (opts.priorDiff ?? defaultPriorDiff)(opts.cwd, prior.head, head); } catch { diff = null; }
-  return { fromHead: prior.head, toHead: head, diff, mustFix: readPriorMustFix(prior.resultPath, pr, opts.readFile) };
+  return { fromHead: prior.head, toHead: head, diff, mustFix: readPriorMustFix(prior.resultPath, pr, prior.head, opts.readFile) };
 }
 
 /** «직전 반영분» 블록 — 종전 런 줄 다음에 붙는다. */

package/src/task-agent/shadow.ts

@@ -5,7 +5,8 @@
  * - 기본 판단은 슈퍼바이저 결과에 이미 실린 종료 어휘·PR 번호·병합 여부를 쓴다.
  *   카드가 묶인 코드 PR의 target diff는 저장소가 고정된 gh 조회로 별도 측정한다. 리뷰 판정·must-fix 는 결과에 없으므로 비운다
  *   («통과»로 읽지 않는다 — 판단부가 review 수를 고른다).
- * - 슈퍼바이저의 기본 호출은 shadow: «했을 수»만 기록하고 명령·복사는 하나도 돌리지 않는다.
+ * - 슈퍼바이저의 기본 호출은 shadow: «했을 수»와 green would-green 판정만 기록한다. green 판정은
+ *   checklist·카드·git·gh·traffic을 읽을 수 있으나 checklist 쓰기·파일 복사는 하지 않는다.
  *   전달 과제의 명시적 live 호출만 파일을 복사한다. 설정 `taskAgent.mode=live` 는 기본 호출에 먹지 않는다.
  * - 관측: `debug.log('task-agent', 'shadow-move', …)` → `elanous logs --category task-agent`.
  */
@@ -13,12 +14,16 @@ import { lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { homedir } from 'node:os';
 import { extname, join, relative, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
 import { passJourneyNode } from '../self-dev/graph-journey-nodes.js';
 import { readJourneyEdge, recordJourneyEdge } from '../self-dev/graph-journey-route.js';
 import { mintMoveId } from './repair-next-move.js';
-import { readTaskAgentState, readTaskCard, taskAgentStatePath, TASK_CARD_PREFIX, type CompletionKind, type TaskCard } from './task-hand.js';
+import { readTaskAgentState, readTaskCard, taskAgentStatePath, TASK_CARD_PREFIX, defaultHandOf, type CompletionKind, type TaskCard } from './task-hand.js';
+import { checkCompletionEvidence, type CompletionEvidenceDeps } from './completion-evidence.js';
+import { openSchedulesDb } from '../domains/schedule-registry.js';
+import { DecisionLedger } from '../decisions/decision-ledger.js';
 import type { SupervisorJobResult, SupervisorStopReason } from '../self-dev/run-supervisor.js';
 import { executeNextAction, type ActionDeps, type DeliveryKind, type NextAction } from './actions.js';
 import { judgeNextMove, LIVE_RETRY_MOVES, type TaskJudgeInput, type TaskJudgement } from './judge.js';
@@ -28,9 +33,12 @@ import { collectWiringEvidence, readCardRunSnapshot, type WiringEvidenceDeps, ty
 import { remoteLedgerMirrorDir } from './parent-host.js';
 import { prodInstanceRoot } from '../instance/resolve.js';
 import { liveMoveHistoryEntry, recordLiveMoveHistory } from './live-move-history.js';
-import { updateTaskCard } from './task-hand.js';
+import { idempotentCreateCardForRun, updateTaskCard } from './task-hand.js';
 import { capturedSelfReview, captureReviewResults, hasCapturedPass } from './review-result-capture.js';
 import { configuredTaskAgentLiveMoves, defaultPrHead, executeLiveDecisionCard, executeLiveGreenProposal, executeLiveLand, executeLiveReview, type LiveMoveDeps, type LiveMoveResult, type TaskAgentLiveMove } from './live-moves.js';
+import { checklistDevVersion, listChecklist, type Checklist } from '../release-loop/checklist.js';
+import { ambiguousGreenSweepPrs, type GreenSweepPr } from './green-sweep.js';
+import type { GreenSweepProbe } from './actions.js';
 
 export interface TaskAgentShadowInput {
   runId: string | null;
@@ -81,12 +89,23 @@ export interface TaskAgentShadowDeps {
   wiring?: Omit<WiringEvidenceDeps, 'card'>;
   /** Complete PR target paths; undefined means unmeasured, never goal-only. */
   prFiles?: (pr: number, prUrl: string | undefined) => Promise<readonly string[] | undefined>;
+  /** GREEN-FROM-LEDGER-FU — 명시적 live green 실행에 필요한 판정 문맥. 기본 shadow 호출은 쓰지 않는다. */
+  greenSweep?: NonNullable<ActionDeps['greenSweep']>;
+  /** Checklist mutation is a separate OP-authorized capability; default false. */
+  greenWriteLive?: boolean;
+  /** Test seam for the production read-only probe builder; production callers use its defaults. */
+  greenSweepRuntime?: ProductionGreenSweepDeps;
   /** Process env for the launched-run id (`ELANOUS_RUN_ID`) — test seam; default process.env. */
   env?: NodeJS.ProcessEnv;
   /** Remote pending-move ledger seam; defaults to the run ledger. */
   queueMove?: typeof appendRunLedgerEntry;
   /** 시험 seam — 일반 재발사 결정의 수 id 발급기(기본 `mintMoveId` · #30226 과 같은 것). live 재발사로 갈 때 결정 순간 한 번만 불린다. */
   mintMoveId?: () => string;
+  /**
+   * DEFAULT-HANDS — «확인 증거» 저장소 의존(시험 주입). 없으면 그때 생산 저장소(스케줄 DB · 결정 원장)를 연다.
+   * 조사·산출물·콘텐츠는 «전달» 경로가 증거를 만들고, 여기 저장소 의존은 실행·감시·결정 지원에만 쓰인다.
+   */
+  evidence?: CompletionEvidenceDeps;
 }
 
 const execFileAsync = promisify(execFile);
@@ -107,6 +126,80 @@ export async function defaultPrFiles(pr: number, prUrl: string | undefined,
   return stdout.split(/\r?\n/).filter(Boolean);
 }
 
+export interface ProductionGreenSweepDeps {
+  readChecklist?: (version: string) => Checklist;
+  readCards?: (statePath: string) => readonly TaskCard[];
+  run?: (command: string, args: string[], cwd: string) => Promise<{ stdout: string }>;
+  trafficPath?: string;
+}
+
+/** Read-only production context for the green shadow. Any unreadable source remains unknown. */
+export function productionGreenSweep(checklistId: string, card: TaskCard | undefined, statePath: string, cwd: string,
+  deps: ProductionGreenSweepDeps = {}) {
+  const version = card?.checklistVersion ?? checklistDevVersion();
+  const readChecklist = deps.readChecklist ?? listChecklist;
+  const snapshot = readChecklist(version);
+  const item = snapshot.items.find((entry) => entry.id === checklistId);
+  if (!item) return undefined;
+  const cards = deps.readCards?.(statePath)
+    ?? Object.values(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath).tasks ?? {});
+  const ambiguous = ambiguousGreenSweepPrs(snapshot.items, version, cards);
+  const prCache = new Map<number, GreenSweepPr | null>();
+  const run = deps.run ?? (async (command, args, workingDirectory) => execFileAsync(command, args,
+    { cwd: workingDirectory, encoding: 'utf8', timeout: 20_000, maxBuffer: 4 * 1024 * 1024 }));
+  // This context is created once per shadow-move evaluation; these caches are turn-scoped.
+  let repoPromise: Promise<string | undefined> | undefined;
+  const repository = () => repoPromise ??= run('git', ['remote', 'get-url', 'origin'], cwd).then(({ stdout }) =>
+    /github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?$/i.exec(stdout.trim())?.[1]?.toLowerCase()).catch(() => undefined);
+  let mainPromise: Promise<boolean> | undefined;
+  const mainFresh = () => mainPromise ??= Promise.all([
+    run('git', ['rev-parse', 'origin/main'], cwd).then(({ stdout }) => stdout.trim()),
+    run('git', ['ls-remote', 'origin', 'refs/heads/main'], cwd).then(({ stdout }) => stdout.trim().split(/\s+/)[0] ?? ''),
+  ]).then(([local, remote]) => /^[a-f0-9]{40}$/i.test(local) && local === remote).catch(() => false);
+  const pr = async (number: number): Promise<GreenSweepPr | null> => {
+    if (prCache.has(number)) return prCache.get(number)!;
+    try {
+      const { stdout } = await run('gh', ['pr', 'view', String(number), '--json', 'number,state,mergeCommit,url'], cwd);
+      const value = JSON.parse(stdout) as { number?: number; state?: string; mergeCommit?: { oid?: string }; url?: string };
+      const result = value.number === number && typeof value.state === 'string'
+        ? { number, state: value.state, ...(value.mergeCommit?.oid ? { mergeSha: value.mergeCommit.oid } : {}), ...(value.url ? { url: value.url } : {}) }
+        : null;
+      prCache.set(number, result); return result;
+    } catch { prCache.set(number, null); return null; }
+  };
+  const probe: GreenSweepProbe = {
+    pr,
+    ancestor: async (sha) => {
+      if (!/^[a-f0-9]{40}$/i.test(sha) || !await mainFresh()) return null;
+      try { await run('git', ['merge-base', '--is-ancestor', sha, 'origin/main'], cwd); return true; }
+      catch (error) {
+        const code = (error as { code?: string | number }).code;
+        return code === 1 || code === '1' ? false : null;
+      }
+    },
+    hold: async () => {
+      try {
+        const trafficPath = deps.trafficPath ?? process.env.ELANOUS_TRAFFIC_SIGNAL ?? join(homedir(), 'elanous-hq', 'seat-state', 'OP', 'traffic.json');
+        const value: unknown = JSON.parse(readFileSync(trafficPath, 'utf8'));
+        return value && typeof value === 'object' && !Array.isArray(value) && Array.isArray((value as { hold?: unknown }).hold)
+          && (value as { hold: unknown[] }).hold.every((entry) => typeof entry === 'string')
+          ? (value as { hold: string[] }).hold.includes(checklistId) : null;
+      } catch { return null; }
+    },
+    repositoryMatches: async (number) => {
+      const [originRepo, candidate] = await Promise.all([repository(), pr(number)]);
+      const prRepo = /^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/\d+(?:\/|$)/i.exec(candidate?.url ?? '')?.[1]?.toLowerCase();
+      return originRepo && prRepo ? originRepo === prRepo : null;
+    },
+    ambiguousAcrossCells: (number) => ambiguous.has(number),
+    cellEvidence: async (cell) => {
+      try { return readChecklist(version).items.find((entry) => entry.id === cell)?.evidence ?? ''; }
+      catch { return undefined; }
+    },
+  };
+  return { probe, item, version, cards };
+}
+
 export const REMOTE_CARD_MOVE_PENDING = 'task-agent-card-move-pending';
 
 /** NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 일반 재발사가 발사 명령을 «성공»으로 받은 뒤 그 카드 history 에 남기는 줄의 이름. */
@@ -157,6 +250,39 @@ function isDeliveryKind(kind: CompletionKind | undefined): kind is DeliveryKind
   return kind !== undefined && DELIVERY_KINDS.has(kind);
 }
 
+/**
+ * DEFAULT-HANDS — 저장소 기록이 곧 «확인 증거»인 종결 종류(§A4c): 실행(실행 기록 ⊕ 되읽기) ·
+ * 감시·브리핑(일정 ⊕ 도착) · 결정 지원(카드 ⊕ 기록). 조사·산출물·콘텐츠는 «전달» 경로가 증거를 만들고,
+ * 전달(deliverable)은 `dispatchDeliverableCompletion` 이 부르는 손이 ref 를 준다.
+ */
+const STORE_EVIDENCE_KINDS: ReadonlySet<CompletionKind> = new Set<CompletionKind>(['ops-action', 'watch-brief', 'decision-support']);
+
+/** 증거 저장소 — 주입이 없으면 그때 생산 저장소를 열고 스케줄 DB 는 닫는다(판정 밖으로 새지 않게). */
+function withEvidenceStores<T>(kind: CompletionKind, deps: TaskAgentShadowDeps, run: (deps: CompletionEvidenceDeps) => T): T {
+  if (deps.evidence) return run(deps.evidence);
+  if (kind === 'watch-brief') {
+    const db = openSchedulesDb();
+    try { return run({ schedulesDb: db }); } finally { db.close(); }
+  }
+  if (kind === 'decision-support') return run({ ledger: new DecisionLedger() });
+  return run({});
+}
+
+/**
+ * DEFAULT-HANDS — code-pr 밖 종결의 «확인 증거»를 생산 경로에서 잰다(규칙 정본 = `completion-evidence.ts`,
+ * 여기서 다시 짓지 않는다). 기록 id = 카드 id — 그 과제가 남긴 실행 기록·일정·결정 카드가 그 id 로 쌓인다.
+ * 대상을 모르면(카드 없음 · 프로젝트 대상 없음 · PR 이 묶인 카드) 재지 않는다 — «통과»로 읽지 않는다.
+ */
+function storeCompletionEvidence(kind: CompletionKind | undefined, card: TaskCard | undefined,
+  deps: TaskAgentShadowDeps): { ok: boolean; ref: string } | undefined {
+  if (kind === undefined || kind === 'code-pr' || !STORE_EVIDENCE_KINDS.has(kind)) return undefined;
+  if (!card || card.pr !== undefined) return undefined;
+  const dir = card.project?.target;
+  if (!dir) return undefined;
+  const verdict = withEvidenceStores(kind, deps, (evidenceDeps) => checkCompletionEvidence(kind, { dir, ref: card.id }, evidenceDeps));
+  return { ok: verdict.ok, ref: verdict.ref };
+}
+
 /**
  * 슈퍼바이저 결과에서 판단부 입력을 만든다 — 추가 조회 없이 이미 실린 값만.
  * `completion` 은 카드의 종결 종류(§A4b③) — 있으면 판단부 입력에 싣는다(비면 종전 입력 그대로).
@@ -285,6 +411,10 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   }
   const kind = card?.completion;
   const judgeInput = shadowJudgeInput(input.stopReason, input.results, kind);
+  // DEFAULT-HANDS — 저장소가 증거인 종결(실행·감시·결정 지원)은 그 기록을 여기서 읽어 판단부 입력에 싣는다.
+  // 이 배선이 없으면 그 종결들은 영영 «확인 증거 대기»에 머문다(사람 손 1 이 필요해진다).
+  const handEvidence = storeCompletionEvidence(kind, card, deps);
+  if (handEvidence) judgeInput.evidence = handEvidence;
   // 슈퍼바이저가 나른 리뷰가 없으면 그 PR 카드에 회수된 리뷰 결과(pass · 실제로 돈 리뷰 · 머리 sha)를 같은 입력 칸으로 쓴다.
   let selfReview = input.selfReview;
   let reviewFromCapture = false;
@@ -332,6 +462,34 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
       ? { move: 'wait', stage: 'observing', reason: '전달 후보 확인 — 산출물 판독 대기', executorKind: 'deliver' }
       : { move: 'wait', stage: 'waiting', reason: '전달 후보 없음' }
     : judgeNextMove(judgeInput);
+  // TA-REVIEW-PASS — 카드 없는 runId 의 «리뷰가 필요한 PR» 판정에서만 고유한 런 소유(그 run 이 성공 결과로 연 PR)를 검증해
+  // 단일 잠금/멱등 원시 함수로 runId 를 카드 1건에 결속한다. 성공 결과 taskId·기존 카드 조회·runId 매칭은 위에서 먼저 존중한다.
+  // 원격 Pod 자식 런·카드 조회 실패·원장 읽기 실패·복수 카드는 임의 생성하지 않고 사유를 남겨 보류한다(fail-closed).
+  if (!card && !cardLookupFailed && !remoteChild && !deps.readCard && input.runId
+    && judgement.move === 'review' && typeof judgeInput.pr === 'number'
+    && input.results.some((result) => result.prNumber === judgeInput.pr && result.ok === true && result.worktreePath)) {
+    const prResult = input.results.find((result) => result.prNumber === judgeInput.pr);
+    // 상속 ELANOUS_RUN_ID(Pod 자식 런의 부모)가 있으면 이 runId 는 이 런의 고유 소유가 아니다 — 임의 결속 없이 보류한다.
+    const inheritedRunId = env.ELANOUS_RUN_ID;
+    if (inheritedRunId && inheritedRunId !== input.runId) {
+      try {
+        (deps.log ?? ((c, e, d) => debug.log(c, e, d, { level: 'warn' })))('task-agent', 'card-create-for-run-deferred',
+          { runId: input.runId, pr: judgeInput.pr, reason: `inherited ELANOUS_RUN_ID ${inheritedRunId} — pod child run은 이 runId를 고유 소유하지 않는다` });
+      } catch { /* fail-closed — 보류 사유 기록 실패는 판정을 막지 않는다 */ }
+    } else {
+    const bound = idempotentCreateCardForRun(cardStatePath(deps), {
+      runId: input.runId, text: prResult?.feature ?? successful?.feature ?? input.runId, env,
+      ...(deps.live?.now ? { now: deps.live.now } : {}),
+    });
+    if (bound.ok) card = bound.card;
+    else {
+      try {
+        (deps.log ?? ((c, e, d) => debug.log(c, e, d, { level: 'warn' })))('task-agent', 'card-create-for-run-deferred',
+          { runId: input.runId, pr: judgeInput.pr, reason: bound.reason });
+      } catch { /* fail-closed — 보류 사유 기록 실패는 판정을 막지 않는다 */ }
+    }
+    }
+  }
   if (judgement.reason.startsWith('goal-only-pr —') && input.runId) {
     try {
       (deps.queueMove ?? appendRunLedgerEntry)({ timestamp: new Date().toISOString(), runId: input.runId,
@@ -358,7 +516,7 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
       pr: delivery ? 0 : typeof judgeInput.pr === 'number' ? judgeInput.pr : 0,
       runId: input.runId ?? '',
       original: [...new Set(input.results.map((result) => result.feature))].join(' · '),
-      checklistId: delivery ? card?.checklistId ?? '' : '',
+      checklistId: delivery ? card?.checklistId ?? '' : judgement.executorKind === 'green' ? card?.checklistId ?? '' : '',
       ...(delivery ? { delivery } : {}),
     };
     const retryMove = !delivery && (LIVE_RETRY_MOVES as readonly string[]).includes(judgement.move);
@@ -366,11 +524,32 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
       { move: judgement.move, source: judgeInput.pr ? `pr:${judgeInput.pr}` : `run:${input.runId ?? 'unknown'}`, runId: input.runId }) : null;
     const liveRetry = retryMove && route?.source === 'graph' && route.to === 'dispatch'
       && deps.command !== undefined && deps.loadGate !== undefined && liveMoves.has(judgement.move as TaskAgentLiveMove);
+    let greenSweep = action.kind === 'green' ? deps.greenSweep : undefined;
+    if (action.kind === 'green' && !greenSweep && action.checklistId) {
+      const hasSuccessfulWorktree = Boolean(successful?.worktreePath);
+      if (!successful?.worktreePath) {
+        try { (deps.log ?? ((c, e, d) => debug.log(c, e, d, { level: 'warn' })))('task-agent', 'green-sweep-context-unavailable',
+          { checklistId: action.checklistId, reason: 'successful-worktree-missing; process cwd probe cannot establish repository match' }); } catch { /* fail-soft */ }
+      }
+      try {
+        greenSweep = productionGreenSweep(action.checklistId, card, cardStatePath(deps), successful?.worktreePath ?? process.cwd(), deps.greenSweepRuntime);
+        // Without a run-owned checkout, cwd may point at another repository; never let it establish a match.
+        if (!hasSuccessfulWorktree && greenSweep) greenSweep = { ...greenSweep,
+          probe: { ...greenSweep.probe, repositoryMatches: async () => null } };
+      }
+      catch (error) {
+        try { (deps.log ?? ((c, e, d) => debug.log(c, e, d, { level: 'warn' })))('task-agent', 'green-sweep-context-unavailable',
+          { checklistId: action.checklistId, reason: (error instanceof Error ? error.message : String(error)).slice(-300) }); } catch { /* fail-soft */ }
+      }
+    }
     // NEXTMOVE-GENERAL-RELAUNCH-MOVEID — live 재발사로 가는 결정 순간 수 id 를 «한 번» 만든다(이미 실린 값이 있으면 그것).
     //   아래 발사 argv · 결정 노드 출구 · graph-edge-taken · 카드 history 가 이 값만 쓴다(다시 만들지 않는다).
     if (liveRetry) generalMoveId = action.moveId ?? (deps.mintMoveId ?? mintMoveId)();
     executorResult = await executeNextAction(generalMoveId ? { ...action, moveId: generalMoveId } : action, {
-      mode: delivery ? (deps.mode ?? 'shadow') : liveRetry ? 'live' : 'shadow',
+      // Green is a completion boundary: only an explicit live invocation may reach the verified writer.
+      mode: delivery ? (deps.mode ?? 'shadow')
+        : action.kind === 'green' && deps.mode === 'live' && deps.greenWriteLive === true ? 'live'
+          : liveRetry ? 'live' : 'shadow',
       command: deps.command ?? (async () => { throw new Error('task-agent shadow path must not run commands'); }),
       observe: (event, data) => {
         wouldDo = data.reason;
@@ -380,6 +559,8 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
         catch { /* Observation must not alter the selected move. */ }
       },
       ...(liveRetry ? { liveMoves, retryLaunches, loadGate: deps.loadGate } : {}),
+      ...(greenSweep ? { greenSweep } : {}),
+      ...(action.kind === 'green' ? { greenWriteLive: deps.mode === 'live' && deps.greenWriteLive === true } : {}),
     });
     if (liveRetry && executorResult === 'done' && route) {
       passJourneyNode('next-move', { provenance: 'task-agent-terminal', outcome: judgement.move,
@@ -514,6 +695,8 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   // 판단 관측은 원격 미결 수를 실제 원장에 기록한 결과까지 확정한 뒤 남긴다.
   (deps.log ?? ((category, event, data) => debug.log(category, event, data)))('task-agent', 'shadow-move', {
     ...move, completion: shadowCompletion(card, cardLookupFailed), card: liveCard?.id ?? pendingCardId,
+    // DEFAULT-HANDS — 이 카드가 어느 손으로 나가는지(«개발»/«실행·조사»)를 판단 관측에 싣는다.
+    hand: kind !== undefined ? defaultHandOf(kind) : null,
     live, liveExecuted: liveMove?.executed ?? false, ...(liveMove ? { liveOk: liveMove.ok } : {}),
     ...(cardBinding ? { cardBinding } : {}),
     ...(reviewFromCapture ? { reviewSource: 'captured-review-result' } : {}),