elanous 0.2.37 → 0.2.38

package/src/task-agent/task-hand.ts

@@ -16,6 +16,8 @@ import { parse as parseYaml } from 'yaml';
 import { runGraph, validateUnitCalls, type GraphRunOptions, type GraphRunState } from '../graph-runner/runner.js';
 import { parseGraphTemplateYaml } from '../self-implement/graph-yaml.js';
 import { resolveDaemonHarnessTarget } from '../intake-plane/harness-target.js';
+import { getUserConfig } from '../user-config.js';
+import { readBudgetInputsLive, type BudgetInputs } from '../self-implement/budget-gate.js';
 import { HARNESS_RUN_ID_ENV, mintRunId, normalizeRunId } from '../harness/harness-space.js';
 import { newLaunchUtteranceId, recordLaunchUtterance } from '../harness/launch-utterance-ledger.js';
 import { debug } from '../debug/log.js';
@@ -33,7 +35,7 @@ import { inspectPrelaunchAlreadyDone, type AlreadyDoneDecision, type AlreadyDone
   type PrelaunchGitRunnerForTest } from './prelaunch-already-done.js';
 import { draftClaimComment, draftClaimRecordLive, draftClaimState, draftReleaseComment } from '../self-dev/draft-triage-rules.js';
 import { parseAskTargetPathHints, parseAskTargetPathHintsResult, type AskTargetPathHintsParseResult } from '../self-dev/launch-preflight-text.js';
-import { inspectGoalDoneBoundary, linesOutsideFencedCode } from '../self-implement/goal-author.js';
+import { draftMissingGoalDoneBoundary, inspectGoalDoneBoundary, linesOutsideFencedCode } from '../self-implement/goal-author.js';
 import { selectKnowhowPack } from '../self-implement/knowhow-pack.js';
 import { INFLIGHT_REGISTRY_FILE, registerInflight } from '../pr-tool/inflight-registry.js';
 import { taskParentRoleEnv, taskParentRolePinsForChild } from './task-parent-role-llm.js';
@@ -384,6 +386,11 @@ export interface TaskCard {
   repairs?: Array<{ pr: number; head: string; branch: string; at: string; move: string; runId: string;
     resultPath: string; fromModel: string; toModel: string; status: 'requested' | 'unconfirmed' | 'failed' | 'applied';
     detail?: string; commit?: string; bundleSha256?: string; bundlePath?: string;
+    /** Hash of exact review must-fix text at launch; old records have no comparable input. */
+    reviewSignature?: string;
+    /** Stable worker failure class; absent means retry policy remains unchanged. */
+    failureSignature?: string;
+    gateFailureTests?: string[];
     /** HARNESS-FULL-GRAPH-NEXTMOVE — next-move 결정 순간 만든 수 id. 이 칸 전 원장 줄엔 없다. */
     moveId?: string }>;
 }
@@ -779,6 +786,23 @@ export function writeTaskCards(path: string, cards: readonly TaskCard[]): void {
   });
 }
 
+/** 여러 카드의 관계 변경을 한 잠금 안에서 검사·기록한다(예: 기존 PR 결속 이동). */
+export function updateTaskCardsAtomically(path: string,
+  update: (tasks: Readonly<Record<string, TaskCard>>) => readonly TaskCard[] | undefined): TaskCard[] | undefined {
+  return withFileLockSync(`${path}.lock`, () => {
+    const disk = readState(path);
+    const current = disk.tasks ?? {};
+    const replacements = update(current);
+    if (!replacements) return undefined;
+    if (!replacements.length || replacements.some((card) => !card.id)) throw new Error('카드 원자 갱신은 id가 있는 카드가 필요하다');
+    const tasks = { ...current };
+    for (const card of replacements) tasks[card.id] = card;
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({ ...disk, tasks }));
+    return [...replacements];
+  });
+}
+
 /** 카드 하나를 잠금 안에서 읽고 고쳐 쓴다 — `update` 가 undefined 를 돌려주면 쓰지 않는다. 쓴(또는 그대로인) 카드를 돌려준다. */
 export function updateTaskCard(path: string, id: string, update: (card: TaskCard | undefined, tasks: Readonly<Record<string, TaskCard>>) => TaskCard | undefined,
   options: { doctorLedgerDir?: string } = {}): TaskCard | undefined {
@@ -1020,6 +1044,8 @@ export interface HandTaskOptions {
   /** TASKS-HAND-CHILD-LLM — `<provider>/<model>`(`parseChildLlm`) ⊕ 선택 추론 노력. effort 만 주면 거부. */
   childLlm?: string;
   childLlmEffort?: string;
+  /** Injected budget facts for a mission child; production reads the live launch-budget inputs just before launch. */
+  childBudgetInputs?: () => Promise<BudgetInputs> | BudgetInputs;
   parentRoleLlm?: string[];
   tier?: TaskCard['tier'];
   /** TIER-SPLIT-BEFORE-LAUNCH — 조각 카드에 싣는 분해 연결(`tier-split.ts` 만 준다). */
@@ -1121,6 +1147,7 @@ export function dispatchDeliverableCompletion(id: string, input: { ref: string;
 const GOAL_EVIDENCE_COMMAND_LINE = /^\s*(?:[-*]\s*)?완료 경계 증거 명령\s*:\s*(.*?)\s*$/;
 const GOAL_EVIDENCE_COMMAND_DESCRIPTION_SUFFIX = /->|→/;
 const GOAL_EVIDENCE_COMMAND_BACKTICK_DECORATION = /`/;
+const GOAL_EVIDENCE_COMMAND_TYPECHECK_DECORATION = /·\s*typecheck\b/i;
 
 function goalEvidenceCommandFormViolations(document: string): string[] {
   const violations: string[] = [];
@@ -1129,6 +1156,7 @@ function goalEvidenceCommandFormViolations(document: string): string[] {
     if (value === undefined || !value.trim()) continue;
     if (GOAL_EVIDENCE_COMMAND_BACKTICK_DECORATION.test(value)) violations.push(`백틱 장식: ${value}`);
     else if (GOAL_EVIDENCE_COMMAND_DESCRIPTION_SUFFIX.test(value)) violations.push(`설명 접미: ${value}`);
+    else if (GOAL_EVIDENCE_COMMAND_TYPECHECK_DECORATION.test(value)) violations.push(`설명 접미: ${value}`);
   }
   return violations;
 }
@@ -1165,8 +1193,14 @@ function firstLinePathListViolations(hints: AskTargetPathHintsParseResult): stri
 }
 
 export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
-  const text = opts.text.trim();
+  const { normalizeEvidenceCommandLines } = await import('./evidence-command-normalize.js');
+  const normalized = normalizeEvidenceCommandLines(opts.text.trim());
+  let text = normalized.text;
   if (!text) throw new Error('과제 한 줄이 비어 있다');
+  for (const warning of normalized.warnings) {
+    console.error(`⚠ ${warning}`);
+    try { debug.log('task-agent.hand', 'evidence-command-warning', { warning }); } catch { /* fail-soft */ }
+  }
   const path = opts.statePath ?? taskAgentStatePath();
   const targetPathHints = parseAskTargetPathHintsResult(text);
   const targetPaths = canonicalTargetPaths(targetPathHints.paths);
@@ -1197,7 +1231,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     }, birthTags);
   const childLlm = opts.childLlm !== undefined ? parseChildLlm(opts.childLlm, opts.childLlmEffort) : undefined;
   const parentRolePins = taskParentRolePinsForChild(opts.parentRoleLlm ?? [], childLlm);
-  const parentRoleEnv = taskParentRoleEnv(parentRolePins); // validate before writing the card
+  let parentRoleEnv = taskParentRoleEnv(parentRolePins); // validate before writing the card
   const completion = opts.completion ?? 'code-pr';
   const selected = selectTaskComposition(completion, opts.compositionRoot);
   // 2판 — launcher 'graph-run' 조합(단위 해석까지 완료)은 실제 graph run 으로 발사한다. 더 이상 거부하지 않는다.
@@ -1272,7 +1306,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(draftClaim ? { draftClaim } : {}),
   };
   // 2판 graph-run 조합의 다음 수는 실제 graph run — harness say 인자를 조립하지 않는다.
-  const move = graphRun && graphRunPath ? { kind: 'launch' as const, command: ['graph', 'run', graphRunPath], reason: `조합 launcher graph-run — ${graphRun.file}` } satisfies TaskCardMove
+  let move = graphRun && graphRunPath ? { kind: 'launch' as const, command: ['graph', 'run', graphRunPath], reason: `조합 launcher graph-run — ${graphRun.file}` } satisfies TaskCardMove
     : selectionFailure ? undefined : nextMoveFor(card, opts.landed);
   // 분해 실패로 막은 카드는 wait(failed 사유)가 정답이다 — 던지지 않고 카드를 적은 뒤 발사 0 으로 돌아간다.
   if (move && move.kind !== 'launch' && tierSplitBlocked === undefined) throw new Error(`발사할 수 없는 과제다 — ${move.reason}`);
@@ -1321,10 +1355,15 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   // Injected launchers are test seams and opt in explicitly at the contract test.
   if (opts.live && opts.preflightGoalDoneBoundary && !selectionFailure && tierSplitBlocked === undefined && move?.kind === 'launch') {
     readTaskAgentState(path);
-    const { missing } = inspectGoalDoneBoundary(text);
-    if (missing.length > 0) {
-      throw new Error(`goal-revision-required: 완료 경계 누락 ${missing.join(' · ')} — 골 문면에 완료 경계 코드·완료 경계 실물·완료 경계 증거 명령을 적은 뒤 다시 넘기세요`);
+    const drafted = draftMissingGoalDoneBoundary(text, targetPaths);
+    if (drafted.added.length > 0) {
+      text = drafted.document;
+      card = { ...card, text };
+      move = graphRun && graphRunPath ? { kind: 'launch' as const, command: ['graph', 'run', graphRunPath], reason: `조합 launcher graph-run — ${graphRun.file}` } : nextMoveFor(card, opts.landed);
+      try { debug.log('task-agent.hand', 'boundary-autodrafted', { taskId: id, labels: drafted.added, targetPathCount: targetPaths.length }); } catch { /* fail-soft */ }
     }
+    const { missing } = inspectGoalDoneBoundary(text);
+    if (missing.length > 0) throw new Error(`goal-revision-required: 완료 경계 누락 ${missing.join(' · ')}`);
     // ENTRANCE-EVIDENCE-COMMAND-ONLY — 존재 검사와 구분된 형태 판정: 증거 명령 줄은 명령 원문만 받는다.
     const formViolations = goalEvidenceCommandFormViolations(text);
     if (formViolations.length > 0) {
@@ -1419,13 +1458,58 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     writeCard(path, candidate);
     return { card: candidate, move: nextMoveFor(candidate), mode, launched: false, ...(project ? { cwd: project.target } : {}) };
   }
+  // A mission parent can carry its original explicit child model into later pieces. Recheck that model
+  // immediately before each launch; an exhausted provider must not pin every following child to the same stop.
+  if (opts.mission && card.childLlm && (card.childLlm.provider === 'grok' || card.childLlm.provider === 'openai-codex')) {
+    let inputs: BudgetInputs | undefined;
+    try { inputs = await (opts.childBudgetInputs ?? readBudgetInputsLive)(); }
+    catch (error) {
+      try { debug.log('task-agent', 'child-model-reselect-unavailable', { taskId: id,
+        reason: error instanceof Error ? error.message : String(error) }, { level: 'warn' }); }
+      catch { /* observation is fail-soft */ }
+    }
+    if (inputs) {
+      const { harnessLaunchBudgetDecision } = await import('../execution-loop/launch-gate.js');
+      const current = harnessLaunchBudgetDecision(inputs, { childLlmProvider: card.childLlm.provider,
+        childLlmModel: card.childLlm.model }).decision;
+      if (current.action === 'stop' || current.action === 'wait-reset') {
+        const alternatives = inputs.preference.chain.filter((slot) => slot.provider !== card.childLlm!.provider);
+        const next = alternatives.map((slot) => harnessLaunchBudgetDecision(inputs, {
+          childLlmProvider: slot.provider, ...(slot.model ? { childLlmModel: slot.model } : {}),
+        }).decision).find((decision) => decision.action === 'proceed' || decision.action === 'next-provider');
+        if (next?.provider) {
+          const from = card.childLlm;
+          const model = next.model ?? (await import('../self-dev/dev-cli.js')).defaultChildLlmModel(next.provider);
+          const to: TaskChildLlm = { provider: next.provider, model };
+          const nextParentRoleEnv = taskParentRoleEnv(taskParentRolePinsForChild(opts.parentRoleLlm ?? [], to));
+          const at = (opts.now ?? (() => new Date()))().toISOString();
+          card = { ...card, childLlm: to, history: [...card.history, { at, event: 'child-model-reselected',
+            detail: `${from.provider}/${from.model} → ${to.provider}/${to.model}: ${current.reasons.join(' · ')}` }] };
+          parentRoleEnv = nextParentRoleEnv;
+          move = { ...move!, command: launchArgs(card) };
+          writeCard(path, card);
+          try { debug.log('task-agent', 'child-model-reselected', { taskId: id, from, to, reason: current.reasons, mission: opts.mission }); }
+          catch { /* observation is fail-soft */ }
+        }
+      }
+    }
+  }
   // Only the code-PR harness Pod consumes podGoal. Keep the card and other launchers unchanged.
   const podLaunch = completion === 'code-pr' && selected.launcher === 'harness-say';
   let childGoal = card.text;
   if (podLaunch) {
-    const knowhow = selectKnowhowPack(project?.target ?? resolve(import.meta.dir, '../..'), card.text, targetPaths);
+    const configuredRepo = project ? undefined : getUserConfig().harness?.defaultRepo;
+    const knowhowRepo = project?.target ?? configuredRepo ?? resolve(import.meta.dir, '../..');
+    const knowhow = selectKnowhowPack(knowhowRepo, card.text, targetPaths);
     if (knowhow.text) childGoal = `${knowhow.text}\n\n${card.text}`;
-    try { debug.log('task-agent', 'knowhow-pack', { taskId: id, ids: knowhow.ids, bytes: knowhow.bytes, injected: knowhow.bytes > 0 }); } catch { /* fail-soft */ }
+    let repoRevision: string | null = null;
+    try {
+      const head = execFileSync('git', ['-C', knowhowRepo, 'rev-parse', '--verify', 'HEAD'], { encoding: 'utf8', timeout: 10_000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      if (/^[0-9a-f]{40,64}$/i.test(head)) repoRevision = head;
+    } catch { /* The source may be absent; reason=source-unreadable records that boundary. */ }
+    try { debug.log('task-agent', 'knowhow-pack', { taskId: id, ids: knowhow.ids, bytes: knowhow.bytes, injected: knowhow.bytes > 0,
+      reason: knowhow.reason, repoPath: knowhowRepo, repoRevision,
+      repoSource: project ? 'project' : configuredRepo ? 'harness.defaultRepo' : 'package' }); } catch { /* fail-soft */ }
   }
   const runId = mintRunId();
   const launchId = newLaunchUtteranceId();
@@ -1445,7 +1529,10 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     receipt = await opts.launcher(podLaunch ? [...move.command!.slice(0, -1), childGoal] : move.command!, project?.target, context);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
-    const failed: TaskCard = { ...card, status: 'launch-failed', history: [{ at: (opts.now ?? (() => new Date()))().toISOString(), event: 'launch-failed', detail: reason }] };
+    const failed: TaskCard = { ...card, status: 'launch-failed', history: [
+      ...card.history.filter((entry) => entry.event === 'child-model-reselected'),
+      { at: (opts.now ?? (() => new Date()))().toISOString(), event: 'launch-failed', detail: reason },
+    ] };
     writeCard(path, failed);
     try { debug.log('task-agent', 'launch-failed', { taskId: id, seat: card.seat ?? null, reason }); } catch { /* fail-soft */ }
     throw new TaskLaunchError(failed, reason);
@@ -1462,6 +1549,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(boundRunId ? { runId: boundRunId, launchId } : {}),
     ...(receipt && receipt.parentHost && typeof receipt.parentHost.host === 'string' ? { parentHost: receipt.parentHost } : {}),
     history: [
+      ...card.history.filter((entry) => entry.event === 'child-model-reselected'),
       { at: launchedAt, event: 'launch', detail: `${receipt && receipt.parentHost ? `[parent@${receipt.parentHost.host} · PR 까지만] ` : ''}${move.command!.join(' ')}` },
       ...(boundRunId ? [{ at: launchedAt, event: 'run-bound', detail: boundRunId, runId: boundRunId }] : []),
     ],

package/src/task-agent/tier-split.ts

@@ -30,9 +30,38 @@ export const TIER_SPLIT_DECOMPOSE_TIMEOUT_MS = 300_000;
 
 /** 조각이 부모 칸에서 물려받는 줄 머리 — hand 의 골 검사(완료 경계 셋)와 계약·경계 문맥. */
 const INHERITED_PARENT_LABELS = /^\s*(?:[-*]\s*)?(현재 계약|완료 경계 코드|완료 경계 실물|완료 경계 증거 명령|경계|증거 보충)\s*:/;
+const VERIFICATION_PLAN_HEADING = '### 검증 계획(TDD)';
+
+/** Read a real Markdown section, ignoring headings inside fenced verbatim asks. */
+function parentVerificationPlan(text: string): string[] {
+  const lines = text.split(/\r?\n/u);
+  let fence: { char: string; length: number } | null = null;
+  let start = -1;
+  const section: string[] = [];
+  for (const [index, line] of lines.entries()) {
+    const marker = /^ {0,3}(`{3,}|~{3,})/u.exec(line)?.[1];
+    if (marker) {
+      if (!fence) fence = { char: marker[0]!, length: marker.length };
+      else if (marker[0] === fence.char && marker.length >= fence.length) fence = null;
+      if (start >= 0 && fence) break;
+      continue;
+    }
+    if (fence) continue;
+    if (start < 0) {
+      if (line.trim() === VERIFICATION_PLAN_HEADING) {
+        start = index;
+        section.push(line);
+      }
+      continue;
+    }
+    if (/^ {0,3}#{1,6}\s/u.test(line)) break;
+    section.push(line);
+  }
+  return section;
+}
 
 /**
- * 조각 hand 문면 = 조각 골(대상 경로·동작 — 첫 줄 유지) ⊕ 조각 표지 ⊕ 부모 칸의 계약·완료 경계·경계 줄.
+ * 조각 hand 문면 = 조각 골(대상 경로·동작 — 첫 줄 유지) ⊕ 조각 표지 ⊕ 부모 칸의 계약·완료 경계·경계 줄·TDD 계획.
  * 분해기의 조각 골은 짧은 제목뿐이라 그대로 넘기면 hand 의 골 검사(완료 경계 누락)가 막는다(10-21 DEVICE-FIRST-AUTHORING 발사 0).
  * 부모에 그 줄이 없으면 아무것도 더하지 않는다 — 검사가 지금처럼 거부한다(보수 쪽).
  */
@@ -43,10 +72,14 @@ export function composeSliceHandText(sliceGoal: string, parentText: string, mark
     const label = INHERITED_PARENT_LABELS.exec(line)?.[1];
     return label !== undefined && !sliceHas.has(label);
   });
+  const sliceHasVerificationPlan = sliceLines.some((line) => line.trim() === VERIFICATION_PLAN_HEADING);
+  const verificationPlan = sliceHasVerificationPlan ? [] : parentVerificationPlan(parentText);
+  inherited.push(...verificationPlan);
   // 표지는 리뷰 범위를 나르므로 장치 우선 조각(총 2 이상)은 상속 줄이 없어도 남는다 —
   // 다만 «물려받았다» 는 물려받은 줄에 대한 주장이므로 그 줄이 있을 때만 붙인다.
   if (inherited.length === 0 && (marker.total < 2 || !sliceGoal.includes(`동작: ${DEVICE_FIRST_STEP}`))) return sliceGoal;
-  const inheritanceClaim = inherited.length > 0 ? ' 아래 계약·완료 경계는 부모 칸에서 물려받았다 — 이 조각 범위만 채운다.' : '';
+  const inheritedTopics = `계약·완료 경계${verificationPlan.length > 0 ? '·검증 계획' : ''}`;
+  const inheritanceClaim = inherited.length > 0 ? ` 아래 ${inheritedTopics}는 부모 칸에서 물려받았다 — 이 조각 범위만 채운다.` : '';
   const tag = `조각 ${marker.index}/${marker.total} — 부모 ${marker.cid ?? '(칸 없음)'}(${marker.fromTier}) 를 중 이하로 나눈 몫.${inheritanceClaim}`;
   return [...sliceLines, tag, ...inherited].join('\n');
 }
@@ -181,7 +214,8 @@ export async function handTaskWithTierSplit(opts: TierSplitHandOptions): Promise
         markFirstLaunchFailure(reason);
       }
     }
-    record({ cid, fromTier, outcome: 'device-first-deferred', group, first: ids[0], blockedUntilLanded: ids.slice(1) });
+    record({ cid, fromTier, outcome: 'device-first-deferred', group, first: ids[0], blockedUntilLanded: ids.slice(1),
+      unavoidable: [...unavoidable], ...counts });
     return { kind: 'split', group, fromTier, slices };
   }
   for (const [index, slice] of plan.slices.entries()) {

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

@@ -334,10 +334,31 @@ export interface PodTermination {
   finishedAt: string | PodTerminationUnknown;
   /** From `state.terminated.reason === 'OOMKilled'` only (never from exit code 137). */
   oomKilled: boolean | PodTerminationUnknown;
+  /** A terminal verdict can race Kubernetes container status; one bounded Pod re-read records the outcome. */
+  collectionAttempts?: 2;
+  collectionFailureReason?: 'pod-still-running-after-retry' | 'pod-absent-after-retry' |
+    'pod-read-unavailable-after-retry' | 'terminated-fields-missing-after-retry' | 'pod-state-unknown-after-retry';
 }
 
-/** Job Failed condition reason first: the classification takes column one, the capture all three, from one read. */
-export const POD_TERMINATION_JOB_JSONPATH = '{.status.conditions[?(@.type=="Failed")].reason}{"\\t"}{.spec.activeDeadlineSeconds}{"\\t"}{.metadata.uid}';
+/** FailureTarget can precede Failed at the deadline. Read both in the same Job snapshot. */
+export const POD_TERMINATION_JOB_JSONPATH = '{.status.conditions[?(@.type=="Failed")].reason}{"|"}{.status.conditions[?(@.type=="FailureTarget")].reason}{"\\t"}{.spec.activeDeadlineSeconds}{"\\t"}{.metadata.uid}';
+
+export function podJobConditionReason(value: string | undefined): string {
+  const [failed, target] = (value ?? '').split('|');
+  return terminationWord(failed || target);
+}
+
+/** Emitted by the Pod wrapper before the Job's hard deadline, scoped to this Job and child run. */
+export function podDeadlineResultMarker(logs: string, job: string, runId: string): { stage: string; pr: number | null; branch: string | null } | null {
+  if (!/^[A-Za-z0-9_.:-]+$/.test(job) || !/^[A-Za-z0-9_.:-]+$/.test(runId)) return null;
+  const prefix = `ELANOUS_POD_DEADLINE_RESULT ${job} ${runId} stop-cause=deadline `;
+  for (const line of logs.split('\n').reverse()) {
+    if (!line.startsWith(prefix)) continue;
+    const match = /^stage=(clone|setup|run|unknown) pr=(unknown|[1-9]\d*) branch=(unknown|[A-Za-z0-9_./-]+)$/.exec(line.slice(prefix.length).trim());
+    if (match) return { stage: match[1]!, pr: match[2] === 'unknown' ? null : Number(match[2]), branch: match[3] === 'unknown' ? null : match[3]! };
+  }
+  return null;
+}
 /**
  * One row per Pod of this Job name. The first three columns keep the classification read's layout
  * (`creation · terminated.reason · terminated.exitCode`, empty when the child has no status yet), so the
@@ -384,7 +405,7 @@ export function readPodTermination(input: { kubectl: PodTerminationKubectl; name
   const jobUid = input.jobUid && JOB_UID.test(input.jobUid) ? input.jobUid : undefined;
   // A read without a uid, or with another uid, is not this launch's Job.
   const jobOk = jobRead?.status === 0 && jobUid !== undefined && readUid === jobUid;
-  const jobConditionReason = jobOk ? terminationWord(reasonText) : 'unknown';
+  const jobConditionReason = jobOk ? podJobConditionReason(reasonText) : 'unknown';
   const podsRead = 'podsRead' in input ? input.podsRead ?? null
     : read(['-n', namespace, 'get', 'pods', '-l', `job-name=${job}`, '-o', `jsonpath=${POD_TERMINATION_PODS_JSONPATH}`]);
   let podLookup: PodTermination['podLookup'] = 'unavailable';
@@ -444,7 +465,11 @@ export function parsePodTermination(value: unknown, job: string): PodTermination
     || !oneOf(row.podLookup, ['terminated', 'running', 'pending', 'unknown', 'absent', 'unavailable'])
     || !wordOrUnknown(row.containerReason) || !numberOrUnknown(row.exitCode)
     || !(row.finishedAt === 'unknown' || (typeof row.finishedAt === 'string' && terminationInstant(row.finishedAt) !== 'unknown'))
-    || !boolOrUnknown(row.oomKilled)) return undefined;
+    || !boolOrUnknown(row.oomKilled)
+    || (row.collectionAttempts !== undefined && row.collectionAttempts !== 2)
+    || (row.collectionFailureReason !== undefined && !oneOf(row.collectionFailureReason, [
+      'pod-still-running-after-retry', 'pod-absent-after-retry', 'pod-read-unavailable-after-retry',
+      'terminated-fields-missing-after-retry', 'pod-state-unknown-after-retry']))) return undefined;
   // Facts are attributed through the uid only: a record claiming Job or Pod facts without one is contradictory.
   if (row.jobUid === 'unknown' && (row.jobLookup !== 'unavailable' || row.podLookup !== 'unavailable')) return undefined;
   return {
@@ -455,5 +480,7 @@ export function parsePodTermination(value: unknown, job: string): PodTermination
     podLookup: row.podLookup as PodTermination['podLookup'], containerReason: row.containerReason as string,
     exitCode: row.exitCode as PodTermination['exitCode'], finishedAt: row.finishedAt as string,
     oomKilled: row.oomKilled as PodTermination['oomKilled'],
+    ...(row.collectionAttempts === 2 ? { collectionAttempts: 2 as const } : {}),
+    ...(row.collectionFailureReason ? { collectionFailureReason: row.collectionFailureReason as PodTermination['collectionFailureReason'] } : {}),
   };
 }

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

@@ -193,7 +193,7 @@ export function parsePodPool(spec: string): PodPoolMember[] {
     // `:N` 이 없으면 «상한 없음»이 아니라 기본 상한 2 다 — 그 사실(`capacityDefaulted`)을 멤버에 남긴다.
     const capacityDefaulted = m[3] === undefined;
     const capacity = capacityDefaulted ? POD_POOL_DEFAULT_CAPACITY : Number(m[3]);
-    // POOL-LITE (10-07): `:0` means «this member is off» — a `node-c:0` entry once threw here and broke every launch.
+    // POOL-LITE (10-07): `:0` means «this member is off» — a zero-capacity entry once threw here and broke every launch.
     //   It is dropped below (never chosen); only a pool with no live member left is an error.
     if (!Number.isInteger(capacity) || capacity < 0) throw new Error(`--pod-pool: 상한은 1 이상 — 「${part}」`);
     if (m[5] && Number(m[5]) > 65535) throw new Error(`--pod-pool: 레지스트리 포트는 65535 이하 — 「${part}」`);
@@ -294,8 +294,8 @@ export interface PodPlacement {
 }
 
 /**
- * Preferred members for a placement kind: lite → the smallest-capacity member(s) (node-c), standard → the largest (node-b).
- * Capacity is the operator's own statement of member size (`pool-node-b@node-b:40,pool-node-c@node-c:6`), so no new spec syntax.
+ * Preferred members for a placement kind: lite → the smallest-capacity member(s), standard → the largest.
+ * Capacity is the operator's own statement of member size (`pool-node-a@node-a:40,pool-node-b@node-b:6`), so no new spec syntax.
  * When every member has the same capacity there is no small/big member and no preference (empty list).
  */
 export function preferredMembers(members: readonly PodPoolMember[], kind: PodPlacementKind | null | undefined): string[] {
@@ -888,6 +888,29 @@ export function syncPoolImage(member: PodPoolMember, image: string, localCommit:
 
 export type PoolKubectl = (args: readonly string[], input?: string) => { status: number | null; stdout: string; stderr: string };
 
+/** Read identities for a shadow decision; this never reserves or changes a Pod. */
+export function snapshotWarmPoolMembers(members: readonly PodPoolMember[], kubectl: PoolKubectl):
+  Record<string, Array<{ name: string; uid: string; node: string | null }>> | null {
+  const result: Record<string, Array<{ name: string; uid: string; node: string | null }>> = {};
+  for (const member of members) {
+    const observed = kubectl(['--context', member.context, '-n', 'elanous-test', 'get', 'pods', '-l', 'elanous.kind=warm-worker', '-o', 'json']);
+    if (observed.status !== 0) return null;
+    try {
+      const parsed: unknown = JSON.parse(observed.stdout);
+      if (!parsed || typeof parsed !== 'object' || !('items' in parsed) || !Array.isArray(parsed.items)) return null;
+      const rows: Array<{ name: string; uid: string; node: string | null }> = [];
+      for (const item of parsed.items) {
+        if (!item || typeof item !== 'object' || !item.metadata || typeof item.metadata.name !== 'string'
+          || typeof item.metadata.uid !== 'string' || !item.metadata.name || !item.metadata.uid) return null;
+        const node = typeof item.spec?.nodeName === 'string' ? item.spec.nodeName : null;
+        rows.push({ name: item.metadata.name, uid: item.metadata.uid, node });
+      }
+      result[member.context] = rows.sort((a, b) => a.uid.localeCompare(b.uid));
+    } catch { return null; }
+  }
+  return result;
+}
+
 /**
  * 발사 전 점검 — 노드마다 «컨텍스트가 닿나 · elanous-test 네임스페이스가 있나».
  * ⛔ 안 되는 노드는 «조용히» 빼지 않는다 — 이유를 낸다. 하나도 안 되면 ok=false.
@@ -972,7 +995,7 @@ export async function syncPoolImages(members: readonly PodPoolMember[], image: s
   const remoteBuild = deps.remoteBuild ?? (script ? defaultRemoteBuild(script, image) : null);
   // The registry-less build fallback below calls this ship path, including its remote import result check.
   const ship = deps.ship ?? ((m: PodPoolMember, img: string, commit: string | null, remote: RemoteRun) =>
-    syncPoolImage(m, img, commit, { run: remote, inspect: deps.inspect, transfer: deps.transfer }));
+    syncPoolImage(m, img, commit, { run: remote, inspect: deps.inspect, transfer: deps.transfer, lock: deps.lock }));
   const results = new Map<string, PoolImageSync>();
   // pack 한 번 ⊕ 나눠 쓰기 — 원격 멤버가 둘 이상일 때만(하나뿐이면 종전대로 build.sh 가 스스로 pack 한다).
   //   주입된 remoteBuild(시험)에는 진짜 pack 을 붙이지 않는다 — pack 도 주입해야 쓴다.