elanous 0.2.29 → 0.2.31

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

@@ -11,13 +11,23 @@ import { hostLeaseBaseDir, type PendingJobIdentity } from '../../pod-lease/host-
 // POD-CPU-REQUEST-RIGHTSIZE(10-09 · OP 실측): 하니스 Pod 실사용은 대부분 100m 미만(LLM 응답 대기)인데 요청 1 CPU 를
 //   잡아 node-b 32코어가 «요청 31/32»로 막혔다(실사용 4.6코어 · 14%). 요청은 실사용 근처로, 한도(4)는 그대로 — 몰릴 때는 한도까지 쓴다.
 //   게이트·pod-command 기본은 pod-command-job.ts 의 POD_COMMAND_CPU_REQUEST_DEFAULT(1)로 따로 둔다(테스트 조각은 CPU 를 실제로 쓴다).
-export const POD_CHILD_REQUESTS = { cpu: '250m', memory: '6Gi' } as const;
+// SI-TASK-ADMIT-RIGHTSIZE: one host env restores the previous 6Gi request and uncapped p95 admission.
+// An invalid override fails conservative at 6Gi rather than silently under-reserving a Pod.
+export function resolveSiTaskMemoryPolicy(override: string | undefined): { requestMemory: string; admissionCapBytes: number | null; source: string } {
+  if (override === undefined) return { requestMemory: '3Gi', admissionCapBytes: 3 * 1024 ** 3, source: 'default' };
+  if (override === '6Gi') return { requestMemory: '6Gi', admissionCapBytes: null, source: 'override' };
+  return { requestMemory: '6Gi', admissionCapBytes: null, source: 'invalid-override-fallback' };
+}
+const siMemoryPolicy = resolveSiTaskMemoryPolicy(process.env.ELANOUS_POD_SI_REQUEST_MEMORY);
+export const POD_CHILD_REQUESTS = { cpu: '250m', memory: siMemoryPolicy.requestMemory } as const;
 /** Finished harness and command Jobs release their Pod slots after 30 minutes. */
 export const POD_JOB_TTL_AFTER_FINISHED_SECONDS = 1800;
 /** 게이트가 돌 때 하니스 «한 자리»로 셈하는 CPU — 요청(250m)보다 보수적으로 1 코어를 잡아 게이트 조각의 CPU 를 지킨다(GATE-RESERVE-AUTO 셈은 그대로). */
 export const HARNESS_SLOT_CPU_BESIDE_GATE = '1';
 /** POD-ADMIT-BY-USAGE — observed usage is scaled by this before it reserves memory. */
 const POD_USAGE_HEADROOM = 1.5;
+/** New standard si-task admission only. Existing Running Pods keep their observed/requested reservation. */
+export const POD_SI_ADMISSION_CAP_BYTES = siMemoryPolicy.admissionCapBytes;
 /** POD-ADMIT-BY-USAGE — a node keeps at least this share of allocatable memory free (real usage and bookkeeping). */
 const POD_NODE_FREE_FLOOR_RATIO = 0.1;
 
@@ -477,6 +487,7 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
         const leasedJobs = new Set<string>();
         const gateJobs = new Map<string, number>();
         const boundGateJobs = new Set<string>();
+        const commandJobs = new Set<string>();
         let jobsValid = true;
         for (const job of jobItems) {
           const meta = object(job.metadata);
@@ -484,6 +495,7 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
           if (object(meta.labels)?.['elanous.substrate'] !== 'pod') continue;
           if (typeof meta.name !== 'string' || !meta.name) { jobsValid = false; continue; }
           jobNames.add(meta.name);
+          if (object(meta.labels)?.['elanous.kind'] === 'command') commandJobs.add(meta.name);
           // GATE-RESERVE-AUTO: a release-gate shard Job (`gate-<uuid>`, kind=command) reserves its Pod template's CPU
           // from creation until it is terminal — also while its Pod is still Pending or not created yet.
           if (meta.name.startsWith('gate-') && object(meta.labels)?.['elanous.kind'] === 'command') {
@@ -521,7 +533,8 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
           } else reservationsValid = false;
           const ownerJob = String(labels?.['elanous.job'] ?? labels?.['job-name'] ?? '');
           const gatePod = metadata?.namespace === 'elanous-test' && gateJobs.has(ownerJob);
-          const harness = metadata?.namespace === 'elanous-test' && labels?.['elanous.probe'] !== 'dns' && !gatePod &&
+          const commandPod = labels?.['elanous.kind'] === 'command' || commandJobs.has(ownerJob);
+          const harness = metadata?.namespace === 'elanous-test' && labels?.['elanous.probe'] !== 'dns' && !gatePod && !commandPod &&
             (labels?.['elanous.substrate'] === 'pod' || jobNames.has(String(labels?.['elanous.job'] ?? '')));
           const spec = object(pod.spec);
           let limit: number | null = null;
@@ -642,7 +655,7 @@ export function recommendConcurrency(measure: PoolLeaseMeasure, options: { capac
   if (goalBytes === null || goalBytes <= 0) return { ...empty, reason: '측정 불가: perGoalMemory' };
   const admission = admissionByUsage(measure, goalBytes, options.perGoalMemory !== undefined);
   if (!measure.members.length || measure.members.some((m) => m.running === null || m.pending === null || m.unleasedRunning === null || m.allocatableMemoryBytes === null || m.memoryLimitBytes === null || m.allocatableCpuMillicores === null || m.availableMemoryByNodeBytes === null)) {
-    debug.log('pod-lease', 'admit-by-usage', { samples: admission.samples, p95Bytes: admission.p95Bytes, admitBytes: admission.admitBytes, fallback: admission.fallback, recommended: null, limitedBy: null, capacity: options.capacity, capacitySlots: null, memorySlots: null, running: null, pending: null });
+    debug.log('pod-lease', 'admit-by-usage', { samples: admission.samples, p95Bytes: admission.p95Bytes, admitBytes: admission.admitBytes, fallback: admission.fallback, requestMemory: siMemoryPolicy.requestMemory, admissionCapBytes: POD_SI_ADMISSION_CAP_BYTES, policySource: siMemoryPolicy.source, recommended: null, limitedBy: null, capacity: options.capacity, capacitySlots: null, memorySlots: null, running: null, pending: null });
     return { ...empty, reason: `측정 불가: cluster${measure.members.map((m) => m.reason ? ` ${m.context}: ${m.reason}` : '').join('')}` };
   }
   if (!Number.isSafeInteger(options.capacity) || options.capacity < 0) return { ...empty, reason: '측정 불가: capacity' };
@@ -694,7 +707,7 @@ export function recommendConcurrency(measure: PoolLeaseMeasure, options: { capac
     && m.reason !== 'dns' && m.running !== null && m.pending !== null && m.running + m.pending >= m.capacity);
   const limitedBy: PoolLeaseRecommendation['limitedBy'] = memoryBound < capacitySlots ? 'memory' : defaultCapFull ? 'pool-cap' : 'capacity';
   if (unleasedRunning > 0) debug.log('pod-lease', 'unleased', { unleasedRunning, running, recommended });
-  debug.log('pod-lease', 'admit-by-usage', { samples: admission.samples, p95Bytes: admission.p95Bytes, admitBytes: admission.admitBytes, fallback: admission.fallback, recommended, limitedBy, capacity: options.capacity, capacitySlots, memorySlots, running, pending });
+  debug.log('pod-lease', 'admit-by-usage', { samples: admission.samples, p95Bytes: admission.p95Bytes, admitBytes: admission.admitBytes, fallback: admission.fallback, requestMemory: siMemoryPolicy.requestMemory, admissionCapBytes: POD_SI_ADMISSION_CAP_BYTES, policySource: siMemoryPolicy.source, recommended, limitedBy, capacity: options.capacity, capacitySlots, memorySlots, running, pending });
   return { recommended, limitedBy, reason: measure.members.some((m) => m.reason === 'dns') ? 'dns' : null, capacitySlots, memorySlots, liteMemorySlots, placeableSlots, accountSlots, running, pending, pendingJobs, unleasedRunning, admission };
 }
 
@@ -714,7 +727,8 @@ function admissionByUsage(measure: PoolLeaseMeasure, goalBytes: number, explicit
       : live.some((m) => m.harnessUsageBytes == null) ? (live.map((m) => m.harnessUsageBytes == null ? `${m.context}: ${m.usageReason ?? 'usage not measured'}` : '').filter(Boolean).join('; '))
         : p95Bytes === null ? 'no Running harness Pod usage samples'
           : null;
-  const admitBytes = fallback !== null || p95Bytes === null ? goalBytes
-    : Math.min(goalBytes, Math.max(requestBytes, Math.ceil(p95Bytes * POD_USAGE_HEADROOM)));
+  const observedBytes = p95Bytes === null ? null : Math.ceil(p95Bytes * POD_USAGE_HEADROOM);
+  const admitBytes = fallback !== null || observedBytes === null ? goalBytes
+    : Math.min(goalBytes, Math.max(requestBytes, POD_SI_ADMISSION_CAP_BYTES === null ? observedBytes : Math.min(observedBytes, POD_SI_ADMISSION_CAP_BYTES)));
   return { samples: samples.length, p95Bytes, admitBytes, fallback };
 }

package/src/task-orchestrator/surfaces/pod-lifecycle-stages.ts

@@ -0,0 +1,169 @@
+/**
+ * POD-LIFECYCLE-STAGES (P0 · Pod 재사용 기준선) — Pod 하나가 끝날 때 «어느 단계에 시간이 갔나»를 한 줄로 낸다.
+ *
+ * 계약: category `pod.lifecycle` · event `stages` ·
+ *   data `{ runId, podJob, host, kind, stages: [{ stage, start, end, clock }], outcome, missing }`.
+ *   - 시각은 epoch ms 하나로 통일한다(Pod 시계의 초 값은 ×1000).
+ *   - `clock` 은 그 값이 어느 시계에서 왔나 — `host`(이 프로세스) · `k8s`(API 서버 시각) · `pod`(Pod 안 `date +%s`) · `mixed`.
+ *   - ⛔ «0초»와 «못 잼»을 섞지 않는다: 시작·끝 둘 다 잰 단계만 `stages` 에 들어가고, 나머지는 이름만 `missing` 에 간다.
+ *     끝이 시작보다 앞서면(시계가 어긋났다) 그 단계도 지어내지 않고 `missing` 이다.
+ *
+ * 관측만 한다 — 판정·rc·파일을 바꾸지 않고, 내보내기가 실패해도 삼킨다.
+ */
+import { debug } from '../../debug/log.js';
+
+export const POD_LIFECYCLE_STAGES = ['create', 'schedule', 'clone', 'mirror', 'deps', 'test', 'delete'] as const;
+/** si-task Pod 은 시험이 아니라 `self implement`(또는 harness ask/say) 본체를 돈다 — 그 칸은 `test` 가 아니라 `run` 이다. */
+export const SI_TASK_POD_LIFECYCLE_STAGES = ['create', 'schedule', 'clone', 'mirror', 'deps', 'run', 'delete'] as const;
+export type PodLifecycleStageName = typeof POD_LIFECYCLE_STAGES[number] | typeof SI_TASK_POD_LIFECYCLE_STAGES[number];
+export type PodLifecycleClock = 'host' | 'k8s' | 'pod' | 'mixed';
+export type PodLifecycleKind = 'gate' | 'si-task';
+
+export interface PodLifecycleStage { stage: PodLifecycleStageName; start: number; end: number; clock: PodLifecycleClock }
+
+export interface PodLifecycleEvent {
+  runId: string | null;
+  podJob: string | null;
+  host: string | null;
+  kind: PodLifecycleKind;
+  stages: PodLifecycleStage[];
+  outcome: string;
+  missing: PodLifecycleStageName[];
+  [extra: string]: unknown;
+}
+
+type Measured = Partial<Record<PodLifecycleStageName, { start?: number; end?: number; clock: PodLifecycleClock }>>;
+
+/** ISO 문자열 → epoch ms (못 읽으면 undefined — 지어내지 않는다). */
+export function isoMs(value: string | undefined): number | undefined {
+  if (typeof value !== 'string') return undefined;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : undefined;
+}
+
+/** Pod 시계의 epoch 초 → ms. */
+function podSecondsMs(value: number | undefined): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value * 1000 : undefined;
+}
+
+/** 잰 것만 stages 로, 나머지는 missing 으로 — 계약의 단계 순서대로. */
+export function splitPodLifecycleStages(measured: Measured, order: readonly PodLifecycleStageName[] = POD_LIFECYCLE_STAGES): { stages: PodLifecycleStage[]; missing: PodLifecycleStageName[] } {
+  const stages: PodLifecycleStage[] = [];
+  const missing: PodLifecycleStageName[] = [];
+  for (const name of order) {
+    const item = measured[name];
+    if (item && item.start !== undefined && item.end !== undefined && item.end >= item.start) stages.push({ stage: name, start: item.start, end: item.end, clock: item.clock });
+    else missing.push(name);
+  }
+  return { stages, missing };
+}
+
+/**
+ * gate shard Pod — `pod-N.json` 에 쓰는 바로 그 값(phaseTimes · podStages · podLifecycle)에서 단계를 고른다.
+ * - create   = 풀 자리 배정(없으면 입장 끝 · host) → Pod 생성(k8s)
+ * - schedule = Pod 생성 → PodScheduled (k8s)
+ * - clone    = 자식 컨테이너 PID 1(prep-start) → 셸 첫 줄(clone-end) (pod)
+ * - deps     = deps-start → deps-end (pod) · test = test-start → test-end (pod)
+ * - mirror · delete = gate 는 Pod 별로 재지 않는다 → 늘 missing.
+ */
+export function gatePodLifecycleStages(input: {
+  phaseTimes?: Readonly<Record<string, string>>;
+  podStages?: Readonly<Record<string, number>>;
+  podLifecycle?: Readonly<Record<string, string>>;
+}): { stages: PodLifecycleStage[]; missing: PodLifecycleStageName[] } {
+  const phase = input.phaseTimes ?? {};
+  const pod = input.podStages ?? {};
+  const k8s = input.podLifecycle ?? {};
+  return splitPodLifecycleStages({
+    create: { start: isoMs(phase.poolPlaced) ?? isoMs(phase.admissionEnd), end: isoMs(k8s.podCreated), clock: 'mixed' },
+    schedule: { start: isoMs(k8s.podCreated), end: isoMs(k8s.podScheduled), clock: 'k8s' },
+    clone: { start: podSecondsMs(pod['prep-start']), end: podSecondsMs(pod['clone-end']), clock: 'pod' },
+    deps: { start: podSecondsMs(pod['deps-start']), end: podSecondsMs(pod['deps-end']), clock: 'pod' },
+    test: { start: podSecondsMs(pod['test-start']), end: podSecondsMs(pod['test-end']), clock: 'pod' },
+  });
+}
+
+/** gate shard 의 끝 — 판정 코드와 같은 순서(잡 실패 → 정지 → 시간 초과 → 판정 없음 → rc). */
+export function gatePodOutcome(o: { jobFailed: boolean; stalled: boolean; timedOut: boolean; rc: number | undefined }): string {
+  if (o.jobFailed) return 'job-failed';
+  if (o.stalled) return 'stall';
+  if (o.timedOut) return 'timeout';
+  if (o.rc === undefined) return 'no-verdict';
+  return o.rc === 0 ? 'pass' : 'fail';
+}
+
+export function gatePodLifecycleEvent(input: {
+  runId?: string | null;
+  podJob?: string | null;
+  host?: string | null;
+  shard: string;
+  attemptId?: string;
+  phaseTimes?: Readonly<Record<string, string>>;
+  podStages?: Readonly<Record<string, number>>;
+  podLifecycle?: Readonly<Record<string, string>>;
+  outcome: string;
+}): PodLifecycleEvent {
+  const { stages, missing } = gatePodLifecycleStages(input);
+  return { runId: input.runId ?? null, podJob: input.podJob ?? null, host: input.host ?? null, kind: 'gate', stages, outcome: input.outcome, missing,
+    shard: input.shard, ...(input.attemptId ? { attemptId: input.attemptId } : {}) };
+}
+
+/** si-task Pod 셸이 찍는 단계 표지 — `ELANOUS_POD_STAGE <stage> <start|end> <epoch초>` (Pod 시계 · `date +%s`). */
+/** Pod 셸이 실제로 표지를 찍는 단계만 — deps 는 si-task Job 에 설치 단계가 없어 읽지도 않는다(늘 missing). */
+const SI_TASK_MARKED_STAGES = ['clone', 'mirror', 'run'] as const;
+export type SiTaskMarkedStage = typeof SI_TASK_MARKED_STAGES[number];
+
+/** Pod 셸 한 줄 — 단계 경계에서 Pod 시계(초)를 찍는다. 실패해도 셸을 끊지 않는다(`|| true`). */
+export function siTaskPodStageShell(stage: SiTaskMarkedStage, edge: 'start' | 'end'): string {
+  return `printf 'ELANOUS_POD_STAGE ${stage} ${edge} %s\\n' "$(date +%s)" || true`;
+}
+const SI_TASK_STAGE_LINE = /^ELANOUS_POD_STAGE (clone|mirror|run) (start|end) (\d{1,12})\r?$/gm;
+
+/**
+ * Job 로그에서 단계 표지를 읽는다 → `{ 'clone-start': 초, 'clone-end': 초, … }` (gate 의 podStages 와 같은 꼴).
+ * 같은 표지가 두 번 나오면 «첫» 값 — 셸 표지는 모두 자식 출력(`cat /tmp/si.out`)보다 앞에 찍히므로, 자식이 같은 모양의 줄을
+ * 내도 셸 값을 덮지 못한다(리뷰 should-fix). 모르는 단계·꼴은 버린다(지어내지 않는다).
+ */
+export function parseSiTaskPodStages(logs: string | undefined): Record<string, number> {
+  const out: Record<string, number> = {};
+  if (!logs) return out;
+  for (const match of logs.matchAll(SI_TASK_STAGE_LINE)) {
+    const key = `${match[1]}-${match[2]}`;
+    if (!(key in out)) out[key] = Number(match[3]);
+  }
+  return out;
+}
+
+/**
+ * si-task Pod — Pod 셸이 찍은 단계 표지(`parseSiTaskPodStages`)로 clone · mirror · deps · run 을 채운다(pod 시계).
+ * - clone  = 소스 받기(`podSourceScript`) 시작 → 그 스크립트 전체가 끝난 뒤(`cd repo` 포함 · 어느 줄에서든 exit 하면 끝이 없다 → missing)
+ * - mirror = 호스트 미러 `clone --shared` 시도 → 성공(미러를 건너뛰면 끝이 없다 → missing)
+ * - deps   = si-task Job 셸엔 의존성 설치 단계가 없다 → 표지를 읽지 않는다(`deps` 표지 줄이 있어도 늘 missing)
+ * - run    = 본체(`self implement` · `harness ask`/`say`) 띄움 → `wait` 가 돌아옴(SIGTERM 이면 끝이 없다 → missing)
+ * - create · schedule · delete = 호스트가 잴 값이 없다 → missing.
+ * 호스트가 지켜본 구간은 단계가 아닌 `watch`(host 시계)로 따로 싣는다 — 단계로 지어내지 않는다.
+ */
+export function siTaskPodLifecycleEvent(input: {
+  runId?: string | null;
+  podJob: string;
+  host?: string | null;
+  watchStart?: number;
+  watchEnd?: number;
+  podStages?: Readonly<Record<string, number>>;
+  outcome: string;
+}): PodLifecycleEvent {
+  const pod = input.podStages ?? {};
+  const measured: Measured = {};
+  for (const name of SI_TASK_MARKED_STAGES) measured[name] = { start: podSecondsMs(pod[`${name}-start`]), end: podSecondsMs(pod[`${name}-end`]), clock: 'pod' };
+  const { stages, missing } = splitPodLifecycleStages(measured, SI_TASK_POD_LIFECYCLE_STAGES);
+  const watched = input.watchStart !== undefined && input.watchEnd !== undefined && Number.isFinite(input.watchStart) && Number.isFinite(input.watchEnd) && input.watchEnd >= input.watchStart;
+  return { runId: input.runId ?? null, podJob: input.podJob, host: input.host ?? null, kind: 'si-task', stages, outcome: input.outcome, missing,
+    ...(watched ? { watch: { start: input.watchStart, end: input.watchEnd, clock: 'host' as const } } : {}) };
+}
+
+export type PodLifecycleLog = (category: string, event: string, data: Record<string, unknown>) => void;
+
+/** 한 줄 낸다 — 관측은 fail-soft(판정 경로를 절대 깨지 않는다). */
+export function emitPodLifecycle(event: PodLifecycleEvent, log: PodLifecycleLog = (category, name, data) => debug.log(category, name, data)): void {
+  try { log('pod.lifecycle', 'stages', event); } catch { /* observation is fail-soft */ }
+}

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

@@ -72,5 +72,32 @@ export function seedMirrorOnce(o: { host: string; commit: string; cwd: string; p
   return pending;
 }
 
+/**
+ * SI-SEED-DEFAULT — a default-source si-task Job (main HEAD, or `--base <branch>`) has no pinned sha, so the host resolves
+ * the branch tip once (`git ls-remote`, bounded) and makes sure the seeding tree has that commit (a bounded fetch of that
+ * one sha when it does not — objects only, no ref is moved). Never throws: a miss returns `reason` and the caller skips
+ * the seed (best effort — the Job keeps its GitHub path).
+ */
+export async function resolveDefaultSourceHead(o: { repoUrl: string; base?: string; cwd: string; git?: Push; limitMs?: number }): Promise<{ sha?: string; reason?: string }> {
+  const git = o.git ?? gitWithin;
+  const limitMs = o.limitMs ?? 30_000;
+  const base = o.base || 'main';
+  if (base.startsWith('-') || !/^[\w./-]+$/.test(base) || o.repoUrl.startsWith('-')) return { reason: 'invalid-ref' };
+  try {
+    const listed = await git(['ls-remote', '--', o.repoUrl, `refs/heads/${base}`], o.cwd, limitMs);
+    if (listed.rc !== 0) return { reason: 'ls-remote-failed' };
+    // Only the exact ref asked for — never the first `refs/heads/*` line (a branch named `a/refs/heads/main` must not pass).
+    const want = `refs/heads/${base}`;
+    const sha = listed.output.split(/\r?\n/).map((line) => line.split('\t')).find(([hash, ref]) => ref === want && /^[0-9a-f]{40}$/.test(hash ?? ''))?.[0];
+    if (!sha) return { reason: 'ls-remote-no-sha' };
+    if ((await git(['cat-file', '-e', `${sha}^{commit}`], o.cwd, limitMs)).rc === 0) return { sha };
+    const fetched = await git(['fetch', '--quiet', '--no-write-fetch-head', '--', o.repoUrl, sha], o.cwd, GATE_MIRROR_SEED_LIMIT_MS);
+    if (fetched.rc !== 0) return { reason: 'commit-fetch-failed' };
+    return (await git(['cat-file', '-e', `${sha}^{commit}`], o.cwd, limitMs)).rc === 0 ? { sha } : { reason: 'commit-not-local' };
+  } catch {
+    return { reason: 'resolve-threw' };
+  }
+}
+
 /** Test seam — forget the per-process seed memo. */
 export function resetMirrorSeedMemo(): void { seeded.clear(); }

package/src/task-orchestrator/surfaces/pod-result-marker-wait.ts

@@ -0,0 +1,33 @@
+// TA-POD-WARMBOOT-PARITY (10-15) — the Pod result marker (GATE-POD-RESULT-MARKER · #27815) for Jobs that do not go
+// through runPodCommand (the si-task Job in self-implement-pod.ts).
+//
+// S: runPodCommand prints `\n<marker> <launch> rc=<n>\n` as the child's last line and ends its wait on it when the Job
+//    condition lags (k3d). The si-task Job builds its own manifest and waits only on the condition.
+// A: reuse the marker format and split from pod-command-job.ts (no second format), and keep the one-poll judgement
+//    («no condition yet → read the tail → this launch's marker? → rc») as a pure function here.
+// ⚠️ pod-command-job.ts imports self-implement-pod.ts statically, so self-implement-pod.ts loads this module with a
+//    dynamic import only (a static import back would hit the TDZ of the cycle).
+// Later (after T1): runPodCommand's own loop can call podResultMarkerRc too.
+import { podResultMarker, splitPodResultMarker } from './pod-command-job.js';
+
+
+/** The child's final shell line: prints this launch's marker with the child rc (same bytes runPodCommand's child prints).
+ *  null when the token is not a plain id (`[A-Za-z0-9_.:-]+`) — the Job then runs without a marker (condition path only). */
+export function podResultMarkerShellLine(token: string): string | null {
+  if (!/^[\w.:-]+$/.test(token)) return null;
+  return `printf '\\n%s rc=%s\\n' '${podResultMarker(token)}' "$rc"`;
+}
+
+/**
+ * One poll, condition not there yet: the `kubectl logs … --tail=2` result → this launch's rc, or null.
+ * A failed read (Pod pending · init container), another launch's marker, or a bare marker word is null (keep waiting).
+ */
+export function podResultMarkerRc(tail: { status: number | null; stdout: string }, token: string): number | null {
+  if (tail.status !== 0) return null;
+  return splitPodResultMarker(tail.stdout.startsWith('\n') ? tail.stdout : `\n${tail.stdout}`, token).rc;
+}
+
+/** Remove this launch's marker tail from the child logs before they are parsed (other bytes unchanged). */
+export function stripPodResultMarker(logs: string, token: string): string {
+  return splitPodResultMarker(logs, token).logs;
+}

package/src/task-orchestrator/surfaces/pod-reuse-cleanup.ts

@@ -0,0 +1,63 @@
+/** Files and caches that survive between requests on a reusable Pod worker. */
+export const POD_REUSE_CLEAN_EXCLUSIONS = [
+  { name: 'node_modules', pattern: 'node_modules' },
+  { name: 'apps/pwa/node_modules', pattern: 'apps/pwa/node_modules' },
+  // Bun's install cache and remote gate cache live outside the worker checkout.
+  { name: 'bun install cache', pattern: null },
+  { name: 'TypeScript build info', pattern: '*.tsbuildinfo' },
+  { name: 'remote gate TypeScript cache', pattern: null },
+] as const;
+
+export type PodReuseCleanupOutcome = 'reuse' | 'discard';
+
+export interface PodReuseCleanupDecisionInput {
+  base: string;
+  resetExitCode: number | null;
+  cleanExitCode: number | null;
+  statusExitCode: number | null;
+  statusPorcelain: string;
+  remainingPaths?: readonly string[];
+}
+
+export interface PodReuseCleanupDecision {
+  resetArgs: readonly string[];
+  cleanArgs: readonly string[];
+  statusArgs: readonly string[];
+  preserved: readonly string[];
+  outcome: PodReuseCleanupOutcome;
+  reason?: 'invalid-base' | 'reset-failed' | 'clean-failed' | 'status-failed' | 'worktree-not-clean';
+  remainingPaths: readonly string[];
+}
+
+/**
+ * Pure request-boundary decision: return argv for the caller to execute and
+ * decide whether the worker can be reused from the command results.
+ * Execution/wiring and lifecycle event emission intentionally live in a later slice.
+ */
+export function decidePodReuseCleanup(input: PodReuseCleanupDecisionInput): PodReuseCleanupDecision {
+  const remainingPaths = (input.remainingPaths ?? []).slice(0, 5);
+  const resetArgs = ['reset', '--hard', input.base] as const;
+  const cleanArgs = [
+    'clean', '-ffdx',
+    ...POD_REUSE_CLEAN_EXCLUSIONS.flatMap(({ pattern }) => pattern ? ['-e', pattern] : []),
+  ] as const;
+  const statusArgs = ['status', '--porcelain'] as const;
+  const preserved = POD_REUSE_CLEAN_EXCLUSIONS.map(({ name }) => name);
+
+  let reason: PodReuseCleanupDecision['reason'];
+  if (!/^[0-9a-f]{40}$/i.test(input.base)) reason = 'invalid-base';
+  else if (input.resetExitCode !== 0) reason = 'reset-failed';
+  else if (input.cleanExitCode !== 0) reason = 'clean-failed';
+  else if (input.statusExitCode !== 0) reason = 'status-failed';
+  else if (input.statusPorcelain.trim() !== '') reason = 'worktree-not-clean';
+
+  return {
+    resetArgs,
+    cleanArgs,
+    statusArgs,
+    preserved,
+    outcome: reason ? 'discard' : 'reuse',
+    ...(reason ? { reason } : {}),
+    remainingPaths,
+  };
+}

package/src/task-orchestrator/surfaces/pod-source-receive.ts

@@ -2,6 +2,7 @@
  *  sha·PR·커밋은 형식 검사 전에 스크립트에 넣지 않는다(셸 주입 차단). */
 
 import { execFileSync } from 'node:child_process';
+import { siTaskPodStageShell } from './pod-lifecycle-stages.js';
 
 export type PodSource =
   | { kind: 'default'; base?: string }
@@ -52,17 +53,30 @@ function assertRemoteBase(repoUrl: string, base: string): void {
   }
 }
 
-/** Job 스크립트의 원천 단계. 성공 갈래는 `ELANOUS_POD_SOURCE <kind> <HEAD>` 로 끝난다. */
-export function podSourceScript(source: PodSource, repoUrl: string, mirrorPath = '/host-mirror'): string {
+/** Job 스크립트의 원천 단계. 성공 갈래는 `ELANOUS_POD_SOURCE <kind> <HEAD>` 로 끝난다.
+ *  `stageMarkers` — si-task Job 만: 호스트 미러 `clone --shared` 시도의 시작·성공을 `ELANOUS_POD_STAGE mirror start|end` 로 찍는다
+ *  (건너뛰거나 실패하면 끝 표지가 없다 → 호스트가 missing 으로 읽는다). 기본은 꺼짐 — gate·pod-command Job 의 바이트는 그대로다. */
+export function podSourceScript(source: PodSource, repoUrl: string, mirrorPath = '/host-mirror', options: { stageMarkers?: boolean } = {}): string {
+  const mark = (edge: 'start' | 'end'): string[] => options.stageMarkers ? [siTaskPodStageShell('mirror', edge)] : [];
   const quotedUrl = `'${repoUrl.replace(/'/g, `'\\''`)}'`;
   const quotedMirror = `'${mirrorPath.replace(/'/g, `'\\''`)}'`;
   const clone = `git clone -q --depth 50 ${quotedUrl} repo`;
   const start = [
     'if [ -e repo ]; then exit 5; fi',
-    `if [ -d ${quotedMirror} ] && git -C ${quotedMirror} rev-parse --verify HEAD >/dev/null 2>&1 && git clone -q --shared -- ${quotedMirror} repo && git -C repo rev-parse --verify HEAD >/dev/null 2>&1; then`,
+    // TA-POD-WARMBOOT-PARITY (10-16): the mirror fallback used to be silent — 157 HARD gate Pods all said
+    // `VIA github` and nothing said why (the Job had no /host-mirror mount). Each failed step now names itself.
+    'mirror_skip=',
+    ...mark('start'),
+    `if ! [ -d ${quotedMirror} ]; then mirror_skip=no-mount`,
+    `elif ! git -C ${quotedMirror} rev-parse --verify HEAD >/dev/null 2>&1; then mirror_skip=rev-parse-failed`,
+    `elif ! git clone -q --shared -- ${quotedMirror} repo || ! git -C repo rev-parse --verify HEAD >/dev/null 2>&1; then mirror_skip=clone-failed`,
+    'fi',
+    'if [ -z "$mirror_skip" ]; then',
+    ...mark('end').map((line) => `  ${line}`),
     `  git -C repo remote set-url origin ${quotedUrl} || exit 5`,
     '  source_via=mirror',
     'else',
+    "  printf 'ELANOUS_POD_SOURCE_MIRROR_SKIP %s\\n' \"$mirror_skip\"",
     '  if [ -e repo ]; then rm -r -- repo || exit 5; fi',
     `  ${clone} || exit 5`,
     '  source_via=github',
@@ -143,7 +157,9 @@ export function podSourceScript(source: PodSource, repoUrl: string, mirrorPath =
     '  exit 3',
     'fi',
     'if [ -e repo ]; then exit 5; fi',
+    ...mark('start'),
     `if [ -d ${quotedMirror} ] && git -C ${quotedMirror} rev-parse --verify HEAD >/dev/null 2>&1 && git clone -q --shared -- ${quotedMirror} repo && git -C repo rev-parse --verify HEAD >/dev/null 2>&1; then`,
+    ...mark('end').map((line) => `  ${line}`),
     `  git -C repo remote set-url origin ${quotedUrl} || exit 5`,
     '  if git -C repo bundle verify /tmp/source.bundle >/dev/null 2>&1; then',
     '    git -C repo fetch /tmp/source.bundle "refs/elanous/pod-source/*:refs/remotes/bundle/*" || exit 5',

package/src/task-orchestrator/surfaces/pod-warm-switch.ts

@@ -0,0 +1,141 @@
+/**
+ * warm Pod 재사용 ⑤ — 소비자별 «실전 사용 가능?» 손잡이 (PLAN-warm-reuse-tonight-2026-10-15 §5).
+ *
+ * 관측: 판정마다 `debug.log('pod.warm', 'switch-decision', …)` 한 줄(소비자·live·reason·표본 수).
+ * 판단: config flag(`pod.warmReuse.{gateRecheck,land,ta}` · 기본 false) ⊕ 증거
+ *       (lease 유효 · 카나리아 통과 · 같은 head/main/lock · 최근 mismatch 0 · 연속 일치 표본 ≥ minMatchSamples).
+ * 수복: live=false 면 소비자는 기존 fresh Job 경로를 그대로 탄다 — reason 이 «무엇이 모자랐나»를 넘긴다.
+ *
+ * ⛔ 이 모듈은 판정만 한다. 소비자 결선(pod-command-job · gate-node · self-implement-pod)은 각 소비자 PR 몫이다.
+ * ⛔ 못 잰 증거(undefined)는 «통과»가 아니라 «off» 다 — 모르면 켜지 않는다.
+ * 순서: gate-recheck → land → ta. 앞 소비자가 «자기 증거로» live 가 아니면 뒤 소비자도 live 가 아니다
+ *       (증거는 소비자별 — 뒤 소비자의 증거로 앞 소비자를 대신 판정하지 않는다 · 앞 증거가 없으면 off).
+ */
+import { debug } from '../../debug/log.js';
+
+export type WarmReuseConsumer = 'gate-recheck' | 'land' | 'ta';
+
+/** 켜는 순서 — 뒤 소비자는 바로 앞 소비자가 live 일 때만 live 가 될 수 있다. */
+export const WARM_REUSE_CONSUMER_ORDER: readonly WarmReuseConsumer[] = ['gate-recheck', 'land', 'ta'];
+
+/** 연속 일치 표본 기본 하한(보수적). */
+export const DEFAULT_WARM_MIN_MATCH_SAMPLES = 3;
+
+/** `pod.warmReuse` config 절 — 타입이 어긋난 값은 off/기본값으로 읽는다. */
+export interface WarmReuseSwitchConfig {
+  gateRecheck?: boolean;
+  land?: boolean;
+  ta?: boolean;
+  minMatchSamples?: number;
+}
+
+/** warm 워커 신원 — 기대값(fresh Job 쪽)과 워커 쪽을 같은 칸끼리 대조한다. */
+export interface WarmReuseIdentity {
+  head?: string;
+  main?: string;
+  lock?: string;
+}
+
+/** 판정 증거. 칸이 비면(undefined) «못 쟀다» = off. */
+export interface WarmReuseEvidence {
+  /** 같은 파일 fresh Job 대비 연속 일치(rc ⊕ JUnit 실패 ID) 표본 수. */
+  consecutiveMatchSamples?: number;
+  /** 최근 창의 warm↔fresh mismatch 수 — 0 이어야 live. */
+  recentMismatchCount?: number;
+  /** Nexus `pod-worker-lease` 가 현재 generation 으로 유효한가. */
+  leaseValid?: boolean;
+  /** 정비 뒤 카나리아 통과. */
+  canaryPassed?: boolean;
+  expected?: WarmReuseIdentity;
+  worker?: WarmReuseIdentity;
+}
+
+/** 소비자별 증거 — 판정 대상 ⊕ 그 앞 소비자들의 증거가 모두 있어야 live 가 될 수 있다. */
+export type WarmReuseEvidenceByConsumer = Partial<Record<WarmReuseConsumer, WarmReuseEvidence>>;
+
+export interface WarmReuseDecision {
+  consumer: WarmReuseConsumer;
+  live: boolean;
+  /** `live` 이거나 첫 번째로 걸린 이유(예 `flag-off` · `predecessor-off:land` · `samples-short`). */
+  reason: string;
+}
+
+const FLAG_KEY: Record<WarmReuseConsumer, keyof Pick<WarmReuseSwitchConfig, 'gateRecheck' | 'land' | 'ta'>> = {
+  'gate-recheck': 'gateRecheck',
+  land: 'land',
+  ta: 'ta',
+};
+
+const IDENTITY_FIELDS = ['head', 'main', 'lock'] as const;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+/** minMatchSamples — 양의 안전 정수만, 아니면 기본값. */
+export function resolveWarmMinMatchSamples(config: unknown): number {
+  const raw = isRecord(config) ? config.minMatchSamples : undefined;
+  return typeof raw === 'number' && Number.isSafeInteger(raw) && raw > 0 ? raw : DEFAULT_WARM_MIN_MATCH_SAMPLES;
+}
+
+/** flag — 문자 그대로 `true` 만 켠다. */
+export function warmReuseFlagOn(config: unknown, consumer: WarmReuseConsumer): boolean {
+  return isRecord(config) && config[FLAG_KEY[consumer]] === true;
+}
+
+function evidenceReason(evidence: WarmReuseEvidence | undefined, minSamples: number): string | null {
+  if (!evidence) return 'evidence-unmeasured';
+  if (evidence.leaseValid !== true) return evidence.leaseValid === false ? 'lease-invalid' : 'lease-unmeasured';
+  if (evidence.canaryPassed !== true) return evidence.canaryPassed === false ? 'canary-failed' : 'canary-unmeasured';
+  for (const field of IDENTITY_FIELDS) {
+    const want = evidence.expected?.[field];
+    const got = evidence.worker?.[field];
+    if (typeof want !== 'string' || !want || typeof got !== 'string' || !got) return `identity-unmeasured:${field}`;
+    // 원값 그대로 정확히 비교한다 — 앞뒤 공백 등 형식이 어긋난 값은 고쳐 읽지 않고 off.
+    if (want !== want.trim() || got !== got.trim()) return `identity-malformed:${field}`;
+    if (want !== got) return `identity-mismatch:${field}`;
+  }
+  const mismatches = evidence.recentMismatchCount;
+  if (typeof mismatches !== 'number' || !Number.isSafeInteger(mismatches) || mismatches < 0) return 'mismatch-unmeasured';
+  if (mismatches > 0) return 'recent-mismatch';
+  const samples = evidence.consecutiveMatchSamples;
+  if (typeof samples !== 'number' || !Number.isSafeInteger(samples) || samples < 0) return 'samples-unmeasured';
+  if (samples < minSamples) return 'samples-short';
+  return null;
+}
+
+function decide(consumer: WarmReuseConsumer, config: unknown, evidence: WarmReuseEvidenceByConsumer | undefined): string {
+  if (!warmReuseFlagOn(config, consumer)) return 'flag-off';
+  const index = WARM_REUSE_CONSUMER_ORDER.indexOf(consumer);
+  if (index > 0) {
+    const predecessor = WARM_REUSE_CONSUMER_ORDER[index - 1]!;
+    if (decide(predecessor, config, evidence) !== 'live') return `predecessor-off:${predecessor}`;
+  }
+  const own = isRecord(evidence) ? evidence[consumer] : undefined;
+  return evidenceReason(isRecord(own) ? own : undefined, resolveWarmMinMatchSamples(config)) ?? 'live';
+}
+
+/**
+ * 소비자 하나가 지금 warm 워커를 «실전»으로 써도 되나.
+ * `config` 는 `getUserConfig().pod?.warmReuse` 를 그대로 넘긴다(없으면 전부 off).
+ * `evidence` 는 소비자별 — 대상 소비자 ⊕ 그 앞 소비자들의 칸이 모두 있어야 한다(앞 칸이 비면 `predecessor-off:<앞>`).
+ */
+export function decideWarmReuse(
+  consumer: WarmReuseConsumer,
+  config: WarmReuseSwitchConfig | undefined,
+  evidence: WarmReuseEvidenceByConsumer | undefined,
+): WarmReuseDecision {
+  const reason = decide(consumer, config, evidence);
+  const live = reason === 'live';
+  const own = isRecord(evidence) && isRecord(evidence[consumer]) ? evidence[consumer] : undefined;
+  debug.log('pod.warm', 'switch-decision', {
+    consumer,
+    live,
+    reason,
+    flag: warmReuseFlagOn(config, consumer),
+    minMatchSamples: resolveWarmMinMatchSamples(config),
+    samples: own?.consecutiveMatchSamples ?? null,
+    recentMismatchCount: own?.recentMismatchCount ?? null,
+  });
+  return { consumer, live, reason };
+}