elanous 0.2.15 → 0.2.17

package/src/session-runtime/retry-policy.ts

@@ -364,7 +364,61 @@ export function decideProviderFallback(input: {
   return { action: 'advance', nextProvider, category, attempts };
 }
 
-export type RetryAction = 'retry' | 'abort' | 'ask-user' | 'auto-undo';
+/** Consecutive overload/5xx/rate-limit outcomes that switch the child off codex
+ *  before the same provider spends its remaining retries. Other errors (400)
+ *  never count. Recovery is this many later non-overload outcomes. */
+export const OVERLOAD_FAILOVER_STREAK = 3;
+
+export type LlmCallOutcomeKind = 'ok' | 'overloaded' | '5xx' | 'rate-limit' | 'other';
+
+/** One finished LLM call. Launch failover reads only this shape. */
+export interface LlmCallOutcome {
+  readonly provider: string;
+  readonly status: number;
+  readonly kind: LlmCallOutcomeKind;
+}
+
+const CODEX_CALL_PROVIDERS = new Set(['codex', 'openai-codex']);
+
+export function llmCallOutcomeKind(status: number, message = ''): LlmCallOutcomeKind {
+  if (status >= 200 && status < 300) return 'ok';
+  const msg = message.toLowerCase();
+  if (status === 429 || msg.includes('rate limit') || msg.includes('too many requests')) return 'rate-limit';
+  if (
+    status === 500 || status === 502 || status === 503 || status === 504 ||
+    msg.includes('overloaded') || msg.includes('server_busy') || msg.includes('server_error')
+  ) {
+    return status >= 500 ? '5xx' : 'overloaded';
+  }
+  if (msg.includes('overloaded')) return 'overloaded';
+  return 'other';
+}
+
+export function isOverloadOutcomeKind(kind: LlmCallOutcomeKind): boolean {
+  return kind === 'overloaded' || kind === '5xx' || kind === 'rate-limit';
+}
+
+/** True when the newest `limit` codex outcomes are all overload-class.
+ *  A non-codex row or a non-overload row breaks the streak. Empty input is false. */
+export function codexOverloadStreakReached(
+  outcomes: readonly LlmCallOutcome[],
+  limit = OVERLOAD_FAILOVER_STREAK,
+): boolean {
+  if (limit < 1 || outcomes.length < limit) return false;
+  const tail = outcomes.slice(-limit);
+  return tail.every((row) => CODEX_CALL_PROVIDERS.has(row.provider) && isOverloadOutcomeKind(row.kind));
+}
+
+/** True when the newest `limit` outcomes are successful (any provider). */
+export function overloadRecovered(
+  outcomes: readonly LlmCallOutcome[],
+  limit = OVERLOAD_FAILOVER_STREAK,
+): boolean {
+  if (limit < 1 || outcomes.length < limit) return false;
+  return outcomes.slice(-limit).every((row) => row.kind === 'ok');
+}
+
+export type RetryAction = 'retry' | 'abort' | 'ask-user' | 'auto-undo' | 'switch-provider';
 
 export interface RetryDecision {
   action: RetryAction;
@@ -417,6 +471,16 @@ export interface RetryContext {
   /** Optional: retry-after header string from a 429 response (ms or
    *  seconds or HTTP date). decideRetry parses it. */
   retryAfter?: string;
+  /** Configured fallbacks still unused. When > 0, an overload-class
+   *  failure that has already repeated `overloadStreak` times switches
+   *  provider instead of spending another retry on the same one.
+   *  Omitted or 0 keeps the historical retry-until-exhausted behaviour. */
+  remainingFallbacks?: number;
+  /** Consecutive overload-class failures already seen for this call,
+   *  including the one under decision. Default threshold is
+   *  OVERLOAD_FAILOVER_STREAK. */
+  overloadStreak?: number;
+  overloadStreakLimit?: number;
 }
 
 /** Classify an error into a RetryCategory without making an action
@@ -519,10 +583,42 @@ export function classifyError(err: unknown): RetryCategory {
   return 'unknown';
 }
 
+function isOverloadSwitchCandidate(msg: string, code: string | null): boolean {
+  return (
+    code === '429' || code === '500' || code === '502' || code === '503' || code === '504' ||
+    msg.includes('rate limit') || msg.includes('too many requests') ||
+    msg.includes('overloaded') || msg.includes('server_busy') || msg.includes('server_error')
+  );
+}
+
+function overloadSwitchDecision(ctx: RetryContext): RetryDecision | undefined {
+  const remaining = ctx.remainingFallbacks ?? 0;
+  if (remaining <= 0) return undefined;
+  const limit = ctx.overloadStreakLimit ?? OVERLOAD_FAILOVER_STREAK;
+  const streak = ctx.overloadStreak ?? 1;
+  if (streak < limit) return undefined;
+  return {
+    action: 'switch-provider',
+    category: 'overloaded',
+    reason: `overload streak ${streak} with ${remaining} fallback(s) left; switch before spending retries`,
+  };
+}
+
 /** Pure verdict. Caller sleeps + retries or aborts per the returned
  *  action. Exponential backoff baseline: 500ms * 2^attempt, clamped
  *  to [500, 30_000]. */
 export function decideRetry(err: unknown, ctx: RetryContext): RetryDecision {
+  const msg = extractMessage(err).toLowerCase();
+  const code = extractErrorCode(err);
+
+  // Overload with a fallback still unused switches before the doom
+  // window (k === 3) turns the same 503 into auto-undo. A 400 is not
+  // a candidate. Doom still wins for every other repeated failure.
+  if (isOverloadSwitchCandidate(msg, code)) {
+    const switched = overloadSwitchDecision(ctx);
+    if (switched) return switched;
+  }
+
   // Doom-loop always wins — even a technically-retryable error
   // becomes auto-undo after N identical failures. The caller may
   // still degrade to ask-user when plan mode is active or when the
@@ -535,9 +631,6 @@ export function decideRetry(err: unknown, ctx: RetryContext): RetryDecision {
     };
   }
 
-  const msg = extractMessage(err).toLowerCase();
-  const code = extractErrorCode(err);
-
   // Context window exhausted — never retry (the next call will also
   // be over-sized). Abort and surface the error to the caller; upstream
   // can trigger compaction.
@@ -589,8 +682,16 @@ export function decideRetry(err: unknown, ctx: RetryContext): RetryDecision {
     };
   }
 
-  // Overloaded / server busy.
-  if (msg.includes('overloaded') || msg.includes('server_busy') || code === '503') {
+  // Overloaded / server busy / 5xx.
+  if (
+    msg.includes('overloaded') ||
+    msg.includes('server_busy') ||
+    msg.includes('server_error') ||
+    code === '500' ||
+    code === '502' ||
+    code === '503' ||
+    code === '504'
+  ) {
     return {
       action: 'retry',
       delayMs: backoffMs(ctx.attempt),

package/src/steward/working-backwards.ts

@@ -57,7 +57,22 @@ export async function recordWorkingBackwardsOnCards(
       debug.log('steward.working-backwards', 'skipped-launched-before-draft', { issueId: issue.identifier });
       continue;
     }
-    const draft = await draftWorkingBackwards(issue, ask);
+    // An invalid draft for the same issue text is not re-asked every tick — each ask is a 70-100 s LLM call (10-05 ELA-29 timed the schedule stage out 3×).
+    const invalidKey = `hitl:draft-invalid-${createHash('sha256').update(JSON.stringify({ title: issue.title, body: issue.body ?? '' })).digest('hex').slice(0, 16)}`;
+    if (card.sections.some(section => section.key === invalidKey)) {
+      debug.log('steward.working-backwards', 'skipped-known-invalid', { issueId: issue.identifier });
+      throw new InvalidWorkingBackwardsDraft();
+    }
+    let draft: WorkingBackwardsDraft;
+    try { draft = await draftWorkingBackwards(issue, ask); }
+    catch (error) {
+      if (error instanceof InvalidWorkingBackwardsDraft) {
+        // The memo is best-effort — failing to write it must not replace the invalid-draft error the caller routes to hitl.
+        try { store.appendSection(card.id, { key: invalidKey, owner: 'steward', content: 'working-backwards draft invalid for this issue text — not re-asked until the issue changes' }); }
+        catch (memoError) { debug.log('steward.working-backwards', 'invalid-memo-failed', { issueId: issue.identifier, error: memoError instanceof Error ? memoError.message : String(memoError) }); }
+      }
+      throw error;
+    }
     for (const [section, content] of [['prfaq', draft.prfaq], ['manual', draft.manual]] as const) {
       const key = `${section}:${createHash('sha256').update(content).digest('hex')}`;
       if (!card.sections.some(item => item.key === key)) store.appendSection(card.id, { key, owner: 'steward', content });

package/src/task-agent/actions.ts

@@ -0,0 +1,118 @@
+export type NextActionKind = 'review' | 'land' | 'retry' | 'green' | 'decision';
+export interface NextAction {
+  kind: NextActionKind;
+  taskId: string;
+  rationale: string;
+  pr: number;
+  runId: string;
+  original: string;
+  checklistId: string;
+  history?: string[];
+  mustFix?: string[];
+  cwd?: string;
+  risk?: 'money' | 'security' | 'irreversible-publication';
+}
+export interface ActionDeps {
+  command(args: string[]): Promise<{ status: number; stdout: string; stderr?: string }>;
+  mode?: string;
+  landingsToday?: number;
+  landingDay?: string;
+  saveState?(): void;
+  dailyLimit?: number;
+  failures?: number;
+  failureCounts?: Record<string, number>;
+  /** 하루 착지 칸을 잠금 안에서 먼저 확보한다 — 다른 프로세스와 같은 잔여 칸을 두 번 쓰지 않게. 없으면 메모리 셈. */
+  reserveLanding?(day: string, limit: number): boolean;
+  /** 병합이 확인되지 않으면 확보한 칸을 돌려준다. */
+  releaseLanding?(day: string): void;
+  /** 실패 한 번을 잠금 안에서 디스크에 더한다(다른 프로세스의 실패를 덮지 않게) · 더한 뒤의 값을 돌려준다. */
+  incrementFailure?(key: string): number;
+  observe(event: 'task-agent.action', data: { taskId: string; kind: NextActionKind; result: string; reason: string }): void;
+}
+
+export async function executeNextAction(action: NextAction, deps: ActionDeps): Promise<string> {
+  const record = (result: string, reason: string) => {
+    if (result === 'failed' && (deps.failureCounts || deps.incrementFailure)) {
+      const key = JSON.stringify([action.taskId, action.kind]);
+      const next = deps.incrementFailure ? deps.incrementFailure(key) : (deps.failureCounts![key] ?? 0) + 1;
+      if (deps.failureCounts) deps.failureCounts[key] = next;
+      if (!deps.incrementFailure) deps.saveState?.();
+    }
+    deps.observe('task-agent.action', { taskId: action.taskId, kind: action.kind, result, reason });
+    return result;
+  };
+  if (deps.mode !== 'live') return record('shadow', `would ${action.kind}: ${action.rationale}`);
+  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(['decisions', 'raise', '--title', `${action.taskId}: ${reason}`, '--category', action.risk === 'money' ? 'money' : action.risk === 'security' ? 'security' : action.risk === 'irreversible-publication' ? 'publish' : 'other', '--s', `Task ${action.taskId} needs a decision.`, '--c', reason, '--ref', evidence, '--q', 'Which action should be taken?', '--option', 'h=Keep on hold:no automatic execution', '--option', 'p=Approve action:execute after approval', '--skip-recommend', 'requires human decision', '--no-xcheck', 'automated escalation']);
+    return record(result.status === 0 ? 'decision' : 'failed', reason);
+  };
+  if (action.risk) return card(`risk: ${action.risk}`);
+  if ((deps.failureCounts?.[JSON.stringify([action.taskId, action.kind])] ?? deps.failures ?? 0) >= 2) 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']);
+    if (view.status !== 0) return card('PR labels unavailable');
+    let labels: unknown;
+    try { labels = (JSON.parse(view.stdout) as { labels?: unknown }).labels; }
+    catch { return card('PR labels unavailable'); }
+    if (!Array.isArray(labels) || !labels.every(label => label && typeof label === 'object' && typeof label.name === 'string')) return card('PR labels unavailable');
+    if (labels.some(label => label.name === 'elanous:release-path')) return card('release-path');
+    const day = new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
+    if (deps.landingDay && deps.landingDay !== day) deps.landingsToday = 0;
+    deps.landingDay = day;
+    const limit = deps.dailyLimit ?? 5;
+    if (deps.reserveLanding ? !deps.reserveLanding(day, limit) : (deps.landingsToday ?? 0) >= limit) return card('daily landing limit');
+  }
+  if (action.kind === 'decision') return card(action.rationale);
+  if (action.kind === 'green') return card('green requires a verified landing in this execution');
+  if (action.kind === 'retry' && !action.mustFix?.length) return card('must-fix missing; cannot narrow retry');
+  if (action.kind === 'review') {
+    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 };
+    try {
+      const payload: unknown = JSON.parse(review.stdout);
+      const item = Array.isArray(payload) ? payload.find((entry: unknown) => entry && typeof entry === 'object' && 'pr' in entry && Number(entry.pr) === action.pr) : payload;
+      if (!item || typeof item !== 'object' || Array.isArray(item)) return record('failed', 'invalid review JSON');
+      parsed = item as typeof parsed;
+    } catch { return record('failed', 'invalid review JSON'); }
+    if (parsed.reviewed !== true) return record('failed', 'review was not performed');
+    if (parsed.verdict === 'pass') { record('done', 'review pass'); return executeNextAction({ ...action, kind: 'land', history: [...(action.history ?? []), 'review pass'] }, deps); }
+    if (parsed.verdict === 'fail' && Array.isArray(parsed.mustFix) && parsed.mustFix.length > 0 && parsed.mustFix.every(fix => typeof fix === 'string' && fix.trim())) { record('done', 'review fail'); return executeNextAction({ ...action, kind: 'retry', mustFix: parsed.mustFix, history: [...(action.history ?? []), 'review fail'] }, deps); }
+    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', `${action.original}\n\nMust-fix:\n${(action.mustFix ?? []).join('\n')}\n\nPrevious run: ${action.runId}`];
+  const day = deps.landingDay ?? new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
+  const outcome = await deps.command(args);
+  if (outcome.status !== 0) {
+    if (action.kind === 'land') deps.releaseLanding?.(day);
+    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']);
+    let sha: string | undefined;
+    let notMerged = false;
+    try {
+      const value = JSON.parse(merged.stdout) as { state?: string; mergeCommit?: { oid?: string } };
+      if (merged.status === 0 && value.state === 'MERGED' && /^[a-f0-9]{40}$/i.test(value.mergeCommit?.oid ?? '')) sha = value.mergeCommit?.oid;
+      else if (merged.status === 0 && typeof value.state === 'string' && value.state !== 'MERGED') notMerged = true;
+    } catch { /* unknown merge state is never green */ }
+    if (!sha) {
+      // «열림»으로 확인됐을 때만 칸을 돌려준다. 상태를 못 읽었으면 병합됐을 수 있으니 칸은 쓴 것으로 둔다(상한을 넘지 않게).
+      if (notMerged) deps.releaseLanding?.(day);
+      return card('landing commit unknown; checklist remains unchanged');
+    }
+    record('done', action.rationale);
+    if (!deps.reserveLanding) deps.landingsToday = (deps.landingsToday ?? 0) + 1;
+    deps.saveState?.();
+    const green = await deps.command(['release', 'checklist', 'set', action.checklistId, '--status', 'green', '--evidence', `${action.pr}·${sha}`]);
+    // 체크리스트 실패는 이 과제·land 의 실패로 센다(두 번이면 다음엔 카드).
+    if (green.status !== 0) return record('failed', `green command failed: ${green.stderr ?? ''}`);
+    deps.observe('task-agent.action', { taskId: action.taskId, kind: 'green', result: 'done', reason: action.rationale });
+    return 'done';
+  }
+  return record('done', action.rationale);
+}

package/src/task-agent/judge.ts

@@ -0,0 +1,96 @@
+/**
+ * TASK-AGENT 판단부 — 슈퍼바이저 종료 어휘(+ PR·리뷰 관측) → «다음 한 수».
+ *
+ * RFC-task-agent-any-task-to-completion-2026-10-06 §A2 표를 순수 함수로 옮긴다.
+ * 부작용이 없다(발사·리뷰·착지는 실행부 `actions.ts` 의 몫). 수확 원천 = run-c9ad6d6d `chooseTaskAction`.
+ */
+import type { SupervisorStopReason } from '../self-dev/run-supervisor.js';
+import type { NextActionKind } from './actions.js';
+
+export type TaskMove =
+  | 'propose-green'
+  | 'review'
+  | 'propose-land'
+  | 'narrow-relaunch'
+  | 'wait-retry'
+  | 'salvage-relaunch'
+  | 'alternative'
+  | 'decision-card'
+  | 'wait';
+
+export interface TaskJudgeInput {
+  stopReason?: SupervisorStopReason;
+  prState?: 'OPEN' | 'MERGED' | 'CLOSED';
+  pr?: string | number;
+  /** `self review --json` 판정. 관측 못 했으면 비운다(«통과»로 읽지 않는다). */
+  review?: 'pass' | 'fail';
+  mustFix?: readonly string[];
+  /** 수마다 누적 실패 수. */
+  failures?: Partial<Record<TaskMove, number>>;
+}
+
+export interface TaskJudgement {
+  move: TaskMove;
+  stage: 'observing' | 'closing' | 'reviewing' | 'repairing' | 'waiting' | 'escalated';
+  reason: string;
+  /** 실행부(`executeNextAction`)가 바로 받는 수면 그 종류. 없으면 발사·대기 계열(실행부 밖). */
+  executorKind?: NextActionKind;
+}
+
+/** 같은 수가 이 횟수만큼 실패하면 다른 수로 넘어간다(RFC §A2 «같은 수 2번 실패»). */
+export const SAME_MOVE_FAILURE_LIMIT = 2;
+
+const EXECUTOR_KIND: Partial<Record<TaskMove, NextActionKind>> = {
+  'propose-green': 'green',
+  review: 'review',
+  'propose-land': 'land',
+  'narrow-relaunch': 'retry',
+  'wait-retry': 'retry',
+  'salvage-relaunch': 'retry',
+  alternative: 'retry',
+  'decision-card': 'decision',
+};
+
+function base(input: TaskJudgeInput): Omit<TaskJudgement, 'executorKind'> {
+  const stop = input.stopReason;
+  const merged = input.prState === 'MERGED' && input.pr !== undefined && input.pr !== '';
+  if (merged) {
+    return { move: 'propose-green', stage: 'closing', reason: `병합된 PR ${input.pr} 근거로 칸 green 제안` };
+  }
+  switch (stop) {
+    case 'harvestable-awaiting-human':
+    case 'needs-human':
+      if (input.review === 'pass') return { move: 'propose-land', stage: 'reviewing', reason: 'self review 통과 — 착지 제안' };
+      if (input.review === 'fail') {
+        return { move: 'narrow-relaunch', stage: 'repairing', reason: `must-fix 로 좁혀 재발사: ${(input.mustFix ?? []).join(' · ') || '(must-fix 비어 있음)'}` };
+      }
+      return { move: 'review', stage: 'reviewing', reason: '수확 가능 런 — self review 필요' };
+    case 'no-progress':
+    case 'decomposable-no-progress':
+      return { move: 'narrow-relaunch', stage: 'repairing', reason: `${stop} — 범위를 좁혀 한 번 재발사(판정선 유지)` };
+    case 'provider-exhausted':
+    case 'step-timeout':
+      return { move: 'wait-retry', stage: 'waiting', reason: `${stop} — 대기 후 재시도` };
+    case 'handed-off-to-salvage':
+      return { move: 'salvage-relaunch', stage: 'repairing', reason: '수확 브랜치 diff 를 가져와 이어 발사' };
+    case 'converged':
+      return { move: 'wait', stage: 'observing', reason: '완주했으나 PR 병합 근거 대기' };
+    case undefined:
+      return { move: 'wait', stage: 'observing', reason: '종료 관측 대기' };
+    default:
+      return { move: 'decision-card', stage: 'escalated', reason: `표에 없는 종료 어휘 ${stop} — 근거 붙여 사람 결정` };
+  }
+}
+
+/** 종료 어휘·관측에서 다음 한 수를 고른다. 같은 수 2회 실패 → 다른 수 → 그것도 실패 → 결정 카드. */
+export function judgeNextMove(input: TaskJudgeInput): TaskJudgement {
+  const failures = input.failures ?? {};
+  let judged = base(input);
+  if ((failures.alternative ?? 0) >= 1) {
+    judged = { move: 'decision-card', stage: 'escalated', reason: `대안도 실패 — 런·PR·must-fix 근거로 사람 결정 (직전: ${judged.move})` };
+  } else if (judged.move !== 'wait' && judged.move !== 'decision-card' && (failures[judged.move] ?? 0) >= SAME_MOVE_FAILURE_LIMIT) {
+    judged = { move: 'alternative', stage: 'repairing', reason: `같은 수 ${SAME_MOVE_FAILURE_LIMIT}회 실패 — 다른 수 선택 (${judged.move})` };
+  }
+  const executorKind = EXECUTOR_KIND[judged.move];
+  return executorKind ? { ...judged, executorKind } : judged;
+}

package/src/task-cards/card-cli.ts

@@ -46,6 +46,31 @@ export function registerCardCommand(program: Command, deps: CardCliDeps = {}): C
       }
     });
 
+  card.command('close <id>')
+    .description('Close a task card with a reason (owner operation)')
+    .requiredOption('--reason <text>', 'One-line close reason')
+    .action((id: string, options: { reason: string }) => {
+      const store = createStore();
+      try {
+        const reason = options.reason.trim();
+        if (!reason || /[\r\n]/.test(options.reason)) throw new Error('Close reason must be one line');
+        const existing = store.getCard(id);
+        if (!existing) {
+          process.stderr.write(`Card not found: ${id}\n`);
+          process.exitCode = 1;
+          return;
+        }
+        if (existing.status === 'closed') {
+          write(`이미 닫힘: ${id}\n`);
+          return;
+        }
+        store.closeCard(id, reason);
+        write(`닫힘: ${id}\n`);
+      } finally {
+        store.close();
+      }
+    });
+
   card.command('list')
     .description('List task cards')
     .option('--open', 'Only show open cards')

package/src/task-cards/card-store.ts

@@ -16,6 +16,7 @@ export interface TaskCard {
   goalId: string;
   title: string;
   status: CardStatus;
+  closedReason?: string;
   createdAt: string;
   sections: CardSection[];
 }
@@ -32,7 +33,7 @@ export interface AppendSectionInput {
 type CardEvent =
   | { type: 'created'; id: string; goalId: string; title: string; createdAt: string }
   | { type: 'section'; key: string; owner: string; content: string; createdAt: string }
-  | { type: 'closed'; createdAt: string };
+  | { type: 'closed'; createdAt: string; reason?: string };
 
 /** RFC §3 (내부 문서 `RFC-execution-and-landing-loop-agents-parallel-first-2026-09-29`) — each card section has one owner.
  *  A key is `<section>` or `<section>:<idempotency key>`: the same section can be appended many times over a
@@ -197,14 +198,16 @@ export class CardStore {
     }).immediate();
   }
 
-  closeCard(id: string): TaskCard {
+  closeCard(id: string, reason?: string): TaskCard {
+    if (reason !== undefined && !reason.trim()) throw new Error('Close reason is required');
     return this.db.transaction(() => {
       this.reconcile();
       const card = this.readCard(id);
       if (!card) throw new Error(`Card not found: ${id}`);
       if (card.status === 'closed') return card;
-      this.append(id, { type: 'closed', createdAt: new Date().toISOString() });
-      return { ...card, status: 'closed' as const };
+      this.append(id, { type: 'closed', createdAt: new Date().toISOString(),
+        ...(reason === undefined ? {} : { reason: redactSecrets(reason.trim()) }) });
+      return { ...card, status: 'closed' as const, ...(reason === undefined ? {} : { closedReason: redactSecrets(reason.trim()) }) };
     }).immediate();
   }
 
@@ -214,8 +217,10 @@ export class CardStore {
     } | null;
     if (!row) return null;
     const events = readFileSync(cardEventsPath(id, this.root), 'utf8').trimEnd().split('\n').map((line) => JSON.parse(line) as CardEvent);
+    const closed = events.find((event): event is Extract<CardEvent, { type: 'closed' }> => event.type === 'closed');
     return {
       id: row.id, goalId: row.goal_id, title: row.title, status: row.status, createdAt: row.created_at,
+      ...(closed?.reason === undefined ? {} : { closedReason: closed.reason }),
       sections: events.filter((event): event is Extract<CardEvent, { type: 'section' }> => event.type === 'section')
         .map(({ key, owner, content, createdAt }) => ({ key, owner, content, createdAt })),
     };

package/src/task-orchestrator/surfaces/pod-failure-reason.ts

@@ -1,3 +1,31 @@
+/** Executor kinds of the dev child's `--json` result line (`src/index.ts` writeStdoutJson · DevExecutor.kind). */
+const CHILD_RESULT_KINDS = new Set(['self', 'external']);
+
+/** The dev child's terminal line nests the stage: {ok, kind, result:{stage, ok, node, outcome, …}}. Other JSON rows are not results. */
+export function nestedPodResult(row: Record<string, unknown>): { stage: string; ok: boolean; error?: string } | null {
+  if (typeof row.kind !== 'string' || !CHILD_RESULT_KINDS.has(row.kind) || typeof row.ok !== 'boolean') return null;
+  if (!row.result || typeof row.result !== 'object' || Array.isArray(row.result)) return null;
+  const result = row.result as Record<string, unknown>;
+  if (typeof result.stage !== 'string' || typeof result.ok !== 'boolean') return null;
+  if (result.ok) return { stage: result.stage, ok: true };
+  const classification = result.abandonedClassification;
+  const detail = typeof result.supervisorVerdict === 'string' ? result.supervisorVerdict
+    : classification && typeof classification === 'object' && !Array.isArray(classification)
+      ? (classification as Record<string, unknown>).classification : undefined;
+  const reason = [result.node, result.outcome].filter((part): part is string => typeof part === 'string' && part.length > 0).join(' ');
+  const error = [reason || (typeof result.error === 'string' ? result.error : ''), typeof detail === 'string' && detail ? detail : ''].filter(Boolean).join(' · ');
+  return { stage: result.stage, ok: false, ...(error ? { error } : {}) };
+}
+
+/** A child terminal row: the legacy flat form {stage, ok, error?} (no kind, or a child kind) or the nested dev result. Any other kind is not a result. */
+export function podTerminalRow(row: Record<string, unknown>): { stage: string; ok: boolean; error?: string } | null {
+  if (typeof row.kind === 'string' && !CHILD_RESULT_KINDS.has(row.kind)) return null;
+  if (typeof row.stage === 'string' && typeof row.ok === 'boolean') {
+    return { stage: row.stage, ok: row.ok, ...(typeof row.error === 'string' ? { error: row.error } : {}) };
+  }
+  return nestedPodResult(row);
+}
+
 /** Extract a human-readable reason from a failed child Pod without treating transfer markers as child errors. */
 export function extractPodFailureReason(input: {
   logs: string;
@@ -12,7 +40,7 @@ export function extractPodFailureReason(input: {
   if (input.containerReason === 'OOMKilled') return 'OOMKilled: 컨테이너 메모리 한도 초과';
 
   const isBookkeeping = (line: string): boolean =>
-    /^ELANOUS_(?:MEM|RUN_LEDGER|USAGE_ROLLUP|POD_)/u.test(line) || /^(?:at\s+\S|\.\.\.\s+\d+\s+more\b|cleanup\s+(?:complete|done|finished)\b)/iu.test(line);
+    /^(?:ELANOUS_(?:MEM|RUN_LEDGER|USAGE_ROLLUP|POD_)|\[graph\] )/u.test(line) || /^(?:at\s+\S|\.\.\.\s+\d+\s+more\b|cleanup\s+(?:complete|done|finished)\b)/iu.test(line);
   const isError = (line: string): boolean =>
     /\berror\b|\bfail(?:ed|ure)?\b|exception|fatal|denied|timed?\s*out|exceeded|overloaded|unavailable|exhausted|오류|실패/iu.test(line);
   const meaningful: Array<{ text: string; terminal: boolean }> = [];
@@ -24,10 +52,11 @@ export function extractPodFailureReason(input: {
       try { parsed = JSON.parse(trimmed); } catch { /* An ordinary line may begin with a brace. */ }
       if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
         const row = parsed as Record<string, unknown>;
-        if (typeof row.ok === 'boolean' && typeof row.stage === 'string') {
+        const terminal = podTerminalRow(row);
+        if (terminal) {
           meaningful.length = 0;
-          if (row.ok === false && typeof row.error === 'string') {
-            const errorLines = row.error.split(/\r\n|\n|\r/u).map((part) => part.trim())
+          if (terminal.ok === false && typeof terminal.error === 'string') {
+            const errorLines = terminal.error.split(/\r\n|\n|\r/u).map((part) => part.trim())
               .filter((part) => part && !isBookkeeping(part));
             const errorLine = [...errorLines].reverse().find(isError) ?? errorLines.at(-1);
             if (errorLine) meaningful.push({ text: errorLine, terminal: true });

package/src/task-orchestrator/surfaces/pod-lease.ts

@@ -64,6 +64,9 @@ export interface PoolLeaseRecommendation {
 }
 
 /** Kubernetes quantity to bytes (memory) or millicores (CPU). */
+/** Kubernetes memory quantity (`16Gi`, `2Gi`, `512Mi`) → bytes; null when unparseable. */
+export function memoryQuantityBytes(raw: string): number | null { return quantity(raw, 'memory'); }
+
 function quantity(raw: string, unit: 'memory' | 'cpu'): number | null {
   const m = /^(\d+(?:\.\d+)?)(n|u|m|k|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$/.exec(raw);
   if (!m) return null;
@@ -235,7 +238,7 @@ function runPoolDnsProbe(context: string, kubectl: PoolKubectl): PoolDnsProbe {
 }
 
 /** Each cluster reads resource reservations; DNS requires a bounded disposable Pod. */
-export function measurePoolLease(members: readonly PodPoolMember[], deps: { kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe } = {}): PoolLeaseMeasure {
+export function measurePoolLease(members: readonly PodPoolMember[], deps: { kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; /** Read-only snapshots must not create the disposable DNS Pod or update its cache. */ skipDnsProbe?: boolean } = {}): PoolLeaseMeasure {
   const kubectl = deps.kubectl ?? leaseKubectl;
   return { members: members.map((member) => {
     const base = ['--context', member.context, '--request-timeout=10s'];
@@ -354,7 +357,7 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
         else if (!reservationsValid && !unknownPhase) reasons.push('cluster reservations: node assignment or memory request/limit missing/invalid');
       }
       result.reason = reasons.length ? reasons.join('; ').slice(0, 240) : null;
-      if (nodeItems?.length && jobItems && podItems) {
+      if (!deps.skipDnsProbe && nodeItems?.length && jobItems && podItems) {
         let dnsState: PoolDnsProbe = 'unknown';
         try { dnsState = (deps.dns ?? ((context) => probePoolDns(context, kubectl)))(member.context); } catch { /* probe could not be measured */ }
         if (dnsState === 'dns') { result.capacity = 0; result.availableMemoryByNodeBytes = []; result.reason = 'dns'; }

package/src/task-orchestrator/surfaces/pod-ledger-collect.ts

@@ -3,6 +3,7 @@ import { gunzipSync } from 'node:zlib';
 import { debug } from '../../debug/log.js';
 import { runLedgerDir, runLedgerPath } from '../../self-implement/run-ledger.js';
 import { ledgerLineToLogEvent } from './pod-ledger-events.js';
+import { defaultPodReemit } from './pod-ledger-prod-sink.js';
 
 type Ledger = { runId: string; jsonl: string };
 type Incomplete = { runId: string; reason: string };
@@ -94,7 +95,7 @@ export function parsePodLedgerChunks(logs: string): ParseResult {
  *  except a ledger that THIS run's live follower created (`replace`): that one is a partial copy and the final is complete. */
 export function collectPodLedgers(
   logs: string,
-  { dir = runLedgerDir(), log = (c, e, d) => debug.log(c, e, d), emit = (c, e, d) => debug.log(c, e, d), replace = new Set<string>() }: {
+  { dir = runLedgerDir(), log = defaultPodReemit(), emit = defaultPodReemit(), replace = new Set<string>() }: {
     dir?: string;
     log?: (category: string, event: string, data: Record<string, unknown>) => void;
     emit?: Emit;
@@ -146,8 +147,8 @@ export function createPodLedgerFollower(opts: {
   onStall?: (message: string) => void;
 }): { poll(): void; readonly owned: boolean } {
   const dir = opts.dir ?? runLedgerDir();
-  const log = opts.log ?? ((c, e, d) => debug.log(c, e, d));
-  const emit: Emit = opts.emit ?? ((c, e, d) => debug.log(c, e, d));
+  const log = opts.log ?? defaultPodReemit();
+  const emit: Emit = opts.emit ?? defaultPodReemit();
   const now = opts.now ?? Date.now;
   const stallMinutes = opts.stallMinutes ?? 30;
   if (!Number.isFinite(stallMinutes) || stallMinutes <= 0) throw new RangeError('stallMinutes must be positive');