elanous 0.2.11 → 0.2.13

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

@@ -66,7 +66,7 @@ export function contextNow(options: { topic?: string; limit?: number } = {}, dep
         ? 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 chronologicalEvents = rawEvents.slice().sort((a, b) => a.at.localeCompare(b.at));
   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 ?? ''}`)));
@@ -95,7 +95,7 @@ export function contextNow(options: { topic?: string; limit?: number } = {}, dep
     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('📌안내'))
+  const guide = summaries.filter(event => event.kind === 'guide-changed' || event.kind === 'guidance-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 };

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'> & { origin?: string; source?: string };
+  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 IN ('coord:channel', 'context:external') 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/long-term-memory.ts

@@ -1,4 +1,4 @@
-import { redactSecretText } from '../debug/log.js';
+import { debug, redactSecretText } from '../debug/log.js';
 import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
 import { listCoordEvents, type CoordEvent } from './coord-events.js';
 
@@ -33,6 +33,14 @@ export interface MemoryDeps {
   decisions?: () => DecisionEntry[];
 }
 
+export type CondenseSkipReason = 'no-seat' | 'no-project' | 'no-topic' | 'no-summary' | 'bad-link' | 'bad-claim' | 'summarize-failed';
+export type CondenseSkipped = Partial<Record<CondenseSkipReason, number>>;
+export interface CondenseWindowReport {
+  cards: MemoryItem[];
+  skipped: CondenseSkipped;
+  folded: number;
+}
+
 const DAY_MS = 86_400_000;
 const oneLine = (text: string) => redactSecretText(text.split(/\r?\n/, 1)[0] ?? '').trim();
 
@@ -43,40 +51,125 @@ export async function condenseContextDay(
   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`;
+  return condenseContextWindow(`${day}T00:00:00.000Z`, new Date(Date.parse(`${day}T00:00:00.000Z`) + DAY_MS).toISOString(), previous, deps, now);
+}
+
+/** Read-only condensation over an exact rolling UTC window; the caller owns any persistence. */
+export async function condenseContextWindow(
+  since: string, until: string, previous: readonly MemoryItem[], deps: MemoryDeps, now: Date = new Date(),
+): Promise<MemoryItem[]> {
+  return (await condenseContextWindowWithReport(since, until, previous, deps, now)).cards;
+}
+
+export async function condenseContextWindowWithReport(
+  since: string, until: string, previous: readonly MemoryItem[], deps: MemoryDeps, now: Date = new Date(),
+): Promise<CondenseWindowReport> {
   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 end = Date.parse(until);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) throw new Error('invalid context window');
+  // Fetch the previous local day as well: the store compares timestamp text rather than instants.
   const events = (deps.events ?? (from => listCoordEvents({ since: from })))(new Date(start - DAY_MS).toISOString());
   const decisions = (deps.decisions ?? (() => new DecisionLedger().list({ status: 'all' })))();
+  const inWindow = (at: string) => {
+    const time = Date.parse(at);
+    return Number.isFinite(time) && time >= start && time < end;
+  };
+  const harnessRuns: Array<{ events: CoordEvent[]; locators: Set<string> }> = [];
+  const earlierStarts: CoordEvent[] = [];
+  const otherEvents: CoordEvent[] = [];
+  let harnessEvents = 0;
+  for (const event of events) {
+    if (!inWindow(event.at)) {
+      const time = Date.parse(event.at);
+      if (event.kind === 'started' && Number.isFinite(time) && time >= start - DAY_MS && time < start) {
+        earlierStarts.push(event);
+      }
+      continue;
+    }
+    // Harness lifecycle = started/finished, or any harness-child event that is not a report (review round 3).
+    const isLifecycle = event.kind === 'started' || event.kind === 'finished'
+      || (event.refs.seat === 'harness-child' && event.kind !== '보고');
+    if (!isLifecycle) {
+      otherEvents.push(event);
+      continue;
+    }
+    harnessEvents++;
+    const locators = new Set([event.refs.source, event.refs.url].filter((ref): ref is string => !!ref));
+    const group = { events: [event], locators };
+    // Either locator can identify the run, including a bridge through a third event.
+    for (let i = 0; i < harnessRuns.length;) {
+      const prior = harnessRuns[i]!;
+      if (locators.size && [...prior.locators].some(ref => locators.has(ref))) {
+        group.events.push(...prior.events);
+        for (const ref of prior.locators) locators.add(ref);
+        harnessRuns.splice(i, 1);
+        i = 0;
+      } else i++;
+    }
+    harnessRuns.push(group);
+  }
+  const eventSource = (event: CoordEvent): MemorySource => ({ kind: 'event', at: event.at, seat: event.refs.seat,
+    text: event.summary, source: event.refs.source ?? event.refs.url ?? `elanous://context/event/${encodeURIComponent(event.id)}` });
+  const foldedSources: MemorySource[] = [];
+  for (const group of harnessRuns) {
+    group.events.sort((a, b) => Date.parse(a.at) - Date.parse(b.at) || a.id.localeCompare(b.id));
+    const finish = group.events.filter(event => event.kind === 'finished').at(-1);
+    const inWindowStart = group.events.find(event => event.kind === 'started');
+    const begin = inWindowStart ?? (finish ? earlierStarts.filter(event =>
+      (group.locators.has(event.refs.source ?? '') || group.locators.has(event.refs.url ?? '')))
+      .sort((a, b) => Date.parse(b.at) - Date.parse(a.at)).at(0) : undefined);
+    const winner = finish ?? inWindowStart ?? group.events.at(-1)!;
+    const frequency = (ref: string) => group.events.filter(event => event.refs.source === ref || event.refs.url === ref).length;
+    const run = [...group.locators].sort((a, b) => frequency(b) - frequency(a))[0] ?? eventSource(winner).source;
+    const duration = finish && begin && Date.parse(finish.at) >= Date.parse(begin.at)
+      ? `${Math.floor((Date.parse(finish.at) - Date.parse(begin.at)) / 60_000)}m ${Math.floor(((Date.parse(finish.at) - Date.parse(begin.at)) % 60_000) / 1_000)}s`
+      : '알 수 없음';
+    const result = finish ? oneLine(finish.summary).replace(/^Harness child finished:\s*/i, '') || '종료'
+      : '진행 중';
+    foldedSources.push({ ...eventSource(winner), seat: winner.refs.seat || begin?.refs.seat || '',
+      source: run, text: `${run} ${result} · ${duration}` });
+  }
+  const folded = harnessEvents - foldedSources.length;
+  try { debug.log('context.condense', 'folded', { harnessEvents, kept: foldedSources.length }); }
+  catch { /* Observation must not stop condensation. */ }
   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)}` })),
+    ...otherEvents.map(eventSource), ...foldedSources,
     ...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));
+  ].filter(source => inWindow(source.at))
+    .sort((a, b) => Date.parse(a.at) - Date.parse(b.at) || a.source.localeCompare(b.source));
 
   const items = new Map<string, MemoryItem>();
+  const skipped: CondenseSkipped = {};
+  let kept = 0;
+  const skip = (reason: CondenseSkipReason, source: MemorySource) => {
+    skipped[reason] = (skipped[reason] ?? 0) + 1;
+    try { debug.log('context.condense', 'source-skipped', { reason, kind: source.kind, at: source.at }); }
+    catch { /* Observation must not stop condensation. */ }
+  };
+  const safeLine = (value: unknown) => typeof value === 'string' ? oneLine(value) : '';
   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 seat = safeLine(source.seat);
+    if (!seat) { skip('no-seat', source); continue; }
+    let summary: MemorySummary;
+    try { summary = await deps.summarize(source); }
+    catch { skip('summarize-failed', source); continue; }
+    const project = safeLine(summary?.project);
+    const topic = safeLine(summary?.topic);
+    const text = safeLine(summary?.summary);
+    const link = safeLine(source.source);
+    if (!project) { skip('no-project', source); continue; }
+    if (!topic) { skip('no-topic', source); continue; }
+    if (!text) { skip('no-summary', source); continue; }
+    if (!/^(?:https?:\/\/|elanous:\/\/)[^\s]+$/.test(link)) { skip('bad-link', source); continue; }
+    const claim = summary.claim && { key: safeLine(summary.claim.key), value: safeLine(summary.claim.value) };
+    if (claim && (!claim.key || !claim.value)) { skip('bad-claim', source); continue; }
+    kept++;
     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.
@@ -103,6 +196,9 @@ export async function condenseContextDay(
       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)
+  const cards = finalItems.sort((a, b) => a.project.localeCompare(b.project) || a.seat.localeCompare(b.seat)
     || a.topic.localeCompare(b.topic));
+  try { debug.log('context.condense', 'window', { sources: sources.length, kept, skipped }); }
+  catch { /* Observation must not stop condensation. */ }
+  return { cards, skipped, folded };
 }

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;
+}
+
+export 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

@@ -884,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 {
@@ -6405,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

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

@@ -273,6 +273,8 @@
 // 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
@@ -422,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;
@@ -1367,6 +1371,26 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
     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

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

package/src/decisions/decision-ledger.ts

@@ -22,11 +22,15 @@ export interface DecisionEntry {
   pendingQuestion?: string;
   /** DEC-TG — optional deadline (UTC). Cards remind the owner two hours before it. */
   dueAt?: string;
+  crossCheck?: Array<{ seat: string; at: string; note: string }>;
+  crossCheckSkipped?: string;
+  alternative?: string;
+  dissent?: string;
   decidedAt?: string; decidedBy?: DecisionActor; choice?: string; note?: string; versionAtDecision?: Versions;
   withdrawnAt?: string; withdrawReason?: string;
   history: Array<{ type: 'raised' | 'options-added' | 'decided' | 'withdrawn'; at?: string; by: string; version?: Versions; choice?: string; reason?: string }>;
 }
-export type RaiseInput = Pick<DecisionEntry, 'title' | 'category' | 'scqa' | 'options' | 'recommendation' | 'raisedBy' | 'refs' | 'dueAt' | 'resume' | 'pendingQuestion'> & { raisedAt?: string };
+export type RaiseInput = Pick<DecisionEntry, 'title' | 'category' | 'scqa' | 'options' | 'recommendation' | 'raisedBy' | 'refs' | 'dueAt' | 'resume' | 'pendingQuestion' | 'crossCheck' | 'crossCheckSkipped' | 'alternative' | 'dissent'> & { raisedAt?: string };
 type Event = { type: 'raised'; entry: DecisionEntry } | { type: 'options-added'; id: string; at: string; options: DecisionOption[]; by: string } | { type: 'decided'; id: string; at?: string; by: DecisionActor; choice?: string; version?: Versions; note?: string } | { type: 'withdrawn'; id: string; at: string; reason: string; version: Versions };
 export interface DecisionLedgerOptions extends VersionOptions { stateDir?: string; now?: () => Date; resolveVersion?: (at: string) => Versions; writeAnswer?: typeof writePendingQuestionAnswer }
 
@@ -89,13 +93,27 @@ function validate(input: RaiseInput, historical = false): RaiseInput {
     ? { skipped: true as const, reason: safe(single(input.recommendation.reason, 'skip reason')) }
     : { option: input.recommendation.option, why: safe(single(input.recommendation.why, 'recommendation why')) };
   if ('option' in recommendation && !options.some(o => o.key === recommendation.option)) throw new Error('recommended option not found');
+  const alternative = input.alternative === undefined ? undefined : single(input.alternative, 'alternative');
+  if (alternative && !options.some(o => o.key === alternative)) throw new Error('alternative option not found');
+  if (alternative && 'option' in recommendation && alternative === recommendation.option) throw new Error('alternative must differ from recommendation');
+  if (input.crossCheck?.length && input.crossCheckSkipped !== undefined) throw new Error('cross-check and skipped reason cannot coexist');
+  if (input.crossCheck !== undefined && !Array.isArray(input.crossCheck)) throw new Error('cross-check must be a list');
+  const crossCheck = input.crossCheck?.map(check => {
+    const seat = single(check.seat, 'cross-check seat');
+    if (!['OP', 'MK', 'TC', 'UX'].includes(seat)) throw new Error('invalid cross-check seat');
+    return { seat, at: utc(check.at), note: safe(single(check.note, 'cross-check note')) };
+  });
+  const crossCheckSkipped = input.crossCheckSkipped === undefined ? undefined : safe(single(input.crossCheckSkipped, 'cross-check skipped reason'));
+  const dissent = input.dissent === undefined ? undefined : safe(single(input.dissent, 'dissent'));
   if (input.resume && !/^(?:auq:[0-9a-z]+:[0-9a-z]{5}|execution:[A-Za-z0-9_-]+:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?![\s\S])/.test(input.resume.questionId)) throw new Error('invalid resume questionId');
   const resume = input.resume ? { questionId: input.resume.questionId,
     ...(input.resume.runId === undefined ? {} : { runId: single(input.resume.runId, 'resume runId') }) } : undefined;
   if (input.pendingQuestion !== undefined) required(input.pendingQuestion, 'pending question');
   return { ...input, title, scqa: { s, c, ...(q ? { q } : {}), ...(a ? { a } : {}) }, options, recommendation,
     ...(input.pendingQuestion === undefined ? {} : { pendingQuestion: safe(input.pendingQuestion) }),
-    ...(resume ? { resume } : {}),
+    ...(resume ? { resume } : {}), ...(crossCheck ? { crossCheck } : {}),
+    ...(crossCheckSkipped !== undefined ? { crossCheckSkipped } : {}),
+    ...(alternative !== undefined ? { alternative } : {}), ...(dissent !== undefined ? { dissent } : {}),
     raisedBy: { agent: safe(single(input.raisedBy.agent, 'agent')), ...(input.raisedBy.track ? { track: input.raisedBy.track } : {}), ...(input.raisedBy.session ? { session: safe(single(input.raisedBy.session, 'session')) } : {}) },
     ...(input.refs ? { refs: input.refs.map(r => safe(single(r, 'ref'))) } : {}),
     ...(input.dueAt ? { dueAt: utc(input.dueAt) } : {}) };
@@ -206,21 +224,29 @@ export class DecisionLedger {
   show(id: string): DecisionEntry { const entry = this.list({ status: 'all' }).find(e => e.id === id); if (!entry) throw new Error(`decision not found: ${id}`); return entry; }
   raise(input: RaiseInput): DecisionEntry {
     const clean = validate(input);
-    return this.locked(() => {
-      const at = utc(clean.raisedAt ?? this.now().toISOString());
-      const day = at.slice(0, 10).replaceAll('-', '');
-      const prefix = `D-${day}-`;
-      let next = 1;
-      for (const entry of this.list({ status: 'all' })) {
-        if (entry.id.startsWith(prefix)) next = Math.max(next, Number(entry.id.slice(prefix.length)) + 1);
-      }
-      const id = `${prefix}${String(next).padStart(2, '0')}`;
-      const version = this.version(at);
-      const entry: DecisionEntry = { ...clean, id, raisedAt: at, version, status: 'open', history: [{ type: 'raised', at, by: clean.raisedBy.agent, version }] };
-      this.append({ type: 'raised', entry });
-      debug.log('decisions', 'raised', { id, category: entry.category, by: entry.raisedBy.agent });
-      return entry;
-    });
+    return this.locked(() => this.raiseLocked(clean));
+  }
+  /** Reuse a card with the same source reference, including across competing raisers. */
+  raiseOnce(input: RaiseInput, ref: string): DecisionEntry {
+    const clean = validate(input);
+    if (!clean.refs?.includes(ref)) throw new Error('decision source reference required');
+    return this.locked(() => this.list({ status: 'all' }).find(entry => entry.refs?.includes(ref)) ?? this.raiseLocked(clean));
+  }
+  private raiseLocked(clean: RaiseInput): DecisionEntry {
+    const at = utc(clean.raisedAt ?? this.now().toISOString());
+    const day = at.slice(0, 10).replaceAll('-', '');
+    const prefix = `D-${day}-`;
+    let next = 1;
+    for (const entry of this.list({ status: 'all' })) {
+      if (entry.id.startsWith(prefix)) next = Math.max(next, Number(entry.id.slice(prefix.length)) + 1);
+    }
+    const id = `${prefix}${String(next).padStart(2, '0')}`;
+    const version = this.version(at);
+    const entry: DecisionEntry = { ...clean, id, raisedAt: at, version, status: 'open', history: [{ type: 'raised', at, by: clean.raisedBy.agent, version }] };
+    this.append({ type: 'raised', entry });
+    debug.log('decisions', 'raised', { id, category: entry.category, by: entry.raisedBy.agent });
+    debug.log('decisions', 'raised-crosscheck', { id, seats: entry.crossCheck?.length ?? 0, skipped: entry.crossCheckSkipped ?? null });
+    return entry;
   }
   /** Record the decision and say whether its answer reached the waiting run (null = the decision resumes nothing). */
   decideWithDelivery(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery } {