elanous 0.2.10 → 0.2.12

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; ref?: string | null };
 }
 
 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', 'context:session') 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/context-bus/nightly-condense.ts

@@ -0,0 +1,153 @@
+import { readFileSync, readdirSync, mkdirSync, writeFileSync, renameSync, existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { streamLLM } from '../llm.js';
+import { condenseContextDay, type MemoryItem, type MemorySource, type MemorySummary } from './long-term-memory.js';
+import { listCoordEvents, type CoordEvent } from './coord-events.js';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { acquireLockAsync } from '../storage/file-lock.js';
+
+type Stage = 'collect' | 'condense' | 'record' | 'conflict-candidates';
+type Input = { day?: string; events?: CoordEvent[]; decisions?: DecisionEntry[]; summaries?: Record<string, MemorySummary> };
+type Context = { graphId?: string; nodeId?: string; input: Input | null; outputs: Record<string, { day?: string; events?: CoordEvent[]; decisions?: DecisionEntry[]; items?: MemoryItem[] } | null> };
+
+const dayBefore = (date: Date) => new Date(date.getTime() - 86_400_000).toISOString().slice(0, 10);
+const fileName = (value: string) => encodeURIComponent(value).replace(/\./g, '%2E');
+
+function snapshotPath(root: string, project: string, seat: string): string {
+  if (project === '.' || project === '..' || seat === '.' || seat === '..') throw new Error('invalid memory path');
+  return join(root, 'context-memory', fileName(project), `${fileName(seat)}.json`);
+}
+
+function save(file: string, value: unknown): void {
+  mkdirSync(dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  writeFileSync(temp, JSON.stringify(value, null, 2) + '\n');
+  renameSync(temp, file);
+}
+
+async function withCurrentDay<T>(root: string, day: string, write: () => T): Promise<T> {
+  const dir = join(root, 'context-memory');
+  mkdirSync(dir, { recursive: true });
+  const lock = await acquireLockAsync(join(dir, '.nightly-write.lock'));
+  try {
+    const marker = join(dir, 'latest-day');
+    const latest = latestDay(root);
+    if ((latest && latest > day) || storedItems(root).some(item =>
+      Date.parse(item.updatedAt) >= Date.parse(`${day}T00:00:00Z`) + 86_400_000)) {
+      throw new Error(`cannot replay ${day}: later project/seat memory exists`);
+    }
+    if (!lock.stillHeld()) throw new Error('nightly memory write lock lost');
+    // Reserve the day before touching either output, so a failed writer cannot let an older run overwrite it.
+    if (!latest || latest < day) save(marker, day);
+    return write();
+  } finally { lock.release(); }
+}
+
+function latestDay(root: string): string | undefined {
+  const marker = join(root, 'context-memory', 'latest-day');
+  return existsSync(marker) ? JSON.parse(readFileSync(marker, 'utf8')) as string : undefined;
+}
+
+function storedItems(root: string): MemoryItem[] {
+  const dir = join(root, 'context-memory');
+  if (!existsSync(dir)) return [];
+  const items: MemoryItem[] = [];
+  for (const project of readdirSync(dir, { withFileTypes: true })) {
+    if (!project.isDirectory()) continue;
+    for (const seat of readdirSync(join(dir, project.name))) {
+      if (!seat.endsWith('.json')) continue;
+      const content: unknown = JSON.parse(readFileSync(join(dir, project.name, seat), 'utf8'));
+      if (!Array.isArray(content)) throw new Error('invalid context memory file');
+      items.push(...content as MemoryItem[]);
+    }
+  }
+  return items;
+}
+
+async function summarize(source: MemorySource, injected?: Record<string, MemorySummary>): Promise<MemorySummary> {
+  if (injected) {
+    const result = injected[source.source];
+    if (!result) throw new Error(`missing test summary: ${source.source}`);
+    return result;
+  }
+  const response = await streamLLM([
+    { role: 'system', content: 'Summarize this one-line context event as a compact project/seat memory item. Return ONLY JSON: {"project":"...","topic":"...","summary":"...","claim":{"key":"...","value":"..."}}. Omit claim when the event makes no comparable factual assertion. Never invent a project, topic or claim.' },
+    { role: 'user', content: JSON.stringify(source) },
+  ], () => {}, { maxTokens: 350, usageRole: 'research' });
+  const parsed: unknown = JSON.parse(response.replace(/^```(?:json)?\s*|\s*```$/g, '').trim());
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('invalid memory summary');
+  const value = parsed as Record<string, unknown>;
+  if (typeof value.project !== 'string' || typeof value.topic !== 'string' || typeof value.summary !== 'string' ||
+    (value.claim !== undefined && (!value.claim || typeof value.claim !== 'object' || Array.isArray(value.claim) ||
+      typeof (value.claim as Record<string, unknown>).key !== 'string' || typeof (value.claim as Record<string, unknown>).value !== 'string'))) {
+    throw new Error('invalid memory summary');
+  }
+  return value as unknown as MemorySummary;
+}
+
+/** Stage outputs travel only through the graph runner's per-run contexts. No decision ledger write occurs here. */
+export async function runNightlyStage(stage: Stage, context: Context, root: string, dryRun: boolean, now = new Date()): Promise<Record<string, unknown>> {
+  const input = context.input ?? {};
+  if (dryRun && stage !== 'collect' && (!input.events || !input.decisions || !input.summaries)) {
+    throw new Error('dry-run requires fake events, decisions and summaries');
+  }
+  const day = context.outputs.collect?.day ?? input.day ?? dayBefore(now);
+  if (!/^\d{4}-\d\d-\d\d$/.test(day) || new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) !== day) {
+    throw new Error('invalid UTC day');
+  }
+  if (stage === 'collect') {
+    if (!dryRun && ((latestDay(root) ?? '') > day || storedItems(root).some(item =>
+      Date.parse(item.updatedAt) >= Date.parse(`${day}T00:00:00Z`) + 86_400_000))) {
+      throw new Error(`cannot replay ${day}: later project/seat memory exists`);
+    }
+    if (dryRun && (!input.events || !input.decisions || !input.summaries)) {
+      throw new Error('dry-run requires fake events, decisions and summaries');
+    }
+    const events = input.events ?? listCoordEvents({ since: new Date(Date.parse(`${day}T00:00:00Z`) - 86_400_000).toISOString() });
+    const decisions = input.decisions ?? (dryRun ? [] : new DecisionLedger().list({ status: 'all' }));
+    return { outcome: 'ok', day, events, decisions };
+  }
+  const collected = context.outputs.collect;
+  if (!collected?.day || !collected.events || !collected.decisions) throw new Error('collect output missing');
+  if (stage === 'condense') {
+    const items = await condenseContextDay(collected.day, dryRun ? [] : storedItems(root).filter(item => Date.parse(item.updatedAt) < Date.parse(`${collected.day}T00:00:00Z`)), {
+      events: () => collected.events!, decisions: () => collected.decisions!,
+      summarize: source => summarize(source, input.summaries),
+    }, now);
+    return { outcome: 'ok', items };
+  }
+  const items = context.outputs.condense?.items;
+  if (!items) throw new Error('condense output missing');
+  if (stage === 'record') {
+    const grouped = new Map<string, MemoryItem[]>();
+    for (const item of items) {
+      const file = snapshotPath(root, item.project, item.seat);
+      grouped.set(file, [...grouped.get(file) ?? [], item]);
+    }
+    if (!dryRun) await withCurrentDay(root, day, () => {
+      for (const [file, group] of grouped) save(file, group);
+    });
+    return { outcome: 'ok', files: [...grouped.keys()], items: items.length, memoryItems: dryRun ? items : undefined, dryRun };
+  }
+  if (stage === 'conflict-candidates') {
+    if (!context.outputs.record) throw new Error('record output missing');
+    const candidates = items.filter(item => item.conflict && item.status === 'active').map(item => ({
+      project: item.project, topic: item.topic, owner: item.conflict!.owner,
+      sources: item.conflict!.sources, status: 'candidate' as const,
+    }));
+    if (!dryRun) await withCurrentDay(root, day, () => save(join(root, 'context-memory', 'conflict-candidates.json'), candidates));
+    return { outcome: 'ok', candidates, published: 0 };
+  }
+  throw new Error(`unknown stage: ${stage}`);
+}
+
+if (import.meta.main) {
+  const stage = process.argv[2] as Stage;
+  const path = process.env.ELANOUS_GRAPH_CONTEXT;
+  if (!path || !['collect', 'condense', 'record', 'conflict-candidates'].includes(stage)) throw new Error('invalid nightly graph stage');
+  const context = JSON.parse(readFileSync(path, 'utf8')) as Context;
+  if (context.graphId !== 'nightly-condense' || context.nodeId !== stage) throw new Error('nightly graph context mismatch');
+  const statePath = resolve(path, '..', '..', '..', '..');
+  const result = await runNightlyStage(stage, context, statePath, process.env.ELANOUS_GRAPH_DRY_RUN === '1');
+  console.log(JSON.stringify(result));
+}

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

@@ -0,0 +1,35 @@
+import type { Database } from 'bun:sqlite';
+import { redactSecretText } from '../debug/log.js';
+import { openSurfaceEventsDb, recordEvent } from '../domains/surface-events.js';
+
+export const SESSION_EVENT_KINDS = ['task-claimed', 'task-done', 'asked', 'guidance-changed'] as const;
+export type SessionEventKind = typeof SESSION_EVENT_KINDS[number];
+
+export interface SessionEventInput {
+  kind: SessionEventKind;
+  seat: string;
+  text: string;
+  ref?: string;
+  at?: string;
+}
+
+/** Publish a one-line external-agent session signal to the existing context journal. */
+export function emitSessionEvent(input: SessionEventInput, deps: { db?: Database } = {}): string {
+  if (!SESSION_EVENT_KINDS.includes(input.kind)) throw new Error('unknown context session kind');
+  if (!['OP', 'TC', 'MK', 'UX'].includes(input.seat)) throw new Error('context session seat must be OP|TC|MK|UX');
+  if (/\r|\n/.test(input.text) || !input.text.trim()) throw new Error('context session text must be one nonempty line');
+  if (input.ref !== undefined && (/\r|\n/.test(input.ref) || !input.ref.trim())) throw new Error('context session ref must be one nonempty line');
+  const summary = redactSecretText(input.text).trim().slice(0, 120);
+  const ref = input.ref ?? null;
+  const db = deps.db ?? openSurfaceEventsDb();
+  try {
+    return recordEvent(db, {
+      surface: 'context:session', direction: 'outbound', domain: 'elanous', category: 'coordination',
+      kind: input.kind, text: input.text, summary,
+      refs: JSON.stringify({ seat: input.seat, recipients: [], all: false, kind: input.kind,
+        slot: null, deadline: null, url: null, ref,
+        ...(ref ? { source: `elanous://context/ref/${encodeURIComponent(ref)}` } : {}) }),
+      ...(input.at ? { ts: input.at } : {}),
+    });
+  } finally { if (!deps.db) db.close(); }
+}

package/src/dashboard/dashboard-status-lines.ts

@@ -5,6 +5,7 @@ export interface DashboardStatusLinesInput {
   readonly daemonAddress?: string | null;
   readonly daemonConnected: boolean;
   readonly accountName?: string | null;
+  readonly seatsNow?: string | null;
   readonly sessionSurfaceLines: readonly string[];
   readonly view: string;
   readonly focus: string;
@@ -31,6 +32,7 @@ export function buildDashboardStatusLines(input: DashboardStatusLinesInput): str
     `모델: ${known(input.provider)}/${known(input.model)} (${known(input.reasoning)})`,
     `연결: 데몬 ${address} ${input.daemonConnected ? '붙음' : '안 붙음'}`,
     `계정: ${input.accountName?.trim() === 'default' ? '기본' : known(input.accountName)}`,
+    ...(input.seatsNow ? [input.seatsNow] : []),
     '',
     '자세히',
     ...input.sessionSurfaceLines.map(line => `  ${line}`),

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,
@@ -883,6 +884,7 @@ import { getInputHistoryStore, inputHistoryDbPath, inputHistoryJsonPath } from '
 import { inspectActiveProvider } from '../provider-summary.js';
 import { activeCodexAccountView } from '../oauth/codex-account-store.js';
 import { buildDashboardStatusLines } from './dashboard-status-lines.js';
+import { readSlashContextNow, seatsNowLine } from '../context-bus/context-now-surfaces.js';
 import { buildFirstScreenBand } from './first-screen-band.js';
 import { runNexusShow, type NexusShowResult } from '../cli/nexus-show.js';
 import {
@@ -6404,7 +6406,14 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     const active = inspectActiveProvider(cfg);
     const reasoningProvider = (['openai-codex', 'openai', 'anthropic', 'gemini', 'grok', 'local', 'openrouter'] as const)
       .find(provider => active.provider === provider || active.provider === `auto:${provider}`);
+    let seatsNow: string | null = null;
+    try {
+      seatsNow = seatsNowLine(readSlashContextNow([]), Date.now());
+    } catch (error) {
+      debug.log('dashboard.status', 'seats-unreadable', { error: String(error) });
+    }
     return buildDashboardStatusLines({
+      seatsNow,
       provider: active.provider,
       model: active.model,
       reasoning: reasoningProvider
@@ -15791,12 +15800,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,10 @@
 // `../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 { createWishCard } from '../../intake-plane/wish-card.js';
+import { CardStore } from '../../task-cards/card-store.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.
@@ -420,6 +424,8 @@ export interface DashboardSlashContext {
   /** Existing TUI structured-question capability. Absent means /ask keeps
    * the self-dev noninteractive deferred-clarification contract. */
   surfaceUx?: Pick<SurfaceUx, 'question'>;
+  /** Optional wish-card store for isolated slash dispatch tests. */
+  wishCardStore?: CardStore;
   attachmentRowMap: { clear(): void };
   pushDebugLine(line: string): void;
   pushChatLine(line: string): void;
@@ -1358,9 +1364,33 @@ 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);
+  });
+
+  registry.register('wish', (args, ctx) => {
+    const text = args.join(' ').trim();
+    if (!text) {
+      ctx.pushChatLine(ctx.warning('  usage: /wish <소원 한 줄>'));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    let store: CardStore | undefined;
+    try {
+      store = ctx.wishCardStore ?? new CardStore();
+      const card = createWishCard({ text, source: 'tui', ref: crypto.randomUUID() }, store);
+      ctx.pushChatLine(ctx.success(`  소원 카드로 남겼습니다 — ${card.title}`));
+    } catch (err) {
+      ctx.pushChatLine(ctx.error(`  소원 카드 등록 실패 — ${err instanceof Error ? err.message : String(err)}`));
+    } finally {
+      if (!ctx.wishCardStore) store?.close();
+    }
+    ctx.setChatScrollOffset(-1);
+  });
+
   // ── 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}`);