elanous 0.2.18 → 0.2.19

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

@@ -7,6 +7,13 @@ import { join } from 'node:path';
 import { dlopen } from 'bun:ffi';
 import { hostLeaseBaseDir, type PendingJobIdentity } from '../../pod-lease/host-lease.js';
 
+/** The harness Pod's container requests (self-implement-pod Job manifest). Lives here so admission reuses the real request. */
+export const POD_CHILD_REQUESTS = { cpu: '1', memory: '6Gi' } as const;
+/** POD-ADMIT-BY-USAGE — observed usage is scaled by this before it reserves memory. */
+const POD_USAGE_HEADROOM = 1.5;
+/** POD-ADMIT-BY-USAGE — a node keeps at least this share of allocatable memory free (real usage and bookkeeping). */
+const POD_NODE_FREE_FLOOR_RATIO = 0.1;
+
 /** Persisted on a Job admitted through the host lease; the file lease remains until its Pod is observed Running or terminal. */
 export const POD_HOST_LEASE_ANNOTATION = 'elanous.dev/host-lease-admitted';
 
@@ -39,6 +46,27 @@ export interface PodLeaseMember {
   /** Node-by-node memory left after all assigned Pod requests and harness Running limits. */
   availableMemoryByNodeBytes: number[] | null;
   reason: string | null;
+  /**
+   * POD-ADMIT-BY-USAGE (only when measured with `measureUsage`): observed memory of Running harness Pods
+   * (`kubectl top pods`). null = metrics unreadable (see usageReason) — every Pod is then reserved at its limit, as before.
+   */
+  harnessUsageBytes?: number[] | null;
+  usageReason?: string | 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. */
+  allocatableMemoryByNodeBytes?: number[] | null;
+  /** Parallel to availableMemoryByNodeBytes: each node's real memory use (`kubectl top nodes`), null when unmeasured. */
+  usedMemoryByNodeBytes?: Array<number | null> | null;
+}
+
+/** POD-ADMIT-BY-USAGE — how much memory one new goal is counted at, and why. */
+export interface PodAdmissionByUsage {
+  samples: number;
+  p95Bytes: number | null;
+  admitBytes: number;
+  /** Why admission stayed on the conservative per-goal size; null when usage drove it. */
+  fallback: string | null;
 }
 
 export interface PoolLeaseMeasure {
@@ -61,6 +89,28 @@ export interface PoolLeaseRecommendation {
   pendingJobs?: PendingJobIdentity[];
   /** Absent only for injected legacy status fixtures; real measurements always report a number or null. */
   unleasedRunning?: number | null;
+  /** POD-ADMIT-BY-USAGE — the per-goal size this recommendation used. */
+  admission?: PodAdmissionByUsage;
+}
+
+/** `kubectl top … --no-headers` → name → memory bytes; null when any line cannot be read (fail conservative). */
+function topMemory(stdout: string, column: number): Map<string, number> | null {
+  const out = new Map<string, number>();
+  for (const line of stdout.split('\n')) {
+    if (!line.trim()) continue;
+    const cols = line.trim().split(/\s+/u);
+    const bytes = cols.length > column ? quantity(cols[column]!, 'memory') : null;
+    if (bytes === null || out.has(cols[0]!)) return null;
+    out.set(cols[0]!, bytes);
+  }
+  return out;
+}
+
+/** Nearest-rank p95. */
+function p95(values: readonly number[]): number | null {
+  if (!values.length) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.max(0, Math.ceil(sorted.length * 0.95) - 1)]!;
 }
 
 /** Kubernetes quantity to bytes (memory) or millicores (CPU). */
@@ -238,7 +288,7 @@ function runPoolDnsProbe(context: string, kubectl: PoolKubectl): PoolDnsProbe {
 }
 
 /** Each cluster reads resource reservations; DNS requires a bounded disposable Pod. */
-export function measurePoolLease(members: readonly PodPoolMember[], deps: { kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; /** Read-only snapshots must not create the disposable DNS Pod or update its cache. */ skipDnsProbe?: boolean } = {}): PoolLeaseMeasure {
+export function measurePoolLease(members: readonly PodPoolMember[], deps: { kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; /** Read-only snapshots must not create the disposable DNS Pod or update its cache. */ skipDnsProbe?: boolean; /** POD-ADMIT-BY-USAGE — also read `kubectl top` so Running harness Pods reserve by observed usage. */ measureUsage?: boolean } = {}): PoolLeaseMeasure {
   const kubectl = deps.kubectl ?? leaseKubectl;
   return { members: members.map((member) => {
     const base = ['--context', member.context, '--request-timeout=10s'];
@@ -249,6 +299,26 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
       // All namespaces are necessary: unrelated workloads also reserve memory on these nodes.
       const pods = kubectl([...base, 'get', 'pods', '--all-namespaces', '-o', 'json']);
       const reasons: string[] = [];
+      // POD-ADMIT-BY-USAGE: metrics are optional — a failed `top` leaves every reservation at today's limit.
+      let podUsage: Map<string, number> | null = null;
+      let nodeUsage: Map<string, number> | null = null;
+      if (deps.measureUsage) {
+        const top = kubectl([...base, '-n', 'elanous-test', 'top', 'pods', '--no-headers']);
+        podUsage = top.status === 0 ? topMemory(top.stdout, 2) : null;
+        result.usageReason = podUsage ? null
+          : `top pods unavailable: ${top.status === 0 ? 'unparseable output' : top.stderr.trim().split('\n').pop() || `rc=${top.status}`}`.slice(0, 160);
+        if (podUsage) {
+          const topNodes = kubectl([...base, 'top', 'nodes', '--no-headers']);
+          nodeUsage = topNodes.status === 0 ? topMemory(topNodes.stdout, 3) : null;
+          // The node real-usage floor needs node metrics: without them stay on today's limit reservations.
+          if (!nodeUsage) {
+            podUsage = null;
+            result.usageReason = `top nodes unavailable: ${topNodes.status === 0 ? 'unparseable output' : topNodes.stderr.trim().split('\n').pop() || `rc=${topNodes.status}`}`.slice(0, 160);
+          }
+        }
+      }
+      const harnessUsage: number[] = [];
+      const nodeAllocatable = new Map<string, number>();
       const parsedItems = (response: ReturnType<PoolKubectl>): Record<string, unknown>[] | null => {
         if (response.status !== 0) return null;
         try { return items(JSON.parse(response.stdout)); } catch { return null; }
@@ -280,12 +350,15 @@ 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);
+          if (spec?.unschedulable !== true && !repels && object(ready[0])?.status === 'True') { nodeFree.set(name, mem); nodeAllocatable.set(name, mem); }
           memory += mem; cpu += cores;
         }
         if (valid) { result.allocatableMemoryBytes = memory; result.allocatableCpuMillicores = cpu; }
-        else { nodeFree.clear(); nodeNames.clear(); reasons.push('cluster nodes: invalid name/allocatable memory/cpu/readiness'); }
+        else { nodeFree.clear(); nodeAllocatable.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;
+      if (unreadNode !== undefined) { podUsage = null; result.usageReason = `top nodes: no reading for ${unreadNode}`.slice(0, 160); }
       const jobItems = parsedItems(jobs);
       const podItems = parsedItems(pods);
       if (!jobItems) reasons.push(`cluster jobs: ${jobs.status === 0 ? 'invalid response' : jobs.stderr.trim().split('\n').pop() || `rc=${jobs.status}`}`);
@@ -303,7 +376,7 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
           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, limitsValid = true, reservationsValid = nodeItems !== null && nodeNames.size === nodeItems.length;
+        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;
         const seenPods = new Set<string>();
@@ -324,6 +397,7 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
             (labels?.['elanous.substrate'] === 'pod' || jobNames.has(String(labels?.['elanous.job'] ?? '')));
           const spec = object(pod.spec);
           let limit: number | null = null;
+          let reserve: number | null = null;
           if (harness) {
             if (phase === 'Pending') {
               pending++;
@@ -338,7 +412,15 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
               if (typeof jobName !== 'string' || !leasedJobs.has(jobName)) unleasedRunning++;
               limit = spec ? runningLimit(spec) : null;
               if (limit === null) limitsValid = false;
-              else limits += limit;
+              else {
+                limits += limit;
+                // Measured usage: max(request, usage×1.5) capped at the limit. Unmeasured: max(request, limit) (today's node reservation).
+                const used = typeof metadata.name === 'string' ? podUsage?.get(metadata.name) : undefined;
+                const request = spec ? requestedMemory(spec) : null;
+                if (used !== undefined) harnessUsage.push(used);
+                reserve = used !== undefined && request !== null ? Math.min(limit, Math.max(request, Math.ceil(used * POD_USAGE_HEADROOM))) : Math.max(request ?? 0, limit);
+                reserved += reserve;
+              }
             }
           }
           // Pending Pods with no assigned node have no node reservation yet. They already occupy a pool slot.
@@ -347,13 +429,22 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
               requestedMemory(spec) !== null) continue;
           const requested = spec ? requestedMemory(spec) : null;
           if (typeof nodeName !== 'string' || !nodeNames.has(nodeName) || requested === null) { reservationsValid = false; continue; }
-          if (nodeFree.has(nodeName)) nodeFree.set(nodeName, nodeFree.get(nodeName)! - Math.max(requested, limit ?? 0));
+          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.running = running; result.pending = pending; result.pendingJobs = [...pendingJobs.values()]; result.unleasedRunning = unleasedRunning; }
-        if (limitsValid && jobsValid && !unknownPhase) result.memoryLimitBytes = limits;
+        if (limitsValid && jobsValid && !unknownPhase) {
+          result.memoryLimitBytes = limits;
+          if (deps.measureUsage) { result.memoryReservedBytes = reserved; result.harnessUsageBytes = podUsage ? harnessUsage : null; }
+        }
         else if (!limitsValid) reasons.push('cluster pods: Running Pod memory limit missing/invalid');
-        if (reservationsValid && limitsValid && jobsValid && !unknownPhase) result.availableMemoryByNodeBytes = [...nodeFree.values()];
+        if (reservationsValid && limitsValid && jobsValid && !unknownPhase) {
+          result.availableMemoryByNodeBytes = [...nodeFree.values()];
+          if (deps.measureUsage) {
+            result.allocatableMemoryByNodeBytes = [...nodeFree.keys()].map((n) => nodeAllocatable.get(n)!);
+            result.usedMemoryByNodeBytes = [...nodeFree.keys()].map((n) => nodeUsage?.get(n) ?? null);
+          }
+        }
         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;
@@ -366,6 +457,7 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
     } catch (error) {
       result.running = null; result.pending = null; result.unleasedRunning = null; result.memoryLimitBytes = null;
       result.allocatableMemoryBytes = null; result.allocatableCpuMillicores = null; result.availableMemoryByNodeBytes = null;
+      if (deps.measureUsage) { result.memoryReservedBytes = null; result.harnessUsageBytes = null; result.allocatableMemoryByNodeBytes = null; result.usedMemoryByNodeBytes = null; }
       result.reason = `cluster: ${error instanceof Error ? error.message : String(error)}`.split('\n')[0]!.slice(0, 240);
     }
     return result;
@@ -377,7 +469,9 @@ export function recommendConcurrency(measure: PoolLeaseMeasure, options: { capac
   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' };
+  const admission = admissionByUsage(measure, goalBytes, options.perGoalMemory !== undefined);
   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)) {
+    debug.log('pod-lease', 'admit-by-usage', { samples: admission.samples, p95Bytes: admission.p95Bytes, admitBytes: admission.admitBytes, fallback: admission.fallback, recommended: null, limitedBy: 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' };
@@ -392,12 +486,25 @@ export function recommendConcurrency(measure: PoolLeaseMeasure, options: { capac
   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));
+  // The goal size may fall back to the conservative size pool-wide; the node floor is separate and follows each
+  // member: once its Running Pods reserve by usage (usage read), its nodes keep 10% free in bookkeeping and real use.
+  const admitBytes = admission.admitBytes;
+  const usageRead = (m: PodLeaseMember) => Array.isArray(m.harnessUsageBytes);
+  const memberMemorySlots = measure.members.map((m) => m.availableMemoryByNodeBytes!.reduce((sum, bytes, i) => {
+    if (!usageRead(m)) return sum + Math.max(0, Math.floor(bytes / admitBytes));
+    const allocatable = m.allocatableMemoryByNodeBytes?.[i];
+    const used = m.usedMemoryByNodeBytes?.[i];
+    // A usage-read member always carries both per-node readings; anything missing admits nothing on that node.
+    if (typeof allocatable !== 'number' || typeof used !== 'number') return sum;
+    const floor = allocatable * POD_NODE_FREE_FLOOR_RATIO;
+    const slots = Math.min(Math.floor((bytes - floor) / admitBytes), Math.floor((allocatable - used - floor) / admitBytes));
+    return sum + Math.max(0, slots);
+  }, 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 + (m.reason === 'dns' ? 0 : 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, usageRead(m)
+    ? Math.floor((m.allocatableMemoryBytes! * (1 - POD_NODE_FREE_FLOOR_RATIO) - (m.memoryReservedBytes ?? m.memoryLimitBytes!)) / admitBytes)
+    : Math.floor((m.allocatableMemoryBytes! - m.memoryLimitBytes!) / admitBytes))), 0);
   const placeableSlots = measure.members.reduce((sum, m, i) => sum + Math.min(
     Math.max(0, m.capacity - m.running! - m.pending!), memberMemorySlots[i]!,
   ), 0);
@@ -411,5 +518,27 @@ export function recommendConcurrency(measure: PoolLeaseMeasure, options: { capac
   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, pendingJobs, unleasedRunning };
+  debug.log('pod-lease', 'admit-by-usage', { samples: admission.samples, p95Bytes: admission.p95Bytes, admitBytes: admission.admitBytes, fallback: admission.fallback, recommended, limitedBy });
+  return { recommended, limitedBy, reason: measure.members.some((m) => m.reason === 'dns') ? 'dns' : null, capacitySlots, memorySlots, liteMemorySlots, placeableSlots, accountSlots, running, pending, pendingJobs, unleasedRunning, admission };
+}
+
+/**
+ * POD-ADMIT-BY-USAGE — one new goal counts at max(the Pod's memory request, p95 of Running harness Pod usage × 1.5),
+ * capped at the per-goal size. No samples (metrics unreadable, nothing running, or an explicit per-goal size such as an
+ * OOM retry tier) keeps the conservative per-goal size.
+ */
+function admissionByUsage(measure: PoolLeaseMeasure, goalBytes: number, explicit: boolean): PodAdmissionByUsage {
+  const live = measure.members.filter((m) => m.reason !== 'dns');
+  const samples = live.flatMap((m) => m.harnessUsageBytes ?? []);
+  const p95Bytes = p95(samples);
+  const requestBytes = quantity(POD_CHILD_REQUESTS.memory, 'memory')!;
+  // Any live member whose usage was not read keeps the whole pool on today's per-goal size (fail conservative).
+  const fallback = explicit ? 'explicit perGoalMemory'
+    : live.every((m) => m.harnessUsageBytes === undefined) ? 'usage not measured'
+      : live.some((m) => m.harnessUsageBytes == null) ? (live.map((m) => m.harnessUsageBytes == null ? `${m.context}: ${m.usageReason ?? 'usage not measured'}` : '').filter(Boolean).join('; '))
+        : p95Bytes === null ? 'no Running harness Pod usage samples'
+          : null;
+  const admitBytes = fallback !== null || p95Bytes === null ? goalBytes
+    : Math.min(goalBytes, Math.max(requestBytes, Math.ceil(p95Bytes * POD_USAGE_HEADROOM)));
+  return { samples: samples.length, p95Bytes, admitBytes, fallback };
 }

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

@@ -193,7 +193,8 @@ export class PodPoolScheduler {
     // One lease directory per pool (contexts, not caps) — every CLI process launching into the same clusters shares it.
     this.hostLease = options.hostLease ?? podPoolHostLease(members);
     const measureStatus = options.status ?? (() => {
-      const measure = measurePoolLease(members, { ...(options.kubectl ? { kubectl: options.kubectl } : {}), ...(options.dns ? { dns: options.dns } : {}) });
+      // POD-ADMIT-BY-USAGE: admission reads observed Pod usage (`kubectl top`); tryAcquire's occupancy read does not.
+      const measure = measurePoolLease(members, { ...(options.kubectl ? { kubectl: options.kubectl } : {}), ...(options.dns ? { dns: options.dns } : {}), measureUsage: true });
       return recommendConcurrency(measure, { capacity: members.reduce((n, m) => n + m.capacity, 0), accounts: 0, perAccount: 0 });
     });
     this.measure = async () => measureStatus();
@@ -297,11 +298,18 @@ export class PodPoolScheduler {
    * 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).
+   * `selfCapped` (POOLGLOBAL-REG 10-07): a caller with its own concurrency cap (the release gate) counts only its own Jobs
+   * — free = capacity − this scheduler's inflight, summed over members as the pool total — and reads no cluster occupancy.
+   * #24253 made every acquire subtract all Running+Pending harness goal Pods, so with ~24 goal Pods on the gate's 25-slot
+   * member the 0.2.15 gate launched its shards one at a time.
    * Ties keep the configured member order. Returns null when every readable member is full.
    */
-  async tryAcquire(skip?: ReadonlySet<string>, onEmpty?: (reason: string) => void): Promise<PodPoolMember | null> {
+  async tryAcquire(skip?: ReadonlySet<string>, onEmpty?: (reason: string) => void, mode: { selfCapped?: boolean } = {}): Promise<PodPoolMember | null> {
+    const selfCapped = mode.selfCapped === true;
     let reading: Record<string, MemberOccupancy>;
-    try { reading = await this.occupancy(); }
+    // A self-capped caller's own Jobs are its inflight; other workloads' Pods are not its slots (no cluster read).
+    if (selfCapped) reading = Object.fromEntries(this.members.map((m) => [m.context, { occupied: 0 }]));
+    else 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 }]));
@@ -329,12 +337,12 @@ export class PodPoolScheduler {
       if (better(cand)) best = cand;
     }
     if (!best) {
-      onEmpty?.(`no free slot · free=${JSON.stringify(free)} · measured=${JSON.stringify(measured)}${skip?.size ? ` · skipped=${[...skip].join(',')}` : ''}`);
+      onEmpty?.(`no free slot · free=${JSON.stringify(free)} · measured=${JSON.stringify(measured)}${selfCapped ? ' · selfCapped' : ''}${skip?.size ? ` · skipped=${[...skip].join(',')}` : ''}`);
       return null;
     }
     this.inflight.set(best.member.context, (this.inflight.get(best.member.context) ?? 0) + 1);
     const share = Object.fromEntries(this.members.map((m) => [m.context, Math.round(Math.max(0, free[m.context] ?? 0) / m.capacity * 100) / 100]));
-    debug.log('pod.pool', 'member-selected', { member: best.member.context, free, measured, share });
+    debug.log('pod.pool', 'member-selected', { member: best.member.context, free, measured, share, ...(selfCapped ? { selfCapped: true } : {}) });
     return best.member;
   }
   release(member: PodPoolMember): void {

package/src/task-orchestrator/surfaces/self-implement-pod.ts

@@ -48,9 +48,9 @@ export const POD_JOB_DEADLINE_SECONDS = 10_800;
 // POD-DIET (10-06 03:47~05:18 · node-b goal Pods · 89 one-minute samples · 42 Pods): per-Pod observed max median 4.6Gi ·
 // p75 6.2Gi · p90 11.7Gi — 23/42 went above the old 4Gi request, so the scheduler over-packed. 6Gi ≈ p75; limits stay.
 // Node allocatable ≈ 343Gi ≫ 25 × 6Gi. One-minute samples can miss the true peak (lower bound).
-export const POD_CHILD_REQUESTS = { cpu: '1', memory: '6Gi' } as const;
 import type { PodPoolMember, PodPoolScheduler } from './pod-pool.js';
-import { measurePoolLease, recommendConcurrency, POD_HOST_LEASE_ANNOTATION, LEASE_KUBECTL_MAX_BUFFER, memoryQuantityBytes } from './pod-lease.js';
+export { POD_CHILD_REQUESTS } from './pod-lease.js';
+import { measurePoolLease, recommendConcurrency, POD_CHILD_REQUESTS, POD_HOST_LEASE_ANNOTATION, LEASE_KUBECTL_MAX_BUFFER, memoryQuantityBytes } from './pod-lease.js';
 import { ACTUAL_SUBSTRATE_ENV, RUN_CONTRACT_ENV, carryRunContract, completionFloorFor } from '../../self-implement/graph-run-contract.js';
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';

package/src/telegram-away-command.ts

@@ -0,0 +1,38 @@
+import { readPresence, writePresence, type Presence } from './away/presence.js';
+import { releaseNowText, releaseWatchTick } from './away/release-watch.js';
+import { readReleaseRuns, type ReleaseRunView } from './nexus/api/ops-api.js';
+
+/** AWAY-MODE-1 ③ — 텔레그램 /release: PWA /ops/release 와 같은 원장을 읽어 지금 런·노드를 한 통으로. */
+export function telegramReleaseStatus(args: string[], runs: () => ReleaseRunView[] | 'unavailable' = () => readReleaseRuns(null, undefined, { facts: true }), now: () => number = Date.now): string {
+  if (args.length) return '사용법: /release';
+  return releaseNowText(runs(), now());
+}
+
+export interface AwaySlashDeps {
+  read?: () => Presence;
+  write?: (away: boolean, by: string) => Presence;
+  tick?: () => unknown;
+  release?: () => string;
+}
+
+/** AWAY-MODE-1 ① — 텔레그램 /away on|off|status. 답은 이 대화로 돌아오므로 따로 발송하지 않는다. */
+export function telegramAwaySlash(args: string[], deps: AwaySlashDeps = {}): string {
+  const read = deps.read ?? (() => readPresence());
+  const write = deps.write ?? ((away: boolean, by: string) => writePresence(away, by));
+  const tick = deps.tick ?? (() => releaseWatchTick());
+  const release = deps.release ?? (() => telegramReleaseStatus([]));
+  const sub = (args[0] ?? 'status').toLowerCase();
+  if (args.length > 1 || !['on', 'off', 'status'].includes(sub)) return '사용법: /away on | off | status';
+  if (sub === 'on') {
+    write(true, 'telegram');
+    tick();
+    return `🚶 외출 모드 켬 — 발행 노드 전이·막힘·60분 생존 줄을 여기로 보낸다(끄기: /away off)\n${release()}`;
+  }
+  if (sub === 'off') {
+    write(false, 'telegram');
+    tick();
+    return '🏠 외출 모드 끔 — 발행 알림은 평소대로';
+  }
+  const presence = read();
+  return `${presence.away ? '🚶 외출 중' : '🏠 자리에 있음'}${presence.since ? ` · ${presence.since}` : ''}\n${release()}`;
+}

package/src/telegram-commands.ts

@@ -50,6 +50,7 @@ import { createAdPipelineDeps, runAdPipeline } from './ad-pipeline/run.js';
 import { projectCommand } from './telegram-project-command.js';
 import { telegramNowSlash } from './context-bus/context-now-surfaces.js';
 import { telegramLoopsStatus } from './telegram-loops-command.js';
+import { telegramAwaySlash, telegramReleaseStatus } from './telegram-away-command.js';
 import { createWishCard } from './intake-plane/wish-card.js';
 import { telegramDecisionOwner } from './decisions/telegram-decision-cards.js';
 import { CardStore } from './task-cards/card-store.js';
@@ -334,6 +335,16 @@ export function defaultTelegramCommands(
       description: '루프·크론 현황 — 늦음·실패를 먼저 보여줍니다',
       handler: (args) => telegramLoopsStatus(args),
     },
+    {
+      name: 'release',
+      description: '발행 현황 — 지금 런·노드·막힘을 한 통으로',
+      handler: async (args) => telegramReleaseStatus(args),
+    },
+    {
+      name: 'away',
+      description: '외출 모드 — /away on|off|status (켜면 발행 전이를 여기로)',
+      handler: async (args) => telegramAwaySlash(args),
+    },
     {
       name: 'status',
       description: 'Show bot identity, current session, provider + model',

package/src/telegram-report-log-probe.ts

@@ -0,0 +1,21 @@
+import { sendTelegramReport } from './telegram-report.js';
+import { getUserConfig, setUserConfigOverlay } from './user-config.js';
+import { registerStandaloneLogSink } from './domains/standalone-log-sink.js';
+
+// Focused subprocess fixture (BRIEF-DELIVERY-1007): the production shape — a channels table whose
+// trading channel lacks the `report` role while the legacy reportChannel points at that bot.
+setUserConfigOverlay(cfg => ({
+  ...cfg,
+  telegram: {
+    ...cfg.telegram,
+    channels: [
+      { name: 'main', botToken: '111111:private-secret', chatId: 98765, interactive: true, roles: ['qa', 'default', 'system'] },
+      { name: 'conatus', botToken: '222222:private-secret', chatId: 98766, interactive: false, roles: ['investment', 'finance'] },
+    ],
+    reportChannel: { botToken: '222222:private-secret', chatId: 98766 },
+  },
+}));
+// The entry point attaches logs.db, exactly as cron morning-report does.
+if (process.env.NODE_ENV !== 'test') await registerStandaloneLogSink('telegram-report-probe');
+console.log(`probe-start ${new Date().toISOString()}`);
+if (await sendTelegramReport(getUserConfig(), 'SECRET-BODY-DO-NOT-LOG', { kind: 'report' })) process.exitCode = 1;

package/src/telegram-report.ts

@@ -11,11 +11,25 @@
 // the report channel while interactive Q&A stays on the main bot.
 
 import { TelegramBot } from './telegram.js';
-import { isTradingKind, kindRouteTarget, logKindRouteFallback, mainHomeTarget } from './domains/telegram-kind-route.js';
+import { explainReportRoute, isTradingKind, kindRouteTarget, logKindRouteFallback, mainHomeTarget } from './domains/telegram-kind-route.js';
+export { explainReportRoute } from './domains/telegram-kind-route.js';
 export { DEFAULT_KIND_ROLES, roleForKind } from './domains/telegram-kind-route.js';
 import { resolveChannelBotToken } from './channel-bot-token.js';
 import type { UserConfig } from './user-config.js';
 import { findSessionByTelegramChat, createSession, appendMessage } from './session/index.js';
+import { debug } from './debug/log.js';
+// Observations go through debug.log only: a standalone caller (cron morning-report) registers its own
+// logs.db sink at its entry point (registerStandaloneLogSink) — registering here would duplicate every
+// row inside the daemon, which already has one (review r4).
+function logReport(event: 'sent' | 'unconfirmed' | 'unrouted', data: Record<string, unknown>): void {
+  try { debug.log('telegram.report', event, data); } catch { /* fail-soft */ }
+}
+
+/** Public numeric bot id only — never the token's secret suffix. */
+function botId(token: string): string {
+  const id = token.split(':', 1)[0] ?? '';
+  return /^\d+$/.test(id) ? id : 'configured';
+}
 
 /** Cross-surface memory — mirror an outbound report/alert into the
  *  RECEIVING channel's session transcript so a follow-up question in that
@@ -95,14 +109,24 @@ export async function sendTelegramReport(
   opts: SendReportOpts = {},
 ): Promise<boolean> {
   const target = resolveReportTarget(cfg, opts.kind);
-  if (!target || !text) return false;
+  if (!text) return false;
+  if (!target) {
+    const why = explainReportRoute(cfg, opts.kind);
+    logReport('unrouted', { kind: opts.kind ?? null, role: why.role, reason: why.reason });
+    return false;
+  }
   const bot = new TelegramBot({
     token: target.botToken,
     allowedUsers: [],
     onMessage: async () => undefined,
     ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
   });
-  await bot.sendMessage(target.chatId, text, { markdown: opts.markdown ?? true });
+  const sent = await bot.sendMessage(target.chatId, text, { markdown: opts.markdown ?? true });
+  // Delivered only with Telegram's message id back — an empty answer is unconfirmed and returns false (review r4).
+  const confirmed = Number.isSafeInteger(sent?.messageId) && (sent?.messageId ?? 0) > 0;
+  logReport(confirmed ? 'sent' : 'unconfirmed',
+    { kind: opts.kind ?? null, role: explainReportRoute(cfg, opts.kind).role, bot: botId(target.botToken), chars: text.length });
+  if (!confirmed) return false;
   // Mirror into the report channel's session so a follow-up question in
   // that chat can recall this alert (Fix — was surface_events-only).
   mirrorOutboundToSession(target, text);

package/src/tui-client/dashboard-session.ts

@@ -195,6 +195,7 @@ export class DashboardSession {
     const pair = createInProcessTransportPair();
     const shutdownCtrl = new AbortController();
     const runTurn = bridgeCoreTurnToAcp({
+      tuiRouting: true,
       getMessages: opts.getMessages,
       getTools: opts.getTools,
       dispatchTool: opts.dispatchTool,