elanous 0.2.10 → 0.2.11

package/src/context-bus/context-now.ts

@@ -0,0 +1,104 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { debug, redactSecretText } from '../debug/log.js';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { listChecklist, devVersion, type Checklist } from '../release-loop/checklist.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { seatDay, seatLedgerPath, type SeatEntry } from '../seat-loop/seat-loop.js';
+import { listCoordEvents, type CoordEvent } from './coord-events.js';
+
+export type ContextFact =
+  | { kind: 'version'; version: string; source: string }
+  | { kind: 'cell'; version: string; id: string; title: string; status: string; owner: string | null; source: string }
+  | { kind: 'decision'; id: string; title: string; status: string; dueAt: string | null; source: string }
+  | { kind: 'seat'; seat: string; at: string; status: string; id: string | null; title: string | null; source: string };
+export type ContextEvent = { at: string; kind: string; summary: string; source: string };
+export type ContextNowAnswer = { at: string; topic: string | null; facts: ContextFact[]; events: ContextEvent[]; guide: string[] };
+
+export interface ContextNowDeps {
+  now?: () => Date;
+  version?: () => string;
+  checklist?: (version: string) => Checklist;
+  decisions?: () => DecisionEntry[];
+  seatEntries?: (now: Date) => Array<{ entry: SeatEntry; source: string }>;
+  events?: (since: string) => CoordEvent[];
+}
+
+function todaySeatEntries(now: Date): Array<{ entry: SeatEntry; source: string }> {
+  const root = effectiveInstanceRoot();
+  const day = seatDay(now);
+  return ['OP', 'TC', 'MK', 'UX'].flatMap(seat => {
+    const path = seatLedgerPath(seat, root, now);
+    if (!existsSync(path)) return [];
+    return readFileSync(path, 'utf8').split('\n').flatMap((line, index) => line.trim() ? [{
+      entry: JSON.parse(line) as SeatEntry,
+      source: `elanous://seat-loop/${seat}/${day}#${index + 1}`,
+    }] : []);
+  });
+}
+
+/** Read a bounded, source-labelled view of current ledgers, never a transcript or decision body. */
+export function contextNow(options: { topic?: string; limit?: number } = {}, deps: ContextNowDeps = {}): ContextNowAnswer {
+  const now = (deps.now ?? (() => new Date()))();
+  const at = `${now.toISOString().slice(0, 16)}:00.000Z`;
+  const topic = options.topic?.trim() || null;
+  const limit = typeof options.limit === 'number' && Number.isFinite(options.limit)
+    ? Math.max(1, Math.min(100, Math.floor(options.limit))) : 20;
+  const version = (deps.version ?? devVersion)().replace(/-.*$/, '');
+  const next = version.replace(/^(\d+)\.(\d+)\.(\d+)$/, (_, major: string, minor: string, patch: string) => `${major}.${minor}.${Number(patch) + 1}`);
+  const facts: ContextFact[] = [];
+  for (const v of [...new Set([version, next])]) {
+    const checklist = (deps.checklist ?? listChecklist)(v);
+    if (v === version) facts.push({ kind: 'version', version: v, source: `elanous://release/${v}/checklist` });
+    for (const item of checklist.items) {
+      if (item.status === 'done') continue;
+      facts.push({ kind: 'cell', version: v, id: item.id, title: redactSecretText(item.title.split(/\r?\n/, 1)[0] ?? '').slice(0, 120),
+        status: item.status, owner: item.owner ?? null, source: `elanous://release/${v}/checklist#${encodeURIComponent(item.id)}` });
+    }
+  }
+  for (const item of (deps.decisions ?? (() => new DecisionLedger().list({ status: 'open' })))()) {
+    if (item.status !== 'open') continue;
+    facts.push({ kind: 'decision', id: item.id, title: redactSecretText(item.title.split(/\r?\n/, 1)[0] ?? '').slice(0, 120),
+      status: item.status, dueAt: item.dueAt ?? null, source: `elanous://decisions/${encodeURIComponent(item.id)}` });
+  }
+  for (const { entry, source } of (deps.seatEntries ?? todaySeatEntries)(now)) {
+    facts.push({ kind: 'seat', seat: entry.seat, at: entry.at, status: entry.status,
+      id: entry.item?.id ?? null, title: entry.item?.source === 'checklist'
+        ? redactSecretText(entry.item.title.split(/\r?\n/, 1)[0] ?? '').slice(0, 120) : null, source });
+  }
+  const rawEvents = (deps.events ?? (since => listCoordEvents({ since })))(new Date(now.getTime() - 7 * 86_400_000).toISOString());
+  const chronologicalEvents = rawEvents.slice().sort((a, b) => a.at.localeCompare(b.at) || a.id.localeCompare(b.id));
+  const matches = (text: string) => !topic || text.toLocaleLowerCase().includes(topic.toLocaleLowerCase());
+  const selectedFacts = facts.filter(f => !topic || (f.kind === 'cell' && matches(`${f.id} ${f.title}`))
+    || (f.kind === 'seat' && matches(`${f.id ?? ''} ${f.title ?? ''}`)));
+  const groups = (['version', 'cell', 'decision', 'seat'] as const).map(kind => selectedFacts.filter(f => f.kind === kind));
+  groups[3]!.sort((a, b) => (a.kind === 'seat' && b.kind === 'seat' ? b.at.localeCompare(a.at) : 0));
+  const nonEmpty = groups.filter(group => group.length > 0);
+  const perKind = Math.floor(limit / nonEmpty.length);
+  const chosen = groups.map(group => group.splice(0, perKind));
+  let remaining = limit - chosen.reduce((total, group) => total + group.length, 0);
+  for (const index of [2, 3, 0, 1]) {
+    if (remaining <= 0) break;
+    if (chosen[index]!.length === 0 && groups[index]!.length > 0) {
+      chosen[index]!.push(...groups[index]!.splice(0, 1));
+      remaining--;
+    }
+  }
+  for (const index of [1, 2, 3, 0]) {
+    if (remaining <= 0) break;
+    const extra = groups[index]!.splice(0, remaining);
+    chosen[index]!.push(...extra);
+    remaining -= extra.length;
+  }
+  const boundedFacts = chosen.flat();
+  const summaries = chronologicalEvents.map(event => ({
+    at: event.at, kind: event.kind, summary: redactSecretText(event.summary.split(/\r?\n/, 1)[0] ?? '').slice(0, 120),
+    source: event.refs.source ?? event.refs.url ?? `elanous://context/event/${encodeURIComponent(event.id)}`,
+  }));
+  const selectedEvents = summaries.filter(event => matches(event.summary)).reverse().slice(0, limit);
+  const guide = summaries.filter(event => event.kind === 'guide-changed' || event.summary.startsWith('📌안내'))
+    .filter(event => matches(event.summary)).reverse().slice(0, limit)
+    .map(event => `📌 ${event.summary} — ${event.source}`);
+  const answer = { at, topic, facts: boundedFacts, events: selectedEvents, guide };
+  debug.log('context.now', 'answer', { topic, facts: answer.facts, events: answer.events });
+  return answer;
+}

package/src/context-bus/coord-events.ts

@@ -22,7 +22,7 @@ export interface CoordEvent {
   text: string;
   summary: string;
   kind: string;
-  refs: Pick<CoordEventInput, 'seat' | 'recipients' | 'all' | 'kind' | 'slot' | 'deadline' | 'url'>;
+  refs: Pick<CoordEventInput, 'seat' | 'recipients' | 'all' | 'kind' | 'slot' | 'deadline' | 'url'> & { origin?: string; source?: string };
 }
 
 function seatIds(): Set<string> {
@@ -104,7 +104,7 @@ export function listCoordEvents(opts: { since: string; seat?: string }, deps: {
   const db = deps.db ?? openSurfaceEventsDb();
   try {
     const rows = db.prepare(`SELECT id, ts, text, summary, kind, refs FROM events
-      WHERE surface='coord:channel' AND direction='outbound' AND ts>=?
+      WHERE surface IN ('coord:channel', 'context:external') AND direction='outbound' AND ts>=?
       ${opts.seat ? "AND json_extract(refs,'$.seat')=?" : ''} ORDER BY ts ASC, rowid ASC`)
       .all(...(opts.seat ? [opts.since, opts.seat] : [opts.since])) as Array<{
         id: string; ts: string; text: string; summary: string; kind: string; refs: string;

package/src/context-bus/external-events.ts

@@ -0,0 +1,52 @@
+import type { Database } from 'bun:sqlite';
+import { debug, redactSecretText } from '../debug/log.js';
+import { openSurfaceEventsDb, recordEvent } from '../domains/surface-events.js';
+
+export type ExternalEventOrigin = 'claude-code' | 'codex-agent-mission' | 'harness-child';
+export type ContextHookKind = 'claimed' | 'done' | 'asked' | 'guide-changed';
+export type ExternalEventKind = ContextHookKind | 'started' | 'finished';
+export const CONTEXT_SUMMARY_MAX = 120;
+export const CONTEXT_SOURCE_MAX = 512;
+
+export interface ExternalEventInput {
+  origin: ExternalEventOrigin;
+  kind: ExternalEventKind;
+  summary: string;
+  source: string;
+  at?: string;
+}
+
+/** Only a single, bounded, redacted summary and a locator enter the journal; no prompt or transcript. */
+export function recordExternalEvent(input: ExternalEventInput, deps: { db?: Database } = {}): string {
+  if (!['claude-code', 'codex-agent-mission', 'harness-child'].includes(input.origin)) throw new Error('invalid context origin');
+  if (input.origin === 'claude-code'
+    ? !['claimed', 'done', 'asked', 'guide-changed'].includes(input.kind)
+    : !['started', 'finished'].includes(input.kind)) throw new Error('invalid context kind');
+  const summary = redactSecretText(input.summary.split(/\r?\n/, 1)[0] ?? '').trim().slice(0, CONTEXT_SUMMARY_MAX);
+  const source = redactSecretText(input.source.split(/\r?\n/, 1)[0] ?? '').trim();
+  if (!summary) throw new Error('context summary must be one nonempty line');
+
+  if (!/^(?:https?:\/\/|elanous:\/\/)[^\s]+$/.test(source) || source.length > CONTEXT_SOURCE_MAX) {
+    throw new Error('context source must be a link (http(s) or elanous://), at most 512 characters');
+  }
+  const db = deps.db ?? openSurfaceEventsDb();
+  try {
+    return recordEvent(db, {
+      surface: 'context:external', direction: 'outbound', domain: 'elanous', category: 'coordination',
+      kind: input.kind, text: summary, summary,
+      refs: JSON.stringify({ seat: input.origin, recipients: [], all: false, kind: input.kind,
+        slot: null, deadline: null, url: source, origin: input.origin, source }),
+      ...(input.at ? { ts: input.at } : {}),
+    });
+  } finally { if (!deps.db) db.close(); }
+}
+
+/** Instrumentation never changes an agent's result. Failures remain visible without logging untrusted payloads. */
+export function observeExternalEvent(input: ExternalEventInput, record: typeof recordExternalEvent = recordExternalEvent): void {
+  try { record(input); }
+  catch (error) {
+    try { debug.log('context.external', 'record-failed', {
+      origin: input.origin, kind: input.kind, reason: error instanceof Error ? error.message : String(error),
+    }, { level: 'warn' }); } catch { /* A broken logger cannot change an agent's result. */ }
+  }
+}

package/src/context-bus/long-term-memory.ts

@@ -0,0 +1,108 @@
+import { redactSecretText } from '../debug/log.js';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { listCoordEvents, type CoordEvent } from './coord-events.js';
+
+export interface MemoryItem {
+  project: string;
+  seat: string;
+  topic: string;
+  summary: string;
+  source: string;
+  updatedAt: string;
+  status: 'active' | 'retired';
+  /** A normalized, comparable assertion supplied by the summarizer; absent means no conflict judgment. */
+  claim?: { key: string; value: string };
+  conflict?: { owner: 'OP'; sources: [string, string] };
+}
+
+export type MemorySource =
+  | { kind: 'event'; at: string; seat: string; text: string; source: string }
+  | { kind: 'decision'; at: string; seat: string; text: string; source: string };
+
+export interface MemorySummary {
+  project: string;
+  topic: string;
+  summary: string;
+  /** Only supply this when the two strings identify the same fact and mutually exclusive values. */
+  claim?: { key: string; value: string };
+}
+
+export interface MemoryDeps {
+  summarize: (source: MemorySource) => Promise<MemorySummary>;
+  events?: (since: string) => CoordEvent[];
+  decisions?: () => DecisionEntry[];
+}
+
+const DAY_MS = 86_400_000;
+const oneLine = (text: string) => redactSecretText(text.split(/\r?\n/, 1)[0] ?? '').trim();
+
+/** Condense one UTC day; callers persist the returned snapshot, not raw transcripts. Read-only ledger access. */
+export async function condenseContextDay(
+  day: string, previous: readonly MemoryItem[], deps: MemoryDeps, now: Date = new Date(),
+): Promise<MemoryItem[]> {
+  if (!/^\d{4}-\d\d-\d\d$/.test(day) || new Date(`${day}T00:00:00.000Z`).toISOString().slice(0, 10) !== day) {
+    throw new Error('day must be a valid UTC YYYY-MM-DD');
+  }
+  const since = `${day}T00:00:00.000Z`;
+  const start = Date.parse(since);
+  const until = start + DAY_MS;
+  // The store compares timestamp text, so fetch the previous local day too before UTC filtering.
+  const events = (deps.events ?? (from => listCoordEvents({ since: from })))(new Date(start - DAY_MS).toISOString());
+  const decisions = (deps.decisions ?? (() => new DecisionLedger().list({ status: 'all' })))();
+  const sources: MemorySource[] = [
+    ...events.map(event => ({ kind: 'event' as const, at: event.at, seat: event.refs.seat,
+      text: event.summary, source: event.refs.source ?? event.refs.url ?? `elanous://context/event/${encodeURIComponent(event.id)}` })),
+    ...decisions.map(decision => ({ kind: 'decision' as const,
+      at: decision.decidedAt ?? decision.raisedAt ?? decision.importedAt ?? '',
+      seat: decision.raisedBy.track ?? 'OP',
+      text: decision.status === 'decided' ? `${decision.title}: ${decision.options.find(o => o.key === decision.choice)?.label ?? decision.note ?? decision.scqa.a ?? '결정됨'}` : `${decision.title}: ${decision.status}`,
+      source: `elanous://decisions/${encodeURIComponent(decision.id)}` })),
+  ].filter(source => {
+    const at = Date.parse(source.at);
+    return Number.isFinite(at) && at >= start && at < until;
+  }).sort((a, b) => Date.parse(a.at) - Date.parse(b.at) || a.source.localeCompare(b.source));
+
+  const items = new Map<string, MemoryItem>();
+  const keyFor = (item: Pick<MemoryItem, 'project' | 'seat' | 'topic'>) => JSON.stringify([item.project, item.seat, item.topic]);
+  for (const item of previous) items.set(keyFor(item), { ...item });
+  for (const source of sources) {
+    const summary = await deps.summarize(source);
+    const project = oneLine(summary.project);
+    const seat = oneLine(source.seat);
+    const topic = oneLine(summary.topic);
+    const text = oneLine(summary.summary);
+    const link = oneLine(source.source);
+    if (!project || !seat || !topic || !text || !/^(?:https?:\/\/|elanous:\/\/)[^\s]+$/.test(link)) {
+      throw new Error('memory summary needs a project, seat, topic, one-line summary and source link');
+    }
+    const claim = summary.claim && { key: oneLine(summary.claim.key), value: oneLine(summary.claim.value) };
+    if (claim && (!claim.key || !claim.value)) throw new Error('memory claim needs key and value');
+    const key = keyFor({ project, seat, topic });
+    const old = items.get(key);
+    // Equal timestamps are resolved by the source link, so shuffled input does not change the winner.
+    if (old && (Date.parse(old.updatedAt) > Date.parse(source.at)
+      || (Date.parse(old.updatedAt) === Date.parse(source.at) && old.source >= link))) continue;
+    items.set(key, { project, seat, topic, summary: text, source: link, updatedAt: source.at,
+      status: 'active', ...(claim ? { claim } : {}) });
+  }
+  const cutoff = now.getTime() - 30 * DAY_MS;
+  // Compare only the winning, non-retired assertions; a superseded claim cannot keep a decision candidate alive.
+  const finalItems: MemoryItem[] = [...items.values()].map(({ conflict: _conflict, ...item }) => ({ ...item,
+    status: Date.parse(item.updatedAt) < cutoff ? 'retired' as const : 'active' as const,
+  }));
+  finalItems.sort((a, b) => Date.parse(a.updatedAt) - Date.parse(b.updatedAt) || a.source.localeCompare(b.source)
+    || a.seat.localeCompare(b.seat));
+  for (let index = 0; index < finalItems.length; index++) {
+    const item = finalItems[index]!;
+    if (item.status !== 'active' || !item.claim) continue;
+    const { key, value } = item.claim;
+    const conflicting = finalItems.slice(0, index).find(other => other.status === 'active'
+      && other.project === item.project
+      && other.claim?.key === key && other.claim.value !== value);
+    if (conflicting) {
+      finalItems[index] = { ...item, conflict: { owner: 'OP', sources: [conflicting.source, item.source] } };
+    }
+  }
+  return finalItems.sort((a, b) => a.project.localeCompare(b.project) || a.seat.localeCompare(b.seat)
+    || a.topic.localeCompare(b.topic));
+}

package/src/dashboard/index.ts

@@ -18,6 +18,7 @@ import type { ShootRunOptions } from '../ad-pipeline/shoot-run.js';
 import type { QcThresholds } from '../ad-pipeline/qc.js';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { suggestProjectForFolder } from '../project/project-store.js';
+import { createProjectSuggester } from '../project/project-suggestion.js';
 
 const dashboardDefaultShootRunOptions: Required<Pick<ShootRunOptions, 'pollIntervalMs' | 'maxPollsPerJob' | 'submitStaggerMs'>> = {
   pollIntervalMs: 3_000,
@@ -15791,12 +15792,16 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         chatLines.push(C.muted(`    ${resume.turns} turns restored. Next turn continues this conversation.`));
       }
     }
+    // 제안은 세션 작업 폴더 기준 — 시작 폴더 한 번이 아니라 폴더가 바뀔 때마다 다시 계산한다(IA1 리뷰 must-fix).
+    const nextProjectSuggestion = createProjectSuggester(suggestProjectForFolder);
+    const pushProjectSuggestion = (folder: string): void => {
+      const project = nextProjectSuggestion(folder);
+      if (project) chatLines.push(C.muted(`  Project suggestion: ${project.name} (${project.id})`));
+    };
     if (dashboardAcpBootResult.mode !== 'resumed' && !chat.history.some((message) => message.role !== 'system')) {
-      try {
-        const project = suggestProjectForFolder(process.cwd());
-        if (project) chatLines.push(C.muted(`  Project suggestion: ${project.name} (${project.id})`));
-      } catch { /* suggestions must not interrupt the dashboard conversation */ }
+      pushProjectSuggestion(getSessionCwd());
     }
+    subscribeSessionCwd((state) => { pushProjectSuggestion(state.cwd); });
     chatScrollOffset = -1;
     void renderDashboardFirstScreenBand({
       history: chat.history,

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

@@ -272,6 +272,8 @@
 // `../index.ts`) instead of importing the type — keeps this module free
 // of circular dependency on dashboard/index.ts.
 
+import { tuiNowSlash } from '../../context-bus/context-now-surfaces.js';
+import type { ContextNowDeps } from '../../context-bus/context-now.js';
 import { runRebindCommand } from '../../input-core/index.js';
 // B4 (TUI half) — /design reuses the CLI's own resolution so the three
 // surfaces (CLI, PWA panel, this) cannot answer differently.
@@ -1358,9 +1360,13 @@ function emitReplyToChat(ctx: Pick<DashboardSlashContext, 'pushChatLine'>, line:
   ctx.pushChatLine(line);
 }
 
-export function buildDashboardSlashRegistry(): SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn> {
+export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn> {
   const registry = new SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn>();
 
+  registry.register(['now'], (args, ctx) => {
+    for (const line of tuiNowSlash(args, nowDeps)) ctx.pushChatLine(line);
+  });
+
   // ── B-1.a pilot ────────────────────────────────────────────────────
   registry.register(['quit', 'q', 'exit'], (_args, ctx) => {
     (ctx.exitTui ?? ctx.closeTui)();

package/src/decisions/decision-cards.ts

@@ -43,6 +43,7 @@ export function renderCardText(e: DecisionEntry, extra: { note?: string; confirm
     '',
     `상황: ${e.scqa.s}`,
     `문제: ${e.scqa.c}`,
+    ...(e.pendingQuestion ? ['', `대기 질문 전문:\n${e.pendingQuestion}`] : []),
     ...(e.scqa.q ? [`질문: ${e.scqa.q}`] : []),
     ...(e.scqa.a ? [`제안: ${e.scqa.a}`] : []),
     '',
@@ -180,7 +181,8 @@ export class DecisionCardService {
             const entry = this.ledger.raise({
               title: question.question.split(/\r?\n/, 1)[0]!.slice(0, 120),
               category: question.impact === 'critical' ? 'irreversible' : 'scope',
-              scqa: { s: question.question, c: question.question },
+              scqa: { s: Array.from(question.question.split(/\r?\n/, 1)[0]!).slice(0, 200).join(''), c: 'The requesting run is waiting for this choice.' },
+              pendingQuestion: question.question,
               options: question.options.map((option, index) => ({ key: keys[index]!, label: option.label, consequence: option.description })),
               recommendation: recommended !== undefined && Number.isInteger(recommended) && recommended >= 0 && recommended < question.options.length
                 ? { option: keys[recommended]!, why: '런이 추천' } : { skipped: true, reason: '추천 없음' },
@@ -251,9 +253,12 @@ export class DecisionCardService {
       return { kind: 'confirm', view: renderCard(entry, { confirm: parsed.key, ...(card?.note ? { note: card.note } : {}) }), toast: '되돌릴 수 없는 결정 — 한 번 더 확인해 주세요' };
     }
     let decided: DecisionEntry;
+    let answerDelivery: ReturnType<DecisionLedger['decideWithDelivery']>['delivery'] = null;
     try {
       // Same ledger method the CLI `decide` uses — one record path.
-      decided = this.ledger.decide(entry.id, parsed.key, { kind: 'human' }, card?.note);
+      const recorded = this.ledger.decideWithDelivery(entry.id, parsed.key, { kind: 'human' }, card?.note);
+      decided = recorded.entry;
+      answerDelivery = recorded.delivery;
     } catch (error) {
       debug.log('decisions.telegram', 'decide-failed', { platform, id: entry.id, reason: error instanceof Error ? error.message.slice(0, 80) : 'unknown' }, { level: 'warn' });
       try { const now = this.ledger.show(entry.id); if (now.status !== 'open') return { kind: 'closed', view: renderCard(now), toast: '이미 정해진 결정입니다' }; } catch { /* fall through */ }
@@ -269,7 +274,9 @@ export class DecisionCardService {
     await this.opts.replyToRaiser?.(decided, platform).catch((error: unknown) => {
       debug.log('decisions.telegram', 'reply-failed', { platform, id: decided.id, reason: error instanceof Error ? error.message.slice(0, 80) : 'unknown' }, { level: 'warn' });
     });
-    return { kind: 'decided', view, toast: `결정했습니다: ${decided.choice?.toUpperCase()}` };
+    return { kind: 'decided', view, toast: answerDelivery && !answerDelivery.ok
+      ? `결정은 기록됐지만 런 답 전달 실패 — decisions retry-answer ${decided.id}`
+      : `결정했습니다: ${decided.choice?.toUpperCase()}` };
   }
 
   /** Store a memo typed after «메모 달기»; the card shows it and the eventual decision carries it. */

package/src/decisions/decision-ledger.ts

@@ -7,7 +7,8 @@ import { createVersionResolver, type VersionOptions, type Versions } from '../di
 import { getUserConfig } from '../user-config.js';
 
 export type DecisionCategory = 'secret' | 'publish' | 'money' | 'security' | 'scope' | 'irreversible' | 'other';
-export type DecisionTrack = 'S' | 'T' | 'F' | 'O';
+/** Old track letters (S·T·F·O) stay readable; seat names (OP·MK·TC·UX) are the current identities. */
+export type DecisionTrack = 'S' | 'T' | 'F' | 'O' | 'OP' | 'MK' | 'TC' | 'UX';
 export interface DecisionOption { key: string; label: string; consequence: string }
 export type Recommendation = { option: string; why: string } | { skipped: true; reason: string };
 export type DecisionActor = { kind: 'human' } | { kind: 'auto'; agent: string; track?: DecisionTrack; delegation: string };
@@ -17,13 +18,15 @@ export interface DecisionEntry {
   raisedBy: { agent: string; track?: DecisionTrack; session?: string }; version?: Versions;
   status: 'open' | 'decided' | 'withdrawn'; refs?: string[];
   resume?: { questionId: string; runId?: string };
+  /** Original pending question, including its newlines; SCQA fields are short summaries. */
+  pendingQuestion?: string;
   /** DEC-TG — optional deadline (UTC). Cards remind the owner two hours before it. */
   dueAt?: 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'> & { raisedAt?: 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 interface DecisionLedgerOptions extends VersionOptions { stateDir?: string; now?: () => Date; resolveVersion?: (at: string) => Versions; writeAnswer?: typeof writePendingQuestionAnswer }
 
@@ -38,7 +41,7 @@ export class DecisionAnswerDeliveryError extends Error {
   }
 }
 const CATEGORIES: readonly string[] = ['secret', 'publish', 'money', 'security', 'scope', 'irreversible', 'other'];
-const TRACKS: readonly string[] = ['S', 'T', 'F', 'O'];
+const TRACKS: readonly string[] = ['S', 'T', 'F', 'O', 'OP', 'MK', 'TC', 'UX'];
 
 function required(value: string, name: string): string {
   if (typeof value !== 'string' || !value.trim()) throw new Error(`${name} is required`);
@@ -86,10 +89,12 @@ 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');
-  if (input.resume && !/^auq:[0-9a-z]+:[0-9a-z]{5}(?![\s\S])/.test(input.resume.questionId)) throw new Error('invalid resume questionId');
+  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 } : {}),
     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'))) } : {}),
@@ -263,13 +268,16 @@ export class DecisionLedger {
       if (!pending.ok) throw new Error(pending.error);
       const target = pending.questions.find(item => item.id === questionId);
       if (!target || target.questions.length !== 1 || !target.questions[0]?.id) throw new Error('pending question target not found or ambiguous');
+      if (questionId.startsWith('execution:') && (!runId || target.runId !== runId || !questionId.startsWith(`execution:${runId}:`))) throw new Error('pending question run differs from decision');
+      if (!questionId.startsWith('execution:') && runId !== undefined && target.runId !== undefined && target.runId !== runId) throw new Error('pending question run differs from decision');
+      if (target.expiresAt && Date.parse(target.expiresAt) <= this.now().getTime()) throw new Error('pending question expired');
       const question = target.questions[0];
       if (question.options.length !== entry.options.length || question.options.some((option, index) =>
         entry.options[index]?.key !== String.fromCharCode(97 + index) || entry.options[index]?.label !== option.label)) {
         throw new Error('pending question options differ from decision');
       }
       const answerKey = question.id;
-      const answer = { id: questionId, result: { answers: { [answerKey]: `${entry.choice}) ${label}` },
+      const answer = { id: questionId, result: { answers: { [answerKey]: questionId.startsWith('execution:') ? label : `${entry.choice}) ${label}` },
         ...(entry.note ? { otherText: { [answerKey]: entry.note } } : {}) } };
       const existing = readPendingQuestionAnswer(questionId, deps);
       if (!existing.ok) throw new Error('existing answer unreadable');

package/src/discord/sprint21-runtime.ts

@@ -21,6 +21,7 @@
 //   ⏳ Mention parser → persona LLM dispatch wire
 
 import { debug } from '../debug/log.js';
+import { botAudienceFor, gateDiscordSchemas } from '../maturity/bot-command-maturity.js';
 import type { DiscordBot } from '../discord.js';
 import {
   loadLayeredPersonaDirs,
@@ -204,7 +205,10 @@ export async function wireSprint21Runtime(opts: WireSprint21Opts): Promise<Sprin
   // 6. Slash command registration
   const cmdRest = makeCommandRest({ token: opts.token, fetchImpl: opts.fetchImpl });
   async function registerSlashCommands(): Promise<number> {
-    const schemas = router.schemas();
+    const allSchemas = router.schemas();
+    const audience = botAudienceFor('discord');
+    const { schemas, hidden } = gateDiscordSchemas(allSchemas, audience);
+    debug.log('discord.command', 'menu-filtered', { total: allSchemas.length, shown: schemas.length - hidden, ...audience });
     if (opts.devGuildId) {
       const out = await cmdRest.bulkOverwriteGuild(opts.appId, opts.devGuildId, schemas);
       log(`[sprint21-wire] registered ${out.length} slash commands to guild ${opts.devGuildId}`);

package/src/discord-self-message.ts

@@ -61,6 +61,9 @@ import { executionFooter } from './telegram-exec-footer.js';
 import { debug } from './debug/log.js';
 import { makeChunkProducer } from './session/streaming/chunk-producer.js';
 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';
 
 const SLASH_FOCUS_TURNS_DEFAULT = 8;
 
@@ -135,6 +138,7 @@ export interface DiscordSelfMessageDeps {
    *  (legacy). */
   questionChannelFor?: (channelId: string) => import('./hitl/question.js').QuestionChannel;
   log?: (msg: string) => void;
+  cardFollowupDeps?: { ocrText?: (path: string) => Promise<string | null>; runGraph?: typeof runGraph; rootDir?: () => string };
 }
 
 /** Compose the full discord self+interweave onMessage handler. */
@@ -352,6 +356,34 @@ 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;
+    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') {
+        const bot = deps.getBot();
+        if (bot) {
+          let imagePath: string;
+          let ocrText: string | null;
+          try {
+            imagePath = (await bot.downloadAttachment(photo)).localPath;
+            ocrText = await (deps.cardFollowupDeps?.ocrText ?? localOcrText)(imagePath);
+          } catch {
+            return '명함을 읽지 못했습니다';
+          }
+          if (detectCard({ width: photo.width, height: photo.height, ocrText }).decision === 'card') {
+            try {
+              const result = await runCardFollowup({ imagePath, ocrText,
+                ...(deps.cardFollowupDeps?.runGraph ? { runGraph: deps.cardFollowupDeps.runGraph } : {}),
+                ...(deps.cardFollowupDeps?.rootDir ? { rootDir: deps.cardFollowupDeps.rootDir() } : {}),
+              });
+              for (const reply of result.replies) await bot.sendMessage(ctx.channelId, reply);
+              return streamer ? '명함 정리를 완료했습니다.' : undefined;
+            } catch (error) {
+              if (!(error instanceof NotACardError)) return '명함을 읽지 못했습니다';
+            }
+          }
+        }
+      }
+    }
     // S1 session commands (!sessions·!new·!attach) — before delegation
     // and self-turn routing, mirroring telegram's command precedence.
     const sessionReply = handleSessionCommand(ctx);

package/src/discord-slash-wire.ts

@@ -21,6 +21,7 @@ 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 { resolveChannelBotToken } from './channel-bot-token.js';
 
 const REST_BASE = 'https://discord.com/api/v10';
@@ -121,8 +122,11 @@ export function buildDiscordSlashWire(deps: DiscordSlashWireDeps): DiscordSlashW
     if (!app.id) { log('[slash] application id unresolved — skip'); return; }
     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 });
     for (const g of Array.isArray(guilds) ? guilds : []) {
-      const registered = await rest.bulkOverwriteGuild(app.id, g.id, [...ELANOUS_SLASH_COMMANDS]);
+      const registered = await rest.bulkOverwriteGuild(app.id, g.id, schemas);
       log(`[slash] registered ${registered.length} commands in guild ${g.id}`);
     }
   }

package/src/discord.ts

@@ -23,6 +23,7 @@
 import { markdownToTelegramHtml as _unusedMarkdownFn } from './telegram-format.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
 import { debug } from './debug/log.js';
 import { getUserConfig } from './user-config.js';
+import { deliverSeatAnswers } from './seat-dispatch/seat-ask.js';
 import { handleDiscordSeatWork, type DiscordSeatWorkDeps } from './intake-plane/discord-seat-work.js';
 import { parseSeatAddress } from './seat-address/seat-address.js';
 
@@ -226,6 +227,7 @@ export class DiscordBot {
   private ws: WebSocket | null = null;
   private running = false;
   private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private seatAskTimer: ReturnType<typeof setInterval> | null = null;
   private lastHeartbeatAck = true;
   private lastSeq: number | null = null;
 
@@ -246,7 +248,15 @@ export class DiscordBot {
     this.onInteraction = opts.onInteraction ?? null;
     this.onReaction = opts.onReaction ?? null;
     this.onTriggerTap = opts.onTriggerTap ?? null;
-    this.seatWorkDeps = opts.seatWorkDeps ?? {};
+    this.seatWorkDeps = { ...opts.seatWorkDeps, askDeps: {
+      ...opts.seatWorkDeps?.askDeps,
+      channel: 'discord',
+      send: opts.seatWorkDeps?.askDeps?.send ?? (async (origin, text) => {
+        if (origin.channel !== 'discord') throw new Error('seat ask belongs to another surface');
+        const posted = await this.sendMessage(origin.threadId ?? origin.channelId, text);
+        if (!posted) throw new Error('Discord seat ask reply was not posted');
+      }),
+    } };
   }
 
   /** Send a raw payload on the gateway WebSocket. Voice adapter uses
@@ -523,8 +533,12 @@ export class DiscordBot {
   async start(): Promise<void> {
     this.running = true;
     this.log(`discord bot starting (allowlist size ${this.allowedUsers.size})`);
+    this.seatAskTimer = setInterval(() => {
+      void deliverSeatAnswers(this.seatWorkDeps.askDeps!).catch((error) => this.log(`seat ask delivery failed: ${String(error)}`));
+    }, 10_000);
     while (this.running) {
       try {
+        await deliverSeatAnswers(this.seatWorkDeps.askDeps!);
         await this.runConnection();
       } catch (err: any) {
         this.log(`gateway error: ${err?.message ?? String(err)}`);
@@ -538,6 +552,8 @@ export class DiscordBot {
 
   stop(): void {
     this.running = false;
+    if (this.seatAskTimer) clearInterval(this.seatAskTimer);
+    this.seatAskTimer = null;
     if (this.ws) {
       try { this.ws.close(1000, 'client stop'); } catch { /* ignore */ }
       this.ws = null;

package/src/domains/core-tools.ts

@@ -15,7 +15,7 @@ import { existsSync } from 'node:fs';
 import { Database } from 'bun:sqlite';
 import type { LLMToolSpec } from '../llm.js';
 import { debug } from '../debug/log.js';
-import { runRecall, type RecallSearch } from '../tool-runtime/self-cognition-runtimes.js';
+import { runRecall, CONTEXT_NOW_SPEC, type RecallSearch } from '../tool-runtime/self-cognition-runtimes.js';
 import type { ToolRuntimeContext } from '../tool-runtime/types.js';
 import { SCHEDULE_MANAGE_SPEC, dispatchScheduleManage } from './schedule-manage-tool.js';
 import { SESSION_MANAGE_SPEC, dispatchSessionQuery } from './session-query-tool.js';
@@ -114,6 +114,7 @@ const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>, onParti
   schedule_manage: dispatchScheduleManage,
   session_manage: (args) => dispatchSessionQuery(args), // 대화 세션 검색·열람·목록·삭제(내용/ID/텔레그램)
   memory_recall: dispatchMemoryRecall,
+  context_now: async (args) => (await import('../context-bus/context-now.js')).contextNow({ ...(typeof args.topic === 'string' ? { topic: args.topic } : {}) }),
   fact_check: dispatchFactCheck, // 팩트체크 캐스케이드(내부 발송원장→외부 X/레딧/웹)·도메인 무관 코어
   self_recall: dispatchSelfRecall, // self-awareness(elanous 구현 이력)·도메인 무관 코어
   autopilot_missions: dispatchAutopilotMissions, // 오토파일럿 계보 조회(AL3)·도메인 무관 코어
@@ -141,7 +142,7 @@ const SELF_RECALL_BUDGET_SPEC: LLMToolSpec = {
     },
   },
 };
-export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC, COO_ADMIN_SPEC, RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC];
+export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, CONTEXT_NOW_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC, COO_ADMIN_SPEC, RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC];
 
 export interface CoreTools {
   specs: LLMToolSpec[];