elanous 0.2.12 → 0.2.14

package/src/context-bus/condense.ts

@@ -0,0 +1,189 @@
+import { closeSync, constants, 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 { DecisionLedger } from '../decisions/decision-ledger.js';
+import { condenseContextWindowWithReport, readCondenseEvents, type CondenseFunnel, 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);
+
+export interface CondenseReport {
+  since: string;
+  until: string;
+  cards: MemoryItem[];
+  conflicts: number;
+  skipped: CondenseSkipped;
+  funnel: CondenseFunnel;
+  folded: number;
+  droppedHarnessChild: 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' | 'droppedHarnessChild' | 'funnel'>): string {
+  const seats = (counts: Record<string, number>) => ['OP', 'TC', 'MK', 'UX', ...Object.keys(counts).filter(seat => !['OP', 'TC', 'MK', 'UX'].includes(seat)).sort()]
+    .map(seat => `${seat} ${counts[seat] ?? 0}`).join(' · ');
+  const stage = (name: string, value: { total: number; bySeat: Record<string, number> }) =>
+    `${name} ${value.total} (${seats(value.bySeat)})`;
+  const lines = [
+    '# Long-term context memory candidates',
+    '',
+    `Window: ${report.since} → ${report.until} · Cards: ${report.cards.length} · Conflicts: ${report.conflicts}`,
+    `Funnel: ${stage('read', report.funnel.read)} → ${stage('sources', report.funnel.sources)} → ${stage('summarized', report.funnel.summarized)} → ${stage('cards', report.funnel.cards)}`,
+    `Skipped: ${JSON.stringify(report.skipped)} · Dropped harness-child: ${report.droppedHarnessChild}`,
+    '',
+  ];
+  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, droppedHarnessChild, funnel } = await condenseContextWindowWithReport(since, until, [], {
+    summarize: deps.summarize,
+    events: deps.events ?? readCondenseEvents,
+    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, droppedHarnessChild, funnel,
+    markdown: renderCondenseMarkdown({ since, until, cards, conflicts, skipped, droppedHarnessChild, funnel }) };
+  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-public.ts

@@ -0,0 +1,86 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { checkBrand } from '../../scripts/brand/check.js';
+import type { ContextFact, ContextNowAnswer } from './context-now.js';
+
+const internalItem = (count: number) => `내부 항목 ${count}개`;
+const seatNames: Record<string, string> = { OP: '운영', TC: '기술', MK: '마케팅', UX: '사용자 경험' };
+
+/** Public copy only: no raw ledger identifiers or private sources in the rendered answer. */
+export function filterPublicDemoContext(answer: ContextNowAnswer): ContextNowAnswer {
+  const dir = mkdtempSync(join(tmpdir(), 'context-now-public-'));
+  const file = join(dir, 'text.txt');
+  try {
+    const flagged = (texts: string[]): Set<number> => {
+      if (!texts.length) return new Set();
+      writeFileSync(file, texts.map(text => text.replace(/[\r\n]+/g, ' ')).join('\n') + '\n');
+      const result = checkBrand('public-docs', [file]);
+      if (result.missing) throw new Error('brand rules missing');
+      return new Set(result.findings.map(finding => finding.line - 1));
+    };
+    const publicText = (value: string): string => value
+      .replace(/\bhttps?:\/\/[^\s)\]}>]+/gi, '공개 주소')
+      .replace(/\b(?:[\w-]+\.)+[a-z]{2,}(?::\d+)?(?:\/[^\s)\]}>]*)?/gi, '공개 주소')
+      .replace(/(?:\/Users\/|\/home\/|\/root(?=[\/\s)\]}>]|$)|~(?=\/)|\$HOME(?=\/)|\$\{HOME\}(?=\/))[^\s)\]}>]*/g, '공개 경로')
+      .replace(/\b[\w.-]+@(?!공개)[a-z][\w-]*(?=\b|:\d)/gi, '공개 호스트')
+      .replace(/\b(?:run[-_][a-z0-9-]{8,}|[a-f0-9]{8}-[a-f0-9-]{16,})\b/gi, '공개 실행')
+      .replace(/\bPR[\s-]*#?\d+\b|#\d+\b/gi, '공개 변경')
+      .replace(/\b(?:OP|TC|MK|UX)\b/g, seat => seatNames[seat]!)
+      .replace(/\b(host(?:name)?|machine|server)\s*([:=])\s*([a-z][\w-]*)\b/gi, '$1$2 공개 호스트')
+      .replace(/\b(host(?:name)?|machine|server|ssh|scp|rsync|ping|mosh)\s+((?:to|from|into|on|at)\s+)?(?!공개)([a-z][\w-]*)(?=\b|:\d)/gi, '$1 $2공개 호스트')
+      .replace(/\b((?:deploy(?:ed|ing)?|connect(?:ed|ing)?)\s+(?:at|on|to|from))\s+[a-z][\w-]*(?=\b|:\d)/gi, '$1 공개 호스트')
+      .replace(/\b(at|on|to|from)\s+(?:msb\d+|localhost|[a-z][\w-]*\d+)(?=\b|:\d)/gi, '$1 공개 호스트')
+      .replace(/\b(?:msb\d+|node-c|cloud-vm|localhost)\b/gi, '공개 호스트');
+    const safe = (value: string, fallback: string): string => {
+      const text = publicText(value);
+      return flagged([text]).size ? fallback : text;
+    };
+    const source = (value: string) => value.startsWith('elanous://') ? '내부 원장' : safe(value, '공개 출처');
+    const titleFacts = answer.facts.filter((fact): fact is Extract<ContextFact, { kind: 'cell' | 'decision' }> =>
+      fact.kind === 'cell' || fact.kind === 'decision');
+    const privateTitles = flagged(titleFacts.map(fact => fact.title));
+    const privateFacts = new Set(titleFacts.filter((_, index) => privateTitles.has(index)));
+    const privateIds = new Set(titleFacts.filter(fact => privateFacts.has(fact)).map(fact => fact.id));
+    const hasOpenPrivateDecision = titleFacts.some(fact => fact.kind === 'decision' && privateFacts.has(fact) && fact.status === 'open');
+    const publicField = (value: string, fallback: string) => safe(value.replace(/\b(?:K|D)\d+\b/g, id =>
+      privateIds.has(id) ? '내부 항목' : id), fallback);
+    const collapsed = { cell: 0, decision: 0 };
+    const facts: ContextFact[] = [];
+    for (const fact of answer.facts) {
+      if (fact.kind === 'cell' || fact.kind === 'decision') {
+        if (privateFacts.has(fact)) {
+          collapsed[fact.kind]++;
+          continue;
+        }
+        facts.push(fact.kind === 'cell'
+          ? { ...fact, version: safe(fact.version, '공개 판'), id: safe(fact.id, '공개 항목'), title: safe(fact.title, '공개 항목'),
+            status: safe(fact.status, '진행 중'), owner: fact.owner ? safe(fact.owner, '공개 담당') : null, source: source(fact.source) }
+          : { ...fact, id: safe(fact.id, '공개 항목'), title: safe(fact.title, '공개 항목'),
+            status: safe(fact.status, '진행 중'), source: source(fact.source) });
+      } else if (fact.kind === 'seat') {
+        facts.push({ ...fact, seat: safe(fact.seat, '공개 담당'), status: safe(fact.status, '진행 중'),
+          id: fact.id ? (privateIds.has(fact.id) ? '내부 항목' : safe(fact.id, '공개 항목')) : null,
+          title: fact.title ? (privateIds.has(fact.id ?? '') ? '내부 항목' : safe(fact.title, '공개 항목')) : null, source: source(fact.source) });
+      } else facts.push({ ...fact, version: safe(fact.version, '공개 판'), source: source(fact.source) });
+    }
+    for (const kind of ['cell', 'decision'] as const) {
+      if (!collapsed[kind]) continue;
+      const title = internalItem(collapsed[kind]);
+      facts.push(kind === 'cell'
+        ? { kind, version: '공개 판', id: '내부 항목', title, status: '진행 중', owner: null, source: '내부 원장' }
+        : { kind, id: '내부 항목', title, status: hasOpenPrivateDecision ? 'open' : '진행 중', dueAt: null, source: '내부 원장' });
+    }
+    return {
+      at: answer.at,
+      topic: answer.topic === null ? null : publicField(answer.topic, '공개 주제'),
+      facts,
+      events: answer.events.map(event => ({ ...event, kind: safe(event.kind, '소식'),
+        summary: publicField(event.summary, '공개 소식'), source: source(event.source) })),
+      guide: answer.guide.map(text => publicField(text, '공개 안내')),
+      hiddenCount: collapsed.cell + collapsed.decision,
+    };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}

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

@@ -1,4 +1,11 @@
 import { contextNow, type ContextFact, type ContextNowAnswer, type ContextNowDeps } from './context-now.js';
+import { filterPublicDemoContext } from './context-now-public.js';
+
+export type ContextNowAudience = 'operator' | 'user' | 'public-demo';
+const publicSeatNames: Record<string, string> = { OP: '운영', MK: '마케팅', TC: '기술', UX: '사용자 경험' };
+const seatOrder = ['OP', 'MK', 'TC', 'UX'] as const;
+const forAudience = (answer: ContextNowAnswer, audience: ContextNowAudience): ContextNowAnswer =>
+  audience === 'public-demo' ? filterPublicDemoContext(answer) : answer;
 
 export function readSlashContextNow(args: string[], deps?: ContextNowDeps): ContextNowAnswer {
   return contextNow({ topic: args.join(' ').trim() }, deps);
@@ -30,7 +37,8 @@ function factText(fact: ContextFact): string {
   }
 }
 
-export function renderTelegramNow(answer: ContextNowAnswer): string {
+export function renderTelegramNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string {
+  const answer = forAudience(input, audience);
   const rows = [
     ['판', answer.facts.filter(f => f.kind === 'version')],
     ['칸', answer.facts.filter(f => f.kind === 'cell')],
@@ -42,11 +50,25 @@ export function renderTelegramNow(answer: ContextNowAnswer): string {
   return lines.map(line => line.replace(/\s+/g, ' ').trim()).join('\n');
 }
 
-export function renderTuiNow(answer: ContextNowAnswer): string[] {
+export function renderTuiNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string[] {
+  const answer = forAudience(input, audience);
+  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})`,
@@ -56,6 +78,50 @@ export function renderTuiNow(answer: ContextNowAnswer): string[] {
   ];
 }
 
+/** Voice keeps the source-labelled ledger view out of the spoken transcript. */
+export function renderVoiceNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string {
+  const answer = forAudience(input, audience);
+  const spoken = (text: string) => text.replace(/\s+/g, ' ').replace(/[.!?。！？]+/g, ' ').trim();
+  const sentence = (text: string) => `${Array.from(spoken(text)).slice(0, 119).join('').trimEnd()}。`;
+  const seats = seatOrder.flatMap(seat => {
+    const label = audience === 'public-demo' ? publicSeatNames[seat]! : seat;
+    const latest = answer.facts.filter((fact): fact is Extract<ContextFact, { kind: 'seat' }> => fact.kind === 'seat' && (fact.seat === label || (audience === 'public-demo' && fact.seat === seat)))
+      .sort((a, b) => Date.parse(b.at) - Date.parse(a.at))[0];
+    if (!latest) return [];
+    return [`${label} ${Array.from(spoken(latest.title ?? latest.status)).slice(0, 18).join('')}`];
+  });
+  const first = sentence(seats.length ? `지금 ${seats.join(', ')} 중입니다` : '지금 자리 현황은 확인되지 않았습니다');
+  const decision = answer.facts.find(fact => fact.kind === 'decision' && fact.status === 'open');
+  const cell = answer.facts.find(fact => fact.kind === 'cell' && fact.status !== 'done');
+  const shortTitle = (text: string) => Array.from(spoken(text)).slice(0, 75).join('').trimEnd();
+  const next = decision?.kind === 'decision' ? `다음은 ${shortTitle(decision.title)} 결정이 필요합니다`
+    : cell?.kind === 'cell' ? `다음은 ${shortTitle(cell.title)} 칸을 확인해야 합니다`
+      : '다음에 필요한 결정이나 미완료 칸은 확인되지 않았습니다';
+  return `${first} ${sentence(next)}`;
+}
+
+/** A compact card retains the same source-labelled public facts as the other /now surfaces. */
+export function renderCardNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): {
+  title: string;
+  sections: Array<{ label: string; items: Array<{ text: string; source: string }> }>;
+} {
+  const answer = forAudience(input, audience);
+  const kinds = [
+    ['판', 'version'], ['칸', 'cell'], ['결정', 'decision'], ['자리', 'seat'],
+  ] as const;
+  return {
+    title: `지금${answer.topic ? ` · ${answer.topic}` : ''} (${answer.at})`,
+    sections: [
+      ...kinds.map(([label, kind]) => ({
+        label,
+        items: answer.facts.filter(fact => fact.kind === kind).map(fact => ({ text: factText(fact), source: fact.source })),
+      })),
+      { label: '최근', items: answer.events.map(event => ({ text: event.summary, source: event.source })) },
+      { label: '안내', items: answer.guide.map(text => ({ text, source: '' })) },
+    ],
+  };
+}
+
 export function telegramNowSlash(args: string[], deps?: ContextNowDeps): string {
   return renderTelegramNow(readSlashContextNow(args, deps));
 }

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

@@ -5,6 +5,7 @@ import { listChecklist, devVersion, type Checklist } from '../release-loop/check
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { seatDay, seatLedgerPath, type SeatEntry } from '../seat-loop/seat-loop.js';
 import { listCoordEvents, type CoordEvent } from './coord-events.js';
+import { filterPublicDemoContext } from './context-now-public.js';
 
 export type ContextFact =
   | { kind: 'version'; version: string; source: string }
@@ -12,7 +13,7 @@ export type ContextFact =
   | { kind: 'decision'; id: string; title: string; status: string; dueAt: string | null; source: string }
   | { kind: 'seat'; seat: string; at: string; status: string; id: string | null; title: string | null; source: string };
 export type ContextEvent = { at: string; kind: string; summary: string; source: string };
-export type ContextNowAnswer = { at: string; topic: string | null; facts: ContextFact[]; events: ContextEvent[]; guide: string[] };
+export type ContextNowAnswer = { at: string; topic: string | null; facts: ContextFact[]; events: ContextEvent[]; guide: string[]; hiddenCount?: number };
 
 export interface ContextNowDeps {
   now?: () => Date;
@@ -37,7 +38,7 @@ function todaySeatEntries(now: Date): Array<{ entry: SeatEntry; source: string }
 }
 
 /** Read a bounded, source-labelled view of current ledgers, never a transcript or decision body. */
-export function contextNow(options: { topic?: string; limit?: number } = {}, deps: ContextNowDeps = {}): ContextNowAnswer {
+export function contextNow(options: { topic?: string; limit?: number; audience?: 'operator' | 'user' | 'public-demo' } = {}, deps: ContextNowDeps = {}): ContextNowAnswer {
   const now = (deps.now ?? (() => new Date()))();
   const at = `${now.toISOString().slice(0, 16)}:00.000Z`;
   const topic = options.topic?.trim() || null;
@@ -100,5 +101,5 @@ export function contextNow(options: { topic?: string; limit?: number } = {}, dep
     .map(event => `📌 ${event.summary} — ${event.source}`);
   const answer = { at, topic, facts: boundedFacts, events: selectedEvents, guide };
   debug.log('context.now', 'answer', { topic, facts: answer.facts, events: answer.events });
-  return answer;
+  return options.audience === 'public-demo' ? filterPublicDemoContext(answer) : answer;
 }