elanous 0.2.13 → 0.2.14

package/src/dashboard/slash-runtime/chat-persona.ts

@@ -0,0 +1,66 @@
+import { awaitGlobalPersonaLoad, getGlobalPersonaRegistry } from '../../persona/global-registry.js';
+import { resolvePersonaAddress } from '../../intake-plane/persona-answer.js';
+import { loadSession, updateSessionMeta } from '../../session/index.js';
+import { assemblePersonaPrompt } from '../../persona/prompt-assembler.js';
+import type { LLMMessage } from '../../llm.js';
+
+/** Unattached conversations use a dashboard-local id; attached sessions use persisted metadata. */
+export class TuiChatPersonaSelection {
+  private readonly selected = new Map<string, string>();
+
+  get(sessionId: string): string | undefined {
+    return loadSession(sessionId)?.meta.chatPersonaId ?? this.selected.get(sessionId);
+  }
+
+  set(sessionId: string, personaId: string | undefined): void {
+    const meta = updateSessionMeta(sessionId, (m) => {
+      if (personaId) m.chatPersonaId = personaId;
+      else delete m.chatPersonaId;
+    });
+    if (!meta) {
+      if (personaId) this.selected.set(sessionId, personaId);
+      else this.selected.delete(sessionId);
+    } else {
+      this.selected.delete(sessionId);
+    }
+  }
+}
+
+export async function handleTuiChatPersona(
+  args: readonly string[], sessionId: string,
+  selection: TuiChatPersonaSelection,
+): Promise<string> {
+  if (args[0] === '-') {
+    if (args.length !== 1) return '쓰는 법: /persona [이름|-]';
+    selection.set(sessionId, undefined);
+    return '이 대화의 페르소나를 뺐습니다';
+  }
+  try {
+    await awaitGlobalPersonaLoad();
+    const registry = getGlobalPersonaRegistry();
+    if (!args.length) {
+      const selected = selection.get(sessionId);
+      const personas = registry.list().sort((a, b) => a.displayName.localeCompare(b.displayName));
+      const current = personas.find(p => p.personaId === selected);
+      return `이 대화의 페르소나: ${current ? `${current.displayName} (${current.personaId})` : '없음'}\n고를 수 있는 페르소나: ${personas.map(p => `${p.displayName} (${p.personaId})${p.personaId === selected ? ' (지금)' : ''}`).join(' · ') || '없음'}\n고르기: /persona <이름> · 빼기: /persona -`;
+    }
+    const name = args.join(' ');
+    const persona = resolvePersonaAddress(name, registry);
+    if (!persona) return `그런 페르소나가 없습니다: ${name}`;
+    selection.set(sessionId, persona.personaId);
+    return `${persona.displayName} 페르소나를 이 대화에 골랐습니다`;
+  } catch {
+    return '페르소나 목록을 읽지 못했습니다';
+  }
+}
+
+export function tuiChatPersonaMessages(
+  sessionId: string, selection: TuiChatPersonaSelection,
+): LLMMessage[] {
+  const id = selection.get(sessionId);
+  if (!id) return [];
+  const persona = getGlobalPersonaRegistry().get(id);
+  if (!persona) return [];
+  const prompt = assemblePersonaPrompt(persona, '').systemPrompt;
+  return prompt ? [{ role: 'system', content: prompt }] : [];
+}

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-ledger.ts

@@ -31,7 +31,15 @@ export interface DecisionEntry {
   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' | 'crossCheck' | 'crossCheckSkipped' | 'alternative' | 'dissent'> & { 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 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). */
@@ -196,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);
@@ -221,6 +230,36 @@ 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));
   }
+  /** 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 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);

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

package/src/execution-loop/launch-gate.ts

@@ -30,19 +30,32 @@ export function activeRunsForGoal(goalId: string, deps: ActiveRunsForGoalDeps =
     if (observation.completeness !== 'complete') unknownReasons.add(`ledger observation ${observation.completeness}`);
     for (const root of observation.pty.unreadable) unknownReasons.add(`unreadable PTY: ${root}`);
     const active = new Set<string>();
+    let skippedTerminal = 0;
     for (const run of observation.entries) {
-      if (run.status === 'ended-unclosed') continue;
-      if (run.ledgerDirectories.length === 0) { unknown = true; unknownReasons.add(`${run.runId}: ledger directory absent`); continue; }
+      if (run.status === 'ended-unclosed') { skippedTerminal += 1; continue; }
+      const hasObservedPty = run.ptyRefs.length > 0;
+      const live = run.status === 'running' && hasObservedPty;
+      if (run.ledgerDirectories.length === 0) {
+        if (hasObservedPty) { unknown = true; unknownReasons.add(`${run.runId}: ledger directory absent`); }
+        else skippedTerminal += 1;
+        continue;
+      }
       let identified = false;
       for (const directory of run.ledgerDirectories) {
         try {
           const ledger = loadLedger(run.runId, directory);
-          if (ledger === null) { unknown = true; unknownReasons.add(`${run.runId}: ledger unavailable`); continue; }
+          if (ledger === null) {
+            if (hasObservedPty) { unknown = true; unknownReasons.add(`${run.runId}: ledger unavailable`); }
+            continue;
+          }
           const ids = new Set(ledger.flatMap((entry) => entry.goalId ? [entry.goalId] : []));
-          if (ids.size !== 1) { unknown = true; unknownReasons.add(`${run.runId}: expected one goalId, found ${ids.size}`); continue; }
+          if (ids.size !== 1) {
+            if (hasObservedPty) { unknown = true; unknownReasons.add(`${run.runId}: expected one goalId, found ${ids.size}`); }
+            continue;
+          }
           identified = true;
           let matches = ids.has(goalId);
-          if (!matches && goalId.startsWith('request-') && run.status === 'running' && run.ptyRefs.length > 0) {
+          if (!matches && goalId.startsWith('request-') && live) {
             const document = ledger.find((entry) => entry.event === 'start')?.data.goalFile;
             if (typeof document === 'string') {
               try {
@@ -52,20 +65,22 @@ export function activeRunsForGoal(goalId: string, deps: ActiveRunsForGoalDeps =
             }
           }
           if (matches) {
-            if (run.status === 'running' && run.ptyRefs.length > 0) active.add(run.runId);
+            if (live) active.add(run.runId);
             else { unknown = true; unknownReasons.add(`${run.runId}: matching ledger without live PTY`); }
           }
-        } catch { unknown = true; unknownReasons.add(`${run.runId}: ledger read failed`); }
+        } catch {
+          if (hasObservedPty) { unknown = true; unknownReasons.add(`${run.runId}: ledger read failed`); }
+        }
       }
-      if (!identified) unknown = true;
+      if (!identified && !hasObservedPty) skippedTerminal += 1;
     }
     // Positive evidence wins even if a different process or store is unreadable.
-    if (active.size > 0) return [...active].sort();
-    if (unknown) {
-      try { debug.log('execution-loop.launch-gate', 'active-runs-unknown', { goalId, reasons: [...unknownReasons] }); } catch { /* observation is fail-soft */ }
-      return 'unknown';
-    }
-    return [];
+    const result: ActiveRunsForGoal = active.size > 0 ? [...active].sort() : unknown ? 'unknown' : [];
+    try {
+      debug.log('execution-loop.launch-gate', 'active-runs-result', { goalId, result, skippedTerminal });
+      if (result === 'unknown') debug.log('execution-loop.launch-gate', 'active-runs-unknown', { goalId, reasons: [...unknownReasons], skippedTerminal });
+    } catch { /* observation is fail-soft */ }
+    return result;
   } catch (error) {
     try { debug.log('execution-loop.launch-gate', 'active-runs-unknown', { goalId, reasons: [error instanceof Error ? error.message : String(error)] }); } catch { /* observation is fail-soft */ }
     return 'unknown';