elanous 0.2.12 → 0.2.14

package/src/loops/verdict.ts

@@ -0,0 +1,34 @@
+export type LoopCronVerdict = 'alive' | 'late' | 'failed' | 'off';
+
+/** 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.
+ * 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 || 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';
+  return 'alive';
+}

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,6 +41,7 @@ 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' },
@@ -57,11 +58,11 @@ export const FEATURE_MATURITY = {
     pty: 'beta', pr: 'beta', repo: 'beta', role: 'beta', machine: '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', 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',
-    persona: 'beta', 'team-set': 'beta', market: 'beta', directive: 'stable', connector: 'beta', storyboard: 'beta',
+    persona: 'beta', team: 'beta', 'team-set': 'beta', market: 'beta', directive: 'stable', connector: 'beta', storyboard: 'beta',
     python: 'beta', 'self-update': 'stable', 'measure-fabric-arc-ab': 'beta', mcp: 'beta',
     relay: 'beta', 'telegram-test': 'beta', telegram: 'beta', 'discord-test': 'beta',
     sync: 'beta', status: 'beta', git: 'beta', gh: 'beta', repro: 'system',
@@ -71,7 +72,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', 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 +111,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 +156,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 +165,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/memory.ts

@@ -63,6 +63,16 @@ export function writeFileDurable(path: string, data: string, fsync: (fd: number)
 
 export type MemoryType = 'user' | 'feedback' | 'project' | 'reference';
 
+/** Context-condense metadata travels with the existing curated memory file, not a parallel store. */
+export interface ContextMemoryCard {
+  project: string;
+  seat: string;
+  topic: string;
+  source: string;
+  updatedAt: string;
+  status: 'active' | 'retired';
+}
+
 export interface MemoryEntry {
   id: string;                 // uuid v4
   filename: string;           // "<uuid>-<slug>.md"
@@ -89,6 +99,7 @@ export interface MemoryEntry {
   pinned: boolean;
   /** Optional pinned-memory freshness window; absent memories retain their original injection text. */
   staleAfterMinutes?: number;
+  contextCard?: ContextMemoryCard;
 }
 
 // ── Paths ────────────────────────────────────────────────────────────
@@ -192,6 +203,7 @@ export interface SaveMemoryOpts {
   staleAfterMinutes?: number;
   /** Override the generated id (tests). */
   id?: string;
+  contextCard?: ContextMemoryCard;
 }
 
 export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): MemoryEntry {
@@ -207,6 +219,7 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
   let existingPriority: number | undefined;
   let existingPinned: boolean | undefined;
   let existingStaleAfterMinutes: number | undefined;
+  let existingContextCard: ContextMemoryCard | undefined;
   if (existsSync(path)) {
     try {
       const parsed = parseFrontmatter(readFileSync(path, 'utf-8'));
@@ -214,6 +227,7 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
       if (parsed.fm.priority) existingPriority = parseInt(parsed.fm.priority, 10) || 0;
       if (parsed.fm.pinned) existingPinned = parsed.fm.pinned === 'true';
       existingStaleAfterMinutes = parseStaleAfterMinutes(parsed.fm['stale-after-minutes']);
+      existingContextCard = parseContextCard(parsed.fm['context-card']);
     } catch { /* keep new createdAt */ }
   }
   const priority = opts.priority ?? existingPriority ?? 0;
@@ -229,6 +243,8 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
   if (priority > 0) frontmatter.priority = String(Math.floor(priority));
   if (pinned) frontmatter.pinned = 'true';
   if (staleAfterMinutes !== undefined) frontmatter['stale-after-minutes'] = String(staleAfterMinutes);
+  const contextCard = opts.contextCard ?? existingContextCard;
+  if (contextCard) frontmatter['context-card'] = JSON.stringify(contextCard);
   const raw = renderFrontmatter(frontmatter, opts.body);
   writeFileDurable(path, raw);
 
@@ -248,9 +264,23 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
     priority,
     pinned,
     staleAfterMinutes,
+    ...(contextCard ? { contextCard } : {}),
   };
 }
 
+function parseContextCard(raw: string | undefined): ContextMemoryCard | undefined {
+  if (!raw) return undefined;
+  try {
+    const card: unknown = JSON.parse(raw);
+    if (card && typeof card === 'object' && !Array.isArray(card)) {
+      const c = card as Record<string, unknown>;
+      if (['project', 'seat', 'topic', 'source', 'updatedAt'].every(key => typeof c[key] === 'string')
+        && (c.status === 'active' || c.status === 'retired')) return c as unknown as ContextMemoryCard;
+    }
+  } catch { /* malformed metadata is not a context memory */ }
+  return undefined;
+}
+
 /** Parse one memory file. Returns null on read/parse error. */
 function parseMemoryFile(path: string): MemoryEntry | null {
   if (!existsSync(path)) return null;
@@ -261,6 +291,7 @@ function parseMemoryFile(path: string): MemoryEntry | null {
   const basename = path.split(/[\\/]/).pop() ?? '';
   const match = basename.match(/^([0-9a-f-]{36})-(.+)\.md$/i);
   const id = match ? match[1] : createHash('sha1').update(basename).digest('hex').slice(0, 36);
+  const contextCard = parseContextCard(fm['context-card']);
   return {
     id,
     filename: basename,
@@ -274,6 +305,7 @@ function parseMemoryFile(path: string): MemoryEntry | null {
     priority: fm.priority ? (parseInt(fm.priority, 10) || 0) : 0,
     pinned: fm.pinned === 'true',
     staleAfterMinutes: parseStaleAfterMinutes(fm['stale-after-minutes']),
+    ...(contextCard ? { contextCard } : {}),
   };
 }
 
@@ -364,6 +396,7 @@ export function searchMemories(
   const entries = listMemories({ type: opts.type }, root);
   const hits: SearchHit[] = [];
   for (const entry of entries) {
+    if (entry.contextCard?.status === 'retired') continue;
     // 정확-토큰 매칭(2026-07-19) — 이전 substring `includes(kw)` 는 "ref"가 "reference"·
     // "prefer" 안에까지 걸려 오차용(false-recall)을 냈다(openclaw tool-search.ts 이식:
     // tokenize→Set.has 전체토큰 동등). name/description 은 토큰집합 정확매칭, body 는
@@ -415,7 +448,7 @@ export function rebuildIndex(root: string = memoryRoot()): void {
   const byType: Record<MemoryType, MemoryEntry[]> = {
     user: [], feedback: [], project: [], reference: [],
   };
-  for (const e of entries) byType[e.type].push(e);
+  for (const e of entries) if (e.contextCard?.status !== 'retired') byType[e.type].push(e);
 
   const lines: string[] = [];
   lines.push('# elanous memory index');
@@ -515,7 +548,7 @@ export function buildMemoryInjection(
 
   // 📌 pinned 기억 — 키워드 무관 항상 주입(relevance gate bypass · Letta pinned block /
   //    claude-code MEMORY.md tier 동형). priority 높은 순. core/safety/ref-location 사실용.
-  const pinnedMems = listMemories({}, root).filter(m => m.pinned).sort((a, b) => b.priority - a.priority);
+  const pinnedMems = listMemories({}, root).filter(m => m.pinned && m.contextCard?.status !== 'retired').sort((a, b) => b.priority - a.priority);
   const pinnedParts: string[] = [];
   for (const e of pinnedMems) {
     const chunk = pinnedChunk(e);
@@ -678,7 +711,7 @@ export async function buildMemoryInjectionLLM(
   }
 
   // pinned 항상주입(키워드/판정 무관).
-  const pinnedMems = listMemories({}, root).filter((m) => m.pinned).sort((a, b) => b.priority - a.priority);
+  const pinnedMems = listMemories({}, root).filter((m) => m.pinned && m.contextCard?.status !== 'retired').sort((a, b) => b.priority - a.priority);
   const pinnedParts: string[] = [];
   for (const e of pinnedMems) {
     const chunk = pinnedChunk(e);
@@ -693,7 +726,7 @@ export async function buildMemoryInjectionLLM(
   let judged: MemoryEntry[] = [];
   if (!lowContext) {
     const candidates = listMemories({}, root)
-      .filter((m) => !m.pinned && !injected.includes(m.id))
+      .filter((m) => !m.pinned && m.contextCard?.status !== 'retired' && !injected.includes(m.id))
       .slice(0, opts.maxCandidates ?? 60);
     if (candidates.length > 0) {
       try {

package/src/nexus/api/card-followup-route.ts

@@ -0,0 +1,118 @@
+import { randomUUID } from 'node:crypto';
+import { chmodSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { isAbsolute, join, relative, sep } from 'node:path';
+import { defaultAttachmentBaseDir, resolveAttachmentPath } from '../../boot/attachment-store.js';
+import { detectCard, NotACardError, runCardFollowup } from '../../card-followup/core.js';
+import { debug } from '../../debug/log.js';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { localOcrText } from '../../telegram-card-followup.js';
+import { jsonResponse } from './json-response.js';
+
+export const CARD_FOLLOWUP_PATH = '/v1/card-followup';
+
+type CardJob = { id: string; status: 'judging' | 'running' | 'done' | 'not-card' | 'failed'; updatedAt: number; replies?: [string, string, string]; error?: string };
+type CardDeps = {
+  rootDir?: string;
+  resolveAttachment?: typeof resolveAttachmentPath;
+  ocr?: typeof localOcrText;
+  detect?: typeof detectCard;
+  run?: typeof runCardFollowup;
+  now?: () => number;
+};
+
+function withinAttachmentStore(path: string): boolean {
+  try {
+    const relativePath = relative(realpathSync(defaultAttachmentBaseDir()), realpathSync(path));
+    return relativePath !== '' && relativePath !== '..' && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
+  } catch { return false; }
+}
+
+/** The in-memory set identifies only work launched by this daemon; disk is the pollable ledger. */
+export function createCardFollowupJobs({
+  rootDir = effectiveInstanceRoot(),
+  resolveAttachment = resolveAttachmentPath,
+  ocr = localOcrText,
+  detect = detectCard,
+  run = runCardFollowup,
+  now = Date.now,
+}: CardDeps = {}) {
+  const base = join(rootDir, 'graph-runs', 'card-followup');
+  const active = new Set<string>();
+  const unavailable = new Set<string>();
+  const file = (id: string) => join(base, `${id}.pwa.json`);
+  const save = (job: CardJob) => {
+    mkdirSync(base, { recursive: true, mode: 0o700 });
+    chmodSync(base, 0o700);
+    writeFileSync(file(job.id), JSON.stringify(job), { mode: 0o600 });
+    chmodSync(file(job.id), 0o600);
+  };
+
+  return {
+    async post(req: Request): Promise<Response> {
+      let body: unknown;
+      try { body = await req.json(); } catch { body = null; }
+      if (!body || typeof body !== 'object' || Array.isArray(body)) return jsonResponse({ error: 'bad_request' }, 400);
+      const { attachmentId, context } = body as Record<string, unknown>;
+      if (context !== undefined && typeof context !== 'string') return jsonResponse({ error: 'bad_request' }, 400);
+      const imagePath = typeof attachmentId === 'string' ? resolveAttachment(attachmentId) : null;
+      if (!imagePath || (resolveAttachment === resolveAttachmentPath && !withinAttachmentStore(imagePath))) {
+        return jsonResponse({ error: 'attachment-not-found' }, 400);
+      }
+
+      const id = randomUUID();
+      const update = (status: CardJob['status'], fields: Partial<Pick<CardJob, 'replies' | 'error'>> = {}) =>
+        save({ id, status, updatedAt: now(), ...fields });
+      update('judging');
+      active.add(id);
+      debug.log('card-followup.pwa', 'started', { id });
+      // Start OCR on the next event-loop turn so the acceptance response precedes the work.
+      setTimeout(() => {
+        void (async () => {
+          try {
+            const ocrText = await ocr(imagePath);
+            if (detect({ ocrText }).decision !== 'card') {
+              update('not-card');
+              debug.log('card-followup.pwa', 'not-card', { id });
+              return;
+            }
+            update('running');
+            const result = await run({ imagePath, ocrText, rootDir, runId: id, ...(context === undefined ? {} : { context }) });
+            update('done', { replies: result.replies });
+            debug.log('card-followup.pwa', 'done', { id });
+          } catch (cause) {
+            const notCard = cause instanceof NotACardError;
+            // OCR·그래프 예외 문구엔 명함 원문이 섞일 수 있다 — 원장·응답엔 고정 코드만 싣는다(리뷰 must-fix).
+            try {
+              update(notCard ? 'not-card' : 'failed', notCard ? {} : { error: 'card-followup-failed' });
+              debug.log('card-followup.pwa', notCard ? 'not-card' : 'failed', { id });
+            } catch {
+              unavailable.add(id);
+              debug.log('card-followup.pwa', 'failed', { id });
+            }
+          } finally {
+            active.delete(id);
+          }
+        })().catch(() => {
+          unavailable.add(id);
+          active.delete(id);
+        });
+      });
+      return jsonResponse({ id }, 202);
+    },
+    get(id: string): Response {
+      if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)) return jsonResponse({ error: 'not-found' }, 404);
+      if (unavailable.has(id)) return jsonResponse({ id, status: 'failed', error: 'card-followup-failed' });
+      let job: CardJob;
+      try { job = JSON.parse(readFileSync(file(id), 'utf8')) as CardJob; }
+      catch { return jsonResponse({ error: 'not-found' }, 404); }
+      if (job.id !== id) return jsonResponse({ error: 'not-found' }, 404);
+      if ((job.status === 'judging' || job.status === 'running') && !active.has(id)) {
+        return jsonResponse({ id, status: 'failed', error: 'daemon-restarted' });
+      }
+      const { status, replies, error } = job;
+      return jsonResponse({ id, status, ...(replies ? { replies } : {}), ...(error ? { error } : {}) });
+    },
+  };
+}
+
+export type CardFollowupJobs = ReturnType<typeof createCardFollowupJobs>;

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/decisions-route.ts

@@ -0,0 +1,68 @@
+import { debug } from '../../debug/log.js';
+import { DecisionLedger, type DecisionEntry } from '../../decisions/decision-ledger.js';
+import { jsonResponse } from './json-response.js';
+
+export const DECISIONS_PATH = '/v1/decisions';
+
+export interface DecisionsRouteDeps {
+  authorize?: (request: Request) => boolean;
+  ledger?: Pick<DecisionLedger, 'list' | 'decide'>;
+}
+
+export async function handleDecisions(req: Request, deps: DecisionsRouteDeps = {}): Promise<Response> {
+  const pathname = new URL(req.url).pathname;
+  if (pathname !== DECISIONS_PATH && !/^\/v1\/decisions\/[^/]+\/decide$/.test(pathname)) return jsonResponse({ error: 'not-found' }, 404);
+  if (!deps.authorize?.(req)) {
+    debug.log('decisions.api', 'rejected', { reason: 'unauthorized' });
+    return jsonResponse({ error: 'unauthorized' }, 401);
+  }
+  const ledger = deps.ledger ?? new DecisionLedger();
+  if (pathname === DECISIONS_PATH) {
+    if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed' }, 405);
+    if (new URL(req.url).searchParams.get('status') !== 'open') {
+      debug.log('decisions.api', 'rejected', { reason: 'invalid-status' });
+      return jsonResponse({ error: 'bad_request' }, 400);
+    }
+    const decisions = ledger.list({ status: 'open' }).map(entry => ({
+      id: entry.id,
+      title: entry.title,
+      situation: entry.scqa.s.slice(0, 200),
+      options: entry.options.map(option => ({ id: option.key, label: option.label })),
+      recommendation: entry.recommendation,
+      raisedAt: entry.raisedAt,
+      dueAt: entry.dueAt,
+    }));
+    debug.log('decisions.api', 'listed', { count: decisions.length });
+    return jsonResponse({ decisions });
+  }
+  if (req.method !== 'POST') return jsonResponse({ error: 'method-not-allowed' }, 405);
+  let id: string;
+  try { id = decodeURIComponent(pathname.slice(DECISIONS_PATH.length + 1, -'/decide'.length)); }
+  catch {
+    debug.log('decisions.api', 'rejected', { reason: 'invalid-id' });
+    return jsonResponse({ error: 'not-found' }, 404);
+  }
+  let body: unknown;
+  try { body = await req.json(); } catch { body = null; }
+  if (!body || typeof body !== 'object' || Array.isArray(body)
+    || !('choice' in body) || typeof body.choice !== 'string' || !body.choice
+    || ('note' in body && body.note !== undefined && typeof body.note !== 'string')) {
+    debug.log('decisions.api', 'rejected', { id, reason: 'invalid-body' });
+    return jsonResponse({ error: 'bad_request' }, 400);
+  }
+  const { choice, note } = body as { choice: string; note?: string };
+  try {
+    const entry: DecisionEntry = ledger.decide(id, choice, { kind: 'human' }, note);
+    debug.log('decisions.api', 'decided', { id });
+    return jsonResponse(entry);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : '';
+    const status = message.startsWith('decision not found:') ? 404
+      : message.startsWith('decision already closed:') ? 409
+      : message.startsWith('option not found:') || message.startsWith('note ') ? 400 : 0;
+    if (!status) throw error;
+    const reason = status === 404 ? 'not-found' : status === 409 ? 'already-decided' : 'bad_request';
+    debug.log('decisions.api', 'rejected', { id, reason });
+    return jsonResponse({ error: reason }, status);
+  }
+}

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

@@ -22,6 +22,9 @@ import { spawnSync } from 'node:child_process';
 import { isAbsolute } from 'node:path';
 import { createProject, listProjects } from '../../project/project-store.js';
 import { handleOutputsGet, type OutputsDeps } from './outputs-route.js';
+import { DECISIONS_PATH, handleDecisions, type DecisionsRouteDeps } from './decisions-route.js';
+import { CARD_FOLLOWUP_PATH, createCardFollowupJobs, type CardFollowupJobs } from './card-followup-route.js';
+import { SKILL_EXEC_PATH, createSkillExecJobs, type SkillExecJobs } from './skill-exec-route.js';
 import { compareTokenConstTime } from '../../acp/transport/auth.js';
 import { ensureAuthToken } from '../../auth/acp-token.js';
 import type { NexusState } from '../state/state.js';
@@ -181,7 +184,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';
@@ -472,6 +477,9 @@ export interface NexusHttpServerOpts {
   /** Optional installer state root for isolated API consumers and tests. */
   pluginStateRoot?: string;
   outputs?: OutputsDeps;
+  decisions?: Pick<DecisionsRouteDeps, 'ledger'>;
+  cardFollowup?: CardFollowupJobs;
+  skillExec?: SkillExecJobs;
   execRequests?: ExecRequestRunner;
   seatRequests?: SeatRequestsDeps;
   consultRequests?: ConsultRequestsDeps;
@@ -480,6 +488,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;
@@ -852,6 +862,16 @@ function execRequestRunner(): ExecRequestRunner {
   return execRequestRunnerInstance;
 }
 
+let cardFollowupJobs: CardFollowupJobs | undefined;
+function defaultCardFollowupJobs(): CardFollowupJobs {
+  return cardFollowupJobs ??= createCardFollowupJobs();
+}
+
+let skillExecJobs: SkillExecJobs | undefined;
+function defaultSkillExecJobs(): SkillExecJobs {
+  return skillExecJobs ??= createSkillExecJobs();
+}
+
 export async function routeRequest(
   req: Request,
   opts: NexusHttpServerOpts,
@@ -1338,6 +1358,23 @@ export async function routeRequest(
     return method === 'GET' ? handleProjectsGet() : handleProjectsPost(req);
   }
 
+  // Polling must remain outside the non-GET dispatch below.
+  if (method === 'GET' && pathname.startsWith(`${SKILL_EXEC_PATH}/`) && !pathname.slice(SKILL_EXEC_PATH.length + 1).includes('/')) {
+    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return (opts.skillExec ?? defaultSkillExecJobs()).get(pathname.slice(SKILL_EXEC_PATH.length + 1));
+  }
+  if (method === 'GET' && pathname.startsWith(`${CARD_FOLLOWUP_PATH}/`) && !pathname.slice(CARD_FOLLOWUP_PATH.length + 1).includes('/')) {
+    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return (opts.cardFollowup ?? defaultCardFollowupJobs()).get(pathname.slice(CARD_FOLLOWUP_PATH.length + 1));
+  }
+
+  if (method === 'GET' && pathname === DECISIONS_PATH) {
+    return handleDecisions(req, {
+      authorize: request => !!opts.metaApi && checkAuth(request, opts.metaApi),
+      ...opts.decisions,
+    });
+  }
+
   if (method === 'GET' && pathname === '/v1/outputs') {
     if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
     return handleOutputsGet(req, opts.outputs);
@@ -1371,6 +1408,20 @@ export async function routeRequest(
   // Templates POST handled here too (PR κ).
   // Config / secrets PUT/POST/DELETE here too (PR μ).
   if (method !== 'GET') {
+    if (method === 'POST' && pathname === SKILL_EXEC_PATH) {
+      if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+      return (opts.skillExec ?? defaultSkillExecJobs()).post(req);
+    }
+    if (method === 'POST' && pathname === CARD_FOLLOWUP_PATH) {
+      if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+      return (opts.cardFollowup ?? defaultCardFollowupJobs()).post(req);
+    }
+    if (method === 'POST' && /^\/v1\/decisions\/[^/]+\/decide$/.test(pathname)) {
+      return handleDecisions(req, {
+        authorize: request => !!opts.metaApi && checkAuth(request, opts.metaApi),
+        ...opts.decisions,
+      });
+    }
     if (method === 'POST' && pathname === '/v1/plugins/install') {
       if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
       return handlePluginsInstall(req, opts.metaApi, opts.pluginStateRoot);
@@ -2832,7 +2883,19 @@ export async function routeRequest(
   }
   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') ?? '' } : {}) }));
+    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 });
   }
   // §6.3 (2026-05-09) — context URL fetch (showroom).
   // POST /v1/context/fetch-url