elanous 0.2.34 → 0.2.36

package/src/onboarding/web-first.ts

@@ -7,6 +7,7 @@ import { runBgLaunch, type BgLaunchResult } from '../cli/bg-launch.js';
 import { joinRestHealthUrl, runNexusShow, type NexusShowResult } from '../cli/nexus-show.js';
 import { issueSetupLinkToken } from '../auth/setup-link-tokens.js';
 import { debug } from '../debug/log.js';
+import { detectLocale, type Locale } from '../expression/locale.js';
 import { browserUnavailableReason } from '../oauth/browser-availability.js';
 import type { UserConfig } from '../user-config.js';
 
@@ -18,6 +19,8 @@ export interface WebFirstSetupDeps {
   /** Bare first run never starts or waits for a missing daemon; explicit setup retains web launch. */
   startIfMissing?: boolean;
   startedAt?: number;
+  /** Locale for user-facing wording; defaults to the shared ambient decision (detectLocale). */
+  locale?: Locale;
   showNexus?: () => Promise<NexusShowResult>;
   startDaemon?: () => Promise<BgLaunchResult>;
   probeHealth?: (url: string, timeoutMs: number) => Promise<boolean>;
@@ -37,6 +40,34 @@ export interface WebFirstSetupDeps {
 
 const STARTUP_TIMEOUT_MS = 12_000;
 
+/** User-facing web-first fallback wording, routed by the shared locale decision (detectLocale). */
+const WEB_FIRST_TEXT = {
+  ko: {
+    unavailable: (reason: string) => `웹 셋업을 사용할 수 없습니다 (${reason}). 터미널 설정으로 전환합니다.`,
+    offline: '오프라인 모드',
+    startingDaemon: '웹 셋업을 위해 데몬을 시작합니다.',
+    continueInBrowser: '브라우저에서 셋업을 이어가세요',
+    phoneOnSameWifi: (link: string) => `같은 와이파이의 폰이면: ${link}`,
+    linkSingleUse: '이 링크는 10분 안에 한 번만 열 수 있습니다',
+    sameWifiRestart: '같은 와이파이에서 열려면 `elanous nexus run` 을 루프백 없이 다시 띄우세요',
+    scanTailnet: '같은 와이파이·tailnet 의 폰 카메라로 스캔하세요',
+    scanSameWifi: '같은 와이파이의 폰 카메라로 스캔하세요',
+    terminalInstead: '터미널에서 하려면: `elanous setup --terminal`',
+  },
+  en: {
+    unavailable: (reason: string) => `web setup is unavailable (${reason}); switching to terminal setup.`,
+    offline: 'offline mode',
+    startingDaemon: 'starting the daemon for web setup.',
+    continueInBrowser: 'continue setup in your browser',
+    phoneOnSameWifi: (link: string) => `on a phone on the same wifi: ${link}`,
+    linkSingleUse: 'this link can be opened only once within 10 minutes',
+    sameWifiRestart: 'to open it from the same wifi, restart `elanous nexus run` without a loopback-only bind',
+    scanTailnet: 'scan with a phone camera on the same wifi/tailnet',
+    scanSameWifi: 'scan with a phone camera on the same wifi',
+    terminalInstead: 'to use the terminal instead: `elanous setup --terminal`',
+  },
+} as const;
+
 async function probeHealth(url: string, timeoutMs: number): Promise<boolean> {
   try {
     const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
@@ -53,12 +84,13 @@ function setupUrl(pwa: string, token: string): string {
 export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-shown' | 'fallback'> {
   const startedAt = deps.startedAt ?? Date.now();
   const print = deps.print ?? console.log;
+  const text = WEB_FIRST_TEXT[(deps.locale ?? detectLocale()) === 'en' ? 'en' : 'ko'];
   const observe = (event: 'link-shown' | 'fallback', reason?: string, qr = false, browserOpened = false, remote: 'loopback' | 'tailnet' = 'loopback', ms?: number, lan?: 'shown' | 'loopback-bind' | 'no-address', ssh?: boolean) => {
     try { debug.log('onboarding.web-first', event, { ...(reason ? { reason } : {}), qr, browserOpened, remote, ...(ms !== undefined ? { ms } : {}), ...(lan ? { lan, ssh } : {}) }); }
     catch { /* Observability must not block onboarding. */ }
   };
   const fallback = (reason: string): 'fallback' => {
-    print(`웹 셋업을 사용할 수 없습니다 (${reason}). 터미널 설정으로 전환합니다.`);
+    print(text.unavailable(reason));
     observe('fallback', reason);
     return 'fallback';
   };
@@ -70,7 +102,7 @@ export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-s
   try { shown = await show(); } catch { /* A missing daemon may make inspection fail. */ }
   const running = shown?.status === 'unregistered' || (shown?.status === 'registered' && shown.instance?.alive === true);
   if (deps.startIfMissing === false && !running) {
-    print('오프라인 모드');
+    print(text.offline);
     observe('fallback', 'offline');
     return 'fallback';
   }
@@ -85,11 +117,11 @@ export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-s
   const deadline = Date.now() + STARTUP_TIMEOUT_MS;
   if (!running || !shown?.urls?.pwa.loopback) {
     if (deps.startIfMissing === false) {
-      print('오프라인 모드');
+      print(text.offline);
       observe('fallback', 'offline');
       return 'fallback';
     }
-    print('웹 셋업을 위해 데몬을 시작합니다.');
+    print(text.startingDaemon);
     let launch: BgLaunchResult;
     try {
       launch = await (deps.startDaemon ?? (() => runBgLaunch({ out: { log: () => {}, error: () => {} } })))();
@@ -115,7 +147,7 @@ export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-s
     if (remaining > 0) await Bun.sleep(Math.min(200, remaining));
   }
   if (!healthy && deps.startIfMissing === false) {
-    print('오프라인 모드');
+    print(text.offline);
     observe('fallback', 'offline');
     return 'fallback';
   }
@@ -154,13 +186,13 @@ export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-s
   const lan: 'shown' | 'loopback-bind' | 'no-address' = !confirmedBind ? 'no-address' : !reachable ? 'loopback-bind' : lanAddress ? 'shown' : 'no-address';
   const lanLink = lanAddress ? setupUrl(`http://${lanAddress}:${port}/app/`, token) : undefined;
   const phoneLink = shown.urls.pwa.tailnet ? setupUrl(shown.urls.pwa.tailnet, token) : lanLink;
-  print('브라우저에서 셋업을 이어가세요');
+  print(text.continueInBrowser);
   print(link);
   if (lanLink) {
-    print(`같은 와이파이의 폰이면: ${lanLink}`);
-    print('이 링크는 10분 안에 한 번만 열 수 있습니다');
+    print(text.phoneOnSameWifi(lanLink));
+    print(text.linkSingleUse);
   } else if (lan === 'loopback-bind') {
-    print('같은 와이파이에서 열려면 `elanous nexus run` 을 루프백 없이 다시 띄우세요');
+    print(text.sameWifiRestart);
   }
   const linkShownMs = Date.now() - startedAt;
   let qr = false;
@@ -172,12 +204,12 @@ export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-s
       }))(phoneLink);
       if (rendered) {
         print(rendered);
-        print(shown.urls.pwa.tailnet ? '같은 와이파이·tailnet 의 폰 카메라로 스캔하세요' : '같은 와이파이의 폰 카메라로 스캔하세요');
+        print(shown.urls.pwa.tailnet ? text.scanTailnet : text.scanSameWifi);
         qr = true;
       }
     } catch { /* QR is optional. */ }
   }
-  print('터미널에서 하려면: `elanous setup --terminal`');
+  print(text.terminalInstead);
   let browserOpened = false;
   const env = deps.browserEnv ?? process.env;
   const ssh = !!(env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY);

package/src/ops/overview-collect.ts

@@ -13,7 +13,7 @@ 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';
@@ -161,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[] = [];
@@ -181,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;
@@ -192,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)) });
@@ -219,6 +234,16 @@ export interface CollectDeps {
   gitLog?: (sinceIso: string) => { lines: string[]; observedAt: string } ;
 }
 
+/** Production schedule.run ledger reader; dbPath is explicit so replays never open the operating ledger. */
+export async function readSchedulerExecutionRows(dbPath: string, sinceMs: number, untilMs: number): Promise<SchedulerExecutionObservation[]> {
+  const { LogStore } = await import('../mss/logging/log-store.js');
+  const store = LogStore.openReadOnly(dbPath);
+  try {
+    return store.queryAll({ exactCategories: ['schedule.run'], sinceMs, untilMs })
+      .map(({ ts_ms, data }) => ({ ts_ms, data }));
+  } finally { store.close(); }
+}
+
 async function defaultDeps(root: string): Promise<Required<CollectDeps>> {
   const [{ listSchedules }, { listChecklist }, { readReleaseRuns }, { readTaskAgentState, taskAgentStatePath }, { ResourceLedger }, { getUserConfig }] = await Promise.all([
     import('../release-loop/release-schedule.js'), import('../release-loop/checklist.js'), import('../nexus/api/ops-api.js'),
@@ -227,12 +252,8 @@ 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(); }
+      const { logsDbPath } = await import('../mss/logging/log-store.js');
+      return readSchedulerExecutionRows(logsDbPath(), sinceMs, untilMs);
     },
     listChecklist: (v) => listChecklist(v),
     readRuns: (dir) => readReleaseRuns(null, dir),

package/src/ops/overview.ts

@@ -51,7 +51,14 @@ 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 }
@@ -100,10 +107,10 @@ export interface OverviewSnapshot {
 
 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×코어를 전체로 본다). */
@@ -111,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;
 }
 
@@ -125,23 +132,29 @@ 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[] = [];
   for (const host of s.machines.hosts) {
     const l = host.load.value;
     if (!l) continue;
-    if (l.totalGb > 0) {
+    if (Number.isFinite(l.freeGb) && Number.isFinite(l.totalGb) && l.totalGb > 0) {
       const remaining = Math.max(0, l.freeGb);
       candidates.push({ kind: 'memory', label: `${host.name} 메모리`, remainingRatio: ratio01(remaining / l.totalGb), remainingText: `${remainingAmount(remaining)}/${l.totalGb.toFixed(0)}GB` });
     }
-    if (l.cpuCount > 0) {
+    if (Number.isFinite(l.load5) && Number.isFinite(l.cpuCount) && l.cpuCount > 0) {
       const cpuCap = l.cpuCount * LOAD_PER_CORE_PRESSURE;
       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 && Number.isFinite(io.someAvg10) && Number.isFinite(io.fullAvg10)) {
+      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) {
@@ -280,7 +293,7 @@ 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` : ''}`)}`);

package/src/persona/loader.ts

@@ -154,6 +154,16 @@ export function validatePersonaShape(
     todo = obj['todo'];
   }
 
+  // 🗣️ 말투(speech style) — TUI-SPEECH-STYLE-CHARACTER. ⛔ 위 `actionHosts` 주석이
+  //    못 박은 그 이유로 ***여기에 명시로 옮긴다*** — 타입에만 더하면 YAML 의 그 줄은 영영 안 읽힌다.
+  let speechStyle: string | undefined;
+  if (Object.hasOwn(obj, 'speechStyle')) {
+    if (typeof obj['speechStyle'] !== 'string' || !obj['speechStyle'].trim()) {
+      return err(path, 'speechStyle must be a non-empty string');
+    }
+    speechStyle = obj['speechStyle'];
+  }
+
   let mentionPatterns: readonly string[] | undefined;
   if (obj['mentionPatterns'] !== undefined) {
     if (!Array.isArray(obj['mentionPatterns'])
@@ -169,6 +179,7 @@ export function validatePersonaShape(
     ...(todo !== undefined ? { todo } : {}),
     ...(description.value !== undefined ? { description: description.value } : {}),
     ...(systemPrompt.value !== undefined ? { systemPrompt: systemPrompt.value } : {}),
+    ...(speechStyle !== undefined ? { speechStyle } : {}),
     ...(brand !== undefined ? { brand } : {}),
     ...(models !== undefined ? { models } : {}),
     ...(mentionPatterns !== undefined ? { mentionPatterns } : {}),

package/src/persona/types.ts

@@ -30,6 +30,14 @@ export interface PersonaProfile {
    *  v1 = no resolution, raw passthrough). */
   readonly systemPrompt?: string;
 
+  /**
+   * 🗣️ **말투(speech style)** — 이 페르소나가 «어떻게» 말하는가(TUI-SPEECH-STYLE-CHARACTER).
+   *
+   * ⛔ 안 적으면 «없다» — 기본 말투를 조용히 채우지 않는다(`actionHosts`·`capabilities`
+   *    와 같은 규율: 관측이 「선언이 없다」고 말한다).
+   */
+  readonly speechStyle?: string;
+
   /**
    * 🚧 **이 봇이 «손을 쓸 수 있는» 호스트들** — 되돌릴 수 없는 브라우저 조작의 «경계».
    *