elanous 0.2.32 → 0.2.35

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

@@ -458,6 +458,10 @@ export async function loadFreshCodexAuthState(
     });
     return state;
   }
+  if (process.env.ELANOUS_REMOTE_CODEX_ACCESS_ONLY === '1') {
+    observeCodexAuth('no-credential', { storeKey: account.storeKey, mirrorPath: mirrorPath ?? null, reason: 'access-only-expiring' });
+    return null;
+  }
   observeCodexAuth('refresh-start', {
     storeKey: account.storeKey, remainingSeconds: remainingSeconds(state),
     mirrorPath: mirrorPath ?? null, bufferMs: CODEX_REFRESH_BUFFER_MS,
@@ -602,6 +606,9 @@ export async function refreshCodexAccountHome(
     now?: () => number;
   } = {},
 ): Promise<CodexAccountRefreshResult> {
+  if (process.env.ELANOUS_REMOTE_CODEX_ACCESS_ONLY === '1') {
+    return { ok: false, kind: 'no-tokens', message: '원격 access 미러는 refresh 권한이 없다' };
+  }
   // ⛔ The CEO's default account (~/.codex) is shared with the official CLI — refreshing it here
   //   rotates the refresh token out from under that CLI. Named accounts only.
   if (name === DEFAULT_CODEX_ACCOUNT) {

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` 이 «기본»으로 들어왔다**(대표 지시).

package/src/onboarding/first-run.ts

@@ -33,12 +33,14 @@ export type MenuAnswer =
   | { kind: 'miss' };
 
 // FIRST10-FIX: 첫 화면의 오타 한 번이 first-run 전체를 취소하던 마찰 — 빈 입력(취소 의사)과 달리
-// 선택지를 가리키지 못하는 입력(오타·범위 밖·전각 숫자)은 취소가 아니라 다시 묻는다.
+// 선택지를 가리키지 못하는 입력(범위 밖·전각·비정수)은 취소가 아니라 다시 묻는다.
+// 메뉴 답으로 인정하는 건 반각 십진 자릿수 문자열뿐이다 — Number() 는 '1e0'·'0x1'·'+1' 같은
+// 수식 표기를 정수로 강제 변환해 선택지로 샌다(0.2.35 재측정).
 export function parseMenuAnswer(answer: string, choices: readonly LLMProviderName[]): MenuAnswer {
   const trimmed = answer.trim();
   if (trimmed === '') return { kind: 'cancel' };
-  const index = Number(trimmed) - 1;
-  const provider = Number.isInteger(index) && index >= 0 ? choices[index] : undefined;
+  if (!/^[0-9]+$/.test(trimmed)) return { kind: 'miss' };
+  const provider = choices[Number(trimmed) - 1];
   return provider !== undefined ? { kind: 'chosen', provider } : { kind: 'miss' };
 }
 

package/src/onboarding/non-interactive.ts

@@ -10,6 +10,7 @@
 
 import type { WizardIO } from '../onboarding.js';
 import type { ChoiceOption, ChooseOpts, StepSpec } from './io-extended.js';
+import type { LlmDetectDeps } from '../cli/llm-detect-cli.js';
 import {
   loadAnswerFile,
   buildEnvOverrides,
@@ -25,6 +26,10 @@ export interface NonInteractiveOptions {
   answers?: AnswerFile;
   /** Inject a custom `process.env` for the env-bridge layer. */
   env?: NodeJS.ProcessEnv;
+  /** Existing configured provider; an explicit choice suppresses auto-probing. */
+  initialProvider?: string;
+  /** Inject `llm detect` dependencies in tests while retaining its real probe selection logic. */
+  llmDetectDeps?: LlmDetectDeps;
 }
 
 interface ResolvedAnswers {
@@ -76,6 +81,28 @@ export function nonInteractiveIO(opts: NonInteractiveOptions = {}): WizardIO {
   let section: AnswerSection | undefined;
   let printedCodexSkipGuidance = false;
   const consumed = new Set<string>();
+  let detectedProvider: string | null | undefined;
+  let providerDetection: Promise<string | null> | undefined;
+
+  const detectProvider = async (): Promise<string | null> => {
+    if (detectedProvider !== undefined) return detectedProvider;
+    providerDetection ??= (async () => {
+      const [{ runLlmDetect }, { detectProviders }] = await Promise.all([
+        import('../cli/llm-detect-cli.js'),
+        import('../llm/provider-detect.js'),
+      ]);
+      const env = opts.env ?? process.env;
+      const result = await runLlmDetect({ probe: true }, {
+        ...opts.llmDetectDeps,
+        detect: opts.llmDetectDeps?.detect ?? (() => detectProviders({ env })),
+        output: () => {},
+      });
+      return result.selected;
+    })();
+    try { detectedProvider = await providerDetection; }
+    catch { detectedProvider = null; }
+    return detectedProvider;
+  };
 
   const peek = (key: string): unknown => {
     if (!section) return undefined;
@@ -112,18 +139,33 @@ export function nonInteractiveIO(opts: NonInteractiveOptions = {}): WizardIO {
       chooseOpts: ChooseOpts = {},
       stepId?: string,
       pickerId?: string,
-    ) => resolveChoice(
-      choices,
-      chooseOpts,
-      stepId,
-      pickerId,
-      section,
-      merged,
-      () => printedCodexSkipGuidance,
-      () => { printedCodexSkipGuidance = true; },
-      (trackedSection, field) => { consumed.add(`${trackedSection}.${field}`); },
-      print,
-    ),
+    ) => {
+      const answerSection = sectionForPicker(stepId, pickerId, section);
+      const field = answerSection === 'llm' ? 'provider' : undefined;
+      const configured = answerSection && field ? merged[answerSection]?.[field] : undefined;
+      const savedProvider = answerSection === 'llm' && configured === undefined
+        && opts.initialProvider !== undefined && opts.initialProvider !== 'auto'
+        ? opts.initialProvider
+        : undefined;
+      const provider = pickerId === 'provider' && answerSection === 'llm' && configured === undefined
+        && (opts.initialProvider === undefined || opts.initialProvider === 'auto')
+        ? await detectProvider()
+        : null;
+      return resolveChoice(
+        choices,
+        chooseOpts,
+        stepId,
+        pickerId,
+        section,
+        merged,
+        () => printedCodexSkipGuidance,
+        () => { printedCodexSkipGuidance = true; },
+        (trackedSection, answerField) => { consumed.add(`${trackedSection}.${answerField}`); },
+        print,
+        provider,
+        savedProvider,
+      );
+    },
     showStep: (spec: StepSpec) => {
       section = STEP_SECTIONS[spec.index];
     },
@@ -145,6 +187,8 @@ function resolveChoice<T>(
   markCodexSkipGuidancePrinted: () => void,
   markConsumed: (section: AnswerSection, field: string) => void,
   print: (text: string) => void,
+  detectedProvider: string | null = null,
+  savedProvider?: string,
 ): T {
   if (choices.length === 0) throw new Error('nonInteractiveIO.choose: options array must not be empty.');
 
@@ -173,7 +217,14 @@ function resolveChoice<T>(
     : choices.find((choice) => choiceValueKey(choice.value) === configured);
   if (answerSection && field && selected) markConsumed(answerSection, field);
 
-  return selected?.value ?? choiceForValue(choices, configured, opts);
+  const detected = answerSection === 'llm' && field === 'provider' && configured === undefined && detectedProvider
+    ? choices.find((choice) => choiceValueKey(choice.value) === detectedProvider)
+    : undefined;
+  const saved = answerSection === 'llm' && field === 'provider' && configured === undefined && savedProvider
+    ? choices.find((choice) => choiceValueKey(choice.value) === savedProvider)
+    : undefined;
+
+  return selected?.value ?? detected?.value ?? saved?.value ?? choiceForValue(choices, configured, opts);
 }
 
 function choiceForValue<T>(

package/src/onboarding.ts

@@ -38,7 +38,7 @@ import {
 } from './user-config.js';
 import {
   GROK_MODEL, OPENAI_MODEL, ANTHROPIC_MODEL, LOCAL_LLM_MODEL, GEMINI_MODEL,
-  KIMI_MODEL, QWEN_MODEL, GLM_MODEL,
+  KIMI_MODEL, QWEN_MODEL, GLM_MODEL, OPENROUTER_MODEL,
 } from './config.js';
 import { CODEX_DEFAULT_MODEL } from './llm.js';
 import { suggestSetupModel } from './model-tier/index.js';
@@ -514,7 +514,10 @@ const PROVIDER_CHOICES: ProviderChoice[] = [
     defaultBaseUrl: 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1' },
   { key: 'glm',          label: 'GLM (Zhipu · Z.ai · GLM-5.1 754B MoE)', defaultModel: GLM_MODEL, needsBaseUrl: true, needsApiKey: true,
     defaultBaseUrl: 'https://open.bigmodel.cn/api/paas/v4' },
+  // Keep `auto` at its established numeric position; scripted onboarding
+  // answers and existing users rely on the stable numbered choices.
   { key: 'auto',         label: 'Auto-detect (pick from env at runtime)', needsBaseUrl: false, needsApiKey: false },
+  { key: 'openrouter',   label: 'OpenRouter', defaultModel: OPENROUTER_MODEL, needsBaseUrl: false, needsApiKey: true },
 ];
 
 /** PLAN-model-intelligence-router · Phase B4 — decide whether the model
@@ -1753,15 +1756,20 @@ export async function runOnboardingNonInteractive(
     answerFilePath?: string;
     /** Override the resolved env when reading env-bridge layer. */
     env?: NodeJS.ProcessEnv;
+    /** Test seam for `llm detect` dependencies while retaining its probe selection logic. */
+    llmDetectDeps?: import('./cli/llm-detect-cli.js').LlmDetectDeps;
   } = {},
 ): Promise<UserConfig> {
   // Lazy import — keeps `expression/config/` out of the cold path.
   const { nonInteractiveIO } = await import('./onboarding/non-interactive.js');
+  const initial = opts.initial ?? buildUserConfig(opts.path ?? userConfigPath());
   const io = nonInteractiveIO({
     answerFilePath: opts.answerFilePath,
     env: opts.env,
+    initialProvider: initial.llm?.provider,
+    llmDetectDeps: opts.llmDetectDeps,
   });
-  const config = await runOnboarding({ ...opts, io, deferComplete: true });
+  const config = await runOnboarding({ ...opts, initial, io, deferComplete: true });
   io.complete?.();
   return config;
 }

package/src/ops/overview-collect.ts

@@ -13,8 +13,9 @@ import type { ResourceView } from '../control-plane/ledger.js';
 import { cardPrNumber, type TaskCard } from '../task-agent/task-hand.js';
 import { measureLandingThroughput, type LandingThroughput } from '../task-agent/cover.js';
 import {
-  okCell, unmeasured, type Cell, type CapacityInfo, type ChecklistCounts, type LaunchableInfo, type LoopRow, type MachineRow,
+  okCell, unmeasured, type Cell, type CapacityInfo, type ChecklistCounts, type IoPressure, type LaunchableInfo, type LoopRow, type MachineRow,
   type OverviewSnapshot, type OwnerTaskRow, type ParentsInfo, type PodMemberRow, type ReleaseRunInfo, type ScheduleInfo,
+  type SchedulerMetrics,
 } from './overview.js';
 import { SEAT_ERA_SOURCE, readDispatcherBeats, readDispatcherCapacity, readSeatEraHanded, seatEraFeederDir } from './overview-seat-era.js';
 import { matchesOverviewOwner, normalizeOverviewOwner } from './overview-owner.js';
@@ -160,6 +161,20 @@ function collectRelease(root: string, version: string | null, schedules: Release
   return { version: versionCell, run, schedule, checklist };
 }
 
+/**
+ * 하트비트가 실어 온 I/O 압박(diskIo.io · PSI 10초 평균)을 꺼낸다.
+ * 못 잼(맥 · /proc/pressure/io 없음 · 항목 빠짐)은 null — «0%» 로 굳히지 않는다.
+ */
+function ioPressureOf(diskIo: unknown): IoPressure | null {
+  const cell = (diskIo as { io?: { status?: unknown; value?: { someAvg10?: unknown; fullAvg10?: unknown } } } | null | undefined)?.io;
+  if (!cell || cell.status !== 'ok') return null;
+  const someAvg10 = cell.value?.someAvg10;
+  const fullAvg10 = cell.value?.fullAvg10;
+  if (typeof someAvg10 !== 'number' || !Number.isFinite(someAvg10)) return null;
+  if (typeof fullAvg10 !== 'number' || !Number.isFinite(fullAvg10)) return null;
+  return { someAvg10, fullAvg10 };
+}
+
 function collectMachines(root: string, ledgerRows: ResourceView[] | Error, poolSpec: string | null, psOut: string | Error, now: number): OverviewSnapshot['machines'] {
   const expected = new Set<string>();
   const pods: PodMemberRow[] = [];
@@ -180,7 +195,7 @@ function collectMachines(root: string, ledgerRows: ResourceView[] | Error, poolS
     for (const r of machines) expected.add(r.machine);
     for (const name of [...expected].sort()) {
       const row = machines.find((r) => r.machine === name);
-      const load = (row?.attrs as { load?: { loadAvg?: number[]; cpuCount?: number; freeMem?: number; totalMem?: number; observedAt?: number } } | undefined)?.load;
+      const load = (row?.attrs as { load?: { loadAvg?: number[]; cpuCount?: number; freeMem?: number; totalMem?: number; observedAt?: number; diskIo?: unknown } } | undefined)?.load;
       if (!row || !load || !Array.isArray(load.loadAvg)) { hosts.push({ name, load: unmeasured('control ledger heartbeat', '하트비트 없음') }); continue; }
       const observed = typeof load.observedAt === 'number' ? load.observedAt : row.observedAt;
       const [l1, l5, l15] = load.loadAvg;
@@ -191,7 +206,8 @@ function collectMachines(root: string, ledgerRows: ResourceView[] | Error, poolS
       }
       const age = Math.max(0, Math.round((now - observed) / 1000));
       const value = { load1: l1, load5: l5, load15: l15, cpuCount: load.cpuCount,
-        freeGb: load.freeMem / GB, totalGb: load.totalMem / GB, ageSeconds: age };
+        freeGb: load.freeMem / GB, totalGb: load.totalMem / GB, ageSeconds: age,
+        ioPressure: ioPressureOf(load.diskIo) };
       hosts.push({ name, load: age > HEARTBEAT_STALE_S
         ? unmeasured('control ledger heartbeat', `낡음(${age}초)`, iso(observed))
         : okCell(value, 'control ledger heartbeat', iso(observed)) });
@@ -204,8 +220,11 @@ function collectMachines(root: string, ledgerRows: ResourceView[] | Error, poolS
   return { hosts, pods, parents };
 }
 
+export interface SchedulerExecutionObservation { ts_ms: number; data: string | null }
+
 export interface CollectDeps {
   listSchedules?: () => ReleaseSchedule[];
+  readSchedulerRuns?: (sinceMs: number, untilMs: number) => SchedulerExecutionObservation[] | Promise<SchedulerExecutionObservation[]>;
   listChecklist?: (v: string) => Checklist;
   readRuns?: (dir: string) => ReturnType<Parameters<typeof collectRelease>[4]>;
   readCards?: () => TaskCard[];
@@ -222,6 +241,14 @@ async function defaultDeps(root: string): Promise<Required<CollectDeps>> {
   ]);
   return {
     listSchedules: () => listSchedules(),
+    readSchedulerRuns: async (sinceMs, untilMs) => {
+      const { LogStore, logsDbPath } = await import('../mss/logging/log-store.js');
+      const store = LogStore.openReadOnly(logsDbPath());
+      try {
+        return store.queryAll({ exactCategories: ['schedule.run'], sinceMs, untilMs })
+          .map(({ ts_ms, data }) => ({ ts_ms, data }));
+      } finally { store.close(); }
+    },
     listChecklist: (v) => listChecklist(v),
     readRuns: (dir) => readReleaseRuns(null, dir),
     readCards: () => {
@@ -351,7 +378,30 @@ export async function collectOverview(opts: CollectOptions, injected: CollectDep
       beat: okCell({ lastAt: b.lastAt, ageSeconds: b.ageSeconds, alive: b.alive }, `${SEAT_ERA_SOURCE} dispatcher-${b.seat}.pid`, b.lastAt) });
   }
 
-  return { generatedAt: iso(now), instanceRoot: root, since: opts.sinceLabel, release, tasks, machines, landings, throughput, loops };
+  let schedulerMetrics: OverviewSnapshot['schedulerMetrics'];
+  try {
+    const runs = await deps.readSchedulerRuns(now - 86_400_000, now);
+    const isCrontabRecord = (row: SchedulerExecutionObservation): boolean => {
+      try {
+        const data = row.data ? JSON.parse(row.data) as { via?: unknown } : null;
+        return data?.via === 'crontab';
+      } catch { return false; }
+    };
+    const lastHourRuns = runs.filter((row) => row.ts_ms >= now - 3_600_000);
+    const crontabRuns = lastHourRuns.filter(isCrontabRecord).length;
+    const crontabRunsLast24h = runs.filter(isCrontabRecord).length;
+    const metrics: SchedulerMetrics = {
+      scheduleRuns: lastHourRuns.length,
+      bunLaunches: crontabRuns,
+      bunLaunchesLast24h: crontabRunsLast24h,
+    };
+    const source = 'logs.db(schedule.run · via=crontab 기록 건수 · 전체 Bun 기동 아님)';
+    schedulerMetrics = okCell(metrics, source, iso(now));
+  } catch (error) {
+    schedulerMetrics = unmeasured<SchedulerMetrics>('logs.db(schedule.run)', errText(error));
+  }
+
+  return { generatedAt: iso(now), instanceRoot: root, since: opts.sinceLabel, release, tasks, machines, landings, throughput, schedulerMetrics, loops };
 }
 
 export function parseSince(raw: string | undefined): { ms: number; label: string } {

package/src/ops/overview.ts

@@ -51,10 +51,22 @@ export interface LaunchableInfo {
   interim: true;
 }
 export interface CapacityInfo { podUsed: number; podTarget: number; localUsed: number; localMax: number; free: number }
-export interface MachineLoad { load1: number; load5: number; load15: number; cpuCount: number; freeGb: number; totalGb: number; ageSeconds: number }
+/** 리눅스 PSI(/proc/pressure/io · 10초 평균) — 적어도 한 작업이 I/O 를 기다린 시간 비율(%). 100 이면 늘 막혀 있었다. */
+export interface IoPressure { someAvg10: number; fullAvg10: number }
+
+export interface MachineLoad {
+  load1: number; load5: number; load15: number; cpuCount: number; freeGb: number; totalGb: number; ageSeconds: number;
+  /** 하트비트가 실어 온 I/O 압박. 못 잼(맥·/proc/pressure/io 없음)은 null — 축에서 빼지 «넉넉»으로 읽지 않는다. */
+  ioPressure?: IoPressure | null;
+}
 export interface MachineRow { name: string; load: Cell<MachineLoad> }
 export interface PodMemberRow { context: string; capacity: number; occupied: Cell<number> }
 export interface ParentsInfo { count: number; staleOver6h: number; oldestHours: number | null }
+export interface SchedulerMetrics {
+  scheduleRuns: number | null;
+  bunLaunches: number | null;
+  bunLaunchesLast24h: number | null;
+}
 export interface LoopRow {
   name: string;
   /** product = 제품 원장 · seat-era = 자리 시대 원천(제품 밖 · 임시) */
@@ -88,15 +100,17 @@ export interface OverviewSnapshot {
   landings: Cell<{ count: number; recent: string[] }>;
   /** Optional until launch/PR/age sources are wired; existing snapshots keep their exact output. */
   throughput?: Cell<LandingThroughput>;
+  /** Scheduler-wrapper observations for the trailing hour and day; absent on legacy snapshots. */
+  schedulerMetrics?: Cell<SchedulerMetrics>;
   loops: LoopRow[];
 }
 
 export interface VerdictResult { verdict: Verdict; reasons: string[]; nextActions: string[] }
 
-/** 부하/코어가 이 값을 넘으면 «기계 압박»(흐름 저하의 사유). 디스크 I/O 신호는 OVW-MACHINE-HB 전까지 없다. */
+/** 부하/코어가 이 값을 넘으면 «기계 압박»(흐름 저하의 사유). */
 export const LOAD_PER_CORE_PRESSURE = 3;
 
-/** 자원 지도의 축 어휘(닫힌 집합 · RES-FLOOR-BINDING). I/O·게이트 예약은 이 칸에 원천이 없어 늘 제외다. */
+/** 자원 지도의 축 어휘(닫힌 집합 · RES-FLOOR-BINDING). 게이트 예약은 이 칸에 원천이 없어 늘 제외다. */
 export type ResourceKind = 'memory' | 'cpu' | 'io' | 'slots' | 'gate';
 
 /** 구속 조건 — 남은 비율이 최소인 축. 남은 비율 = 남은 양/전체 양(CPU 는 압박선 LOAD_PER_CORE_PRESSURE×코어를 전체로 본다). */
@@ -104,7 +118,7 @@ export interface ResourceBinding {
   kind: ResourceKind;
   label: string;
   remainingRatio: number;
-  /** 남은 양/전체 양의 사람 표기 — `5/64GB` · `0/54코어(압박선 3/코어)` · `0/46자리`. */
+  /** 남은 양/전체 양의 사람 표기 — `5/64GB` · `0/54코어(압박선 3/코어)` · `4/100(압박 96% · full 61% · 10초 평균)` · `0/46자리`. */
   remainingText: string;
 }
 
@@ -118,8 +132,9 @@ function remainingAmount(n: number): string {
 
 /**
  * 구속 조건 규칙(RES-FLOOR-BINDING) — 메모리·CPU·I/O·슬롯·게이트 예약 중 «남은 비율 최소»인 축이 흐름을 묶는다.
- * 못 잰 축(하트비트 없는 호스트 · 용량 못 잼 · 원천 없는 I/O·게이트 예약)은 후보에서 뺀다 — «넉넉»으로도 «바닥»으로도 읽지 않는다.
- * 측정 축이 하나도 없으면 null. 동율은 정해진 순서(호스트 순 메모리→CPU, 그 다음 슬롯)의 첫 축이 이긴다.
+ * 못 잰 축(하트비트 없는 호스트 · 용량 못 잼 · 하트비트에 PSI 가 없는 I/O · 원천이 없는 게이트 예약)은 후보에서 뺀다
+ * — «넉넉»으로도 «바닥»으로도 읽지 않는다.
+ * 측정 축이 하나도 없으면 null. 동율은 정해진 순서(호스트 순 메모리→CPU→I/O, 그 다음 슬롯)의 첫 축이 이긴다.
  */
 export function bindingResource(s: OverviewSnapshot): ResourceBinding | null {
   const candidates: ResourceBinding[] = [];
@@ -135,6 +150,11 @@ export function bindingResource(s: OverviewSnapshot): ResourceBinding | null {
       const remaining = Math.max(0, cpuCap - l.load5);
       candidates.push({ kind: 'cpu', label: `${host.name} CPU`, remainingRatio: ratio01(remaining / cpuCap), remainingText: `${remainingAmount(remaining)}/${cpuCap.toFixed(0)}코어(압박선 ${LOAD_PER_CORE_PRESSURE}/코어)` });
     }
+    const io = l.ioPressure;
+    if (io) {
+      const remaining = Math.max(0, 100 - io.someAvg10);
+      candidates.push({ kind: 'io', label: `${host.name} I/O`, remainingRatio: ratio01(remaining / 100), remainingText: `${remainingAmount(remaining)}/100(압박 ${remainingAmount(io.someAvg10)}% · full ${remainingAmount(io.fullAvg10)}% · 10초 평균)` });
+    }
   }
   const capacity = s.tasks.capacity.value;
   if (capacity && capacity.podTarget + capacity.localMax > 0) {
@@ -238,6 +258,7 @@ export function unmeasuredCells(s: OverviewSnapshot): string[] {
   for (const p of s.machines.pods) visit(`pods.${p.context}`, p.occupied);
   visit('machines.parents', s.machines.parents); visit('landings', s.landings);
   if (s.throughput) visit('throughput', s.throughput);
+  if (s.schedulerMetrics) visit('schedulerMetrics', s.schedulerMetrics);
   for (const l of s.loops) visit(`loops.${l.name}`, l.beat);
   return out;
 }
@@ -272,11 +293,14 @@ export function renderOverview(s: OverviewSnapshot, v: VerdictResult, meta: { el
   lines.push(`일꾼   ${owners} · 끝 ${show(s.tasks.done, String)}`);
   lines.push(`       발사 가능 ${show(s.tasks.launchable, (l) => `${l.count}${l.interim ? '(임시 술어)' : ''} · 대상 경로 없음 ${l.skipped.noTargetPath} · 선행 미완 ${l.skipped.predecessorOpen} · 이미 넘김 ${l.skipped.alreadyHanded}`)}`);
   lines.push(`       빈 자리 ${show(s.tasks.capacity, (c) => `${c.free} (Pod ${c.podUsed}/${c.podTarget} · 로컬 ${c.localUsed}/${c.localMax})`)} [${s.tasks.capacity.source}]`);
-  const hosts = s.machines.hosts.map((h) => `${h.name} ${show(h.load, (l) => `${l.load1.toFixed(0)}/${l.cpuCount}코어 여유 ${l.freeGb.toFixed(0)}/${l.totalGb.toFixed(0)}GB (${l.ageSeconds}s 전)`)}`);
+  const hosts = s.machines.hosts.map((h) => `${h.name} ${show(h.load, (l) => `${l.load1.toFixed(0)}/${l.cpuCount}코어 여유 ${l.freeGb.toFixed(0)}/${l.totalGb.toFixed(0)}GB${l.ioPressure ? ` · I/O 압박 ${l.ioPressure.someAvg10}% · full ${l.ioPressure.fullAvg10}%` : ''} (${l.ageSeconds}s 전)`)}`);
   lines.push(`기계   ${hosts.join(' · ') || '못 잼(하트비트 원장 비어 있음)'}`);
   lines.push(`       Pod ${s.machines.pods.map((p) => `${p.context} ${show(p.occupied, String)}/${p.capacity}`).join(' · ') || '못 잼(풀 설정 없음)'}`);
   lines.push(`       하니스 부모(이 기계) ${show(s.machines.parents, (p) => `${p.count} · 6h 넘음 ${p.staleOver6h}${p.oldestHours !== null ? ` · 최고 ${p.oldestHours}h` : ''}`)}`);
   lines.push(`착지   ${s.since} ${show(s.landings, (l) => `${l.count}`)} [${s.landings.source}]`);
+  if (s.schedulerMetrics) {
+    lines.push(`스케줄 로그 기록(최근 1시간) ${show(s.schedulerMetrics, (m) => `schedule.run ${m.scheduleRuns === null ? '못 잼' : `${m.scheduleRuns}건`} · crontab 경유 기록 ${m.bunLaunches === null ? '못 잼' : `${m.bunLaunches}건`} · 최근 24h crontab 경유 기록 ${m.bunLaunchesLast24h === null ? '못 잼' : `${m.bunLaunchesLast24h}건`}`)} [${s.schedulerMetrics.source}]`);
+  }
   if (s.throughput) {
     lines.push(`${show(s.throughput, formatLandingThroughput)} [${s.throughput.source}]`);
   }