elanous 0.2.14 → 0.2.15

package/src/task-orchestrator/surfaces/pod-artifact-return.ts

@@ -1,9 +1,9 @@
-import { lstatSync, mkdirSync, writeFileSync } from 'node:fs';
+import { lstatSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { gunzipSync } from 'node:zlib';
 import { debug } from '../../debug/log.js';
 import { getDefaultLogStore, type LogStore } from '../../mss/logging/log-store.js';
-import type { LogRecord } from '../../mss/logging/record.js';
+import { fromJsonl, type LogRecord } from '../../mss/logging/record.js';
 
 const FILE_LIMIT = 5 * 1024 * 1024;
 const TOTAL_LIMIT = 20 * 1024 * 1024;
@@ -83,50 +83,58 @@ export function parsePodArtifactChunks(logs: string): ParseResult {
 
 const POD_LOGS_PATH = 'pod-logs/logs.jsonl';
 
-function childRunId(data: unknown): string | undefined {
-  if (!data || typeof data !== 'object' || Array.isArray(data)) return undefined;
-  const value = (data as Record<string, unknown>).runId;
-  return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-
-function decisionRecord(line: string): { rec: LogRecord; surface: string } | undefined {
-  let parsed: unknown;
-  try { parsed = JSON.parse(line); } catch { return undefined; }
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return undefined;
-  const row = parsed as Record<string, unknown>;
-  if (row.category !== 'harness.decision') return undefined;
-  if (typeof row.ts !== 'string' || typeof row.event !== 'string') return undefined;
-  const runId = childRunId(row.data);
-  if (!runId) return undefined;
-  const data = { ...(row.data as Record<string, unknown>), podJob: '', importedFrom: 'pod' as const };
-  return {
-    rec: {
-      ts: row.ts,
-      category: 'harness.decision',
-      event: row.event,
-      data,
-      ...(typeof row.level === 'string' ? { level: row.level as LogRecord['level'] } : {}),
-      ...(typeof row.trace_id === 'string' ? { trace_id: row.trace_id } : {}),
-    },
-    surface: typeof row.surface === 'string' && row.surface ? row.surface : 'pod',
-  };
+/** Last measured child ledger context when a failed Pod emitted no terminal JSON. */
+export function podNoResultDiagnostic(ledger: string): string | null {
+  let stage: string | undefined;
+  let round: number | undefined;
+  let mustFix: string | undefined;
+  for (const line of ledger.split(/\r?\n/)) {
+    try {
+      const entry = JSON.parse(line) as { event?: unknown; data?: Record<string, unknown> };
+      if (!entry || typeof entry !== 'object' || !entry.data || typeof entry.data !== 'object' || typeof entry.event !== 'string' || entry.event === 'pod-ledger-incomplete') continue;
+      if (typeof entry.data.round === 'number' && Number.isSafeInteger(entry.data.round)) round = entry.data.round;
+      if (entry.event !== 'run-origin') stage = entry.event;
+      // `reviewed` carries pointers only (count + finding ids); the text stays in the review artifact.
+      if (entry.event === 'reviewed' && typeof entry.data.mustFix === 'number') {
+        const ids = Array.isArray(entry.data.findingIds) ? entry.data.findingIds.filter((id): id is string => typeof id === 'string') : [];
+        mustFix = `${entry.data.mustFix}${ids.length ? ` ${JSON.stringify(ids)}` : ''}`;
+      }
+    } catch { /* incomplete ledger line */ }
+  }
+  return stage ? `child terminal result missing; last ledger stage=${stage}; round=${round ?? 'unknown'}; mustFix=${mustFix ?? 'unknown'}` : null;
 }
 
-/** Import only harness.decision rows from a returned pod log into the launching host store. */
-export function importPodDecisionLogs(bytes: Buffer, job: string, store: LogStore | null = getDefaultLogStore()): { imported: number; skipped: number } {
+/** Import valid JSONL log records into the launching host store, with durable per-job line receipts. */
+export function importPodLogs(bytes: Buffer, job: string, store: LogStore | null = getDefaultLogStore()): { imported: number; skipped: number } {
   if (!store) return { imported: 0, skipped: 0 };
-  const text = bytes.toString('utf8');
-  const rows: Array<{ rec: LogRecord; surface: string }> = [];
+  const rows: Array<{ rec: LogRecord; surface: string; line: number }> = [];
   let skipped = 0;
-  for (const line of text.split(/\r?\n/)) {
+  for (const [lineNumber, line] of bytes.toString('utf8').split(/\r?\n/).entries()) {
     if (!line) continue;
-    const row = decisionRecord(line);
-    if (!row) { skipped += 1; continue; }
-    row.rec.data = { ...(row.rec.data as Record<string, unknown>), podJob: job };
-    rows.push(row);
+    const rec = fromJsonl(line);
+    if (!rec || !Number.isFinite(Date.parse(rec.ts))) { skipped++; continue; }
+    const data = rec.data && typeof rec.data === 'object' && !Array.isArray(rec.data)
+      ? rec.data as Record<string, unknown>
+      : rec.data === undefined ? {} : { originalData: rec.data };
+    const surface = (rec as LogRecord & { surface?: unknown }).surface;
+    rows.push({
+      rec: { ...rec, data: { ...data, origin: 'pod', podJob: job } },
+      surface: typeof surface === 'string' && surface ? surface : 'pod',
+      line: lineNumber,
+    });
+  }
+  return { imported: store.insertPodBatch(job, rows), skipped };
+}
+
+function importReturnedLogs(bytes: Buffer, job: string, store: LogStore | null,
+  log: (category: string, event: string, data: Record<string, unknown>) => void): void {
+  try {
+    if (!store) throw new Error('host log store unavailable');
+    const imported = importPodLogs(bytes, job, store);
+    log('self-implement.pod', 'pod-logs-imported', { job, imported: imported.imported, skipped: imported.skipped });
+  } catch (error) {
+    debug.log('self-implement.pod', 'pod-logs-import-failed', { job, reason: error instanceof Error ? error.message : String(error) });
   }
-  if (rows.length > 0) store.insertBatch(rows);
-  return { imported: rows.length, skipped };
 }
 
 /** Reject symlink parents as well as lexical traversal; never replace a host file. */
@@ -176,17 +184,24 @@ export function collectPodArtifacts(logs: string, { dir, job, log = (c, e, d) =>
         podLogsReturned = true;
         const lines = bytes.length ? bytes.toString('utf8').split('\n').length - (bytes.at(-1) === 10 ? 1 : 0) : 0;
         log('self-implement.pod', 'pod-logs-returned', { job, path: destination, lines });
-        try {
-          const imported = importPodDecisionLogs(bytes, job, logStore);
-          log('self-implement.pod', 'pod-decisions-imported', { job, imported: imported.imported, skipped: imported.skipped });
-        } catch (error) {
-          log('self-implement.pod', 'pod-logs-import-failed', { job, reason: error instanceof Error ? error.message : String(error) });
-        }
+        importReturnedLogs(bytes, job, logStore, log);
       }
     } catch (e) {
       const reason = (e as NodeJS.ErrnoException).code === 'EEXIST' ? 'exists' : e instanceof Error ? e.message : String(e);
-      if ((e as NodeJS.ErrnoException).code === 'EEXIST') log('self-implement.pod', 'artifact-collect-skipped', { job, path, reason });
-      else log('self-implement.pod', 'artifact-collect-incomplete', { job, path, reason });
+      if ((e as NodeJS.ErrnoException).code === 'EEXIST') {
+        log('self-implement.pod', 'artifact-collect-skipped', { job, path, reason });
+        if (path === podLogsPath) {
+          try {
+            const existing = resolve(dir, job, path);
+            if (!lstatSync(existing).isSymbolicLink() && readFileSync(existing).equals(bytes)) {
+              podLogsReturned = true;
+              importReturnedLogs(bytes, job, logStore, log);
+            }
+          } catch (error) {
+            debug.log('self-implement.pod', 'pod-logs-import-failed', { job, reason: error instanceof Error ? error.message : String(error) });
+          }
+        }
+      } else log('self-implement.pod', 'artifact-collect-incomplete', { job, path, reason });
       if (path === podLogsPath) podLogsMissingReason = reason;
     }
   }

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-pool.ts

@@ -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,36 @@ export class PodPoolScheduler {
   admissionSnapshot(): ReturnType<PodLeaseAdmission['snapshot']> {
     return this.admission.snapshot();
   }
-  /** 자리가 있으면 그 노드를 잡고 돌려준다. 없으면 null. */
-  tryAcquire(): PodPoolMember | null {
+  /**
+   * Pick the member with the most free slots: capacity − measured cluster occupancy − this process's inflight.
+   * 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 } | null = null;
     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;
+      if (!best || slots > best.slots) best = { member: m, slots };
     }
-    return null;
+    if (!best) return null;
+    this.inflight.set(best.member.context, (this.inflight.get(best.member.context) ?? 0) + 1);
+    debug.log('pod.pool', 'member-selected', { member: best.member.context, free, measured });
+    return best.member;
   }
   release(member: PodPoolMember): void {
     this.inflight.set(member.context, Math.max(0, (this.inflight.get(member.context) ?? 0) - 1));