elanous 0.2.18 → 0.2.20

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

@@ -0,0 +1,292 @@
+/**
+ * TA-CARD-RUN-LINK — 과제 카드의 런 id 로 그 런이 연 골 id · PR 을 런 원장에서 읽어 카드에 «한 번» 적는다.
+ * - 순수 판정 `bindCardEvidence(card, snapshot)` — 호스트 원장 → Pod 자식 원장(`pod-child-run`) → 호스트 logs 의
+ *   `self-implement.pod job-finished {childRunId, prUrl}` 순. 모르면 비운다(추측하지 않는다).
+ * - `refreshCardRunBinding` 은 `tasks show`·`tasks advance` 가 부른다 — 읽기 조회이고, 찾았을 때만 잠금 안에서 카드의
+ *   `goalId`·`pr {number,url}`(UX LOOP-INTERACT 계약 칸)을 비어 있을 때만 적는다 · 수동 근거(refSource manual)는 덮지 않는다.
+ * - 관측: `debug.log('task-agent', 'card-pr-bound', {card, runId, pr})`.
+ */
+import { existsSync } from 'node:fs';
+import { STOP_CLASS_POD_FAILURE, STOP_CLASS_NO_LAUNCH } from '../task-orchestrator/surfaces/pod-failure-reason.js';
+import { readLaunchBinding } from '../harness/launch-registry.js';
+import { readRunExits, type RunExit } from '../harness/harness-incidents.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { debug } from '../debug/log.js';
+import { LogStore, logsDbPath } from '../mss/logging/log-store.js';
+import type { RunLedgerEntry } from '../self-implement/run-ledger.js';
+import { cardPrNumber, taskAgentStatePath, updateTaskCard, readTaskCard, type TaskCard } from './task-hand.js';
+import { judgeNextMove } from './judge.js';
+
+const GOAL_ID = /^[a-f0-9]{16}$/;
+const PR_URL = /^https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/(\d+)$/;
+const RUN_ID = /^run-[A-Za-z0-9_-]{4,64}$/;
+
+/** 카드 런 하나의 원장 사진 — host = 카드 런 원장(없으면 null) · children = `pod-child-run` 자식 원장 · podFinishes = 호스트 logs. */
+export interface CardRunSnapshot {
+  host: readonly RunLedgerEntry[] | null;
+  children: Readonly<Record<string, readonly RunLedgerEntry[] | null>>;
+  podFinishes?: ReadonlyArray<{ childRunId: string; prUrl: string; state?: string; childError?: string }>;
+  /** 읽기 «실패»(원장·logs) — 부재(null)와 갈린다. 있으면 refresh 가 card-bind-failed 를 남긴다. */
+  readErrors?: readonly string[];
+}
+
+export interface CardRunEvidence {
+  goalId?: string;
+  pr?: { number: number; url?: string };
+  childRunId?: string;
+  /** 호스트 원장이 있었나 — 없으면 런이 아직 시작 전이거나 대기열로 갔다. */
+  ledgerFound: boolean;
+}
+
+function entryGoal(entry: RunLedgerEntry): string | undefined {
+  const value = entry.goalId ?? (typeof entry.data?.goalId === 'string' ? entry.data.goalId : undefined);
+  return typeof value === 'string' && GOAL_ID.test(value) ? value : undefined;
+}
+
+/**
+ * 그 PR 의 골 id — PR 의 `pr-opened` 줄 골이 먼저. 없으면 원장 전체의 골이 «하나뿐»이고 다른 PR 줄이 골을 싣지 않았을 때만
+ * 그 골(대응이 모호하면 비운다 — set-once 라 틀린 짝은 못 고친다).
+ */
+function goalIdOf(entries: readonly RunLedgerEntry[], prNumber: number): string | undefined {
+  const own = [...entries].reverse().find((entry) => entry.event === 'pr-opened' && entry.data?.number === prNumber && entryGoal(entry));
+  if (own) return entryGoal(own);
+  if (entries.some((entry) => entry.event === 'pr-opened' && entry.data?.number !== prNumber && entryGoal(entry))) return undefined;
+  const goals = new Set(entries.map(entryGoal).filter((value): value is string => value !== undefined));
+  return goals.size === 1 ? [...goals][0] : undefined;
+}
+
+function lastPr(entries: readonly RunLedgerEntry[]): { number: number; url?: string } | undefined {
+  for (let at = entries.length - 1; at >= 0; at--) {
+    const entry = entries[at]!;
+    if (entry.event !== 'pr-opened') continue;
+    const number = entry.data?.number;
+    if (!Number.isSafeInteger(number) || (number as number) <= 0) continue;
+    const url = typeof entry.data.url === 'string' && PR_URL.exec(entry.data.url)?.[1] === String(number) ? entry.data.url : undefined;
+    return { number: number as number, ...(url ? { url } : {}) };
+  }
+  return undefined;
+}
+
+/** 자식 런 id — 호스트 원장의 `pod-child-run` 만(호스트 런 자신은 빼고 · 순서 유지). */
+export function podChildRunIds(host: readonly RunLedgerEntry[] | null, runId?: string): string[] {
+  return [...new Set((host ?? []).filter((entry) => entry.event === 'pod-child-run' && typeof entry.data?.childRunId === 'string'
+    && RUN_ID.test(entry.data.childRunId) && entry.data.childRunId !== runId).map((entry) => entry.data.childRunId as string))];
+}
+
+/** 순수 — 카드 런의 골 id · PR. PR 은 호스트 → 자식(나중 자식 먼저) → job-finished 순으로 처음 찾은 것. */
+export function bindCardEvidence(card: Pick<TaskCard, 'runId'>, snapshot: CardRunSnapshot): CardRunEvidence {
+  if (!card.runId || !snapshot.host) return { ledgerFound: false };
+  const children = podChildRunIds(snapshot.host, card.runId).reverse();
+  const childLedgers = children.map((id) => [id, snapshot.children[id] ?? null] as const);
+  let pr = lastPr(snapshot.host);
+  let childRunId: string | undefined;
+  for (const [id, entries] of childLedgers) {
+    if (pr) break;
+    const found = entries ? lastPr(entries) : undefined;
+    if (found) { pr = found; childRunId = id; }
+  }
+  for (const id of children) {
+    if (pr) break;
+    const finish = [...(snapshot.podFinishes ?? [])].reverse().find((row) => row.childRunId === id && PR_URL.test(row.prUrl));
+    const number = finish ? Number(PR_URL.exec(finish.prUrl)![1]) : NaN;
+    if (finish && Number.isSafeInteger(number) && number > 0) { pr = { number, url: finish.prUrl }; childRunId = id; }
+  }
+  // 골 id 는 PR 을 낸 런의 것뿐이고 PR 과 함께만 — 자식이 냈으면 그 자식 원장의 골(아직 없으면 비움 · 나중 조회가 채운다),
+  // 호스트가 냈으면 호스트 골. PR 전에는 누가 낼지 모르니 골도 묶지 않는다(set-once 라 섞이면 못 고친다).
+  const childGoal = (id: string) => { const entries = snapshot.children[id]; return entries && pr ? goalIdOf(entries, pr.number) : undefined; };
+  const goalId = pr ? (childRunId ? childGoal(childRunId) : goalIdOf(snapshot.host, pr.number)) : undefined;
+  return { ledgerFound: true, ...(goalId ? { goalId } : {}), ...(pr ? { pr } : {}), ...(childRunId ? { childRunId } : {}) };
+}
+
+/** DRAFT-NOT-ARCHIVE — 원장의 마지막 `salvaged`(self-implement.draft-not-archive) 줄이 남긴 수확 가지. 없으면 undefined. */
+export function salvageBranchOf(entries: readonly RunLedgerEntry[] | null | undefined): string | undefined {
+  return lastSalvaged(entries)?.branch;
+}
+
+function lastSalvaged(entries: readonly RunLedgerEntry[] | null | undefined): { branch: string; at: number; order: number } | undefined {
+  for (let at = (entries?.length ?? 0) - 1; at >= 0; at--) {
+    const entry = entries![at]!;
+    const branch = entry.event === 'salvaged' ? entry.data?.salvageBranch : undefined;
+    if (typeof branch === 'string' && branch.startsWith('salvage/')) return { branch, at: Date.parse(entry.timestamp ?? ''), order: at };
+  }
+  return undefined;
+}
+
+/** 카드 런(호스트 → 자식 나중 것부터)의 수확 가지. 원장을 못 읽었으면 `readErrors` 로 갈린다(⛔ «없음» 이 아니다). */
+export async function readCardSalvageBranch(card: Pick<TaskCard, 'runId' | 'createdAt'>, deps: CardRunEvidenceDeps = {}): Promise<{ salvageBranch: string | null; readErrors?: readonly string[] }> {
+  if (!card.runId) return { salvageBranch: null };
+  const snapshot = await readCardRunSnapshot(card, { ...deps, podFinishes: () => [] });
+  // 호스트 ⊕ Pod 자식 원장 전체에서 «가장 나중»(타임스탬프) 수확 가지. 시각이 같거나 못 읽으면 호스트가 이긴다.
+  const candidates = [lastSalvaged(snapshot.host), ...podChildRunIds(snapshot.host, card.runId).map((id) => lastSalvaged(snapshot.children[id]))]
+    .filter((row): row is NonNullable<typeof row> => row !== undefined);
+  const latest = candidates.reduce<typeof candidates[number] | undefined>((best, row) => !best || (Number.isFinite(row.at) && (!Number.isFinite(best.at) || row.at > best.at)) ? row : best, undefined);
+  return { salvageBranch: latest?.branch ?? null, ...(snapshot.readErrors?.length ? { readErrors: snapshot.readErrors } : {}) };
+}
+
+/** 원장·logs 읽기(시험 주입). */
+export interface CardRunEvidenceDeps {
+  loadLedger?: (runId: string) => RunLedgerEntry[] | null;
+  podFinishes?: (childRunIds: readonly string[], sinceIso: string) => Array<{ childRunId: string; prUrl: string; state?: string; childError?: string }>;
+  now?: () => Date;
+  launchBound?: (runId: string) => boolean;
+  dispatchPod?: (runId: string, sinceIso: string) => boolean;
+  runExit?: (runId: string) => RunExit | undefined;
+}
+
+async function defaultLoadLedger(): Promise<(runId: string) => RunLedgerEntry[] | null> {
+  const { loadRunLedger, runLedgerDir, resolveFederatedRunLedgerDirectories } = await import('../self-implement/run-ledger.js');
+  let dirs: string[] = [runLedgerDir()];
+  // 연합 목록을 못 읽으면 이 우주만 읽되, 여기서 못 찾으면 «없음»이 아니라 실패로 올린다(card-bind-failed).
+  let federationFailure: unknown;
+  try { dirs = [...new Set([...dirs, ...resolveFederatedRunLedgerDirectories({})])]; } catch (error) { federationFailure = new Error(`federated run-ledger lookup failed: ${error instanceof Error ? error.message : String(error)}`); }
+  return ledgerLoader(dirs, (runId, dir) => loadRunLedger(runId, dir), federationFailure);
+}
+
+/** 디렉터리들에서 첫 원장 — 어디서도 못 찾았고 읽기(또는 연합 목록) 실패가 있었으면 부재(null)가 아니라 던진다. */
+export function ledgerLoader(dirs: readonly string[], load: (runId: string, dir: string) => RunLedgerEntry[] | null, priorFailure?: unknown): (runId: string) => RunLedgerEntry[] | null {
+  return (runId) => {
+    let failure: unknown = priorFailure;
+    for (const dir of dirs) {
+      try { const entries = load(runId, dir); if (entries) return entries; } catch (error) { failure ??= error; }
+    }
+    if (failure !== undefined) throw failure;
+    return null;
+  };
+}
+
+function defaultDispatchPod(runId: string, sinceIso: string): boolean {
+  const path = logsDbPath();
+  if (!existsSync(path)) return false;
+  const store = LogStore.openReadOnly(path);
+  try {
+    const sinceMs = Date.parse(sinceIso);
+    return store.queryAll({ exactCategories: ['harness.substrate'], events: ['dispatch-pod'], ...(Number.isFinite(sinceMs) ? { sinceMs } : {}) })
+      .some((row) => { try { return (JSON.parse(row.data ?? '{}') as { runId?: string }).runId === runId; } catch { return false; } });
+  } finally { store.close(); }
+}
+
+async function defaultPodFinishes(): Promise<NonNullable<CardRunEvidenceDeps['podFinishes']>> {
+  return (childRunIds, sinceIso) => {
+    const path = logsDbPath();
+    if (!childRunIds.length || !existsSync(path)) return [];
+    const store = LogStore.openReadOnly(path);
+    try {
+      const wanted = new Set(childRunIds);
+      const rows: Array<{ childRunId: string; prUrl: string; state?: string; childError?: string }> = [];
+      const sinceMs = Date.parse(sinceIso);
+      for (const row of store.queryAll({ exactCategories: ['self-implement.pod'], events: ['job-finished'], ...(Number.isFinite(sinceMs) ? { sinceMs } : {}) })) {
+        let data: { childRunId?: unknown; prUrl?: unknown; state?: unknown; childError?: unknown } | null = null;
+        try { data = row.data ? JSON.parse(row.data) : null; } catch { continue; }
+        if (typeof data?.childRunId === 'string' && wanted.has(data.childRunId)) rows.push({ childRunId: data.childRunId, prUrl: typeof data.prUrl === 'string' ? data.prUrl : '', ...(typeof data.state === 'string' ? { state: data.state } : {}), ...(typeof data.childError === 'string' ? { childError: data.childError } : {}) });
+      }
+      return rows;
+    } finally { store.close(); }
+  };
+}
+
+/** 카드 런의 원장 사진을 읽는다 — 읽기 실패는 «없음»(null)이다. */
+export async function readCardRunSnapshot(card: Pick<TaskCard, 'runId' | 'createdAt'>, deps: CardRunEvidenceDeps = {}): Promise<CardRunSnapshot> {
+  if (!card.runId) return { host: null, children: {} };
+  const load = deps.loadLedger ?? await defaultLoadLedger();
+  const readErrors: string[] = [];
+  const reason = (error: unknown) => (error instanceof Error ? error.message : String(error)).slice(0, 300);
+  const safe = (runId: string) => { try { return load(runId); } catch (error) { readErrors.push(`ledger ${runId}: ${reason(error)}`); return null; } };
+  const host = safe(card.runId);
+  const childIds = podChildRunIds(host, card.runId);
+  const children = Object.fromEntries(childIds.map((id) => [id, safe(id)]));
+  let podFinishes: NonNullable<CardRunSnapshot['podFinishes']> = [];
+  if (childIds.length && (!host || !lastPr(host))) {
+    try { podFinishes = (deps.podFinishes ?? await defaultPodFinishes())(childIds, card.createdAt); } catch (error) { readErrors.push(`logs: ${reason(error)}`); }
+  }
+  return { host, children, podFinishes, ...(readErrors.length ? { readErrors } : {}) };
+}
+
+/**
+ * 카드에 런 근거를 채운다 — 런 id 가 있고 아직 비어 있는 칸(goalId·pr)만, 잠금 안에서 «한 번».
+ * 찾지 못했으면 쓰지 않는다. 쓴(또는 그대로인) 카드를 돌려준다.
+ */
+export async function refreshCardRunBinding(cardId: string, statePath = taskAgentStatePath(), deps: CardRunEvidenceDeps = {}): Promise<{ card: TaskCard | undefined; evidence?: CardRunEvidence }> {
+  const card = readTaskCard(cardId, statePath);
+  // 수동 근거(refSource manual)는 덮지 않는다 · 둘 다 차 있으면 다시 읽지 않는다(한 번만).
+  if (!card?.runId || card.refSource === 'manual' || (card.pr !== undefined && card.goalId !== undefined)) return { card };
+  const snapshot = await readCardRunSnapshot(card, deps);
+  if (snapshot.readErrors?.length) {
+    try { debug.log('task-agent', 'card-bind-failed', { card: cardId, runId: card.runId, errors: snapshot.readErrors }); } catch { /* fail-soft */ }
+  }
+  const evidence = bindCardEvidence(card, snapshot);
+  if (card.status === 'launched' && !card.pr && !evidence.pr && !snapshot.readErrors?.length) {
+    const rows = [...(snapshot.host ?? []), ...Object.values(snapshot.children).flatMap((entries) => entries ?? [])];
+    let exit: RunExit | undefined;
+    let exitReadFailed = false;
+    try { exit = (deps.runExit ?? ((id) => readRunExits(effectiveInstanceRoot()).find((row) => row.runId === id)))(card.runId); }
+    catch { exitReadFailed = true; }
+    const finished = [...(snapshot.podFinishes ?? [])].reverse().find((item) => item.state === 'failed');
+    const parentTerminal = [...(snapshot.host ?? [])].reverse().find((item) => item.event === 'run-status');
+    const parentFailed = parentTerminal?.data?.runStatus === 'failed';
+    const boundAt = card.history.find((item) => item.event === 'run-bound')?.at;
+    const elapsed = boundAt ? (deps.now ?? (() => new Date()))().getTime() - Date.parse(boundAt) : NaN;
+    const launched = rows.some((entry) => entry.event === 'pod-child-run');
+    let dispatched = false;
+    let dispatchReadFailed = false;
+    try { dispatched = (deps.dispatchPod ?? defaultDispatchPod)(card.runId, boundAt ?? card.createdAt); }
+    catch { dispatchReadFailed = true; }
+    let launchBound = false;
+    let launchReadFailed = false;
+    try { launchBound = (deps.launchBound ?? ((id) => !!readLaunchBinding(id)))(card.runId); }
+    catch { launchReadFailed = true; }
+    const timedOut = !finished && !launched && !dispatched && !dispatchReadFailed && !exit && !exitReadFailed && !launchBound && !launchReadFailed && Number.isFinite(elapsed) && elapsed >= 600_000;
+    const hasPr = !!card.pr || !!evidence.pr;
+    const exitHarvestBranch = exit?.lastLines?.some((line) => /(?:수확할 브랜치: |ELANOUS_POD_SALVAGE )(?:salvage\/|self-impl\/)[^\s]+/.test(line)) ?? false;
+    const ledgerFailure = rows.find((entry) => entry.event === 'run-status' && entry.data?.runStatus === 'failed'
+      && (entry.data?.failureKind === STOP_CLASS_POD_FAILURE || entry.data?.stop_class === STOP_CLASS_POD_FAILURE));
+    const resultFailure = rows.find((entry) => entry.event === 'result-without-error' && entry.data?.ok === false);
+    const noLaunchExit = exit?.reason === STOP_CLASS_NO_LAUNCH && exit.status !== null && exit.status !== 0 && !launched && !dispatched && !dispatchReadFailed;
+    // 발사 근거가 있는 런이 nonzero 로 끝났고 분류기가 pod-failure 나 unknown(원인 미상)을 냈다 = 죽은 런(TA-JUDGE-DEAD-RUN ③ «exit 1 · unknown/pod-failure»).
+    const deadExit = (exit?.reason === STOP_CLASS_POD_FAILURE || exit?.reason === 'unknown') && exit.status !== null && exit.status !== 0;
+    const podFailure = !noLaunchExit && (launched || dispatched) && (parentFailed && (finished || !!ledgerFailure || !!resultFailure) || deadExit)
+      && (finished || ledgerFailure || resultFailure || deadExit);
+    const failure = podFailure ? judgeNextMove({ terminalRun: {
+      kind: STOP_CLASS_POD_FAILURE,
+      reason: finished?.childError || (exit?.status != null ? `exit ${exit.status} · ${exit.reason || STOP_CLASS_POD_FAILURE}` : resultFailure ? 'result-without-error · failed' : finished ? `job-finished failed · ${STOP_CLASS_POD_FAILURE}` : `run-status failed · ${STOP_CLASS_POD_FAILURE}`),
+      hasPr,
+      hasHarvestBranch: exitHarvestBranch || rows.some((entry) => typeof entry.data?.harvestBranch === 'string' && !!entry.data.harvestBranch) || !!salvageBranchOf(rows),
+    } }) : noLaunchExit ? judgeNextMove({ terminalRun: { kind: STOP_CLASS_NO_LAUNCH, reason: `exit ${exit!.status} · ${exit!.reason}`, hasPr, hasHarvestBranch: false } })
+      : timedOut ? judgeNextMove({ terminalRun: { kind: STOP_CLASS_NO_LAUNCH, reason: 'card-run-bound 뒤 10분 동안 Pod 발사 근거 없음', hasPr: false, hasHarvestBranch: false } }) : undefined;
+    if (failure?.reason.startsWith('failed/')) {
+      const at = (deps.now ?? (() => new Date()))().toISOString();
+      const next = updateTaskCard(statePath, cardId, (current) => current?.status === 'launched' && current.runId === card.runId && !current.pr && current.refSource !== 'manual' ? {
+        ...current, status: 'failed', history: [...current.history, { at, event: 'failed', detail: failure.reason, runId: card.runId }],
+      } : undefined);
+      return { card: next, evidence };
+    }
+  }
+  // 이미 묶인 PR 이 있으면 «같은» PR(번호 ⊕ 낸 자식)을 다시 찾았을 때만 뒤늦은 골을 채운다.
+  const samePr = (current: TaskCard) => current.pr === undefined
+    || (evidence.pr !== undefined && cardPrNumber(current) === evidence.pr.number && current.runChildId === evidence.childRunId);
+  const wantsGoal = card.goalId === undefined && evidence.goalId && samePr(card);
+  const wantsPr = card.pr === undefined && evidence.pr;
+  if (!wantsGoal && !wantsPr) return { card, evidence };
+  const at = (deps.now ?? (() => new Date()))().toISOString();
+  const wrote = { pr: false };
+  const next = updateTaskCard(statePath, cardId, (current) => {
+    if (!current || current.runId !== card.runId || current.refSource === 'manual') return undefined;
+    const goal = current.goalId === undefined && evidence.goalId && samePr(current) ? evidence.goalId : undefined;
+    const pr = current.pr === undefined && evidence.pr ? evidence.pr : undefined;
+    if (!goal && !pr) return undefined;
+    wrote.pr = pr !== undefined;
+    return {
+      ...current,
+      ...(goal ? { goalId: goal } : {}),
+      ...(pr ? { pr, ...(evidence.childRunId && !current.runChildId ? { runChildId: evidence.childRunId } : {}) } : {}),
+      history: [
+        ...(current.history ?? []),
+        ...(goal ? [{ at, event: 'goal-bound', detail: goal, runId: current.runId! }] : []),
+        ...(pr ? [{ at, event: 'pr-bound', detail: pr.url ?? `#${pr.number}`, runId: current.runId!, pr: pr.number }] : []),
+      ],
+    };
+  });
+  if (wrote.pr && typeof next?.pr === 'object') {
+    try { debug.log('task-agent', 'card-pr-bound', { card: cardId, runId: next.runId ?? null, pr: next.pr.number, url: next.pr.url ?? null, childRunId: next.runChildId ?? null }); } catch { /* fail-soft */ }
+  }
+  return { card: next, evidence };
+}

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

@@ -0,0 +1,126 @@
+import { readFileSync, statSync } from 'node:fs';
+import { extname, isAbsolute, relative, resolve, sep } from 'node:path';
+import type { Database } from 'bun:sqlite';
+import type { DecisionLedger } from '../decisions/decision-ledger.js';
+import { getLastStatus } from '../domains/schedule-registry.js';
+
+export type CompletionEvidenceKind = 'research-report' | 'artifact' | 'content' | 'ops-action' | 'watch-brief' | 'decision-support';
+export interface CompletionEvidenceDeps {
+  ledger?: Pick<DecisionLedger, 'list'>;
+  schedulesDb?: Database;
+}
+
+/** A missing record is negative evidence; a failed read is explicitly unmeasured. No store is opened or mutated here. */
+export function checkCompletionEvidence(
+  kind: CompletionEvidenceKind,
+  input: { dir: string; ref: string },
+  deps: CompletionEvidenceDeps = {},
+): { ok: boolean; ref: string; missing: string[] } {
+  const missing: string[] = [];
+  const add = (item: string) => { if (!missing.includes(item)) missing.push(item); };
+  const pathFor = (ref: string): string | null => {
+    const root = resolve(input.dir);
+    const path = resolve(root, ref);
+    const rel = relative(root, path);
+    return !isAbsolute(ref) && rel !== '..' && !rel.startsWith(`..${sep}`) ? path : null;
+  };
+  const read = (path: string): string | null => {
+    try { return readFileSync(path, 'utf8'); }
+    catch (error) {
+      add((error as NodeJS.ErrnoException).code === 'ENOENT' ? '파일' : '못 쟀다: 파일 읽기');
+      return null;
+    }
+  };
+  const file = () => {
+    const path = pathFor(input.ref);
+    if (!path) add('못 쟀다: 경로');
+    return path;
+  };
+
+  switch (kind) {
+    case 'research-report': {
+      const path = file();
+      if (!path) break;
+      if (extname(path).toLowerCase() !== '.md') { add('md 파일'); break; }
+      const text = read(path);
+      if (text === null) break;
+      const sources = new Set([...text.matchAll(/https?:\/\/[^\s<>"')\]]+/g)].map((match) => match[0]!.replace(/[.,;]+$/, '')));
+      if (sources.size < 2) add('출처');
+      if (!/^#{1,6}\s*반대 근거\s*$/m.test(text)) add('반대 근거');
+      break;
+    }
+    case 'artifact':
+    case 'content': {
+      const path = file();
+      if (!path) break;
+      try {
+        const stat = statSync(path);
+        if (!stat.isFile() || stat.size === 0) add('파일 크기');
+      } catch (error) { add((error as NodeJS.ErrnoException).code === 'ENOENT' ? '파일' : '못 쟀다: 파일 크기'); }
+      const stem = path.slice(0, path.length - extname(path).length);
+      let preview = false;
+      for (const ext of ['.png', '.pdf', '.html']) {
+        const candidate = `${stem}${ext}`;
+        if (candidate === path) continue;
+        try {
+          const stat = statSync(candidate);
+          if (stat.isFile() && stat.size > 0) preview = true;
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code !== 'ENOENT') add('못 쟀다: 미리보기 읽기');
+        }
+      }
+      if (extname(path).toLowerCase() === '.md' && !missing.includes('파일')) {
+        const text = read(path);
+        if (text !== null && /^#{1,6}\s+\S.*$/m.test(text)) preview = true;
+      }
+      if (!preview && !missing.some((item) => item.startsWith('못 쟀다: 미리보기') || item === '못 쟀다: 파일 읽기')) add('미리보기');
+      break;
+    }
+    case 'ops-action': {
+      const path = pathFor('execution.jsonl');
+      if (!path) { add('못 쟀다: 경로'); break; }
+      let text: string;
+      try { text = readFileSync(path, 'utf8'); }
+      catch (error) {
+        add((error as NodeJS.ErrnoException).code === 'ENOENT' ? '실행 기록' : '못 쟀다: 실행 기록 읽기');
+        break;
+      }
+      let execution = false;
+      let readback = false;
+      for (const line of text.split('\n').filter((line) => line.trim())) {
+        let record: unknown;
+        try { record = JSON.parse(line); }
+        catch { add('못 쟀다: 실행 기록 해석'); continue; }
+        if (!record || typeof record !== 'object') { add('못 쟀다: 실행 기록 해석'); continue; }
+        const entry = record as { id?: unknown; type?: unknown };
+        if (entry.id !== input.ref) continue;
+        if (entry.type === 'execution') execution = true;
+        if (entry.type === 'readback') readback = true;
+      }
+      if (!missing.includes('못 쟀다: 실행 기록 해석')) {
+        if (!execution) add('실행 기록');
+        if (!readback) add('되읽기');
+      }
+      break;
+    }
+    case 'watch-brief': {
+      if (!deps.schedulesDb) { add('못 쟀다: 스케줄 DB'); break; }
+      try {
+        const row = deps.schedulesDb.query('SELECT id FROM schedule_registry WHERE id = ?').get(input.ref);
+        if (!row) add('일정');
+        else if (getLastStatus(deps.schedulesDb, input.ref) !== 'ok') add('도착');
+      } catch { add('못 쟀다: 스케줄 DB 읽기'); }
+      break;
+    }
+    case 'decision-support': {
+      if (!deps.ledger) { add('못 쟀다: 결정 원장'); break; }
+      try {
+        if (!deps.ledger.list({ status: 'all' }).some((entry) => entry.id === input.ref)) add('결정 기록');
+      } catch { add('못 쟀다: 결정 원장 읽기'); }
+      break;
+    }
+    default:
+      add('못 쟀다: 증거 종류');
+  }
+  return { ok: missing.length === 0, ref: input.ref, missing };
+}

package/src/task-agent/judge.ts

@@ -4,8 +4,10 @@
  * RFC-task-agent-any-task-to-completion-2026-10-06 §A2 표를 순수 함수로 옮긴다.
  * 부작용이 없다(발사·리뷰·착지는 실행부 `actions.ts` 의 몫). 수확 원천 = run-c9ad6d6d `chooseTaskAction`.
  */
+import { STOP_CLASS_POD_FAILURE, STOP_CLASS_NO_LAUNCH } from '../task-orchestrator/surfaces/pod-failure-reason.js';
 import type { SupervisorStopReason } from '../self-dev/run-supervisor.js';
 import type { NextActionKind, RetryVariant } from './actions.js';
+import type { CompletionKind } from './task-hand.js';
 
 export type TaskMove =
   | 'propose-green'
@@ -27,6 +29,13 @@ export interface TaskJudgeInput {
   mustFix?: readonly string[];
   /** 수마다 누적 실패 수. */
   failures?: Partial<Record<TaskMove, number>>;
+  deliveryEvidence?: { ok: boolean; files: readonly string[]; reason: string };
+  /** 과제 종결 종류(§A4b③) — 비거나 code-pr 이면 종전처럼 PR 병합이 종결이다. */
+  completion?: CompletionKind;
+  /** code-pr 밖 종류의 확인 증거(`completion-evidence.ts` 판독). 비면 «아직 못 받았다» — 통과로 읽지 않는다. */
+  evidence?: { ok: boolean; ref: string };
+  /** Only classified terminal evidence; an absent input preserves the existing stop-reason table. */
+  terminalRun?: { kind: typeof STOP_CLASS_POD_FAILURE | typeof STOP_CLASS_NO_LAUNCH; reason: string; hasPr: boolean; hasHarvestBranch: boolean };
 }
 
 export interface TaskJudgement {
@@ -64,7 +73,23 @@ const EXECUTOR_VARIANT: Partial<Record<TaskMove, RetryVariant>> = {
 };
 
 function base(input: TaskJudgeInput): Omit<TaskJudgement, 'executorKind'> {
+  if (input.deliveryEvidence) return input.deliveryEvidence.ok
+    ? { move: 'propose-green', stage: 'closing', reason: `전달 근거 확인: ${input.deliveryEvidence.files.join(', ')}` }
+    : { move: 'wait', stage: 'waiting', reason: input.deliveryEvidence.reason };
+  if (input.terminalRun && !input.terminalRun.hasPr && !input.terminalRun.hasHarvestBranch) {
+    const disposition = input.terminalRun.kind === STOP_CLASS_POD_FAILURE ? 'needs-owner' : 'needs-relaunch';
+    return { move: 'wait', stage: 'escalated', reason: `failed/${disposition} — ${input.terminalRun.reason.replace(/[\r\n]+/gu, ' ').trim() || input.terminalRun.kind}` };
+  }
   const stop = input.stopReason;
+  const kind = input.completion;
+  if (kind !== undefined && kind !== 'code-pr') {
+    const ref = input.evidence?.ref?.trim() ?? '';
+    // green 은 추적 가능한 근거(비지 않은 ref)가 있을 때만 — ok 인데 ref 가 비면 «증거 없음»으로 읽는다.
+    if (input.evidence?.ok === true && ref) return { move: 'propose-green', stage: 'closing', reason: `확인 증거 ${ref} 근거로 칸 green 제안 — ${kind}` };
+    if (input.evidence?.ok === false) return { move: 'narrow-relaunch', stage: 'repairing', reason: `확인 증거 미충족(${ref || '근거 없음'}) — ${kind} · 범위를 좁혀 재발사` };
+    // 증거가 아직 없다 — 완주·종료 미관측이면 증거를 기다린다(PR 병합은 이 종류의 종결이 아니다). 그 밖의 종료 어휘는 아래 표 그대로.
+    if (stop === 'converged' || stop === undefined) return { move: 'wait', stage: 'observing', reason: `확인 증거 대기 — ${kind}${input.evidence?.ok === true ? ' (ref 비어 있음)' : ''}` };
+  }
   const merged = input.prState === 'MERGED' && input.pr !== undefined && input.pr !== '';
   if (merged) {
     return { move: 'propose-green', stage: 'closing', reason: `병합된 PR ${input.pr} 근거로 칸 green 제안` };