elanous 0.2.13 → 0.2.15

package/src/loops/status-rows.ts

@@ -0,0 +1,118 @@
+import { loopCronVerdict, type LoopCronVerdict } from './verdict';
+
+const VERDICT_LABEL: Record<LoopCronVerdict, LoopRow['verdict']> = {
+  alive: '살아 있음', late: '늦음', failed: '실패', off: '꺼짐',
+};
+
+export interface LoopSchedule {
+  id: string;
+  name: string;
+  source: string;
+  category: string | null;
+  domain: string | null;
+  runVia: string | null;
+  cron: string | null;
+  intervalMs: number | null;
+  state: 'live' | 'firing' | 'stale' | 'off';
+  next: string[];
+  lastRun: { at: string; status: string | null; exit: number | null } | null;
+}
+
+export interface LoopRow {
+  id: string;
+  name: string;
+  layer: string;
+  owner: string;
+  mode: string;
+  lastRun: string | null;
+  verdict: '살아 있음' | '늦음' | '실패' | '꺼짐' | '판정 불가';
+}
+
+export const LOOP_SCHEDULES_PATH = '/v1/schedules?includeOff=1';
+export const LOOPS_PATH = '/v1/dashboard/loops';
+
+interface RecordedLoop {
+  name: string;
+  label: string;
+  category?: string;
+  armed: boolean | null;
+  last: { at: string; status: string } | null;
+}
+
+export async function loadLoopRows(fetchJson: (path: string) => Promise<unknown>, now: number): Promise<LoopRow[]> {
+  const [schedulesResult, loopsResult] = await Promise.allSettled([
+    fetchJson(LOOP_SCHEDULES_PATH), fetchJson(LOOPS_PATH),
+  ]);
+  const schedules = schedulesResult.status === 'fulfilled' ? (schedulesResult.value as { schedules?: unknown })?.schedules : null;
+  const loops = loopsResult.status === 'fulfilled' ? (loopsResult.value as { loops?: { loops?: unknown } | null })?.loops?.loops : null;
+  if (!Array.isArray(schedules) && !Array.isArray(loops)) throw new Error('loop registries unavailable');
+  if (!Array.isArray(schedules)) throw new Error('스케줄 레지스트리 조회 실패');
+  if (!Array.isArray(loops)) throw new Error('루프 레지스트리 조회 실패');
+  // These registries have different ID namespaces even when labels match.
+  const rows = loopRows(schedules as LoopSchedule[], now).map((row) => ({ ...row, id: `schedule:${row.id}` }));
+  for (const loop of loops as RecordedLoop[]) {
+    const last = loop.last ? Date.parse(loop.last.at) : NaN;
+    const verdict = loopCronVerdict({
+      enabled: loop.armed !== false,
+      lastRunAt: loop.last?.at ?? null,
+      lastStatus: loop.last?.status.toLowerCase() ?? null,
+      intervalMs: null,
+    }, now);
+    rows.push({
+      id: `loop:${loop.name}`, name: loop.label, layer: loop.category ?? '루프', owner: '미지정',
+      mode: loop.armed === null ? '관측' : loop.armed ? 'armed' : 'off',
+      lastRun: Number.isFinite(last) ? loop.last!.at : null,
+      verdict: verdict === 'alive' ? '판정 불가' : VERDICT_LABEL[verdict],
+    });
+  }
+  return rows;
+}
+
+export function createLoopRowsRefresh(
+  fetchJson: (path: string) => Promise<unknown>,
+  onResult: (result: { rows: LoopRow[]; state: 'ready' | 'error' }) => void,
+  clock: () => number = Date.now,
+) {
+  let sequence = 0;
+  let active = true;
+  return {
+    async refresh() {
+      const request = ++sequence;
+      try {
+        const rows = await loadLoopRows(fetchJson, clock());
+        if (active && request === sequence) onResult({ rows, state: 'ready' });
+      } catch {
+        if (active && request === sequence) onResult({ rows: [], state: 'error' });
+      }
+    },
+    dispose() { active = false; },
+  };
+}
+
+export function loopRows(schedules: readonly LoopSchedule[], now: number): LoopRow[] {
+  return schedules.map((schedule) => {
+    const last = schedule.lastRun ? Date.parse(schedule.lastRun.at) : NaN;
+    const sharedVerdict = loopCronVerdict({
+      enabled: schedule.state !== 'off',
+      lastRunAt: schedule.lastRun?.at ?? null,
+      lastStatus: schedule.lastRun?.exit != null && schedule.lastRun.exit !== 0
+        ? 'failed' : schedule.lastRun?.status != null && !['ok', 'success', 'completed'].includes(schedule.lastRun.status.toLowerCase())
+          ? 'failed' : schedule.lastRun?.status?.toLowerCase() ?? null,
+      intervalMs: schedule.cron ? null : schedule.intervalMs,
+      // A cron uses daemon calendar state; fixed intervals use the 2× interval rule.
+      ...(schedule.cron ? { scheduleState: schedule.state } : {}),
+    }, now);
+    const noCadence = !schedule.cron && !(schedule.intervalMs && schedule.intervalMs > 0);
+    const verdict = sharedVerdict === 'alive' && (!Number.isFinite(last) || noCadence)
+      ? '판정 불가' : VERDICT_LABEL[sharedVerdict];
+    return {
+      id: schedule.id,
+      name: schedule.name,
+      layer: schedule.domain || schedule.category || schedule.source,
+      owner: '미지정',
+      mode: schedule.runVia || schedule.source,
+      lastRun: Number.isFinite(last) ? schedule.lastRun!.at : null,
+      verdict,
+    };
+  });
+}

package/src/loops/verdict.ts

@@ -1,20 +1,32 @@
 export type LoopCronVerdict = 'alive' | 'late' | 'failed' | 'off';
 
-/** Shared display inputs for a graph loop or a cron job. The caller supplies
- * the cadence in milliseconds (or null when it is not known). */
+/** Shared display inputs for a graph loop or cron job. Fixed intervals use
+ * milliseconds; calendar cron schedules supply the second actual due instant. */
 export interface LoopCronVerdictInput {
   enabled: boolean;
   lastRunAt: string | null;
   lastStatus: string | null;
   intervalMs: number | null;
+  /** Second scheduled execution after the last run, for calendar-based cron schedules. */
+  secondDueAt?: string | null;
+  /** Cron-aware daemon state (src/domains/schedule-state.ts). Callers pass it for cron schedules only —
+   *  a fixed interval keeps its own «2× interval» rule (review must-fix: stale must not override an interval). */
+  scheduleState?: 'live' | 'firing' | 'stale' | 'off';
 }
 
 /** Pure health classification; a failed last execution takes precedence over age.
- * With no valid timestamp or positive cadence, lateness cannot be established. */
+ * Without a valid last run and a cadence/due instant, lateness needs the daemon stale signal. */
 export function loopCronVerdict(entry: LoopCronVerdictInput, nowMs: number): LoopCronVerdict {
-  if (!entry.enabled) return 'off';
-  if (entry.lastStatus === 'failed' || entry.lastStatus === 'error' || entry.lastStatus === 'failure') return 'failed';
+  if (!entry.enabled || entry.scheduleState === 'off') return 'off';
+  if (entry.lastStatus === 'failed' || entry.lastStatus === 'error' || entry.lastStatus === 'failure' ||
+      entry.lastStatus === 'abandoned' || entry.lastStatus === 'expired') return 'failed';
+  if (entry.scheduleState === 'stale') return 'late';
   const lastRunMs = entry.lastRunAt === null ? NaN : Date.parse(entry.lastRunAt);
+  if (entry.secondDueAt !== undefined) {
+    const secondDueMs = entry.secondDueAt === null ? NaN : Date.parse(entry.secondDueAt);
+    return Number.isFinite(lastRunMs) && Number.isFinite(nowMs) &&
+      Number.isFinite(secondDueMs) && secondDueMs > lastRunMs && nowMs > secondDueMs ? 'late' : 'alive';
+  }
   if (Number.isFinite(nowMs) && Number.isFinite(lastRunMs) &&
       entry.intervalMs !== null && Number.isFinite(entry.intervalMs) && entry.intervalMs > 0 &&
       nowMs - lastRunMs > 2 * entry.intervalMs) return 'late';

package/src/maturity/bot-slash-catalog.ts

@@ -0,0 +1,66 @@
+import type { SlashCommand } from '../chat/index.js';
+import type { Maturity } from './feature-maturity.js';
+import type { BotSurface } from './bot-command-maturity.js';
+
+export interface BotSlashCatalogEntry {
+  name: string;
+  description: string;
+  supported: boolean;
+}
+
+export interface BotSlashCatalog {
+  commands: BotSlashCatalogEntry[];
+  /** Null means this name is already handled, or is not in the catalog. */
+  unsupportedReply(name: string): string | null;
+}
+
+/** The menu is a projection of registered core commands, not a second list of invented names.
+ * A bot's actual handlers take precedence over maturity metadata: a grade describes
+ * visibility, never whether an existing command can be dispatched. */
+export function buildBotSlashCatalog(options: {
+  surface: BotSurface;
+  coreCommands: readonly Pick<SlashCommand, 'name' | 'description'>[];
+  maturity: {
+    tuiSlash: Readonly<Record<string, Maturity>>;
+    telegramCommand: Readonly<Record<string, Maturity>>;
+    discordCommand: Readonly<Record<string, Maturity>>;
+  };
+  handledCommands: readonly { name: string; description: string }[];
+}): BotSlashCatalog {
+  const { surface, coreCommands, maturity, handledCommands } = options;
+  const grades = surface === 'telegram' ? maturity.telegramCommand : maturity.discordCommand;
+  const validName = surface === 'telegram' ? /^[a-z0-9_]{1,32}$/ : /^[a-z0-9_-]{1,32}$/;
+  const commands: BotSlashCatalogEntry[] = [];
+  const seen = new Set<string>();
+  for (const command of handledCommands) {
+    if (seen.has(command.name)) continue;
+    commands.push({ name: command.name, description: command.description, supported: true });
+    seen.add(command.name);
+  }
+  const limit = surface === 'telegram' ? 100 : 25;
+  const candidateNames = new Set<string>();
+  const candidates = coreCommands.filter((command) => {
+    const name = command.name;
+    const grade = Object.hasOwn(grades, name) ? grades[name] : undefined;
+    if (seen.has(name) || candidateNames.has(name) || !validName.test(name) || grade === undefined || grade === 'broken' || grade === 'system') return false;
+    candidateNames.add(name);
+    return true;
+  });
+  if (commands.length + candidates.length > limit) {
+    throw new Error(`${surface} command catalog exceeds ${limit} slots`);
+  }
+  for (const command of candidates) {
+    const name = command.name;
+    const description = command.description.replace(/\s+/g, ' ').trim();
+    const suffix = ` (${surface === 'telegram' ? '텔레그램' : '디스코드'} 미지원)`;
+    commands.push({ name, description: `${description.slice(0, 100 - suffix.length)}${suffix}`, supported: false });
+    seen.add(name);
+  }
+  const unsupported = new Set(commands.filter((command) => !command.supported).map((command) => command.name));
+  return {
+    commands,
+    unsupportedReply(name) {
+      return unsupported.has(name) ? `/${name}은(는) ${surface === 'telegram' ? '텔레그램' : '디스코드'}에서 아직 지원되지 않습니다. TUI에서 /${name}을(를) 사용하세요.` : null;
+    },
+  };
+}

package/src/maturity/feature-maturity.ts

@@ -41,9 +41,11 @@ export const FEATURE_MATURITY = {
     '/design-check': { pwa: 'tool' },
     '/control': { pwa: 'tool' },
     '/scheduler': { pwa: 'ops' },
+    '/loops': { pwa: 'beta' },
     '/ops/release': { pwa: 'ops' },
     '/ops/seats': { pwa: 'ops' },
     '/ops/checklist': { pwa: 'ops' },
+    '/ceo': { pwa: 'ops' },
     '/dashboard': { pwa: 'ops' },
     '/bots': { pwa: 'ops' },
     '/botlab': { pwa: 'ops' },
@@ -54,10 +56,10 @@ export const FEATURE_MATURITY = {
   },
   // Canonical CLI command names only; aliases inherit their command's grade.
   cliRoot: {
-    pty: 'beta', pr: 'beta', repo: 'beta', role: 'beta', machine: 'beta',
+    pty: 'beta', pr: 'beta', repo: 'beta', role: 'beta', machine: 'beta', 'agent-env': 'beta',
     where: 'stable', shadow: 'beta', llm: 'beta', storage: 'beta', leader: 'beta',
     pod: 'beta', browser: 'beta', questions: 'beta', usage: 'stable', live: 'beta',
-    research: 'beta', release: 'beta', seat: 'beta', hq: 'beta', steward: 'beta', coord: 'beta', context: 'beta', 'model-watch': 'beta', doctor: 'stable',
+    research: 'beta', release: 'beta', freeze: 'beta', flow: 'beta', seat: 'beta', hq: 'beta', steward: 'beta', coord: 'beta', context: 'beta', 'model-watch': 'beta', doctor: 'stable',
     control: 'beta', resources: 'beta', hooks: 'beta', setup: 'stable', start: 'stable',
     grounding: 'beta', graph: 'beta', loop: 'stable', card: 'stable', 'launch-head': 'beta',
     a2a: 'beta', plugin: 'stable', make: 'beta', skills: 'beta', connect: 'beta', import: 'beta',
@@ -71,7 +73,7 @@ export const FEATURE_MATURITY = {
     provider: 'stable', 'provider:set': 'beta', 'provider:restore': 'beta',
     'provider:rotate': 'beta', 'provider:use': 'beta', 'status-bar': 'beta',
     schedule: 'beta', intake: 'beta', logs: 'stable', ad: 'beta', docs: 'beta',
-    decisions: 'beta', directives: 'beta', fleet: 'beta', ops: 'stable', outputs: 'beta', publish: 'beta',
+    decisions: 'beta', directives: 'beta', claims: 'beta', lesson: 'beta', fleet: 'beta', ops: 'stable', outputs: 'beta', publish: 'beta',
     env: 'beta', 'agent-mission': 'beta', dev: 'beta', keys: 'beta', finance: 'beta',
     config: 'stable', tasks: 'stable', labels: 'beta', msg: 'beta', ask: 'stable',
     onboarding: 'beta', login: 'stable', session: 'beta', chat: 'stable', repl: 'stable',
@@ -110,6 +112,8 @@ export const FEATURE_MATURITY = {
     plugin: 'tool',
     widget: 'tool',
     log: 'tool',
+    loops: 'beta',
+    persona: 'beta', // G3 b — 대화별 페르소나(GOAL-BENCH B7 #23836)
     memory: 'beta',
     export: 'stable',
     delta: 'tool',
@@ -153,7 +157,7 @@ export const FEATURE_MATURITY = {
     ping: 'stable', provider: 'stable', sessions: 'stable', fork: 'stable', resume: 'stable',
     decisions: 'stable', work: 'stable', cancel: 'stable',
     skills: 'beta', skill: 'beta', digest: 'beta', intake: 'beta', ad: 'beta',
-    taste: 'beta', missions: 'beta', attach: 'beta', detach: 'beta', now: 'beta', project: 'beta', wish: 'beta',
+    taste: 'beta', missions: 'beta', attach: 'beta', detach: 'beta', now: 'beta', loops: 'beta', project: 'beta', wish: 'beta',
     brain: 'tool', cc: 'tool', cdx: 'tool', gem: 'tool', local: 'tool',
     harness: 'ops',
     // Existing commands outside the CXO four-grade menu list are owner-only.
@@ -162,7 +166,7 @@ export const FEATURE_MATURITY = {
   },
   discordCommand: {
     status: 'stable', sessions: 'stable', new: 'stable', fork: 'stable',
-    persona: 'beta', poll: 'beta', attach: 'beta',
+    persona: 'beta', poll: 'beta', attach: 'beta', now: 'beta',
     brain: 'tool', cc: 'tool', cdx: 'tool', gem: 'tool',
     relay: 'ops', showroom: 'ops', bots: 'ops', bot: 'ops', screen: 'ops', chart: 'ops',
     routines: 'ops', botsay: 'ops', 'voice-join': 'ops', 'voice-leave': 'ops', 'voice-status': 'ops',

package/src/maturity/tui-slash-availability.ts

@@ -0,0 +1,31 @@
+import { SLASH_COMMANDS, type SlashCommand } from '../chat/index.js';
+import { FEATURE_MATURITY, type Maturity } from './feature-maturity.js';
+
+export interface TuiSlashAvailability {
+  name: string;
+  maturity: Maturity;
+  telegram: boolean;
+  discord: boolean;
+}
+
+/** Project canonical TUI commands onto the maturity map and bot-surface grade maps.
+ * An absent bot grade means unavailable; a missing TUI grade is a registry error.
+ */
+export function deriveTuiSlashAvailability(
+  commands: readonly Pick<SlashCommand, 'name'>[] = SLASH_COMMANDS,
+  grades: {
+    tuiSlash: Readonly<Record<string, Maturity>>;
+    telegramCommand: Readonly<Record<string, Maturity>>;
+    discordCommand: Readonly<Record<string, Maturity>>;
+  } = FEATURE_MATURITY,
+): TuiSlashAvailability[] {
+  return commands.map(({ name }) => {
+    if (!Object.hasOwn(grades.tuiSlash, name)) throw new Error(`TUI slash command /${name} has no maturity grade`);
+    return {
+      name,
+      maturity: grades.tuiSlash[name]!,
+      telegram: Object.hasOwn(grades.telegramCommand, name),
+      discord: Object.hasOwn(grades.discordCommand, name),
+    };
+  });
+}

package/src/mss/logging/log-store.ts

@@ -270,23 +270,54 @@ export class LogStore {
     this.db.run('CREATE INDEX IF NOT EXISTS idx_logs_level ON logs(level, ts_ms)');
     this.db.run('CREATE INDEX IF NOT EXISTS idx_logs_surface ON logs(surface, ts_ms)');
     this.db.run('CREATE INDEX IF NOT EXISTS idx_logs_category ON logs(category, ts_ms)');
+    this.db.run(`CREATE TABLE IF NOT EXISTS pod_log_imports (
+      job TEXT NOT NULL,
+      line INTEGER NOT NULL,
+      PRIMARY KEY (job, line)
+    )`);
+  }
+
+  /** Insert each returned Pod line at most once per job, atomically with its receipt. */
+  insertPodBatch(job: string, rows: Array<{ rec: LogRecord; surface: string; line: number }>): number {
+    if (rows.length === 0) return 0;
+    const receipt = this.db.prepare('INSERT OR IGNORE INTO pod_log_imports (job, line) VALUES (?, ?)');
+    return this.db.transaction(() => {
+      const unseen = rows.filter(({ line }) => receipt.run(job, line).changes > 0);
+      this.insertBatch(unseen, { preserveRows: true });
+      return unseen.length;
+    })();
   }
 
   /** 배치 insert(단일 트랜잭션). 실패는 throw — fail-soft 는 호출측(StoreSink)
    *  책임(ops-log 의 recordOpsEvent/Safe 분업 동형). */
-  insertBatch(rows: Array<{ rec: LogRecord; surface: string }>): void {
+  insertBatch(rows: Array<{ rec: LogRecord; surface: string }>, opts: { preserveRows?: boolean } = {}): void {
     if (rows.length === 0) return;
     const stmt = this.db.prepare(
       `INSERT INTO logs (ts, ts_ms, level, instance, host_id, surface, category, event, session_id, trace_id, data)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     );
+    const decisionRow = this.db.prepare(`SELECT id FROM logs WHERE instance = ? AND category = 'loop.steward' AND event = 'decision'
+      AND json_valid(data) AND json_extract(data, '$.runId') = ? ORDER BY id DESC LIMIT 1`);
+    const updateDecision = this.db.prepare(`UPDATE logs SET ts = ?, ts_ms = ?, level = ?, surface = ?, data = ? WHERE id = ?`);
     const insertAll = this.db.transaction((batch: Array<{ rec: LogRecord; surface: string }>) => {
       for (const { rec, surface } of batch) {
         const tsMs = Date.parse(rec.ts);
+        const timestamp = Number.isFinite(tsMs) ? tsMs : Date.now();
+        const level = deriveLogLevel(rec);
+        const data = rec.data !== undefined ? JSON.stringify(rec.data) : null;
+        const runId = rec.category === 'loop.steward' && rec.event === 'decision' &&
+          rec.data && typeof rec.data === 'object' && !Array.isArray(rec.data)
+          ? (rec.data as Record<string, unknown>).runId : undefined;
+        const existing = !opts.preserveRows && typeof runId === 'string' && runId
+          ? decisionRow.get(this.instance, runId) as { id: number } | undefined : undefined;
+        if (existing) {
+          updateDecision.run(rec.ts, timestamp, level, surface, data, existing.id);
+          continue;
+        }
         stmt.run(
           rec.ts,
-          Number.isFinite(tsMs) ? tsMs : Date.now(),
-          deriveLogLevel(rec),
+          timestamp,
+          level,
           this.instance,
           rec.data && typeof rec.data === 'object' && !Array.isArray(rec.data)
             && typeof (rec.data as Record<string, unknown>).hostId === 'string'
@@ -297,7 +328,7 @@ export class LogStore {
           rec.event,
           (rec as { session_id?: string }).session_id ?? null,
           rec.trace_id ?? null,
-          rec.data !== undefined ? JSON.stringify(rec.data) : null,
+          data,
         );
       }
     });

package/src/nexus/api/dashboard.ts

@@ -4,6 +4,7 @@
 //   GET /v1/dashboard/timeline  — 신호 타임라인 (?hours=48&floor=6)
 //   GET /v1/dashboard/heatmap   — 자산×국가×섹터 매력도 + US 섹터 + 뉴스 분포
 //   GET /v1/dashboard/digs      — 디깅 리포트 피드 (?limit=20)
+//   GET /v1/dashboard/loop-activity — 루프 활동 그래프 (?since=24h)
 //
 // 전부 read-only · 캐시/로컬 SQLite 만 (dashboard-data.ts) — 라이브 fetch 없음.
 // PWA 폴링(60s) 대상. reflection.ts 패턴(CORS·checkAuth seam) 상속.
@@ -16,12 +17,15 @@ import {
 } from '../../domains/dashboard-data.js';
 import { readLiveSnapshot } from '../../domains/market-live.js';
 import { marketSessions } from '../../domains/finance.js';
+import { loopActivity } from '../../loops/activity.js';
 
 export interface DashboardRouteOpts {
   /** Auth check seam. */
   checkAuth?: (req: Request) => boolean;
   /** Test seam — 실제 detached 수집 spawn 대체. */
   spawnCollector?: () => void;
+  /** Read-only activity provider for isolated route tests. */
+  loopActivity?: typeof loopActivity;
 }
 
 const CORS_HEADERS: Record<string, string> = {
@@ -43,7 +47,7 @@ export function parseDashboardPath(pathname: string): string | null {
   const m = /^\/v1\/dashboard\/([^/]+)$/.exec(pathname);
   if (!m) return null;
   const seg = decodeURIComponent(m[1]!);
-  return ['summary', 'timeline', 'heatmap', 'digs', 'schedules', 'ontology', 'backtest', 'loops', 'ops'].includes(seg) ? seg : null;
+  return ['summary', 'timeline', 'heatmap', 'digs', 'schedules', 'ontology', 'backtest', 'loops', 'loop-activity', 'ops'].includes(seg) ? seg : null;
 }
 
 /** POST /v1/dashboard/refresh-live — 온디맨드 라이브 재수집 트리거 (refresh 버튼 설계 ·
@@ -99,6 +103,7 @@ export function handleDashboard(req: Request, section: string, opts: DashboardRo
       case 'ontology': return jsonResponse({ ok: true, ontology: dashboardOntology() }, 200);
       case 'backtest': return jsonResponse({ ok: true, backtest: dashboardBacktest() }, 200);
       case 'loops': return jsonResponse({ ok: true, loops: dashboardLoops() }, 200);
+      case 'loop-activity': return jsonResponse({ ok: true, activity: (opts.loopActivity ?? loopActivity)({ since: q.get('since') ?? '24h' }) }, 200);
       case 'ops': {
         const mid = q.get('mission');
         if (mid) return jsonResponse({ ok: true, missionDetail: dashboardOpsMission(mid) }, 200);

package/src/nexus/api/http-server.ts

@@ -162,6 +162,7 @@ import {
 } from './vault-api.js';
 import { handleBuildsGet, parseBuildsPath } from './builds-api.js';
 import { handleHarnessAskPost, handleHarnessAskStatusGet, handleHarnessRunEventsGet, handleHarnessRunScreenGet, handleHarnessRunsGet, handleHarnessStopPost } from './harness-api.js';
+import { handleLoopEdgesGet } from './loop-edges.js';
 import { handleFabricPlans, type FabricPlansRouteOpts } from './fabric-plans.js';
 import { dispatchPersonaRoute } from './personas.js';
 import { handleMe } from './operator.js';
@@ -184,7 +185,9 @@ import { handleChannelBotsGet, handleChannelBotSet } from './setup-channel-bot.j
 import { handleLlmRoutePredict } from './llm-route-predict.js';
 import type { MissionRouter } from '../../llm/mission-router.js';
 import { handleContextFetchUrl } from './context-url.js';
-import { contextNow } from '../../context-bus/context-now.js';
+import { contextNow, type ContextNowDeps } from '../../context-bus/context-now.js';
+import type { ContextNowAudience } from '../../context-bus/context-now-surfaces.js';
+import { renderVoiceNow } from '../../context-bus/context-now-surfaces.js';
 import type { IntentPredictionService } from '../../intent-prediction/index.js';
 import type { NotificationActionLoopback } from '../../web-push/notification-action-loopback.js';
 import { handlePlatforms } from './platforms.js';
@@ -486,6 +489,8 @@ export interface NexusHttpServerOpts {
   eventBus: NexusEventBus;
   /** Test seam for the read-only usage collector; production uses the cached handler. */
   usageHandler?: () => Promise<Response>;
+  /** Test seam for the context-now ledgers; production reads the live ledgers. */
+  contextNowDeps?: ContextNowDeps;
   /** Supervisor handle — required for the write API (PR ι). When omitted
    *  (skipSupervisor mode), mutation routes return 503. */
   supervisor?: Supervisor;
@@ -1291,6 +1296,15 @@ export async function routeRequest(
     return handleDevices(req, opts.devices);
   }
 
+  if (pathname === '/v1/loops/edges' && method === 'GET') {
+    if (!opts.metaApi?.bearerToken) return jsonResponse({ error: 'unauthorized' }, 401);
+    const offered = req.headers.get('authorization');
+    if (!offered?.startsWith('Bearer ') || !compareTokenConstTime(offered.slice('Bearer '.length).trim(), opts.metaApi.bearerToken)) {
+      return jsonResponse({ error: 'unauthorized' }, 401);
+    }
+    return handleLoopEdgesGet(req);
+  }
+
   if (pathname === '/v1/harness/runs' && method === 'GET') {
     if (!opts.metaApi) return jsonResponse({ error: 'meta-api-runtime-not-wired' }, 503);
     if (!checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
@@ -2878,8 +2892,24 @@ export async function routeRequest(
     if (result) return result;
   }
   if (pathname === '/v1/context/now') {
-    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
-    return jsonResponse(contextNow({ ...(url.searchParams.has('topic') ? { topic: url.searchParams.get('topic') ?? '' } : {}) }));
+    try {
+      if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+      const audiences = url.searchParams.getAll('audience');
+      if (audiences.length > 1) return jsonResponse({ error: 'invalid_audience' }, 400);
+      const requested = audiences[0];
+      if (requested !== undefined && requested !== 'operator' && requested !== 'user' && requested !== 'public-demo') {
+        return jsonResponse({ error: 'invalid_audience' }, 400);
+      }
+      const forced = getUserConfig().nexus?.demoMode === true;
+      const audience: ContextNowAudience = forced ? 'public-demo' : requested ?? 'operator';
+      const answer = contextNow({ audience, ...(url.searchParams.has('topic') ? { topic: url.searchParams.get('topic') ?? '' } : {}) }, opts.contextNowDeps);
+      debug.log('context.now', 'served', { audience, hidden: answer.hiddenCount ?? 0, forced });
+      return jsonResponse(url.searchParams.get('format') === 'voice'
+        ? { text: renderVoiceNow(answer, audience), audience, hiddenCount: answer.hiddenCount ?? 0 }
+        : { ...answer, audience, hiddenCount: answer.hiddenCount ?? 0 });
+    } catch {
+      return jsonResponse({ error: 'context-now-failed' }, 500);
+    }
   }
   // §6.3 (2026-05-09) — context URL fetch (showroom).
   // POST /v1/context/fetch-url