elanous 0.2.27 → 0.2.29

package/src/task-agent/shadow.ts

@@ -15,8 +15,8 @@ import { extname, join, relative, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
 import { readTaskAgentState, readTaskCard, taskAgentStatePath, TASK_CARD_PREFIX, type CompletionKind, type TaskCard } from './task-hand.js';
 import type { SupervisorJobResult, SupervisorStopReason } from '../self-dev/run-supervisor.js';
-import { executeNextAction, type DeliveryKind, type NextAction } from './actions.js';
-import { judgeNextMove, type TaskJudgeInput, type TaskJudgement } from './judge.js';
+import { executeNextAction, type ActionDeps, type DeliveryKind, type NextAction } from './actions.js';
+import { judgeNextMove, LIVE_RETRY_MOVES, type TaskJudgeInput, type TaskJudgement } from './judge.js';
 import { HARNESS_RUN_ID_ENV } from '../harness/harness-space.js';
 import { appendRunLedgerEntry, loadRunLedger } from '../self-implement/run-ledger.js';
 import { collectWiringEvidence, readCardRunSnapshot, type WiringEvidenceDeps, type CardRunEvidenceDeps } from './card-evidence.js';
@@ -57,8 +57,10 @@ export interface TaskAgentShadowMove {
 
 export interface TaskAgentShadowDeps {
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
-  /** 시험용 — shadow 실행부가 명령을 부르면 여기로 온다(정상이면 0회). */
-  command?: (args: string[]) => Promise<{ status: number; stdout: string; stderr?: string }>;
+  /** 재발사 live 실행부 명령(주입되지 않으면 shadow). */
+  command?: ActionDeps['command'];
+  /** 재발사 live 부하 관문(주입되지 않으면 shadow). */
+  loadGate?: ActionDeps['loadGate'];
   readCard?: (taskId: string) => TaskCard | undefined;
   /** Explicit live invocation only; supervisor's default hook always uses shadow. */
   mode?: 'shadow' | 'live';
@@ -265,6 +267,9 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
       : { move: 'wait', stage: 'waiting', reason: '전달 후보 없음' }
     : judgeNextMove(judgeInput);
   if (cardLookupFailed) judgement.reason = `${judgement.reason} · 종결 종류 미확인(카드 조회 실패)`;
+  // 판단마다 해석한다 — 허용되지 않은 수를 판단할 때도 모르는 항목 경고가 남게.
+  const liveMoves = deps.liveMoves ?? await configuredTaskAgentLiveMoves();
+  const retryLaunches = { count: 0 };
   let executorResult: string | null = null;
   let wouldDo: string | null = null;
   if (judgement.executorKind) {
@@ -279,10 +284,13 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
       checklistId: delivery ? card?.checklistId ?? '' : '',
       ...(delivery ? { delivery } : {}),
     };
+    const liveRetry = !delivery && deps.command !== undefined && deps.loadGate !== undefined
+      && (LIVE_RETRY_MOVES as readonly string[]).includes(judgement.move) && liveMoves.has(judgement.move as TaskAgentLiveMove);
     executorResult = await executeNextAction(action, {
-      mode: delivery ? (deps.mode ?? 'shadow') : 'shadow',
+      mode: delivery ? (deps.mode ?? 'shadow') : liveRetry ? 'live' : 'shadow',
       command: deps.command ?? (async () => { throw new Error('task-agent shadow path must not run commands'); }),
       observe: (_event, data) => { wouldDo = data.reason; },
+      ...(liveRetry ? { liveMoves, retryLaunches, loadGate: deps.loadGate } : {}),
     });
   }
   const move: TaskAgentShadowMove = {
@@ -305,8 +313,6 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
     move.wouldDo = null;
   }
   const liveKind: TaskAgentLiveMove | null = move.move === 'review' || move.move === 'propose-green' || move.move === 'propose-land' || move.move === 'decision-card' ? move.move : null;
-  // 판단마다 해석한다 — 허용되지 않은 수를 판단할 때도 모르는 항목 경고가 남게.
-  const liveMoves = deps.liveMoves ?? await configuredTaskAgentLiveMoves();
   // 카드 id 는 모든 판단 관측에 싣는다(그림자 일치율을 카드로 잇는다) — 읽기 전용 조회.
   // live 수는 «근거 결과»에 묶는다 — PR 수는 그 PR 을 낸 결과의 카드·작업 트리, 전달은 전달한 카드(다중 결과에서 남의 카드에 쓰지 않게).
   const prResult = typeof judgeInput.pr === 'number' ? input.results.find((result) => result.prNumber === judgeInput.pr) : undefined;

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

@@ -11,6 +11,10 @@ import { execFileSync } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { mkdirSync, readFileSync, statSync, writeFileSync, type Stats } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse as parseYaml } from 'yaml';
+import { validateUnitCalls } from '../graph-runner/runner.js';
+import { parseGraphTemplateYaml } from '../self-implement/graph-yaml.js';
 import { resolveDaemonHarnessTarget } from '../intake-plane/harness-target.js';
 import { HARNESS_RUN_ID_ENV, mintRunId, normalizeRunId } from '../harness/harness-space.js';
 import { debug } from '../debug/log.js';
@@ -89,6 +93,66 @@ export function taskCardLabelContext(card: Pick<TaskCard, 'id'>): TaskCardLabelC
 export const COMPLETION_KINDS = ['code-pr', 'artifact', 'research-report', 'ops-action', 'content', 'watch-brief', 'decision-support', 'deliverable'] as const;
 export type CompletionKind = typeof COMPLETION_KINDS[number];
 
+export interface TaskComposition {
+  file: string;
+  /** null = 파일은 있으나 파싱 실패로 판을 확인하지 못했다. */
+  version: number | null;
+}
+
+export interface CompositionSelection {
+  composition?: TaskComposition;
+  unitsResolved: boolean;
+  missingUnits: string[];
+  launcher?: 'harness-say' | 'graph-run';
+  error?: string;
+}
+
+/** 1판은 조합을 고르고 단위 해석 결과를 기록한다. 단위 실행은 2판의 몫이다. */
+export function selectTaskComposition(completion: CompletionKind, root = join(dirname(fileURLToPath(import.meta.url)), '..', '..')): CompositionSelection {
+  const file = `graphs/work/${completion}.yaml`;
+  const path = join(root, file);
+  let source: string;
+  try { source = readFileSync(path, 'utf8'); } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') return { unitsResolved: false, missingUnits: [] };
+    return { composition: { file, version: null }, unitsResolved: false, missingUnits: [],
+      error: `조합 읽기 오류: ${file}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const parsed = parseGraphTemplateYaml(source, path);
+  if (!parsed.template || parsed.errors.length) {
+    let version: number | null = null;
+    try {
+      const raw: unknown = parseYaml(source);
+      if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+        const candidate = (raw as Record<string, unknown>).version;
+        if (typeof candidate === 'number' && Number.isInteger(candidate)) version = candidate;
+      }
+    } catch { /* 파싱 실패 자체를 아래 원장에 적는다. */ }
+    return { composition: { file, version }, unitsResolved: false, missingUnits: [],
+      error: `조합 오류: ${file}: ${parsed.errors.map(e => e.message).join('; ')}` };
+  }
+  const raw: unknown = parseYaml(source);
+  const launcher = raw && typeof raw === 'object' && !Array.isArray(raw) ? (raw as Record<string, unknown>).launcher : undefined;
+  if (launcher !== undefined && launcher !== 'harness-say' && launcher !== 'graph-run') {
+    return { composition: { file, version: parsed.template.version }, unitsResolved: false, missingUnits: [],
+      error: `조합 오류: ${file}: 모르는 launcher` };
+  }
+  if (completion === 'code-pr' && launcher === undefined) {
+    return { composition: { file, version: parsed.template.version }, unitsResolved: false, missingUnits: [],
+      error: `조합 오류: ${file}: launcher 없음` };
+  }
+  const missingUnits: string[] = [];
+  let unitError: string | undefined;
+  try { validateUnitCalls(parsed.template, path, [], call => missingUnits.push(call)); }
+  catch (error) { unitError = error instanceof Error ? error.message : String(error); }
+  return {
+    composition: { file, version: parsed.template.version },
+    unitsResolved: missingUnits.length === 0 && !unitError,
+    missingUnits,
+    ...(launcher === 'harness-say' || launcher === 'graph-run' ? { launcher } : {}),
+    ...(unitError ? { error: `조합 단위 해석 오류: ${file}: ${unitError}` } : {}),
+  };
+}
+
 /**
  * `run-bound`·`goal-bound`·`pr-bound` 은 runId(⊕ pr)를 싣는다 — 옛 카드의 칸은 at·event·detail 뿐이다.
  * TA-LIVE-MOVE-CARD-HISTORY — `live-move` 줄만 kind·executed·ok·executorResult·head·effect 를 더 싣는다(`live-move-history.ts`).
@@ -104,6 +168,8 @@ export interface TaskCardEvent {
   resultPath?: string;
   /** TA-REVIEW-RESULT-CAPTURE — `live-move-result` 줄만: 회수한 `self review --json` 의 칸(못 읽은 칸은 null). */
   verdict?: string | null; reviewed?: boolean | null; mustFix?: number | null; reviewRoute?: string | null;
+  /** Exact bytes of the captured review stdout; repair must read the same resultPath and digest. */
+  reviewSha256?: string;
 }
 /** 카드 history 의 live-move 줄 이벤트 이름 — 상태 사유(«마지막 칸») 판정에서 뺀다. */
 export const LIVE_MOVE_HISTORY_EVENT = 'live-move';
@@ -117,8 +183,15 @@ export interface TaskCard {
   text: string;
   seat?: TaskSeat;
   checklistId?: string;
+  /** Explicit release version for an adopted PR; post-land still confirms the cell exists there. */
+  checklistVersion?: string;
   /** 종결 종류 — 비면 code-pr. */
   completion?: CompletionKind;
+  /** 선택된 일 조합 파일과 판(1판: 실행은 launcher 에 위임). */
+  composition?: TaskComposition;
+  graphSelectedBy?: 'completion';
+  unitsResolved?: boolean;
+  missingUnits?: string[];
   /** 과제 대상 프로젝트(§A4b②) — target 은 절대 경로(git 이 아닐 수 있다). id 는 `task hand --project` 가 싣는다(옛 카드엔 없을 수 있다). */
   project?: { id?: string; target: string };
   /** 보드(§A4b① `board.ts`) 소속 — 목표 id · 이정표 id(`task hand --goal/--milestone`). 조각 카드의 `goalId`(골 sha 16자)와 다른 칸이다. */
@@ -130,7 +203,7 @@ export interface TaskCard {
    * failed = 발사된 런이 PR·수확 가지 없이 죽었거나 끝내 안 떴다(TA-JUDGE-DEAD-RUN · `card-evidence.ts`) — 사유
    * (`failed/needs-owner|needs-relaunch — …`)는 history 마지막 칸 · 자동 재발사하지 않는다(사람/판단부 몫).
    */
-  status: 'handed' | 'launched' | 'launch-failed' | 'failed';
+  status: 'handed' | 'launched' | 'launch-failed' | 'failed' | 'done';
   history: TaskCardEvent[];
   /** 미션 카드만 — 조각 카드 id(순서대로) · 쪼갠 출처(`mission.ts` splitMission). */
   pieces?: string[];
@@ -145,6 +218,12 @@ export interface TaskCard {
    * 번호는 `cardPrNumber` 로 읽는다(옛 카드의 number 도 그대로 읽힌다).
    */
   pr?: number | TaskCardPr;
+  /** Host-verified existing OPEN PR adopted without launching a new implementation run. */
+  adoptedPr?: { pr: number; url: string; head: string; at: string };
+  /** Bound PR observed in a terminal GitHub state. Only applies while the card still binds the same PR and URL. */
+  prTerminal?: { pr: number; url: string; head: string; state: 'MERGED' | 'CLOSED'; at: string };
+  /** Post-land checklist judgement. A partial slice closes this card while leaving the checklist cell yellow. */
+  postLand?: { pr: number; head: string; at: string; outcome: 'complete' | 'partial'; evidence: string[]; remaining: string[] };
   goalId?: string;
   /** `manual` = pr/goalId 를 사람이 적었다(`recordPieceRef`) — 런 묶기가 건드리지 않는다. */
   refSource?: 'manual';
@@ -185,6 +264,10 @@ export interface TaskCard {
   taLand?: true;
   /** TASKS-HAND-CHILD-LLM — `tasks hand --child-llm <provider>/<model> [--child-llm-effort <level>]` → 발사 인자 `--child-llm-provider/-model/-effort`. */
   childLlm?: TaskChildLlm;
+  /** Same-PR repair launches; exact source head and worker result are retained for CAS and retry limits. */
+  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 }>;
 }
 
 /** 구현 자식 LLM 선택 — 하니스 `--child-llm-provider/--child-llm-model/--child-llm-effort` 로 그대로 넘긴다(검증 권위는 하니스). */
@@ -215,6 +298,12 @@ export function cardPrNumber(card: Pick<TaskCard, 'pr'>): number | undefined {
   return typeof card.pr === 'number' ? card.pr : card.pr?.number;
 }
 
+/** A stale terminal marker must never close a card after its PR binding changes. */
+export function boundPrTerminal(card: Pick<TaskCard, 'pr' | 'prTerminal'>): TaskCard['prTerminal'] | undefined {
+  const marker = card.prTerminal;
+  return marker && typeof card.pr === 'object' && card.pr.number === marker.pr && card.pr.url === marker.url ? marker : undefined;
+}
+
 /** A uniquely launched code-PR card may own a draft through its PR or its opening run. */
 export function draftTaskOwner(cards: readonly TaskCard[], draft: { number: number; runId?: string | null }): TaskCard | undefined {
   const owners = cards.filter((card) => card.status === 'launched' && (card.completion ?? 'code-pr') === 'code-pr'
@@ -374,6 +463,8 @@ export interface HandTaskOptions {
   childLlm?: string;
   childLlmEffort?: string;
   statePath?: string;
+  /** 시험에서만 조합 저장소를 바꿔 해석·거부를 검증한다. */
+  compositionRoot?: string;
   /** `--live` 일 때만 불린다. */
   launcher?: TaskLauncher;
   now?: () => Date;
@@ -443,6 +534,11 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   }
   if (opts.childLlmEffort !== undefined && opts.childLlm === undefined) throw new Error('--child-llm-effort 는 --child-llm <provider>/<model> 과 함께 준다');
   const childLlm = opts.childLlm !== undefined ? parseChildLlm(opts.childLlm, opts.childLlmEffort) : undefined;
+  const completion = opts.completion ?? 'code-pr';
+  const selected = selectTaskComposition(completion, opts.compositionRoot);
+  const selectionFailure = !selected.composition ? `조합 없음: graphs/work/${completion}.yaml`
+    : selected.error ?? (completion !== 'code-pr' || selected.launcher !== 'harness-say'
+      ? `조합 실행기 없음: ${selected.composition.file} (1판은 code-pr harness-say만 발사)` : undefined);
   let project: TaskCard['project'];
   let targetIsGit: boolean | null = null;
   if (opts.project) {
@@ -467,19 +563,25 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(opts.seat ? { seat: opts.seat } : {}),
     ...(opts.checklistId ? { checklistId: opts.checklistId } : {}),
     ...(opts.completion ? { completion: opts.completion } : {}),
+    ...(selected.composition ? { composition: selected.composition, graphSelectedBy: 'completion' as const } : {}),
+    unitsResolved: selected.unitsResolved,
+    missingUnits: selected.missingUnits,
     ...(project ? { project } : {}),
     ...(opts.goal ? { goal: opts.goal } : {}),
     ...(opts.milestone ? { milestone: opts.milestone } : {}),
     ...(opts.taLand === true ? { taLand: true as const } : {}),
     ...(childLlm ? { childLlm } : {}),
     createdAt: now.toISOString(),
-    status: 'handed',
-    history: [],
+    status: selectionFailure ? 'failed' : 'handed',
+    history: selectionFailure ? [{ at: now.toISOString(), event: !selected.composition ? 'composition-missing'
+      : selected.error ? 'composition-invalid' : 'composition-launcher-unavailable', detail: selectionFailure }] : [],
     ...(opts.mission ? { mission: opts.mission, after: [...(opts.after ?? [])] } : {}),
-    ...(opts.cardFields ?? {}),
+    ...(opts.cardFields?.pr !== undefined ? { pr: opts.cardFields.pr } : {}),
+    ...(opts.cardFields?.goalId !== undefined ? { goalId: opts.cardFields.goalId } : {}),
+    ...(opts.cardFields?.handed !== undefined ? { handed: opts.cardFields.handed } : {}),
   };
-  const move = nextMoveFor(card, opts.landed);
-  if (move.kind !== 'launch') throw new Error(`발사할 수 없는 과제다 — ${move.reason}`);
+  const move = selectionFailure ? undefined : nextMoveFor(card, opts.landed);
+  if (move && move.kind !== 'launch') throw new Error(`발사할 수 없는 과제다 — ${move.reason}`);
   const guard = opts.writeGuard;
   const writeCard = (target: string, next: TaskCard): void => {
     if (!guard) { writeTaskCards(target, [next]); return; }
@@ -495,6 +597,13 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     if (!owned.ok) throw new TaskCardSupersededError(next.id);
   };
   writeCard(path, card);
+  try { debug.log('task-agent.graph-select', !selected.composition ? 'composition-missing' : selected.error ? 'composition-invalid' : 'composition-selected', {
+    completion, file: selected.composition?.file ?? `graphs/work/${completion}.yaml`,
+    unitsResolved: selected.unitsResolved, missingUnits: selected.missingUnits,
+    ...(selected.error ? { error: selected.error } : {}),
+  }); } catch { /* fail-soft */ }
+  if (selectionFailure) throw new Error(`${selectionFailure} (카드 ${id})`);
+  if (!move || move.kind !== 'launch') throw new Error('조합 선택 뒤 발사 수가 없다');
   try { debug.log('task-agent', 'handed', { taskId: id, seat: card.seat ?? null, checklistId: card.checklistId ?? null, mode, projectId: project?.id ?? null, targetIsGit, taLand: card.taLand === true }); } catch { /* fail-soft */ }
   if (childLlm) {
     try { debug.log('task-agent', 'child-llm', { taskId: id, input: opts.childLlm, provider: childLlm.provider, model: childLlm.model, effort: childLlm.effort ?? null, mode }); } catch { /* fail-soft */ }

package/src/task-orchestrator/surfaces/kubectl-transient-retry.ts

@@ -0,0 +1,51 @@
+/**
+ * K3S-SECRET-DB-LOCK-RETRY — kubectl 호출이 «일시 오류»로 거부되면 지수 백오프로 다시 친다.
+ *
+ * 근거: node-b k3d(k3s · sqlite 저장소)가 Pod Secret 생성 때
+ *   `Error from server: error when creating "STDIN": rpc error: code = Unknown desc = database is locked`
+ * 로 거부했다(10-15 02:11 KST 전후 4건 · TC #4186). sqlite 쓰기 잠금 경합이라 잠시 뒤 같은 apply 는 선다.
+ *
+ * ⛔ 판정 문구는 «실측 근거가 있는 것»만 둔다 — 짐작으로 늘리면 진짜 거부(권한·스키마)를 백오프 동안 삼킨다.
+ * 재시도 소진 시에만 호출부의 기존 실패 경로로 마지막 결과를 그대로 돌려준다.
+ */
+import { debug } from '../../debug/log.js';
+
+export type KubectlCallResult = { status: number | null; stdout: string; stderr: string };
+
+/** 실측된 일시 오류 문구(stderr 만 · 부분 일치 · 대소문자 무시 — stdout 은 apply 결과라 판정에 안 쓴다). */
+export const KUBECTL_TRANSIENT_PATTERNS: readonly RegExp[] = [/database is locked/i];
+
+/** 재시도 사이 대기(ms) — 길이가 곧 재시도 상한(4회 · 합 7.5s). */
+export const KUBECTL_TRANSIENT_BACKOFF_MS: readonly number[] = [500, 1_000, 2_000, 4_000];
+
+export function kubectlTransientReason(result: KubectlCallResult): string | null {
+  if (result.status === 0) return null;
+  const hit = KUBECTL_TRANSIENT_PATTERNS.find((pattern) => pattern.test(result.stderr));
+  return hit ? hit.source : null;
+}
+
+/**
+ * 첫 결과 `first` 가 일시 오류일 때만 부른다(성공 경로에 await 를 더하지 않으려고 — 호출부의 마이크로태스크 순서를 지킨다).
+ * 다시 친 결과가 성공이거나 일시 오류가 아니면 즉시 돌려주고, 백오프를 다 써도 일시 오류면 마지막 결과를 돌려준다.
+ */
+export async function retryKubectlTransient(
+  run: () => KubectlCallResult,
+  first: KubectlCallResult,
+  opts: { sleep: (ms: number) => Promise<void>; category: string; data?: Record<string, unknown>; backoffMs?: readonly number[] },
+): Promise<KubectlCallResult> {
+  const backoff = opts.backoffMs ?? KUBECTL_TRANSIENT_BACKOFF_MS;
+  let last = first;
+  let reason = kubectlTransientReason(last);
+  for (let i = 0; i < backoff.length && reason; i++) {
+    debug.log(opts.category, 'retry', { ...opts.data, attempt: i + 1, maxAttempts: backoff.length, delayMs: backoff[i], reason });
+    await opts.sleep(backoff[i]!);
+    last = run();
+    reason = kubectlTransientReason(last);
+    if (last.status === 0) {
+      debug.log(opts.category, 'retry-recovered', { ...opts.data, attempt: i + 1 });
+      return last;
+    }
+  }
+  if (reason) debug.log(opts.category, 'retry-exhausted', { ...opts.data, attempts: backoff.length, reason, stderr: last.stderr.trim().slice(0, 300) }, { level: 'warn' });
+  return last;
+}

package/src/task-orchestrator/surfaces/pod-command-job.ts

@@ -16,10 +16,11 @@ import { collectPodArtifacts } from './pod-artifact-return.js';
 import { getDefaultLogStore, type LogStore } from '../../mss/logging/log-store.js';
 import { podBunCacheVolume } from './pod-bun-cache.js';
 import { POD_JOB_TTL_AFTER_FINISHED_SECONDS } from './pod-lease.js';
-import { podHostDirsInit, podInstallSlotsVolume } from './pod-install-slots.js';
+import { podHostDirsScript, podInstallSlotsVolume } from './pod-install-slots.js';
 import { type PodPoolMember, PodPoolScheduler, resolvePodPoolSpec, parsePodPool, checkPodPool, syncPoolImages, type PoolKubectl } from './pod-pool.js';
 import { podSkillsDigest, readSkillEnvFiles, resolvePodSkills } from './pod-skills.js';
 import { podSourceScript, type PodSource } from './pod-source-receive.js';
+import { seedMirrorOnce, type MirrorSeedResult } from './pod-mirror-seed.js';
 import {
   POD_CHILD_REQUESTS,
   POD_JOB_DEADLINE_SECONDS,
@@ -132,13 +133,18 @@ export function tailBytes(text: string, maxBytes: number): string {
   return `…[앞 ${bytes.length - maxBytes}바이트 생략]\n${cut.subarray(start).toString('utf8')}`;
 }
 
-const GATE = `ok=0
+/** The isolation probe: wait until the NetworkPolicy blocks the host/prod daemons, then run `onPass` (default `exit 0`). */
+function isolationGateScript(onPass = 'exit 0'): string {
+  return `ok=0
 for i in $(seq 1 60); do
   if curl -s -m 1 -o /dev/null http://host.orb.internal:31415/health || curl -s -m 1 -o /dev/null http://core.elanous-prod:8080/; then ok=0; else ok=$((ok+1)); fi
-  [ "$ok" -ge 3 ] && { echo "[gate] isolation enforced after \${i} probes"; exit 0; }
+  [ "$ok" -ge 3 ] && { echo "[gate] isolation enforced after \${i} probes"; ${onPass}; }
   sleep 0.5
 done
 echo "[gate] ISOLATION NOT ENFORCED within 30s"; exit 1`;
+}
+
+const GATE = isolationGateScript();
 
 /** Export the command's log store into the existing outbox return channel without changing the command exit status. */
 const COMMAND_LOG_EXPORT = `if mkdir -p "$HOME/outbox/pod-logs" && elanous --test="$HOME/.elanous-test" logs --instance prod --since 12h --limit 20000 --json --json-data > "$HOME/outbox/pod-logs/logs.jsonl"; then
@@ -244,6 +250,10 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
     // A command may not end in LF; keep artifact markers on their own line for the existing parser.
     ...(o.returnLogs ? ["printf '\\n'", COMMAND_LOG_EXPORT] : []),
     ARTIFACT_EMIT,
+    // GATE-POD-RESULT-MARKER: the last line says «the child is done» so the host need not wait for the Job condition
+    // (k3d on node-b flips it 90~550s late). Leading LF keeps it on its own line; the host strips exactly this tail.
+    // The token is this launch's random id — a command that prints the bare marker word cannot end the wait early.
+    `printf '\\n${podResultMarker(o.launch ?? o.name)} rc=%s\\n' "$rc"`,
     'exit $rc',
   ].join('\n');
   const secretKeys = grok || skillNames.length || o.clone === true;
@@ -261,8 +271,12 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
           restartPolicy: 'Never',
           securityContext: { runAsUser: 1000, fsGroup: 1000 },
           initContainers: [
-            { name: 'isolation-gate', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never', command: ['bash', '-c'], args: [GATE] },
-            ...(hostDirMounts.length ? [podHostDirsInit(o.image, o.imagePullPolicy ?? 'Never', hostDirMounts)] : []),
+            // GATE-WARM-BOOT (10-15): ONE init container. Each extra container cost minutes on a loaded k3d node (the measured
+            // gap between a finished init script and the next container start), so the root host-dir hand-over runs inside
+            // the isolation init after the probe passes instead of as a second `host-dirs` container.
+            hostDirMounts.length
+              ? { name: 'isolation-gate', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never', securityContext: { runAsUser: 0 }, command: ['bash', '-c'], args: [isolationGateScript(podHostDirsScript(hostDirMounts))], volumeMounts: hostDirMounts.map((mount) => ({ ...mount })) }
+              : { name: 'isolation-gate', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never', command: ['bash', '-c'], args: [GATE] },
           ],
           containers: [{
             name: 'child', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never',
@@ -380,6 +394,10 @@ export interface RunPodCommandOptions {
   kubectl?: Kubectl;
   /** A caller-owned scheduler is self-capped: acquires count only its own Jobs, never cluster occupancy (POOLGLOBAL-REG). */
   poolScheduler?: PodPoolScheduler;
+  /** GATE-WARM-BOOT — seeds a commit-pinned clone's commit into the pool host mirror (test seam · default {@link seedMirrorOnce}). */
+  seedMirror?: (o: { host: string; commit: string; cwd: string }) => Promise<MirrorSeedResult | undefined>;
+  /** GATE-WARM-BOOT — the git tree the seed pushes from (default: the process cwd — the gate runs in the repo tree). */
+  mirrorSeedCwd?: string;
   checkPool?: typeof checkPodPool;
   syncImages?: typeof syncPoolImages;
   imageCommit?: string | null;
@@ -396,6 +414,19 @@ export interface RunPodCommandOptions {
   childLogMaxBytes?: number;
 }
 
+/** GATE-POD-RESULT-MARKER — the child script's final line (`\n<marker> <token> rc=<n>\n`), printed after the artifact emit. */
+export const POD_RESULT_MARKER = '__ELANOUS_POD_DONE__';
+/** The marker bound to one launch (`token` = the launch's random id · the Job name when the manifest has no launch). */
+export function podResultMarker(token: string): string { return `${POD_RESULT_MARKER} ${token}`; }
+
+/** Split the child's logs into the command output (marker tail removed, bytes otherwise unchanged) and the marker rc (null = no marker for this token). */
+export function splitPodResultMarker(logs: string, token: string): { logs: string; rc: number | null } {
+  const escaped = podResultMarker(token).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = new RegExp(`\\n${escaped} rc=(\\d+)\\n?$`).exec(logs);
+  if (!match) return { logs, rc: null };
+  return { logs: logs.slice(0, match.index), rc: Number(match[1]) };
+}
+
 function jobFinished(types: string): 'complete' | 'failed' | null {
   if (/Complete|SuccessCriteriaMet/.test(types)) return 'complete';
   if (/Failed|FailureTarget/.test(types)) return 'failed';
@@ -522,6 +553,16 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
     }
     const imageRef = member?.imageRef;
     if (!imageRef) log('pod.command-job', 'image-fallback-local', { reason: !member ? 'no-pool-member' : !imageCommit ? 'image-commit-unavailable' : 'registry-tag-unavailable' });
+    // GATE-WARM-BOOT (10-15): a commit-pinned clone on a pool host — put that commit into the host's mirror first (once per
+    // host·commit in this process), so the Pod's podSourceScript finds it (`cat-file -e`) instead of fetching from GitHub.
+    // Best effort: a failed seed only logs; the Pod keeps the old path. Never with an injected kubectl (tests) unless seeded.
+    const seedMirror = options.seedMirror ?? (options.kubectl ? undefined : seedMirrorOnce);
+    if (seedMirror && options.clone && options.source?.kind === 'commit' && hostMirror && member?.sshHost) {
+      // Worst case added to a cold start: the push limit (GATE_MIRROR_SEED_LIMIT_MS), once per host·commit.
+      const seed = await seedMirror({ host: member.sshHost, commit: options.source.sha, cwd: options.mirrorSeedCwd ?? process.cwd() })
+        .catch((error: unknown) => ({ host: member!.sshHost!, ok: false, ms: 0, detail: String(error).slice(0, 300) }));
+      log('pod.command-job', 'mirror-seed', { host: member.sshHost, commit: options.source.sha, ok: seed?.ok ?? false, ms: seed?.ms ?? 0, ...(seed?.detail ? { detail: seed.detail } : {}) });
+    }
     const ghToken = options.clone ? (options.ghToken ?? defaultGhToken)() : undefined;
     const secret = commandJobSecret({ name, namespace, launch, skills, skillEnvText, ...(grokAuth !== undefined ? { grokAuth } : {}), ...(ghToken !== undefined ? { ghToken } : {}) });
     if (secret) {
@@ -543,10 +584,24 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
     }
     let state: 'complete' | 'failed' = 'failed';
     let unreadableSince: number | null = null;
+    let markerRc: number | null = null;
+    const appliedAt = Date.now();
     for (;;) {
       const got = kubectl(['-n', namespace, 'get', 'job', name, '-o', 'jsonpath={.status.conditions[*].type}']);
       const finished = jobFinished(got.stdout);
       if (finished) { state = finished; break; }
+      // GATE-POD-RESULT-MARKER: the condition is not there yet — the child may already be done (k3d condition lag).
+      // A tail read that fails (Pod still pending · init container) or lacks the marker changes nothing.
+      const tail = kubectl(['-n', namespace, 'logs', `job/${name}`, '-c', 'child', '--tail=2']);
+      if (tail.status === 0) {
+        const seen = splitPodResultMarker(tail.stdout.startsWith('\n') ? tail.stdout : `\n${tail.stdout}`, launch).rc;
+        if (seen !== null) {
+          markerRc = seen;
+          state = seen === 0 ? 'complete' : 'failed';
+          log('pod.command-job', 'result-marker-early', { job: name, waitedMs: Date.now() - appliedAt, rc: seen });
+          break;
+        }
+      }
       if (got.status !== 0 && options.statusUnreadableMs !== undefined) {
         unreadableSince ??= Date.now();
         if (Date.now() - unreadableSince >= options.statusUnreadableMs) {
@@ -558,7 +613,7 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
     }
     const logsResult = kubectl(['-n', namespace, 'logs', `job/${name}`, '-c', 'child']);
     const logsFailed = logsResult.status !== 0;
-    const logs = logsFailed ? '' : logsResult.stdout;
+    const logs = logsFailed ? '' : splitPodResultMarker(logsResult.stdout, launch).logs;
     const artifactDir = artifactRoot;
     let artifacts: PodArtifactCollection;
     if (logsFailed) {
@@ -591,7 +646,8 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
     const maxBytes = options.childLogMaxBytes ?? podChildLogMaxBytes();
     const childLog = logsFailed ? `산출 회수 못 함: ${artifacts.error}` : tailBytes(logs, maxBytes);
     writeFileSync(resolve(artifactsDir, 'child.log'), childLog);
-    const exitCode = exitCodeFromPod(kubectl, namespace, name, state);
+    // Marker path: the rc the child printed (the Pod's terminated state may lag like the condition). Condition path: unchanged.
+    const exitCode = markerRc ?? exitCodeFromPod(kubectl, namespace, name, state);
     cleanupSecret();
     log('pod.command', 'job-finished', {
       job: name,

package/src/task-orchestrator/surfaces/pod-install-slots.ts

@@ -22,7 +22,7 @@ export const POD_INSTALL_SLOTS_DEFAULT = 4;
 export const POD_INSTALL_SLOTS_MOUNT = '/gate-install-slots';
 
 /** hostPath volume ⊕ mount for the tokens. `DirectoryOrCreate` makes a root-owned 0755 directory, so the Pod also needs
- *  {@link podHostDirsInit} (the child runs as uid 1000). */
+ *  {@link podHostDirsScript} (the child runs as uid 1000). */
 export function podInstallSlotsVolume(hostPath: string = POD_INSTALL_SLOTS_HOST_PATH) {
   return {
     volume: { name: 'install-slots', hostPath: { path: hostPath, type: 'DirectoryOrCreate' } },
@@ -31,19 +31,14 @@ export function podInstallSlotsVolume(hostPath: string = POD_INSTALL_SLOTS_HOST_
 }
 
 /**
- * A root init container that hands the mounted hostPath directories to the child's uid. Without it a `DirectoryOrCreate`
+ * The root shell that hands the mounted hostPath directories to the child's uid. Without it a `DirectoryOrCreate`
  * hostPath stays root:root 0755 and the child's `[ -w … ]` guard silently skips it (the Bun cache option was a no-op).
+ * Never fails the Pod: an unchanged directory only means the child falls back (no cache · no throttle).
+ * GATE-WARM-BOOT — it runs inside the Pod's single init container (after the isolation probe), not as a second one.
  */
-export function podHostDirsInit(image: string, imagePullPolicy: string, mounts: ReadonlyArray<{ name: string; mountPath: string; readOnly: boolean }>) {
+export function podHostDirsScript(mounts: ReadonlyArray<{ mountPath: string }>): string {
   const paths = mounts.map((mount) => `'${mount.mountPath.replace(/'/g, `'\\''`)}'`).join(' ');
-  return {
-    name: 'host-dirs', image, imagePullPolicy,
-    securityContext: { runAsUser: 0 },
-    command: ['sh', '-c'],
-    // Never fails the Pod: an unchanged directory only means the child falls back (no cache · no throttle).
-    args: [`for d in ${paths}; do mkdir -p "$d" && chown 1000:1000 "$d" && chmod 0775 "$d" || echo "[host-dirs] could not prepare $d"; done; exit 0`],
-    volumeMounts: mounts.map((mount) => ({ ...mount })),
-  };
+  return `for d in ${paths}; do mkdir -p "$d" && chown 1000:1000 "$d" && chmod 0775 "$d" || echo "[host-dirs] could not prepare $d"; done; exit 0`;
 }
 
 const int = (value: number, label: string) => {

package/src/task-orchestrator/surfaces/pod-mirror-seed.ts

@@ -0,0 +1,76 @@
+// GATE-WARM-BOOT (10-15) — put the cut commit into each pool host's git mirror before the shard Pods start.
+//
+// S: 0.2.29 gate Pods spent 750–840 s before the shard shell; the tests took 0–69 s. Every Pod clones from the host
+//    mirror (`pod.hostMirror` → `/host-mirror`, podSourceScript), but the cut commit e1783835 was not in the node-b mirror
+//    (the mirror's own fetch loop follows `main`; only the `--remote` host executor pushed `refs/elanous/gate/<sha>`).
+//    So all 68 Pods fell to `git fetch --depth 1 origin <sha>` from GitHub, under load, one by one.
+// A: push `<sha>:refs/elanous/gate/<sha>` to the placed pool member's mirror once per (host, commit) per process — podSourceScript's commit branch
+//    then passes `git cat-file -e` and skips the GitHub fetch. Best effort: a failed push is recorded and the Pod keeps
+//    its old path (fetch from GitHub) — never a silent use of another tree.
+import { spawn } from 'node:child_process';
+import { debug } from '../../debug/log.js';
+
+/** Host-side mirror path (relative to the ssh user's home) — the k3d node binds `~/mirror` at `/mirror-host`. */
+export const GATE_POOL_MIRROR_PATH = 'mirror/elanous-agent.git';
+export const GATE_MIRROR_SEED_LIMIT_MS = 120_000;
+
+export interface MirrorSeedResult { host: string; ok: boolean; ms: number; detail?: string }
+
+type Push = (args: string[], cwd: string, limitMs: number) => Promise<{ rc: number; output: string }>;
+
+export async function seedPoolMirrors(o: { hosts: readonly (string | undefined)[]; commit: string; tree: string; push: Push; mirrorPath?: string; limitMs?: number }): Promise<MirrorSeedResult[]> {
+  if (!/^[0-9a-f]{40}$/.test(o.commit)) throw new Error('invalid gate commit');
+  const mirror = o.mirrorPath ?? GATE_POOL_MIRROR_PATH;
+  const hosts = [...new Set(o.hosts.filter((host): host is string => !!host && /^[\w.@-]+$/.test(host) && !host.startsWith('-')))];
+  const results = await Promise.all(hosts.map(async (host): Promise<MirrorSeedResult> => {
+    const start = Date.now();
+    try {
+      const run = await o.push(['push', '--quiet', '--no-verify', `${host}:${mirror}`, `${o.commit}:refs/elanous/gate/${o.commit}`], o.tree, o.limitMs ?? GATE_MIRROR_SEED_LIMIT_MS);
+      const ms = Date.now() - start;
+      return run.rc === 0 ? { host, ok: true, ms } : { host, ok: false, ms, detail: run.output.trim().slice(-300) };
+    } catch (error) {
+      return { host, ok: false, ms: Date.now() - start, detail: String(error).slice(0, 300) };
+    }
+  }));
+  for (const result of results) {
+    debug.log('release-loop.gate', result.ok ? 'pod-mirror-seeded' : 'pod-mirror-seed-failed', { ...result, commit: o.commit }, result.ok ? undefined : { level: 'warn' });
+  }
+  return results;
+}
+
+const seeded = new Map<string, Promise<MirrorSeedResult | undefined>>();
+
+/** Bounded `git <args>` in `cwd` — killed after `limitMs`; never throws. */
+export function gitWithin(args: string[], cwd: string, limitMs: number): Promise<{ rc: number; output: string }> {
+  return new Promise((resolve) => {
+    let output = '';
+    let child;
+    try { child = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] }); }
+    catch (error) { resolve({ rc: 2, output: String(error) }); return; }
+    const timer = setTimeout(() => { output += `\n[mirror-seed] timed out after ${limitMs} ms`; child.kill('SIGKILL'); }, limitMs);
+    child.stdout?.on('data', (chunk) => { output += String(chunk); });
+    child.stderr?.on('data', (chunk) => { output += String(chunk); });
+    child.on('error', (error) => { clearTimeout(timer); resolve({ rc: 2, output: `${output}\n${String(error)}` }); });
+    child.on('close', (code) => { clearTimeout(timer); resolve({ rc: code ?? 2, output }); });
+  });
+}
+
+/**
+ * Seed once per (host, commit) in this process: every shard Job placed on the same member awaits the same push, so a
+ * 28-shard gate pushes once per host. `cwd` must be a git tree that has the commit (the gate runs in the repo tree).
+ */
+export function seedMirrorOnce(o: { host: string; commit: string; cwd: string; push?: Push }): Promise<MirrorSeedResult | undefined> {
+  const key = `${o.host}\0${o.commit}`;
+  let pending = seeded.get(key);
+  if (!pending) {
+    // A failed seed is not memoized — the next Job on that host tries again (a transient ssh drop must not send the whole gate to GitHub).
+    pending = seedPoolMirrors({ hosts: [o.host], commit: o.commit, tree: o.cwd, push: o.push ?? gitWithin })
+      .then((results) => { if (!results[0]?.ok) seeded.delete(key); return results[0]; },
+        (error: unknown) => { seeded.delete(key); return { host: o.host, ok: false, ms: 0, detail: String(error).slice(0, 300) }; });
+    seeded.set(key, pending);
+  }
+  return pending;
+}
+
+/** Test seam — forget the per-process seed memo. */
+export function resetMirrorSeedMemo(): void { seeded.clear(); }