elanous 0.2.12 → 0.2.14

package/src/dashboard/slash-runtime/dashboard-handlers.ts

@@ -273,6 +273,7 @@
 // of circular dependency on dashboard/index.ts.
 
 import { tuiNowSlash } from '../../context-bus/context-now-surfaces.js';
+import { handleTuiChatPersona, type TuiChatPersonaSelection } from './chat-persona.js';
 import { createWishCard } from '../../intake-plane/wish-card.js';
 import { CardStore } from '../../task-cards/card-store.js';
 import type { ContextNowDeps } from '../../context-bus/context-now.js';
@@ -390,6 +391,8 @@ import { resolveTerminalMoveDestination } from '../../terminal-matrix/mobility.j
 import { loadPersistedSessions } from '../../terminal/session-persistence.js';
 import { dispatchTerminalModalObserve } from '../../skills/tools/terminal-modal.js';
 import { SlashCommandRegistry } from './registry.js';
+import { cronSecondDueAt, filterLoopRows, formatLoopsTable, localLoopRows, type LoopsTableRow } from './loops-table.js';
+import { loopCronVerdict } from '../../loops/verdict.js';
 import { executeImmediateDashboardSlash } from '../input/slash-executor.js';
 import {
   buildContextSlashCommand,
@@ -1029,6 +1032,7 @@ export interface DashboardSlashContext {
   /** Currently-attached session id (TUI's pointer to a JSONL on disk). */
   getAttachedSessionId(): string | null;
   setAttachedSessionId(id: string | null): void;
+  chatPersona?: { sessionId(): string; selection: TuiChatPersonaSelection; newConversation?(): void };
   /** Telegram chat id paired with the attached session, when handed off. */
   getAttachedChatId(): number | null;
   setAttachedChatId(id: number | null): void;
@@ -1038,6 +1042,9 @@ export interface DashboardSlashContext {
     send: (cfg: ReturnType<typeof getUserConfig>, text: string) => Promise<boolean>;
   };
 
+  /** Test seam for the local read-only loop and cron registry. */
+  loopsLocalRows?: (now: Date) => LoopsTableRow[];
+
   sessionSlash: {
     /** opts.remote — when the dashboard is attached to a remote daemon. */
     remoteDaemon(): { url: string; token: string | undefined } | null;
@@ -1364,6 +1371,28 @@ function emitReplyToChat(ctx: Pick<DashboardSlashContext, 'pushChatLine'>, line:
   ctx.pushChatLine(line);
 }
 
+async function fetchLoopsDaemonJson<T>(url: string, headers: Record<string, string>): Promise<T> {
+  const controller = new AbortController();
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      (async () => {
+        const response = await fetch(url, { headers, signal: controller.signal });
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        return await response.json() as T;
+      })(),
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => {
+          controller.abort();
+          reject(new Error('request timed out'));
+        }, 1_000);
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
 export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn> {
   const registry = new SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn>();
 
@@ -1371,6 +1400,61 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
     for (const line of tuiNowSlash(args, nowDeps)) ctx.pushChatLine(line);
   });
 
+  registry.register('loops', async (args, ctx) => {
+    if (args.length > 1) {
+      ctx.pushChatLine(ctx.warning('  usage: /loops [owner]'));
+      return;
+    }
+    const now = new Date(Date.now());
+    let rows: LoopsTableRow[] = [];
+    const remote = ctx.sessionSlash.remoteDaemon();
+    if (remote) {
+      const base = deriveDaemonHttpBase(remote.url);
+      if (base) {
+        try {
+          const headers: Record<string, string> = remote.token ? { authorization: `Bearer ${remote.token}` } : {};
+          const body = await fetchLoopsDaemonJson<{ schedules?: Array<{ name: string; domain?: string | null; runVia?: string | null;
+            source: string; cron?: string | null; state: string; lastRun?: { at: string; status: string | null; exit: number | null } | null;
+            intervalMs?: number | null }> }>(`${base}/v1/schedules?includeOff=1`, headers);
+          rows = (body.schedules ?? []).map(schedule => ({
+            layer: 'daemon cron', name: schedule.name, owner: schedule.domain ?? '—', mode: schedule.runVia ?? schedule.source,
+            lastRun: schedule.lastRun?.at ?? null,
+            verdict: loopCronVerdict({ enabled: schedule.state !== 'off', lastRunAt: schedule.lastRun?.at ?? null,
+              lastStatus: schedule.lastRun?.exit != null && schedule.lastRun.exit !== 0 ? 'failed' : schedule.lastRun?.status ?? null,
+              intervalMs: schedule.intervalMs ?? null,
+              secondDueAt: cronSecondDueAt(schedule.cron ?? null, schedule.lastRun?.at ?? null) }, now.getTime()),
+          }));
+        } catch (err) {
+          ctx.pushChatLine(ctx.warning(`  daemon cron unavailable: ${err instanceof Error ? err.message : String(err)}`));
+        }
+        try {
+          const headers: Record<string, string> = remote.token ? { authorization: `Bearer ${remote.token}` } : {};
+          const body = await fetchLoopsDaemonJson<{ loops?: { loops?: Array<{
+            name: string; label: string; armed: boolean | null; category?: string;
+            last: { at: string; status: string } | null;
+          }> } | null }>(`${base}/v1/dashboard/loops`, headers);
+          // dashboardLoops returns LoopStatus (no owner field). Its category is
+          // exec/reflect, not an owner; keep ownership unknown rather than
+          // attributing every daemon loop to a guessed domain.
+          rows.push(...(body.loops?.loops ?? []).map(loop => ({
+            layer: 'daemon loop', name: loop.label || loop.name, owner: '—', mode: loop.category ?? 'loop',
+            lastRun: loop.last?.at ?? null,
+            verdict: loopCronVerdict({ enabled: loop.armed !== false, lastRunAt: loop.last?.at ?? null,
+              lastStatus: loop.last?.status ?? null, intervalMs: null }, now.getTime()),
+          })));
+        } catch (err) {
+          ctx.pushChatLine(ctx.warning(`  daemon loops unavailable: ${err instanceof Error ? err.message : String(err)}`));
+        }
+      }
+    }
+    try { rows.push(...(ctx.loopsLocalRows ?? localLoopRows)(now)); }
+    catch (err) { ctx.pushChatLine(ctx.warning(`  local loops unavailable: ${err instanceof Error ? err.message : String(err)}`)); }
+    const filtered = filterLoopRows(rows, args[0]);
+    for (const line of formatLoopsTable(filtered, text => ctx.error(text))) ctx.pushChatLine(`  ${line}`);
+    if (!filtered.length) ctx.pushChatLine(ctx.muted('  No loops or cron jobs found.'));
+    ctx.setChatScrollOffset(-1);
+  });
+
   registry.register('wish', (args, ctx) => {
     const text = args.join(' ').trim();
     if (!text) {
@@ -1427,6 +1511,16 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
     }
   });
 
+  registry.register('persona', async (args, ctx) => {
+    if (!ctx.chatPersona) {
+      ctx.pushChatLine(ctx.warning('  페르소나를 사용할 수 없습니다'));
+    } else {
+      const text = await handleTuiChatPersona(args, ctx.chatPersona.sessionId(), ctx.chatPersona.selection);
+      for (const line of text.split('\n')) ctx.pushChatLine(ctx.muted(`  ${line}`));
+    }
+    ctx.setChatScrollOffset(-1);
+  });
+
   registry.register('directive', async (args, ctx) => {
     try {
       const { addDirective } = await import('../../steward/directive.js');
@@ -4042,6 +4136,7 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
       const prev = attached;
       ctx.setAttachedSessionId(null);
       ctx.setAttachedChatId(null);
+      ctx.chatPersona?.newConversation?.();
       const chatHistory = ctx.compactSlash.chatHistory;
       const sysFromDash = chatHistory.find(m => m.role === 'system');
       chatHistory.length = 0;
@@ -4151,6 +4246,10 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
           sessionAppendMessage(meta.id, { role: m.role, content, ts: nowTs });
         }
         sessionAttachTelegram(meta.id, chatTarget);
+        if (ctx.chatPersona) {
+          const selected = ctx.chatPersona.selection.get(ctx.chatPersona.sessionId());
+          if (selected) ctx.chatPersona.selection.set(meta.id, selected);
+        }
         ctx.setAttachedSessionId(meta.id);
         ctx.setAttachedChatId(chatTarget);
         ctx.chatLines.push(ctx.success(`  ✓ attached session ${meta.id.slice(0, 8)} → chat ${chatTarget}  (${chatHistory.length} turns mirrored)`));

package/src/dashboard/slash-runtime/loops-table.ts

@@ -0,0 +1,77 @@
+import { Database } from 'bun:sqlite';
+import { existsSync } from 'node:fs';
+import { listLoops, type LoopEntry } from '../../loops/registry.js';
+import { loopCronVerdict, type LoopCronVerdict } from '../../loops/verdict.js';
+import { listSchedules, schedulesDbPath, type ScheduleRow } from '../../domains/schedule-registry.js';
+import { nextRuns } from '../../domains/schedule-state.js';
+
+export interface LoopsTableRow {
+  layer: string;
+  name: string;
+  owner: string;
+  mode: string;
+  lastRun: string | null;
+  verdict: LoopCronVerdict;
+}
+
+/** Read the already-inventoried local registry without opening/migrating a writable store. */
+export function localLoopRows(now: Date): LoopsTableRow[] {
+  let schedules: ScheduleRow[] = [];
+  if (existsSync(schedulesDbPath())) {
+    const db = new Database(schedulesDbPath(), { readonly: true });
+    try { schedules = listSchedules(db); } finally { db.close(); }
+  }
+  const loops = listLoops({ schedules, now });
+  const rows: LoopsTableRow[] = loops.map(loop => graphLoopRow(loop, schedules, now));
+  const graphJobIds = new Set(loops.flatMap(loop => loop.jobs.map(job => job.id)));
+  for (const schedule of schedules) {
+    if (graphJobIds.has(schedule.id)) continue;
+    rows.push(scheduleRow(schedule, 'local cron', now));
+  }
+  return rows;
+}
+
+export function cronSecondDueAt(cron: string | null, lastRun: string | null): string | null {
+  if (!cron || !lastRun) return null;
+  const last = new Date(lastRun);
+  if (!Number.isFinite(last.getTime())) return null;
+  return nextRuns(cron, last, 2)[1] ?? null;
+}
+
+export function graphLoopRow(loop: LoopEntry, schedules: ScheduleRow[], now: Date): LoopsTableRow {
+  const active = loop.jobs.map(job => schedules.find(row => row.id === job.id)).filter((r): r is ScheduleRow => !!r);
+  const cron = loop.trigger.cron ?? active[0]?.cron ?? null;
+  const interval = active.find(r => r.interval_ms && r.interval_ms > 0)?.interval_ms ?? null;
+  const lastRun = loop.lastRun?.at ?? active.map(r => r.last_run).filter((at): at is string => !!at).sort().at(-1) ?? null;
+  const status = loop.lastRun?.status ?? active.find(r => r.last_run === lastRun)?.last_status ?? null;
+  return {
+    layer: 'local loop', name: loop.title, owner: loop.owner ?? '—', mode: loop.mode ?? (loop.trigger.cron ? 'cron' : 'event'), lastRun,
+    verdict: loopCronVerdict({ enabled: loop.enabled, lastRunAt: lastRun, lastStatus: status, intervalMs: interval,
+      secondDueAt: cronSecondDueAt(cron, lastRun) }, now.getTime()),
+  };
+}
+
+export function scheduleRow(row: ScheduleRow, layer: string, now: Date): LoopsTableRow {
+  return {
+    layer, name: row.name, owner: row.domain ?? '—', mode: row.run_via || row.source,
+    lastRun: row.last_run,
+    verdict: loopCronVerdict({ enabled: !!row.enabled && row.disabled_reason !== 'vanished', lastRunAt: row.last_run,
+      lastStatus: row.last_exit !== null && row.last_exit !== undefined && row.last_exit !== 0 ? 'failed' : row.last_status ?? null,
+      intervalMs: row.interval_ms, secondDueAt: cronSecondDueAt(row.cron, row.last_run) }, now.getTime()),
+  };
+}
+
+export function filterLoopRows(rows: LoopsTableRow[], owner?: string): LoopsTableRow[] {
+  return owner ? rows.filter(row => row.owner !== '—' && row.owner.toLowerCase() === owner.toLowerCase()) : rows;
+}
+
+export function formatLoopsTable(rows: LoopsTableRow[], verdictColor: (text: string) => string): string[] {
+  const columns = ['LAYER', 'NAME', 'OWNER', 'MODE', 'LAST RUN', 'VERDICT'];
+  const data = rows.map(r => [r.layer, r.name, r.owner, r.mode, r.lastRun ?? '—', r.verdict]);
+  const widths = columns.map((col, i) => Math.max(col.length, ...data.map(cells => cells[i]!.length)));
+  const format = (cells: string[]) => cells.map((cell, i) => cell.padEnd(widths[i]!)).join('  ');
+  return [format(columns), ...rows.map((row, i) => {
+    const cells = data[i]!;
+    return `${format(cells.slice(0, 5))}  ${row.verdict === 'late' || row.verdict === 'failed' ? verdictColor(cells[5]!) : cells[5]}`;
+  })];
+}

package/src/decisions/decision-cards.ts

@@ -35,21 +35,27 @@ export function isIrreversible(entry: Pick<DecisionEntry, 'category'>): boolean
 
 const kst = (at: string) => new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(at));
 
-/** The card body: title, SCQA in four short lines, options with consequences, recommendation, deadline. */
+/** The card opens with a short pitch; the full question and choice buttons remain below it. */
 export function renderCardText(e: DecisionEntry, extra: { note?: string; confirm?: string } = {}): string {
+  const recommendedKey = 'option' in e.recommendation ? e.recommendation.option : undefined;
+  const recommended = e.options.find(o => o.key === recommendedKey);
+  const alternative = e.options.find(o => o.key === e.alternative);
   const lines = [
     `🗳 결정 요청 ${e.id}${isIrreversible(e) ? ' · ⚠️ 되돌릴 수 없음' : ''}`,
     `«${e.title}» · 올린 자리: ${e.raisedBy.agent}${e.raisedBy.track ? `(${e.raisedBy.track})` : ''}`,
     '',
-    `상황: ${e.scqa.s}`,
-    `문제: ${e.scqa.c}`,
+    `S: ${e.scqa.s.replace(/\s+/g, ' ')}`,
+    `C: ${e.scqa.c.replace(/\s+/g, ' ')}`,
+    `Q: ${(e.scqa.q ?? '(비움)').replace(/\s+/g, ' ')}`,
+    `A: ${(e.scqa.a ?? '(비움)').replace(/\s+/g, ' ')}`,
+    'skipped' in e.recommendation ? `권고 없음: ${e.recommendation.reason}` : `권고: ${recommended?.label ?? e.recommendation.option} — ${e.recommendation.why}`,
+    ...(alternative ? [`대안: ${alternative.label} — ${alternative.consequence}`] : []),
+    e.crossCheck?.length ? `교차 확인: ${e.crossCheck.map(check => `${check.seat} ✓ ${check.note.replace(/\s+/g, ' ')}`).join(' · ')}` : `교차 확인 없음(${e.crossCheckSkipped ?? '미기재'})`,
+    ...(e.dissent ? [`이견: ${e.dissent}`] : []),
+    ...(e.dueAt ? [`기한: ${kst(e.dueAt)} KST`] : []),
     ...(e.pendingQuestion ? ['', `대기 질문 전문:\n${e.pendingQuestion}`] : []),
-    ...(e.scqa.q ? [`질문: ${e.scqa.q}`] : []),
-    ...(e.scqa.a ? [`제안: ${e.scqa.a}`] : []),
     '',
     ...e.options.map((o) => `${o.key.toUpperCase()}) ${o.label} — ${o.consequence}`),
-    'skipped' in e.recommendation ? `권고 없음: ${e.recommendation.reason}` : `권고: ${e.recommendation.option.toUpperCase()} — ${e.recommendation.why}`,
-    ...(e.dueAt ? [`기한: ${kst(e.dueAt)}`] : []),
     ...(extra.note ? ['', `📝 메모: ${extra.note}`] : []),
   ];
   if (extra.confirm) {

package/src/decisions/decision-ledger.ts

@@ -22,12 +22,24 @@ export interface DecisionEntry {
   pendingQuestion?: string;
   /** DEC-TG — optional deadline (UTC). Cards remind the owner two hours before it. */
   dueAt?: string;
+  crossCheck?: Array<{ seat: string; at: string; note: string }>;
+  crossCheckSkipped?: string;
+  alternative?: string;
+  dissent?: string;
   decidedAt?: string; decidedBy?: DecisionActor; choice?: string; note?: string; versionAtDecision?: Versions;
   withdrawnAt?: string; withdrawReason?: string;
   history: Array<{ type: 'raised' | 'options-added' | 'decided' | 'withdrawn'; at?: string; by: string; version?: Versions; choice?: string; reason?: string }>;
 }
-export type RaiseInput = Pick<DecisionEntry, 'title' | 'category' | 'scqa' | 'options' | 'recommendation' | 'raisedBy' | 'refs' | 'dueAt' | 'resume' | 'pendingQuestion'> & { raisedAt?: string };
-type Event = { type: 'raised'; entry: DecisionEntry } | { type: 'options-added'; id: string; at: string; options: DecisionOption[]; by: string } | { type: 'decided'; id: string; at?: string; by: DecisionActor; choice?: string; version?: Versions; note?: string } | { type: 'withdrawn'; id: string; at: string; reason: string; version: Versions };
+export type RaiseInput = Pick<DecisionEntry, 'title' | 'category' | 'scqa' | 'options' | 'recommendation' | 'raisedBy' | 'refs' | 'dueAt' | 'resume' | 'pendingQuestion' | 'crossCheck' | 'crossCheckSkipped' | 'alternative' | 'dissent'> & { raisedAt?: string };
+export type Seat = 'OP' | 'MK' | 'TC' | 'UX';
+export interface SeatDecisionRecord {
+  id: string; title: string; decision: string; seat: Seat; delegation: string;
+  reporting: 'posthoc'; recordedAt: string;
+  /** Present only when the actual decision time is known. */
+  decidedAt?: string; versionAtDecision?: Versions; refs?: string[];
+}
+export type SeatDecisionInput = Pick<SeatDecisionRecord, 'title' | 'decision' | 'seat' | 'delegation' | 'refs'> & { decidedAt?: string };
+type Event = { type: 'raised'; entry: DecisionEntry } | { type: 'seat-recorded'; entry: SeatDecisionRecord } | { type: 'options-added'; id: string; at: string; options: DecisionOption[]; by: string } | { type: 'decided'; id: string; at?: string; by: DecisionActor; choice?: string; version?: Versions; note?: string } | { type: 'withdrawn'; id: string; at: string; reason: string; version: Versions };
 export interface DecisionLedgerOptions extends VersionOptions { stateDir?: string; now?: () => Date; resolveVersion?: (at: string) => Versions; writeAnswer?: typeof writePendingQuestionAnswer }
 
 /** null = the decision resumes no run; otherwise whether the answer file was written (or already matched). */
@@ -89,13 +101,27 @@ function validate(input: RaiseInput, historical = false): RaiseInput {
     ? { skipped: true as const, reason: safe(single(input.recommendation.reason, 'skip reason')) }
     : { option: input.recommendation.option, why: safe(single(input.recommendation.why, 'recommendation why')) };
   if ('option' in recommendation && !options.some(o => o.key === recommendation.option)) throw new Error('recommended option not found');
+  const alternative = input.alternative === undefined ? undefined : single(input.alternative, 'alternative');
+  if (alternative && !options.some(o => o.key === alternative)) throw new Error('alternative option not found');
+  if (alternative && 'option' in recommendation && alternative === recommendation.option) throw new Error('alternative must differ from recommendation');
+  if (input.crossCheck?.length && input.crossCheckSkipped !== undefined) throw new Error('cross-check and skipped reason cannot coexist');
+  if (input.crossCheck !== undefined && !Array.isArray(input.crossCheck)) throw new Error('cross-check must be a list');
+  const crossCheck = input.crossCheck?.map(check => {
+    const seat = single(check.seat, 'cross-check seat');
+    if (!['OP', 'MK', 'TC', 'UX'].includes(seat)) throw new Error('invalid cross-check seat');
+    return { seat, at: utc(check.at), note: safe(single(check.note, 'cross-check note')) };
+  });
+  const crossCheckSkipped = input.crossCheckSkipped === undefined ? undefined : safe(single(input.crossCheckSkipped, 'cross-check skipped reason'));
+  const dissent = input.dissent === undefined ? undefined : safe(single(input.dissent, 'dissent'));
   if (input.resume && !/^(?:auq:[0-9a-z]+:[0-9a-z]{5}|execution:[A-Za-z0-9_-]+:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?![\s\S])/.test(input.resume.questionId)) throw new Error('invalid resume questionId');
   const resume = input.resume ? { questionId: input.resume.questionId,
     ...(input.resume.runId === undefined ? {} : { runId: single(input.resume.runId, 'resume runId') }) } : undefined;
   if (input.pendingQuestion !== undefined) required(input.pendingQuestion, 'pending question');
   return { ...input, title, scqa: { s, c, ...(q ? { q } : {}), ...(a ? { a } : {}) }, options, recommendation,
     ...(input.pendingQuestion === undefined ? {} : { pendingQuestion: safe(input.pendingQuestion) }),
-    ...(resume ? { resume } : {}),
+    ...(resume ? { resume } : {}), ...(crossCheck ? { crossCheck } : {}),
+    ...(crossCheckSkipped !== undefined ? { crossCheckSkipped } : {}),
+    ...(alternative !== undefined ? { alternative } : {}), ...(dissent !== undefined ? { dissent } : {}),
     raisedBy: { agent: safe(single(input.raisedBy.agent, 'agent')), ...(input.raisedBy.track ? { track: input.raisedBy.track } : {}), ...(input.raisedBy.session ? { session: safe(single(input.raisedBy.session, 'session')) } : {}) },
     ...(input.refs ? { refs: input.refs.map(r => safe(single(r, 'ref'))) } : {}),
     ...(input.dueAt ? { dueAt: utc(input.dueAt) } : {}) };
@@ -178,6 +204,7 @@ export class DecisionLedger {
     if (filters.category && !CATEGORIES.includes(filters.category)) throw new Error('invalid category');
     const map = new Map<string, DecisionEntry>();
     for (const event of this.events()) {
+      if (event.type === 'seat-recorded') continue;
       if (event.type === 'raised') {
         if (map.has(event.entry.id)) throw new Error(`duplicate decision: ${event.entry.id}`);
         map.set(event.entry.id, event.entry);
@@ -203,25 +230,63 @@ export class DecisionLedger {
       && (!filters.decidedBy || e.decidedBy?.kind === filters.decidedBy)
       && (!filters.category || e.category === filters.category)).sort((a, b) => (b.raisedAt ?? b.importedAt ?? '').localeCompare(a.raisedAt ?? a.importedAt ?? '') || a.id.localeCompare(b.id));
   }
-  show(id: string): DecisionEntry { const entry = this.list({ status: 'all' }).find(e => e.id === id); if (!entry) throw new Error(`decision not found: ${id}`); return entry; }
-  raise(input: RaiseInput): DecisionEntry {
-    const clean = validate(input);
+  /** Delegated decisions are already made: they share the append-only ledger, never the owner's open-card state machine. */
+  recordSeatDecision(input: SeatDecisionInput): SeatDecisionRecord {
+    const seat = input.seat;
+    if (!['OP', 'MK', 'TC', 'UX'].includes(seat)) throw new Error('invalid seat');
+    const title = safe(single(input.title, 'title'));
+    const decision = safe(single(input.decision, 'decision'));
+    const delegation = safe(single(input.delegation, 'delegation'));
+    const refs = input.refs?.map(ref => safe(single(ref, 'ref')));
+    const decidedAt = input.decidedAt === undefined ? undefined : utc(input.decidedAt);
     return this.locked(() => {
-      const at = utc(clean.raisedAt ?? this.now().toISOString());
-      const day = at.slice(0, 10).replaceAll('-', '');
-      const prefix = `D-${day}-`;
-      let next = 1;
-      for (const entry of this.list({ status: 'all' })) {
-        if (entry.id.startsWith(prefix)) next = Math.max(next, Number(entry.id.slice(prefix.length)) + 1);
-      }
-      const id = `${prefix}${String(next).padStart(2, '0')}`;
-      const version = this.version(at);
-      const entry: DecisionEntry = { ...clean, id, raisedAt: at, version, status: 'open', history: [{ type: 'raised', at, by: clean.raisedBy.agent, version }] };
-      this.append({ type: 'raised', entry });
-      debug.log('decisions', 'raised', { id, category: entry.category, by: entry.raisedBy.agent });
+      const existing = this.seatReport();
+      if (refs?.some(ref => existing.some(entry => entry.seat === seat && entry.title === title && entry.decision === decision && entry.refs?.includes(ref)))) throw new Error('seat decision source already recorded');
+      const recordedAt = utc(this.now().toISOString());
+      const prefix = `SD-${recordedAt.slice(0, 10).replaceAll('-', '')}-`;
+      const next = existing.reduce((n, entry) => entry.id.startsWith(prefix) ? Math.max(n, Number(entry.id.slice(prefix.length)) + 1) : n, 1);
+      const entry: SeatDecisionRecord = { id: `${prefix}${String(next).padStart(2, '0')}`, title, decision, seat, delegation,
+        reporting: 'posthoc', recordedAt, ...(decidedAt ? { decidedAt, versionAtDecision: this.version(decidedAt) } : {}), ...(refs?.length ? { refs } : {}) };
+      this.append({ type: 'seat-recorded', entry });
+      debug.log('decisions', 'seat-recorded', { id: entry.id, seat });
       return entry;
     });
   }
+  seatReport(filters: { since?: string; seat?: Seat } = {}): SeatDecisionRecord[] {
+    const since = filters.since === undefined ? undefined : utc(filters.since);
+    if (filters.seat && !['OP', 'MK', 'TC', 'UX'].includes(filters.seat)) throw new Error('invalid seat');
+    return this.events().filter((event): event is Extract<Event, { type: 'seat-recorded' }> => event.type === 'seat-recorded')
+      .map(event => event.entry)
+      .filter(entry => (!since || (entry.recordedAt ?? entry.decidedAt ?? '') >= since) && (!filters.seat || entry.seat === filters.seat))
+      .sort((a, b) => (b.recordedAt ?? b.decidedAt ?? '').localeCompare(a.recordedAt ?? a.decidedAt ?? '') || a.id.localeCompare(b.id));
+  }
+  show(id: string): DecisionEntry { const entry = this.list({ status: 'all' }).find(e => e.id === id); if (!entry) throw new Error(`decision not found: ${id}`); return entry; }
+  raise(input: RaiseInput): DecisionEntry {
+    const clean = validate(input);
+    return this.locked(() => this.raiseLocked(clean));
+  }
+  /** Reuse a card with the same source reference, including across competing raisers. */
+  raiseOnce(input: RaiseInput, ref: string): DecisionEntry {
+    const clean = validate(input);
+    if (!clean.refs?.includes(ref)) throw new Error('decision source reference required');
+    return this.locked(() => this.list({ status: 'all' }).find(entry => entry.refs?.includes(ref)) ?? this.raiseLocked(clean));
+  }
+  private raiseLocked(clean: RaiseInput): DecisionEntry {
+    const at = utc(clean.raisedAt ?? this.now().toISOString());
+    const day = at.slice(0, 10).replaceAll('-', '');
+    const prefix = `D-${day}-`;
+    let next = 1;
+    for (const entry of this.list({ status: 'all' })) {
+      if (entry.id.startsWith(prefix)) next = Math.max(next, Number(entry.id.slice(prefix.length)) + 1);
+    }
+    const id = `${prefix}${String(next).padStart(2, '0')}`;
+    const version = this.version(at);
+    const entry: DecisionEntry = { ...clean, id, raisedAt: at, version, status: 'open', history: [{ type: 'raised', at, by: clean.raisedBy.agent, version }] };
+    this.append({ type: 'raised', entry });
+    debug.log('decisions', 'raised', { id, category: entry.category, by: entry.raisedBy.agent });
+    debug.log('decisions', 'raised-crosscheck', { id, seats: entry.crossCheck?.length ?? 0, skipped: entry.crossCheckSkipped ?? null });
+    return entry;
+  }
   /** Record the decision and say whether its answer reached the waiting run (null = the decision resumes nothing). */
   decideWithDelivery(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery } {
     return this.decideLocked(id, choice, by, note, decidedAt);

package/src/discord/sprint21-runtime.ts

@@ -22,6 +22,9 @@
 
 import { debug } from '../debug/log.js';
 import { botAudienceFor, gateDiscordSchemas } from '../maturity/bot-command-maturity.js';
+import { buildBotSlashCatalog } from '../maturity/bot-slash-catalog.js';
+import { FEATURE_MATURITY } from '../maturity/feature-maturity.js';
+import { SLASH_COMMANDS } from '../chat/index.js';
 import type { DiscordBot } from '../discord.js';
 import {
   loadLayeredPersonaDirs,
@@ -195,6 +198,19 @@ export async function wireSprint21Runtime(opts: WireSprint21Opts): Promise<Sprin
   router.bind(statusCommand);
   router.bind(pollCommand);
   for (const command of botCommands) router.bind(command);
+  const catalog = buildBotSlashCatalog({
+    surface: 'discord', coreCommands: SLASH_COMMANDS, maturity: FEATURE_MATURITY,
+    handledCommands: router.schemas(),
+  });
+  for (const entry of catalog.commands) {
+    if (entry.supported) continue;
+    const { name, description } = entry;
+    router.bind({ schema: { name, description }, handler: async () => ({
+      type: RESPONSE_CHANNEL_MESSAGE_WITH_SOURCE,
+      content: catalog.unsupportedReply(entry.name)!,
+      ephemeral: true,
+    }) });
+  }
 
   // 5. Wire bot callbacks — INTERACTION_CREATE + reactions
   // (Bot must be created with onInteraction/onReaction in opts;

package/src/discord-self-message.ts

@@ -64,6 +64,8 @@ import { getUserConfig } from './user-config.js';
 import { detectCard, runCardFollowup, NotACardError } from './card-followup/core.js';
 import { localOcrText } from './telegram-card-followup.js';
 import type { runGraph } from './graph-runner/runner.js';
+import { readSlashContextNow, renderTelegramNow } from './context-bus/context-now-surfaces.js';
+import type { ContextNowDeps } from './context-bus/context-now.js';
 
 const SLASH_FOCUS_TURNS_DEFAULT = 8;
 
@@ -139,6 +141,7 @@ export interface DiscordSelfMessageDeps {
   questionChannelFor?: (channelId: string) => import('./hitl/question.js').QuestionChannel;
   log?: (msg: string) => void;
   cardFollowupDeps?: { ocrText?: (path: string) => Promise<string | null>; runGraph?: typeof runGraph; rootDir?: () => string };
+  nowDeps?: ContextNowDeps;
 }
 
 /** Compose the full discord self+interweave onMessage handler. */
@@ -356,6 +359,11 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
     // Voice text commands pass the guild gate for the voice adapter's
     // sake — never route them into the LLM turn (legacy behavior).
     if (/^\/voice-(join|leave|status)\b/.test(ctx.text.trim())) return undefined;
+    const nowCommand = /^[/!]now(?:\s+([\s\S]*))?$/.exec(ctx.text.trim());
+    if (nowCommand) {
+      const args = nowCommand[1]?.trim().split(/\s+/).filter(Boolean) ?? [];
+      return renderTelegramNow(readSlashContextNow(args, deps.nowDeps));
+    }
     if (!ctx.text.trim() && ctx.attachments.length === 1 && ctx.attachments[0]!.contentType?.startsWith('image/')) {
       const photo = ctx.attachments[0]!;
       if (detectCard({ width: photo.width, height: photo.height, ocrText: null }).decision !== 'skip') {

package/src/discord-slash-wire.ts

@@ -16,12 +16,15 @@
 // 우회해 도착하므로 여기서 allowlist를 직접 강제한다.
 
 import type { UserConfig } from './user-config.js';
+import { SLASH_COMMANDS } from './chat/index.js';
 import type { DiscordBot, DcIncoming, DcMessageStreamer } from './discord.js';
 import { makeCommandRest } from './discord/slash-registry.js';
 import { normalizeInteractionPayload } from './discord/slash-router.js';
 import type { SlashCommandSchema } from './discord/slash-types.js';
 import { debug } from './debug/log.js';
 import { gateDiscordSchemas, readBotAudience } from './maturity/bot-command-maturity.js';
+import { buildBotSlashCatalog } from './maturity/bot-slash-catalog.js';
+import { FEATURE_MATURITY } from './maturity/feature-maturity.js';
 import { resolveChannelBotToken } from './channel-bot-token.js';
 
 const REST_BASE = 'https://discord.com/api/v10';
@@ -42,6 +45,9 @@ export const ELANOUS_SLASH_COMMANDS: readonly SlashCommandSchema[] = [
     { name: 'file', description: '첨부 (이미지/문서 — 백엔드가 봄)', type: 11, required: false },
   ] },
   { name: 'brain', description: '브레인 모드로 복귀 (위임 해제)' },
+  { name: 'now', description: '지금 판·칸·결정·자리·최근 맥락 보기', options: [
+    { name: 'topic', description: '좁혀 볼 주제 (선택)', type: 3, required: false },
+  ] },
   { name: 'sessions', description: '바인딩된 세션 목록' },
   { name: 'new', description: '새 세션으로 시작 (이전 대화 보존)' },
   { name: 'attach', description: '이 채널을 다른 세션에 연결', options: [
@@ -58,6 +64,15 @@ export const ELANOUS_SLASH_COMMANDS: readonly SlashCommandSchema[] = [
   { name: 'voice-status', description: '보이스 연결 상태' },
 ] as const;
 
+/** The native wire keeps its original schemas (including options); only new catalog
+ * entries use the core registry's description and the unsupported response. */
+export function discordWireCatalog() {
+  return buildBotSlashCatalog({
+    surface: 'discord', coreCommands: SLASH_COMMANDS, maturity: FEATURE_MATURITY,
+    handledCommands: ELANOUS_SLASH_COMMANDS,
+  });
+}
+
 /** SlashInteraction → 기존 텍스트 명령 문장 합성. */
 export function synthesizeCommandText(
   commandName: string,
@@ -79,6 +94,10 @@ export function synthesizeCommandText(
     case 'voice-leave': return '!voice-leave';
     case 'voice-status': return '!voice-status';
     case 'sessions': return '!sessions';
+    case 'now': {
+      const topic = options.get('topic');
+      return typeof topic === 'string' && topic.trim() ? `!now ${topic.trim()}` : '!now';
+    }
     case 'new': return '!new';
     case 'attach': return `!attach ${String(options.get('prefix') ?? '').trim()}`;
     case 'brain': return '!brain';
@@ -123,8 +142,16 @@ export function buildDiscordSlashWire(deps: DiscordSlashWireDeps): DiscordSlashW
     const guilds = await (await fetchImpl(`${REST_BASE}/users/@me/guilds`, auth)).json() as Array<{ id: string }>;
     const rest = makeCommandRest({ token, ...(deps.__fetchImpl ? { fetchImpl: deps.__fetchImpl } : {}) });
     const audience = readBotAudience((deps.userConfig.raw?.discord as { commandAudience?: unknown } | undefined)?.commandAudience);
-    const { schemas, hidden } = gateDiscordSchemas(ELANOUS_SLASH_COMMANDS, audience);
-    debug.log('discord.command', 'menu-filtered', { total: ELANOUS_SLASH_COMMANDS.length, shown: schemas.length - hidden, ...audience });
+    const catalog = discordWireCatalog();
+    const handled = new Map(ELANOUS_SLASH_COMMANDS.map((schema) => [schema.name, schema]));
+    const allSchemas: SlashCommandSchema[] = catalog.commands.map((entry) => {
+      const original = handled.get(entry.name);
+      if (original) return original;
+      const { name, description } = entry;
+      return { name, description };
+    });
+    const { schemas, hidden } = gateDiscordSchemas(allSchemas, audience);
+    debug.log('discord.command', 'menu-filtered', { total: allSchemas.length, shown: schemas.length - hidden, ...audience });
     for (const g of Array.isArray(guilds) ? guilds : []) {
       const registered = await rest.bulkOverwriteGuild(app.id, g.id, schemas);
       log(`[slash] registered ${registered.length} commands in guild ${g.id}`);
@@ -180,6 +207,8 @@ export function buildDiscordSlashWire(deps: DiscordSlashWireDeps): DiscordSlashW
       await ack(it.id, it.token, `이 봇은 <#${deps.channelScope}> 채널 전용입니다.`);
       return;
     }
+    const unsupported = discordWireCatalog().unsupportedReply(it.commandName);
+    if (unsupported) { await ack(it.id, it.token, unsupported); return; }
     const text = synthesizeCommandText(it.commandName, it.options);
     const attachments = resolvedAttachments(raw);
     await ack(it.id, it.token, `▶ \`${text}\`${attachments.length ? ` (+첨부 ${attachments.length})` : ''}`);

package/src/domains/outbound-alert.ts

@@ -448,7 +448,7 @@ function reportUndeliverable(kind: string, daemonPath: DaemonPathClass | 'not-fo
   try { debug.log('outbound.send', 'undeliverable', { kind: safeObservationLabel(kind), daemonPath, universe, root }); } catch { /* fail-soft */ }
   const hint = universe === 'prod'
     ? '운영 데몬이 떠 있는지 확인: elanous nexus show'
-    : '운영으로 보내려면 설치본 elanous 로 실행하거나 ELANOUS_STATE_DIR=~/.elanous ELANOUS_CONFIG_DIR=~/.elanous 를 준다';
+    : '운영으로 보내려면 설치본 elanous 로 실행하거나 ELANOUS_STATE_DIR=~/.elanous 와 --config-dir ~/.elanous 를 준다';
   try { console.error(`[outbound] ⛔ 못 보냄(${kind}) — 데몬 ${daemonPath} · 직접 발송도 실패(토큰 없음 또는 전송 실패) · 이 프로세스의 우주 ${universe} (${root}) · ${hint}`); } catch { /* fail-soft */ }
 }
 

package/src/elanous-config-dir.ts

@@ -15,18 +15,41 @@
 // Resolution order:
 //   1. Programmatic override set via `setElanousConfigDir(dir)` (incl.
 //      from the `--config-dir` CLI flag).
-//   2. `~/.elanous` — default daily-driver root.
+//   2. State-dir via `effectiveInstanceRoot()` (including isolated source trees).
+//   3. `~/.elanous` for the installed daily-driver root.
 
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { resolve } from 'node:path';
 
 let override: string | undefined;
+let checkedIgnoredEnv = false;
+
+function normalizedDir(dir: string): string {
+  const trimmed = dir.trim();
+  const expanded = trimmed === '~' ? homedir() : trimmed.startsWith('~/') ? `${homedir()}${trimmed.slice(1)}` : trimmed;
+  return resolve(expanded);
+}
+
+function warnIfIgnoredEnv(resolved: string, source: 'flag' | 'state-dir' | 'default'): void {
+  if (checkedIgnoredEnv) return;
+  checkedIgnoredEnv = true;
+  const env = process.env.ELANOUS_CONFIG_DIR;
+  if (env === undefined || normalizedDir(env) === normalizedDir(resolved)) return;
+  console.error(`ELANOUS_CONFIG_DIR 는 읽지 않습니다 — 설정 폴더 = ${resolved} · 그 폴더를 쓰려면 --config-dir ${normalizedDir(env)}`);
+  try {
+    const { debug } = require('./debug/log.js') as typeof import('./debug/log.js');
+    debug.log('config.dir', 'env-ignored', { env, resolved, source });
+  } catch { /* logging must not change config resolution */ }
+}
 
 /** Resolve the current elanous config / daemon root directory. Caller
  *  decides what subpath to append (`workflows/`, `config.json`,
  *  `acp-token`, ...). */
 export function getElanousConfigDir(): string {
-  if (override !== undefined) return override;
+  if (override !== undefined) {
+    warnIfIgnoredEnv(override, 'flag');
+    return override;
+  }
   // ★ §4d (P3 · 2026-07-26) — **config-dir 은 state-dir 을 따라간다.**
   //
   //   `ELANOUS_STATE_DIR` 은 env 라 전 자손에 자동 전파되는데 config-dir 은 argv 재부착 **7곳**
@@ -41,7 +64,9 @@ export function getElanousConfigDir(): string {
   //     (`configDirFollowingStateDir` 은 §4d 계약을 문서화·테스트하는 순수 함수로 남는다 —
   //      실제 해석 경로는 이 리졸버 하나다.)
   const { effectiveInstanceRoot } = require('./instance/resolve.js') as typeof import('./instance/resolve.js');
-  return effectiveInstanceRoot();
+  const resolved = effectiveInstanceRoot();
+  warnIfIgnoredEnv(resolved, process.env.ELANOUS_STATE_DIR?.trim() ? 'state-dir' : 'default');
+  return resolved;
 }
 
 /** Programmatic override. Trims, rejects empty/blank. Child processes