elanous 0.2.16 → 0.2.18

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

@@ -0,0 +1,235 @@
+/**
+ * TASK-AGENT 과제 넘기기 문 — `elanous task hand "<한 줄>"` (RFC-task-agent-any-task-to-completion §A9 표 1행 · R3).
+ *
+ * - 과제 카드를 실행부와 «같은» 상태 파일(`effectiveInstanceRoot()/task-agent-actions.json`)의 `tasks` 칸에 적는다.
+ *   종전 칸(landingDay·landingsToday·failureCounts)은 그대로 두고 덧붙이기만 한다(하위 호환 — 실행부 쓰기는 `...disk` 로 보존).
+ * - 첫 수는 «launch» = `harness say [--seat <자리>] --substrate pod --merge-by-host "<원문>"`.
+ * - 기본은 SHADOW: 카드와 명령만 남기고 아무것도 띄우지 않는다. `--live` 일 때만 주입된 launcher 로 띄운다.
+ * - 관측: `debug.log('task-agent', 'handed', {taskId, seat, checklistId, mode})`.
+ */
+import { randomBytes } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { withFileLockSync } from '../storage/file-lock.js';
+
+export const TASK_SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
+export type TaskSeat = typeof TASK_SEATS[number];
+/** 과제 카드 id 접두 — `task show <id>` 가 이 접두로 TOX 태스크와 갈린다. */
+export const TASK_CARD_PREFIX = 'ta-';
+
+export interface TaskCardEvent { at: string; event: string; detail?: string }
+export interface TaskCardMove { kind: 'launch' | 'wait'; command?: string[]; reason: string }
+export interface TaskCard {
+  id: string;
+  text: string;
+  seat?: TaskSeat;
+  checklistId?: string;
+  createdAt: string;
+  /** launch-failed = 발사기가 띄우기에 실패했다(사유는 history 마지막 칸) — 다음 수는 다시 발사. */
+  status: 'handed' | 'launched' | 'launch-failed';
+  history: TaskCardEvent[];
+  /** 미션 카드만 — 조각 카드 id(순서대로) · 쪼갠 출처(`mission.ts` splitMission). */
+  pieces?: string[];
+  splitSource?: string;
+  /** 조각 카드만 — 소속 미션 카드 id · 먼저 착지해야 하는 조각 id(선후). */
+  mission?: string;
+  after?: string[];
+  /** 조각 카드만 — 착지 근거(② `tasks advance --pr|--goal`): 이 조각 런이 연 PR 번호 · 골 id(16자 · 런 원장 `pr-opened` 로 PR 을 찾는다). */
+  pr?: number;
+  goalId?: string;
+  /** 조각 카드만 — ② 가 선행 착지 뒤 넘겼다(한 번만 · 같은 잠금 안에서 먼저 적는다). */
+  handed?: { at: string; mode: 'shadow' | 'live'; claim?: string; error?: string };
+  /** 미션 카드만 — 모든 조각 착지 → 칸 green «제안»(체크리스트는 손대지 않는다 · OP/주인이 뒤집는다). */
+  greenProposal?: { at: string; checklistId: string | null; evidence: Record<string, string> };
+}
+
+interface TaskAgentStateFile { tasks?: Record<string, TaskCard>; [key: string]: unknown }
+
+export function taskAgentStatePath(): string {
+  return join(effectiveInstanceRoot(), 'task-agent-actions.json');
+}
+
+/** 상태 파일을 읽을 수 없거나(ENOENT 제외) 해석할 수 없다 — 덮어쓰기 전에 멈춘다. */
+export class TaskAgentStateError extends Error {
+  constructor(path: string, cause: unknown) {
+    super(`task-agent 상태 파일을 읽을 수 없다 — 덮어쓰지 않고 멈춘다: ${path} (${cause instanceof Error ? cause.message : String(cause)})`);
+    this.name = 'TaskAgentStateError';
+  }
+}
+
+/**
+ * 실행부·과제 넘기기 문이 함께 쓰는 상태 파일(`task-agent-actions.json`)의 엄격한 읽기.
+ * 파일이 «없음»(ENOENT)만 빈 상태다. 그 밖의 읽기·해석 오류(손상된 JSON · 객체 아님 · 권한)는
+ * 던진다 — 빈 상태로 읽고 다시 쓰면 failureCounts·착지 기록·과제 카드가 지워진다.
+ */
+export function readTaskAgentState<T extends object = TaskAgentStateFile>(path: string): T {
+  let raw: string;
+  try { raw = readFileSync(path, 'utf8'); } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') return {} as T;
+    return stateError(path, error);
+  }
+  let parsed: unknown;
+  try { parsed = JSON.parse(raw); } catch (error) { return stateError(path, error); }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return stateError(path, new Error('최상위가 객체가 아니다'));
+  return parsed as T;
+}
+
+function stateError(path: string, cause: unknown): never {
+  const error = new TaskAgentStateError(path, cause);
+  try { debug.log('task-agent', 'state-unreadable', { path, reason: error.message }); } catch { /* fail-soft */ }
+  throw error;
+}
+
+function readState(path: string): TaskAgentStateFile {
+  return readTaskAgentState<TaskAgentStateFile>(path);
+}
+
+/** 카드 여럿을 한 잠금 안에서 적는다(미션 ⊕ 조각) — 종전 칸은 `...disk` 로 보존. */
+export function writeTaskCards(path: string, cards: readonly TaskCard[]): void {
+  withFileLockSync(`${path}.lock`, () => {
+    const disk = readState(path);
+    mkdirSync(dirname(path), { recursive: true });
+    const tasks = { ...(disk.tasks ?? {}) };
+    for (const card of cards) tasks[card.id] = card;
+    writeFileSync(path, JSON.stringify({ ...disk, tasks }));
+  });
+}
+
+/** 카드 하나를 잠금 안에서 읽고 고쳐 쓴다 — `update` 가 undefined 를 돌려주면 쓰지 않는다. 쓴(또는 그대로인) 카드를 돌려준다. */
+export function updateTaskCard(path: string, id: string, update: (card: TaskCard | undefined, tasks: Readonly<Record<string, TaskCard>>) => TaskCard | undefined): TaskCard | undefined {
+  return withFileLockSync(`${path}.lock`, () => {
+    const disk = readState(path);
+    const current = disk.tasks?.[id];
+    const next = update(current, disk.tasks ?? {});
+    if (!next) return current;
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({ ...disk, tasks: { ...(disk.tasks ?? {}), [id]: next } }));
+    return next;
+  });
+}
+
+export function readTaskCard(id: string, path = taskAgentStatePath()): TaskCard | undefined {
+  return readState(path).tasks?.[id];
+}
+
+/** 첫 수의 elanous 인자(진입점·--config-dir 앞붙임은 launcher 몫). */
+export function launchArgs(card: Pick<TaskCard, 'text' | 'seat'>): string[] {
+  return ['harness', 'say', ...(card.seat ? ['--seat', card.seat] : []), '--substrate', 'pod', '--merge-by-host', card.text];
+}
+
+/**
+ * `landed` = 착지한 조각 id(② 감지가 채운다). 안 주면 «모른다» — 선행은 미착지로 보고(fail-closed)
+ * 이유에 «착지 미확인»을 단다(착지했다/안 했다를 단정하지 않는다).
+ * 미션 카드는 스스로 발사하지 않는다 · 아직 안 뜬 조각의 선행이 덜 착지했으면 `wait after <id>`.
+ */
+export function nextMoveFor(card: TaskCard, landed?: ReadonlySet<string>): TaskCardMove {
+  if (card.pieces) return { kind: 'wait', reason: `미션 — 조각 ${card.pieces.length}장이 선후대로 발사된다` };
+  const unmet = (card.after ?? []).filter((id) => !landed?.has(id));
+  if (card.status !== 'launched' && unmet.length > 0) return { kind: 'wait', reason: `after ${unmet.join(', ')}${landed ? '' : ' · 착지 미확인'}` };
+  if (card.status === 'handed') return { kind: 'launch', command: launchArgs(card), reason: '넘겨받은 과제 — 첫 발사' };
+  if (card.status === 'launch-failed') return { kind: 'launch', command: launchArgs(card), reason: '직전 발사 실패 — 다시 발사' };
+  return { kind: 'wait', reason: '발사됨 — 런 멈춤을 슈퍼바이저 그림자 판단(task-agent.shadow-move)이 받는다' };
+}
+
+export function shellQuote(arg: string): string {
+  return /^[A-Za-z0-9_./:=@%+-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'\\''`)}'`;
+}
+
+export type TaskLauncher = (args: string[]) => void | Promise<void>;
+
+export interface HandTaskOptions {
+  text: string;
+  seat?: TaskSeat;
+  checklistId?: string;
+  live?: boolean;
+  statePath?: string;
+  /** `--live` 일 때만 불린다. */
+  launcher?: TaskLauncher;
+  now?: () => Date;
+  id?: string;
+  /** 미션 조각으로 넘길 때 — 카드에 소속 미션·선후를 싣는다. */
+  mission?: string;
+  after?: string[];
+  /** 착지한 조각 id — `after` 가 모두 여기 있어야 발사한다(② 의 자리). */
+  landed?: ReadonlySet<string>;
+  /** 카드에 그대로 싣는 칸(② 의 넘김 표지·착지 근거) — handTask 가 카드를 새로 적을 때 지워지지 않게. */
+  cardFields?: Pick<TaskCard, 'pr' | 'goalId' | 'handed'>;
+  /**
+   * 있으면 카드 쓰기마다 잠금 안에서 디스크 카드를 보고 참일 때만 쓴다(② 의 claim 소유 확인).
+   * 거짓이면 쓰지 않고 `TaskCardSupersededError` — 다른 넘김이 그 카드를 가져갔다(발사 전이면 발사하지 않는다).
+   */
+  writeGuard?: (current: TaskCard | undefined) => boolean;
+}
+
+/** `writeGuard` 가 거짓 — 다른 넘김이 카드를 가져갔다. 카드는 건드리지 않았다. */
+export class TaskCardSupersededError extends Error {
+  constructor(id: string) {
+    super(`과제 카드를 다른 넘김이 가져갔다 — 쓰지 않았다: ${id}`);
+    this.name = 'TaskCardSupersededError';
+  }
+}
+
+/** `--live` 발사가 실패했다 — 카드는 launch-failed 로 남았다. */
+export class TaskLaunchError extends Error {
+  constructor(card: TaskCard, reason: string) {
+    super(`발사 실패 (${card.id} → launch-failed): ${reason}`);
+    this.name = 'TaskLaunchError';
+  }
+}
+
+export interface HandTaskResult { card: TaskCard; move: TaskCardMove; mode: 'shadow' | 'live'; launched: boolean }
+
+export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
+  const text = opts.text.trim();
+  if (!text) throw new Error('과제 한 줄이 비어 있다');
+  if (opts.seat !== undefined && !TASK_SEATS.includes(opts.seat)) throw new Error(`자리는 ${TASK_SEATS.join('|')} 중 하나다: ${opts.seat}`);
+  const now = (opts.now ?? (() => new Date()))();
+  const id = opts.id ?? `${TASK_CARD_PREFIX}${now.toISOString().slice(0, 10).replaceAll('-', '')}-${randomBytes(3).toString('hex')}`;
+  const mode = opts.live ? 'live' : 'shadow';
+  const path = opts.statePath ?? taskAgentStatePath();
+  const card: TaskCard = {
+    id, text,
+    ...(opts.seat ? { seat: opts.seat } : {}),
+    ...(opts.checklistId ? { checklistId: opts.checklistId } : {}),
+    createdAt: now.toISOString(),
+    status: 'handed',
+    history: [],
+    ...(opts.mission ? { mission: opts.mission, after: [...(opts.after ?? [])] } : {}),
+    ...(opts.cardFields ?? {}),
+  };
+  const move = nextMoveFor(card, opts.landed);
+  if (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; }
+    const owned = { ok: false };
+    // 착지 근거(pr·goalId)는 `recordPieceRef` 소유 — claim 뒤에 적힌 최신 근거를 디스크에서 이어 받는다.
+    updateTaskCard(target, next.id, (current) => {
+      if (!guard(current)) return undefined;
+      owned.ok = true;
+      // next 의 옛 근거는 버리고 디스크의 근거로 «교체»한다 — 정정된 근거 옆에 옛 근거가 되살아나지 않게.
+      const { pr: _stalePr, goalId: _staleGoal, ...base } = next;
+      return { ...base, ...(current?.pr !== undefined ? { pr: current.pr } : {}), ...(current?.goalId !== undefined ? { goalId: current.goalId } : {}) };
+    });
+    if (!owned.ok) throw new TaskCardSupersededError(next.id);
+  };
+  writeCard(path, card);
+  try { debug.log('task-agent', 'handed', { taskId: id, seat: card.seat ?? null, checklistId: card.checklistId ?? null, mode }); } catch { /* fail-soft */ }
+  if (mode === 'shadow') return { card, move, mode, launched: false };
+  if (!opts.launcher) throw new Error('--live 인데 launcher 가 없다');
+  try {
+    await opts.launcher(move.command!);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const failed: TaskCard = { ...card, status: 'launch-failed', history: [{ at: (opts.now ?? (() => new Date()))().toISOString(), event: 'launch-failed', detail: reason }] };
+    writeCard(path, failed);
+    try { debug.log('task-agent', 'launch-failed', { taskId: id, seat: card.seat ?? null, reason }); } catch { /* fail-soft */ }
+    throw new TaskLaunchError(failed, reason);
+  }
+  const launched: TaskCard = { ...card, status: 'launched', history: [{ at: (opts.now ?? (() => new Date()))().toISOString(), event: 'launch', detail: move.command!.join(' ') }] };
+  writeCard(path, launched);
+  try { debug.log('task-agent', 'launched', { taskId: id, seat: card.seat ?? null }); } catch { /* fail-soft */ }
+  return { card: launched, move, mode, launched: true };
+}

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

@@ -16,6 +16,7 @@ export interface TaskCard {
   goalId: string;
   title: string;
   status: CardStatus;
+  closedReason?: string;
   createdAt: string;
   sections: CardSection[];
 }
@@ -206,7 +207,7 @@ export class CardStore {
       if (card.status === 'closed') return card;
       this.append(id, { type: 'closed', createdAt: new Date().toISOString(),
         ...(reason === undefined ? {} : { reason: redactSecrets(reason.trim()) }) });
-      return { ...card, status: 'closed' as const };
+      return { ...card, status: 'closed' as const, ...(reason === undefined ? {} : { closedReason: redactSecrets(reason.trim()) }) };
     }).immediate();
   }
 
@@ -216,8 +217,10 @@ export class CardStore {
     } | null;
     if (!row) return null;
     const events = readFileSync(cardEventsPath(id, this.root), 'utf8').trimEnd().split('\n').map((line) => JSON.parse(line) as CardEvent);
+    const closed = events.find((event): event is Extract<CardEvent, { type: 'closed' }> => event.type === 'closed');
     return {
       id: row.id, goalId: row.goal_id, title: row.title, status: row.status, createdAt: row.created_at,
+      ...(closed?.reason === undefined ? {} : { closedReason: closed.reason }),
       sections: events.filter((event): event is Extract<CardEvent, { type: 'section' }> => event.type === 'section')
         .map(({ key, owner, content, createdAt }) => ({ key, owner, content, createdAt })),
     };

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

@@ -1,3 +1,31 @@
+/** Executor kinds of the dev child's `--json` result line (`src/index.ts` writeStdoutJson · DevExecutor.kind). */
+const CHILD_RESULT_KINDS = new Set(['self', 'external']);
+
+/** The dev child's terminal line nests the stage: {ok, kind, result:{stage, ok, node, outcome, …}}. Other JSON rows are not results. */
+export function nestedPodResult(row: Record<string, unknown>): { stage: string; ok: boolean; error?: string } | null {
+  if (typeof row.kind !== 'string' || !CHILD_RESULT_KINDS.has(row.kind) || typeof row.ok !== 'boolean') return null;
+  if (!row.result || typeof row.result !== 'object' || Array.isArray(row.result)) return null;
+  const result = row.result as Record<string, unknown>;
+  if (typeof result.stage !== 'string' || typeof result.ok !== 'boolean') return null;
+  if (result.ok) return { stage: result.stage, ok: true };
+  const classification = result.abandonedClassification;
+  const detail = typeof result.supervisorVerdict === 'string' ? result.supervisorVerdict
+    : classification && typeof classification === 'object' && !Array.isArray(classification)
+      ? (classification as Record<string, unknown>).classification : undefined;
+  const reason = [result.node, result.outcome].filter((part): part is string => typeof part === 'string' && part.length > 0).join(' ');
+  const error = [reason || (typeof result.error === 'string' ? result.error : ''), typeof detail === 'string' && detail ? detail : ''].filter(Boolean).join(' · ');
+  return { stage: result.stage, ok: false, ...(error ? { error } : {}) };
+}
+
+/** A child terminal row: the legacy flat form {stage, ok, error?} (no kind, or a child kind) or the nested dev result. Any other kind is not a result. */
+export function podTerminalRow(row: Record<string, unknown>): { stage: string; ok: boolean; error?: string } | null {
+  if (typeof row.kind === 'string' && !CHILD_RESULT_KINDS.has(row.kind)) return null;
+  if (typeof row.stage === 'string' && typeof row.ok === 'boolean') {
+    return { stage: row.stage, ok: row.ok, ...(typeof row.error === 'string' ? { error: row.error } : {}) };
+  }
+  return nestedPodResult(row);
+}
+
 /** Extract a human-readable reason from a failed child Pod without treating transfer markers as child errors. */
 export function extractPodFailureReason(input: {
   logs: string;
@@ -5,6 +33,8 @@ export function extractPodFailureReason(input: {
   containerReason?: string | null;
   jobReason?: string;
   deadlineSeconds?: number;
+  /** POD-NORESULT: the stage and PR from the child's parsed result row (disposition) — used only when no log line gives a readable reason. */
+  result?: { stage?: string | null; prUrl?: string | null; prNumber?: number | null } | null;
 }): string {
   if (input.jobReason === 'DeadlineExceeded') {
     return `DeadlineExceeded: Job 수명 상한 ${input.deadlineSeconds ?? 'unknown'}초 초과`;
@@ -12,7 +42,7 @@ export function extractPodFailureReason(input: {
   if (input.containerReason === 'OOMKilled') return 'OOMKilled: 컨테이너 메모리 한도 초과';
 
   const isBookkeeping = (line: string): boolean =>
-    /^ELANOUS_(?:MEM|RUN_LEDGER|USAGE_ROLLUP|POD_)/u.test(line) || /^(?:at\s+\S|\.\.\.\s+\d+\s+more\b|cleanup\s+(?:complete|done|finished)\b)/iu.test(line);
+    /^(?:ELANOUS_(?:MEM|RUN_LEDGER|USAGE_ROLLUP|POD_)|\[graph\] )/u.test(line) || /^(?:at\s+\S|\.\.\.\s+\d+\s+more\b|cleanup\s+(?:complete|done|finished)\b)/iu.test(line);
   const isError = (line: string): boolean =>
     /\berror\b|\bfail(?:ed|ure)?\b|exception|fatal|denied|timed?\s*out|exceeded|overloaded|unavailable|exhausted|오류|실패/iu.test(line);
   const meaningful: Array<{ text: string; terminal: boolean }> = [];
@@ -24,10 +54,11 @@ export function extractPodFailureReason(input: {
       try { parsed = JSON.parse(trimmed); } catch { /* An ordinary line may begin with a brace. */ }
       if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
         const row = parsed as Record<string, unknown>;
-        if (typeof row.ok === 'boolean' && typeof row.stage === 'string') {
+        const terminal = podTerminalRow(row);
+        if (terminal) {
           meaningful.length = 0;
-          if (row.ok === false && typeof row.error === 'string') {
-            const errorLines = row.error.split(/\r\n|\n|\r/u).map((part) => part.trim())
+          if (terminal.ok === false && typeof terminal.error === 'string') {
+            const errorLines = terminal.error.split(/\r\n|\n|\r/u).map((part) => part.trim())
               .filter((part) => part && !isBookkeeping(part));
             const errorLine = [...errorLines].reverse().find(isError) ?? errorLines.at(-1);
             if (errorLine) meaningful.push({ text: errorLine, terminal: true });
@@ -43,6 +74,14 @@ export function extractPodFailureReason(input: {
   const errorLine = [...meaningful].reverse().find((line) => line.terminal || isError(line.text));
   const reason = errorLine?.text.replace(/\/home\/[^/\s]+\//gu, '~/').slice(0, 240);
   if (reason) return reason;
+  // POD-NORESULT: an unconverged child (exit 2 → BackoffLimitExceeded under backoffLimit 0) often leaves a result row
+  // with a stage and PR but no error text — report that instead of «unreadable».
+  const stage = input.result?.stage?.trim();
+  if (stage) {
+    const prNumber = input.result?.prNumber;
+    const pr = Number.isSafeInteger(prNumber) && prNumber! > 0 ? `PR #${prNumber}` : input.result?.prUrl ? `PR ${input.result.prUrl}` : '';
+    return pr ? `수확 가능(${stage}) · ${pr}` : `수렴 못 함(단계 ${stage})`;
+  }
   const why = input.logTailReason?.trim() || (input.logs.trim() ? '로그에 읽을 수 있는 오류 줄 없음' : '자식 로그 비어 있음');
   return `사유 못 읽음: ${why.replace(/\/home\/[^/\s]+\//gu, '~/').slice(0, 240)}`;
 }

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

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

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

@@ -14,7 +14,8 @@
  * 풀을 안 주면 종전처럼 «현재 컨텍스트» 하나다(동작 불변).
  */
 import { spawn, spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { debug } from '../../debug/log.js';
 import { PodLeaseAdmission, type PodLeasePredecessor, type PodLeaseRelease } from '../../pod-lease/admission.js';
@@ -186,7 +187,8 @@ export class PodPoolScheduler {
   private readonly hostLease: HostPoolLease;
   private readonly pollMs: number;
   private readonly occupancy: () => Record<string, MemberOccupancy> | Promise<Record<string, MemberOccupancy>>;
-  constructor(readonly members: readonly PodPoolMember[], options: { status?: () => PoolLeaseRecommendation | Promise<PoolLeaseRecommendation>; kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; pollMs?: number; hostLease?: HostPoolLease; occupancy?: () => Record<string, MemberOccupancy> | Promise<Record<string, MemberOccupancy>>; dependencyMerged?: (after: PodLeasePredecessor, signal?: AbortSignal) => PredecessorState | boolean | Promise<PredecessorState | boolean> } = {}) {
+  private readonly memberMemory: () => Array<{ context: string; allocatableMemoryBytes: number | null }> | Promise<Array<{ context: string; allocatableMemoryBytes: number | null }>>;
+  constructor(readonly members: readonly PodPoolMember[], options: { status?: () => PoolLeaseRecommendation | Promise<PoolLeaseRecommendation>; kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; pollMs?: number; hostLease?: HostPoolLease; memberMemory?: () => Array<{ context: string; allocatableMemoryBytes: number | null }> | Promise<Array<{ context: string; allocatableMemoryBytes: number | null }>>; occupancy?: () => Record<string, MemberOccupancy> | Promise<Record<string, MemberOccupancy>>; dependencyMerged?: (after: PodLeasePredecessor, signal?: AbortSignal) => PredecessorState | boolean | Promise<PredecessorState | boolean> } = {}) {
     this.pollMs = options.pollMs ?? 15_000;
     // One lease directory per pool (contexts, not caps) — every CLI process launching into the same clusters shares it.
     this.hostLease = options.hostLease ?? podPoolHostLease(members);
@@ -195,6 +197,9 @@ export class PodPoolScheduler {
       return recommendConcurrency(measure, { capacity: members.reduce((n, m) => n + m.capacity, 0), accounts: 0, perAccount: 0 });
     });
     this.measure = async () => measureStatus();
+    // An injected status (tests, callers with their own measurement) without memberMemory never shells out to kubectl here.
+    this.memberMemory = options.memberMemory ?? (options.status ? (() => []) : () => measurePoolLease(members, { ...(options.kubectl ? { kubectl: options.kubectl } : {}), ...(options.dns ? { dns: options.dns } : {}) }).members
+      .map((m: PodLeaseMember) => ({ context: m.context, allocatableMemoryBytes: m.allocatableMemoryBytes })));
     this.occupancy = options.occupancy ?? (() => measureMemberOccupancy(members, { ...(options.kubectl ? { kubectl: options.kubectl } : {}), ...(options.dns ? { dns: options.dns } : {}) }));
     this.admission = new PodLeaseAdmission({ status: async () => {
       const measured = await measureStatus();
@@ -267,6 +272,23 @@ export class PodPoolScheduler {
       };
     });
   }
+  /**
+   * LAUNCH-STALL (10-06): members whose total allocatable memory is below one Job's limit can never take it —
+   * waiting for them is an endless silent stall (minio 12.5GB vs a 16Gi standard Job). A member whose memory
+   * could not be read is not judged unfit (unknown ≠ too small).
+   */
+  async unfitMembers(limitBytes: number): Promise<Array<{ context: string; allocatableMemoryBytes: number }>> {
+    let rows: Array<{ context: string; allocatableMemoryBytes: number | null }>;
+    try { rows = await this.memberMemory(); } catch { return []; }
+    return rows.flatMap((r) => r.allocatableMemoryBytes !== null && r.allocatableMemoryBytes < limitBytes
+      ? [{ context: r.context, allocatableMemoryBytes: r.allocatableMemoryBytes }] : []);
+  }
+  /** Why admission is still waiting: the pool-wide lease measurement (null before any reading). Slot waits get their reason from tryAcquire's onEmpty. */
+  waitReason(): string | null {
+    const r = this.lastRaw;
+    if (!r) return null;
+    return `recommended=${r.recommended ?? 'unknown'} limitedBy=${r.limitedBy ?? '-'} memorySlots=${r.memorySlots ?? '?'}${r.reason ? ` reason=${r.reason}` : ''}`;
+  }
   admissionSnapshot(): ReturnType<PodLeaseAdmission['snapshot']> {
     return this.admission.snapshot();
   }
@@ -277,7 +299,7 @@ export class PodPoolScheduler {
    * A member whose occupancy could not be read falls back to inflight-only (never treated as zero occupied).
    * Ties keep the configured member order. Returns null when every readable member is full.
    */
-  async tryAcquire(): Promise<PodPoolMember | null> {
+  async tryAcquire(skip?: ReadonlySet<string>, onEmpty?: (reason: string) => void): Promise<PodPoolMember | null> {
     let reading: Record<string, MemberOccupancy>;
     try { reading = await this.occupancy(); }
     catch (error) {
@@ -293,6 +315,8 @@ export class PodPoolScheduler {
       || (cand.measured !== best.measured ? cand.measured
         : cand.slots / cand.member.capacity > best.slots / best.member.capacity);
     for (const m of this.members) {
+      // LAUNCH-STALL: a member this launch cannot fit is skipped for this call only (other launches may fit it).
+      if (skip?.has(m.context)) continue;
       const inflight = this.inflight.get(m.context) ?? 0;
       const row = reading[m.context];
       const ok = !!row && row.occupied !== null;
@@ -304,7 +328,10 @@ export class PodPoolScheduler {
       const cand = { member: m, slots, measured: ok };
       if (better(cand)) best = cand;
     }
-    if (!best) return null;
+    if (!best) {
+      onEmpty?.(`no free slot · free=${JSON.stringify(free)} · measured=${JSON.stringify(measured)}${skip?.size ? ` · skipped=${[...skip].join(',')}` : ''}`);
+      return null;
+    }
     this.inflight.set(best.member.context, (this.inflight.get(best.member.context) ?? 0) + 1);
     const share = Object.fromEntries(this.members.map((m) => [m.context, Math.round(Math.max(0, free[m.context] ?? 0) / m.capacity * 100) / 100]));
     debug.log('pod.pool', 'member-selected', { member: best.member.context, free, measured, share });
@@ -396,13 +423,14 @@ export function podImageBuildScript(cwd: string = process.cwd()): string | null
   return null;
 }
 
-type RemoteBuild = (host: string, cluster: string, registry?: string) => Promise<{ ok: boolean; detail: string }>;
+/** packedTgz = 풀 동기화가 한 번 만든 패키지 묶음(있으면 build.sh 가 pack 을 다시 하지 않는다). */
+type RemoteBuild = (host: string, cluster: string, registry?: string, packedTgz?: string) => Promise<{ ok: boolean; detail: string }>;
 
-function defaultRemoteBuild(script: string, image: string): RemoteBuild {
-  return (host, cluster, registry) => new Promise((done) => {
-    const env: NodeJS.ProcessEnv = { ...process.env, ELANOUS_BUILD_REMOTE: host, ELANOUS_L2_CLUSTER: cluster, ELANOUS_BUILD_IMAGE: image === 'elanous-harness-lite:local' ? 'lite' : 'full' };
-    delete env.ELANOUS_BUILD_REGISTRY;
-    if (registry) env.ELANOUS_BUILD_REGISTRY = registry;
+/** 같은 트리의 패키지 묶음(tgz)을 «한 번» 만든다 — 멤버들이 같이 쓴다. cleanup 은 동기화가 끝나면 부른다. */
+type PoolPack = () => Promise<{ ok: boolean; tgz?: string; detail: string; cleanup?: () => void }>;
+
+function runBuildScript(script: string, env: NodeJS.ProcessEnv): Promise<{ ok: boolean; detail: string }> {
+  return new Promise((done) => {
     const child = spawn('bash', [script], { env, stdio: ['ignore', 'pipe', 'pipe'] });
     let out = '';
     child.stdout.on('data', (d) => { out += d; }); child.stderr.on('data', (d) => { out += d; });
@@ -411,18 +439,53 @@ function defaultRemoteBuild(script: string, image: string): RemoteBuild {
   });
 }
 
+/**
+ * 🩸 2026-10-06: 멤버마다 build.sh 가 같은 트리에서 `bun pm pack` 을 «동시에» 돌렸다 — prepack 이 트리에 쓰는
+ * src/version/packed-revision.json 을 다른 쪽 postpack 이 지워 한쪽이 «⛔ pack» 으로 죽었다(node-c 가 매 발사 빠졌다).
+ * ⇒ 원격 멤버가 둘 이상이면 pack 은 여기서 한 번만 하고 그 tgz 를 나눠 준다.
+ */
+function defaultPoolPack(script: string): PoolPack {
+  return async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'elanous-pool-pack-'));
+    const tgz = join(dir, 'elanous.tgz');
+    const env: NodeJS.ProcessEnv = { ...process.env, ELANOUS_BUILD_PACK_ONLY: tgz };
+    delete env.ELANOUS_BUILD_PACKED_TGZ;
+    delete env.ELANOUS_BUILD_REMOTE;
+    const r = await runBuildScript(script, env);
+    const cleanup = () => rmSync(dir, { recursive: true, force: true });
+    if (!r.ok || !existsSync(tgz)) { cleanup(); return { ok: false, detail: r.detail }; }
+    return { ok: true, tgz, detail: r.detail, cleanup };
+  };
+}
+
+function defaultRemoteBuild(script: string, image: string): RemoteBuild {
+  return (host, cluster, registry, packedTgz) => {
+    const env: NodeJS.ProcessEnv = { ...process.env, ELANOUS_BUILD_REMOTE: host, ELANOUS_L2_CLUSTER: cluster, ELANOUS_BUILD_IMAGE: image === 'elanous-harness-lite:local' ? 'lite' : 'full' };
+    delete env.ELANOUS_BUILD_REGISTRY;
+    if (registry) env.ELANOUS_BUILD_REGISTRY = registry;
+    delete env.ELANOUS_BUILD_PACK_ONLY;
+    delete env.ELANOUS_BUILD_PACKED_TGZ;
+    if (packedTgz) env.ELANOUS_BUILD_PACKED_TGZ = packedTgz;
+    return runBuildScript(script, env);
+  };
+}
 /**
  * 풀의 원격 노드들을 «동시에» 이 트리의 판으로 맞춘다 (09-25 개선).
  *   1순위 = 노드 «쪽에서» 빌드(build.sh ELANOUS_BUILD_REMOTE) — 빌드 재료(수십 MB)만 보내고 무거운 층은 그 노드의 캐시가 재사용한다.
  *           📏 커밋이 바뀐 뒤 두 노드를 올리는 데 벽시계 55초(종전: 다시 굽기 1분 40초 ⊕ 4GB 차례 전송 5분 48초).
  *   실패하면 = 종전의 통째 전송(syncPoolImage)으로 떨어진다.
  */
-export async function syncPoolImages(members: readonly PodPoolMember[], image: string, localCommit: string | null, deps: { run?: RemoteRun; remoteBuild?: RemoteBuild; buildScript?: string | null; ship?: typeof syncPoolImage; localSkillsDigest?: string | null; waitIntervalMs?: number; waitMaxMs?: number; now?: () => number; sleep?: (ms: number) => Promise<void>; inspect?: LocalImageInspect; transfer?: ImageShip } = {}): Promise<Map<string, PoolImageSync>> {
+export async function syncPoolImages(members: readonly PodPoolMember[], image: string, localCommit: string | null, deps: { run?: RemoteRun; remoteBuild?: RemoteBuild; buildScript?: string | null; ship?: typeof syncPoolImage; localSkillsDigest?: string | null; waitIntervalMs?: number; waitMaxMs?: number; now?: () => number; sleep?: (ms: number) => Promise<void>; inspect?: LocalImageInspect; transfer?: ImageShip; pack?: PoolPack | null } = {}): Promise<Map<string, PoolImageSync>> {
   const run = deps.run ?? defaultRemoteRun;
   const script = deps.buildScript === undefined ? podImageBuildScript() : deps.buildScript;
   const remoteBuild = deps.remoteBuild ?? (script ? defaultRemoteBuild(script, image) : null);
   const ship = deps.ship ?? ((m: PodPoolMember, img: string, commit: string | null, remote: RemoteRun) => syncPoolImage(m, img, commit, { run: remote, inspect: deps.inspect, transfer: deps.transfer }));
   const results = new Map<string, PoolImageSync>();
+  // pack 한 번 ⊕ 나눠 쓰기 — 원격 멤버가 둘 이상일 때만(하나뿐이면 종전대로 build.sh 가 스스로 pack 한다).
+  //   주입된 remoteBuild(시험)에는 진짜 pack 을 붙이지 않는다 — pack 도 주입해야 쓴다.
+  const pack = deps.pack !== undefined ? deps.pack : (!deps.remoteBuild && script ? defaultPoolPack(script) : null);
+  const sharePack = pack && members.filter((m) => m.sshHost).length >= 2 ? pack : null;
+  let packed: ReturnType<PoolPack> | null = null;
   await Promise.all(members.map(async (m) => {
     const t0 = Date.now();
     if (!m.sshHost) { results.set(m.context, { ok: true, action: 'local', detail: 'this machine', ms: 0 }); return; }
@@ -437,7 +500,12 @@ export async function syncPoolImages(members: readonly PodPoolMember[], image: s
       return;
     }
     if (remoteBuild) {
-      const b = await remoteBuild(m.sshHost, m.k3dCluster, m.registry);
+      // 같은 판이 아닌 멤버가 처음 여기 닿을 때 pack 한다(전부 fresh 면 pack 도 없다).
+      const shared = sharePack ? await (packed ??= sharePack()) : null;
+      if (shared && !shared.ok) debug.log('self-implement.pod', 'pool-image-pack-failed', { context: m.context, detail: shared.detail });
+      const b = shared && !shared.ok
+        ? { ok: false, detail: shared.detail }
+        : await remoteBuild(m.sshHost, m.k3dCluster, m.registry, shared?.tgz);
       const after = remoteImageCommit(m, image, run);
       const refAfter = registryImageRef(m, localCommit ?? after, run, image);
       // ⭐ 레지스트리 노드면 «이 판 커밋 태그가 레지스트리에 있나»로 판정한다 — Pod 는 그 커밋 태그를 pull 한다.
@@ -462,6 +530,6 @@ export async function syncPoolImages(members: readonly PodPoolMember[], image: s
       return;
     }
     results.set(m.context, { ...ship(m, image, localCommit, run), ms: Date.now() - t0 });
-  }));
+  })).finally(async () => { if (packed) (await packed).cleanup?.(); });
   return results;
 }