elanous 0.2.19 → 0.2.20

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

@@ -44,8 +44,12 @@ export interface TaskCard {
   goal?: string;
   milestone?: string;
   createdAt: string;
-  /** launch-failed = 발사기가 띄우기에 실패했다(사유는 history 마지막 칸) — 다음 수는 다시 발사. */
-  status: 'handed' | 'launched' | 'launch-failed';
+  /**
+   * launch-failed = 발사기가 띄우기에 실패했다(사유는 history 마지막 칸) — 다음 수는 다시 발사.
+   * failed = 발사된 런이 PR·수확 가지 없이 죽었거나 끝내 안 떴다(TA-JUDGE-DEAD-RUN · `card-evidence.ts`) — 사유
+   * (`failed/needs-owner|needs-relaunch — …`)는 history 마지막 칸 · 자동 재발사하지 않는다(사람/판단부 몫).
+   */
+  status: 'handed' | 'launched' | 'launch-failed' | 'failed';
   history: TaskCardEvent[];
   /** 미션 카드만 — 조각 카드 id(순서대로) · 쪼갠 출처(`mission.ts` splitMission). */
   pieces?: string[];
@@ -178,6 +182,7 @@ export function nextMoveFor(card: TaskCard, landed?: ReadonlySet<string>): TaskC
   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: '직전 발사 실패 — 다시 발사' };
+  if (card.status === 'failed') return { kind: 'wait', reason: card.history.at(-1)?.detail ?? '런 실패 — PR·수확 가지 없음' };
   return { kind: 'wait', reason: '발사됨 — 런 멈춤을 슈퍼바이저 그림자 판단(task-agent.shadow-move)이 받는다' };
 }
 

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

@@ -14,6 +14,7 @@ import { debug } from '../../debug/log.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { collectPodArtifacts } from './pod-artifact-return.js';
 import { podBunCacheVolume } from './pod-bun-cache.js';
+import { podHostDirsInit, podInstallSlotsVolume } from './pod-install-slots.js';
 import { type PodPoolMember, PodPoolScheduler, resolvePodPoolSpec, parsePodPool, checkPodPool, syncPoolImages, type PoolKubectl } from './pod-pool.js';
 import { podSkillsDigest, readSkillEnvFiles, resolvePodSkills } from './pod-skills.js';
 import { podSourceScript, type PodSource } from './pod-source-receive.js';
@@ -176,6 +177,8 @@ export interface PodCommandJobInput {
   clone?: boolean;
   hostMirror?: string;
   bunCache?: string;
+  /** GATE-INSTALL-CACHE — hostPath of the node-wide install tokens (release gate shards only · `pod-install-slots.ts`). */
+  installSlots?: string;
   /** 컨테이너 메모리 한도(기본 16Gi) — 게이트가 파일 하나 격리 Job 에 올린다. */
   memoryLimit?: string;
   /** GATE-SPEED A3①: CPU request/limit override (release gate shards only). Omitted = request 1 / limit 4. */
@@ -197,6 +200,9 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
   }
   const grok = o.llm === 'grok';
   const bunCache = o.bunCache ? podBunCacheVolume(o.bunCache) : undefined;
+  const installSlots = o.installSlots ? podInstallSlotsVolume(o.installSlots) : undefined;
+  // hostPath directories the uid-1000 child writes: a root init container hands them over (DirectoryOrCreate is root 0755).
+  const hostDirMounts = [...(bunCache ? [bunCache.volumeMount] : []), ...(installSlots ? [installSlots.volumeMount] : [])];
   const cpu = resolvePodCpu(o.cpu);
   const quotedArgs = o.command.map(bashSingleQuote).join(' ');
   const credLines = [
@@ -233,7 +239,10 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
         spec: {
           restartPolicy: 'Never',
           securityContext: { runAsUser: 1000, fsGroup: 1000 },
-          initContainers: [{ name: 'isolation-gate', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never', command: ['bash', '-c'], args: [GATE] }],
+          initContainers: [
+            { name: 'isolation-gate', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never', command: ['bash', '-c'], args: [GATE] },
+            ...(hostDirMounts.length ? [podHostDirsInit(o.image, o.imagePullPolicy ?? 'Never', hostDirMounts)] : []),
+          ],
           containers: [{
             name: 'child', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never',
             resources: { requests: { ...POD_CHILD_REQUESTS, cpu: cpu.request, memory: memoryRequestWithin(o.memoryLimit) }, limits: { memory: o.memoryLimit ?? '16Gi', cpu: cpu.limit } },
@@ -243,16 +252,17 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
               { name: 'ELANOUS_SUBSTRATE', value: 'pod' },
               { name: 'ELANOUS_POD_NAME', valueFrom: { fieldRef: { fieldPath: 'metadata.name' } } },
             ],
-            ...(secretKeys || o.hostMirror || bunCache ? { volumeMounts: [
+            ...(secretKeys || o.hostMirror || hostDirMounts.length ? { volumeMounts: [
               ...(secretKeys ? [{ name: 'creds', mountPath: '/creds', readOnly: true }] : []),
               ...(o.hostMirror ? [{ name: 'host-mirror', mountPath: '/host-mirror', readOnly: true }] : []),
-              ...(bunCache ? [bunCache.volumeMount] : []),
+              ...hostDirMounts,
             ] } : {}),
           }],
-          ...(secretKeys || o.hostMirror || bunCache ? { volumes: [
+          ...(secretKeys || o.hostMirror || hostDirMounts.length ? { volumes: [
             ...(secretKeys ? [{ name: 'creds', secret: { secretName: `${o.name}-creds`, defaultMode: 0o400 } }] : []),
             ...(o.hostMirror ? [{ name: 'host-mirror', hostPath: { path: o.hostMirror, type: 'Directory' } }] : []),
             ...(bunCache ? [bunCache.volume] : []),
+            ...(installSlots ? [installSlots.volume] : []),
           ] } : {}),
         },
       },
@@ -321,6 +331,8 @@ export interface RunPodCommandOptions {
   clone?: boolean;
   hostMirror?: string;
   bunCache?: string;
+  /** GATE-INSTALL-CACHE — hostPath of the node-wide install tokens (absolute). */
+  installSlots?: string;
   /** 컨테이너 메모리 한도(기본 16Gi · lite 면 2Gi). */
   memoryLimit?: string;
   /** GATE-SPEED A3①: CPU request/limit override — only the release gate passes it. Omitted = request 1 / limit 4. */
@@ -410,6 +422,8 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
   if (hostMirror && !isAbsolute(hostMirror)) throw new Error('pod.hostMirror must be an absolute directory path');
   const bunCache = options.bunCache?.trim() || undefined;
   if (bunCache && !isAbsolute(bunCache)) throw new Error('pod.bunCache must be an absolute directory path');
+  const installSlots = options.installSlots?.trim() || undefined;
+  if (installSlots && !isAbsolute(installSlots)) throw new Error('pod installSlots must be an absolute directory path');
   // Fail before any Secret/Job is applied — a bad quantity must not reach the cluster.
   if (options.cpu) resolvePodCpu(options.cpu);
 
@@ -486,7 +500,7 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       name, namespace, launch, image: imageRef ?? image,
       ...(imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}),
       repoUrl, command, skills, ...(llm ? { llm } : {}), ...(options.clone ? { clone: true } : {}),
-      ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), ...(bunCache ? { bunCache } : {}), ...(memoryLimit ? { memoryLimit } : {}), ...(options.cpu ? { cpu: options.cpu } : {}), deadlineSeconds,
+      ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), ...(bunCache ? { bunCache } : {}), ...(installSlots ? { installSlots } : {}), ...(memoryLimit ? { memoryLimit } : {}), ...(options.cpu ? { cpu: options.cpu } : {}), deadlineSeconds,
       ...(options.runId ? { runId: options.runId } : {}),
     });
     kubectl(['-n', namespace, 'delete', 'job', '-l', own, '--ignore-not-found']);

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

@@ -1,3 +1,7 @@
+/** STOP-RECORD stop_class values used by the card terminal classifier. */
+export const STOP_CLASS_POD_FAILURE = 'pod-failure' as const;
+export const STOP_CLASS_NO_LAUNCH = 'no-launch' as const;
+
 /** Executor kinds of the dev child's `--json` result line (`src/index.ts` writeStdoutJson · DevExecutor.kind). */
 const CHILD_RESULT_KINDS = new Set(['self', 'external']);
 

package/src/task-orchestrator/surfaces/pod-install-slots.ts

@@ -0,0 +1,89 @@
+// GATE-INSTALL-CACHE (0.2.20) — a node-wide throttle for the release-gate shards' `bun install`.
+//
+// Cause, measured on the 0.2.19 gate (`elanous logs --category release-loop.gate --event pod-shard --all --include-test`):
+//   · no cache is «not» the cause — the harness image carries a warm Bun cache, and a Pod that installed alone
+//     (10-07 10:48–10:55 · 12:13 · 12:16) took 2.4–5.0 s with `pod-bun-cache source=none`;
+//   · the same install took 150–340 s when 24 shard Pods (or ~20 isolation Pods) started together on the one 32-CPU
+//     node-b node (09:3x round 1: 221–337 s · 11:4x round 3: 150–240 s · 10:34 isolation wave: 124–188 s).
+//   ⇒ concurrent installs thrash the node (24 × copying node_modules out of the image cache + CPU), so a shared
+//   hostPath Bun cache would not help (the bytes are already local) — fewer installs «at once» does.
+//
+// Concurrency safety: the hostPath holds only throttle tokens (`slot-<n>` directories), never packages. Each Pod still
+// installs into its own container (its own node_modules, its own image-local Bun cache), so correctness never depends on
+// the token: a lost token (Pod killed mid-install) only lowers throughput until it goes stale (`staleSeconds`), a doubled
+// token (two waiters reclaiming one stale slot in the same instant) only lets one extra install run, and a waiter that
+// cannot get a token within `waitSeconds` — or finds the directory unwritable — installs anyway (fail-open).
+// `mkdir` is atomic on one filesystem, and every Pod on a node sees the same hostPath directory.
+
+/** Default hostPath of the install tokens on each gate node. */
+export const POD_INSTALL_SLOTS_HOST_PATH = '/var/lib/elanous/gate-install-slots';
+/** Default concurrent installs per node (`release.loop.gatePodInstallSlots` · 0 = off). Alone ≈ 3–5 s ⇒ 24 shards ≈ 6 waves. */
+export const POD_INSTALL_SLOTS_DEFAULT = 4;
+export const POD_INSTALL_SLOTS_MOUNT = '/gate-install-slots';
+
+/** hostPath volume ⊕ mount for the tokens. `DirectoryOrCreate` makes a root-owned 0755 directory, so the Pod also needs
+ *  {@link podHostDirsInit} (the child runs as uid 1000). */
+export function podInstallSlotsVolume(hostPath: string = POD_INSTALL_SLOTS_HOST_PATH) {
+  return {
+    volume: { name: 'install-slots', hostPath: { path: hostPath, type: 'DirectoryOrCreate' } },
+    volumeMount: { name: 'install-slots', mountPath: POD_INSTALL_SLOTS_MOUNT, readOnly: false },
+  };
+}
+
+/**
+ * A root init container that hands the mounted hostPath directories to the child's uid. Without it a `DirectoryOrCreate`
+ * hostPath stays root:root 0755 and the child's `[ -w … ]` guard silently skips it (the Bun cache option was a no-op).
+ */
+export function podHostDirsInit(image: string, imagePullPolicy: string, mounts: ReadonlyArray<{ name: string; mountPath: string; readOnly: boolean }>) {
+  const paths = mounts.map((mount) => `'${mount.mountPath.replace(/'/g, `'\\''`)}'`).join(' ');
+  return {
+    name: 'host-dirs', image, imagePullPolicy,
+    securityContext: { runAsUser: 0 },
+    command: ['sh', '-c'],
+    // Never fails the Pod: an unchanged directory only means the child falls back (no cache · no throttle).
+    args: [`for d in ${paths}; do mkdir -p "$d" && chown 1000:1000 "$d" && chmod 0775 "$d" || echo "[host-dirs] could not prepare $d"; done; exit 0`],
+    volumeMounts: mounts.map((mount) => ({ ...mount })),
+  };
+}
+
+const int = (value: number, label: string) => {
+  if (!Number.isSafeInteger(value) || value < 1) throw new Error(`invalid ${label}: ${value}`);
+  return value;
+};
+
+/**
+ * Bash that defines `install_slot_acquire` / `install_slot_release`. Acquire waits for one of `slots` tokens under `dir`
+ * (polling every `pollSeconds`, default 2 s), reclaims a token older than `staleSeconds` (minute granularity), and gives up after `waitSeconds` (install runs anyway).
+ * It prints `[gate] install-slot <n> waited <s>s` or `[gate] install-slot none …` for the shard log.
+ */
+export function installSlotScript(o: { dir?: string; slots: number; waitSeconds?: number; staleSeconds?: number; pollSeconds?: number }): string {
+  const dir = `'${(o.dir ?? POD_INSTALL_SLOTS_MOUNT).replace(/'/g, `'\\''`)}'`;
+  const slots = int(o.slots, 'install slots');
+  const wait = int(o.waitSeconds ?? 600, 'install slot wait');
+  const poll = o.pollSeconds ?? 2;
+  if (!Number.isFinite(poll) || poll <= 0 || poll > 60) throw new Error(`invalid install slot poll: ${poll}`);
+  const staleMinutes = Math.max(1, Math.ceil(int(o.staleSeconds ?? 900, 'install slot stale age') / 60));
+  return [
+    'install_slot=',
+    'install_slot_acquire() {',
+    `  local d=${dir} t0 now n`,
+    '  t0=$(date +%s)',
+    '  if [ ! -d "$d" ] || [ ! -w "$d" ]; then echo "[gate] install-slot none (directory not writable)"; return 0; fi',
+    '  while :; do',
+    `    for n in $(seq 0 ${slots - 1}); do`,
+    '      if mkdir "$d/slot-$n" 2>/dev/null; then',
+    '        install_slot="$d/slot-$n"',
+    '        echo "[gate] install-slot $n waited $(( $(date +%s) - t0 ))s"; return 0',
+    '      fi',
+    // A token whose holder died (directory mtime older than the stale age · `find -mmin` is the same on GNU and BSD) is
+    // renamed away first (rename is atomic: one reclaimer wins) and the slot is tried again on the next pass.
+    `      if [ -n "$(find "$d/slot-$n" -maxdepth 0 -mmin +${staleMinutes} 2>/dev/null)" ]; then mv "$d/slot-$n" "$d/stale-$n-$$" 2>/dev/null && rm -rf "$d/stale-$n-$$"; fi`,
+    '    done',
+    '    now=$(date +%s)',
+    `    if [ $(( now - t0 )) -ge ${wait} ]; then echo "[gate] install-slot none (waited $(( now - t0 ))s)"; return 0; fi`,
+    `    sleep ${poll}`,
+    '  done',
+    '}',
+    'install_slot_release() { if [ -n "$install_slot" ]; then rm -rf "$install_slot"; install_slot=; fi; }',
+  ].join('\n');
+}

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

@@ -52,6 +52,18 @@ export interface PodLeaseMember {
    */
   harnessUsageBytes?: number[] | null;
   usageReason?: string | null;
+  /** GATE-RESERVE-AUTO — non-terminal release-gate shard Jobs (`gate-<uuid>`, kind=command). */
+  gateJobs?: number | null;
+  /** GATE-RESERVE-AUTO — of those, Jobs whose Pod is not bound to a node yet (not created, or Pending unscheduled). */
+  gateUnboundJobs?: number | null;
+  /** GATE-RESERVE-AUTO — CPU requested by the non-terminal gate Jobs' Pod templates (observability; Infinity: unreadable). */
+  gateCpuMillicores?: number | null;
+  /** GATE-RESERVE-AUTO — allocatable CPU of the schedulable (Ready, untainted, cordon-free) nodes. */
+  schedulableCpuMillicores?: number | null;
+  /** GATE-RESERVE-AUTO — per schedulable node: allocatable CPU − requests of every non-terminal Pod bound to it (gate Pods too). */
+  cpuFreeByNodeMillicores?: number[] | null;
+  /** GATE-RESERVE-AUTO — CPU requested by harness Pods still waiting for a node (they take CPU somewhere once bound). */
+  pendingHarnessCpuMillicores?: number | null;
   /** Pool-wide harness reservation: Σ min(limit, max(request, usage×1.5)), or max(request, limit) when the Pod's usage is unmeasured. */
   memoryReservedBytes?: number | null;
   /** Parallel to availableMemoryByNodeBytes: each schedulable node's allocatable memory. */
@@ -138,16 +150,19 @@ function object(value: unknown): Record<string, unknown> | null {
   return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null;
 }
 
-/** Effective scheduling reservation: max(sum of app requests, largest init request, Pod-level request) + overhead. */
-function requestedMemory(spec: Record<string, unknown>): number | null {
+/**
+ * Effective scheduling reservation: max(sum of app requests, largest init request, Pod-level request) + overhead.
+ * A container without a request reserves its limit (Kubernetes defaults the request to the limit), or 0 with neither.
+ */
+function requestedResource(spec: Record<string, unknown>, unit: 'memory' | 'cpu'): number | null {
   const request = (resources: unknown): number | null => {
     const r = object(resources);
     if (resources !== undefined && !r) return null;
     const requests = object(r?.requests);
     const limits = object(r?.limits);
     if ((r?.requests !== undefined && !requests) || (r?.limits !== undefined && !limits)) return null;
-    const raw = requests?.memory ?? limits?.memory;
-    return raw === undefined ? 0 : typeof raw === 'string' ? quantity(raw, 'memory') : null;
+    const raw = requests?.[unit] ?? limits?.[unit];
+    return raw === undefined ? 0 : typeof raw === 'string' ? quantity(raw, unit) : null;
   };
   const containers = spec.containers;
   if (!Array.isArray(containers) || !containers.length) return null;
@@ -167,12 +182,16 @@ function requestedMemory(spec: Record<string, unknown>): number | null {
     init = Math.max(init, v);
   }
   const pod = spec.resources === undefined ? 0 : request(spec.resources);
-  const overheadRaw = object(spec.overhead)?.memory;
+  const overheadRaw = object(spec.overhead)?.[unit];
   const overhead = spec.overhead !== undefined && !object(spec.overhead) ? null
-    : overheadRaw === undefined ? 0 : typeof overheadRaw === 'string' ? quantity(overheadRaw, 'memory') : null;
+    : overheadRaw === undefined ? 0 : typeof overheadRaw === 'string' ? quantity(overheadRaw, unit) : null;
   return pod === null || overhead === null ? null : Math.max(app, init, pod) + overhead;
 }
 
+const requestedMemory = (spec: Record<string, unknown>): number | null => requestedResource(spec, 'memory');
+/** GATE-RESERVE-AUTO — the CPU the scheduler reserves for a Pod (same rule as memory). */
+const requestedCpu = (spec: Record<string, unknown>): number | null => requestedResource(spec, 'cpu');
+
 function runningLimit(spec: Record<string, unknown>): number | null {
   if (!Array.isArray(spec.containers) || !spec.containers.length) return null;
   let total = 0;
@@ -325,6 +344,8 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
       };
       const nodeItems = parsedItems(nodes);
       const nodeFree = new Map<string, number>();
+      let schedulableCpu = 0;
+      const nodeCpuFree = new Map<string, number>();
       const nodeNames = new Set<string>();
       if (!nodeItems?.length) reasons.push(`cluster nodes: ${nodes.status === 0 ? 'invalid/empty response' : nodes.stderr.trim().split('\n').pop() || `rc=${nodes.status}`}`);
       else {
@@ -350,11 +371,11 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
           }
           nodeNames.add(name);
           const repels = taintList.some((t) => t!.effect === 'NoSchedule' || t!.effect === 'NoExecute');
-          if (spec?.unschedulable !== true && !repels && object(ready[0])?.status === 'True') { nodeFree.set(name, mem); nodeAllocatable.set(name, mem); }
+          if (spec?.unschedulable !== true && !repels && object(ready[0])?.status === 'True') { nodeFree.set(name, mem); nodeAllocatable.set(name, mem); nodeCpuFree.set(name, cores); schedulableCpu += cores; }
           memory += mem; cpu += cores;
         }
-        if (valid) { result.allocatableMemoryBytes = memory; result.allocatableCpuMillicores = cpu; }
-        else { nodeFree.clear(); nodeAllocatable.clear(); nodeNames.clear(); reasons.push('cluster nodes: invalid name/allocatable memory/cpu/readiness'); }
+        if (valid) { result.allocatableMemoryBytes = memory; result.allocatableCpuMillicores = cpu; result.schedulableCpuMillicores = schedulableCpu; }
+        else { nodeFree.clear(); nodeAllocatable.clear(); nodeCpuFree.clear(); nodeNames.clear(); reasons.push('cluster nodes: invalid name/allocatable memory/cpu/readiness'); }
       }
       // POD-ADMIT-BY-USAGE: every schedulable node needs a real-usage reading, or the member stays on limits.
       const unreadNode = podUsage && nodeUsage ? [...nodeFree.keys()].find((n) => !nodeUsage!.has(n)) : undefined;
@@ -366,6 +387,8 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
       if (podItems && jobItems) {
         const jobNames = new Set<string>();
         const leasedJobs = new Set<string>();
+        const gateJobs = new Map<string, number>();
+        const boundGateJobs = new Set<string>();
         let jobsValid = true;
         for (const job of jobItems) {
           const meta = object(job.metadata);
@@ -373,12 +396,27 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
           if (object(meta.labels)?.['elanous.substrate'] !== 'pod') continue;
           if (typeof meta.name !== 'string' || !meta.name) { jobsValid = false; continue; }
           jobNames.add(meta.name);
+          // GATE-RESERVE-AUTO: a release-gate shard Job (`gate-<uuid>`, kind=command) reserves its Pod template's CPU
+          // from creation until it is terminal — also while its Pod is still Pending or not created yet.
+          if (meta.name.startsWith('gate-') && object(meta.labels)?.['elanous.kind'] === 'command') {
+            const status = object(job.status);
+            const conditions = Array.isArray(status?.conditions) ? status.conditions as unknown[] : [];
+            const terminal = !!status?.completionTime || Number(status?.succeeded) > 0 ||
+              conditions.some((c) => (object(c)?.type === 'Failed' || object(c)?.type === 'Complete') && object(c)?.status === 'True');
+            if (!terminal) {
+              const spec = object(object(object(job.spec)?.template)?.spec);
+              // An unreadable request cannot be reserved as 0: it blocks harness admission until the gate ends.
+              gateJobs.set(meta.name, (spec ? requestedCpu(spec) : null) ?? Number.POSITIVE_INFINITY);
+            }
+          }
           if (object(meta.annotations)?.[POD_HOST_LEASE_ANNOTATION] === 'true') leasedJobs.add(meta.name);
         }
         if (!jobsValid) reasons.push('cluster jobs: missing name/labels');
         let running = 0, pending = 0, unleasedRunning = 0, limits = 0, reserved = 0, limitsValid = true, reservationsValid = nodeItems !== null && nodeNames.size === nodeItems.length;
         const pendingJobs = new Map<string, PendingJobIdentity>();
         let unknownPhase = false;
+        let pendingHarnessCpu = 0;
+        let cpuValid = true;
         const seenPods = new Set<string>();
         for (const pod of podItems) {
           const metadata = object(pod.metadata);
@@ -393,7 +431,9 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
             if (seenPods.has(identity)) { reservationsValid = false; continue; }
             seenPods.add(identity);
           } else reservationsValid = false;
-          const harness = metadata?.namespace === 'elanous-test' && labels?.['elanous.probe'] !== 'dns' &&
+          const ownerJob = String(labels?.['elanous.job'] ?? labels?.['job-name'] ?? '');
+          const gatePod = metadata?.namespace === 'elanous-test' && gateJobs.has(ownerJob);
+          const harness = metadata?.namespace === 'elanous-test' && labels?.['elanous.probe'] !== 'dns' && !gatePod &&
             (labels?.['elanous.substrate'] === 'pod' || jobNames.has(String(labels?.['elanous.job'] ?? '')));
           const spec = object(pod.spec);
           let limit: number | null = null;
@@ -425,6 +465,17 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
           }
           // Pending Pods with no assigned node have no node reservation yet. They already occupy a pool slot.
           const nodeName = spec?.nodeName;
+          // GATE-RESERVE-AUTO: CPU is placed per node (a free core split across two nodes is not one slot). Every Pod
+          // bound to a schedulable node — gate Pods too — takes its request there; harness Pods without a node yet
+          // take CPU somewhere once bound. A gate Pod bound to any node marks its Job as placed.
+          const boundNode = typeof nodeName === 'string' && nodeName !== '' ? nodeName : null;
+          if (gatePod && boundNode !== null && nodeNames.has(boundNode)) boundGateJobs.add(ownerJob);
+          if ((boundNode !== null && nodeCpuFree.has(boundNode)) || (boundNode === null && harness && phase === 'Pending')) {
+            const cpu = spec ? requestedCpu(spec) : null;
+            if (cpu === null) cpuValid = false;
+            else if (boundNode !== null) nodeCpuFree.set(boundNode, nodeCpuFree.get(boundNode)! - cpu);
+            else pendingHarnessCpu += cpu;
+          }
           if ((nodeName === undefined || nodeName === '') && phase === 'Pending' && spec && typeof metadata?.namespace === 'string' &&
               requestedMemory(spec) !== null) continue;
           const requested = spec ? requestedMemory(spec) : null;
@@ -432,6 +483,15 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
           if (nodeFree.has(nodeName)) nodeFree.set(nodeName, nodeFree.get(nodeName)! - Math.max(requested, reserve ?? limit ?? 0));
         }
         if (unknownPhase) reasons.push('cluster pods: missing/Unknown phase');
+        if (jobsValid && !unknownPhase && result.schedulableCpuMillicores !== undefined) {
+          result.gateJobs = gateJobs.size;
+          result.gateUnboundJobs = [...gateJobs.keys()].filter((job) => !boundGateJobs.has(job)).length;
+          result.gateCpuMillicores = [...gateJobs.values()].reduce((sum, cpu) => sum + cpu, 0);
+        }
+        if (cpuValid && !unknownPhase && result.schedulableCpuMillicores !== undefined) {
+          result.cpuFreeByNodeMillicores = [...nodeCpuFree.values()];
+          result.pendingHarnessCpuMillicores = pendingHarnessCpu;
+        }
         if (jobsValid && !unknownPhase) { result.running = running; result.pending = pending; result.pendingJobs = [...pendingJobs.values()]; result.unleasedRunning = unleasedRunning; }
         if (limitsValid && jobsValid && !unknownPhase) {
           result.memoryLimitBytes = limits;
@@ -464,6 +524,29 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
   }) };
 }
 
+/**
+ * GATE-RESERVE-AUTO — while a release-gate shard Job is not terminal, how many more harness Pods (each requesting
+ * `POD_CHILD_REQUESTS.cpu`) fit beside it. The gate gets its CPU first: while any gate shard is still waiting for a
+ * node, no harness Pod is admitted (the scheduler may place new harness Pods where the shard would have gone). Once
+ * every shard is bound its CPU sits on its node, and the answer is Σ per-node ⌊free ÷ request⌋ minus the harness Pods
+ * still waiting for a node. `undefined`: no gate Job is active (normal admission) · `null`: a gate is active but CPU
+ * could not be measured — a Pod's or a gate template's request is unreadable (admit nothing more). The count comes from this one reading, never from earlier ones.
+ */
+export function harnessCpuSlotsBesideGate(measure: PoolLeaseMeasure): number | null | undefined {
+  if (!measure.members.some((m) => (m.gateJobs ?? 0) > 0)) return undefined;
+  const perPod = quantity(POD_CHILD_REQUESTS.cpu, 'cpu')!;
+  let slots = 0;
+  for (const m of measure.members) {
+    if (m.gateJobs == null || m.gateUnboundJobs == null || m.cpuFreeByNodeMillicores == null || m.pendingHarnessCpuMillicores == null) return null;
+    // A gate Job whose Pod template CPU cannot be read is unmeasured even when its Pod is bound (fail closed).
+    if (m.gateCpuMillicores == null || !Number.isFinite(m.gateCpuMillicores)) return null;
+    if (m.gateUnboundJobs > 0) return 0;
+    const placeable = m.cpuFreeByNodeMillicores.reduce((sum, free) => sum + Math.max(0, Math.floor(free / perPod)), 0);
+    slots += Math.max(0, placeable - Math.ceil(m.pendingHarnessCpuMillicores / perPod));
+  }
+  return slots;
+}
+
 /** Per-node memory and per-member slots cannot be exchanged across nodes/clusters. */
 export function recommendConcurrency(measure: PoolLeaseMeasure, options: { capacity: number; perGoalMemory?: string; liteGoalMemory?: string; accounts: number; perAccount: number }): PoolLeaseRecommendation {
   const empty: PoolLeaseRecommendation = { recommended: null, limitedBy: null, reason: null, capacitySlots: null, memorySlots: null, liteMemorySlots: null, placeableSlots: null, accountSlots: null, running: null, pending: null, unleasedRunning: null };