elanous 0.2.12 → 0.2.13

package/src/context-bus/condense.ts

@@ -0,0 +1,194 @@
+import { Database } from 'bun:sqlite';
+import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync } from 'node:fs';
+import { dlopen, FFIType } from 'bun:ffi';
+import { join } from 'node:path';
+import { listMemories, memoryRoot, saveMemory, type MemoryEntry } from '../memory.js';
+import { surfaceEventsDbPath } from '../domains/surface-events.js';
+import { DecisionLedger } from '../decisions/decision-ledger.js';
+import { listCoordEvents } from './coord-events.js';
+import { condenseContextWindowWithReport, type CondenseSkipped, type MemoryDeps, type MemoryItem, type MemorySource, type MemorySummary } from './long-term-memory.js';
+
+const summarize = async (source: MemorySource): Promise<MemorySummary> =>
+  (await import('./nightly-condense.js')).summarize(source);
+
+/** Reuse the context-bus reader against a strictly read-only SQLite handle. */
+function readContextEvents(since: string) {
+  const path = surfaceEventsDbPath();
+  if (!existsSync(path)) return [];
+  const db = new Database(path, { readonly: true, strict: true });
+  try { return listCoordEvents({ since }, { db }); }
+  finally { db.close(); }
+}
+
+export interface CondenseReport {
+  since: string;
+  until: string;
+  cards: MemoryItem[];
+  conflicts: number;
+  skipped: CondenseSkipped;
+  folded: number;
+  markdown: string;
+  applied?: { written: number; retired: number; decisions: string[] };
+}
+
+function mdCell(value: string): string {
+  return value.replaceAll('|', '\\|').replaceAll('\n', ' ');
+}
+
+export function renderCondenseMarkdown(report: Pick<CondenseReport, 'since' | 'until' | 'cards' | 'conflicts' | 'skipped'>): string {
+  const lines = [
+    '# Long-term context memory candidates',
+    '',
+    `Window: ${report.since} → ${report.until} · Cards: ${report.cards.length} · Conflicts: ${report.conflicts}`,
+    `Skipped: ${JSON.stringify(report.skipped)}`,
+    '',
+  ];
+  for (const card of report.cards) {
+    lines.push(`## ${mdCell(card.project)} · ${mdCell(card.seat)} · ${mdCell(card.topic)}`,
+      `- Updated: ${card.updatedAt}`,
+      `- Candidate: ${mdCell(card.summary)}`,
+      `- Source: ${card.source}`);
+    if (card.conflict) lines.push(`- 충돌 (${card.conflict.owner}): ${card.conflict.sources.join(' ↔ ')}`);
+    lines.push('');
+  }
+  return lines.join('\n').trimEnd() + '\n';
+}
+
+type CondenseStore = {
+  list(): MemoryEntry[];
+  save(input: Parameters<typeof saveMemory>[0]): MemoryEntry;
+  raise(input: Parameters<DecisionLedger['raiseOnce']>[0], ref: string): string;
+  withLock<T>(action: () => T): T;
+};
+
+/** Persistent inode in the existing memory directory: all condense writers share one cross-process lock. */
+function withMemoryLock<T>(dir: string, action: () => T): T {
+  mkdirSync(dir, { recursive: true });
+  const libc = process.platform === 'darwin' ? '/usr/lib/libSystem.B.dylib' : process.platform === 'linux' ? 'libc.so.6' : null;
+  if (!libc) throw new Error('context memory locking unavailable on this platform');
+  const lib = dlopen(libc, { flock: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 } });
+  const flock = lib.symbols.flock as (fd: number, op: number) => number;
+  const path = join(dir, '.context-condense.lock');
+  let fd: number | undefined;
+  let acquired = false;
+  try {
+    fd = openSync(path, constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW, 0o600);
+    const stat = fstatSync(fd);
+    const current = lstatSync(path);
+    if (!stat.isFile() || stat.ino !== current.ino || stat.dev !== current.dev || (stat.mode & 0o077) !== 0) {
+      throw new Error('context memory lock must be a private regular file');
+    }
+    const deadline = Date.now() + 10_000;
+    const pause = new Int32Array(new SharedArrayBuffer(4));
+    while (flock(fd, 2 | 4) !== 0) {
+      if (Date.now() >= deadline) throw new Error('context memory lock timed out');
+      Atomics.wait(pause, 0, 0, 10);
+    }
+    acquired = true;
+    const locked = lstatSync(path);
+    if (stat.ino !== locked.ino || stat.dev !== locked.dev) throw new Error('context memory lock changed');
+    return action();
+  } finally {
+    if (fd !== undefined) {
+      try { if (acquired) flock(fd, 8); } finally { closeSync(fd); }
+    }
+    lib.close();
+  }
+}
+
+function defaultStore(root?: string): CondenseStore {
+  const memoryDir = root ? join(root, 'elanous', 'memory') : memoryRoot();
+  const ledger = new DecisionLedger(root ? { stateDir: root } : {});
+  return {
+    list: () => listMemories({}, memoryDir),
+    save: input => saveMemory(input, memoryDir),
+    raise: (input, ref) => ledger.raiseOnce(input, ref).id,
+    withLock: action => withMemoryLock(memoryDir, action),
+  };
+}
+
+function cardKey(card: Pick<MemoryItem, 'project' | 'seat' | 'topic'>): string {
+  return JSON.stringify([card.project, card.seat, card.topic]);
+}
+
+function newestActive(entries: readonly MemoryEntry[]): MemoryEntry | undefined {
+  return entries.reduce<MemoryEntry | undefined>((best, entry) => {
+    const current = entry.contextCard!;
+    const previous = best?.contextCard;
+    return !previous || current.updatedAt > previous.updatedAt
+      || (current.updatedAt === previous.updatedAt && current.source > previous.source)
+      || (current.updatedAt === previous.updatedAt && current.source === previous.source && entry.id > best!.id)
+      ? entry : best;
+  }, undefined);
+}
+
+/** Apply candidate cards through the existing curated memory and decision ledger paths. */
+export function applyCondensedCards(cards: readonly MemoryItem[], store: CondenseStore): NonNullable<CondenseReport['applied']> {
+  const decisions: string[] = [];
+  let written = 0;
+  let retired = 0;
+  for (const card of cards) {
+    if (card.conflict) {
+      const ref = `context-condense:${JSON.stringify([card.project, card.seat, card.topic, card.source, card.updatedAt])}`;
+      decisions.push(store.raise({
+        title: `Context conflict: ${card.project} / ${card.seat} / ${card.topic}`.slice(0, 120),
+        category: 'scope',
+        scqa: { s: `Candidate (${card.updatedAt}): ${card.summary}`.slice(0, 220), c: `Conflicting sources: ${card.conflict.sources.join(' ↔ ')}`.slice(0, 220) },
+        options: [
+          { key: 'a', label: 'Keep the existing claim', consequence: 'Candidate is not stored' },
+          { key: 'b', label: 'Reconcile and apply the new claim', consequence: 'Resolve source disagreement before memory update' },
+        ],
+        recommendation: { skipped: true, reason: 'Conflicting claims require OP judgment' },
+        raisedBy: { agent: 'context-condense', track: 'OP' },
+        refs: [ref, ...card.conflict.sources],
+      }, ref));
+      continue;
+    }
+    if (card.status !== 'active') continue;
+    const applyTopic = () => {
+      const prior = store.list().filter(entry => entry.contextCard?.status === 'active' && cardKey(entry.contextCard) === cardKey(card));
+      const winner = newestActive(prior);
+      const alreadyPresent = prior.some(entry => entry.contextCard!.updatedAt === card.updatedAt && entry.contextCard!.source === card.source);
+      if (!alreadyPresent && (!winner || winner.contextCard!.updatedAt < card.updatedAt
+        || (winner.contextCard!.updatedAt === card.updatedAt && winner.contextCard!.source < card.source))) {
+        store.save({ type: 'project', name: `${card.project} · ${card.seat} · ${card.topic}`,
+          description: card.summary, body: `${card.summary}\n\nSource: ${card.source}\nUpdated: ${card.updatedAt}\n`,
+          contextCard: { project: card.project, seat: card.seat, topic: card.topic, source: card.source, updatedAt: card.updatedAt, status: 'active' } });
+        written++;
+      }
+      const active = store.list().filter(entry => entry.contextCard?.status === 'active' && cardKey(entry.contextCard) === cardKey(card));
+      const keep = newestActive(active);
+      for (const old of active) {
+        if (old.id === keep?.id) continue;
+        store.save({ type: old.type, name: old.name, description: old.description, body: old.body, id: old.id,
+          pinned: false, priority: old.priority, contextCard: { ...old.contextCard!, status: 'retired' } });
+        retired++;
+      }
+    };
+    store.withLock(applyTopic);
+  }
+  return { written, retired, decisions };
+}
+
+/** Produce a rolling-window candidate snapshot; no store is opened for writing in dry-run. */
+export async function runContextCondense(options: {
+  hours: number; apply?: boolean; now?: Date; root?: string;
+}, deps: MemoryDeps = { summarize }, store?: CondenseStore): Promise<CondenseReport> {
+  if (!Number.isSafeInteger(options.hours) || options.hours <= 0 || options.hours > 24 * 30) {
+    throw new Error('--since must be a positive number of hours (at most 720h)');
+  }
+  const now = options.now ?? new Date();
+  const until = now.toISOString();
+  const since = new Date(now.getTime() - options.hours * 3_600_000).toISOString();
+  const { cards, skipped, folded } = await condenseContextWindowWithReport(since, until, [], {
+    summarize: deps.summarize,
+    events: deps.events ?? readContextEvents,
+    decisions: deps.decisions ?? (() => new DecisionLedger(options.root ? { stateDir: options.root } : {}).list({ status: 'all' })
+      .filter(decision => decision.raisedBy.agent !== 'context-condense')),
+  }, now);
+  const conflicts = cards.filter(card => card.conflict !== undefined).length;
+  const report: CondenseReport = { since, until, cards, conflicts, skipped, folded,
+    markdown: renderCondenseMarkdown({ since, until, cards, conflicts, skipped }) };
+  if (options.apply === true) report.applied = applyCondensedCards(cards, store ?? defaultStore(options.root));
+  return report;
+}

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

@@ -0,0 +1,82 @@
+import { Database } from 'bun:sqlite';
+import { existsSync } from 'node:fs';
+import { surfaceEventsDbPath } from '../domains/surface-events.js';
+
+export const CONTEXT_DAY_SOURCES = ['OP', 'TC', 'MK', 'UX', 'claude-code', 'codex-agent-mission', 'harness-child'] as const;
+export type ContextDaySource = typeof CONTEXT_DAY_SOURCES[number];
+export type ContextDayKind = 'task-claimed' | 'done' | 'asked' | 'guidance-changed';
+export interface ContextDayRow {
+  source: ContextDaySource;
+  counts: Record<ContextDayKind, number>;
+  lastAt: string | null;
+  status: '들어옴' | '안 들어옴';
+}
+export interface ContextDayReport { since: string; until: string; rows: ContextDayRow[] }
+
+/** Reject malformed windows instead of silently changing the time range being judged. */
+export function contextDayHours(since: string): number {
+  if (!/^[1-9]\d*h$/.test(since)) throw new Error('--since requires positive hours, e.g. 24h');
+  const hours = Number(since.slice(0, -1));
+  if (!Number.isSafeInteger(hours) || hours * 3_600_000 > 8.64e15) throw new Error('--since is out of range');
+  return hours;
+}
+
+function kindFor(surface: string, kind: string): ContextDayKind | null {
+  if (surface === 'context:external') {
+    if (kind === 'started' || kind === 'claimed') return 'task-claimed';
+    if (kind === 'finished' || kind === 'done') return 'done';
+    if (kind === 'guide-changed') return 'guidance-changed';
+  }
+  if (kind === 'task-claimed' || kind === 'claimed') return 'task-claimed';
+  if (kind === 'task-done' || kind === 'done') return 'done';
+  if (kind === 'asked' || (surface === 'coord:channel' && kind === '요청')) return 'asked';
+  if (kind === 'guidance-changed' || kind === 'guide-changed') return 'guidance-changed';
+  return null;
+}
+
+/** Read only the context journal, not recallEvents (which mutates recall counts) or the writable DB opener. */
+export function contextDay(since = '24h', deps: { now?: () => Date; dbPath?: string } = {}): ContextDayReport {
+  const hours = contextDayHours(since);
+  const now = (deps.now ?? (() => new Date()))();
+  const until = now.toISOString();
+  const from = new Date(now.getTime() - hours * 3_600_000).toISOString();
+  const rows: ContextDayRow[] = CONTEXT_DAY_SOURCES.map(source => ({
+    source, counts: { 'task-claimed': 0, done: 0, asked: 0, 'guidance-changed': 0 }, lastAt: null, status: '안 들어옴',
+  }));
+  const bySource = new Map(rows.map(row => [row.source, row]));
+  const path = deps.dbPath ?? surfaceEventsDbPath();
+  if (!existsSync(path)) return { since: from, until, rows };
+  const db = new Database(path, { readonly: true });
+  try {
+    const events = db.prepare(`SELECT surface, kind, ts, refs FROM events
+      WHERE surface IN ('coord:channel', 'context:session', 'context:external')
+        AND direction='outbound' AND ts>=? AND ts<=? ORDER BY ts ASC`).all(from, until) as Array<{
+      surface: string; kind: string; ts: string; refs: string | null;
+    }>;
+    for (const event of events) {
+      let refs: { seat?: unknown; origin?: unknown };
+      try { refs = JSON.parse(event.refs ?? '{}') as typeof refs; } catch { continue; }
+      const source = event.surface === 'context:external' ? refs.origin : refs.seat;
+      if (typeof source !== 'string') continue;
+      const row = bySource.get(source as ContextDaySource);
+      if (!row) continue;
+      // Do not attribute an external hook to a seat (or a seat event to an external origin).
+      if ((event.surface === 'context:external') !== (rows.indexOf(row) >= 4)) continue;
+      row.lastAt = event.ts;
+      row.status = '들어옴';
+      const kind = kindFor(event.surface, event.kind);
+      if (kind) row.counts[kind]++;
+    }
+  } finally { db.close(); }
+  return { since: from, until, rows };
+}
+
+export function renderContextDay(report: ContextDayReport): string {
+  return [
+    `맥락 이벤트 ${report.since} ~ ${report.until} (UTC)`,
+    '| 출처 | task-claimed | done | asked | guidance-changed | 마지막 시각 (UTC) | 상태 |',
+    '| --- | ---: | ---: | ---: | ---: | --- | --- |',
+    ...report.rows.map(row => `| ${row.source} | ${row.counts['task-claimed']} | ${row.counts.done} | ${row.counts.asked} | ${row.counts['guidance-changed']} | ${row.lastAt ?? '—'} | ${row.status} |`),
+    '안 들어옴 = 이 시간 창에서 해당 출처 이벤트 0건 (Claude Code 훅 미설치 가능성; 설치 여부는 미확인). 카운트 열은 네 종류만 셈.',
+  ].join('\n');
+}

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

@@ -43,10 +43,23 @@ export function renderTelegramNow(answer: ContextNowAnswer): string {
 }
 
 export function renderTuiNow(answer: ContextNowAnswer): string[] {
+  const shortText = (text: string) => {
+    const characters = Array.from(text);
+    return characters.length > 100 ? `${characters.slice(0, 100).join('')}…` : text;
+  };
+  const shortSource = (source: string) => {
+    if (/^https?:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+#issuecomment-/.test(source)) return '채널';
+    if (source.startsWith('elanous://release/')) return '원장';
+    return Array.from(source).slice(0, 40).join('');
+  };
+  const factLabels = { version: '판', cell: '칸', decision: '결정', seat: '자리' } as const;
+  const eventLabels: Record<string, string> = { report: '보고', dispatch: '발사', decision: '결정' };
+  const events = answer.events.slice().sort((a, b) => Date.parse(b.at) - Date.parse(a.at));
   const rows = [
-    ...answer.facts.map(f => [f.kind, factText(f), f.source]),
-    ...answer.events.map(e => [e.kind, e.summary, e.source]),
+    ...answer.facts.map(f => [factLabels[f.kind], shortText(factText(f)), shortSource(f.source)]),
+    ...events.slice(0, 8).map(e => [eventLabels[e.kind] ?? '소식', shortText(e.summary), shortSource(e.source)]),
     ...answer.guide.map(guide => ['안내', guide, '']),
+    ...(events.length > 8 ? [['안내', `… 사건 ${events.length - 8}개 더(/now <주제> 로 좁히기)`, '']] : []),
   ];
   return [
     `지금${answer.topic ? ` · ${answer.topic}` : ''} (${answer.at})`,

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

@@ -64,7 +64,7 @@ function storedItems(root: string): MemoryItem[] {
   return items;
 }
 
-async function summarize(source: MemorySource, injected?: Record<string, MemorySummary>): Promise<MemorySummary> {
+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}`);

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 } {