elanous 0.2.28 → 0.2.31

package/src/task-agent/train-landing.ts

@@ -0,0 +1,77 @@
+import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export interface TrainLanding {
+  componentPr: number;
+  integrationPr: number;
+  mergeSha: string;
+  train: string;
+}
+
+interface TrainLedgerRow extends Omit<TrainLanding, 'mergeSha'> { mergePrefix: string }
+
+/** HQ train ledger is advisory until the integration PR's exact merge commit is verified. */
+export function trainLedgerPath(): string {
+  return process.env.ELANOUS_TRAIN_LEDGER_PATH || join(homedir(), 'elanous-hq', 'seat-state', 'OP', 'train-ledger.tsv');
+}
+
+export function trainLedgerComponent(text: string, componentPr: number): TrainLedgerRow | null {
+  const lines = text.trim().split(/\r?\n/);
+  if (lines.shift() !== 'time\ttrain\tintegrationPr\tmergeSha\tcomponentPrs\tsideHost\tresult') return null;
+  let matched: TrainLedgerRow | null = null;
+  let matchedLine: string | null = null;
+  for (const line of lines) {
+    const fields = line.split('\t');
+    if (fields.length !== 7) return null;
+    const integrationPr = Number(fields[2]);
+    const mergePrefix = fields[3]?.toLowerCase() ?? '';
+    const componentPrs = (fields[4] ?? '').split(',').map(Number);
+    if (!componentPrs.every((pr) => Number.isSafeInteger(pr) && pr > 0)) return null;
+    if (!componentPrs.includes(componentPr)) continue;
+    if (fields[6] !== 'merged' || !Number.isSafeInteger(integrationPr) || integrationPr <= 0
+      || !/^[a-f0-9]{12,40}$/.test(mergePrefix)) return null;
+    const row = { componentPr, integrationPr, mergePrefix, train: fields[1] ?? '' };
+    if (matchedLine !== null && matchedLine !== line) return null;
+    matched = row;
+    matchedLine = line;
+  }
+  return matched;
+}
+
+export type TrainPrView = (pr: number, cwd: string) => { state: string; mergeSha?: string } | null;
+
+export function defaultTrainPrView(pr: number, cwd: string): ReturnType<TrainPrView> {
+  const run = (env: NodeJS.ProcessEnv) => spawnSync('gh', ['pr', 'view', String(pr), '--json', 'state,mergeCommit'],
+    { cwd, env, encoding: 'utf8', timeout: 20_000, maxBuffer: 512 * 1024 });
+  let result = run(process.env);
+  if (result.status !== 0) {
+    const noProxy = { ...process.env };
+    for (const key of ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy']) delete noProxy[key];
+    result = run(noProxy);
+  }
+  if (result.status !== 0) return null;
+  try {
+    const parsed = JSON.parse(result.stdout) as { state?: unknown; mergeCommit?: { oid?: unknown } };
+    return typeof parsed.state === 'string' && typeof parsed.mergeCommit?.oid === 'string'
+      ? { state: parsed.state, mergeSha: parsed.mergeCommit.oid } : null;
+  } catch { return null; }
+}
+
+export function verifiedTrainLanding(componentPr: number, cwd: string, opts: {
+  ledgerText?: string;
+  readLedger?: () => string;
+  trainPrView?: TrainPrView;
+} = {}): TrainLanding | null {
+  let ledger: string;
+  try { ledger = opts.ledgerText ?? (opts.readLedger ?? (() => readFileSync(trainLedgerPath(), 'utf8')))(); }
+  catch { return null; }
+  const row = trainLedgerComponent(ledger, componentPr);
+  if (!row) return null;
+  let view: ReturnType<TrainPrView>;
+  try { view = (opts.trainPrView ?? defaultTrainPrView)(row.integrationPr, cwd); } catch { return null; }
+  const mergeSha = view?.mergeSha?.toLowerCase();
+  return view?.state === 'MERGED' && mergeSha && /^[a-f0-9]{40}$/.test(mergeSha) && mergeSha.startsWith(row.mergePrefix)
+    ? { componentPr, integrationPr: row.integrationPr, mergeSha, train: row.train } : null;
+}

package/src/task-agent/work-order.ts

@@ -0,0 +1,104 @@
+/**
+ * TASK-AGENT 작업 지시서(work order) 스키마 — RFC-adaptive-graph-ops-2026-10-09 §9 «작업 지시서» 칸 아홉.
+ *
+ * 조율자 → TA 호출의 계약으로 칸 제목 한 줄을 대신한다. 이 첫 조각은 스키마와 검증(`parseWorkOrder`)·
+ * 골 문면 펼치기만 담는다 — 조율자가 칸·신호·선례에서 지시서를 «자동 작성»하는 일은 다음 조각이다.
+ *
+ * 칸 아홉(RFC 목록 그대로 — 칸 1·4는 여러 키로 펼친다):
+ *   1. `lifeId` · 칸 id(`cellId`) · 판(`version`) · 착지 마감(`landBy`) — cellId 만 필수다.
+ *   2. 신분 태그(`identityTags` — class·care·rights·origin·rework)
+ *   3. 우선순위(`priority` — 신호 order 순위 · 승수 등급 · 대표 표시)
+ *   4. 판정 신호(`verdictSignal` — 조건·관측·기대) ⊕ 현재 계약 한 줄(`contract`)
+ *   5. 경계(`boundary` — 대상 경로 · 건드리지 말 곳)
+ *   6. 예산(`budget` — 시간 · 모델 티어 · Pod 자리 · 재작업 상한)
+ *   7. 선행·짝 칸(`peers`)
+ *   8. 선례 묶음(`precedents` — 같은 칸 앞 생애 결말·must-fix 서명)
+ *   9. 올림 규칙(`escalation` — 무엇이면 누구에게 · 돈·보안은 대표)
+ *
+ * 빠진 칸은 거부하지 않고 «모름»(`WORK_ORDER_UNKNOWN`)으로 채워 그 키를 `unknownFields` 에 적는다
+ * (RFC: 비우면 TA 가 추측한다). 거부는 두 가지뿐 — JSON 이 깨졌거나 칸 id 가 없거나.
+ */
+
+/** 빠진 칸을 채우는 값 — RFC «빠진 칸은 «모름»으로 적는다». */
+export const WORK_ORDER_UNKNOWN = '모름';
+/** 지시서 골 파일 이름 접미 — 이 이름으로 끝나는 파일만 지시서로 검증한다. */
+export const WORK_ORDER_FILE_PATTERN = /\.work-order\.json$/i;
+
+/** 칸 아홉 중 채울 수 있는 키(칸 id 제외) — unknownFields 는 이 순서로 적는다. */
+export const WORK_ORDER_FIELDS = [
+  'lifeId', 'version', 'landBy',
+  'identityTags', 'priority', 'verdictSignal', 'contract',
+  'boundary', 'budget', 'peers', 'precedents', 'escalation',
+] as const;
+export type WorkOrderField = typeof WORK_ORDER_FIELDS[number];
+
+/** 검증을 통과한 작업 지시서 — 모든 칸이 문자열로 채워져 있다(빠진 칸은 «모름»). */
+export interface WorkOrder {
+  lifeId: string;
+  /** 필수 칸 — 이것만 없으면 거부한다. */
+  cellId: string;
+  version: string;
+  landBy: string;
+  identityTags: string;
+  priority: string;
+  verdictSignal: string;
+  contract: string;
+  boundary: string;
+  budget: string;
+  peers: string;
+  precedents: string;
+  escalation: string;
+  /** 입력에 없어 «모름»으로 채운 키. */
+  unknownFields: string[];
+}
+
+export type ParseWorkOrderResult = { ok: true; order: WorkOrder } | { ok: false; reason: string };
+
+/** 칸 하나를 사람이 읽는 문자열로 정규화한다 — 없거나 비면 «모름», 문자열이 아니면 JSON 표기로. */
+function cellText(value: unknown): string {
+  if (value === undefined || value === null) return WORK_ORDER_UNKNOWN;
+  if (typeof value === 'string') { const carried = value.trim(); return carried || WORK_ORDER_UNKNOWN; }
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  try { const carried = JSON.stringify(value); return carried === 'null' || carried === undefined ? WORK_ORDER_UNKNOWN : carried; }
+  catch { return WORK_ORDER_UNKNOWN; }
+}
+
+/**
+ * 지시서 JSON 원문을 검증한다. 깨진 JSON 은 `JSON 이 깨졌다: …`, 칸 id(문자열)가 없으면 `칸 id 가 없다`
+ * 하나로 거부하고, 그 밖의 빠진 칸은 «모름»으로 채운다(거부 아님).
+ */
+export function parseWorkOrder(source: string): ParseWorkOrderResult {
+  let parsed: unknown;
+  try { parsed = JSON.parse(source); }
+  catch (error) {
+    return { ok: false, reason: `JSON 이 깨졌다: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const record = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+  const rawCellId = record['cellId'];
+  if (typeof rawCellId !== 'string' || !rawCellId.trim()) return { ok: false, reason: '칸 id 가 없다' };
+  const unknownFields: string[] = [];
+  const cells = {} as Record<WorkOrderField, string>;
+  for (const field of WORK_ORDER_FIELDS) {
+    const text = cellText(record[field]);
+    if (text === WORK_ORDER_UNKNOWN) unknownFields.push(field);
+    cells[field] = text;
+  }
+  return { ok: true, order: { cellId: rawCellId.trim(), ...cells, unknownFields } };
+}
+
+/** 검증된 지시서를 사람이 읽는 골 문면으로 펼친다 — 첫 줄 «대상 경로:»(경계), 둘째 줄 «현재 계약:». */
+export function renderWorkOrderGoal(order: WorkOrder): string {
+  return [
+    `대상 경로: ${order.boundary}`,
+    `현재 계약: ${order.contract}`,
+    '',
+    `[${order.lifeId} · 칸 ${order.cellId} · 판 ${order.version} · 착지 마감 ${order.landBy}]`,
+    `신분 태그: ${order.identityTags}`,
+    `우선순위: ${order.priority}`,
+    `판정 신호: ${order.verdictSignal}`,
+    `예산: ${order.budget}`,
+    `선행·짝 칸: ${order.peers}`,
+    `선례: ${order.precedents}`,
+    `올림 규칙: ${order.escalation}`,
+  ].join('\n');
+}

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 { podHostDirsCheckScript, podInstallSlotsVolume, prepareHostDirsOnce, type HostDirsPrepResult, podHostDirsScript } 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,
@@ -39,11 +40,18 @@ export const POD_LITE_IMAGE = 'elanous-harness-lite:local';
 
 export const POD_LITE_MEMORY_LIMIT = '2Gi';
 
+/** W5 (10-15 #27801): where a memory-backed TMPDIR is mounted for release gate shards — the overlayfs `/tmp` made SQLite
+ *  tests take 0.4~5s per turn (once 124s). tmpfs pages count against the container memory limit, so the caller's cap
+ *  (`tmpfsSizeLimit`) stays small next to the 16Gi shard limit (request 6Gi). */
+export const POD_TMPFS_MOUNT_PATH = '/tmp-mem';
+
 /** 요청은 한도를 넘을 수 없다(쿠버네티스가 Job 을 거부한다) — lite 2Gi 처럼 한도가 기본 요청보다 작으면 한도로 맞춘다. */
 /** The command Job container's CPU limit when the caller names none (GATE-SPEED A3①: unchanged default). */
 export const POD_COMMAND_CPU_LIMIT_DEFAULT = '4';
 /** 게이트 조각·pod-command 의 CPU 요청 기본 — 하니스 Pod(POD_CHILD_REQUESTS.cpu)와 따로 둔다(조각은 bun test 로 CPU 를 실제로 쓴다). */
 export const POD_COMMAND_CPU_REQUEST_DEFAULT = '1';
+/** Gate and command Pods retain their measured 6Gi scheduler request; si-task admission uses its own size. */
+export const POD_COMMAND_MEMORY_REQUEST_DEFAULT = '6Gi';
 
 /** Container CPU request/limit override. Omitted fields keep the defaults (request `POD_COMMAND_CPU_REQUEST_DEFAULT` · limit 4). */
 export interface PodCpu { request?: string; limit?: string }
@@ -92,9 +100,9 @@ export function parsePodCpu(value: unknown, label = 'cpu'): PodCpu | undefined {
 
 export function memoryRequestWithin(limit: string | undefined): string {
   const gi = (value: string | undefined) => { const m = /^(\d+)Gi$/.exec(value ?? ''); return m ? Number(m[1]) : null; };
-  const request = gi(POD_CHILD_REQUESTS.memory);
+  const request = gi(POD_COMMAND_MEMORY_REQUEST_DEFAULT);
   const max = gi(limit);
-  return request !== null && max !== null && request > max ? limit! : POD_CHILD_REQUESTS.memory;
+  return request !== null && max !== null && request > max ? limit! : POD_COMMAND_MEMORY_REQUEST_DEFAULT;
 }
 
 /** POD7 must-fix: the skill list alone can't tell a network-only job from one that needs ffmpeg/browser — so lite is
@@ -132,13 +140,24 @@ export function tailBytes(text: string, maxBytes: number): string {
   return `…[앞 ${bytes.length - maxBytes}바이트 생략]\n${cut.subarray(start).toString('utf8')}`;
 }
 
-const GATE = `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; }
-  sleep 0.5
-done
-echo "[gate] ISOLATION NOT ENFORCED within 30s"; exit 1`;
+/**
+ * The isolation probe: wait until the NetworkPolicy blocks the host/prod daemons, then go on with the child shell.
+ * GATE-WARM-BOOT-NO-INIT (10-15) — this used to be the `isolation-gate` init container; it is now the child shell's first
+ * lines, before any credential is read. Same probes, same log lines, same exit 1 when isolation is not enforced in 30 s.
+ * Measured on node-b k3d (#27805): init 2 → 354 s · init 1 → 41 s · none → 1 s from Pod creation to the child start.
+ */
+export function isolationGateLines(): string {
+  return `elanous_isolation_gate() {
+  local ok=0 i
+  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"; return 0; }
+    sleep 0.5
+  done
+  echo "[gate] ISOLATION NOT ENFORCED within 30s"; exit 1
+}
+elanous_isolation_gate || exit 1`;
+}
 
 /** 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
@@ -176,7 +195,7 @@ if [ -d "$HOME/outbox" ]; then
     else
       printf 'ELANOUS_POD_ARTIFACT_SKIPPED %s %s\\n' "$relative" "$size"
     fi
-  done < <(find "$HOME/outbox" -type f -print0)
+  done < <(find "$HOME/outbox" -type f -print0 | while IFS= read -r -d '' f; do printf '%s\\t%s\\0' "$(( $(wc -c < "$f") ))" "$f"; done | LC_ALL=C sort -z -t $'\\t' -k1,1n -k2 | while IFS= read -r -d '' row; do printf '%s\\0' "\${row#*$'\\t'}"; done)
 fi`;
 
 export interface PodCommandJobInput {
@@ -202,9 +221,13 @@ export interface PodCommandJobInput {
   memoryLimit?: string;
   /** GATE-SPEED A3①: CPU request/limit override (release gate shards only). Omitted = request 1 / limit 4. */
   cpu?: PodCpu;
+  /** W5 — emptyDir{medium: Memory} sizeLimit mounted at {@link POD_TMPFS_MOUNT_PATH} ⊕ `TMPDIR` (release gate shards only). Omitted = image `/tmp`. */
+  tmpfsSizeLimit?: string;
   source?: PodSource;
   deadlineSeconds: number;
   runId?: string;
+  /** GATE-WARM-BOOT-NO-INIT fallback: the node-side hand-over did not run, so a root init container hands the hostPath dirs to uid 1000. */
+  hostDirsInit?: boolean;
 }
 
 function bashSingleQuote(value: string): string {
@@ -220,8 +243,11 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
   const grok = o.llm === 'grok';
   const bunCache = o.bunCache ? podBunCacheVolume(o.bunCache) : undefined;
   const installSlots = o.installSlots ? podInstallSlotsVolume(o.installSlots) : undefined;
-  // hostPath directories the uid-1000 child writes: a root init container hands them over (DirectoryOrCreate is root 0755).
+  // hostPath directories the uid-1000 child writes. DirectoryOrCreate makes them root 0755, so runPodCommand hands them to
+  // uid 1000 once per node (prepareHostDirsOnce); the child only reports a directory it still cannot write.
   const hostDirMounts = [...(bunCache ? [bunCache.volumeMount] : []), ...(installSlots ? [installSlots.volumeMount] : [])];
+  const tmpfs = o.tmpfsSizeLimit?.trim() || undefined;
+  const tmpfsMounts = tmpfs ? [{ name: 'tmp-mem', mountPath: POD_TMPFS_MOUNT_PATH }] : [];
   const cpu = resolvePodCpu(o.cpu);
   const quotedArgs = o.command.map(bashSingleQuote).join(' ');
   const credLines = [
@@ -231,12 +257,14 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
       : []),
   ];
   const script = [
+    isolationGateLines(),
     'set -u',
     ...credLines,
     'curl -s -m 3 -o /dev/null http://host.orb.internal:31415/health && { echo "[pod] ISOLATION FAIL"; exit 3; }',
     ...(o.clone
       ? ['export GH_TOKEN="$(cat /creds/gh-token)" && gh auth setup-git', podSourceScript(o.source ?? { kind: 'default' }, o.repoUrl)]
       : ['mkdir -p ~/work && cd ~/work']),
+    ...(hostDirMounts.length ? [podHostDirsCheckScript(hostDirMounts)] : []),
     ...(bunCache ? [bunCache.shellPrefix] : []),
     `set -- ${quotedArgs}`,
     '"$@"',
@@ -244,6 +272,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;
@@ -260,10 +292,10 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
         spec: {
           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)] : []),
-          ],
+          // Normal path: no init container. Fallback only when the node-side hand-over did not run (no member · prep failed).
+          ...(o.hostDirsInit && hostDirMounts.length ? { initContainers: [
+            { name: 'host-dirs', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never', securityContext: { runAsUser: 0 }, command: ['bash', '-c'], args: [podHostDirsScript(hostDirMounts)], volumeMounts: hostDirMounts.map((mount) => ({ ...mount })) },
+          ] } : {}),
           containers: [{
             name: 'child', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never',
             resources: { requests: { ...POD_CHILD_REQUESTS, cpu: cpu.request, memory: memoryRequestWithin(o.memoryLimit) }, limits: { memory: o.memoryLimit ?? '16Gi', cpu: cpu.limit } },
@@ -272,18 +304,21 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
               ...(o.runId ? [{ name: 'ELANOUS_RUN_ID', value: o.runId }] : []),
               { name: 'ELANOUS_SUBSTRATE', value: 'pod' },
               { name: 'ELANOUS_POD_NAME', valueFrom: { fieldRef: { fieldPath: 'metadata.name' } } },
+              ...(tmpfs ? [{ name: 'TMPDIR', value: POD_TMPFS_MOUNT_PATH }] : []),
             ],
-            ...(secretKeys || o.hostMirror || hostDirMounts.length ? { volumeMounts: [
+            ...(secretKeys || o.hostMirror || hostDirMounts.length || tmpfs ? { volumeMounts: [
               ...(secretKeys ? [{ name: 'creds', mountPath: '/creds', readOnly: true }] : []),
               ...(o.hostMirror ? [{ name: 'host-mirror', mountPath: '/host-mirror', readOnly: true }] : []),
               ...hostDirMounts,
+              ...tmpfsMounts,
             ] } : {}),
           }],
-          ...(secretKeys || o.hostMirror || hostDirMounts.length ? { volumes: [
+          ...(secretKeys || o.hostMirror || hostDirMounts.length || tmpfs ? { volumes: [
             ...(secretKeys ? [{ name: 'creds', secret: { secretName: `${o.name}-creds`, defaultMode: 0o400 } }] : []),
             ...(o.hostMirror ? [{ name: 'host-mirror', hostPath: { path: o.hostMirror, type: 'Directory' } }] : []),
             ...(bunCache ? [bunCache.volume] : []),
             ...(installSlots ? [installSlots.volume] : []),
+            ...(tmpfs ? [{ name: 'tmp-mem', emptyDir: { medium: 'Memory', sizeLimit: tmpfs } }] : []),
           ] } : {}),
         },
       },
@@ -360,6 +395,8 @@ export interface RunPodCommandOptions {
   memoryLimit?: string;
   /** GATE-SPEED A3①: CPU request/limit override — only the release gate passes it. Omitted = request 1 / limit 4. */
   cpu?: PodCpu;
+  /** W5 — memory-backed TMPDIR sizeLimit mounted at {@link POD_TMPFS_MOUNT_PATH}; only the release gate passes it. Omitted = image `/tmp`. */
+  tmpfsSizeLimit?: string;
   /** POD7: 호출부가 «네트워크 스킬만 쓰는 명령»이라고 말할 때만 lite 이미지 ⊕ 2Gi. */
   lite?: boolean;
   source?: PodSource;
@@ -380,6 +417,12 @@ 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;
+  /** GATE-WARM-BOOT-NO-INIT — hands the hostPath dirs to uid 1000 on the member's nodes (test seam · default {@link prepareHostDirsOnce}). */
+  prepareHostDirs?: (o: { member: PodPoolMember; hostPaths: readonly string[] }) => Promise<HostDirsPrepResult | undefined>;
   checkPool?: typeof checkPodPool;
   syncImages?: typeof syncPoolImages;
   imageCommit?: string | null;
@@ -396,6 +439,21 @@ 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). */
+/** Full-log re-reads after an early marker return before the artifacts count as lost (GATE-POD-RESULT-MARKER follow-up). */
+export const POD_MARKER_LOG_RETRIES = 2;
+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 +580,34 @@ 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 } : {}) });
+    }
+    // GATE-WARM-BOOT-NO-INIT (10-15): the hostPath dirs the uid-1000 child writes are handed over on the node itself, once per
+    // member·paths in this process (no init container). Best effort: a failure only logs; the child then falls back.
+    const hostDirPaths = [...(bunCache ? [bunCache] : []), ...(installSlots ? [installSlots] : [])];
+    const prepareHostDirs = options.prepareHostDirs ?? (options.kubectl ? undefined : prepareHostDirsOnce);
+    let hostDirsPrepared = false;
+    if (hostDirPaths.length) {
+      // Observed whether or not a hand-over runs: no member (nothing to reach) and an injected kubectl without a seam are skips.
+      if (!member) log('pod.command-job', 'host-dirs-prep', { ok: false, reason: 'no-pool-member', paths: hostDirPaths });
+      else if (!prepareHostDirs) log('pod.command-job', 'host-dirs-prep', { ok: false, reason: 'prep-disabled', paths: hostDirPaths });
+      else {
+        const prep = await prepareHostDirs({ member, hostPaths: hostDirPaths })
+          .catch((error: unknown) => ({ host: member!.sshHost ?? 'local', ok: false, ms: 0, detail: String(error).slice(0, 300) }));
+        hostDirsPrepared = prep?.ok === true;
+        log('pod.command-job', 'host-dirs-prep', { host: prep?.host ?? member.sshHost ?? 'local', ok: prep?.ok ?? false, ms: prep?.ms ?? 0, paths: hostDirPaths, ...(prep?.detail ? { detail: prep.detail } : {}) });
+      }
+    }
+    // Any path where the node-side hand-over did not succeed keeps the old in-Pod hand-over (review mf: uid 1000 could not write).
+    const hostDirsInit = hostDirPaths.length > 0 && !hostDirsPrepared;
     const ghToken = options.clone ? (options.ghToken ?? defaultGhToken)() : undefined;
     const secret = commandJobSecret({ name, namespace, launch, skills, skillEnvText, ...(grokAuth !== undefined ? { grokAuth } : {}), ...(ghToken !== undefined ? { ghToken } : {}) });
     if (secret) {
@@ -532,8 +618,9 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       name, namespace, launch, image: imageRef ?? image,
       ...(imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}),
       repoUrl, command, skills, ...(options.returnLogs ? { returnLogs: true } : {}), ...(llm ? { llm } : {}), ...(options.clone ? { clone: true } : {}),
-      ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), ...(bunCache ? { bunCache } : {}), ...(installSlots ? { installSlots } : {}), ...(memoryLimit ? { memoryLimit } : {}), ...(options.cpu ? { cpu: options.cpu } : {}), deadlineSeconds,
+      ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), ...(bunCache ? { bunCache } : {}), ...(installSlots ? { installSlots } : {}), ...(memoryLimit ? { memoryLimit } : {}), ...(options.cpu ? { cpu: options.cpu } : {}), ...(options.tmpfsSizeLimit ? { tmpfsSizeLimit: options.tmpfsSizeLimit } : {}), deadlineSeconds,
       ...(options.runId ? { runId: options.runId } : {}),
+      ...(hostDirsInit ? { hostDirsInit: true } : {}),
     });
     kubectl(['-n', namespace, 'delete', 'job', '-l', own, '--ignore-not-found']);
     const applied = kubectl(['apply', '-f', '-'], JSON.stringify(manifest));
@@ -543,10 +630,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) {
@@ -556,9 +657,23 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       } else unreadableSince = null;
       await sleep(options.pollMs ?? 15_000);
     }
-    const logsResult = kubectl(['-n', namespace, 'logs', `job/${name}`, '-c', 'child']);
+    let logsResult = kubectl(['-n', namespace, 'logs', `job/${name}`, '-c', 'child']);
+    // Marker path returns before the Job condition — a full-log read can hit the same transient window the tail read
+    // already survived (container log rotation · API hiccup). Retry it a little before calling the artifacts lost.
+    // A read that «succeeds» but stops before this launch's marker (empty · cut off) is incomplete too (review mf · #27842).
+    const fullLogIncomplete = (r: { status: number | null; stdout: string }) =>
+      r.status !== 0 || splitPodResultMarker(r.stdout.startsWith('\n') ? r.stdout : `\n${r.stdout}`, launch).rc === null;
+    for (let attempt = 1; markerRc !== null && fullLogIncomplete(logsResult) && attempt <= POD_MARKER_LOG_RETRIES; attempt++) {
+      log('pod.command-job', 'result-marker-log-retry', { job: name, attempt, ...(logsResult.status !== 0 ? { error: (logsResult.stderr ?? '').trim().slice(0, 200) } : { reason: 'marker-missing-in-full-log' }) });
+      await sleep(options.pollMs === undefined ? 1_000 : Math.min(options.pollMs, 1_000));   // ≤2 re-reads within ≈2s total
+      logsResult = kubectl(['-n', namespace, 'logs', `job/${name}`, '-c', 'child']);
+    }
+    // Still without this launch's marker after the retries: the artifacts are not trusted as complete (explicit failure).
+    if (markerRc !== null && logsResult.status === 0 && fullLogIncomplete(logsResult)) {
+      logsResult = { ...logsResult, status: 1, stderr: 'full log ended before this launch\'s result marker (incomplete after retries)' };
+    }
     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 +706,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,