elanous 0.2.31 → 0.2.34

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/tick.ts

@@ -3,7 +3,9 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renam
 import { dirname, join } from 'node:path';
 import { CardStore, taskCardsDir, type TaskCard } from '../../task-cards/card-store.js';
 import { Database } from 'bun:sqlite';
-import { type ChecklistItem } from '../../release-loop/checklist.js';
+import { checklistDevVersion, listChecklist, type ChecklistItem } from '../../release-loop/checklist.js';
+import { readTrafficSignal } from '../../seat-loop/traffic-signal.js';
+import { runHoldHygiene, type HygieneCell, type HygieneDeps } from '../../steward/hold-hygiene.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { getUserConfig, ORCHESTRATOR_DEFAULTS, resolveConfiguredAgentRoleLlm, type OrchestratorLoopConfig } from '../../user-config.js';
 import { rubricPriority } from '../../release-loop/rubric.js';
@@ -63,6 +65,8 @@ export type RebalanceAdapter = (version: string) => Promise<{ decisions: unknown
 export interface TickDeps {
   root?: string; now?: Date | (() => Date); mode?: Mode; runId?: string; window?: Window;
   heartbeatIntervalMs?: number;
+  hygieneCells?: () => HygieneCell[];
+  hygienePaths?: Pick<HygieneDeps, 'trafficPath' | 'metaPath' | 'dispatcherDir'>;
   cards?: () => TaskCard[]; split?: SplitAdapter; placeCell?: PlaceAdapter;
   degradation?: () => { llm: boolean; board: boolean };
   gridHosts?: readonly GridHost[];
@@ -888,7 +892,25 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
           }
         }
       }
-    } else if (node === 'report') (deps.print ?? console.log)(reportLine(state));
+    } else if (node === 'report') {
+      if (mode === 'live') {
+        try {
+          const signal = readTrafficSignal(deps.hygienePaths?.trafficPath);
+          const versions = signal && !('unreadable' in signal) && signal.versions?.length ? signal.versions : [checklistDevVersion()];
+          let cells: HygieneCell[] = [];
+          if (deps.hygieneCells) cells = deps.hygieneCells();
+          else if (signal && !('unreadable' in signal) && signal.hold?.length) {
+            for (const version of versions) {
+              try { cells.push(...listChecklist(version).items); }
+              catch (error) { observe('hold-hygiene-checklist-unreadable', `${version}:${String(error).slice(0, 100)}`, 0); }
+            }
+          }
+          const sent = runHoldHygiene({ root, now, cells, ...deps.hygienePaths });
+          for (const notice of sent) observe('exchange', `hold-hygiene:${notice.key}`, 1, SEAT_LOOP_IDS[notice.to]);
+        } catch (error) { observe('hold-hygiene-failed', String(error).slice(0, 160), 0); }
+      }
+      (deps.print ?? console.log)(reportLine(state));
+    }
     state.nodes[node] = 'ok';
   } else if (state.nodes[node] !== 'ok') {
     // A rerun of a node that already completed keeps its result (review round 3): only never-run nodes become skipped.

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/maturity/feature-maturity.ts

@@ -82,7 +82,7 @@ export const FEATURE_MATURITY = {
     onboarding: 'beta', login: 'stable', session: 'beta', chat: 'stable', repl: 'stable',
     agent: 'stable', registry: 'beta', tier: 'stable', local: 'beta', scheduler: 'beta',
     attach: 'beta', wf: 'beta', nexus: 'stable', phone: 'beta', token: 'beta',
-    acp: 'beta', voice: 'beta',
+    acp: 'beta', voice: 'beta', sim: 'beta',
     'run-detached': 'system', dogfood: 'system', run: 'system',
   },
   // Canonical names only; aliases inherit their command's grade at lookup.

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/mss/logging/render-categories.ts

@@ -79,6 +79,11 @@ export const RENDER_CATEGORY_EXEMPTIONS: ReadonlyMap<string, string> = new Map([
   //   ⛔ 접두 전체(`dashboard`)를 풀지 «않는다» — 그러면 진짜 렌더 소음이 되살아난다. 이 둘만 뗀다.
   ['dashboard.turn-typeahead', 'Mid-turn input queueing decisions — which key was consumed, what was queued, and when it drains. Turn-control judgment, not frame noise.'],
   ['dashboard.streaming-key', 'Streaming-window key ownership — whether a key reached the streaming dispatcher at all. This is the probe that answers "is the ladder live?", so it must survive render mute.'],
+  // ⛔ 2026-10-17 (`TUI-H8-SEAT-BOOT-LOG-MUTED`) — 자리 부트 카드는 «항상성» 이벤트다(렌더 소음 아님).
+  //   `/session new` 뒤 카드가 실렸는지를 `logs --all --include-test` 로도 0행으로 만들어
+  //   «카드가 빠졌다»와 «음소거됐다»를 가를 수 없었다. 접두 전체는 풀지 않고 이것만 뗀다.
+  //   (`tui.autoturn`·`tui.wakeup`·`tui.autowake` 는 `tui` 가 렌더 접두가 아니라 애초에 안 잘린다.)
+  ['dashboard.seat-boot', 'Seat boot card lifecycle — conversation-start, card-injected, card-skipped. Homeostasis evidence that the seat card reached the turn, not frame noise.'],
 ]);
 
 /** Reject an exemption without its required, human-readable rationale. */

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

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]

package/src/oauth/codex-access-mirror.ts

@@ -0,0 +1,55 @@
+/** Codex access-only credential copies for hosts that must never own refresh authority. */
+
+export interface CodexAccessMirrorInput {
+  account: string;
+  store: { version?: number; providers: Record<string, Record<string, unknown>> };
+  codexAuth: { [key: string]: unknown; auth_mode?: string; tokens: Record<string, unknown> };
+}
+
+export interface CodexAccessMirror {
+  /** Minimal elanous auth store containing only this account's access token. */
+  elanousAuth: string;
+  /** Codex CLI auth document with refresh authority removed. */
+  codexAuth: string;
+  expiresAt: number;
+}
+
+/** Build the same refresh-less access-token copies used by Pod credentials. */
+export function createCodexAccessMirror(input: CodexAccessMirrorInput): CodexAccessMirror {
+  const storeKey = input.account === 'default' ? 'openai-codex' : `openai-codex:${input.account}`;
+  const entry = input.store.providers[storeKey] as {
+    tokens?: Record<string, unknown>; lastRefresh?: string; authMode?: string;
+  } | undefined;
+  if (!entry?.tokens) throw new Error(`${storeKey} 계정이 없다`);
+
+  const accessToken = input.codexAuth.tokens.access_token;
+  if (typeof accessToken !== 'string' || !accessToken) throw new Error(`${storeKey} access token 이 없다`);
+  // The Codex auth document is the authority for its own auth_mode. Store metadata
+  // remains available in elanousAuth, but must not be synthesized into auth.json.
+  const authMode = input.codexAuth.auth_mode;
+  if (authMode !== undefined && (typeof authMode !== 'string' || !authMode.trim())) throw new Error(`${storeKey} Codex CLI auth_mode 가 비어 있다`);
+  let payload: { exp?: unknown };
+  try {
+    payload = JSON.parse(Buffer.from(accessToken.split('.')[1] ?? '', 'base64url').toString('utf8')) as { exp?: unknown };
+  } catch { throw new Error(`${storeKey} access token 만료를 읽을 수 없다`); }
+  const expiresAt = Number(payload.exp) * 1000;
+  if (!Number.isFinite(expiresAt) || expiresAt <= 0) throw new Error(`${storeKey} access token 만료를 읽을 수 없다`);
+
+  const elanousAuth = JSON.stringify({
+    version: input.store.version ?? 1,
+    providers: {
+      'openai-codex': {
+        tokens: { ...entry.tokens, accessToken, expiresAt, refreshToken: '', refresh_token: '' },
+        lastRefresh: entry.lastRefresh,
+        authMode: entry.authMode,
+        chatGPT: { accountId: input.codexAuth.tokens.account_id },
+      },
+    },
+  });
+  const codexAuth = JSON.stringify({
+    ...input.codexAuth,
+    auth_mode: authMode,
+    tokens: { ...input.codexAuth.tokens, refresh_token: '', refreshToken: '' },
+  });
+  return { elanousAuth, codexAuth, expiresAt };
+}

package/src/oauth/fallback-chain.ts

@@ -28,7 +28,7 @@ import type { ClaudePtyMaturity } from './claude-pty-maturity.js';
  *    그 grok 마저 못 쓰면 갈 곳이 없었다 — 이 칸을 grok «뒤»에 두면 그때만 크레딧으로 돌아온다.
  *    ⛔ 첫 칸의 크레딧 금지(`codexQuotaPolicy`)는 그대로다 — 이 칸은 «체인이 여기까지 왔을 때»만 돈을 쓴다.
  *    ⛔ 기본 체인에는 «없다» — 돈이라 사람이 config 에 «명시»할 때만 켜진다. */
-export const FALLBACK_STEPS = ['codex-rotate', 'grok', 'claude-pty', 'openrouter', 'codex-credits'] as const;
+export const FALLBACK_STEPS = ['codex-rotate', 'grok', 'zai', 'claude-pty', 'openrouter', 'codex-credits'] as const;
 export type FallbackStep = (typeof FALLBACK_STEPS)[number];
 
 /** 기본 체인 — ⛔⭐ **2026-08-20 에 `grok` 이 «기본»으로 들어왔다**(대표 지시).