elanous 0.2.16 → 0.2.17

package/src/task-agent/judge.ts

@@ -0,0 +1,96 @@
+/**
+ * TASK-AGENT 판단부 — 슈퍼바이저 종료 어휘(+ PR·리뷰 관측) → «다음 한 수».
+ *
+ * RFC-task-agent-any-task-to-completion-2026-10-06 §A2 표를 순수 함수로 옮긴다.
+ * 부작용이 없다(발사·리뷰·착지는 실행부 `actions.ts` 의 몫). 수확 원천 = run-c9ad6d6d `chooseTaskAction`.
+ */
+import type { SupervisorStopReason } from '../self-dev/run-supervisor.js';
+import type { NextActionKind } from './actions.js';
+
+export type TaskMove =
+  | 'propose-green'
+  | 'review'
+  | 'propose-land'
+  | 'narrow-relaunch'
+  | 'wait-retry'
+  | 'salvage-relaunch'
+  | 'alternative'
+  | 'decision-card'
+  | 'wait';
+
+export interface TaskJudgeInput {
+  stopReason?: SupervisorStopReason;
+  prState?: 'OPEN' | 'MERGED' | 'CLOSED';
+  pr?: string | number;
+  /** `self review --json` 판정. 관측 못 했으면 비운다(«통과»로 읽지 않는다). */
+  review?: 'pass' | 'fail';
+  mustFix?: readonly string[];
+  /** 수마다 누적 실패 수. */
+  failures?: Partial<Record<TaskMove, number>>;
+}
+
+export interface TaskJudgement {
+  move: TaskMove;
+  stage: 'observing' | 'closing' | 'reviewing' | 'repairing' | 'waiting' | 'escalated';
+  reason: string;
+  /** 실행부(`executeNextAction`)가 바로 받는 수면 그 종류. 없으면 발사·대기 계열(실행부 밖). */
+  executorKind?: NextActionKind;
+}
+
+/** 같은 수가 이 횟수만큼 실패하면 다른 수로 넘어간다(RFC §A2 «같은 수 2번 실패»). */
+export const SAME_MOVE_FAILURE_LIMIT = 2;
+
+const EXECUTOR_KIND: Partial<Record<TaskMove, NextActionKind>> = {
+  'propose-green': 'green',
+  review: 'review',
+  'propose-land': 'land',
+  'narrow-relaunch': 'retry',
+  'wait-retry': 'retry',
+  'salvage-relaunch': 'retry',
+  alternative: 'retry',
+  'decision-card': 'decision',
+};
+
+function base(input: TaskJudgeInput): Omit<TaskJudgement, 'executorKind'> {
+  const stop = input.stopReason;
+  const merged = input.prState === 'MERGED' && input.pr !== undefined && input.pr !== '';
+  if (merged) {
+    return { move: 'propose-green', stage: 'closing', reason: `병합된 PR ${input.pr} 근거로 칸 green 제안` };
+  }
+  switch (stop) {
+    case 'harvestable-awaiting-human':
+    case 'needs-human':
+      if (input.review === 'pass') return { move: 'propose-land', stage: 'reviewing', reason: 'self review 통과 — 착지 제안' };
+      if (input.review === 'fail') {
+        return { move: 'narrow-relaunch', stage: 'repairing', reason: `must-fix 로 좁혀 재발사: ${(input.mustFix ?? []).join(' · ') || '(must-fix 비어 있음)'}` };
+      }
+      return { move: 'review', stage: 'reviewing', reason: '수확 가능 런 — self review 필요' };
+    case 'no-progress':
+    case 'decomposable-no-progress':
+      return { move: 'narrow-relaunch', stage: 'repairing', reason: `${stop} — 범위를 좁혀 한 번 재발사(판정선 유지)` };
+    case 'provider-exhausted':
+    case 'step-timeout':
+      return { move: 'wait-retry', stage: 'waiting', reason: `${stop} — 대기 후 재시도` };
+    case 'handed-off-to-salvage':
+      return { move: 'salvage-relaunch', stage: 'repairing', reason: '수확 브랜치 diff 를 가져와 이어 발사' };
+    case 'converged':
+      return { move: 'wait', stage: 'observing', reason: '완주했으나 PR 병합 근거 대기' };
+    case undefined:
+      return { move: 'wait', stage: 'observing', reason: '종료 관측 대기' };
+    default:
+      return { move: 'decision-card', stage: 'escalated', reason: `표에 없는 종료 어휘 ${stop} — 근거 붙여 사람 결정` };
+  }
+}
+
+/** 종료 어휘·관측에서 다음 한 수를 고른다. 같은 수 2회 실패 → 다른 수 → 그것도 실패 → 결정 카드. */
+export function judgeNextMove(input: TaskJudgeInput): TaskJudgement {
+  const failures = input.failures ?? {};
+  let judged = base(input);
+  if ((failures.alternative ?? 0) >= 1) {
+    judged = { move: 'decision-card', stage: 'escalated', reason: `대안도 실패 — 런·PR·must-fix 근거로 사람 결정 (직전: ${judged.move})` };
+  } else if (judged.move !== 'wait' && judged.move !== 'decision-card' && (failures[judged.move] ?? 0) >= SAME_MOVE_FAILURE_LIMIT) {
+    judged = { move: 'alternative', stage: 'repairing', reason: `같은 수 ${SAME_MOVE_FAILURE_LIMIT}회 실패 — 다른 수 선택 (${judged.move})` };
+  }
+  const executorKind = EXECUTOR_KIND[judged.move];
+  return executorKind ? { ...judged, executorKind } : judged;
+}

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;
@@ -12,7 +40,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 +52,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 });

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;
 }