elanous 0.2.12 → 0.2.14

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

@@ -9,6 +9,32 @@ type Incomplete = { runId: string; reason: string };
 type ParseResult = Ledger[] | { error: Incomplete[]; ledgers: Ledger[] };
 
 const NON_PROGRESS_EVENTS = new Set(['progress-delivery-outcome']);
+const REEMIT_EXCLUDED_PREFIX = 'progress-delivery';
+type Emit = (category: string, event: string, data: Record<string, unknown>) => void;
+
+/** Reemit only complete ledger records; offsets name the first byte of each line in the Pod ledger. */
+function reemitLedgerLines(jsonl: string, runId: string, startOffset: number, emit: Emit): number {
+  let offset = startOffset;
+  let lines = 0;
+  for (const raw of jsonl.split('\n').slice(0, -1)) {
+    const podLedgerOffset = offset;
+    offset += Buffer.byteLength(raw) + 1;
+    try {
+      const entry: unknown = JSON.parse(raw);
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+      const { category, event, data } = entry as Record<string, unknown>;
+      if (typeof event !== 'string' || !event || event.startsWith(REEMIT_EXCLUDED_PREFIX)
+        || !data || typeof data !== 'object' || Array.isArray(data)) continue;
+      emit(typeof category === 'string' && category ? category : 'self-implement', event,
+        { ...data, runId, origin: 'pod', podLedgerOffset });
+      lines += 1;
+    } catch (error) {
+      try { debug.log('self-implement.pod', 'reemit-failed', { runId, reason: error instanceof Error ? error.message : String(error) }); }
+      catch { /* Host log failure must not interrupt the ledger append or collection. */ }
+    }
+  }
+  return lines;
+}
 
 /** Reassemble only complete, unambiguous transfers; retain good runs when another run is incomplete. */
 export function parsePodLedgerChunks(logs: string): ParseResult {
@@ -68,9 +94,10 @@ export function parsePodLedgerChunks(logs: string): ParseResult {
  *  except a ledger that THIS run's live follower created (`replace`): that one is a partial copy and the final is complete. */
 export function collectPodLedgers(
   logs: string,
-  { dir = runLedgerDir(), log = (c, e, d) => debug.log(c, e, d), replace = new Set<string>() }: {
+  { dir = runLedgerDir(), log = (c, e, d) => debug.log(c, e, d), emit = (c, e, d) => debug.log(c, e, d), replace = new Set<string>() }: {
     dir?: string;
     log?: (category: string, event: string, data: Record<string, unknown>) => void;
+    emit?: Emit;
     replace?: ReadonlySet<string>;
   } = {},
 ): void {
@@ -82,7 +109,11 @@ export function collectPodLedgers(
   for (const { runId, jsonl } of ledgers) {
     try {
       mkdirSync(dir, { recursive: true });
-      writeFileSync(runLedgerPath(runId, dir), jsonl, { flag: replace.has(runId) ? 'w' : 'wx' });
+      const path = runLedgerPath(runId, dir);
+      const previousBytes = replace.has(runId) && existsSync(path) ? readFileSync(path).length : 0;
+      writeFileSync(path, jsonl, { flag: replace.has(runId) ? 'w' : 'wx' });
+      const newLines = Buffer.from(jsonl).subarray(previousBytes).toString('utf8');
+      reemitLedgerLines(newLines, runId, previousBytes, emit);
       log('self-implement.pod', 'ledger-collected', { runId, lines: jsonl.split('\n').filter(Boolean).length, bytes: Buffer.byteLength(jsonl) });
     } catch (e) {
       if ((e as NodeJS.ErrnoException).code === 'EEXIST') {
@@ -109,12 +140,14 @@ export function createPodLedgerFollower(opts: {
   exec: (script: string) => { status: number | null; stdout: string; stderr: string };
   dir?: string;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  emit?: Emit;
   stallMinutes?: number;
   now?: () => number;
   onStall?: (message: string) => void;
 }): { poll(): void; readonly owned: boolean } {
   const dir = opts.dir ?? runLedgerDir();
   const log = opts.log ?? ((c, e, d) => debug.log(c, e, d));
+  const emit: Emit = opts.emit ?? ((c, e, d) => debug.log(c, e, d));
   const now = opts.now ?? Date.now;
   const stallMinutes = opts.stallMinutes ?? 30;
   if (!Number.isFinite(stallMinutes) || stallMinutes <= 0) throw new RangeError('stallMinutes must be positive');
@@ -188,17 +221,24 @@ export function createPodLedgerFollower(opts: {
       mkdirSync(dir, { recursive: true });
       appendFileSync(path, complete);
       owned = true;
+      const reemitted = reemitLedgerLines(complete, opts.runId, offset - Buffer.byteLength(text), emit);
+      if (reemitted) {
+        try { debug.log('self-implement.pod', 'reemitted', { runId: opts.runId, lines: reemitted }); }
+        catch { /* The observation cannot interrupt following. */ }
+      }
       log('self-implement.pod', 'ledger-live-appended', { runId: opts.runId, lines: complete.split('\n').filter(Boolean).length, bytes: Buffer.byteLength(complete), offset });
       for (const line of complete.split('\n')) {
         if (!line) continue;
         let logEvent: ReturnType<typeof ledgerLineToLogEvent>;
-        try {
-          logEvent = ledgerLineToLogEvent(line, opts.runId);
-          if (logEvent) log(logEvent.category, logEvent.event, logEvent.data);
-        } catch { /* A failed host log write must not interrupt ledger following or stall accounting. */ }
         let entry: unknown;
         try { entry = JSON.parse(line); } catch { continue; }
         const event = (entry && typeof entry === 'object' && 'event' in entry) ? entry.event : undefined;
+        try {
+          if (typeof event === 'string' && !event.startsWith(REEMIT_EXCLUDED_PREFIX)) {
+            logEvent = ledgerLineToLogEvent(line, opts.runId);
+            if (logEvent && opts.log) log(logEvent.category, logEvent.event, logEvent.data);
+          }
+        } catch { /* A failed host log write must not interrupt ledger following or stall accounting. */ }
         if (typeof event !== 'string' || !event || NON_PROGRESS_EVENTS.has(event)) continue;
         const idleMinutes = Math.max(0, (now() - lastProgressAt) / 60_000);
         if (stalled) log('self-implement.pod', 'stall-cleared', { runId: opts.runId, idleMinutes });

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

@@ -19,7 +19,7 @@ import { join, resolve } from 'node:path';
 import { debug } from '../../debug/log.js';
 import { PodLeaseAdmission, type PodLeasePredecessor, type PodLeaseRelease } from '../../pod-lease/admission.js';
 import { predecessorState, type PredecessorState } from '../../pod-lease/dependency-state.js';
-import { HostPoolLease } from '../../pod-lease/host-lease.js';
+import { HostPoolLease, leaseHasPendingPod } from '../../pod-lease/host-lease.js';
 import { measurePoolLease, recommendConcurrency, type PoolDnsProbe, type PoolLeaseRecommendation } from './pod-lease.js';
 
 export interface PodPoolMember {
@@ -143,6 +143,10 @@ export function genericConfigPodPool(config: { pod?: { pool?: string }; harness?
 }
 
 /** 노드 자리 배분 — 우선순위 순서로 첫 빈 자리. 순수(시각·대기는 호출자가). */
+export function podPoolHostLease(members: readonly PodPoolMember[]): HostPoolLease {
+  return new HostPoolLease([...members.map((m) => `${m.context}@${m.sshHost ?? ''}`)].sort().join(','));
+}
+
 export class PodPoolScheduler {
   private readonly inflight = new Map<string, number>();
   private readonly admission: PodLeaseAdmission;
@@ -157,7 +161,7 @@ export class PodPoolScheduler {
   constructor(readonly members: readonly PodPoolMember[], options: { status?: () => PoolLeaseRecommendation | Promise<PoolLeaseRecommendation>; kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; pollMs?: number; hostLease?: HostPoolLease; dependencyMerged?: (after: PodLeasePredecessor, signal?: AbortSignal) => PredecessorState | boolean | Promise<PredecessorState | boolean> } = {}) {
     this.pollMs = options.pollMs ?? 15_000;
     // One lease directory per pool (contexts, not caps) — every CLI process launching into the same clusters shares it.
-    this.hostLease = options.hostLease ?? new HostPoolLease([...members.map((m) => `${m.context}@${m.sshHost ?? ''}`)].sort().join(','));
+    this.hostLease = options.hostLease ?? podPoolHostLease(members);
     const measureStatus = options.status ?? (() => {
       const measure = measurePoolLease(members, { ...(options.kubectl ? { kubectl: options.kubectl } : {}), ...(options.dns ? { dns: options.dns } : {}) });
       return recommendConcurrency(measure, { capacity: members.reduce((n, m) => n + m.capacity, 0), accounts: 0, perAccount: 0 });
@@ -166,9 +170,13 @@ export class PodPoolScheduler {
     this.admission = new PodLeaseAdmission({ status: async () => {
       const measured = await measureStatus();
       this.lastRaw = measured;
-      // Launches admitted by other processes on this host but not yet visible as Jobs hold free slots too.
-      const others = measured.recommended === null ? 0 : this.hostLease.othersPending();
-      const decision = measured.recommended === null ? measured : { ...measured, recommended: Math.max(0, measured.recommended - others) };
+      const pendingJobs = measured.pendingJobs ?? [];
+      const ownStart = this.hostLease.selfStart();
+      const transferId = process.env.ELANOUS_POD_RESERVED_LEASE;
+      const transferIsOther = !!transferId && this.hostLease.reservationIsOther(transferId);
+      const others = measured.recommended === null ? 0 : this.hostLease.live().filter((r) =>
+        (r.pid !== process.pid || r.startedAt !== ownStart) && !leaseHasPendingPod(r, pendingJobs)).length;
+      const decision = measured.recommended === null ? measured : { ...measured, recommended: Math.max(0, measured.recommended - others + (transferIsOther ? 1 : 0)) };
       // An unknown reading cannot erase permits already granted: on recovery,
       // the first healthy recommendation must still account for their slots.
       if (decision.recommended === null) return decision;
@@ -181,19 +189,28 @@ export class PodPoolScheduler {
     }, ...(options.pollMs ? { pollMs: options.pollMs } : {}), dependencyMerged: options.dependencyMerged ?? ((after, signal) => predecessorState(after, {}, signal)) });
   }
   /** FIFO gate within this process, then a host lease so independent CLI processes cannot over-admit the same pool. */
-  async acquireAdmission(signal?: AbortSignal, after?: PodLeasePredecessor): Promise<PodLeaseRelease & { applied: () => void }> {
+  async acquireAdmission(signal?: AbortSignal, after?: PodLeasePredecessor): Promise<PodLeaseRelease & { applied: (job: string, context: string, namespace: string) => void; observed: () => void }> {
     const local = await this.acquireLocalAdmission(signal, after);
     try {
       for (;;) {
         if (signal?.aborted) throw new Error('pod lease admission aborted');
         const free = this.lastRaw?.recommended ?? null;
-        // Same check as the local gate, but atomic across processes: other unapplied leases must stay under the free slots.
-        const lease = free !== null && free > 0 ? this.hostLease.tryReserve((others) => others < free) : null;
+        // Same check as the local gate, but atomic across processes: other authoring and pre-Running leases hold slots.
+        const reservedId = process.env.ELANOUS_POD_RESERVED_LEASE;
+        const transferred = reservedId ? this.hostLease.claim(reservedId) : null;
+        if (reservedId && !transferred) throw new Error('pod lease: authoring reservation could not be transferred');
+        if (transferred) delete process.env.ELANOUS_POD_RESERVED_LEASE;
+        const pendingJobs = this.lastRaw?.pendingJobs ?? [];
+        const lease = transferred ?? (free !== null && free > 0 ? this.hostLease.tryReserve((others) =>
+          others - this.hostLease.live().filter((r) => leaseHasPendingPod(r, pendingJobs) &&
+            (r.pid !== process.pid || r.startedAt !== this.hostLease.selfStart())).length < free) : null);
         if (lease) {
           let hostReleased = false;
           const releaseHost = () => { if (!hostReleased) { hostReleased = true; lease(); } };
-          // Once the Job is applied the cluster measurement counts it — the host lease would double count.
-          return Object.assign(() => { releaseHost(); local(); }, { applied: releaseHost });
+          return Object.assign(() => { releaseHost(); local(); }, {
+            applied: (job: string, context: string, namespace: string) => lease.applied(job, context, namespace),
+            observed: releaseHost,
+          });
         }
         await new Promise<void>((resolve, reject) => {
           const timer = setTimeout(() => { signal?.removeEventListener('abort', onAbort); resolve(); }, this.pollMs);

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

@@ -40,7 +40,7 @@ export const POD_JOB_DEADLINE_SECONDS = 10_800;
  *  예약만 실사용에 맞춘다. */
 export const POD_CHILD_REQUESTS = { cpu: '1', memory: '4Gi' } as const;
 import type { PodPoolMember, PodPoolScheduler } from './pod-pool.js';
-import { measurePoolLease, recommendConcurrency, POD_HOST_LEASE_ANNOTATION } from './pod-lease.js';
+import { measurePoolLease, recommendConcurrency, POD_HOST_LEASE_ANNOTATION, LEASE_KUBECTL_MAX_BUFFER } 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';
@@ -58,6 +58,9 @@ import { envLiteral } from '../../platform/env-literal.js';
 import { LLM_TIER_MAP_BY_PROVIDER, lookupLlmTierSpec, type LlmTierProvider } from '../../model-tier/llm-tier-map.js';
 import { parseSelfImplementJson, type SelfImplementJobDone, type SelfImplementJobSpawn } from './self-implement.js';
 import { codexQuotaPolicyFromConfig } from '../../oauth/codex-account-store.js';
+import { goalTypeOf, type GoalType } from '../../../scripts/measure-pod-memory-by-goal.js';
+import { readPodMemoryAdvice, type PodMemoryAdvice } from '../../cli/pod-memory-advice.js';
+import { getUserConfig } from '../../user-config.js';
 
 export type Kubectl = (args: readonly string[], input?: string) => { status: number | null; stdout: string; stderr: string };
 
@@ -132,14 +135,21 @@ export interface PodSpawnOptions {
   env?: NodeJS.ProcessEnv;
   /** Detail switch file (test injection; defaults to the host's local/production selection). */
   liveDetailFile?: string;
+  /** Test seam for the opt-in user configuration; otherwise read the active user config. */
+  adviseDefaults?: boolean;
+  /** Test seam for the read-only measured advice. */
+  memoryAdvice?: () => PodMemoryAdvice;
 }
 
 export function defaultKubectl(args: readonly string[], input?: string): { status: number | null; stdout: string; stderr: string } {
   // 셸 프록시가 kubectl 의 로컬 API 요청을 가로챈다(2026-09-25 실측) — 자식 env 에서 뺀다.
   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', input, env, timeout: 120_000 });
-  return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? String(r.error) : '') };
+  const r = spawnSync('kubectl', [...args], { encoding: 'utf8', input, env, timeout: 120_000, maxBuffer: LEASE_KUBECTL_MAX_BUFFER });
+  const error = (r.error as NodeJS.ErrnoException | undefined)?.code === 'ENOBUFS'
+    ? `kubectl 출력 너무 큼 (ENOBUFS; maxBuffer=${LEASE_KUBECTL_MAX_BUFFER} bytes)`
+    : r.error ? String(r.error) : '';
+  return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + error };
 }
 
 /** Job·Secret 이름 — 런마다 다르게(병렬) · k8s 이름 규칙(소문자·숫자·하이픈 · 63자 이하). */
@@ -213,6 +223,46 @@ export function hostGrokCredentials(opts: {
   throw new Error('grok: 구독 자격 없음 · API 키 opt-in 꺼짐 또는 키 없음');
 }
 
+export type PodGrokSkipReason = 'missing' | 'expiring' | 'refresh-failed';
+
+/** GROK-OPTIONAL (10-05) — may this launch plan put grok in the Pod's chain at all?
+ *  The Pod copy must outlive the Job (POD_GROK_MIN_VALIDITY_MS), so an expiring subscription that the host cannot
+ *  refresh is «not available» here: the plan drops grok and goes on with codex instead of failing every launch. */
+export function podGrokSubscriptionUsable(opts: {
+  home?: string; env?: NodeJS.ProcessEnv;
+  refresh?: () => void; isExpiring?: () => boolean; expiresAt?: () => string | null;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+} = {}): { usable: true } | { usable: false; reason: PodGrokSkipReason; expiresAt: string | null } {
+  const log = opts.log ?? ((category, event, data) => debug.log(category, event, data));
+  const expiresAt = () => {
+    if (opts.expiresAt) return opts.expiresAt();
+    try {
+      const scopes = JSON.parse(readFileSync(grokAuthFilePath(opts.home), 'utf8')) as Record<string, { expires_at?: unknown }>;
+      const all = Object.values(scopes).flatMap((s) => (s && typeof s.expires_at === 'string' ? [s.expires_at] : []));
+      return all.sort().at(-1) ?? null;
+    } catch { return null; }
+  };
+  const skip = (reason: PodGrokSkipReason) => {
+    const at = expiresAt();
+    try { log('pod.grok-credentials', 'skipped', { reason, expiresAt: at }); } catch { /* observation is fail-soft */ }
+    return { usable: false as const, reason, expiresAt: at };
+  };
+  const credential = resolveGrokCredential({ home: opts.home, env: opts.env });
+  if (credential?.kind !== 'subscription') return skip('missing');
+  const expiring = opts.isExpiring ?? (() => isGrokSubscriptionExpiring({ home: opts.home, bufferMs: POD_GROK_MIN_VALIDITY_MS }));
+  if (!expiring()) return { usable: true };
+  let refreshed = true;
+  try { (opts.refresh ?? (() => { refreshGrokSubscriptionToken({ home: opts.home }); }))(); } catch { refreshed = false; }
+  if (!expiring()) return { usable: true };
+  return skip(refreshed ? 'expiring' : 'refresh-failed');
+}
+
+/** The one launch line for a skipped grok copy — the reader sees why grok left this run's chain. */
+export function podGrokSkippedLine(skip: { reason: PodGrokSkipReason; expiresAt: string | null }): string {
+  const why = skip.reason === 'missing' ? '구독 자격 없음' : skip.reason === 'expiring' ? '만료 임박' : '만료 임박 · 호스트 갱신 실패';
+  return `⚠️ grok 자격 없음(${why}${skip.expiresAt ? ` · 만료 ${skip.expiresAt}` : ''}) — 이 런의 폴백 체인에서 grok 을 뺐다`;
+}
+
 /** 키 캐시 관례: `~/.cache/<env 이름 소문자>`(예: OPENROUTER_API_KEY → ~/.cache/openrouter_api_key · src/config.ts 와 같다). */
 function defaultReadKeyCache(name: string): string | undefined {
   try { const v = readFileSync(join(homedir(), '.cache', name.toLowerCase()), 'utf8').trim(); return v || undefined; } catch { return undefined; }
@@ -409,9 +459,23 @@ export const POD_MEMORY_DEFAULT = '16Gi';
 export const POD_MEMORY_HIGH_DEFAULT = '32Gi';
 /** POD7 — `lite`(`ELANOUS_POD_MEMORY_LITE` 또는 2Gi): 명시할 때만(인자·문면 줄) · 자동 판정은 없다(성공 런 피크 기록 0 — 설계 §②). OOM 이면 POD9 가 high 로 한 번 다시 띄운다. */
 export const POD_MEMORY_LITE_DEFAULT = '2Gi';
+
+/** Reserve from measured per-run peaks, never from the advisory limit tier. Sparse or missing measurements keep the old reservation. */
+export function podMemoryRequestFor(kind: GoalType | null, advice?: PodMemoryAdvice): string {
+  const evidence = advice?.byGoalType.find((entry) => entry.goalType === kind)?.evidence;
+  const peak = evidence?.peakMiB.p95;
+  const reason = !kind ? 'unknown-kind' : !evidence ? 'no-advice'
+    : evidence.measured < 3 || evidence.runs < 3 || evidence.measured * 2 < evidence.runs ? 'insufficient-sample'
+      : peak === null || peak === undefined || !Number.isFinite(peak) || peak < 0 ? 'no-peak' : null;
+  if (reason) {
+    debug.log('pod.memory', 'request-default', { kind, reason });
+    return POD_CHILD_REQUESTS.memory;
+  }
+  return `${Math.max(1, Math.ceil(peak! * 1.25 / 1024))}Gi`;
+}
 export const POD_MEMORY_TIERS = ['lite', 'standard', 'high'] as const;
 export type PodMemoryTier = (typeof POD_MEMORY_TIERS)[number];
-export type PodMemorySource = 'option' | 'goal-line' | 'pwa-auto' | 'default' | 'parent-goal-line' | 'parent-pwa-auto';
+export type PodMemorySource = 'option' | 'goal-line' | 'pwa-auto' | 'default' | 'parent-goal-line' | 'parent-pwa-auto' | 'advise';
 const PWA_PATH = /(?:^|[\s`'"(,·])apps\/pwa\//m;
 const GOAL_LINE = /^[ \t]*(?:Pod 메모리|pod-memory)[ \t]*:[ \t]*(lite|standard|high)[ \t]*\r?$/im;
 
@@ -453,14 +517,21 @@ function memoryGi(v: string): number | null {
   return m[2] === 'Gi' ? Number(m[1]) : Number(m[1]) / 1024;
 }
 
-export function podMemoryLimitFor(feature: string, env: NodeJS.ProcessEnv | Readonly<Record<string, string | undefined>>, parentGoal?: string): { limit: string; tier: PodMemoryTier; source: PodMemorySource } {
+export function podMemoryLimitFor(feature: string, env: NodeJS.ProcessEnv | Readonly<Record<string, string | undefined>>, parentGoal?: string, advice?: PodMemoryAdvice): { limit: string; tier: PodMemoryTier; source: PodMemorySource } {
   const option = parsePodMemoryTier(env.ELANOUS_POD_MEMORY_TIER);
   const line = parsePodMemoryTier(GOAL_LINE.exec(feature)?.[1]);
-  const parentLine = !option && !line && !goalTouchesPwa(feature) ? parsePodMemoryTier(GOAL_LINE.exec(parentGoal ?? '')?.[1]) : null;
+  const parentLine = !option && !line ? parsePodMemoryTier(GOAL_LINE.exec(parentGoal ?? '')?.[1]) : null;
+  const goalType = advice && !option && !line && !parentLine
+    ? (broadPodTestWarning(feature) ? 'test' : goalTypeOf(feature))
+      ?? (parentGoal ? (broadPodTestWarning(parentGoal) ? 'test' : goalTypeOf(parentGoal)) : null)
+    : null;
+  const recommendation = advice?.byGoalType.find((entry) => entry.goalType === goalType && entry.evidence.runs > 0)?.recommended;
   const [tier, source]: [PodMemoryTier, PodMemorySource] = option ? [option, 'option']
     : line ? [line, 'goal-line']
+    // 조각 자신의 PWA 경로가 부모 줄·실측 권고보다 먼저다 — 부모 «standard» 가 PWA 조각을 16Gi 로 내리면 OOM(POD7 · #23569 순서 회귀)
     : goalTouchesPwa(feature) ? ['high', 'pwa-auto']
     : parentLine ? [parentLine, 'parent-goal-line']
+    : recommendation ? [recommendation, 'advise']
     : parentGoal && goalTouchesPwa(parentGoal) ? ['high', 'parent-pwa-auto']
     : ['standard', 'default'];
   if (tier === 'lite') return { limit: env.ELANOUS_POD_MEMORY_LITE?.trim() || POD_MEMORY_LITE_DEFAULT, tier, source };
@@ -471,7 +542,7 @@ export function podMemoryLimitFor(feature: string, env: NodeJS.ProcessEnv | Read
   return { limit: a !== null && b !== null && a > b ? base : high, tier, source };
 }
 
-export function podJobManifest(o: { name: string; namespace: string; image: string; /** 레지스트리 이미지면 IfNotPresent(노드가 pull) · 반입 이미지면 Never. */ imagePullPolicy?: 'Never' | 'IfNotPresent'; repoUrl: string; source?: PodSource; hostMirror?: string; args: readonly string[]; passEnv: readonly string[]; deadlineSeconds: number; runId?: string; parentRunId?: string; armEnv?: Readonly<Record<string, string>>; hostId?: string; imageCommit?: string | null; skillEnvs?: readonly string[]; memoryLimit?: string; goalDoc?: string; grokCredential?: 'subscription' | 'api_key'; codexAccounts?: readonly string[]; appCredential?: boolean; /** Test seam — default POD_GH_STALE_SECONDS. */ githubStaleSeconds?: number; /** Which goal execution and attempt this Job is — a resumed host verifies it before following the Job (POD9). */ execution?: { key: string; attempt: number }; hostLeaseAdmitted?: boolean }): Record<string, unknown> {
+export function podJobManifest(o: { name: string; namespace: string; image: string; /** 레지스트리 이미지면 IfNotPresent(노드가 pull) · 반입 이미지면 Never. */ imagePullPolicy?: 'Never' | 'IfNotPresent'; repoUrl: string; source?: PodSource; hostMirror?: string; args: readonly string[]; passEnv: readonly string[]; deadlineSeconds: number; runId?: string; parentRunId?: string; armEnv?: Readonly<Record<string, string>>; hostId?: string; imageCommit?: string | null; skillEnvs?: readonly string[]; memoryLimit?: string; memoryRequest?: string; goalDoc?: string; grokCredential?: 'subscription' | 'api_key'; codexAccounts?: readonly string[]; appCredential?: boolean; /** Test seam — default POD_GH_STALE_SECONDS. */ githubStaleSeconds?: number; /** Which goal execution and attempt this Job is — a resumed host verifies it before following the Job (POD9). */ execution?: { key: string; attempt: number }; hostLeaseAdmitted?: boolean }): Record<string, unknown> {
   const quoted = o.args.map((a) => `'${a.replace(/'/g, `'\\''`)}'`).join(' ');
   const goalPath = o.goalDoc ? `'${(o.goalDoc.startsWith('-') ? `./${o.goalDoc}` : o.goalDoc).replace(/'/g, `'\\''`)}'` : undefined;
   const askBaseIndex = o.goalDoc ? o.args.indexOf('--base') : -1;
@@ -584,8 +655,8 @@ if [ "$found" -eq 0 ]; then echo ELANOUS_RUN_LEDGER_NONE; fi`,
             name: 'child', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never',
             // 📏 09-25: 6Gi 는 빠듯했다 — 자식이 6,127Mi 에 붙어 OOMKilled(137) → 12Gi.
             // 📏 09-27: 12Gi 에서도 OOMKilled 셋(구현 노드 도중) — 같은 골을 16Gi 로 다시 쏘니 끝까지 갔다(#20930) → 기본 16Gi.
-            //   요청(4Gi · POD_CHILD_REQUESTS)과 따로라 자리 계산은 안 바뀐다. ELANOUS_POD_MEMORY 로 조정.
-            resources: { requests: { ...POD_CHILD_REQUESTS }, limits: { memory: o.memoryLimit ?? POD_MEMORY_DEFAULT, cpu: '4' } },
+            //   요청은 실측 피크별로 고르고 상한은 독립적으로 유지한다. ELANOUS_POD_MEMORY 로 상한 조정.
+            resources: { requests: { ...POD_CHILD_REQUESTS, memory: o.memoryRequest ?? POD_CHILD_REQUESTS.memory }, limits: { memory: o.memoryLimit ?? POD_MEMORY_DEFAULT, cpu: '4' } },
             command: ['bash', '-c'], args: [script],
             env: [
               ...(o.runId ? [{ name: 'ELANOUS_RUN_ID', value: o.runId }] : []),
@@ -640,7 +711,6 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
   const hostSupervised = options.hostSupervised ?? true;
   return (input) => {
     const name = podJobName(input.spaceId);
-    const featureMemory = podMemoryLimitFor(input.feature, env);
     let parentGoal: string | undefined;
     let parentGoalUnreadable = false;
     let inheritedFrom: string | undefined;
@@ -658,7 +728,14 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
         inheritedFrom = withinRoot;
       } catch { parentGoalUnreadable = true; }
     }
-    const { limit: selectedMemoryLimit, tier: memoryTier, source: memorySource } = parentGoal === undefined ? featureMemory : podMemoryLimitFor(input.feature, env, parentGoal);
+    let advice: PodMemoryAdvice | undefined;
+    const explicitMemory = Boolean(parsePodMemoryTier(env.ELANOUS_POD_MEMORY_TIER) || GOAL_LINE.test(input.feature) || GOAL_LINE.test(parentGoal ?? ''));
+    const useAdvice = options.adviseDefaults ?? getUserConfig().pod?.memory?.adviseDefaults === true;
+    try { advice = (options.memoryAdvice ?? readPodMemoryAdvice)(); }
+    catch (error) { debug.log('self-implement.pod', 'memory-advice-unavailable', { spaceId: input.spaceId, reason: error instanceof Error ? error.message : String(error) }, { level: 'warn' }); }
+    const { limit: selectedMemoryLimit, tier: memoryTier, source: memorySource } = podMemoryLimitFor(input.feature, env, parentGoal, useAdvice && !explicitMemory ? advice : undefined);
+    const requestKind = broadPodTestWarning(input.feature) ? 'test' : goalTypeOf(input.feature)
+      ?? (parentGoal ? (broadPodTestWarning(parentGoal) ? 'test' : goalTypeOf(parentGoal)) : null);
     for (const [where, text] of [['feature', input.feature], ['parent-goal', parentGoal]] as const) {
       if (text && text.split(/\r?\n/u).some((line) => /Pod 메모리/u.test(line) && !GOAL_LINE.test(line))) {
         const reason = '한 줄 단독 `Pod 메모리: high|standard` 형식이 아님';
@@ -674,7 +751,7 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
     let oomRetried = false;
     let retryFromChildRunId: string | undefined;
     let retryFromMemoryLimit: string | undefined;
-    debug.log('self-implement.pod', 'memory-limit', { spaceId: input.spaceId, memoryLimit, tier: memoryTier, source: memorySource,
+    debug.log('self-implement.pod', 'memory-limit', { spaceId: input.spaceId, goalType: requestKind, memoryLimit, tier: memoryTier, source: memorySource,
       ...(memorySource.startsWith('parent-') ? { inheritedFrom } : {}), ...(parentGoalUnreadable ? { parentGoal: 'unreadable' } : {}) });
     const childRunId = mintRunId();
     const executionKey = createHash('sha256').update(JSON.stringify({ spaceId: input.spaceId, feature: input.feature, base: input.base, autoMerge: input.autoMerge, autoReview: input.autoReview, openPr: input.openPr, draft: input.draft })).digest('hex');
@@ -716,7 +793,7 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
       if (recoveryError) return { exitCode: 1, output: '', error: { code: 'pod-oom-recovery', message: recoveryError } };
       // Each Job attempt has its own host lease; releasing the first after OOM lets the retry
       // compete with other processes for the newly measured capacity before applying another Job.
-      let releaseAdmission: ((() => void) & { applied?: () => void }) | undefined;
+      let releaseAdmission: ((() => void) & { applied?: (job: string, context: string, namespace: string) => void; observed?: () => void }) | undefined;
       try {
       // Every attempt, including an OOM retry, must acquire a pool slot before applying a Job.
       const acquireSlot = async (): Promise<PodPoolMember | null> => {
@@ -1054,19 +1131,26 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
         const detailUntil = detail && (detail.scope === 'all' || detail.scope === parentRunId || detail.scope === launchRunId) && detail.until > Date.now()
           ? String(detail.until) : undefined;
         const armEnv = Object.fromEntries(Object.entries(options.armEnv ?? {}).filter(([key]) => key !== 'ELANOUS_LIVE_DETAIL_UNTIL' && key !== POD_GITHUB_CREDENTIAL_TOKEN_ENV && key !== POD_GITHUB_CREDENTIAL_URL_ENV && (!hostRefresh || !['GH_TOKEN', 'GITHUB_TOKEN', 'GH_CONFIG_DIR'].includes(key))));
-        const jobArmEnv = grounding || credentialRelay || githubRelay || env.ELANOUS_DISPATCH_RECORDED === '1' || options.armEnv || detailUntil
+        const seat = env.ELANOUS_HARNESS_SEAT;
+        const jobArmEnv = grounding || credentialRelay || githubRelay || env.ELANOUS_DISPATCH_RECORDED === '1' || options.armEnv || detailUntil || seat
           ? {
               ...armEnv,
               ...(detailUntil ? { ELANOUS_LIVE_DETAIL_UNTIL: detailUntil } : {}),
               ...(env.ELANOUS_DISPATCH_RECORDED === '1' ? { ELANOUS_DISPATCH_RECORDED: '1' } : {}),
+              ...(seat === 'OP' || seat === 'TC' || seat === 'MK' || seat === 'UX' ? { ELANOUS_HARNESS_SEAT: seat } : {}),
               ...(grounding ? { [GROUNDING_URL_ENV]: groundingUrl! } : {}),
               ...(credentialRelay ? { [POD_CREDENTIAL_URL_ENV]: `${new URL(groundingUrl!).origin}${POD_CREDENTIAL_GROK_PATH}` } : {}),
               ...(githubRelay ? { [POD_GITHUB_CREDENTIAL_URL_ENV]: `${new URL(groundingUrl!).origin}${POD_CREDENTIAL_GITHUB_PATH}` } : {}),
             }
           : undefined;
-        const job = podJobManifest({ name, namespace, image: jobImage, ...(member?.imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}), repoUrl, ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), args, passEnv: jobPassEnv, deadlineSeconds: options.deadlineSeconds ?? POD_JOB_DEADLINE_SECONDS, ...(goalDoc ? { goalDoc } : {}), runId: launchRunId, ...(parentRunId ? { parentRunId } : {}), ...(jobArmEnv ? { armEnv: jobArmEnv } : {}), hostId: resolveHostId(env), skillEnvs: Object.keys(skillEnvs), memoryLimit, imageCommit: options.imageCommit !== undefined ? options.imageCommit : options.kubectl ? null : podImageFreshness({ image }).imageCommit, ...(grok ? { grokCredential: 'grokAuth' in creds && creds.grokAuth ? 'subscription' as const : 'api_key' as const } : {}), ...(codexAccounts ? { codexAccounts } : {}), ...(hostRefresh ? { appCredential: true } : {}), execution: { key: executionKey, attempt: oomRetried ? 2 : 1 }, hostLeaseAdmitted: !!releaseAdmission });   // kubectl 주입(=시험)이면 docker 를 부르지 않는다
+        const measuredRequest = podMemoryRequestFor(requestKind, advice);
+        const requestGi = memoryGi(measuredRequest);
+        const limitGi = memoryGi(memoryLimit);
+        const memoryRequest = requestGi !== null && limitGi !== null && requestGi > limitGi ? memoryLimit : measuredRequest;
+        const job = podJobManifest({ name, namespace, image: jobImage, ...(member?.imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}), repoUrl, ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), args, passEnv: jobPassEnv, deadlineSeconds: options.deadlineSeconds ?? POD_JOB_DEADLINE_SECONDS, ...(goalDoc ? { goalDoc } : {}), runId: launchRunId, ...(parentRunId ? { parentRunId } : {}), ...(jobArmEnv ? { armEnv: jobArmEnv } : {}), hostId: resolveHostId(env), skillEnvs: Object.keys(skillEnvs), memoryLimit, memoryRequest, imageCommit: options.imageCommit !== undefined ? options.imageCommit : options.kubectl ? null : podImageFreshness({ image }).imageCommit, ...(grok ? { grokCredential: 'grokAuth' in creds && creds.grokAuth ? 'subscription' as const : 'api_key' as const } : {}), ...(codexAccounts ? { codexAccounts } : {}), ...(hostRefresh ? { appCredential: true } : {}), execution: { key: executionKey, attempt: oomRetried ? 2 : 1 }, hostLeaseAdmitted: !!releaseAdmission });   // kubectl 주입(=시험)이면 docker 를 부르지 않는다
         const a = kubectl(['apply', '-f', '-'], JSON.stringify(job));
         if (a.status !== 0) { cleanupSecret(); return { exitCode: 1, output: a.stderr, error: { code: 'pod-apply', message: a.stderr.trim() } }; }
+        releaseAdmission?.applied?.(name, context, namespace);
         if (options.source?.kind === 'bundle') {
           const podName = await waitForRunningPod(kubectl, namespace, name, sleep);
           if (!podName) {
@@ -1074,6 +1158,8 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
             cleanupSecret();
             return { exitCode: 1, output: '', error: { code: 'pod-source', message: `Pod for ${name} did not become Running` } };
           }
+          releaseAdmission?.observed?.();
+          if (releaseAdmission) delete releaseAdmission.observed;
           const copied = kubectl(['cp', options.source.bundlePath, `${podName}:/tmp/source.bundle`, '-c', 'child', '-n', namespace]);
           if (copied.status !== 0) {
             debug.log('self-implement.pod', 'source-mismatch', { job: name, kind: 'bundle', headCommit: options.source.headCommit });
@@ -1106,7 +1192,6 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
         }
         writePodFragment({ spaceId: input.spaceId, context, namespace, job: name, inboxDir: POD_CONTROL_INBOX_DIR, ...(liveChildRunId === normalizeRunId(liveChildRunId) ? { runId: liveChildRunId } : {}), ...(parentRunId && normalizeRunId(parentRunId) === parentRunId ? { parentRunId } : {}) }, env);
         recorded = true;
-        releaseAdmission?.applied?.();
         debug.log('self-implement.pod', 'job-applied', { job: name, namespace, ...(member ? { context: member.context } : {}), image: jobImage, spaceId: input.spaceId, passEnv, extraArgs: options.extraArgs ?? [], ...(options.armEnv?.ELANOUS_ARM_ID ? { armId: options.armEnv.ELANOUS_ARM_ID } : {}) });
         let state: 'complete' | 'failed' | 'aborted' = 'failed';
         let failedReason = '';
@@ -1122,8 +1207,9 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
           }
           const g = kubectl(['-n', namespace, 'get', 'job', name, '-o', 'jsonpath={.status.conditions[*].type}']);
           const types = g.stdout;
-          if (/Complete|SuccessCriteriaMet/.test(types)) { state = 'complete'; break; }
+          if (/Complete|SuccessCriteriaMet/.test(types)) { releaseAdmission?.observed?.(); state = 'complete'; break; }
           if (/Failed|FailureTarget/.test(types)) {
+            releaseAdmission?.observed?.();
             state = 'failed';
             const reason = kubectl(['-n', namespace, 'get', 'job', name, '-o', 'jsonpath={.status.conditions[?(@.type=="Failed")].reason}']);
             failedReason = reason.status === 0 ? reason.stdout.trim() : '';
@@ -1143,6 +1229,13 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
             debug.log('self-implement.pod', 'container-terminated', { job: name, container: 'child', reason: containerReason, exitCode: containerExitCode, jobReason: failedReason || null, memoryLimit });
             break;
           }
+          if (releaseAdmission?.observed) {
+            const podPhase = kubectl(['-n', namespace, 'get', 'pods', '-l', `job-name=${name}`, '-o', 'jsonpath={.items[*].status.phase}']);
+            if (podPhase.status === 0 && /\b(?:Running|Succeeded|Failed)\b/.test(podPhase.stdout)) {
+              releaseAdmission.observed();
+              delete releaseAdmission.observed;
+            }
+          }
           if (ghTokenExpiresAt !== null && ghTokenExpiresAt - now() <= 10 * 60_000) {
             try {
               const fresh = await issueVerifiedAppCredential();
@@ -1237,7 +1330,8 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
             catch (error) { debug.log('harness.host-regate', 'unmeasured', { pr: prNumber, files: [], os: process.platform, failedStep: 'comment', detail: error instanceof Error ? error.message : String(error) }); }
           }
           const releaseHold = regate.failures[0]?.step === 'release-path-hold';
-          disposition = { ...disposition, stage: regate.passed ? 'merged' : releaseHold ? 'pr-opened' : 'host-regate-failed', merged: regate.passed, hostRegate: regate, ok: regate.passed || releaseHold };
+          const frozen = regate.status === 'frozen';
+          disposition = { ...disposition, stage: frozen || releaseHold ? 'pr-opened' : regate.passed ? 'merged' : 'host-regate-failed', merged: regate.passed && !frozen, hostRegate: regate, ok: regate.passed || releaseHold || frozen };
         }
         const childFailure = state === 'failed' && !oomKilled && failedReason !== 'DeadlineExceeded'
           ? lastPodChildFailure(logs) : null;

package/src/telegram-commands.ts

@@ -14,6 +14,9 @@
 import type { TgIncoming, TgMessageStreamer } from './telegram.js';
 import type { UserConfig } from './user-config.js';
 import { botCommandsToTelegram } from './bots/command-surface.js';
+import { SLASH_COMMANDS, type SlashCommand } from './chat/index.js';
+import { FEATURE_MATURITY, type Maturity } from './maturity/feature-maturity.js';
+import { buildBotSlashCatalog } from './maturity/bot-slash-catalog.js';
 import {
   appendMessage,
   attachTelegramBinding,
@@ -46,6 +49,7 @@ import { classifyIntake } from './ad-pipeline/intake.js';
 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 { createWishCard } from './intake-plane/wish-card.js';
 import { telegramDecisionOwner } from './decisions/telegram-decision-cards.js';
 import { CardStore } from './task-cards/card-store.js';
@@ -298,8 +302,12 @@ function dropChatSessionReply(ctx: TgIncoming): string {
 /** Build the default command set for a Telegram bot wired via
  *  botFromConfig. Returns the array rather than mutating globals so
  *  tests can construct a variant set with stubbed handlers. */
-export function defaultTelegramCommands(nowDeps?: ContextNowDeps): TgSlashCommand[] {
-  return [
+export function defaultTelegramCommands(
+  nowDeps?: ContextNowDeps,
+  coreCommands: readonly SlashCommand[] = SLASH_COMMANDS,
+  maturity: { tuiSlash: Readonly<Record<string, Maturity>>; telegramCommand: Readonly<Record<string, Maturity>>; discordCommand: Readonly<Record<string, Maturity>> } = FEATURE_MATURITY,
+): TgSlashCommand[] {
+  const handled: TgSlashCommand[] = [
     {
       name: 'help',
       description: 'List available commands',
@@ -316,6 +324,11 @@ export function defaultTelegramCommands(nowDeps?: ContextNowDeps): TgSlashComman
       description: 'Show current release, decisions, seats and context: /now [topic]',
       handler: async (args) => telegramNowSlash(args, nowDeps),
     },
+    {
+      name: 'loops',
+      description: '루프·크론 현황 — 늦음·실패를 먼저 보여줍니다',
+      handler: async (args) => telegramLoopsStatus(args),
+    },
     {
       name: 'status',
       description: 'Show bot identity, current session, provider + model',
@@ -604,7 +617,8 @@ export function defaultTelegramCommands(nowDeps?: ContextNowDeps): TgSlashComman
         if (args.length === 0) return '/wish <소원 한 줄>';
         const store = new CardStore();
         try {
-          const card = createWishCard({ text: args.join(' '), source: 'telegram', ref: `${ctx.chatId}:${ctx.messageId}` }, store);
+          const card = createWishCard({ text: args.join(' '), source: 'telegram', ref: `${ctx.chatId}:${ctx.messageId}`,
+            replyTo: { surface: 'telegram', chatId: String(ctx.chatId), ...(ctx.threadId != null ? { threadId: String(ctx.threadId) } : {}), ...(ctx.botId ? { botId: ctx.botId } : {}) } }, store);
           return `소원 카드로 남겼습니다 — ${card.title} (카드 ${card.cardId.slice(0, 8)})`;
         } finally {
           store.close();
@@ -951,6 +965,16 @@ export function defaultTelegramCommands(nowDeps?: ContextNowDeps): TgSlashComman
     },
     ...botCommandsToTelegram(),
   ];
+  const catalog = buildBotSlashCatalog({
+    surface: 'telegram', coreCommands, maturity,
+    handledCommands: handled,
+  });
+  const handlers = new Map(handled.map((command) => [command.name, command]));
+  return catalog.commands.map((entry) => handlers.get(entry.name) ?? {
+    name: entry.name,
+    description: entry.description,
+    handler: async () => catalog.unsupportedReply(entry.name)!,
+  });
 }
 
 /** Telegram-side adapter over the messenger-agnostic ACP turn runner.

package/src/telegram-dispatch-forward.ts

@@ -42,7 +42,7 @@ export function defaultBaseUrl(deps: { runtime?: () => ReturnType<typeof readNex
   return `http://${host}:${rt.httpPort}`;
 }
 
-function defaultToken(): string | null {
+export function defaultToken(): string | null {
   const p = join(getElanousConfigDir(), 'acp-token');
   try { return existsSync(p) ? readFileSync(p, 'utf-8').trim() || null : null; } catch { return null; }
 }