elanous 0.2.32 → 0.2.34

package/src/llm.ts

@@ -1586,6 +1586,7 @@ type ResponsesInputItem =
 export interface MessagesToResponsesInputOpts {
   acceptToolImages?: boolean;
   acceptUserMessageImages?: boolean;
+  onOrphanToolResult?: (callId: string) => void;
 }
 
 /** Exported for tests. Converts the unified LLMMessage shape into the
@@ -1603,21 +1604,23 @@ export function messagesToResponsesInput(
   // P-3 §6.9 — user-message image gating (default true; current gpt-5
   // family all vision-capable per allowlist).
   const acceptUserImages = opts.acceptUserMessageImages ?? true;
-  // First pass — collect every tool_result.tool_use_id that ever
-  // appears across the message list. Second pass below uses this set
-  // to drop orphan tool_use blocks (assistant invoked a tool but no
-  // matching tool_result followed). Orphans happen when the runtime
+  // First pass — collect both sides of each tool round. Second pass
+  // drops either side when its partner is absent from retained history.
+  // Orphan tool_use blocks happen when the runtime
   // pre-empts dispatch (e.g. W5-G early force-synthesis fires
   // immediately after the assistant's tool_use stream completes but
   // before dispatchTool runs) — codex Responses API hard-rejects
   // function_call without function_call_output ("No tool output
   // found for function call X" → 400).
   const seenToolResultIds = new Set<string>();
+  const seenToolUseIds = new Set<string>();
   for (const m of messages) {
     if (!Array.isArray(m.content)) continue;
     for (const b of m.content) {
       if (b && typeof b === 'object' && b.type === 'tool_result' && b.tool_use_id) {
         seenToolResultIds.add(b.tool_use_id);
+      } else if (m.role === 'assistant' && b && typeof b === 'object' && b.type === 'tool_use' && b.id) {
+        seenToolUseIds.add(b.id);
       }
     }
   }
@@ -1695,6 +1698,13 @@ export function messagesToResponsesInput(
             call_id: b.id,
           });
         } else if (b.type === 'tool_result') {
+          // A restored/truncated session can retain an output after its
+          // assistant call was removed. Codex rejects that wire item with
+          // "No tool call found for function call output" on every retry.
+          if (!seenToolUseIds.has(b.tool_use_id)) {
+            opts.onOrphanToolResult?.(b.tool_use_id);
+            continue;
+          }
           // Image-pipeline P3 (2026-05-05) — when the caller opted in
           // (acceptToolImages, set by Codex provider for gpt-5 family)
           // AND the tool_result content carries image bytes, emit the
@@ -4016,6 +4026,13 @@ export const PROVIDERS: Record<string, LLMProvider> = {
     streamChat: (messages, opts = {}) => makeCodexProvider({ provider: 'openai-codex' }).streamChat!(messages, opts),
     chat: (messages, opts = {}) => makeCodexProvider({ provider: 'openai-codex' }).chat!(messages, opts),
   },
+  glm: {
+    name: 'glm',
+    get defaultModel() { return configuredZaiProvider().defaultModel; },
+    available: () => zaiCodingPlanAvailable(),
+    streamChat: (messages, opts = {}) => configuredZaiProvider().streamChat!(messages, opts),
+    chat: (messages, opts = {}) => configuredZaiProvider().chat!(messages, opts),
+  },
   anthropic: AnthropicProvider,
   local: LocalProvider,
   gemini: GeminiProvider,
@@ -4030,6 +4047,11 @@ export const PROVIDERS: Record<string, LLMProvider> = {
   bedrock: BedrockProvider, // 명시 선택 전용 — 자동 순서·폴백 체인에 «안» 넣는다(src/llm/bedrock-provider.ts)
 };
 
+function configuredZaiProvider(): LLMProvider {
+  const { getUserConfig } = require('./user-config.js') as typeof import('./user-config.js');
+  return makeZaiCodingPlanProvider(getUserConfig().llm);
+}
+
 const AUTOMATIC_PROVIDER_ORDER = ['grok', 'anthropic', 'gemini', 'local'] as const;
 const PROVIDER_DECISION_ORDER = ['grok', 'anthropic', 'openai', 'gemini', 'local', 'openrouter'] as const;
 const SUBSCRIPTION_DECISION_ORDER = ['openai-codex', 'grok'] as const;
@@ -4419,6 +4441,16 @@ function providerByName(name: string): LLMProvider | undefined {
   return PROVIDERS[name] ?? automaticProviderCandidates().find((candidate) => candidate.name === name);
 }
 
+function firstAvailableFallbackProvider(attempted: ReadonlySet<string>, opts: LLMOpts): LLMProvider | undefined {
+  // A candidate may lose its credential between chain enumeration and the
+  // switch. Keep scanning the ordered chain instead of stopping at that slot.
+  for (const name of remainingFallbackProviderNames(attempted, opts)) {
+    const candidate = providerByName(name);
+    if (candidate?.available()) return candidate;
+  }
+  return undefined;
+}
+
 function finalizeStreamingProviderModel(provider: LLMProvider, model: string): { provider: LLMProvider; model: string } {
   if (!isKnownProviderName(provider.name)) return { provider, model };
 
@@ -4821,8 +4853,11 @@ export async function streamLLM(
 
     const err: any = consumed.error;
     if (err instanceof OverloadFailoverError && !opts.provider) {
-      const switched = providerByName('grok');
-      if (switched && !attemptedProviders.has(switched.name) && switched.available() && full.length === 0) {
+      const switched = activeProvider.name === 'openai-codex'
+        ? firstAvailableFallbackProvider(attemptedProviders, opts)
+        : providerByName('grok');
+      if (switched && !attemptedProviders.has(switched.name)
+        && (activeProvider.name === 'openai-codex' || switched.available()) && full.length === 0) {
         debug.log('llm.router', 'overload-failover', {
           blockedProvider: activeProvider.name,
           fallbackProvider: switched.name,
@@ -8501,6 +8536,8 @@ export async function streamLLMWithTools(
       }
     }
     let turnText = '';
+    // TUI-TURN-NARRATION — 이 라운드에 받은 추론 요약 글자 수(내용은 남기지 않는다).
+    let turnReasoningChars = 0;
     turnReasoningDetails = undefined;
     const pendingCalls: Array<{
       id: string;
@@ -8638,6 +8675,7 @@ export async function streamLLMWithTools(
         fullText = fullText.slice(0, fullText.length - turnText.length);
         turnText = '';
       }
+      turnReasoningChars = 0;
       retryDisplay.arm();
       turnReasoningDetails = undefined;
       evCount = 0;
@@ -8666,8 +8704,11 @@ export async function streamLLMWithTools(
       } catch (err) {
         if (idleTimer) clearTimeout(idleTimer);
         if (err instanceof OverloadFailoverError && !opts.provider) {
-          const switched = providerByName('grok');
-          if (switched && !attemptedProviders.has(switched.name) && switched.available() && evCount === 0) {
+          const switched = activeProvider.name === 'openai-codex'
+            ? firstAvailableFallbackProvider(attemptedProviders, opts)
+            : providerByName('grok');
+          if (switched && !attemptedProviders.has(switched.name)
+            && (activeProvider.name === 'openai-codex' || switched.available()) && evCount === 0) {
             debug.log('llm.router', 'overload-failover', {
               turn,
               blockedProvider: activeProvider.name,
@@ -8797,6 +8838,7 @@ export async function streamLLMWithTools(
         // OpenAI-compat `delta.reasoning_content` field — same
         // consumer-side semantics as summary_delta, no part index.
         // Callers that don't render reasoning skip silently.
+        if (ev.kind !== 'summary_part_added') turnReasoningChars += ev.delta.length;
         if (ev.kind === 'summary_part_added') {
           handlers.onReasoning?.({
             kind: 'summary_part_added',
@@ -8873,7 +8915,7 @@ export async function streamLLMWithTools(
 
     // hang 진단 — for-await(SSE 스트림) 정상 종료 확정. 이 로그가 없으면 codex SSE 스트림 hang.
     emitRetryDisplayStep(retryDisplay.settle(turnText));
-    debug.log('llm.stream', 'consume-end', { turn, evCount, lastEvType, textChars: turnText.length, pendingCalls: pendingCalls.length });
+    debug.log('llm.stream', 'consume-end', { turn, evCount, lastEvType, textChars: turnText.length, reasoningChars: turnReasoningChars, pendingCalls: pendingCalls.length });
     const turnInfo = {
       turn,
       durationMs: Date.now() - turnStartedAt,
@@ -11489,6 +11531,10 @@ function makeCodexProvider(cfg: UCLLMConfig): LLMProvider {
         const { instructions, input } = messagesToResponsesInput(messages, {
           acceptToolImages: codexAcceptToolImages,
           acceptUserMessageImages: codexAcceptUserImages,
+          onOrphanToolResult: (callId) => {
+            try { debug.log('llm.codex', 'orphan-tool-output-dropped', { callId }); }
+            catch { /* observation must not block the request */ }
+          },
         });
         const tools = toCodexResponsesTools(opts.tools, opts.serverTools);
         // Codex backend rejects max_output_tokens + temperature — omit.

package/src/loops/budget.ts

@@ -1,6 +1,10 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { ORCHESTRATOR_DEFAULTS, type OrchestratorSeat } from '../user-config.js';
+import { debug } from '../debug/log.js';
 import type { ChecklistItem } from '../release-loop/checklist.js';
 import type { TrafficCell, TrafficProcess, TrafficResult, TrafficSeatRow } from './orchestrator/traffic.js';
+import { withFileLockSync } from '../storage/file-lock.js';
 
 const RESOURCE_SEATS: readonly OrchestratorSeat[] = ['OP', 'TC', 'MK', 'UX'];
 
@@ -277,3 +281,94 @@ export function budgetTrafficTick({ processes, now, caps, lastLaunchAt, idleSinc
   }
   return { seats, unassigned: launches.filter(process => process.seat === null).length, now, idleMinutes };
 }
+
+/** A tick's seat rows as observed: one journal line per tick, kept for the 24h metrics only. */
+export type TrafficTickSample = { at: string; seats: readonly TrafficSeatRow[] };
+
+export interface TrafficSampleDeps {
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+/** Observation-only journal for 24h metrics: never read for launch decisions. A failure to record costs one metrics sample, never the tick itself. */
+export function recordTrafficSample24h(root: string, sample: TrafficTickSample,
+  deps: TrafficSampleDeps = {}): void {
+  const log = deps.log ?? debug.log.bind(debug);
+  const path = join(root, 'orchestrator', 'traffic-samples-24h.jsonl');
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    withFileLockSync(`${path}.lock`, () => {
+      // A torn final line has no newline; separate it from the next valid JSONL row.
+      const previous = existsSync(path) ? readFileSync(path, 'utf8') : '';
+      const separator = previous === '' || previous.endsWith('\n') ? '' : '\n';
+      appendFileSync(path, `${separator}${JSON.stringify(sample)}\n`);
+    });
+    log('loop.orchestrator', 'traffic-sample-24h', { at: sample.at, path });
+  } catch (error) {
+    try { log('loop.orchestrator', 'traffic-sample-24h-failed', { error: String(error).slice(0, 200) }); }
+    catch { /* Observation cannot change a recorded decision. */ }
+  }
+}
+
+/** Read the 24h sample journal; torn lines are skipped (same rule as the dispatch ledger). */
+export function readTrafficSamples24h(root: string, now: Date, windowMinutes = 1440): TrafficTickSample[] {
+  const path = join(root, 'orchestrator', 'traffic-samples-24h.jsonl');
+  if (!existsSync(path)) return [];
+  const floor = now.getTime() - windowMinutes * 60_000;
+  return readFileSync(path, 'utf8').split('\n').flatMap(line => {
+    if (!line.trim()) return [];
+    try {
+      const parsed = JSON.parse(line) as TrafficTickSample;
+      const at = Date.parse(parsed.at);
+      if (!Number.isFinite(at) || at < floor || at > now.getTime() || !Array.isArray(parsed.seats)) return [];
+      return [parsed];
+    } catch { return []; }
+  });
+}
+
+export type TrafficMetrics24h = {
+  /** Occupied share of the observed slot budget over all ticks (Σrunning / Σcap). */
+  utilizationRate: number;
+  running: number;
+  capacity: number;
+  /** Mean minutes an idle, empty seat has waited for its next launch; null when no waits were observed. */
+  meanWaitMinutes: number | null;
+  waitSamples: number;
+  /** Seat-ticks where a seat ran on borrowed share — its own base share could not keep it. */
+  preemptedSeatTicks: number;
+  sampledTicks: number;
+  windowMinutes: number;
+  firstSampleAt: string | null;
+  lastSampleAt: string | null;
+};
+
+/** Aggregate the 24h traffic metrics from the observation journal. Pure over the given samples. */
+export function computeTrafficMetrics24h(samples: readonly TrafficTickSample[], windowMinutes = 1440): TrafficMetrics24h {
+  let running = 0;
+  let capacity = 0;
+  let waitSum = 0;
+  let waitSamples = 0;
+  let preemptedSeatTicks = 0;
+  for (const sample of samples) {
+    for (const row of sample.seats) {
+      running += row.running;
+      capacity += row.cap;
+      if (row.borrowed > 0) preemptedSeatTicks++;
+      if (row.idleFor !== null && row.idleFor > 0) {
+        waitSum += row.idleFor;
+        waitSamples++;
+      }
+    }
+  }
+  return {
+    utilizationRate: capacity > 0 ? Math.round((running / capacity) * 1000) / 1000 : 0,
+    running,
+    capacity,
+    meanWaitMinutes: waitSamples > 0 ? Math.round((waitSum / waitSamples) * 10) / 10 : null,
+    waitSamples,
+    preemptedSeatTicks,
+    sampledTicks: samples.length,
+    windowMinutes,
+    firstSampleAt: samples[0]?.at ?? null,
+    lastSampleAt: samples.at(-1)?.at ?? null,
+  };
+}

package/src/loops/msg-wake.ts

@@ -309,7 +309,7 @@ export async function wakeRecipient(address: string, msgId: number, message: { f
 
 interface PendingWakeRow { address: string; first_msg_id: number; last_msg_id: number; last_from: string; count: number; since: number; attempts: number; reason: string }
 
-export type PendingWakeEvent = 'deferred' | 'redelivered' | 'gave-up' | 'dropped-read';
+export type PendingWakeEvent = 'deferred' | 'redelivered' | 'gave-up' | 'dropped-read' | 'skip';
 
 function logPending(event: PendingWakeEvent, data: Record<string, unknown>): void {
   try { debug.log('loops.msg-wake', event, data); } catch { /* observability is fail-open */ }
@@ -389,8 +389,14 @@ export function redeliverLine(row: Pick<PendingWakeRow, 'address' | 'last_from'
  * Re-knock deferred wakes whose TUI is now recorded idle. `target` limits the sweep to one pty (the TUI's own poller).
  * Never throws per row; a row stays pending while the TUI is busy or the 5-minute window is held.
  */
+// not-live 우주의 재점검은 침묵 대신 이유 한 줄을 남긴다 — 폴러가 15초마다 틱하므로 프로세스당 처음 한 번만(래치).
+let notLiveSkipLogged = false;
+
 export async function redeliverPendingWakes(deps: WakeDeps = {}, opts: { target?: string } = {}): Promise<RedeliverOutcome[]> {
-  if (!isLive(deps)) return [];
+  if (!isLive(deps)) {
+    if (!notLiveSkipLogged) { notLiveSkipLogged = true; logPending('skip', { reason: 'not-live' }); }
+    return [];
+  }
   const db = claimDbPath(deps);
   if (!existsSync(db)) return [];
   const conn = openWakeDb(db);

package/src/loops/orchestrator/traffic.ts

@@ -9,7 +9,8 @@ import { withFileLockSync } from '../../storage/file-lock.js';
 import { getUserConfig, ORCHESTRATOR_DEFAULTS, type OrchestratorLoopConfig, type OrchestratorSeat } from '../../user-config.js';
 import { finishAdvice, measureFinish, type FinishAdvice, type FinishMetrics, type MeasureFinishDeps } from './finish-rate.js';
 import { collectAuthorDepth, type AuthorDepthResult, type CollectAuthorDepthDeps } from './author-depth.js';
-import { budgetTrafficTick } from '../budget.js';
+import { probeDegradation, type DegradationSignal } from './degradation.js';
+import { budgetTrafficTick, computeTrafficMetrics24h, readTrafficSamples24h, recordTrafficSample24h, type TrafficSampleDeps } from '../budget.js';
 
 export const TRAFFIC_SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
 export type TrafficCell = Pick<ChecklistItem, 'id' | 'title' | 'owner' | 'status'>;
@@ -33,6 +34,11 @@ export type DispatchCycle = {
 /** Separate journal: never extend or reinterpret seat-requests or per-run state rows. */
 export function recordDispatchCycle(root: string, cycle: DispatchCycle,
   log: (category: string, event: string, data: Record<string, unknown>) => void = debug.log.bind(debug)): void {
+  // 상시 게이트 관측: tick launch 노드와 runTrafficTick 이 지나는 이 배선 자체가 항상 켜져 있으므로
+  // 24h halt 저널은 이 자리에서 쌓인다 — `--metrics` 수동 읽기에만 매달면 관측 부재로 지표가
+  // 언제나 0이 되는 Goodhart 구조가 된다. 관측 전용: append 아래 원장 기록은 절대 막지 않는다.
+  try { observeGateHalt(root, { log }); }
+  catch { /* 게이트 저널은 관측일 뿐 — dispatch 원장은 관측 실패와 무관하게 기록된다 */ }
   const path = join(root, 'orchestrator', 'dispatch-ledger.jsonl');
   try {
     mkdirSync(dirname(path), { recursive: true });
@@ -207,6 +213,10 @@ export function runTrafficTick({ processes, now, caps, openCells, nextRound, tot
       skipped, dispatch: getUserConfig().loops?.orchestrator?.dispatch ?? ORCHESTRATOR_DEFAULTS.dispatch,
     });
   }
+  // 24h metrics journal: observation only, silent on the decision log, never read for this decision path.
+  recordTrafficSample24h(root, { at: now.toISOString(), seats: result.seats }, { log: () => {} });
+  // 게이트 관측은 위 recordDispatchCycle 상시 배선(과 tick launch 노드의 동일 호출)에서 매 사이클
+  // 쌓인다 — 이 틱에서 중복 관측을 또 하지 않는다. 관측 전용, 이 판정 경로는 이 저널을 읽지 않는다.
   let authorShadow: AuthorShadow | null = null;
   let shadowFailure: Record<string, unknown> | null = null;
   try {
@@ -228,9 +238,129 @@ export function runTrafficTick({ processes, now, caps, openCells, nextRound, tot
   return { result, queued, authorShadow };
 }
 
+export type GateObservation = { at: string; level: 'L1' | 'L2' | null };
+
+/** Map a degradation probe to the gate level that stops place/delegate/launch; L2 is the stronger gate. */
+export function gateLevelOf(signal: Pick<DegradationSignal, 'llm' | 'board'>): 'L1' | 'L2' | null {
+  if (!signal.board) return 'L2';
+  if (!signal.llm) return 'L1';
+  return null;
+}
+
+export interface GateHaltDeps {
+  signal?: Pick<DegradationSignal, 'llm' | 'board'>;
+  probe?: (root: string) => Pick<DegradationSignal, 'llm' | 'board'>;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+/** Observation-only journal for the 24h gate metric: probe the degradation gates and append the level. */
+export function observeGateHalt(root: string, deps: GateHaltDeps = {}): GateObservation {
+  const log = deps.log ?? debug.log.bind(debug);
+  const signal = deps.signal ?? deps.probe?.(root) ?? probeDegradation(root);
+  const observation: GateObservation = { at: new Date().toISOString(), level: gateLevelOf(signal) };
+  const path = join(root, 'orchestrator', 'gate-halt-24h.jsonl');
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    withFileLockSync(`${path}.lock`, () => {
+      const previous = existsSync(path) ? readFileSync(path, 'utf8') : '';
+      const separator = previous === '' || previous.endsWith('\n') ? '' : '\n';
+      appendFileSync(path, `${separator}${JSON.stringify(observation)}\n`);
+    });
+    log('loop.orchestrator', 'gate-halt-24h', { ...observation, path });
+  } catch (error) {
+    try { log('loop.orchestrator', 'gate-halt-24h-failed', { error: String(error).slice(0, 200) }); }
+    catch { /* Observation cannot change a recorded decision. */ }
+  }
+  return observation;
+}
+
+/** Read the 24h gate journal; torn lines are skipped (same rule as the dispatch ledger). */
+export function readGateObservations24h(root: string, now: Date, windowMinutes = 1440): GateObservation[] {
+  const path = join(root, 'orchestrator', 'gate-halt-24h.jsonl');
+  if (!existsSync(path)) return [];
+  const floor = now.getTime() - windowMinutes * 60_000;
+  return readFileSync(path, 'utf8').split('\n').flatMap(line => {
+    if (!line.trim()) return [];
+    try {
+      const parsed = JSON.parse(line) as GateObservation;
+      const at = Date.parse(parsed.at);
+      if (!Number.isFinite(at) || at < floor || at > now.getTime()) return [];
+      if (parsed.level !== null && parsed.level !== 'L1' && parsed.level !== 'L2') return [];
+      return [parsed];
+    } catch { return []; }
+  });
+}
+
+/** Read the dispatch ledger verbatim journal; torn lines are skipped, kept only for forensics. */
+export function readDispatchLedger(root: string, now: Date, windowMinutes = 1440): DispatchCycle[] {
+  const path = join(root, 'orchestrator', 'dispatch-ledger.jsonl');
+  if (!existsSync(path)) return [];
+  const floor = now.getTime() - windowMinutes * 60_000;
+  return readFileSync(path, 'utf8').split('\n').flatMap(line => {
+    if (!line.trim()) return [];
+    try {
+      const parsed = JSON.parse(line) as DispatchCycle;
+      const at = Date.parse(parsed.at);
+      if (!Number.isFinite(at) || at < floor || at > now.getTime()) return [];
+      return [parsed];
+    } catch { return []; }
+  });
+}
+
+/** Gate-halted minutes: gate-active spans where the verbatim ledger shows zero launch attempts AND the gate's
+ * own skip reason (degraded-skip) — a gate-active span with no demand is not halted time. */
+export function gateHaltedLaunchMinutes({ gate, ledger }: {
+  gate: readonly GateObservation[];
+  ledger?: readonly DispatchCycle[];
+}): { minutes: number; launchAttempts: number; haltedTicks: number; activeObservations: number } {
+  const points = gate.map(observation => ({ observation, t: Date.parse(observation.at) }))
+    .filter(point => Number.isFinite(point.t)).sort((a, b) => a.t - b.t);
+  const cycles = (ledger ?? []).map(cycle => ({ cycle, t: Date.parse(cycle.at) }))
+    .filter(entry => Number.isFinite(entry.t));
+  let minutes = 0;
+  let launchAttempts = 0;
+  let haltedTicks = 0;
+  let activeObservations = 0;
+  for (const point of points) {
+    if (point.observation.level !== null) activeObservations++;
+  }
+  for (let i = 1; i < points.length; i++) {
+    if (points[i].observation.level === null || points[i - 1].observation.level === null) continue;
+    const from = points[i - 1].t;
+    const to = points[i].t;
+    const inSpan = cycles.filter(entry => entry.t >= from && entry.t <= to);
+    const attempts = inSpan.reduce((sum, entry) => sum + entry.cycle.eligible, 0);
+    // Only the ledger's own skip reason proves the gate stopped launches: eligible is structurally 0 while the
+    // gate skips, so attempts === 0 alone would also count zero-demand spans as «halted» (Goodhart).
+    const gateSkipped = inSpan.reduce((sum, entry) => sum + (entry.cycle.skipped['degraded-skip'] ?? 0), 0);
+    launchAttempts += attempts;
+    if (attempts === 0 && gateSkipped > 0) {
+      haltedTicks++;
+      minutes += Math.max(0, (to - from) / 60_000);
+    }
+  }
+  return { minutes, launchAttempts, haltedTicks, activeObservations };
+}
+
 if (import.meta.main) {
   try {
     const args = process.argv.slice(2);
+    if (args.includes('--metrics')) {
+      if (args.some(arg => arg !== '--metrics' && arg !== '--json'))
+        throw new Error('usage: traffic.ts [--version <판>] [--json] | --metrics [--json]');
+      const root = effectiveInstanceRoot();
+      const now = new Date();
+      const observation = observeGateHalt(root);
+      const gate = gateHaltedLaunchMinutes({ gate: readGateObservations24h(root, now), ledger: readDispatchLedger(root, now) });
+      const traffic = computeTrafficMetrics24h(readTrafficSamples24h(root, now));
+      const report = { at: now.toISOString(), version: devVersion().replace(/-dev\.\d+$/, ''), traffic,
+        gate: { ...gate, observation } };
+      if (args.includes('--json')) console.log(JSON.stringify(report));
+      else {
+        const wait = traffic.meanWaitMinutes === null ? '?' : `${traffic.meanWaitMinutes}분`;
+        console.log(`traffic-24h utilization=${traffic.utilizationRate} (${traffic.running}/${traffic.capacity}) · mean-wait=${wait} (표본 ${traffic.waitSamples}) · preemptions=${traffic.preemptedSeatTicks} · gate-halt=${gate.minutes}분 (발사시도 ${gate.launchAttempts}) · ticks=${traffic.sampledTicks} · window=${traffic.windowMinutes}분`);
+      }
+    } else {
     const versionFlag = args.indexOf('--version');
     const version = versionFlag < 0 ? devVersion().replace(/-dev\.\d+$/, '') : args[versionFlag + 1];
     if (!version || version.startsWith('--')
@@ -253,6 +383,7 @@ if (import.meta.main) {
     });
     if (args.includes('--json')) console.log(JSON.stringify({ ...result, mode: cfg.trafficMode, queued, version, authorShadow }));
     else console.log(trafficLine(result, cfg.trafficMode));
+    }
   } catch (error) {
     console.error(`traffic: ${error instanceof Error ? error.message : String(error)}`);
     process.exitCode = 1;

package/src/mss/logging/log-store.ts

@@ -1132,10 +1132,9 @@ export interface StaleOpenerCheck {
 }
 
 /** 설치 checkout의 Git 객체 그래프에서 선후를 확인한다. 알 수 없으면 다른 판으로 남긴다. */
-function revisionRelation(openerSha: string | null | undefined, installedSha: string | null): StaleOpenerCheck['revisionRelation'] {
+function revisionRelation(openerSha: string | null | undefined, installedSha: string | null, root = resolve(dirname(fileURLToPath(import.meta.url)), '../../..')): StaleOpenerCheck['revisionRelation'] {
   if (!openerSha || !installedSha) return 'different';
   if (openerSha === installedSha) return 'same';
-  const root = resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
   const ancestor = (from: string, to: string): boolean =>
     spawnSync('git', ['-C', root, 'merge-base', '--is-ancestor', from, to], { timeout: 2_000, stdio: 'ignore' }).status === 0;
   if (ancestor(openerSha, installedSha)) return 'older';
@@ -1167,17 +1166,17 @@ export interface StaleOpenerAlert {
  *  전 경로 fail-soft — 수호자가 retention 을 절대 깨지 않는다. */
 export function alertStaleLogDbOpeners(
   dbPath: string,
-  deps: { openers?: () => LogDbOpenerInfo[]; installedAtMs?: number | null } = {},
+  deps: { openers?: () => LogDbOpenerInfo[]; installedAtMs?: number | null; installedRoot?: string } = {},
 ): StaleOpenerAlert[] {
   const alerts: StaleOpenerAlert[] = [];
   try {
     // must-fix: 옛 판 판정 마커는 모듈 파일 mtime 이 아니라 «설치 sha 의 설치 시점»이다.
-    const marker = resolveInstalledRevisionMarker();
+    const marker = resolveInstalledRevisionMarker(deps.installedRoot);
     const installedAtMs = deps.installedAtMs ?? marker.installedAtMs;
     const openers = (deps.openers ?? (() => scanLogDbOpeners(dbPath)))();
     for (const opener of openers) {
       const relation = opener.revisionSha && marker.sha
-        ? revisionRelation(opener.revisionSha, marker.sha) : undefined;
+        ? revisionRelation(opener.revisionSha, marker.sha, deps.installedRoot) : undefined;
       if (relation === 'different') {
         debug.log('log-store.retention', 'different-opener-alert', {
           pid: opener.pid, db: dbPath, openerSha: opener.revisionSha, installedSha: marker.sha,

package/src/nexus/api/graphs-api.ts

@@ -6,7 +6,8 @@ import { parse as parseYaml } from 'yaml';
 import { elanousStateRoot } from '../../autopilot/state-paths.js';
 import { debug } from '../../debug/log.js';
 import { defaultGraphsDir, loadGraphTemplatesFrom } from '../../self-implement/graph-templates.js';
-import { loadGraphTemplates } from '../../self-implement/graph-yaml.js';
+import { graphVersionHash, loadGraphTemplates, parseGraphTemplateYaml } from '../../self-implement/graph-yaml.js';
+import { flattenGraphTemplate } from '../../self-implement/graph-unit-resolver.js';
 import { validateGraphYaml } from './graph-kinds.js';
 import { parseWizardSteps, readWizardSteps, withWizardSteps } from '../../graph-wizard/saved-steps.js';
 import type { WizardNodeStep } from '../../graph-wizard/steps.js';
@@ -115,7 +116,7 @@ export async function handleGraphAccessPut(pathname: string, req: Request, deps:
 
 /** The peer token works only on this graph and the requested read/edit operation. */
 export function graphAccessForRequest(pathname: string, method: string, token: string | null, deps: GraphsApiDeps = {}): boolean {
-  const match = /^\/v1\/graphs\/([^/]+)(?:\/(yaml))?$/.exec(pathname);
+  const match = /^\/v1\/graphs\/([^/]+)(?:\/(yaml|flat))?$/.exec(pathname);
   const id = match ? resolveId(match[1]!) : null;
   if (!id || !token || !TOKEN_PATTERN.test(token)) return false;
   if (method !== 'GET' && !(method === 'PUT' && match?.[2] === 'yaml')) return false;
@@ -266,7 +267,7 @@ export function handleGraphsGet(pathname: string, dir = defaultGraphsDir(), deps
     return jsonResponse({ graphs: [...(core.ok ? core.graphs : []), ...mine.filter((graph) => !coreIds.has(graph.id))] });
   }
 
-  const yamlMatch = /^\/v1\/graphs\/([^/]+)\/yaml$/.exec(pathname);
+  const yamlMatch = /^\/v1\/graphs\/([^/]+)\/(yaml|flat)$/.exec(pathname);
   if (yamlMatch) {
     const id = resolveId(yamlMatch[1]!);
     if (!id) return jsonResponse({ error: 'bad_request', reason: 'invalid graph id' }, 400);
@@ -274,6 +275,24 @@ export function handleGraphsGet(pathname: string, dir = defaultGraphsDir(), deps
     const coreHit = core.ok ? indexByDeclaredId(coreDir).get(id) : undefined;
     const hit = mineHit ?? coreHit;
     if (!hit) return jsonResponse({ error: 'not-found', id }, 404);
+    if (pathname.endsWith('/flat')) {
+      const parsed = parseGraphTemplateYaml(hit.text, hit.file);
+      const spec = parsed.template;
+      if (!spec || parsed.errors.length) return jsonResponse({ error: 'invalid-graph', id, issues: parsed.errors }, 422);
+      try {
+        const flat = flattenGraphTemplate(spec, join(mineHit ? mineDir : coreDir, hit.file));
+        return jsonResponse({
+          id, source: mineHit ? 'mine' : 'core', editable: false,
+          entry_node: flat.entryNode,
+          terminal_nodes: flat.terminalNodes,
+          graph_hash: graphVersionHash(flat),
+          nodes: flat.nodes.map(({ nodeId, kind, recipe, maxVisits }) => ({ node_id: nodeId, kind, recipe, max_visits: maxVisits })),
+          edges: flat.edges.map(({ from, to, on, map, fallback }) => ({ from, ...(to === undefined ? {} : { to }), ...(on === undefined ? {} : { on }), ...(map === undefined ? {} : { map }), ...(fallback === undefined ? {} : { fallback }) })),
+        });
+      } catch (error) {
+        return jsonResponse({ error: 'unit-flatten-failed', id, message: error instanceof Error ? error.message : String(error) }, 422);
+      }
+    }
     const steps = mineHit ? readWizardSteps(mineDir, id, hit.text) : null;
     return jsonResponse({ id, source: mineHit ? 'mine' : 'core', editable: Boolean(mineHit), yaml: hit.text, ...(steps ? { steps } : {}) });
   }

package/src/nexus/api/http-server.ts

@@ -3004,7 +3004,7 @@ export async function routeRequest(
     return handleGraphAccess(pathname, req);
   }
   // F-M1 read + P-F1 raw YAML. Writes live in the mutation block and never touch core graphs/.
-  if (method === 'GET' && (pathname === '/v1/graphs' || /^\/v1\/graphs\/[^/]+$/.test(pathname) || /^\/v1\/graphs\/[^/]+\/yaml$/.test(pathname))) {
+  if (method === 'GET' && (pathname === '/v1/graphs' || /^\/v1\/graphs\/[^/]+$/.test(pathname) || /^\/v1\/graphs\/[^/]+\/(?:yaml|flat)$/.test(pathname))) {
     return handleGraphsGet(pathname);
   }
   if (method === 'GET' && /^\/v1\/graphs\/[^/]+\/versions$/.test(pathname)) {

package/src/nexus/api/ops-api.ts

@@ -221,6 +221,18 @@ export function handleOpsApi(req: Request, metaApi: MetaApiOpts | undefined): Re
       ? served(jsonResponse(resourcesFromOverview(peeked.snapshot, peeked.pods, peeked.at)))
       : served(jsonResponse({ stale: true })));
   }
+  if (pathname === '/v1/ops/loops-map') {
+    // LOOP-MAP-API — projects only the shared overview cache's loops snapshot
+    // (name·era·beat cell observedAt; null/unmeasured value and reason preserved);
+    // no new remote fan-out of its own. Loop-edge joining is a later shard.
+    overviewCache ??= createOverviewCache();
+    return overviewCache.get()
+      .then((overview) => served(jsonResponse({
+        generatedAt: overview.generatedAt,
+        cacheAgeMs: overview.cacheAgeMs,
+        loops: overview.loops.map((loop) => ({ name: loop.name, era: loop.era, beat: loop.beat })),
+      })), () => jsonResponse({ error: 'overview-unavailable' }, 500));
+  }
   if (pathname === '/v1/ops/seats') {
     const date = url.searchParams.get('date') ?? todayKst();
     if (!DATE.test(date) || Number.isNaN(Date.parse(`${date}T00:00:00+09:00`))) return jsonResponse({ error: 'invalid-date' }, 400);