elanous 0.2.14 → 0.2.16

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

@@ -7,6 +7,7 @@
 
 import { randomBytes } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
 import { isAbsolute, resolve } from 'node:path';
 import { getUserConfig } from '../../user-config.js';
 import { debug } from '../../debug/log.js';
@@ -35,6 +36,14 @@ export const POD_LITE_IMAGE = 'elanous-harness-lite:local';
 
 export const POD_LITE_MEMORY_LIMIT = '2Gi';
 
+/** 요청은 한도를 넘을 수 없다(쿠버네티스가 Job 을 거부한다) — lite 2Gi 처럼 한도가 기본 요청보다 작으면 한도로 맞춘다. */
+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 max = gi(limit);
+  return request !== null && max !== null && request > max ? limit! : POD_CHILD_REQUESTS.memory;
+}
+
 /** POD7 must-fix: the skill list alone can't tell a network-only job from one that needs ffmpeg/browser — so lite is
  *  only ever chosen when the caller says so (`lite`), and then only for network skills without a clone. Anything we
  *  can't judge keeps the full image. A lite request that doesn't fit is refused with the reason, not silently widened. */
@@ -50,6 +59,26 @@ export function podCommandImageFor(skills: readonly string[], clone: boolean, li
 
 const COMMAND_LOG_CHARS = 80;
 
+/** 자식 로그 전문 상한(바이트) — 넘으면 끝부분을 남긴다. config `pod.childLogMaxBytes` 가 양의 정수일 때만 그 값. */
+export const POD_CHILD_LOG_MAX_BYTES_DEFAULT = 1_048_576;
+
+export function podChildLogMaxBytes(read: () => number | undefined = () => getUserConfig().pod?.childLogMaxBytes): number {
+  const configured = read();
+  return typeof configured === 'number' && Number.isSafeInteger(configured) && configured > 0
+    ? configured
+    : POD_CHILD_LOG_MAX_BYTES_DEFAULT;
+}
+
+/** 크기 상한을 넘으면 끝부분을 남긴다(잘린 앞은 표시). */
+export function tailBytes(text: string, maxBytes: number): string {
+  const bytes = Buffer.from(text);
+  if (bytes.length <= maxBytes) return text;
+  const cut = bytes.subarray(bytes.length - maxBytes);
+  let start = 0;
+  while (start < cut.length && (cut[start]! & 0xc0) === 0x80) start += 1;
+  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
@@ -156,7 +185,7 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
           initContainers: [{ name: 'isolation-gate', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never', command: ['bash', '-c'], args: [GATE] }],
           containers: [{
             name: 'child', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never',
-            resources: { requests: { ...POD_CHILD_REQUESTS }, limits: { memory: o.memoryLimit ?? '16Gi', cpu: '4' } },
+            resources: { requests: { ...POD_CHILD_REQUESTS, memory: memoryRequestWithin(o.memoryLimit) }, limits: { memory: o.memoryLimit ?? '16Gi', cpu: '4' } },
             command: ['bash', '-c'], args: [script],
             env: [
               ...(o.runId ? [{ name: 'ELANOUS_RUN_ID', value: o.runId }] : []),
@@ -214,12 +243,23 @@ export function podCommandSecretKeys(secret: Record<string, unknown> | null): st
   return Object.keys((secret.stringData as Record<string, string> | undefined) ?? {});
 }
 
+export interface PodArtifactCollection {
+  /** 회수한 산출 파일 수(child.log 제외). 로그 조회 실패면 null. */
+  files: number | null;
+  /** 회수한 산출 파일의 상대 경로. */
+  names: string[];
+  /** 로그 조회 자체가 실패했을 때의 사유. 성공이면 null. */
+  error: string | null;
+}
+
 export interface PodCommandResult {
   exitCode: number;
   artifactsDir: string;
   job: string;
   /** 이 런이 실제로 쓴 이미지(레지스트리 판 태그 또는 로컬 이름). */
   image?: string;
+  /** collectPodArtifacts 가 회수한 파일. 로그 조회 실패면 files=null · error=사유. runPodCommand 는 항상 채운다. */
+  artifacts?: PodArtifactCollection;
 }
 
 export interface RunPodCommandOptions {
@@ -255,6 +295,8 @@ export interface RunPodCommandOptions {
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
   env?: NodeJS.ProcessEnv;
   configHostMirror?: () => string | undefined;
+  /** 자식 로그 전문 상한(바이트). 생략 시 config `pod.childLogMaxBytes`, 없으면 1MiB. 넘으면 끝부분 우선. */
+  childLogMaxBytes?: number;
 }
 
 function jobFinished(types: string): 'complete' | 'failed' | null {
@@ -263,6 +305,19 @@ function jobFinished(types: string): 'complete' | 'failed' | null {
   return null;
 }
 
+function artifactNames(logs: string): string[] {
+  const names = new Set<string>();
+  for (const line of logs.split(/\r?\n/)) {
+    const match = /^ELANOUS_POD_ARTIFACT (\S+) \d+\/\d+ /.exec(line);
+    if (!match) continue;
+    try {
+      const path = Buffer.from(match[1]!, 'base64url').toString('utf8');
+      if (path && !path.split('/').some((part) => part === '' || part === '.' || part === '..')) names.add(path);
+    } catch { /* 회수 쪽(collectPodArtifacts)이 불완전 사유를 남긴다 */ }
+  }
+  return [...names];
+}
+
 function exitCodeFromPod(kubectl: Kubectl, namespace: string, job: string, state: 'complete' | 'failed'): number {
   const got = kubectl(['-n', namespace, 'get', 'pods', '-l', `job-name=${job}`, '-o', 'jsonpath={.items[0].status.containerStatuses[?(@.name=="child")].state.terminated.exitCode}']);
   const code = Number(got.stdout.trim());
@@ -316,7 +371,7 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
   }
   if (pool) {
     for (;;) {
-      member = pool.tryAcquire();
+      member = await pool.tryAcquire();
       if (member) break;
       await sleep(options.pollMs ?? 15_000);
     }
@@ -387,12 +442,29 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       if (finished) { state = finished; break; }
       await sleep(options.pollMs ?? 15_000);
     }
-    const logs = kubectl(['-n', namespace, 'logs', `job/${name}`, '-c', 'child']).stdout;
-    collectPodArtifacts(logs, {
-      dir: options.artifactsRoot ?? `${effectiveInstanceRoot()}/pod-artifacts`,
-      job: name,
-      log: (c, e, d) => log(c, e, d),
-    });
+    const logsResult = kubectl(['-n', namespace, 'logs', `job/${name}`, '-c', 'child']);
+    const logsFailed = logsResult.status !== 0;
+    const logs = logsFailed ? '' : logsResult.stdout;
+    const artifactDir = options.artifactsRoot ?? `${effectiveInstanceRoot()}/pod-artifacts`;
+    let artifacts: PodArtifactCollection;
+    if (logsFailed) {
+      const reason = logsResult.stderr.trim() || `kubectl logs exit ${logsResult.status}`;
+      artifacts = { files: null, names: [], error: reason };
+      log('pod.command', 'artifact-collect-failed', { job: name, reason });
+    } else {
+      collectPodArtifacts(logs, {
+        dir: artifactDir,
+        job: name,
+        log: (c, e, d) => log(c, e, d),
+      });
+      const names = artifactNames(logs);
+      artifacts = { files: names.length, names, error: null };
+    }
+    // 표지가 없어도 알리는 경로는 실제로 존재해야 한다. 자식 로그 전문은 child.log (상한 넘으면 끝부분).
+    mkdirSync(artifactsDir, { recursive: true });
+    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);
     cleanupSecret();
     log('pod.command', 'job-finished', {
@@ -401,8 +473,11 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       skills,
       llm: llm ?? null,
       command: command.join(' ').slice(0, COMMAND_LOG_CHARS),
+      artifactsDir,
+      artifacts,
+      ...(logsFailed ? { artifactError: `산출 회수 못 함: ${artifacts.error}` } : {}),
     });
-    return { exitCode, artifactsDir, job: name, image: imageRef ?? image };
+    return { exitCode, artifactsDir, job: name, image: imageRef ?? image, artifacts };
   } catch (err) {
     cleanupSecret();
     throw err;

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

@@ -0,0 +1,48 @@
+/** Extract a human-readable reason from a failed child Pod without treating transfer markers as child errors. */
+export function extractPodFailureReason(input: {
+  logs: string;
+  logTailReason?: string;
+  containerReason?: string | null;
+  jobReason?: string;
+  deadlineSeconds?: number;
+}): string {
+  if (input.jobReason === 'DeadlineExceeded') {
+    return `DeadlineExceeded: Job 수명 상한 ${input.deadlineSeconds ?? 'unknown'}초 초과`;
+  }
+  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);
+  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 }> = [];
+  for (const line of input.logs.split(/\r\n|\n|\r/u)) {
+    const trimmed = line.trim();
+    if (!trimmed || isBookkeeping(trimmed)) continue;
+    if (trimmed.startsWith('{')) {
+      let parsed: unknown;
+      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') {
+          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())
+              .filter((part) => part && !isBookkeeping(part));
+            const errorLine = [...errorLines].reverse().find(isError) ?? errorLines.at(-1);
+            if (errorLine) meaningful.push({ text: errorLine, terminal: true });
+          }
+          continue;
+        }
+        // A JSON transfer/observation is not a plain-text failure reason.
+        continue;
+      }
+    }
+    meaningful.push({ text: trimmed, terminal: false });
+  }
+  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;
+  const why = input.logTailReason?.trim() || (input.logs.trim() ? '로그에 읽을 수 있는 오류 줄 없음' : '자식 로그 비어 있음');
+  return `사유 못 읽음: ${why.replace(/\/home\/[^/\s]+\//gu, '~/').slice(0, 240)}`;
+}

package/src/task-orchestrator/surfaces/pod-ledger-collect.ts

@@ -3,6 +3,7 @@ import { gunzipSync } from 'node:zlib';
 import { debug } from '../../debug/log.js';
 import { runLedgerDir, runLedgerPath } from '../../self-implement/run-ledger.js';
 import { ledgerLineToLogEvent } from './pod-ledger-events.js';
+import { defaultPodReemit } from './pod-ledger-prod-sink.js';
 
 type Ledger = { runId: string; jsonl: string };
 type Incomplete = { runId: string; reason: string };
@@ -94,7 +95,7 @@ export function parsePodLedgerChunks(logs: string): ParseResult {
  *  except a ledger that THIS run's live follower created (`replace`): that one is a partial copy and the final is complete. */
 export function collectPodLedgers(
   logs: string,
-  { dir = runLedgerDir(), log = (c, e, d) => debug.log(c, e, d), emit = (c, e, d) => debug.log(c, e, d), replace = new Set<string>() }: {
+  { dir = runLedgerDir(), log = defaultPodReemit(), emit = defaultPodReemit(), replace = new Set<string>() }: {
     dir?: string;
     log?: (category: string, event: string, data: Record<string, unknown>) => void;
     emit?: Emit;
@@ -146,8 +147,8 @@ export function createPodLedgerFollower(opts: {
   onStall?: (message: string) => void;
 }): { poll(): void; readonly owned: boolean } {
   const dir = opts.dir ?? runLedgerDir();
-  const log = opts.log ?? ((c, e, d) => debug.log(c, e, d));
-  const emit: Emit = opts.emit ?? ((c, e, d) => debug.log(c, e, d));
+  const log = opts.log ?? defaultPodReemit();
+  const emit: Emit = opts.emit ?? defaultPodReemit();
   const now = opts.now ?? Date.now;
   const stallMinutes = opts.stallMinutes ?? 30;
   if (!Number.isFinite(stallMinutes) || stallMinutes <= 0) throw new RangeError('stallMinutes must be positive');

package/src/task-orchestrator/surfaces/pod-ledger-prod-sink.ts

@@ -0,0 +1,75 @@
+import { debug } from '../../debug/log.js';
+import { LogStore, logsDbPath } from '../../mss/logging/log-store.js';
+
+type Emit = (category: string, event: string, data: Record<string, unknown>) => void;
+type Store = Pick<LogStore, 'insertBatch'>;
+
+/** 발사한 부모(`harness say --config-dir …`)가 정한 집의 logs.db — 부모가 자식 `self orchestrate` 에 env 로 넘긴다. */
+export const POD_REEMIT_LOGS_DB_ENV = 'ELANOUS_POD_REEMIT_LOGS_DB';
+export function launchHomeLogsDb(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  return env[POD_REEMIT_LOGS_DB_ENV]?.trim() || undefined;
+}
+
+let cached: { path: string; store: Store } | null = null;
+let announced = '';
+
+/**
+ * POD-OBS(10-06 · 0.2.16 P0 · OP 사양): Pod 자식 원장 «재방출»만 부모가 발사 때 정한 집(A)의 logs.db 로 보낸다.
+ * 자식 orchestrate 는 트리 파생 test 우주(B)에서 돌아, 지금은 재방출이 B 에만 쌓였다(24h `ledger-collected` 운영 2 vs 다른 우주 250).
+ * 자식 우주 원장·격리는 그대로 둔다. A 를 못 열면 조용히 버리지 않고 B 로 떨어뜨리며 경고한다.
+ * env 가 없거나(옛 발사) A == B 이거나 시험 프로세스면 null → 호출측이 지금처럼 B 에만 쓴다.
+ */
+export function operationalReemit(opts: {
+  currentDb?: string;
+  operationalDb?: string;
+  open?: (path: string) => Store;
+  testProcess?: boolean;
+  fallback?: Emit;
+} = {}): Emit | null {
+  const operationalDb = opts.operationalDb ?? launchHomeLogsDb();
+  if (!operationalDb) return null;
+  const currentDb = opts.currentDb ?? logsDbPath();
+  const testProcess = opts.testProcess ?? (process.env.NODE_ENV === 'test' || !!process.env.ELANOUS_TEST_HOME);
+  if (testProcess && !opts.open) return null;
+  if (currentDb === operationalDb) return null;
+  const open = opts.open ?? ((path: string) => new LogStore(path, { instance: 'prod' }));
+  const fallback: Emit = opts.fallback ?? ((c, e, d) => debug.log(c, e, d));
+  const write = (category: string, event: string, data: Record<string, unknown>): void => {
+    if (!cached || cached.path !== operationalDb || opts.open) cached = { path: operationalDb, store: open(operationalDb) };
+    cached.store.insertBatch([{ rec: { ts: new Date().toISOString(), category, event, data }, surface: 'pod-reemit' }]);
+  };
+  let warned = false;
+  return (category, event, data) => {
+    try {
+      if (announced !== `${currentDb}->${operationalDb}` || opts.open) {
+        // 어느 우주로 보냈는지 한 줄(A 에) — 조회자가 «B 에 왜 없나»를 여기서 본다.
+        write('self-implement.pod', 'reemit-target', { targetUniverse: operationalDb, childUniverse: currentDb });
+        announced = `${currentDb}->${operationalDb}`;
+      }
+      write(category, event, data);
+    } catch (error) {
+      fallback(category, event, data);
+      if (warned) return;
+      // 경고는 싱크(발사 하나)당 한 번 — 줄마다 찍으면 경고가 원장을 덮는다.
+      warned = true;
+      try {
+        fallback('self-implement.pod', 'reemit-target-unavailable', {
+          targetUniverse: operationalDb, childUniverse: currentDb, reason: error instanceof Error ? error.message : String(error),
+        });
+      } catch { /* nothing */ }
+    }
+  };
+}
+
+let shared: { key: string; emit: Emit } | null = null;
+
+/** 재방출 기본 경로: 집(A)이 정해져 있으면 A 에만, 아니면 지금처럼 지금 우주(B)의 debug.log.
+ *  프로세스(발사)당 싱크 하나 — collector 의 `log`·`emit`, follower 가 같은 싱크를 써서 경고·대상 줄이 한 번이다. */
+export function defaultPodReemit(): Emit {
+  const key = `${launchHomeLogsDb() ?? ''}->${logsDbPath()}`;
+  if (shared?.key === key) return shared.emit;
+  const operational = operationalReemit();
+  const emit: Emit = operational ?? ((category, event, data) => { debug.log(category, event, data); });
+  shared = { key, emit };
+  return emit;
+}

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

@@ -8,7 +8,7 @@
  *   - 컨텍스트  kubectl 컨텍스트 이름(이 맥의 kubeconfig)
  *   - @ssh호스트 원격 클러스터면 그 기계 — 이미지 판 대조·반입(`docker load` ⊕ `k3d image import`)에 쓴다
  *   - 상한      이 노드에 동시에 둘 Job 수(기본 2)
- * Job 마다 앞 순위부터 «진행 중 < 상한»인 노드를 고른다. 다 차면 자리가 날 때까지 기다린다.
+ * Job 마다 «빈 자리 비율»이 가장 큰 노드를 고른다(동률은 앞 순위 · 측정 실패 노드는 측정된 노드가 다 찼을 때만). 다 차면 자리가 날 때까지 기다린다.
  * 노드 선택의 진행 중 수는 로컬 프로세스 기준이다. 발사 허가는 별도의 lease 측정으로
  * 다른 호스트의 Running/Pending 및 메모리 예약까지 고려한다.
  * 풀을 안 주면 종전처럼 «현재 컨텍스트» 하나다(동작 불변).
@@ -20,7 +20,7 @@ import { debug } from '../../debug/log.js';
 import { PodLeaseAdmission, type PodLeasePredecessor, type PodLeaseRelease } from '../../pod-lease/admission.js';
 import { predecessorState, type PredecessorState } from '../../pod-lease/dependency-state.js';
 import { HostPoolLease, leaseHasPendingPod } from '../../pod-lease/host-lease.js';
-import { measurePoolLease, recommendConcurrency, type PoolDnsProbe, type PoolLeaseRecommendation } from './pod-lease.js';
+import { measurePoolLease, recommendConcurrency, type PodLeaseMember, type PoolDnsProbe, type PoolLeaseRecommendation } from './pod-lease.js';
 
 export interface PodPoolMember {
   readonly context: string;
@@ -142,7 +142,34 @@ export function genericConfigPodPool(config: { pod?: { pool?: string }; harness?
   return config.pod?.pool;
 }
 
-/** 노드 자리 배분 — 우선순위 순서로 첫 빈 자리. 순수(시각·대기는 호출자가). */
+/**
+ * Cluster occupancy of one pool member: Running + Pending harness goal Pods.
+ * `null` means the read failed — callers must not treat that as zero.
+ */
+export type MemberOccupancy = { occupied: number } | { occupied: null; reason: string };
+
+/** Read each member's cluster occupancy (Running + Pending harness goal Pods). A failed member is `occupied: null`, never 0. */
+export function measureMemberOccupancy(members: readonly PodPoolMember[], deps: { kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; measure?: (members: readonly PodPoolMember[]) => { members: PodLeaseMember[] } } = {}): Record<string, MemberOccupancy> {
+  let measured: { members: PodLeaseMember[] };
+  try {
+    measured = deps.measure
+      ? deps.measure(members)
+      : measurePoolLease(members, { ...(deps.kubectl ? { kubectl: deps.kubectl } : {}), ...(deps.dns ? { dns: deps.dns } : {}) });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return Object.fromEntries(members.map((m) => [m.context, { occupied: null, reason }]));
+  }
+  const byContext = new Map(measured.members.map((m) => [m.context, m]));
+  return Object.fromEntries(members.map((member) => {
+    const row = byContext.get(member.context);
+    if (!row || row.running === null || row.pending === null) {
+      return [member.context, { occupied: null, reason: row?.reason ?? '측정 불가' }];
+    }
+    return [member.context, { occupied: row.running + row.pending }];
+  }));
+}
+
+/** 노드 자리 배분 — 클러스터 실측 점유가 있으면 남은 칸이 가장 큰 멤버. 측정이 없으면 우선순위 순 첫 빈 자리. */
 export function podPoolHostLease(members: readonly PodPoolMember[]): HostPoolLease {
   return new HostPoolLease([...members.map((m) => `${m.context}@${m.sshHost ?? ''}`)].sort().join(','));
 }
@@ -158,7 +185,8 @@ export class PodPoolScheduler {
   private lastRaw: PoolLeaseRecommendation | null = null;
   private readonly hostLease: HostPoolLease;
   private readonly pollMs: number;
-  constructor(readonly members: readonly PodPoolMember[], options: { status?: () => PoolLeaseRecommendation | Promise<PoolLeaseRecommendation>; kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; pollMs?: number; hostLease?: HostPoolLease; dependencyMerged?: (after: PodLeasePredecessor, signal?: AbortSignal) => PredecessorState | boolean | Promise<PredecessorState | boolean> } = {}) {
+  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> } = {}) {
     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);
@@ -167,6 +195,7 @@ export class PodPoolScheduler {
       return recommendConcurrency(measure, { capacity: members.reduce((n, m) => n + m.capacity, 0), accounts: 0, perAccount: 0 });
     });
     this.measure = async () => measureStatus();
+    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();
       this.lastRaw = measured;
@@ -241,13 +270,45 @@ export class PodPoolScheduler {
   admissionSnapshot(): ReturnType<PodLeaseAdmission['snapshot']> {
     return this.admission.snapshot();
   }
-  /** 자리가 있으면 그 노드를 잡고 돌려준다. 없으면 null. */
-  tryAcquire(): PodPoolMember | null {
+  /**
+   * Pick the member with the largest free share: (capacity − measured cluster occupancy − this process's inflight) / capacity.
+   * POOL-SPREAD (10-06): comparing absolute free slots always picked the big member (node-b 25 vs node-c 4), so the small
+   * member idled until the big one was full. Comparing the free share fills members in proportion to their capacity.
+   * 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> {
+    let reading: Record<string, MemberOccupancy>;
+    try { reading = await this.occupancy(); }
+    catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      reading = Object.fromEntries(this.members.map((m) => [m.context, { occupied: null, reason }]));
+    }
+    const free: Record<string, number> = {};
+    const measured: Record<string, boolean> = {};
+    let best: { member: PodPoolMember; slots: number; measured: boolean } | null = null;
+    // A measured member always beats an unmeasured one (its share would read 100% and draw every Job to a node
+    // that did not answer); unmeasured members compete only when no measured member has a free slot.
+    const better = (cand: { member: PodPoolMember; slots: number; measured: boolean }) => !best
+      || (cand.measured !== best.measured ? cand.measured
+        : cand.slots / cand.member.capacity > best.slots / best.member.capacity);
     for (const m of this.members) {
-      const n = this.inflight.get(m.context) ?? 0;
-      if (n < m.capacity) { this.inflight.set(m.context, n + 1); return m; }
+      const inflight = this.inflight.get(m.context) ?? 0;
+      const row = reading[m.context];
+      const ok = !!row && row.occupied !== null;
+      measured[m.context] = ok;
+      const occupied = ok ? row.occupied! : 0;
+      const slots = m.capacity - occupied - inflight;
+      free[m.context] = slots;
+      if (slots <= 0) continue;
+      const cand = { member: m, slots, measured: ok };
+      if (better(cand)) best = cand;
     }
-    return null;
+    if (!best) 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 });
+    return best.member;
   }
   release(member: PodPoolMember): void {
     this.inflight.set(member.context, Math.max(0, (this.inflight.get(member.context) ?? 0) - 1));

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

@@ -1,8 +1,10 @@
 /** Pod Job 원천 단계 — default clone · 커밋 · PR · 호스트 번들.
  *  sha·PR·커밋은 형식 검사 전에 스크립트에 넣지 않는다(셸 주입 차단). */
 
+import { execFileSync } from 'node:child_process';
+
 export type PodSource =
-  | { kind: 'default' }
+  | { kind: 'default'; base?: string }
   | { kind: 'commit'; sha: string }
   | { kind: 'pr'; number: number }
   | { kind: 'bundle'; bundlePath: string; sha256: string; sizeBytes: number; headCommit: string };
@@ -29,6 +31,27 @@ function assertSize(value: number): number {
   return value;
 }
 
+/** Check the requested branch on origin before creating a Pod Job, not in the launched job. */
+function assertRemoteBase(repoUrl: string, base: string): void {
+  if (base.startsWith('-') || base === 'HEAD') throw new Error(`invalid Pod base ref: ${base}`);
+  try {
+    execFileSync('git', ['check-ref-format', '--branch', base], { stdio: 'pipe' });
+  } catch {
+    throw new Error(`invalid Pod base ref: ${base}`);
+  }
+  try {
+    const advertised = execFileSync('git', ['ls-remote', '--exit-code', '--heads', repoUrl, `refs/heads/${base}`], {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+    const [sha, ref] = advertised.split('\t');
+    if (!/^[0-9a-f]{40,64}$/.test(sha ?? '') || ref !== `refs/heads/${base}`) {
+      throw new Error('origin did not advertise the requested branch');
+    }
+  } catch {
+    throw new Error(`Pod base ref not found on origin: ${base}`);
+  }
+}
+
 /** Job 스크립트의 원천 단계. 성공 갈래는 `ELANOUS_POD_SOURCE <kind> <HEAD>` 로 끝난다. */
 export function podSourceScript(source: PodSource, repoUrl: string, mirrorPath = '/host-mirror'): string {
   const quotedUrl = `'${repoUrl.replace(/'/g, `'\\''`)}'`;
@@ -48,6 +71,19 @@ export function podSourceScript(source: PodSource, repoUrl: string, mirrorPath =
     'cd repo || exit 5',
   ];
   if (source.kind === 'default') {
+    if (source.base && source.base !== 'main') {
+      assertRemoteBase(repoUrl, source.base);
+      const base = source.base;
+      const quote = (value: string) => `'${value.replace(/'/g, `'\\''`)}'`;
+      const quotedTrackingRef = quote(`refs/remotes/origin/${base}`);
+      return [
+        ...start,
+        `git fetch --depth 50 origin ${quote(`+refs/heads/${base}:refs/remotes/origin/${base}`)} || exit 5`,
+        `git checkout -q -B ${quote(base)} ${quotedTrackingRef} || exit 5`,
+        'head=$(git rev-parse HEAD)',
+        "printf 'ELANOUS_POD_SOURCE default %s\\n' \"$head\"",
+      ].join('\n');
+    }
     return [
       ...start,
       'if [ "$source_via" = mirror ]; then',