elanous 0.2.32 → 0.2.35

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/model-tier/llm-tier-map.ts

@@ -24,6 +24,7 @@
 // surfaces tier label + model id + per-turn rationale only.
 
 import type { LLMProviderName, ReasoningLevel } from '../user-config.js';
+import { OPENGATEWAY_DEFAULT_MODEL } from '../llm/opengateway-models.js';
 import type { ModelTier } from './types.js';
 
 export interface LlmTierSpec {
@@ -417,6 +418,18 @@ const OPENROUTER: TierMap = {
   loaded:   { model: 'openrouter/moonshotai/kimi-k3', reasoningLevel: 'high', label: 'Kimi K3 · reasoning high (OpenRouter)', rationale: 'Loaded · deep multi-step', status: 'shipping' },
 };
 
+// First OpenGateway slice has one measured model. Every explicit tier resolves to the same model
+// until distinct tiers have their own live evidence; no quality or price ordering is implied.
+const OPENGATEWAY_MODEL = OPENGATEWAY_DEFAULT_MODEL;
+// The provider has no effort/thinking control; all five tiers use the verified model without reasoning options.
+const OPENGATEWAY: TierMap = {
+  budget:   { model: OPENGATEWAY_MODEL, reasoningLevel: 'off', label: 'DeepSeek V4.1 Flash Ultrafast (OpenGateway)', rationale: 'Single verified first-slice model', status: 'shipping' },
+  balanced: { model: OPENGATEWAY_MODEL, reasoningLevel: 'off', label: 'DeepSeek V4.1 Flash Ultrafast (OpenGateway)', rationale: 'Single verified first-slice model', status: 'shipping' },
+  better:   { model: OPENGATEWAY_MODEL, reasoningLevel: 'off', label: 'DeepSeek V4.1 Flash Ultrafast (OpenGateway)', rationale: 'Single verified first-slice model', status: 'shipping' },
+  best:     { model: OPENGATEWAY_MODEL, reasoningLevel: 'off', label: 'DeepSeek V4.1 Flash Ultrafast (OpenGateway)', rationale: 'Single verified first-slice model', status: 'shipping' },
+  loaded:   { model: OPENGATEWAY_MODEL, reasoningLevel: 'off', label: 'DeepSeek V4.1 Flash Ultrafast (OpenGateway)', rationale: 'Single verified first-slice model', status: 'shipping' },
+};
+
 // ── AWS Bedrock (BEDROCK-PROVIDER · 2026-10-11) ───────────────────
 //   ⭐ 판단: ANTHROPIC 사다리의 «추론 수준·역할 배치»를 그대로 두고, 모델은 Bedrock 메시지 엔드포인트에서
 //   확인한 5.5 계열 id(`src/llm/bedrock.ts` BEDROCK_MODELS · 출처 platform.claude.com «Claude in Amazon Bedrock»
@@ -466,6 +479,7 @@ export const LLM_TIER_MAP_BY_PROVIDER: Readonly<Record<LlmTierProvider, TierMap>
   glm: GLM,
   grok: GROK,
   openrouter: OPENROUTER,
+  opengateway: OPENGATEWAY,
   bedrock: BEDROCK,
 } as const;
 
@@ -488,7 +502,7 @@ export function parseTierArg(raw: string): ModelTier | undefined {
  *  tsc 는 배열 누락을 못 잡는다(2026-09-23 `#19900` 이 `openrouter` 를 빠뜨려 배선 계약 자가 그것을
  *  한 번도 누르지 않았다). 자 = `provider-wiring-contract.test.ts`. */
 export const TIER_PROVIDERS: readonly LlmTierProvider[] = [
-  'anthropic', 'openai', 'openai-codex', 'gemini', 'grok', 'local', 'kimi', 'qwen', 'glm', 'openrouter', 'bedrock',
+  'anthropic', 'openai', 'openai-codex', 'gemini', 'grok', 'local', 'kimi', 'qwen', 'glm', 'openrouter', 'opengateway', 'bedrock',
 ];
 
 /** OpenRouter 모델 id(`openrouter/<vendor>/<model>` 또는 `<vendor>/<model>`)의 tier-map 칸.

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/native-tool-catalog.ts

@@ -392,7 +392,7 @@ export const nativeToolCatalog: NativeToolCatalogEntry[] = [
   // OP TUI turns drove msg list/post/ack and release checklist
   // list/move/set/add through `eln` RunShell calls — 1.3–2s of CLI
   // startup each, 30+ spawns per turn, shell stdout amplifying screen
-  // defects. These eight tools reuse the SAME durable services
+  // defects. These ledger tools reuse the SAME durable services
   // in-process (msg-store SQLite ledger · release-loop checklist
   // ledger), preserving the structured results, the seat/OP permission
   // boundaries (ELANOUS_TRACK actor routing, seatMove rules, the HQ
@@ -429,6 +429,20 @@ export const nativeToolCatalog: NativeToolCatalogEntry[] = [
     intentScope: 'ops-fleet',
     cleanerFitThanShell: true,
   },
+  {
+    id: 'msg_ask',
+    kind: 'other',
+    aliases: ['MsgAsk', 'msg_ask'],
+    displayName: 'MsgAsk',
+    description: 'Post a durable seat question and wait for its first replyTo-linked reply. On timeout the question remains in the ledger and its ID is returned.',
+    promptSummary: '`MsgAsk(from, to, question, waitSeconds?)` (durable question + linked reply · in-process)',
+    host: ['skill', 'tui'],
+    safety: ['mutating'],
+    supportsParallel: false,
+    defaultEnabled: true,
+    intentScope: 'ops-fleet',
+    cleanerFitThanShell: true,
+  },
   {
     id: 'msg_ack',
     kind: 'other',

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/loop-resources.ts

@@ -38,13 +38,25 @@ export function observeLoopResources(deps: {
   });
 }
 
+/** The waiting cell a seat is served: the single ID the Nexus API and the PWA resource screen agree on. */
+export function waitingCellId(cell: { id?: unknown } | null | undefined): string | null {
+  const id = cell?.id;
+  return typeof id === 'string' && id.trim() !== '' ? id : null;
+}
+
+/** A seat names a waiting cell only when that cell has a real ID; a blank ID is served as no cell. */
+export function withWaitingCellIds(resource: TrafficResult): TrafficResult {
+  return { ...resource, seats: resource.seats.map(row =>
+    row.nextCell && waitingCellId(row.nextCell) === null ? { ...row, nextCell: null } : row) };
+}
+
 /** The Nexus resource view reads the existing control ledger; it never allocates a second pool ledger. */
 export function handleLoopResourcesGet(
   observe: () => TrafficResult = observeLoopResources,
   listPodWorkers: () => ResourceView[] = () => new ResourceLedger(effectiveInstanceRoot()).list({ kind: 'pod-worker-lease' }),
 ): Response {
   try {
-    const resource = observe();
+    const resource = withWaitingCellIds(observe());
     try {
       const podWorkers = listPodWorkers().map(row => ({ id: row.id, machine: row.machine, workerId: row.name,
         key: row.attrs.key, state: row.attrs.state, generation: row.attrs.generation, ageMs: row.ageMs, expired: row.expired }));

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);

package/src/oauth/claude-pty-maturity.ts

@@ -1,3 +1,7 @@
+import { debug } from '../debug/log.js';
+import { classifyLedgerRun, queryUsageOutcomes, type UsageOutcomesDeps } from '../budget/usage-outcomes.js';
+import { loadRunLedger } from '../self-implement/run-ledger.js';
+
 export type ClaudePtyMaturity =
   | { readonly mature: true }
   | { readonly mature: false; readonly why: 'too-few-samples' | 'completion-below-70' | 'unknown-screen-above-10' | 'intervention-above-0.2' | 'sample-unreadable' };
@@ -9,6 +13,68 @@ export type ClaudePtyMaturitySample = {
   readonly interventionCount: number;
 };
 
+/** Read the latest Claude PTY runs from the run ledger without changing the ledger or fallback path. */
+export function collectClaudePtyMaturitySample(
+  deps: UsageOutcomesDeps & { readonly limit?: number },
+): ClaudePtyMaturitySample | null {
+  const limit = deps.limit ?? 10;
+  const nowMs = deps.nowMs ?? Date.now();
+  let runCount = 0;
+  let completedCount = 0;
+  let readable = Number.isSafeInteger(limit) && limit > 0;
+  let sample: ClaudePtyMaturitySample | null = null;
+
+  if (readable) {
+    const ledgers: { readonly runId: string; readonly entries: NonNullable<ReturnType<NonNullable<UsageOutcomesDeps['load']>>> }[] = [];
+    const load = deps.load ?? loadRunLedger;
+    try {
+      // The maturity sample is over the latest runs, not over a recent time window.
+      // Number.MAX_SAFE_INTEGER days covers the full JavaScript Date range.
+      const report = queryUsageOutcomes(Number.MAX_SAFE_INTEGER, {
+        ...deps,
+        load: (runId, dir, read) => {
+          const entries = load(runId, dir, read);
+          if (entries) ledgers.push({ runId, entries });
+          return entries;
+        },
+      });
+      const runs = ledgers.flatMap(({ runId, entries }) => {
+        const classified = classifyLedgerRun(entries, nowMs);
+        return classified?.provider === 'claude-pty' ? [{ runId, entries, classified }] : [];
+      }).sort((left, right) => right.classified.atMs - left.classified.atMs || right.runId.localeCompare(left.runId))
+        .slice(0, limit);
+      runCount = runs.length;
+      completedCount = runs.filter(({ classified }) => classified.outcome === 'landed').length;
+      readable = report.unreadableLedgers === 0 && runs.every(({ entries }) => {
+        const hasUnknownScreens = entries.some((entry) => Object.hasOwn(entry.data, 'claudePtyUnknownScreens'));
+        const hasInterventions = entries.some((entry) => Object.hasOwn(entry.data, 'humanInterventions'));
+        const unknownScreens = entries.find((entry) => Object.hasOwn(entry.data, 'claudePtyUnknownScreens'))?.data.claudePtyUnknownScreens;
+        const interventions = entries.find((entry) => Object.hasOwn(entry.data, 'humanInterventions'))?.data.humanInterventions;
+        return hasUnknownScreens && hasInterventions
+          && typeof unknownScreens === 'number' && Number.isSafeInteger(unknownScreens) && unknownScreens >= 0
+          && typeof interventions === 'number' && Number.isSafeInteger(interventions) && interventions >= 0;
+      });
+      if (readable) {
+        sample = runs.reduce<ClaudePtyMaturitySample>((total, { entries }) => {
+          const unknownScreens = entries.find((entry) => Object.hasOwn(entry.data, 'claudePtyUnknownScreens'))!.data.claudePtyUnknownScreens as number;
+          const interventions = entries.find((entry) => Object.hasOwn(entry.data, 'humanInterventions'))!.data.humanInterventions as number;
+          return {
+            runCount: total.runCount + 1,
+            completedCount: total.completedCount,
+            unknownScreenCount: total.unknownScreenCount + unknownScreens,
+            interventionCount: total.interventionCount + interventions,
+          };
+        }, { runCount: 0, completedCount, unknownScreenCount: 0, interventionCount: 0 });
+      }
+    } catch {
+      readable = false;
+    }
+  }
+
+  debug.log('oauth.claude-pty', 'maturity-sample', { runCount, completedCount, readable });
+  return readable ? sample : null;
+}
+
 /** 최근 런의 계수만 판정한다. 표본을 못 읽거나 계수가 불가능하면 성숙으로 추정하지 않는다. */
 export function judgeClaudePtyMaturity(sample: ClaudePtyMaturitySample | null | undefined): ClaudePtyMaturity {
   if (!sample || ![sample.runCount, sample.completedCount, sample.unknownScreenCount, sample.interventionCount]