elanous 0.2.4 → 0.2.6

package/src/nexus/api/trace.ts

@@ -1,12 +1,13 @@
 import { getDefaultLogStore, resolveLogInstanceName, LogStore, type LogStoreRow, type LogQuery } from '../../mss/logging/log-store.js';
 import { readLogInstances, type LogInstanceView } from '../../mss/logging/instance-registry.js';
-import { existsSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { prodInstanceRoot } from '../../instance/resolve.js';
 import { debug, redactSecretText, redactSecrets } from '../../debug/log.js';
-import { activeStoreNames, parseSinceParam, type LogFabricDeps } from './log-fabric.js';
+import { activeStoreNames, parseSinceParam, type LogFabricDeps, registeredLogStoreCount } from './log-fabric.js';
 import { checkAuth, type MetaApiOpts } from './meta-api.js';
 import { jsonResponse } from './json-response.js';
+import { runLedgerDir, runLedgerPath } from '../../self-implement/run-ledger.js';
 
 export type TraceLevel = 'L0' | 'L1' | 'L2' | 'L3';
 export interface TraceEvent {
@@ -201,12 +202,19 @@ export function buildRunTrace(
 
 export interface TraceDeps extends LogFabricDeps {
   queryLog?: (details: { stores: string[]; level: TraceLevel; count: number; truncated: boolean; mode: 'rows' | 'runs'; runs: number }) => void;
+  ledgerStat?: (path: string) => void;
 }
 function storeNames(url: URL, deps: TraceDeps): string[] {
   const names = [...new Set(url.searchParams.getAll('store').flatMap((v) => v.split(',')).map((v) => v.trim()).filter(Boolean))];
-  return names.includes('@active') ? [...new Set([...activeStoreNames(deps), ...names.filter((n) => n !== '@active')])]
-    : (names.length ? names : [url.searchParams.get('universe') || resolveLogInstanceName()]);
+  if (names.includes('@active')) {
+    let active: string[];
+    try { active = activeStoreNames(deps); }
+    catch { active = [resolveLogInstanceName()]; }
+    return [...new Set([...active, ...names.filter((n) => n !== '@active')])];
+  }
+  return names.length ? names : [url.searchParams.get('universe') || resolveLogInstanceName()];
 }
+const registeredStoreCount = (deps: TraceDeps): number | null => registeredLogStoreCount(deps);
 function selectedStores(names: string[], deps: TraceDeps): { name: string; store: LogStore | null; remote: boolean; error?: string }[] {
   const selfName = resolveLogInstanceName();
   const self = names.includes(selfName) ? (deps.store ?? getDefaultLogStore)() : null;
@@ -266,6 +274,22 @@ function sortRows(a: LogStoreRow, b: LogStoreRow): number {
   return b.ts_ms - a.ts_ms || b.id - a.id || a.instance.localeCompare(b.instance);
 }
 
+function findRunUniverse(runId: string, selected: readonly string[], deps: TraceDeps): { universe?: string; checked: number } {
+  let checked = 0;
+  const views = (deps.instances ?? readLogInstances)();
+  for (const view of [...views.filter((v) => selected.includes(v.name)), ...views.filter((v) => !selected.includes(v.name))]) {
+    checked++;
+    try {
+      (deps.ledgerStat ?? statSync)(runLedgerPath(runId, runLedgerDir(view.stateDir)));
+      return { universe: view.name, checked };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') continue;
+      throw new Error(`unable to check run ledger for '${view.name}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { checked };
+}
+
 /** Read-only bounded log-fabric fan-in, authenticated before any store access. */
 export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {}): Response {
   if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
@@ -300,7 +324,7 @@ export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {
       const trace = buildRunTrace(runs, parsed.level as 'L0' | 'L1');
       trace.truncated = runLimitReached || failures.length > 0;
       try { (deps.queryLog ?? ((details) => debug.log('logs.trace', 'query', details)))({ stores: names, level: parsed.level, count: trace.events.length, truncated: trace.truncated, mode: 'runs', runs: runs.length }); } catch { /* query logging must not block reads */ }
-      return jsonResponse({ ok: true, ...trace, stores: names, ...(failures.length ? { failedStores: failures } : {}) }, 200);
+      return jsonResponse({ ok: true, ...trace, stores: names, registeredStores: registeredStoreCount(deps), ...(failures.length ? { failedStores: failures } : {}) }, 200);
     }
     const failures: Array<{ name: string; reason: string }> = [];
     const rows: LogStoreRow[] = [];
@@ -321,10 +345,37 @@ export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {
       } catch (e) { failures.push({ name: entry.name, reason: e instanceof Error ? e.message : String(e) }); }
     }
     if (!opened) return jsonResponse({ ok: false, error: 'log-store-unavailable', failedStores: failures }, 503);
+    const runId = url.searchParams.get('runId');
+    let resolution: { universe?: string; checked: number } | undefined;
+    if ((parsed.level === 'L2' || parsed.level === 'L3') && runId && !rows.some((row) => matches(row, url)) && !requestedUniverse) {
+      // A store with no log db at all («has no log store yet» — e.g. the daemon's own tree-derived universe) cannot
+      // hold the run, so it must not block the ledger lookup. A store that exists but failed to open/read still does:
+      // «could not read» is never answered as «not there». The reply keeps `failedStores` either way.
+      const blocking = failures.filter((failure) => !/has no log store yet/.test(failure.reason));
+      if (blocking.length) return jsonResponse({ ok: false, error: 'log-store-unavailable', failedStores: failures }, 503);
+      try { resolution = findRunUniverse(runId, names, deps); }
+      catch (error) { return jsonResponse({ ok: false, error: 'run-universe-unavailable', reason: error instanceof Error ? error.message : String(error) }, 503); }
+      try { debug.log('nexus.trace', 'run-universe-resolved', { runId, universe: resolution.universe ?? 'not-found', checked: resolution.checked }); } catch { /* observation must not block reads */ }
+      if (resolution.universe && !names.includes(resolution.universe)) {
+        const name = resolution.universe;
+        names.push(name);
+        const [entry] = selectedStores([name], deps);
+        if (!entry?.store) return jsonResponse({ ok: false, error: 'log-store-unavailable', failedStores: [{ name, reason: entry?.error ?? 'log-store-unavailable' }] }, 503);
+        stores.push(entry);
+        try {
+          const query: LogQuery = { sinceMs: parsed.from, untilMs: parsed.to, limit: TRACE_LIMIT + 1 };
+          const search = url.searchParams.get('q');
+          if (search) query.grep = search;
+          const page = entry.store.queryTraceRun(runId, query);
+          if (page.length > TRACE_LIMIT) candidateLimitReached = true;
+          rows.push(...page.map((row) => ({ ...row, instance: row.instance || name })));
+        } catch (e) { return jsonResponse({ ok: false, error: 'log-store-unavailable', failedStores: [{ name, reason: e instanceof Error ? e.message : String(e) }] }, 503); }
+      }
+    }
     const filtered = rows.filter((row) => matches(row, url)).sort(sortRows);
     const trace = buildTrace(filtered.slice(0, parsed.limit), parsed.level, filtered.length > parsed.limit || candidateLimitReached || failures.length > 0);
     try { (deps.queryLog ?? ((details) => debug.log('logs.trace', 'query', details)))({ stores: names, level: parsed.level, count: trace.events.length, truncated: trace.truncated, mode: 'rows', runs: trace.nodes.filter((node) => node.level === 'L1' && node.count > 0).length }); } catch { /* query logging must not block reads */ }
-    return jsonResponse({ ok: true, ...trace, stores: names, ...(failures.length ? { failedStores: failures } : {}) }, 200);
+    return jsonResponse({ ok: true, ...trace, stores: names, registeredStores: registeredStoreCount(deps), ...(resolution ? resolution.universe ? { resolvedFrom: 'ledger' as const, runUniverse: resolution.universe } : { runUniverse: 'not-found' as const, checked: resolution.checked } : {}), ...(failures.length ? { failedStores: failures } : {}) }, 200);
   } finally { closeStores(stores, deps); }
 }
 

package/src/nexus/boot/register-mcp-clients.ts

@@ -28,13 +28,21 @@
 //     daemon exit.
 
 import type { McpServerSpec } from '../../user-config.js';
-import { McpClient, McpConnectionError } from '../../mcp/client.js';
+import { McpClient, McpConnectionError, type McpToolCallResult } from '../../mcp/client.js';
 import {
   createMcpProxyRuntime,
   createMcpToolAuthorizer,
 } from '../../mcp/proxy-runtime.js';
 import { registerToolRuntime, unregisterToolRuntime } from '../../tool-runtime/registry.js';
 import { debug, redactSecretText } from '../../debug/log.js';
+import { elanousStateRoot } from '../../autopilot/state-paths.js';
+import { spawn as nodeSpawn } from 'node:child_process';
+import { listNodeKinds } from '../../graph-kinds/registry.js';
+import { syncInstalledPluginNodes } from '../../graph-kinds/installed-plugin-nodes.js';
+import { listInstalledPlugins } from '../../plugins/install/plugin-install.js';
+import { pluginEnv, credentialStatus } from '../../plugins/install/plugin-credentials.js';
+import { existsSync, realpathSync } from 'node:fs';
+import { resolve, sep } from 'node:path';
 
 export interface McpClientsHandle {
   /** Live clients (one per successfully started server). */
@@ -172,24 +180,64 @@ export async function registerMcpClients(
   // breadcrumbs when a child (e.g. xcrun mcpbridge) deadlocked elanous's
   // boot. The trace category prefix `mcp.client.boot.*` keeps these
   // distinct from any per-call instrumentation a future PR adds.
+  const injectedValuesByServer = new Map<string, string[]>();
+  const redactPluginValues = (text: string): string => {
+    try {
+      const root = elanousStateRoot();
+      const current = [...new Set(listInstalledPlugins(root).map(item => item.name))]
+        .flatMap(name => Object.values(pluginEnv(name, root)));
+      return redactValues(text, [...current, ...injectedValuesByServer.values()].flat());
+    } catch { return '[REDACTED]'; }
+  };
   const bootLogger = (id: string) => (event: string, data?: Record<string, unknown>) => {
     try {
-      debug.log('mcp.client.boot', event, { id, ...(data ?? {}) });
+      const safe = data ? Object.fromEntries(Object.entries(data).map(([key, value]) =>
+        [key, typeof value === 'string' ? redactPluginValues(value) : value])) : {};
+      debug.log('mcp.client.boot', event, { id, ...safe });
     } catch { /* logger must never throw the boot */ }
   };
   const createClient =
     opts.createClient ??
-    ((spec: McpServerSpec) =>
-      spec.transport === 'http'
-        ? new McpClient({
-            id: spec.id,
-            url: spec.url,
-            logger: bootLogger(spec.id),
-            ...(spec.oauthIssuer ? { oauthIssuer: spec.oauthIssuer } : {}),
-            ...(spec.oauthTokenEndpoint ? { oauthTokenEndpoint: spec.oauthTokenEndpoint } : {}),
-            ...(spec.bearerTokenEnv ? { bearerTokenEnv: spec.bearerTokenEnv } : {}),
-          })
-        : new McpClient({ id: spec.id, command: spec.command, logger: bootLogger(spec.id) }));
+    ((spec: McpServerSpec) => {
+      if (spec.transport === 'http') return new McpClient({
+        id: spec.id, url: spec.url, logger: bootLogger(spec.id),
+        ...(spec.oauthIssuer ? { oauthIssuer: spec.oauthIssuer } : {}),
+        ...(spec.oauthTokenEndpoint ? { oauthTokenEndpoint: spec.oauthTokenEndpoint } : {}),
+        ...(spec.bearerTokenEnv ? { bearerTokenEnv: spec.bearerTokenEnv } : {}),
+      });
+      const root = elanousStateRoot();
+      const installed = listInstalledPlugins(root);
+      const owners = [...new Set(listNodeKinds('workflow').filter(entry =>
+        !entry.core && entry.plugin && entry.run && 'mcp' in entry.run && entry.run.mcp.server === spec.id,
+      ).map(entry => entry.plugin!))];
+      const commandOwners = [...new Set(installed.filter(item => {
+        const dir = realpathSync(item.path);
+        return spec.command.some(arg => {
+          if (typeof arg !== 'string' || !existsSync(arg)) return false;
+          try { return realpathSync(resolve(arg)).startsWith(`${dir}${sep}`); }
+          catch { return false; }
+        });
+      }).map(item => item.name))];
+      const selected = commandOwners.length === 1 && owners.length === 1 && owners[0] === commandOwners[0]
+        ? commandOwners[0] : undefined;
+      return new McpClient({ id: spec.id, command: spec.command, logger: bootLogger(spec.id),
+        spawn: (cmd, args) => {
+          const declaredEnv = [...new Set(listInstalledPlugins(root).map(item => item.name))]
+            .flatMap(name => credentialStatus(name, root).fields.map(field => field.env));
+          const childEnv = { ...process.env };
+          for (const key of declaredEnv) delete childEnv[key];
+          injectedValuesByServer.delete(spec.id);
+          if (selected) {
+            const env = pluginEnv(selected, root);
+            const fields = credentialStatus(selected, root).fields.filter(field => field.set).map(field => field.name);
+            debug.log('plugin.credentials', 'injected', { plugin: selected, fields, count: fields.length });
+            Object.assign(childEnv, env);
+            injectedValuesByServer.set(spec.id, Object.values(env));
+          }
+          return nodeSpawn(cmd, args, { stdio: ['pipe', 'pipe', 'pipe'], env: childEnv });
+        },
+      });
+    });
   const handshakeTimeoutMs = opts.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS;
   const setTimeoutFn = opts.setTimeoutFn
     ?? ((cb: () => void, ms: number) => {
@@ -204,6 +252,11 @@ export async function registerMcpClients(
   const perServer: Record<string, McpServerBootResult> = {};
   let registered = 0;
 
+  if (opts.servers.some(spec => spec.transport === 'stdio') && !opts.createClient) {
+    try { syncInstalledPluginNodes(elanousStateRoot()); }
+    catch (error) { debug.log('graph.kinds', 'installed-sync-failed', { reason: String(error) }); }
+  }
+
   for (const spec of opts.servers) {
     const serverHandshakeTimeoutMs = spec.handshakeTimeoutMs ?? handshakeTimeoutMs;
     if (spec.enabled === false) {
@@ -213,6 +266,20 @@ export async function registerMcpClients(
     let client: McpClient | undefined;
     try {
       client = createClient(spec) as McpClient;
+      if (!opts.createClient && spec.transport === 'stdio') {
+        const originalCallTool = client.callTool.bind(client);
+        client.callTool = async (name: string, args: Record<string, unknown>): Promise<McpToolCallResult> => {
+          const values = injectedValuesByServer.get(spec.id) ?? [];
+          try {
+            const result = await originalCallTool(name, args);
+            return maskInjectedValues(result, values) as McpToolCallResult;
+          } catch (err) {
+            if (err instanceof Error) err.message = redactValues(err.message, values);
+            else throw new Error(redactValues(String(err), values));
+            throw err;
+          }
+        };
+      }
       await withTimeout(`mcp.${spec.id}.start`, () => client!.start(), serverHandshakeTimeoutMs, setTimeoutFn, clearTimeoutFn);
       const tools = await withTimeout(
         `mcp.${spec.id}.listTools`,
@@ -287,7 +354,7 @@ export async function registerMcpClients(
       }
       const msg = err instanceof Error ? err.message : String(err);
       const reasonClass = classifyMcpConnectFailure(err);
-      const detail = redactSecretText(msg);
+      const detail = redactPluginValues(redactSecretText(msg));
       perServer[spec.id] = { status: 'failed', toolCount: 0, reason: detail, reasonClass };
       try {
         debug.log('mcp.client.boot', 'connect-failed', { id: spec.id, reason: reasonClass, detail });
@@ -303,6 +370,7 @@ export async function registerMcpClients(
       if (client) {
         try { await client.dispose(); } catch { /* best-effort */ }
       }
+      injectedValuesByServer.delete(spec.id);
     }
   }
 
@@ -328,6 +396,7 @@ export async function registerMcpClients(
           }),
         ),
       );
+      injectedValuesByServer.clear();
     },
   };
 }
@@ -338,3 +407,19 @@ function defaultLogger(): McpBootLogger {
     warn: (line) => console.warn(line),
   };
 }
+
+function redactValues(text: string, values: readonly string[]): string {
+  return values.filter(value => value.length > 0)
+    .reduce((safe, value) => safe.replaceAll(value, '[REDACTED]'), text);
+}
+
+/** Mask injected credential values anywhere in an MCP result — string values **and object keys**
+ *  (a server can echo a secret back as a key, e.g. `structuredContent: { [secret]: "ok" }`). */
+export function maskInjectedValues(value: unknown, values: readonly string[]): unknown {
+  if (typeof value === 'string') return redactValues(value, values);
+  if (Array.isArray(value)) return value.map(item => maskInjectedValues(item, values));
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [redactValues(key, values), maskInjectedValues(item, values)]));
+  }
+  return value;
+}

package/src/nexus/index.ts

@@ -79,6 +79,8 @@ import { type PtyBackend, createWebtermSpawn, resolveWebtermCwd } from './webter
 import { SettingsTabController } from './config/settings-controller.js';
 import { tryRegisterSettings } from './boot/register-settings.js';
 import { registerMcpClients, type McpClientsHandle } from './boot/register-mcp-clients.js';
+import { syncInstalledPluginNodes } from '../graph-kinds/installed-plugin-nodes.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
 import type { McpReloadOutcome, McpReloadServerResult } from './api/admin-mcp-reload.js';
 import { loadOrCreateSigningKey, NonceStore } from './api/edit-in-pwa-core.js';
 import { subscribeErrorSnapshotWriter } from './supervisor/error-snapshot.js';
@@ -238,9 +240,8 @@ import {
   type PwaVoiceAdapter,
 } from '../voice/channel-adapters/pwa-voice-adapter.js';
 import { getIntakeStore } from '../intake-plane/runtime.js';
-import { existsSync, readFileSync } from 'node:fs';
 import { join as joinPath } from 'node:path';
-import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { ensureAuthToken } from '../auth/acp-token.js';
 import type { SupervisorSpawnBackend } from './supervisor/spawn.js';
 import type { HealthProbeBackend } from './supervisor/health.js';
 import { gracefulExit, cleanExit } from './supervisor/graceful-exit.js';
@@ -264,8 +265,10 @@ import { createGlobalSubagentCallable } from '../agent/subagent-callable.js';
 import { setAgentHopCap } from '../agent/registry.js';
 import type { SidebarTabSurface } from '../ui/widgets/sidebar-tab-surface.js';
 import { defaultIO, runOnboardingStep, type WizardIO } from '../onboarding.js';
+import { packageVersion } from '../version/code-revision.js';
 
-export const NEXUS_VERSION = '0.17.0';
+// 데몬 배너·`nexus status`·연결 라벨이 보이는 판 = 제품 판(`package.json`) — 옛 내부 상수 `0.17.0` 이 0.2.x 제품 옆에 떴다(🅞 M5 · M5c).
+export const NEXUS_VERSION = packageVersion();
 export const NEXUS_PHASE = 'N-5 PR χ (graceful exit + restart pending)';
 
 type TelegramAgentRunTurnFactory = typeof import('../telegram-agent.js').makeTelegramAgentRunTurn;
@@ -397,6 +400,8 @@ export interface RunNexusOptions {
    *  registry stays empty so the dispatcher's webterm interception
    *  is a no-op). */
   webtermSpawn?: (spec: { id: string; cwd?: string }) => PtyBackend;
+  /** Explicitly disable HTTP and ACP websocket token auth for this run. */
+  noAuth?: boolean;
   /** Skip the HTTP API server boot. Default: true in tests via
    *  detachForTesting; production runs always start the server. Tests
    *  that DO want the server can pass false explicitly. */
@@ -653,7 +658,7 @@ export interface RunNexusHandle {
 /** ACP WS auth gate for the NEXUS HTTP bridge.
  *  Same shape as `src/boot/acp-server.ts` websocket auth: pass
  *  `createAuthVerifier` only when a bearer token is configured;
- *  omit the field entirely for first-boot tokenless dogfood.
+ *  explicit no-auth opt-out omits the verifier.
  *  ⛔ `noAuth` was declared on WsBridgeOpts but the bridge NEVER read it
  *  (0 executable references) while this file assigned it — a value that
  *  flowed in and died. We removed the field rather than leave a knob that
@@ -710,7 +715,7 @@ export function buildNexusWsBridgeAuth(
   bearerToken: string | undefined,
   paths?: TokenStorePaths,
 ): Pick<NexusWsBridgeInit, 'wsAuthVerifier'> {
-  // ⛔ 첫 부팅 무인증 도그푸드는 그대로다 — 부팅 토큰이 «없으면» 검증기를 안 넘긴다.
+  // Explicit opt-out supplies no boot token, so the bridge has no verifier.
   if (!bearerToken) return {};
   return {
     // ⭐ 배열이 아니라 «공급자» — 매 핸드셰이크마다 봉투를 다시 읽는다.
@@ -764,6 +769,13 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
   }
 
   const leasePortFromLauncher = checkLauncherLeaseBoot(opts, process.env, () => resolveCurrentInstance().kind);
+  const noAuth = opts.noAuth === true || process.env.ELANOUS_NEXUS_NO_AUTH === '1';
+  // Resolve before acquiring the daemon lock or binding HTTP. A broken token
+  // store must fail closed without leaving a half-booted Nexus behind.
+  const httpBootEnabled = !(opts.skipHttpServer ?? !!opts.detachForTesting);
+  const needsToken = httpBootEnabled && !(opts.skipRuntimeApi ?? !!opts.detachForTesting) && !noAuth;
+  const bearerToken = needsToken ? ensureAuthToken().token : undefined;
+  if (needsToken && !bearerToken) throw new Error('Nexus auth token is empty');
 
   // 설치본 전환 RFC 0b — 키는 launchd plist 가 아니라 키 캐시에서(캐시 우선 · 자식도 물려받는다). 값은 안 찍고 «이름만».
   if (!opts.detachForTesting) {
@@ -973,6 +985,11 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
     });
     const startLevel = resolvedLevel.level;
     dbgMod.debug.setLevel(startLevel);
+    if (httpBootEnabled && noAuth) {
+      dbgMod.debug.log('nexus.auth', 'explicit-opt-out', {
+        source: opts.noAuth === true ? '--no-auth' : 'ELANOUS_NEXUS_NO_AUTH',
+      }, { level: 'warn' });
+    }
     dbgMod.debug.log('logging.level', 'startup-resolved', {
       level: startLevel, source: resolvedLevel.source,
       gateOpen: scopedMod.hotPathGateOpen(startLevel), surface: 'nexus',
@@ -1340,6 +1357,10 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
     current: () => false,
   };
 
+  // Installed graph kinds do not depend on the runtime API or MCP server configuration.
+  try { syncInstalledPluginNodes(elanousStateRoot()); }
+  catch (error) { debug.log('graph.kinds', 'installed-sync-failed', { reason: String(error) }); }
+
   if (!skipRuntime) {
     // Tool surface — flag · env · UserConfig switch · switch default.
     // See resolveToolsKind() jsdoc for resolution order.
@@ -2000,11 +2021,6 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
     let metaApiOpts: import('./api/meta-api.js').MetaApiOpts | undefined;
 
     if (!skipRuntime && runtimeHistory) {
-      // Bearer token — read from getElanousConfigDir()/acp-token (the
-      // canonical store `elanous serve` uses). Loopback default is
-      // noAuth; tests opt in by writing a token file before boot.
-      const bearerToken = readAcpToken();
-
       // Voice REST + adapter. createVoiceRestHandler is stateless;
       // the STT provider singleton (getDaemonSttProvider) returns
       // null until `initDaemonSttProvider()` is called — fine, the
@@ -2081,9 +2097,8 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
       const surfaceForOpts = toolSurface(toolsKind);
       const toolCwdForOpts = resolveToolCwd({ tools: toolsKind, toolCwd: opts.toolCwd });
 
-      // Same shape as src/boot/acp-server.ts websocket auth: pass
-      // createAuthVerifier only when a token is present; omit it
-      // entirely for first-boot dogfood (tokenless ACP upgrade).
+      // ACP websocket and REST share the same boot token; explicit
+      // opt-out omits the websocket verifier as well.
       wsBridgeOpts = {
         ...(acpHandlerRef ? {
           acpOnConnection: async (conn) => {
@@ -2099,7 +2114,7 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
       metaApiOpts = {
         voiceRest,
         ...(bearerToken ? { bearerToken } : {}),
-        noAuth: !bearerToken,
+        noAuth,
         history: runtimeHistory,
         intakeStore: getIntakeStore(),
         toolSurface: surfaceForOpts,
@@ -3048,7 +3063,7 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
     }
     runtime.httpPort = httpServer.port;
     runtime.httpHost = httpServer.hostname;
-    runtime.httpAuth = 'off';
+    runtime.httpAuth = metaApiOpts && !metaApiOpts.noAuth ? 'on' : 'off';
     // The actual bound port (not the requested port or registry entry) is the member endpoint.
     try {
       const configured = (getUserConfig().raw?.nexus as { primary?: unknown } | undefined)?.primary;
@@ -3475,6 +3490,9 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
   }
 
   printBootBanner(runtime, pwaStaticDir);
+  if (runtime.httpPort && noAuth) {
+    console.warn('  ⚠ NEXUS AUTH DISABLED (--no-auth / ELANOUS_NEXUS_NO_AUTH=1) — HTTP API and ACP websocket are unprotected.');
+  }
 
   // P.3 — first-boot PWA share wizard. Only runs in interactive TUI mode
   // when the switch is still 'ask'. Headless / non-TTY boots skip it (the
@@ -3784,23 +3802,6 @@ function shouldAskPwaShareSwitch(): boolean {
   }
 }
 
-/** PR k — load the persistent ACP bearer token at
- *  `getElanousConfigDir()/acp-token`. Mirrors the helper in
- *  `boot/acp-server.ts` that `elanous serve` uses, so the same token
- *  gates daemon and NEXUS HTTP. Returns undefined when the token
- *  file is absent (loopback noAuth default — first-boot dogfood
- *  works without configuration). Read failures are swallowed. */
-export function readAcpToken(): string | undefined {
-  try {
-    const tokenPath = joinPath(getElanousConfigDir(), 'acp-token');
-    if (existsSync(tokenPath)) {
-      const tok = readFileSync(tokenPath, 'utf-8').trim();
-      return tok || undefined;
-    }
-  } catch { /* swallow */ }
-  return undefined;
-}
-
 function printBootBanner(runtime: NexusRuntimeMeta, pwaStaticDir?: string): void {
   const lines = [
     '',

package/src/nexus/outbound/router.ts

@@ -141,7 +141,7 @@ export function resolveChannels(
 async function deliverTelegram(cfg: UserConfig, msg: OutboundMsg, deps: RouterDeps): Promise<ChannelResult> {
   const fmt = formatForChannel('telegram', msg);
   const send = deps.telegramSend ?? sendTelegramReport;
-  const ok = await send(cfg, fmt.text, { markdown: fmt.markdown ?? msg.markdown, fetchImpl: deps.fetchImpl });
+  const ok = await send(cfg, fmt.text, { markdown: fmt.markdown ?? msg.markdown, fetchImpl: deps.fetchImpl, kind: msg.kind });
   return ok ? { type: 'telegram', ok: true } : { type: 'telegram', ok: false, error: 'not-configured' };
 }
 

package/src/notify/llm-budget-alert.ts

@@ -0,0 +1,119 @@
+// NT1 — LLM 예산 알림 «모양» (UX · 대표 2026-09-30 22:30 재요청 · OP 결정 B6 ⊕ NT1).
+// 숫자·정책은 TC 의 B6 로더가 채운다(`내부 문서 `RFC-llm-policy-single-file-2026-09-30``) — 이 파일은 문구만 정한다.
+//
+// 규칙 셋(대표 가 받은 알림이 어긴 것들):
+//   ① 한 알림 = 한 결정·한 행동 — 맨 윗줄이 «무엇이 바뀌었나», 마지막 줄이 «할 일».
+//   ② 바뀐 게 없으면 침묵 — 같은 상태(key)면 send=false.
+//   ③ 모순 금지 — «한도 참»과 «크레딧으로 진행 중»을 한 알림에 같이 쓰지 않는다. 상태 하나만 고른다.
+//   ⊕ 내부 낱말 0 — «자»·«판정»·계정 내부 이름 나열을 쓰지 않는다(계정은 «계정 N개»로 센다).
+
+export interface LlmBudgetAccount {
+  name: string;
+  /** 구독 잔량 %(0~100). 모르면 undefined. */
+  subscriptionRemainingPct?: number;
+  /** 이 계정의 크레딧 잔액. */
+  credits?: number;
+  resetInHours?: number;
+}
+
+export interface LlmBudgetSnapshot {
+  /** ISO 시각(Asia/Seoul 로 날짜를 자른다). */
+  at: string;
+  credits: {
+    total: number;
+    usedToday: number;
+    /** 하루 목표 소진량(정책 `credits.pace`). */
+    paceTarget: number;
+    /** ISO 날짜 — 크레딧이 사라지는 날. */
+    expiresAt?: string;
+    /** 정책이 «크레딧 먼저»인가(`until` 전). */
+    useFirst?: boolean;
+  };
+  accounts: LlmBudgetAccount[];
+  selected: { account?: string; reason: 'subscription' | 'credits' | 'fallback' | 'none' };
+  fallback?: { provider: string; remainingPct?: number };
+}
+
+export interface LlmBudgetAlert {
+  send: boolean;
+  /** 상태 열쇠 — 다음 호출의 prevKey 로 넘긴다. */
+  key: string;
+  text: string;
+}
+
+const EXPIRY_WARN_DAYS = 7;
+/** 이 시각(서울) 뒤에야 «오늘 페이스가 느리다»를 말한다 — 아침에 0 인 건 정상이다. */
+const PACE_CHECK_HOUR = 18;
+
+const n = (v: number) => Math.round(v).toLocaleString('ko-KR');
+
+function seoulParts(iso: string): { date: string; hour: number } {
+  const d = new Date(iso);
+  const f = new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', hourCycle: 'h23' });
+  const p = Object.fromEntries(f.formatToParts(d).map((x) => [x.type, x.value]));
+  return { date: `${p.year}-${p.month}-${p.day}`, hour: Number(p.hour) };
+}
+
+function daysBetween(fromIso: string, toIso: string): number {
+  const a = Date.parse(seoulParts(fromIso).date);
+  const b = Date.parse(seoulParts(toIso).date);
+  return Math.round((b - a) / 86_400_000);
+}
+
+function mmdd(iso: string): string {
+  const { date } = seoulParts(iso);
+  return `${date.slice(5, 7)}-${date.slice(8, 10)}`;
+}
+
+function creditsLine(s: LlmBudgetSnapshot): string {
+  const parts = [`오늘 ${n(s.credits.usedToday)} / 목표 ${n(s.credits.paceTarget)}`, `남은 크레딧 ${n(s.credits.total)}`];
+  if (s.credits.expiresAt) parts.push(`${mmdd(s.credits.expiresAt)} 만료`);
+  return parts.join(' · ');
+}
+
+/** 지금 상태 하나를 고른다(위에서부터 먼저 맞는 것). 아무것도 아니면 침묵. */
+export function buildLlmBudgetAlert(now: LlmBudgetSnapshot, prevKey?: string): LlmBudgetAlert {
+  const { date, hour } = seoulParts(now.at);
+  const accounts = now.accounts.length;
+  let key = 'ok';
+  let lines: string[] = [];
+
+  const expiryDays = now.credits.expiresAt ? daysBetween(now.at, now.credits.expiresAt) : undefined;
+
+  if (now.selected.reason === 'none') {
+    key = 'blocked';
+    lines = [
+      '⛔ LLM 을 쓸 곳이 없어 작업이 멈췄습니다.',
+      `구독 계정 ${accounts}개 한도 · 크레딧·대체 모델도 못 씁니다.`,
+      '할 일: 크레딧 사용을 허락하거나 대체 모델 키를 확인해 주세요.',
+    ];
+  } else if (now.selected.reason === 'fallback' && now.fallback) {
+    const soonest = now.accounts.map((a) => a.resetInHours).filter((h): h is number => typeof h === 'number').sort((a, b) => a - b)[0];
+    key = `fallback:${now.fallback.provider}`;
+    lines = [
+      `⚠️ codex 를 못 써서 ${now.fallback.provider} 로 일하고 있습니다${typeof now.fallback.remainingPct === 'number' ? `(남은 ${Math.round(now.fallback.remainingPct)}%)` : ''}.`,
+      soonest !== undefined ? `codex 는 ${Math.ceil(soonest)}시간 뒤 돌아옵니다.` : 'codex 가 언제 돌아오는지 아직 모릅니다.',
+      '할 일: 없음 — 참고만 하세요.',
+    ];
+  } else if (expiryDays !== undefined && expiryDays <= EXPIRY_WARN_DAYS && now.credits.total > 0) {
+    key = `expiry:${Math.max(0, expiryDays)}`;
+    lines = [
+      `💳 크레딧 ${n(now.credits.total)} 이 ${expiryDays <= 0 ? '오늘' : `${expiryDays}일 뒤`} 사라집니다.`,
+      creditsLine(now),
+      '할 일: 무거운 작업을 지금 맡기면 크레딧으로 돕니다.',
+    ];
+  } else if (now.credits.useFirst && now.credits.total > 0 && hour >= PACE_CHECK_HOUR && now.credits.usedToday < now.credits.paceTarget * 0.5) {
+    // 하루 한 번만 — 날짜를 열쇠에 넣는다.
+    key = `pace-behind:${date}`;
+    lines = [
+      now.selected.reason === 'credits'
+        ? '💳 크레딧을 먼저 쓰는 중인데 오늘 쓴 양이 목표의 절반이 안 됩니다.'
+        : '💳 크레딧을 먼저 쓰라는 방침인데 오늘은 구독 계정이 먼저 쓰였습니다.',
+      creditsLine(now),
+      now.selected.reason === 'credits' ? '할 일: 없음 — 맡긴 일이 적었던 날입니다.' : '할 일: 없음 — 기술 담당이 순서를 고치는 중입니다.',
+    ];
+  }
+
+  const send = key !== 'ok' && key !== prevKey;
+  return { send, key, text: lines.join('\n') };
+}

package/src/onboarding.ts

@@ -1193,6 +1193,27 @@ export function shouldRefuseInteractiveOnboarding(
   return o.ctx !== 'production' || !o.stdinIsTTY;
 }
 
+export class OnboardingRefusedError extends Error {
+  readonly code = 'onboarding-refused' as const;
+
+  constructor(message: string, readonly reason: 'non-tty' | 'autonomous-empty-universe') {
+    super(message);
+    this.name = 'OnboardingRefusedError';
+  }
+}
+
+/** Handle only typed refusals; the agent setup hint applies to its non-TTY path alone. */
+export function handleOnboardingRefusal(error: unknown, entrance: 'agent' | 'other'): boolean {
+  if (!(error instanceof OnboardingRefusedError) || error.code !== 'onboarding-refused') return false;
+  if (entrance === 'agent' && error.reason === 'non-tty') {
+    console.error('elanous agent needs a configured LLM. Run `elanous setup` in a terminal, or `elanous setup --non-interactive --config <path>` for unattended setup.');
+  } else {
+    console.error(error.message);
+  }
+  process.exitCode = 2;
+  return true;
+}
+
 function refuseInteractiveOnboardingIfNeeded(opts: RunWizardOpts, path: string): void {
   const ctx = getRunContext();
   const stdinIsTTY = !!input.isTTY;
@@ -1208,15 +1229,17 @@ function refuseInteractiveOnboardingIfNeeded(opts: RunWizardOpts, path: string):
       : '자율 컨텍스트에서 대화형 온보딩 요청 — 우주가 비어 있다(물질화 누락)',
   }, { level: 'error' });
   if (nonTTY) {
-    throw new Error(
+    throw new OnboardingRefusedError(
       '대화형 온보딩은 stdin TTY가 있는 자리에서만 실행할 수 있다. '
       + '무인 설정은 `elanous setup --non-interactive --config <path>`를 사용하라.',
+      'non-tty',
     );
   }
-  throw new Error(
+  throw new OnboardingRefusedError(
     `온보딩 마법사는 자율 컨텍스트(${ctx})에서 뜰 수 없다 — config 가 비어 있다(${path}). `
     + '자식 우주가 물질화되지 않았다는 뜻이다: `elanous config sync-test --state-dir <그 우주>` '
     + '로 깔거나, 스포너가 provisionDerivedUniverse 를 부르는지 확인하라.',
+    'autonomous-empty-universe',
   );
 }