elanous 0.2.13 → 0.2.15

package/src/decisions/proact-meter.ts

@@ -0,0 +1,286 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DecisionLedger, type DecisionEntry, type SeatDecisionRecord } from './decision-ledger.js';
+import { createRequire } from 'node:module';
+import { listCoordEvents, type CoordEvent } from '../context-bus/coord-events.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+
+/** Directive row fields this meter reads — kept local because `src/directives/directive-index` is excluded from the public export. */
+export interface DirectiveRow { ts: string; text: string; source_file: string; line_no: number }
+
+/** Loads the private directive index at run time only, so public builds (no index) bundle cleanly and report `directivesError`. */
+function openDirectiveIndex(stateDir?: string): { search(q: string, f: { since?: string; until?: string; limit?: number }): DirectiveRow[]; close(): void } {
+  const spec = ['..', 'directives', 'directive-index.js'].join('/');
+  const mod = createRequire(import.meta.url)(spec) as { DirectiveIndex: new (o: { stateDir?: string }) => ReturnType<typeof openDirectiveIndex> };
+  return new mod.DirectiveIndex(stateDir ? { stateDir } : {});
+}
+
+/** KST calendar day, matching the seat-loop ledger file name. */
+export function proactKstDay(at: Date | string): string {
+  const date = typeof at === 'string' ? new Date(at) : at;
+  if (!Number.isFinite(date.getTime())) throw new Error('valid timestamp required');
+  return new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit' }).format(date);
+}
+
+export function proactWindow(now: Date, days = 7): { since: string; until: string; days: string[] } {
+  if (!Number.isFinite(now.getTime()) || !Number.isInteger(days) || days < 1) throw new Error('valid window required');
+  const today = proactKstDay(now);
+  const todayStart = Date.parse(`${today}T00:00:00+09:00`);
+  const list: string[] = [];
+  for (let i = days - 1; i >= 0; i--) list.push(proactKstDay(new Date(todayStart - i * 86_400_000)));
+  return { since: new Date(todayStart - (days - 1) * 86_400_000).toISOString(), until: now.toISOString(), days: list };
+}
+
+export type ProactKind = 'proposal' | 'alert' | 'action';
+export type ProactSource = 'decision' | 'directive' | 'coord' | 'loop';
+export interface ProactSample {
+  readonly day: string;
+  readonly bucket: 'offered' | 'adopted' | 'asked';
+  readonly source: ProactSource;
+  readonly id: string;
+  readonly at: string;
+  readonly title: string;
+  /** Where the original row lives, so a count can be opened again. */
+  readonly link: string;
+}
+export interface ProactDay {
+  readonly day: string;
+  /** System offered a proposal, alert, or action before the owner asked. */
+  readonly offered: number;
+  /** Of those, the ones the owner (or a delegated seat) adopted. */
+  readonly adopted: number;
+  /** Problems that stayed invisible until the owner asked first. */
+  readonly asked: number;
+}
+export interface ProactSourceStatus { readonly read: boolean; readonly reason?: string }
+export interface ProactMeter {
+  readonly since: string;
+  readonly until: string;
+  readonly days: readonly ProactDay[];
+  readonly samples: readonly ProactSample[];
+  readonly sources: Readonly<Record<ProactSource, ProactSourceStatus>>;
+}
+
+export interface ProactMeterInput {
+  decisions?: readonly DecisionEntry[];
+  seatDecisions?: readonly SeatDecisionRecord[];
+  directives?: readonly DirectiveRow[];
+  coord?: readonly CoordEvent[];
+  loops?: readonly ProactLoopRow[];
+  decisionsError?: string;
+  directivesError?: string;
+  coordError?: string;
+  loopsError?: string;
+}
+export interface ProactLoopRow {
+  readonly seat: string;
+  readonly at: string;
+  readonly status: string;
+  readonly action?: string;
+  readonly id?: string;
+  readonly title?: string;
+  readonly file: string;
+}
+
+const ALERT = /경보|경고|장애|실패|막힘|alert|fail|blocked|stall/i;
+const ACTION = /조치|실행|발사|launch|queued|launched/i;
+const ASKED = /왜|문제|안 되|안돼|고장|버그|실패|막혀|뭐가|무슨 일|확인해/;
+
+export function proactKind(text: string, action?: string): ProactKind {
+  if (action === 'decision' || action === 'harness' || action === 'seat-question' || ACTION.test(text)) return 'action';
+  if (ALERT.test(text)) return 'alert';
+  return 'proposal';
+}
+
+function sample(day: string, bucket: ProactSample['bucket'], source: ProactSource, id: string, at: string, title: string, link: string): ProactSample {
+  return { day, bucket, source, id, at, title: title.replace(/\s+/g, ' ').trim().slice(0, 160), link };
+}
+
+/** Count one row once. Adoption is a property of an offered row, never a second offered row. */
+export function measureProact(input: ProactMeterInput, now: Date, days = 7): ProactMeter {
+  const window = proactWindow(now, days);
+  const inWindow = (at: string | undefined): at is string => !!at && at >= window.since && at <= window.until;
+  const offered: ProactSample[] = [];
+  const adopted: ProactSample[] = [];
+  const asked: ProactSample[] = [];
+
+  if (!input.decisionsError) {
+    for (const card of input.decisions ?? []) {
+      const at = card.raisedAt ?? card.importedAt;
+      if (!inWindow(at)) continue;
+      const day = proactKstDay(at);
+      const link = `decisions://${card.id}`;
+      const system = card.raisedBy.agent !== 'human' && card.raisedBy.agent !== 'owner';
+      if (system) {
+        offered.push(sample(day, 'offered', 'decision', card.id, at, card.title, link));
+        const decidedAt = card.decidedAt;
+        const adoptedDay = decidedAt ? proactKstDay(decidedAt) : '';
+        if (card.status === 'decided' && decidedAt && decidedAt <= window.until) {
+          adopted.push(sample(adoptedDay, 'adopted', 'decision', card.id, decidedAt, card.title, link));
+        }
+      } else if (ASKED.test(`${card.title} ${card.scqa.c}`)) {
+        asked.push(sample(day, 'asked', 'decision', card.id, at, card.title, link));
+      }
+    }
+    for (const seat of input.seatDecisions ?? []) {
+      if (!inWindow(seat.recordedAt)) continue;
+      const at = seat.decidedAt && seat.decidedAt <= window.until ? seat.decidedAt : seat.recordedAt;
+      const adoptedDay = proactKstDay(at);
+      const link = `decisions://${seat.id}`;
+      offered.push(sample(proactKstDay(seat.recordedAt), 'offered', 'decision', seat.id, seat.recordedAt, seat.title, link));
+      if (window.days.includes(adoptedDay)) adopted.push(sample(adoptedDay, 'adopted', 'decision', seat.id, at, seat.title, link));
+    }
+  }
+
+  if (!input.directivesError) {
+    for (const row of input.directives ?? []) {
+      if (!inWindow(row.ts) || !ASKED.test(row.text)) continue;
+      asked.push(sample(proactKstDay(row.ts), 'asked', 'directive', `${row.source_file}:${row.line_no}`, row.ts, row.text, `directives://${row.source_file}#L${row.line_no}`));
+    }
+  }
+
+  if (!input.coordError) {
+    for (const event of input.coord ?? []) {
+      if (!inWindow(event.at)) continue;
+      const day = proactKstDay(event.at);
+      const link = event.refs.url ?? `coord://${event.id}`;
+      const text = `${event.summary} ${event.kind}`;
+      const systemOffered = event.refs.seat && event.refs.seat !== 'CEO' && (event.kind === '제안' || event.kind === '보고' || event.kind === '사고' || ALERT.test(text) || ACTION.test(text));
+      if (systemOffered) {
+        offered.push(sample(day, 'offered', 'coord', event.id, event.at, event.summary, link));
+      } else if (event.refs.seat === 'CEO' && (event.kind === '요청' || ASKED.test(text))) {
+        asked.push(sample(day, 'asked', 'coord', event.id, event.at, event.summary, link));
+      }
+    }
+  }
+
+  if (!input.loopsError) {
+    const proactive = new Set(['queued', 'launched', 'asked', 'hitl', 'shadow', 'attempting']);
+    for (const row of input.loops ?? []) {
+      if (!inWindow(row.at)) continue;
+      const day = proactKstDay(row.at);
+      const id = row.id ?? `${row.seat}:${row.at}`;
+      const link = `loop://${row.file}#${id}`;
+      const title = row.title ?? `${row.seat} ${row.status}`;
+      if (proactive.has(row.status) || row.action === 'decision' || row.action === 'harness') {
+        offered.push(sample(day, 'offered', 'loop', id, row.at, `${proactKind(title, row.action)}:${title}`, link));
+        if (row.status === 'launched' || row.status === 'queued' || row.action === 'decision') {
+          adopted.push(sample(day, 'adopted', 'loop', id, row.at, title, link));
+        }
+      }
+    }
+  }
+
+  const tally = new Map<string, { day: string; offered: number; adopted: number; asked: number }>(window.days.map(day => [day, { day, offered: 0, adopted: 0, asked: 0 }]));
+  for (const row of offered) tally.get(row.day)!.offered += 1;
+  for (const row of adopted) {
+    const cell = tally.get(row.day);
+    if (cell) cell.adopted += 1;
+  }
+  for (const row of asked) tally.get(row.day)!.asked += 1;
+  const pick = (rows: ProactSample[]) => {
+    const seen = new Set<string>();
+    const out: ProactSample[] = [];
+    for (const source of ['decision', 'directive', 'coord', 'loop'] as const) {
+      for (const row of rows.filter(item => item.source === source).sort((a, b) => b.at.localeCompare(a.at) || a.id.localeCompare(b.id))) {
+        if (seen.has(row.link)) continue;
+        seen.add(row.link);
+        out.push(row);
+        if (out.length === 2) break;
+      }
+    }
+    return out;
+  };
+  const status = (error: string | undefined, read: boolean): ProactSourceStatus => error ? { read: false, reason: error } : { read };
+  return {
+    since: window.since, until: window.until,
+    days: window.days.map(day => tally.get(day)!),
+    samples: [...pick(offered), ...pick(adopted), ...pick(asked)],
+    sources: {
+      decision: status(input.decisionsError, !input.decisionsError),
+      directive: status(input.directivesError, !input.directivesError),
+      coord: status(input.coordError, !input.coordError),
+      loop: status(input.loopsError, !input.loopsError),
+    },
+  };
+}
+
+function readLoopRows(root: string, days: readonly string[]): ProactLoopRow[] {
+  const base = join(root, 'seat-loop');
+  const seats = readdirSync(base, { withFileTypes: true }).filter(entry => entry.isDirectory()).map(entry => entry.name);
+  const rows: ProactLoopRow[] = [];
+  for (const seat of seats) {
+    for (const day of days) {
+      const file = join(base, seat, `${day}.jsonl`);
+      let text = '';
+      try { text = readFileSync(file, 'utf8'); } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') continue;
+        throw error;
+      }
+      for (const line of text.split('\n')) {
+        if (!line.trim()) continue;
+        const parsed = JSON.parse(line) as { at?: string; ts?: string; status?: string; action?: string; item?: { id?: string; title?: string } };
+        const at = parsed.at ?? parsed.ts;
+        if (!at || !parsed.status) continue;
+        rows.push({ seat, at, status: parsed.status, action: parsed.action, id: parsed.item?.id, title: parsed.item?.title, file });
+      }
+    }
+  }
+  return rows;
+}
+
+export interface ProactMeterDeps {
+  readonly now?: Date;
+  readonly days?: number;
+  readonly stateDir?: string;
+  readonly instanceRoot?: string;
+  readonly readDecisions?: () => { decisions: DecisionEntry[]; seatDecisions: SeatDecisionRecord[] };
+  readonly readDirectives?: (since: string, until: string) => DirectiveRow[];
+  readonly readCoord?: (since: string) => CoordEvent[];
+  readonly readLoops?: (days: readonly string[]) => ProactLoopRow[];
+}
+
+/** Read the four ledgers. A source that cannot be opened is reported, never counted as zero evidence. */
+export function readProactMeter(deps: ProactMeterDeps = {}): ProactMeter {
+  const now = deps.now ?? new Date();
+  const window = proactWindow(now, deps.days ?? 7);
+  const input: ProactMeterInput = {};
+  const stateDir = deps.stateDir;
+  try {
+    const read = deps.readDecisions ?? (() => {
+      const ledger = new DecisionLedger(stateDir ? { stateDir } : {});
+      return { decisions: ledger.list({ status: 'all', since: window.since }), seatDecisions: ledger.seatReport({ since: window.since }) };
+    });
+    const got = read();
+    input.decisions = got.decisions;
+    input.seatDecisions = got.seatDecisions;
+  } catch (error) { input.decisionsError = error instanceof Error ? error.message : String(error); }
+  try {
+    input.directives = (deps.readDirectives ?? ((since, until) => {
+      const index = openDirectiveIndex(stateDir);
+      try { return index.search('', { since, until, limit: 1000 }); }
+      finally { index.close(); }
+    }))(window.since, window.until);
+  } catch (error) { input.directivesError = error instanceof Error ? error.message : String(error); }
+  try {
+    input.coord = (deps.readCoord ?? ((since) => listCoordEvents({ since, channelOnly: true })))(window.since);
+  } catch (error) { input.coordError = error instanceof Error ? error.message : String(error); }
+  try {
+    const loopRoot = deps.instanceRoot ?? stateDir ?? effectiveInstanceRoot() ?? elanousStateRoot();
+    input.loops = (deps.readLoops ?? ((days) => readLoopRows(loopRoot, days)))(window.days);
+  } catch (error) { input.loopsError = error instanceof Error ? error.message : String(error); }
+  return measureProact(input, now, deps.days ?? 7);
+}
+
+export function formatProactMeter(meter: ProactMeter): string {
+  const lines = [`선제성 ${meter.since} ~ ${meter.until}`, '날짜 · 먼저 냄 · 채택 · 물어서야'];
+  for (const day of meter.days) lines.push(`${day.day} · ${day.offered} · ${day.adopted} · ${day.asked}`);
+  const unread = (Object.entries(meter.sources) as Array<[ProactSource, ProactSourceStatus]>).filter(([, status]) => !status.read);
+  if (unread.length) lines.push(`못 읽음: ${unread.map(([name, status]) => `${name}(${status.reason})`).join(' · ')}`);
+  if (meter.samples.length) {
+    lines.push('표본:');
+    for (const row of meter.samples) lines.push(`  ${row.bucket} · ${row.source} · ${row.id} · ${row.link}`);
+  }
+  return lines.join('\n');
+}

package/src/decisions/proact1-lite.ts

@@ -0,0 +1,86 @@
+import type { DecisionEntry } from './decision-ledger.js';
+import type { ChecklistItem } from '../release-loop/checklist.js';
+import type { ReleaseSchedule } from '../release-loop/release-schedule.js';
+import type { DraftSweepResult, SweepDraft } from '../self-dev/draft-sweep.js';
+
+type ProactLoop = { readonly name: string; readonly state: 'alive' | 'late' | 'failing' | 'off' | 'unknown'; readonly scope?: string };
+type ProactYellow = { readonly version: string; readonly item: Pick<ChecklistItem, 'id' | 'title' | 'status'> };
+type ProactDrafts = { readonly drafts: readonly Pick<SweepDraft, 'number' | 'title'>[]; readonly sweep: Pick<DraftSweepResult, 'complete' | 'entries'> };
+export interface ProactSignals {
+  /** A suspended run (resume) or an explicitly observed blocker, not merely an old open card. */
+  readonly decisions?: readonly (Pick<DecisionEntry, 'id' | 'title' | 'status' | 'raisedAt' | 'importedAt' | 'resume'> & { readonly blocked?: boolean })[];
+  readonly yellow?: readonly ProactYellow[];
+  readonly schedules?: readonly Pick<ReleaseSchedule, 'version' | 'landBy'>[];
+  readonly loops?: readonly ProactLoop[];
+  /** Only a complete, read-only runDraftSweep({ apply: false }) assessment proves draft staleness. */
+  readonly draftAssessment?: ProactDrafts;
+}
+type ProactSuggestion = {
+  readonly key: string;
+  readonly kind: 'decision' | 'yellow' | 'loop' | 'draft';
+  readonly title: string;
+  readonly reason: string;
+  readonly source: string;
+  readonly score: number;
+};
+
+const HOUR = 3_600_000;
+const DECISION_AGE_HOURS = 24;
+const LANDING_WINDOW_HOURS = 24;
+const MAX_SUGGESTIONS = 3;
+
+/** Rules-only, read-only selection. Missing/invalid observations are unknown, never evidence of urgency. */
+export function selectProact1Lite(signals: ProactSignals, options: { now: Date; previouslySuggested?: ReadonlySet<string> }): ProactSuggestion[] {
+  const now = options.now.getTime();
+  if (!Number.isFinite(now)) throw new Error('valid now required');
+  const candidates: ProactSuggestion[] = [];
+  const elapsedHours = (iso: string | undefined): number => iso ? (now - Date.parse(iso)) / HOUR : NaN;
+  const valid = (text: string): boolean => text.trim().length > 0;
+
+  for (const card of signals.decisions ?? []) {
+    if (card.status !== 'open' || (card.blocked !== true && !card.resume) || !valid(card.id) || !valid(card.title)) continue;
+    // Imported historical cards have no known raise time; their import time is a lower bound on age.
+    const age = elapsedHours(card.raisedAt ?? card.importedAt);
+    if (!Number.isFinite(age) || age < DECISION_AGE_HOURS) continue;
+    candidates.push({ key: `decision:${card.id}`, kind: 'decision', title: card.title,
+      reason: `열린 결정 ${Math.floor(age)}시간 대기${card.raisedAt ? '' : ' (가져온 시각 기준)'}`,
+      source: card.id, score: 400 + Math.min(100, Math.floor(age / 24)) });
+  }
+
+  const deadlines = new Map((signals.schedules ?? []).map(schedule => [schedule.version, schedule.landBy]));
+  for (const { version, item } of signals.yellow ?? []) {
+    if (item.status !== 'yellow' || !valid(item.id) || !valid(item.title) || !valid(version)) continue;
+    const landBy = deadlines.get(version);
+    const remaining = landBy ? (Date.parse(landBy) - now) / HOUR : NaN;
+    if (!Number.isFinite(remaining) || remaining > LANDING_WINDOW_HOURS) continue;
+    candidates.push({ key: `yellow:${version}:${item.id}`, kind: 'yellow', title: item.title,
+      reason: remaining < 0 ? `착지 마감 ${Math.ceil(-remaining)}시간 경과` : `착지 마감 ${Math.ceil(remaining)}시간 전`,
+      source: `${version}/${item.id} · ${landBy}`, score: 500 + Math.min(100, Math.max(0, Math.ceil(-remaining))) });
+  }
+
+  for (const loop of signals.loops ?? []) {
+    if (loop.state !== 'late' || !valid(loop.name)) continue;
+    candidates.push({ key: `loop:${loop.scope ?? ''}:${loop.name}`, kind: 'loop', title: loop.name,
+      reason: '루프 실행 지연 관측', source: `${loop.scope ?? 'loop'}/${loop.name}`, score: 300 });
+  }
+
+  const assessment = signals.draftAssessment;
+  if (assessment?.sweep.complete) {
+    const drafts = new Map(assessment.drafts.map(draft => [draft.number, draft]));
+    for (const entry of assessment.sweep.entries) {
+      // A stale assessment is not a request to close: only surface the already-verified signal.
+      if (entry.action !== 'close' || entry.applied || !['stale-unobserved', 'claim-expired', 'claim-expired (self-implement.result final; worktree is not live)'].includes(entry.reason)) continue;
+      const draft = drafts.get(entry.number);
+      if (!draft || !valid(draft.title)) continue;
+      candidates.push({ key: `draft:${entry.number}`, kind: 'draft', title: draft.title,
+        reason: `draft PR 정체 (${entry.reason})`, source: `#${entry.number}`, score: 200 });
+    }
+  }
+
+  const selected = new Map<string, ProactSuggestion>();
+  for (const candidate of candidates) {
+    if (options.previouslySuggested?.has(candidate.key)) continue;
+    if (!selected.has(candidate.key) || selected.get(candidate.key)!.score < candidate.score) selected.set(candidate.key, candidate);
+  }
+  return [...selected.values()].sort((a, b) => b.score - a.score || a.key.localeCompare(b.key)).slice(0, MAX_SUGGESTIONS);
+}

package/src/decisions/web-push-decision-cards.ts

@@ -28,7 +28,7 @@ export function webPushDecisionTransport(
       const recommendation = 'skipped' in entry.recommendation ? '추천안 없음' : `추천안: ${entry.recommendation.option.toUpperCase()}`;
       const body = `${recommendation}${entry.dueAt ? ` · 기한: ${new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(entry.dueAt))}` : ''}`;
       const result = await push({ title: title('대표 결정 · ', entry.title), body, url: url(id), tag: tag(id) });
-      debug.log('decisions.webpush', 'card-sent', { id, delivered: result.delivered });
+      if (result.attempted) debug.log('decisions.webpush', 'card-sent', { id, delivered: result.delivered });
       return result.delivered ? { chat: 'webpush', message: id } : null;
     },
     edit: async (ref, _view) => {

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})` : ''}`);