elanous 0.2.23 → 0.2.24

package/src/ops/overview-cache.ts

@@ -0,0 +1,175 @@
+import { debug } from '../debug/log.js';
+import { parentPort, Worker } from 'node:worker_threads';
+import { collectOverview, type CollectOptions } from './overview-collect.js';
+import { computeVerdict, unmeasured, okCell, type OverviewSnapshot, type PodMemberRow } from './overview.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { getElanousConfigDirOverride, setElanousConfigDir } from '../elanous-config-dir.js';
+
+const SNAPSHOT_MS = 10_000;
+const POD_MS = 60_000;
+const POD_STALE_MS = 2 * POD_MS;
+/** Bounds for distinct (version, owner, since) keys: memo entries kept and collections in flight. */
+const MAX_MEMO = 32;
+const MAX_PENDING = 2;
+
+type PodReading = { context: string; occupied: number | null; reason: string | null; observedAt: number };
+type OverviewData = OverviewSnapshot & ReturnType<typeof computeVerdict> & { cacheAgeMs: number; durationMs: number; sources: string[]; refreshFailed: string | null };
+type WorkerMessage = ({ kind: 'pods' } | { kind: 'snapshot'; options: CollectOptions }) & { configDir?: string };
+
+/** The kubectl-capable grid reader lives in a worker, never on the HTTP event loop. */
+const port = parentPort;
+if (port) {
+  port.on('message', async (message: WorkerMessage) => {
+    try {
+      // A worker does not share the main thread's module state: carry the daemon's universe in.
+      if (message.configDir) setElanousConfigDir(message.configDir);
+      if (message.kind === 'pods') {
+        const { buildGridData } = await import('../nexus/api/grid.js');
+        const rows = buildGridData().members.map((m) => ({ context: m.context, occupied: m.occupied, reason: m.reason, observedAt: Date.now() }));
+        port.postMessage({ rows });
+      } else port.postMessage({ snapshot: await collectOverview(message.options) });
+    } catch (error) {
+      port.postMessage({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+}
+
+function workerRead<T>(message: WorkerMessage, timeoutMs: number, field: 'rows' | 'snapshot'): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(new URL('./overview-cache.ts', import.meta.url));
+    let settled = false;
+    const finish = (error?: Error, result?: T) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      void worker.terminate();
+      if (error) reject(error);
+      else resolve(result!);
+    };
+    const timeout = setTimeout(() => finish(new Error(`${field} 측정 시간 초과`)), timeoutMs);
+    worker.on('message', (result: { rows?: PodReading[]; snapshot?: OverviewSnapshot; error?: string }) => {
+      if (result.error) finish(new Error(result.error));
+      else finish(undefined, result[field] as T);
+    });
+    worker.on('error', (error) => finish(error instanceof Error ? error : new Error(String(error))));
+    const configDir = getElanousConfigDirOverride();
+    worker.postMessage({ ...message, ...(configDir ? { configDir } : {}) });
+  });
+}
+
+const measurePodsInWorker = () => workerRead<PodReading[]>({ kind: 'pods' }, 55_000, 'rows');
+const collectInWorker = (options: CollectOptions) => workerRead<OverviewSnapshot>({ kind: 'snapshot', options: { ...options, root: options.root ?? effectiveInstanceRoot() } }, 30_000, 'snapshot');
+
+function pendingSnapshot(at: number, since: string, reason: string): OverviewSnapshot {
+  const missing = <T>(name: string) => unmeasured<T>(name, reason);
+  return {
+    // Same resolution the collector uses; never the daemon's cwd.
+    generatedAt: new Date(at).toISOString(), instanceRoot: effectiveInstanceRoot(), since,
+    release: { version: missing('release.version'), run: missing('release.run'), schedule: missing('release.schedule'), checklist: missing('release.checklist') },
+    tasks: { byOwner: missing('tasks.byOwner'), done: missing('tasks.done'), launchable: missing('tasks.launchable'), capacity: missing('tasks.capacity') },
+    machines: { hosts: [], pods: [], parents: missing('machines.parents') },
+    landings: missing('landings'), loops: [],
+  };
+}
+
+export function createOverviewCache(deps: {
+  collect?: (opts: CollectOptions) => Promise<OverviewSnapshot>;
+  measurePods?: () => Promise<PodReading[]>;
+  now?: () => number;
+  schedule?: (tick: () => void, ms: number) => NodeJS.Timeout;
+} = {}) {
+  const now = deps.now ?? Date.now;
+  const collect = deps.collect ?? collectInWorker;
+  const backgroundSnapshot = !deps.collect;
+  const measurePods = deps.measurePods ?? measurePodsInWorker;
+  const schedule = deps.schedule ?? ((tick: () => void, ms: number): NodeJS.Timeout => setInterval(tick, ms));
+  // The memo holds the collected snapshot only; Pod occupancy and the verdict are
+  // overlaid at response time so a failed or stale (120 s) measurement shows at once.
+  type Entry = { at: number; snapshot: OverviewSnapshot; durationMs: number; failure?: string; retryAt?: number };
+  const memo = new Map<string, Entry>();
+  const pending = new Map<string, Promise<void>>();
+  let podRows: PodReading[] = [];
+  let podFailure: string | null = null;
+  let podTimer: ReturnType<typeof setInterval> | null = null;
+  let podPending = false;
+
+  const refreshPods = async () => {
+    if (podPending) return;
+    podPending = true;
+    try { podRows = await measurePods(); podFailure = null; }
+    catch (error) { podRows = []; podFailure = error instanceof Error ? error.message : String(error); }
+    finally { podPending = false; }
+  };
+  const start = () => {
+    if (podTimer) return;
+    // The timer starts on the first authorized read; measurement never runs on the request stack.
+    podTimer = schedule(() => { void refreshPods(); }, POD_MS);
+    podTimer.unref();
+  };
+  const present = (entry: Entry): OverviewData => {
+    const at = now();
+    const byContext = new Map(podRows.map((row) => [row.context, row]));
+    const pods: PodMemberRow[] = entry.snapshot.machines.pods.map((pod) => {
+      const row = byContext.get(pod.context);
+      const stale = row && at - row.observedAt >= POD_STALE_MS;
+      const occupied = !podFailure && row && !stale && row.occupied !== null
+        ? okCell(row.occupied, 'pod pool background measure', new Date(row.observedAt).toISOString())
+        : unmeasured<number>('pod pool background measure', podFailure ?? (stale ? '낡음(120초)' : row?.reason ?? '측정 대기'), row ? new Date(row.observedAt).toISOString() : null);
+      return { ...pod, occupied };
+    });
+    const full = { ...entry.snapshot, machines: { ...entry.snapshot.machines, pods } };
+    return { ...full, ...computeVerdict(full), durationMs: entry.durationMs,
+      sources: [full.release.run.source, full.tasks.launchable.source, full.tasks.capacity.source],
+      cacheAgeMs: Math.max(0, at - entry.at), refreshFailed: entry.failure ?? null };
+  };
+  const get = async (options: Pick<CollectOptions, 'version' | 'owner'> & { sinceMs?: number; sinceLabel?: string } = {}): Promise<OverviewData> => {
+    start();
+    const key = JSON.stringify([options.version ?? null, options.owner ?? null, options.sinceMs ?? 3_600_000]);
+    const at = now();
+    // Drop expired entries of other keys, then cap the memo (oldest first).
+    for (const [other, entry] of memo) if (other !== key && !pending.has(other) && at - entry.at >= SNAPSHOT_MS && (entry.retryAt ?? 0) <= at) memo.delete(other);
+    const cached = memo.get(key);
+    // A failed refresh keeps the original collection time (true age) and only delays the retry.
+    if (cached && (at - cached.at < SNAPSHOT_MS || backgroundSnapshot && pending.has(key) || (cached.retryAt ?? 0) > at)) return present(cached);
+    let current = pending.get(key);
+    if (!current && pending.size >= MAX_PENDING) {
+      // Collections in flight are capped; answer from what we have instead of starting another worker.
+      const entry = cached ?? { at, snapshot: pendingSnapshot(at, options.sinceLabel ?? '최근 1h', '동시 수집 상한'), durationMs: 0 };
+      return present({ ...entry, failure: entry.failure ?? `동시 수집 상한(${MAX_PENDING})` });
+    }
+    if (!current) {
+      // Evict only when a new key is about to be stored, never on a hit for an existing key.
+      if (!memo.has(key)) while (memo.size >= MAX_MEMO) { const oldest = [...memo.keys()].find((other) => !pending.has(other)); if (!oldest) break; memo.delete(oldest); }
+      if (backgroundSnapshot && !cached) {
+        // Placeholder until the worker answers; it is not a collection.
+        memo.set(key, { at, snapshot: pendingSnapshot(at, options.sinceLabel ?? '최근 1h', '백그라운드 스냅숏 수집 대기'), durationMs: 0 });
+      }
+      current = (async () => {
+        const startAt = now();
+        const snapshot = await collect({ sinceMs: options.sinceMs ?? 3_600_000, sinceLabel: options.sinceLabel ?? '최근 1h',
+          ...(options.version ? { version: options.version } : {}), ...(options.owner ? { owner: options.owner } : {}), now: startAt });
+        // Age counts from when collection started (= snapshot.generatedAt), not when it finished.
+        const entry = { at: startAt, snapshot, durationMs: now() - startAt };
+        memo.set(key, entry);
+        const verdict = present(entry);
+        debug.log('ops.overview', 'verdict', { verdict: verdict.verdict, reasons: verdict.reasons, cacheAgeMs: verdict.cacheAgeMs, durationMs: entry.durationMs });
+      })();
+      pending.set(key, current);
+      void current.then(
+        () => { pending.delete(key); },
+        (error) => {
+          pending.delete(key);
+          debug.log('ops.overview', 'refresh-failed', { reason: error instanceof Error ? error.message : String(error) });
+          const prior = memo.get(key);
+          if (prior) memo.set(key, { ...prior, failure: error instanceof Error ? error.message : String(error), retryAt: now() + SNAPSHOT_MS });
+        },
+      );
+    }
+    if (!backgroundSnapshot) {
+      try { await current; }
+      catch (error) { if (!memo.has(key)) throw error; }
+    }
+    return present(memo.get(key)!);
+  };
+  return { get, memoSize: () => memo.size, stop: () => { if (podTimer) clearInterval(podTimer); podTimer = null; memo.clear(); } };
+}

package/src/ops/overview.ts

@@ -6,6 +6,8 @@
  * ⛔ «못 잼»은 `value:null` ⊕ `reason` 이다 — 절대 0 으로 읽지 않는다(판정도 그렇다).
  */
 
+import { formatLandingThroughput, type LandingThroughput } from '../task-agent/cover.js';
+
 export type CellStatus = 'ok' | 'unmeasured' | 'partial';
 export interface Cell<T> {
   value: T | null;
@@ -84,6 +86,8 @@ export interface OverviewSnapshot {
     parents: Cell<ParentsInfo>;
   };
   landings: Cell<{ count: number; recent: string[] }>;
+  /** Optional until launch/PR/age sources are wired; existing snapshots keep their exact output. */
+  throughput?: Cell<LandingThroughput>;
   loops: LoopRow[];
 }
 
@@ -176,6 +180,7 @@ export function unmeasuredCells(s: OverviewSnapshot): string[] {
   for (const h of s.machines.hosts) visit(`machines.${h.name}`, h.load);
   for (const p of s.machines.pods) visit(`pods.${p.context}`, p.occupied);
   visit('machines.parents', s.machines.parents); visit('landings', s.landings);
+  if (s.throughput) visit('throughput', s.throughput);
   for (const l of s.loops) visit(`loops.${l.name}`, l.beat);
   return out;
 }
@@ -215,6 +220,9 @@ export function renderOverview(s: OverviewSnapshot, v: VerdictResult, meta: { el
   lines.push(`       Pod ${s.machines.pods.map((p) => `${p.context} ${show(p.occupied, String)}/${p.capacity}`).join(' · ') || '못 잼(풀 설정 없음)'}`);
   lines.push(`       하니스 부모(이 기계) ${show(s.machines.parents, (p) => `${p.count} · 6h 넘음 ${p.staleOver6h}${p.oldestHours !== null ? ` · 최고 ${p.oldestHours}h` : ''}`)}`);
   lines.push(`착지   ${s.since} ${show(s.landings, (l) => `${l.count}`)} [${s.landings.source}]`);
+  if (s.throughput) {
+    lines.push(`${show(s.throughput, formatLandingThroughput)} [${s.throughput.source}]`);
+  }
   for (const l of s.loops) {
     lines.push(`루프   ${l.name}${l.era === 'seat-era' ? ' [자리 시대 원천]' : ''} ${show(l.beat, (b) => `${kst(b.lastAt)} (${Math.round(b.ageSeconds / 60)}분 전)${b.alive === null ? '' : b.alive ? ' 살아 있음' : ' 프로세스 없음'}${l.staleAfterSeconds === null ? ' · 주기 미상(판정 제외)' : ''}`)}`);
   }

package/src/prompt-cache/openai.ts

@@ -23,6 +23,7 @@
 // event with cacheReadInputTokens absent (treated as 0 downstream).
 
 import type { LLMUsage } from './types.js';
+import { readOpenRouterByokUsage } from '../llm/openrouter-byok-cost.js';
 
 /** Extract LLMUsage from an OpenAI streaming chunk. Returns null when
  *  the chunk has no usage object (every chunk except the final one
@@ -71,6 +72,8 @@ export function parseOpenAIUsage(event: unknown): LLMUsage | null {
     out.reasoningOutputTokens = r.completion_tokens_details.reasoning_tokens;
   }
   if (typeof r.cost === 'number' && Number.isFinite(r.cost) && r.cost >= 0) out.reportedCostUsd = r.cost;
+  // OR-BYOK-COST — BYOK 호출이면 `byok` ⊕ `upstreamCostUsd`(비-BYOK 이면 아무 칸도 안 더한다 · 종전 바이트).
+  Object.assign(out, readOpenRouterByokUsage(event));
   const keys = Object.keys(out).filter(k => k !== 'provider');
   return keys.length === 0 ? null : out;
 }

package/src/prompt-cache/types.ts

@@ -32,6 +32,11 @@ export interface LLMUsage {
   /** provider 가 «응답에 실어 보낸» 실제 청구액(USD) — OpenRouter `usage.cost`(요청에 `usage:{include:true}`).
    *  ⭐ 추정(카탈로그 단가)이 아니라 청구 사실이다 — 비용 판정이 이것을 먼저 쓴다(BACKLOG C7). */
   reportedCostUsd?: number;
+  /** OR-BYOK-COST — OpenRouter `usage.is_byok === true`(상류 키로 청구된 호출 · OR `cost` 는 0). */
+  byok?: true;
+  /** OR-BYOK-COST — OpenRouter `usage.cost_details.upstream_inference_cost`(상류 키로 실제 청구된 USD).
+   *  ⛔ 칸이 없거나 숫자가 아니면 «없다»(=미상) — 0 으로 꾸미지 않는다. */
+  upstreamCostUsd?: number;
 }
 
 /** Back-compat alias for callers that imported `AnthropicUsage` from

package/src/prompt-enhance/enhance.ts

@@ -158,6 +158,29 @@ export function selectEnhanceLlm(
   return { model, effort: opts.reasoningEffort ?? validEnvEffort ?? planning?.effort ?? 'high', modelSource, effortSource };
 }
 
+/**
+ * ⭐ AUTHOR-DECOMPOSE-KNOB(0.2.24 · G7 #25848) — 골 쪼개기·적대 비평의 `streamLLM` 두 호출이 따를 노브.
+ *   `selectEnhanceLlm` 과 «같은 규칙»으로 planning 역할을 푼다: ELANOUS_PROMPT_ENHANCE_MODEL/EFFORT →
+ *   `roleLlm.planning`(`resolveRoleLlm('planning', …)`). 규칙의 «유일한» 차이는 model 폴백이다 —
+ *   인핸서는 자기 기본(`tierModel('better')`)으로 떨어지지만, 이 길은 아무것도 설정되지 않으면
+ *   `undefined` 를 돌려 호출자가 `model` 을 아예 전달하지 않게 한다(프로바이더 기본 모델 = 종전 동작).
+ *   effort 는 `selectEnhanceLlm` 과 같은 `high` 폴백이며, 두 노브는 따로 풀린다 —
+ *   effort 만 세팅돼도 모델은 종전 기본 그대로다.
+ */
+export function selectPlanningLlm(
+  env: NodeJS.ProcessEnv = process.env,
+  config: UserConfig = getUserConfig(),
+): { model: string | undefined; effort: 'low' | 'medium' | 'high' } {
+  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 envEffort = env.ELANOUS_PROMPT_ENHANCE_EFFORT;
+  const validEnvEffort = envEffort === 'low' || envEffort === 'medium' || envEffort === 'high' ? envEffort : undefined;
+  return { model, effort: validEnvEffort ?? planning?.effort ?? 'high' };
+}
+
 /** 스캐폴드 생성 LLM 시스템 프롬프트 — 가산·원문불가침 규율. */
 const enhanceSystem = (deliverableHint?: string, wantsScqa = false, checklistUse: ChecklistUse = 'coverage-gate'): string =>
   [

package/src/release-loop/placement.ts

@@ -6,7 +6,7 @@ import { resolveRepositoryName } from '../harness/repository-name.js';
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { userConfigPath } from '../user-config.js';
-import { addItem, listChecklist, ownerMatches, parseOwner, setItem, validateCeoLoad, type ChecklistItem } from './checklist.js';
+import { addItem, checklistHistory, listChecklist, ownerMatches, parseOwner, setItem, validateCeoLoad, type ChecklistItem } from './checklist.js';
 import { assignedVersions, move, releasedVersion } from './feature-store.js';
 import { debug } from '../debug/log.js';
 import { kstDay, listSchedules, type ReleaseSchedule } from './release-schedule.js';
@@ -406,9 +406,24 @@ export function rebalance(version: string, deps: PlacementDeps = {}): RebalanceR
   return result;
 }
 
+/** Reasons that justify a second forward rollover of the same cell (대표 10-10 «계속 이월되지 않게»). */
+const SECOND_ROLLOVER_REASON_PREFIXES: readonly string[] = ['쪼개기:', '닫기:', '\u{1F451}:'];
+
+/** Forward moves (to > from) already recorded for this cell across every release. */
+function priorForwardMoves(id: string): number {
+  return checklistHistory(id).filter((row) => row.field === 'move'
+    && typeof row.from === 'string' && typeof row.to === 'string'
+    && versionOrder(row.to, row.from) > 0).length;
+}
+
 /** A seat may defer its own cell one release, never pull another owner's cell forward. */
 export function seatMove(id: string, from: string, to: string, by: string, reason: string, deps: PlacementDeps = {}): void {
   if (!reason.trim()) throw new CliUserError('이동 이유가 필요하다');
+  const trimmed = reason.trim();
+  // A second rollover is only deliberate: split, closure, or a king's order.
+  if (versionOrder(to, from) > 0 && priorForwardMoves(id) >= 1
+    && !SECOND_ROLLOVER_REASON_PREFIXES.some((prefix) => trimmed.startsWith(prefix)))
+    throw new CliUserError(`${id}: 두 번째 이월은 «쪼개기:»·«닫기:»·«\u{1F451}:» 로 시작하는 이유만 허용한다 — 첫 이월 이후 계속 이월되지 않게`);
   const rows = [...(deps.schedules ?? listSchedules())].sort((a, b) => versionOrder(a.version, b.version));
   const backlog = deps.backlog ?? BACKLOG_VERSIONS;
   const next = rows.find((row) => versionOrder(row.version, from) > 0 && !backlog.includes(row.version));