elanous 0.2.10 → 0.2.12

package/src/task-orchestrator/store.ts

@@ -138,6 +138,7 @@ interface MissionRow {
   priority: MissionPriority | null;
   task_ids_json: string;   // JSON array of taskId
   goal_slug: string | null;
+  project_id: string | null;
   notes_json: string;      // JSON array of string
   autopilot_json: string | null;  // JSON MissionAutopilot | null (U1)
 }
@@ -309,6 +310,8 @@ export class TaskStore {
     // Mission Fabric 통합 U1 (v3) — tox_missions.autopilot_json:
     // PFC Layer2 자율 메타(apm Mission 흡수). NULL = 일반 Mission.
     this.addColumnIfMissing('tox_missions', 'autopilot_json', 'TEXT');
+    this.addColumnIfMissing('tox_missions', 'project_id', 'TEXT');
+    this.db.exec('CREATE INDEX IF NOT EXISTS idx_tox_missions_project ON tox_missions(project_id)');
     this.addColumnIfMissing('tox_executions', 'host_id', 'TEXT');
     this.addColumnIfMissing('tox_executions', 'hostname', 'TEXT');
     this.db.exec('CREATE INDEX IF NOT EXISTS idx_tox_executions_host ON tox_executions(host_id, started_at)');
@@ -587,8 +590,8 @@ export class TaskStore {
         `INSERT OR REPLACE INTO tox_missions (
           id, created_at, updated_at, closed_at, title, description, intent,
           source_json, status, priority, task_ids_json, goal_slug, notes_json,
-          autopilot_json
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+          autopilot_json, project_id
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       )
       .run(
         mission.id,
@@ -605,6 +608,7 @@ export class TaskStore {
         mission.goalSlug ?? null,
         JSON.stringify([...mission.notes]),
         mission.autopilot ? JSON.stringify(mission.autopilot) : null,
+        mission.projectId ?? null,
       ));
   }
 
@@ -616,7 +620,7 @@ export class TaskStore {
     return this.rowToMission(row);
   }
 
-  listMissions(opts: { status?: MissionStatus; goalSlug?: string } = {}): Mission[] {
+  listMissions(opts: { status?: MissionStatus; goalSlug?: string; projectId?: string } = {}): Mission[] {
     const where: string[] = [];
     const params: Array<string | number | null> = [];
     if (opts.status !== undefined) {
@@ -627,6 +631,10 @@ export class TaskStore {
       where.push('goal_slug = ?');
       params.push(opts.goalSlug);
     }
+    if (opts.projectId !== undefined) {
+      where.push('project_id = ?');
+      params.push(opts.projectId);
+    }
     const sql =
       'SELECT * FROM tox_missions' +
       (where.length > 0 ? ' WHERE ' + where.join(' AND ') : '') +
@@ -729,6 +737,7 @@ export class TaskStore {
       priority: row.priority ?? undefined,
       taskIds: Object.freeze(JSON.parse(row.task_ids_json) as string[]),
       goalSlug: row.goal_slug ?? undefined,
+      ...(row.project_id != null ? { projectId: row.project_id } : {}),
       notes: Object.freeze(JSON.parse(row.notes_json) as string[]),
       autopilot: row.autopilot_json
         ? (JSON.parse(row.autopilot_json) as Mission['autopilot'])

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

@@ -7,14 +7,14 @@
 
 import { randomBytes } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
-import { isAbsolute } from 'node:path';
+import { isAbsolute, resolve } from 'node:path';
 import { getUserConfig } from '../../user-config.js';
 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 { type PodPoolMember, PodPoolScheduler, resolvePodPoolSpec, parsePodPool, checkPodPool, syncPoolImages, type PoolKubectl } from './pod-pool.js';
-import { readSkillEnvFiles } from './pod-skills.js';
+import { podSkillsDigest, readSkillEnvFiles, resolvePodSkills } from './pod-skills.js';
 import { podSourceScript, type PodSource } from './pod-source-receive.js';
 import {
   POD_CHILD_REQUESTS,
@@ -30,6 +30,24 @@ import {
 /** CLI `--deadline` 생략 시 — 기존 Pod Job 수명 상한과 같다. */
 export const POD_COMMAND_DEADLINE_SECONDS = POD_JOB_DEADLINE_SECONDS;
 
+export const POD_NETWORK_SKILLS = ['omni-crawl', 'omni-digest'] as const;
+export const POD_LITE_IMAGE = 'elanous-harness-lite:local';
+
+export const POD_LITE_MEMORY_LIMIT = '2Gi';
+
+/** 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. */
+export function podCommandImageFor(skills: readonly string[], clone: boolean, lite = false): string {
+  if (!lite) return 'elanous-harness:local';
+  if (clone) throw new Error('pod command: --lite 는 clone 없는 명령만 받는다(lite 이미지는 git·빌드 도구가 적다)');
+  const outside = skills.filter((skill) => !(POD_NETWORK_SKILLS as readonly string[]).includes(skill));
+  if (skills.length === 0 || outside.length > 0) {
+    throw new Error(`pod command: --lite 는 네트워크 스킬(${POD_NETWORK_SKILLS.join('·')})만 받는다${outside.length ? ` — 벗어난 스킬: ${outside.join(', ')}` : ' — --skill 이 없다'}`);
+  }
+  return POD_LITE_IMAGE;
+}
+
 const COMMAND_LOG_CHARS = 80;
 
 const GATE = `ok=0
@@ -212,8 +230,10 @@ export interface RunPodCommandOptions {
   clone?: boolean;
   hostMirror?: string;
   bunCache?: string;
-  /** 컨테이너 메모리 한도(기본 16Gi). */
+  /** 컨테이너 메모리 한도(기본 16Gi · lite 면 2Gi). */
   memoryLimit?: string;
+  /** POD7: 호출부가 «네트워크 스킬만 쓰는 명령»이라고 말할 때만 lite 이미지 ⊕ 2Gi. */
+  lite?: boolean;
   source?: PodSource;
   ghToken?: () => string;
   deadlineSeconds?: number;
@@ -266,7 +286,8 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
   const baseKubectl = options.kubectl ?? defaultKubectl;
   const sleep = options.sleep ?? ((ms: number) => new Promise<void>((r) => setTimeout(r, ms)));
   const namespace = options.namespace ?? 'elanous-test';
-  const image = options.image ?? 'elanous-harness:local';
+  const image = options.image ?? podCommandImageFor(skills, options.clone === true, options.lite === true);
+  const memoryLimit = options.memoryLimit ?? (image === POD_LITE_IMAGE ? POD_LITE_MEMORY_LIMIT : undefined);
   const repoUrl = options.repoUrl ?? 'https://github.com/ElanvitalAI/elanous';
   const deadlineSeconds = options.deadlineSeconds ?? POD_COMMAND_DEADLINE_SECONDS;
   // POD1 (10-01): two launches in the same moment got the same `si-cmd-<time>` and the failing one's cleanup
@@ -283,13 +304,15 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
 
   let member: PodPoolMember | null = null;
   let pool = options.poolScheduler;
-  if (!pool && options.pool) {
-    const spec = resolvePodPoolSpec(options.pool, env);
-    if (!spec) throw new Error('pod command: 풀 스펙이 비었다');
-    const members = parsePodPool(spec);
-    const checked = (options.checkPool ?? checkPodPool)(members, baseKubectl as PoolKubectl);
-    if (!checked.ok) throw new Error('pod command: 풀의 노드가 하나도 준비되지 않았다');
-    pool = new PodPoolScheduler(checked.ready);
+  if (!pool) {
+    const spec = resolvePodPoolSpec(options.pool, env, () => options.kubectl ? undefined : getUserConfig().pod?.pool);
+    if (options.pool && !spec) throw new Error('pod command: 풀 스펙이 비었다');
+    if (spec) {
+      const members = parsePodPool(spec);
+      const checked = (options.checkPool ?? checkPodPool)(members, baseKubectl as PoolKubectl);
+      if (!checked.ok) throw new Error('pod command: 풀의 노드가 하나도 준비되지 않았다');
+      pool = new PodPoolScheduler(checked.ready);
+    }
   }
   if (pool) {
     for (;;) {
@@ -328,13 +351,16 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
           localImageCommit: () => podImageFreshness({ image }).imageCommit,
         });
     if (pool && member) {
-      const { podSkillsDigest, resolvePodSkills } = await import('./pod-skills.js');
-      const localSkillsDigest = options.kubectl ? null : podSkillsDigest(resolvePodSkills(env).skills).digest;
+      const localSkillsDigest = options.kubectl ? null : image === POD_LITE_IMAGE
+        ? podSkillsDigest(POD_NETWORK_SKILLS, resolve(import.meta.dir, '../../../skills')).digest
+        : podSkillsDigest(resolvePodSkills(env).skills).digest;
       const syncs = await (options.syncImages ?? syncPoolImages)([member], image, imageCommit, { localSkillsDigest });
       const synced = syncs.get(member.context);
       if (synced && !synced.ok) throw new Error(`pod command: 이미지 판을 못 맞췄다: ${synced.detail}`);
       if (synced?.imageRef) member = { ...member, imageRef: synced.imageRef };
     }
+    const imageRef = member?.imageRef;
+    if (!imageRef) log('pod.command-job', 'image-fallback-local', { reason: !member ? 'no-pool-member' : !imageCommit ? 'image-commit-unavailable' : 'registry-tag-unavailable' });
     const ghToken = options.clone ? (options.ghToken ?? defaultGhToken)() : undefined;
     const secret = commandJobSecret({ name, namespace, launch, skills, skillEnvText, ...(grokAuth !== undefined ? { grokAuth } : {}), ...(ghToken !== undefined ? { ghToken } : {}) });
     if (secret) {
@@ -342,10 +368,10 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       if (applied.status !== 0) throw new Error(applied.stderr.trim() || 'pod command: Secret 적용 실패');
     }
     const manifest = podCommandJobManifest({
-      name, namespace, launch, image: member?.imageRef ?? image,
-      ...(member?.imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}),
+      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 } : {}), ...(options.memoryLimit ? { memoryLimit: options.memoryLimit } : {}), deadlineSeconds,
+      ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), ...(bunCache ? { bunCache } : {}), ...(memoryLimit ? { memoryLimit } : {}), deadlineSeconds,
       ...(options.runId ? { runId: options.runId } : {}),
     });
     kubectl(['-n', namespace, 'delete', 'job', '-l', own, '--ignore-not-found']);
@@ -376,7 +402,7 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       llm: llm ?? null,
       command: command.join(' ').slice(0, COMMAND_LOG_CHARS),
     });
-    return { exitCode, artifactsDir, job: name, image: member?.imageRef ?? image };
+    return { exitCode, artifactsDir, job: name, image: imageRef ?? image };
   } catch (err) {
     cleanupSecret();
     throw err;

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

@@ -1,13 +1,22 @@
 import type { PodPoolMember, PoolKubectl } from './pod-pool.js';
+import { debug } from '../../debug/log.js';
 import { spawnSync } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { dlopen } from 'bun:ffi';
+import { hostLeaseBaseDir } from '../../pod-lease/host-lease.js';
+
+/** Persisted on a Job admitted through the host lease; the file lease is released after apply. */
+export const POD_HOST_LEASE_ANNOTATION = 'elanous.dev/host-lease-admitted';
 
 // `get pods --all-namespaces -o json` on a busy cluster is several MB — the default spawnSync
 // buffer fails with ENOBUFS (10-03 node-b measured). Same proxy stripping as the Pod launch kubectl.
 const LEASE_KUBECTL_MAX_BUFFER = 256 * 1024 * 1024;
-export function leaseKubectl(args: readonly string[]): { status: number | null; stdout: string; stderr: string } {
+export function leaseKubectl(args: readonly string[], input?: string): { status: number | null; stdout: string; stderr: string } {
   const env = { ...process.env };
   for (const k of ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy', 'ALL_PROXY', 'all_proxy']) delete env[k];
-  const r = spawnSync('kubectl', [...args], { encoding: 'utf8', env, timeout: 120_000, maxBuffer: LEASE_KUBECTL_MAX_BUFFER });
+  const r = spawnSync('kubectl', [...args], { encoding: 'utf8', input, env, timeout: 120_000, maxBuffer: LEASE_KUBECTL_MAX_BUFFER });
   return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? String(r.error) : '') };
 }
 
@@ -16,6 +25,8 @@ export interface PodLeaseMember {
   capacity: number;
   running: number | null;
   pending: number | null;
+  /** Running harness Pods whose Jobs predate host lease admission. */
+  unleasedRunning: number | null;
   memoryLimitBytes: number | null;
   /** All-node allocatable memory, before existing reservations. */
   allocatableMemoryBytes: number | null;
@@ -35,10 +46,14 @@ export interface PoolLeaseRecommendation {
   reason: string | null;
   capacitySlots: number | null;
   memorySlots: number | null;
+  /** POD7 — the same memory headroom counted in lite goals (2Gi) · observation only: `recommended` stays on the standard size. */
+  liteMemorySlots?: number | null;
   placeableSlots: number | null;
   accountSlots: number | null;
   running: number | null;
   pending: number | null;
+  /** Absent only for injected legacy status fixtures; real measurements always report a number or null. */
+  unleasedRunning?: number | null;
 }
 
 /** Kubernetes quantity to bytes (memory) or millicores (CPU). */
@@ -110,12 +125,114 @@ function runningLimit(spec: Record<string, unknown>): number | null {
   return total;
 }
 
-/** Read only: each cluster probe is kubectl get. Missing reservations cannot become zero. */
-export function measurePoolLease(members: readonly PodPoolMember[], deps: { kubectl?: PoolKubectl } = {}): PoolLeaseMeasure {
+/** A short-lived Pod proves cluster DNS from inside the same namespace as harness Jobs. Image pull failures are not DNS failures. */
+export type PoolDnsProbe = 'ready' | 'dns' | 'image' | 'unknown';
+const DNS_CACHE_MS = 10 * 60_000;
+const DNS_LOCK_WAIT_MS = 6 * 60_000;
+// flock is released by the kernel on process exit, including a crash before any cache write.
+// The lock file is never unlinked: unlinking it would let waiters lock different inodes.
+const dnsFlock = process.platform === 'linux' || process.platform === 'darwin'
+  ? dlopen(process.platform === 'linux' ? 'libc.so.6' : 'libSystem.B.dylib', {
+    flock: { args: ['int', 'int'], returns: 'int' },
+  }).symbols.flock : null;
+
+/** The cache and lock are shared by CLI processes, keyed by context rather than pool composition. */
+export function probePoolDns(context: string, kubectl: PoolKubectl = leaseKubectl, options: { dir?: string; now?: () => number } = {}): PoolDnsProbe {
+  const dir = options.dir ?? hostLeaseBaseDir();
+  const now = options.now ?? Date.now;
+  const key = createHash('sha256').update(context).digest('hex');
+  const cache = join(dir, `dns-${key}.cache`);
+  const outcome = join(dir, `dns-${key}.outcome`);
+  const lock = join(dir, `dns-${key}.flock`);
+  const readRecord = (path: string): Record<string, unknown> | null => {
+    try { return object(JSON.parse(readFileSync(path, 'utf8'))); }
+    catch { return null; }
+  };
+  const cached = (): boolean => {
+    const record = readRecord(cache);
+    return record?.result === 'ready' && typeof record.at === 'number' &&
+      now() >= record.at && now() - record.at < DNS_CACHE_MS;
+  };
+  if (cached()) return 'ready';
+  const previous = readRecord(outcome);
+  try { mkdirSync(dir, { recursive: true, mode: 0o700 }); } catch { return 'unknown'; }
+  if (!dnsFlock) return 'unknown';
+  let fd: number;
+  try { fd = openSync(lock, 'a', 0o600); } catch { return 'unknown'; }
+  const deadline = Date.now() + DNS_LOCK_WAIT_MS;
+  let held = false;
+  try {
+    const sharedFailure = (): PoolDnsProbe | null => {
+      const record = readRecord(outcome);
+      // Only a caller that started before this generation was written can reuse it.
+      if (record?.generation !== undefined && record.generation !== previous?.generation &&
+          ['dns', 'image', 'unknown'].includes(String(record.result))) return record.result as PoolDnsProbe;
+      return null;
+    };
+    while (!held) {
+      if (cached()) return 'ready';
+      const shared = sharedFailure();
+      if (shared) return shared;
+      if (dnsFlock(fd, 2 | 4) === 0) { held = true; break; } // LOCK_EX | LOCK_NB
+      if (Date.now() >= deadline) return 'unknown';
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+    }
+    if (cached()) return 'ready';
+    const shared = sharedFailure();
+    if (shared) return shared;
+    const result = runPoolDnsProbe(context, kubectl);
+    const destination = result === 'ready' ? cache : outcome;
+    const temp = `${destination}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(temp, JSON.stringify({ result, at: now(), generation: randomUUID() }), { mode: 0o600 });
+      renameSync(temp, destination);
+    } catch { try { rmSync(temp, { force: true }); } catch { /* best-effort cleanup */ } }
+    return result;
+  } finally {
+    if (held) dnsFlock(fd, 8); // LOCK_UN
+    closeSync(fd);
+  }
+}
+
+function runPoolDnsProbe(context: string, kubectl: PoolKubectl): PoolDnsProbe {
+  const name = `elanous-dns-${randomUUID().slice(0, 12)}`;
+  const base = ['--context', context, '--request-timeout=10s'];
+  try {
+    const core = kubectl([...base, '-n', 'kube-system', 'get', 'deployment', 'coredns', '-o', 'json']);
+    if (core.status !== 0) return 'unknown';
+    const deployment = object(JSON.parse(core.stdout));
+    const spec = object(deployment?.spec);
+    const status = object(deployment?.status);
+    if (typeof spec?.replicas !== 'number' || spec.replicas < 1 || status?.readyReplicas !== spec.replicas) return 'dns';
+    const manifest = JSON.stringify({ apiVersion: 'v1', kind: 'Pod', metadata: { name, namespace: 'elanous-test', labels: { 'elanous.probe': 'dns' } }, spec: {
+      restartPolicy: 'Never', activeDeadlineSeconds: 40, automountServiceAccountToken: false,
+      containers: [{ name: 'dns', image: 'busybox:1.36', command: ['nslookup', 'kubernetes.default.svc.cluster.local'], resources: { requests: { cpu: '10m', memory: '16Mi' }, limits: { cpu: '100m', memory: '64Mi' } } }],
+    } });
+    if (kubectl([...base, 'create', '-f', '-'], manifest).status !== 0) return 'unknown';
+    const waited = kubectl([...base, '-n', 'elanous-test', 'wait', '--for=jsonpath={.status.phase}=Succeeded', `pod/${name}`, '--timeout=30s']);
+    const pod = kubectl([...base, '-n', 'elanous-test', 'get', `pod/${name}`, '-o', 'json']);
+    if (pod.status !== 0) return 'unknown';
+    const state = object(JSON.parse(pod.stdout));
+    const phase = object(state?.status)?.phase;
+    const statuses = object(state?.status)?.containerStatuses;
+    if (Array.isArray(statuses) && statuses.some((c) =>
+      ['ErrImagePull', 'ImagePullBackOff', 'InvalidImageName'].includes(String(object(object(object(c)?.state)?.waiting)?.reason)))) return 'image';
+    if (phase !== 'Succeeded' && phase !== 'Failed') return 'unknown';
+    if (waited.status !== 0 && phase !== 'Failed') return 'unknown';
+    const log = kubectl([...base, '-n', 'elanous-test', 'logs', `pod/${name}`]);
+    if (log.status !== 0) return 'unknown';
+    if (phase === 'Failed') return /can't resolve|server can't find|connection timed out|no servers could be reached|NXDOMAIN|SERVFAIL/iu.test(log.stdout) ? 'dns' : 'unknown';
+    return /\bName:\s*kubernetes\.default\.svc\.cluster\.local\b/u.test(log.stdout) && /\bAddress(?:es)?:\s*\S+/u.test(log.stdout) ? 'ready' : 'dns';
+  } catch { return 'unknown'; }
+  finally { try { kubectl([...base, '-n', 'elanous-test', 'delete', `pod/${name}`, '--ignore-not-found=true', '--wait=false']); } catch { /* best-effort cleanup */ } }
+}
+
+/** 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 {
   const kubectl = deps.kubectl ?? leaseKubectl;
   return { members: members.map((member) => {
     const base = ['--context', member.context, '--request-timeout=10s'];
-    const result: PodLeaseMember = { context: member.context, capacity: member.capacity, running: null, pending: null, memoryLimitBytes: null, allocatableMemoryBytes: null, allocatableCpuMillicores: null, availableMemoryByNodeBytes: null, reason: null };
+    const result: PodLeaseMember = { context: member.context, capacity: member.capacity, running: null, pending: null, unleasedRunning: null, memoryLimitBytes: null, allocatableMemoryBytes: null, allocatableCpuMillicores: null, availableMemoryByNodeBytes: null, reason: null };
     try {
       const nodes = kubectl([...base, 'get', 'nodes', '-o', 'json']);
       const jobs = kubectl([...base, '-n', 'elanous-test', 'get', 'jobs', '-l', 'elanous.substrate=pod', '-o', 'json']);
@@ -165,6 +282,7 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
       if (!podItems) reasons.push(`cluster pods: ${pods.status === 0 ? 'invalid response' : pods.stderr.trim().split('\n').pop() || `rc=${pods.status}`}`);
       if (podItems && jobItems) {
         const jobNames = new Set<string>();
+        const leasedJobs = new Set<string>();
         let jobsValid = true;
         for (const job of jobItems) {
           const meta = object(job.metadata);
@@ -172,9 +290,10 @@ 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);
+          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, limits = 0, limitsValid = true, reservationsValid = nodeItems !== null && nodeNames.size === nodeItems.length;
+        let running = 0, pending = 0, unleasedRunning = 0, limits = 0, limitsValid = true, reservationsValid = nodeItems !== null && nodeNames.size === nodeItems.length;
         let unknownPhase = false;
         const seenPods = new Set<string>();
         for (const pod of podItems) {
@@ -190,7 +309,7 @@ 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' &&
+          const harness = metadata?.namespace === 'elanous-test' && labels?.['elanous.probe'] !== 'dns' &&
             (labels?.['elanous.substrate'] === 'pod' || jobNames.has(String(labels?.['elanous.job'] ?? '')));
           const spec = object(pod.spec);
           let limit: number | null = null;
@@ -198,6 +317,8 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
             if (phase === 'Pending') pending++;
             else {
               running++;
+              const jobName = labels?.['elanous.job'] ?? labels?.['job-name'];
+              if (typeof jobName !== 'string' || !leasedJobs.has(jobName)) unleasedRunning++;
               limit = spec ? runningLimit(spec) : null;
               if (limit === null) limitsValid = false;
               else limits += limit;
@@ -212,15 +333,21 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
           if (nodeFree.has(nodeName)) nodeFree.set(nodeName, nodeFree.get(nodeName)! - Math.max(requested, limit ?? 0));
         }
         if (unknownPhase) reasons.push('cluster pods: missing/Unknown phase');
-        if (jobsValid && !unknownPhase) { result.running = running; result.pending = pending; }
+        if (jobsValid && !unknownPhase) { result.running = running; result.pending = pending; result.unleasedRunning = unleasedRunning; }
         if (limitsValid && jobsValid && !unknownPhase) result.memoryLimitBytes = limits;
         else if (!limitsValid) reasons.push('cluster pods: Running Pod memory limit missing/invalid');
         if (reservationsValid && limitsValid && jobsValid && !unknownPhase) result.availableMemoryByNodeBytes = [...nodeFree.values()];
         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) {
+        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'; }
+        else if (dnsState !== 'ready') { result.availableMemoryByNodeBytes = null; result.reason = `측정 불가: dns probe ${dnsState}`; }
+      }
     } catch (error) {
-      result.running = null; result.pending = null; result.memoryLimitBytes = null;
+      result.running = null; result.pending = null; result.unleasedRunning = null; result.memoryLimitBytes = null;
       result.allocatableMemoryBytes = null; result.allocatableCpuMillicores = null; result.availableMemoryByNodeBytes = null;
       result.reason = `cluster: ${error instanceof Error ? error.message : String(error)}`.split('\n')[0]!.slice(0, 240);
     }
@@ -229,32 +356,42 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
 }
 
 /** Per-node memory and per-member slots cannot be exchanged across nodes/clusters. */
-export function recommendConcurrency(measure: PoolLeaseMeasure, options: { capacity: number; perGoalMemory?: string; accounts: number; perAccount: number }): PoolLeaseRecommendation {
-  const empty: PoolLeaseRecommendation = { recommended: null, limitedBy: null, reason: null, capacitySlots: null, memorySlots: null, placeableSlots: null, accountSlots: null, running: null, pending: null };
+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 };
   const goalBytes = quantity(options.perGoalMemory ?? '16Gi', 'memory');
   if (goalBytes === null || goalBytes <= 0) return { ...empty, reason: '측정 불가: perGoalMemory' };
-  if (!measure.members.length || measure.members.some((m) => m.running === null || m.pending === null || m.allocatableMemoryBytes === null || m.memoryLimitBytes === null || m.allocatableCpuMillicores === null || m.availableMemoryByNodeBytes === null)) {
+  if (!measure.members.length || measure.members.some((m) => m.running === null || m.pending === null || m.unleasedRunning === null || m.allocatableMemoryBytes === null || m.memoryLimitBytes === null || m.allocatableCpuMillicores === null || m.availableMemoryByNodeBytes === null)) {
     return { ...empty, reason: `측정 불가: cluster${measure.members.map((m) => m.reason ? ` ${m.context}: ${m.reason}` : '').join('')}` };
   }
   if (!Number.isSafeInteger(options.capacity) || options.capacity < 0) return { ...empty, reason: '측정 불가: capacity' };
   const running = measure.members.reduce((sum, m) => sum + m.running!, 0);
   const pending = measure.members.reduce((sum, m) => sum + m.pending!, 0);
-  const capacitySlots = Math.max(0, Math.min(options.capacity - running - pending,
-    measure.members.reduce((sum, m) => sum + Math.max(0, m.capacity - m.running! - m.pending!), 0)));
+  const unleasedRunning = measure.members.reduce((sum, m) => sum + m.unleasedRunning!, 0);
+  // Pool-wide free = sum of per-member free slots: a member over its cap counts as full, never negative,
+  // so it cannot zero another member's free slot (and its unleased Pods only consume its own free slots).
+  const memberFree = measure.members.map((m) => Math.max(0, m.capacity - m.running! - m.pending!));
+  const eligibleUnleasedRunning = measure.members.reduce((sum, m, i) => sum + (m.reason === 'dns' ? 0 : Math.min(m.unleasedRunning!, memberFree[i]!)), 0);
+  const eligibleOccupied = measure.members.reduce((sum, m) => sum + (m.reason === 'dns' ? 0 : Math.min(m.capacity, m.running! + m.pending!)), 0);
+  const capacitySlots = Math.max(0, Math.min(options.capacity - eligibleOccupied,
+    memberFree.reduce((sum, free) => sum + free, 0)));
   const memberMemorySlots = measure.members.map((m) => m.availableMemoryByNodeBytes!.reduce(
     (sum, bytes) => sum + Math.max(0, Math.floor(bytes / goalBytes)), 0));
   // Preserve the requested allocatable-minus-harness-limit metric. The node-local
   // placement bound additionally accounts for every namespace's reservations.
-  const memorySlots = measure.members.reduce((sum, m) => sum + Math.max(0,
-    Math.floor((m.allocatableMemoryBytes! - m.memoryLimitBytes!) / goalBytes)), 0);
+  const memorySlots = measure.members.reduce((sum, m) => sum + (m.reason === 'dns' ? 0 : Math.max(0,
+    Math.floor((m.allocatableMemoryBytes! - m.memoryLimitBytes!) / goalBytes))), 0);
   const placeableSlots = measure.members.reduce((sum, m, i) => sum + Math.min(
     Math.max(0, m.capacity - m.running! - m.pending!), memberMemorySlots[i]!,
   ), 0);
   // Account count is not a concurrency limit (same IP · own accounts, 10-03 decision) — observed only, never a bound.
   const accountSlots = [options.accounts, options.perAccount].every((n) => Number.isSafeInteger(n) && n >= 0)
     ? Math.max(0, options.accounts * options.perAccount - running) : null;
+  const liteBytes = quantity(options.liteGoalMemory ?? '2Gi', 'memory');
+  const liteMemorySlots = liteBytes === null || liteBytes <= 0 ? null : measure.members.reduce((sum, m) => sum + (m.reason === 'dns' ? 0 : Math.max(0,
+    Math.floor((m.allocatableMemoryBytes! - m.memoryLimitBytes!) / liteBytes))), 0);
   const memoryBound = Math.min(memorySlots, placeableSlots);
-  const recommended = Math.min(capacitySlots, memoryBound);
-  const limitedBy = recommended === memoryBound && memoryBound < capacitySlots ? 'memory' : 'capacity';
-  return { recommended, limitedBy, reason: null, capacitySlots, memorySlots, placeableSlots, accountSlots, running, pending };
+  const recommended = Math.max(0, Math.min(capacitySlots, memoryBound) - eligibleUnleasedRunning);
+  const limitedBy = memoryBound < capacitySlots ? 'memory' : 'capacity';
+  if (unleasedRunning > 0) debug.log('pod-lease', 'unleased', { unleasedRunning, running, recommended });
+  return { recommended, limitedBy, reason: measure.members.some((m) => m.reason === 'dns') ? 'dns' : null, capacitySlots, memorySlots, liteMemorySlots, placeableSlots, accountSlots, running, pending, unleasedRunning };
 }