elanous 0.2.27 → 0.2.29

package/src/pod-lease/admission.ts

@@ -15,21 +15,27 @@ export interface PodLeaseAdmissionOptions {
   dependencyMerged?: (after: PodLeasePredecessor, signal?: AbortSignal) => PredecessorState | boolean | Promise<PredecessorState | boolean>;
   /** Recheck even when there are no local releases (another launcher may free a slot). */
   pollMs?: number;
+  /** Maximum time spent waiting for a free slot; defaults to 30 minutes (predecessor waits do not count). */
+  maxWaitMs?: number;
 }
 
 /** FIFO admission across launches sharing this instance. Unknown status never grants a slot. */
 export class PodLeaseAdmission {
-  private readonly queue: Array<{ resolve: (release: PodLeaseRelease) => void; reject: (error: Error) => void; signal?: AbortSignal; after?: PodLeasePredecessor; onAbort?: () => void; cancelCheck?: () => void; waitReason?: string }> = [];
+  private readonly queue: Array<{ resolve: (release: PodLeaseRelease) => void; reject: (error: Error) => void; signal?: AbortSignal; after?: PodLeasePredecessor; onAbort?: () => void; cancelCheck?: () => void; checkingDependency?: boolean; predecessorMerged?: boolean; waitReason?: string; waitStartedAt?: number }> = [];
   private active = 0;
   private limit = 0;
   private checking: Promise<void> | undefined;
   private recheckRequested = false;
   private timer: ReturnType<typeof setTimeout> | undefined;
+  private expiryTimer: ReturnType<typeof setTimeout> | undefined;
   private readonly pollMs: number;
+  private readonly maxWaitMs: number;
 
   constructor(private readonly options: PodLeaseAdmissionOptions) {
     this.pollMs = options.pollMs ?? 15_000;
+    this.maxWaitMs = options.maxWaitMs ?? 30 * 60_000;
     if (!Number.isFinite(this.pollMs) || this.pollMs <= 0) throw new Error('pod lease pollMs must be positive');
+    if (!Number.isFinite(this.maxWaitMs) || this.maxWaitMs <= 0) throw new Error('pod lease maxWaitMs must be positive');
   }
 
   /** Queue view: each waiting item says why it waits (predecessor not merged yet, or no free slot). */
@@ -42,19 +48,18 @@ export class PodLeaseAdmission {
   acquire(signal?: AbortSignal, after?: PodLeasePredecessor): Promise<PodLeaseRelease> {
     if (signal?.aborted) return Promise.reject(new Error('pod lease admission aborted'));
     return new Promise((resolve, reject) => {
-      const waiter: (typeof this.queue)[number] = { resolve, reject, signal, after };
+      const waiter: (typeof this.queue)[number] = { resolve, reject, signal, after,
+        ...(after === undefined ? { waitStartedAt: Date.now(), waitReason: 'no-free-slot' }
+          : { waitReason: `predecessor-unmerged:${String(after)}` }) };
       if (signal) {
         waiter.onAbort = () => {
-          const index = this.queue.indexOf(waiter);
-          if (index < 0) return;
-          this.queue.splice(index, 1);
-          waiter.cancelCheck?.();
+          if (!this.removeWaiter(waiter)) return;
           reject(new Error('pod lease admission aborted'));
-          this.schedule();
         };
         signal.addEventListener('abort', waiter.onAbort, { once: true });
       }
       this.queue.push(waiter);
+      this.scheduleExpiry();
       void this.refresh();
     });
   }
@@ -83,41 +88,29 @@ export class PodLeaseAdmission {
         } catch {
           this.limit = 0;
         }
-        // No head-of-line blocking: a waiter whose predecessor is not merged yet is skipped and later waiters may admit.
+        // Start independent predecessor checks before admitting eligible waiters in queue order.
+        // A slow predecessor cannot reserve a slot or delay a follower's admission decision.
+        this.expireWaiters();
+        const checks = this.queue.filter((waiter) => waiter.after !== undefined && !waiter.checkingDependency && !waiter.predecessorMerged)
+          .map((waiter) => this.checkPredecessor(waiter));
+        if (checks.length) {
+          // Let ready states settle, but do not hold a free slot for an unanswered dependency check.
+          await Promise.race([Promise.all(checks), new Promise<void>((resolve) => { setTimeout(resolve, 0); })]);
+        }
+        this.expireWaiters();
         let index = 0;
-        while (this.active < this.limit && index < this.queue.length) {
+        while (index < this.queue.length) {
           const waiter = this.queue[index]!;
-          if (waiter.after !== undefined) {
-            let state: PredecessorState = 'waiting';
-            const controller = new AbortController();
-            try {
-              const check = this.options.dependencyMerged?.(waiter.after, controller.signal);
-              const result = await Promise.race([
-                Promise.resolve(check),
-                new Promise<PredecessorState>((resolve) => { waiter.cancelCheck = () => { controller.abort(); resolve('waiting'); }; }),
-              ]);
-              state = result === true ? 'merged' : result === false || result === undefined ? 'waiting' : result;
-            } catch {
-              // An unavailable dependency state cannot grant admission.
-            } finally {
-              waiter.cancelCheck = undefined;
-            }
-            if (!this.queue.includes(waiter)) continue; // aborted while checking
-            if (state === 'blocked') {
-              this.queue.splice(this.queue.indexOf(waiter), 1);
-              if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener('abort', waiter.onAbort);
-              debug.log('pod-lease', 'predecessor-blocked', { after: waiter.after });
-              waiter.reject(new Error(`pod lease predecessor blocked: ${String(waiter.after)} was closed without merging`));
-              continue;
-            }
-            if (state !== 'merged') {
-              waiter.waitReason = `predecessor-unmerged:${String(waiter.after)}`;
-              index++;
-              continue;
-            }
+          if (waiter.after !== undefined && !waiter.predecessorMerged) {
+            index++;
+            continue;
+          }
+          if (this.active >= this.limit) {
+            waiter.waitReason = 'no-free-slot';
+            index++;
+            continue;
           }
-          this.queue.splice(this.queue.indexOf(waiter), 1);
-          if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener('abort', waiter.onAbort);
+          this.removeWaiter(waiter);
           this.active++;
           let released = false;
           waiter.resolve(() => {
@@ -127,21 +120,103 @@ export class PodLeaseAdmission {
             void this.refresh();
           });
         }
-        for (const waiter of this.queue.slice(index)) if (!waiter.waitReason?.startsWith('predecessor-')) waiter.waitReason = 'no-free-slot';
       } while (this.recheckRequested && this.queue.length > 0);
     } finally {
       this.checking = undefined;
+      this.scheduleExpiry();
       this.schedule();
     }
   }
 
+  private async checkPredecessor(waiter: (typeof this.queue)[number]): Promise<void> {
+    waiter.checkingDependency = true;
+    const controller = new AbortController();
+    let state: PredecessorState = 'waiting';
+    try {
+      const check = this.options.dependencyMerged?.(waiter.after!, controller.signal);
+      const result = await Promise.race([
+        Promise.resolve(check),
+        new Promise<PredecessorState>((resolve) => { waiter.cancelCheck = () => { controller.abort(); resolve('waiting'); }; }),
+      ]);
+      state = result === true ? 'merged' : result === false || result === undefined ? 'waiting' : result;
+    } catch {
+      // An unavailable dependency state cannot grant admission.
+    } finally {
+      waiter.cancelCheck = undefined;
+      waiter.checkingDependency = false;
+    }
+    if (!this.queue.includes(waiter)) return;
+    if (state === 'blocked') {
+      this.removeWaiter(waiter);
+      debug.log('pod-lease', 'predecessor-blocked', { after: waiter.after });
+      waiter.reject(new Error(`pod lease predecessor blocked: ${String(waiter.after)} was closed without merging`));
+    } else if (state === 'merged') {
+      waiter.predecessorMerged = true;
+      waiter.waitStartedAt = Date.now();
+      waiter.waitReason = 'no-free-slot';
+      this.scheduleExpiry();
+      void this.refresh();
+    } else {
+      waiter.waitReason = `predecessor-unmerged:${String(waiter.after)}`;
+      waiter.waitStartedAt = undefined;
+    }
+  }
+
+  private expireWaiters(): void {
+    const now = Date.now();
+    for (let index = 0; index < this.queue.length;) {
+      const waiter = this.queue[index]!;
+      if (waiter.waitReason !== 'no-free-slot' || waiter.waitStartedAt === undefined ||
+          now - waiter.waitStartedAt <= this.maxWaitMs) {
+        index++;
+        continue;
+      }
+      this.removeWaiter(waiter);
+      const waitedMs = now - waiter.waitStartedAt;
+      const reason = waiter.waitReason;
+      debug.log('pod-lease', 'admit-starved', { waitedMs, reason, after: waiter.after });
+      waiter.reject(new Error(`pod lease admit-starved: waited ${Math.round(waitedMs / 60_000)}m · reason ${reason}`));
+    }
+    this.scheduleExpiry();
+  }
+
+  /** Every queue exit also updates both timers; an empty queue must retain no timer. */
+  private removeWaiter(waiter: (typeof this.queue)[number]): boolean {
+    const index = this.queue.indexOf(waiter);
+    if (index < 0) return false;
+    this.queue.splice(index, 1);
+    if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener('abort', waiter.onAbort);
+    waiter.cancelCheck?.();
+    this.scheduleExpiry();
+    if (!this.checking || this.queue.length === 0) this.schedule();
+    return true;
+  }
+
+  private scheduleExpiry(): void {
+    if (this.expiryTimer) clearTimeout(this.expiryTimer);
+    this.expiryTimer = undefined;
+    const now = Date.now();
+    let delay = Infinity;
+    for (const waiter of this.queue) {
+      if (waiter.waitReason === 'no-free-slot' && waiter.waitStartedAt !== undefined) {
+        delay = Math.min(delay, Math.max(1, waiter.waitStartedAt + this.maxWaitMs - now + 1));
+      }
+    }
+    if (Number.isFinite(delay)) {
+      this.expiryTimer = setTimeout(() => {
+        this.expiryTimer = undefined;
+        this.expireWaiters();
+      }, delay);
+    }
+  }
+
   private schedule(): void {
     if (!this.queue.length) {
       if (this.timer) clearTimeout(this.timer);
       this.timer = undefined;
       return;
     }
-    if (this.timer) return;
+    if (this.timer) clearTimeout(this.timer);
     this.timer = setTimeout(() => {
       this.timer = undefined;
       void this.refresh();

package/src/preview/terminal.ts

@@ -85,6 +85,13 @@ export interface PreviewTerminalOpts {
    *  로 받아 같은 에뮬레이터/탭에 먹인다(정체성·크로스서피스 goto 획득). bun onData-死는 registry bun-native
    *  openpty 가 해결. ⚠️ 라이브 렌더(yazi DA2·마우스·커서·alt-screen) 검증은 기기 세션 필요(대표) → 기본 off. */
   useRegistry?: boolean;
+  /** Shared PTY identity for registry-backed popups. Defaults to preview. */
+  registryKind?: string;
+  /** Human-readable purpose shown by PTY inventory. */
+  registryNickname?: string;
+  registryOrigin?: { originRoot: string; controller?: string };
+  registryPurpose?: string;
+  registrySeat?: string;
   /** P13 — OSC 9/99/777 notification hook. Fires when the child
    *  emits one of:
    *    ESC ] 9 ; <title> BEL                  (iTerm2 growl)
@@ -337,7 +344,13 @@ export class PreviewTerminal {
       this.registryHandle = this.registryDeps.startPty({
         // 합성자 = registry(resolveSpawnShape) — 여기서는 overlay 만 넘긴다.
         cmd: shell, args, workdir: this.opts.cwd, env: childEnv,
-        cols: this.term.cols, rows: this.term.rows, kind: 'preview', accessMode: 'write',
+        cols: this.term.cols, rows: this.term.rows,
+        kind: this.opts.registryKind ?? 'preview',
+        nickname: this.opts.registryNickname,
+        origin: this.opts.registryOrigin,
+        purpose: this.opts.registryPurpose,
+        seat: this.opts.registrySeat,
+        accessMode: 'write',
       });
       this.alive = true;
     } else {

package/src/prompt-cache/types.ts

@@ -15,6 +15,8 @@
 export interface LLMUsage {
   /** Origin provider — lets the metrics module tag accumulated tokens. */
   provider?: 'anthropic' | 'openai';
+  /** 이 사용량을 낸 턴의 모델(내보내는 쪽이 알 때만). 턴 지표가 설정 모델 대신 이것으로 ctx 최대치·단가를 잡는다. */
+  model?: string;
   inputTokens?: number;
   outputTokens?: number;
   cacheReadInputTokens?: number;

package/src/prompt-enhance/enhance.ts

@@ -134,7 +134,11 @@ function askMarkerCount(ask: string): number {
   return (ask.match(/(?:^|\s)(?:불변식|경계|판정\s*신호|invariant|boundary|decision\s+signal)\s*:/gi) ?? []).length;
 }
 
-type EnhanceSelectionSource = 'opts' | 'env' | 'config-role' | 'default';
+type EnhanceSelectionSource = 'opts' | 'env' | 'config-role' | 'fallback-child' | 'default';
+const PLANNING_FALLBACK_REASONS = new Set(['quota-exhausted', 'quota-unmeasured', 'quota-unavailable', 'no-credential-source', 'expiring', 'credential-shape', 'credential-error', 'credential-unavailable', 'unavailable']);
+export function normalizePlanningFallbackReason(value: unknown): string {
+  return typeof value === 'string' && PLANNING_FALLBACK_REASONS.has(value) ? value : 'unavailable';
+}
 
 /** Select the authoring knobs independently; a planning effort alone cannot change the model. */
 export function selectEnhanceLlm(
@@ -146,8 +150,10 @@ export function selectEnhanceLlm(
   const configuredModel = opts.model === undefined && !env.ELANOUS_PROMPT_ENHANCE_MODEL
     && planning && (planning.model || planning.tier || planning.provider)
     ? resolveRoleLlm('planning', { config, overrides: {} }).model : undefined;
+  const forwardedModelSource = env.ELANOUS_PROMPT_ENHANCE_MODEL_RELAY === 'pod' ? env.ELANOUS_PROMPT_ENHANCE_MODEL_SOURCE : undefined;
   const modelSource: EnhanceSelectionSource = opts.model !== undefined ? 'opts'
-    : env.ELANOUS_PROMPT_ENHANCE_MODEL ? 'env'
+    : env.ELANOUS_PROMPT_ENHANCE_MODEL
+      ? forwardedModelSource === 'config-role' || forwardedModelSource === 'fallback-child' || forwardedModelSource === 'default' ? forwardedModelSource : 'env'
     : configuredModel !== undefined ? 'config-role' : 'default';
   const model = opts.model ?? (env.ELANOUS_PROMPT_ENHANCE_MODEL || configuredModel || env.ELANOUS_PR_REVIEW_MODEL || tierModel('better'));
   const envEffort = env.ELANOUS_PROMPT_ENHANCE_EFFORT;
@@ -170,15 +176,25 @@ export function selectEnhanceLlm(
 export function selectPlanningLlm(
   env: NodeJS.ProcessEnv = process.env,
   config: UserConfig = getUserConfig(),
-): { model: string | undefined; effort: 'low' | 'medium' | 'high' } {
+): { model: string | undefined; effort: 'low' | 'medium' | 'high'; modelSource: 'env' | 'config-role' | 'fallback-child' | 'default'; fallbackReason?: string; requestedModel?: string; requestedSource?: string } {
   const planning = config.roleLlm?.planning;
-  const model = env.ELANOUS_PROMPT_ENHANCE_MODEL
-    || (planning && (planning.model || planning.tier || planning.provider)
-      ? resolveRoleLlm('planning', { config, overrides: {} }).model
-      : undefined);
+  const envModel = env.ELANOUS_PROMPT_ENHANCE_MODEL;
+  const roleModel = !envModel && planning && (planning.model || planning.tier || planning.provider)
+    ? resolveRoleLlm('planning', { config, overrides: {} }).model : undefined;
+  const model = envModel || roleModel || undefined;
+  // Pod authoring receives the host's selection through env. Preserve its origin for the grounding log.
+  const relayed = env.ELANOUS_PROMPT_ENHANCE_MODEL_RELAY === 'pod';
+  const forwardedSource = relayed ? env.ELANOUS_PROMPT_ENHANCE_MODEL_SOURCE : undefined;
+  const modelSource = envModel
+    ? forwardedSource === 'config-role' || forwardedSource === 'fallback-child' || forwardedSource === 'default' ? forwardedSource : 'env'
+    : roleModel ? 'config-role' : 'default';
   const envEffort = env.ELANOUS_PROMPT_ENHANCE_EFFORT;
   const validEnvEffort = envEffort === 'low' || envEffort === 'medium' || envEffort === 'high' ? envEffort : undefined;
-  return { model, effort: validEnvEffort ?? planning?.effort ?? 'high' };
+  const fallbackReason = modelSource === 'fallback-child' ? normalizePlanningFallbackReason(env.ELANOUS_PROMPT_ENHANCE_MODEL_FALLBACK_REASON) : undefined;
+  const requestedModel = fallbackReason ? env.ELANOUS_PROMPT_ENHANCE_REQUESTED_MODEL : undefined;
+  const requestedSource = fallbackReason ? env.ELANOUS_PROMPT_ENHANCE_REQUESTED_SOURCE : undefined;
+  return { model, effort: validEnvEffort ?? planning?.effort ?? 'high', modelSource,
+    ...(fallbackReason ? { fallbackReason } : {}), ...(requestedModel ? { requestedModel } : {}), ...(requestedSource ? { requestedSource } : {}) };
 }
 
 /** 스캐폴드 생성 LLM 시스템 프롬프트 — 가산·원문불가침 규율. */