elanous 0.2.13 → 0.2.14

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,7 +50,8 @@ 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;
@@ -69,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;
 }

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

@@ -1,5 +1,8 @@
+import { Database } from 'bun:sqlite';
+import { existsSync } from 'node:fs';
 import { debug, redactSecretText } from '../debug/log.js';
 import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { surfaceEventsDbPath } from '../domains/surface-events.js';
 import { listCoordEvents, type CoordEvent } from './coord-events.js';
 
 export interface MemoryItem {
@@ -27,23 +30,50 @@ export interface MemorySummary {
   claim?: { key: string; value: string };
 }
 
+type CondenseEvent = CoordEvent & { surface?: string };
+
 export interface MemoryDeps {
   summarize: (source: MemorySource) => Promise<MemorySummary>;
-  events?: (since: string) => CoordEvent[];
+  events?: (since: string) => CondenseEvent[];
   decisions?: () => DecisionEntry[];
 }
 
-export type CondenseSkipReason = 'no-seat' | 'no-project' | 'no-topic' | 'no-summary' | 'bad-link' | 'bad-claim' | 'summarize-failed';
+export type CondenseSkipReason = 'no-seat' | 'no-project' | 'no-topic' | 'no-summary' | 'bad-link' | 'bad-claim' | 'no-claim' | 'summarize-failed';
 export type CondenseSkipped = Partial<Record<CondenseSkipReason, number>>;
+export interface FunnelCount { total: number; bySeat: Record<string, number> }
+export interface CondenseFunnel {
+  read: FunnelCount & { bySurface: Record<string, number> };
+  sources: FunnelCount & { folded: FunnelCount; droppedHarnessChild: FunnelCount; noSeat: FunnelCount };
+  summarized: FunnelCount & { accepted: FunnelCount; summarizeFailed: FunnelCount;
+    skipped: Partial<Record<CondenseSkipReason, FunnelCount>> };
+  collapsed: FunnelCount;
+  cards: FunnelCount & { carried: FunnelCount; supersededByPrevious: FunnelCount };
+}
 export interface CondenseWindowReport {
   cards: MemoryItem[];
+  funnel: CondenseFunnel;
   skipped: CondenseSkipped;
   folded: number;
+  droppedHarnessChild: number;
 }
 
 const DAY_MS = 86_400_000;
 const oneLine = (text: string) => redactSecretText(text.split(/\r?\n/, 1)[0] ?? '').trim();
 
+/** Keep the reader's event selection unchanged; attach surfaces from the same read-only snapshot. */
+export function readCondenseEvents(since: string): CondenseEvent[] {
+  const path = surfaceEventsDbPath();
+  if (!existsSync(path)) return [];
+  const db = new Database(path, { readonly: true, strict: true });
+  try {
+    const surfaces = db.prepare(`SELECT id, surface FROM events
+      WHERE surface IN ('coord:channel', 'context:external', 'context:session') AND direction='outbound' AND ts>=?`)
+      .all(since) as Array<{ id: string; surface: string }>;
+    const byEvent = new Map(surfaces.map(row => [row.id, row.surface]));
+    return listCoordEvents({ since }, { db }).map(event => ({ ...event, surface: byEvent.get(event.id) }));
+  } finally { db.close(); }
+}
+
 /** Condense one UTC day; callers persist the returned snapshot, not raw transcripts. Read-only ledger access. */
 export async function condenseContextDay(
   day: string, previous: readonly MemoryItem[], deps: MemoryDeps, now: Date = new Date(),
@@ -68,27 +98,47 @@ export async function condenseContextWindowWithReport(
   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 events = (deps.events ?? readCondenseEvents)(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 count = (): FunnelCount => ({ total: 0, bySeat: {} });
+  const bump = (bucket: FunnelCount, seat: string | undefined) => {
+    const key = seat || '(unknown)';
+    bucket.total++;
+    bucket.bySeat[key] = (bucket.bySeat[key] ?? 0) + 1;
+  };
+  const funnel: CondenseFunnel = {
+    read: { ...count(), bySurface: {} },
+    sources: { ...count(), folded: count(), droppedHarnessChild: count(), noSeat: count() },
+    summarized: { ...count(), accepted: count(), summarizeFailed: count(), skipped: {} },
+    collapsed: count(), cards: { ...count(), carried: count(), supersededByPrevious: count() },
+  };
   const harnessRuns: Array<{ events: CoordEvent[]; locators: Set<string> }> = [];
   const earlierStarts: CoordEvent[] = [];
   const otherEvents: CoordEvent[] = [];
   let harnessEvents = 0;
+  let droppedHarnessChild = 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) {
+      if (event.kind === 'started' && event.refs.seat !== 'harness-child'
+        && 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 !== '보고');
+    bump(funnel.read, event.refs.seat);
+    const surface = event.surface ?? '(unknown)';
+    funnel.read.bySurface[surface] = (funnel.read.bySurface[surface] ?? 0) + 1;
+    if (event.refs.seat === 'harness-child' && event.kind !== '보고') {
+      droppedHarnessChild++;
+      bump(funnel.sources.droppedHarnessChild, event.refs.seat);
+      continue;
+    }
+    const isLifecycle = event.kind === 'started' || event.kind === 'finished';
     if (!isLifecycle) {
       otherEvents.push(event);
       continue;
@@ -119,6 +169,7 @@ export async function condenseContextWindowWithReport(
       (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)!;
+    for (const event of group.events) if (event !== winner) bump(funnel.sources.folded, event.refs.seat);
     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)
@@ -130,7 +181,7 @@ export async function condenseContextWindowWithReport(
       source: run, text: `${run} ${result} · ${duration}` });
   }
   const folded = harnessEvents - foldedSources.length;
-  try { debug.log('context.condense', 'folded', { harnessEvents, kept: foldedSources.length }); }
+  try { debug.log('context.condense', 'folded', { harnessEvents, kept: foldedSources.length, droppedHarnessChild }); }
   catch { /* Observation must not stop condensation. */ }
   const sources: MemorySource[] = [
     ...otherEvents.map(eventSource), ...foldedSources,
@@ -142,23 +193,41 @@ export async function condenseContextWindowWithReport(
   ].filter(source => inWindow(source.at))
     .sort((a, b) => Date.parse(a.at) - Date.parse(b.at) || a.source.localeCompare(b.source));
 
+  for (const source of sources) {
+    if (typeof source.seat !== 'string' || !oneLine(source.seat)) bump(funnel.sources.noSeat, source.seat);
+    else bump(funnel.sources, source.seat);
+  }
+  for (const decision of decisions) {
+    const at = decision.decidedAt ?? decision.raisedAt ?? decision.importedAt ?? '';
+    if (!inWindow(at)) continue;
+    bump(funnel.read, decision.raisedBy.track ?? 'OP');
+    funnel.read.bySurface['decision:ledger'] = (funnel.read.bySurface['decision:ledger'] ?? 0) + 1;
+  }
+
   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. */ }
+    bump(funnel.summarized.skipped[reason] ??= count(), source.seat);
+    if (reason === 'summarize-failed') bump(funnel.summarized.summarizeFailed, source.seat);
+    try {
+      debug.log('context.condense', 'source-skipped', { reason, kind: source.kind, at: source.at });
+      if (reason === 'no-claim') debug.log('context.condense', 'skipped', { reason, source: source.source });
+    } 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 });
+  const candidateKeys = new Set<string>();
+  const updatedKeys = new Set<string>();
   for (const source of sources) {
     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; }
+    bump(funnel.summarized, source.seat);
     const project = safeLine(summary?.project);
     const topic = safeLine(summary?.topic);
     const text = safeLine(summary?.summary);
@@ -169,14 +238,19 @@ export async function condenseContextWindowWithReport(
     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; }
+    if (source.kind === 'event' && !claim) { skip('no-claim', source); continue; }
     kept++;
+    bump(funnel.summarized.accepted, source.seat);
     const key = keyFor({ project, seat, topic });
+    if (candidateKeys.has(key)) bump(funnel.collapsed, source.seat);
+    else candidateKeys.add(key);
     const old = items.get(key);
     // Equal timestamps are resolved by the source link, so shuffled input does not change the winner.
     if (old && (Date.parse(old.updatedAt) > Date.parse(source.at)
       || (Date.parse(old.updatedAt) === Date.parse(source.at) && old.source >= link))) continue;
     items.set(key, { project, seat, topic, summary: text, source: link, updatedAt: source.at,
       status: 'active', ...(claim ? { claim } : {}) });
+    updatedKeys.add(key);
   }
   const cutoff = now.getTime() - 30 * DAY_MS;
   // Compare only the winning, non-retired assertions; a superseded claim cannot keep a decision candidate alive.
@@ -198,7 +272,14 @@ export async function condenseContextWindowWithReport(
   }
   const cards = finalItems.sort((a, b) => a.project.localeCompare(b.project) || a.seat.localeCompare(b.seat)
     || a.topic.localeCompare(b.topic));
+  for (const card of cards) {
+    bump(funnel.cards, card.seat);
+    if (!candidateKeys.has(keyFor(card))) bump(funnel.cards.carried, card.seat);
+    else if (!updatedKeys.has(keyFor(card))) bump(funnel.cards.supersededByPrevious, card.seat);
+  }
   try { debug.log('context.condense', 'window', { sources: sources.length, kept, skipped }); }
   catch { /* Observation must not stop condensation. */ }
-  return { cards, skipped, folded };
+  try { debug.log('context.condense', 'funnel', funnel); }
+  catch { /* Observation must not stop condensation. */ }
+  return { cards, skipped, folded, droppedHarnessChild, funnel };
 }

package/src/dashboard/index.ts

@@ -593,6 +593,8 @@ import { resolveDashboardChatMainSubmitIntent } from './input/chat-main-submit-r
 import { maybeEmitDashboardSubmitQuickPass } from './input/chat-main-submit-control.js';
 import { attachDashboardQuickPassConsumers } from './input/control-signal-consumers.js';
 import { resolveDashboardChatMainSlashCommand } from './input/chat-main-slash-command.js';
+import { TuiChatPersonaSelection, tuiChatPersonaMessages } from './slash-runtime/chat-persona.js';
+import { awaitGlobalPersonaLoad } from '../persona/global-registry.js';
 import { resolveDashboardChatMainCacheCommand } from './input/chat-main-cache-command.js';
 import {
   dashboardDeltaHelpLines,
@@ -956,6 +958,8 @@ import {
   resetDashboardAcpTurnRef,
 } from './turn-lifecycle-runtime.js';
 import { runDashboardTurnPrelude } from './turn-prelude-runtime.js';
+import { askSeat, deliverSeatAnswers, getTuiSeatAskClientId, parseSeatAsk } from '../seat-dispatch/seat-ask.js';
+import { ceoTaskDeps } from '../seat-dispatch/ceo-intent.js';
 import {
   commitDashboardAssistantRenderState,
   runDashboardTurnTailAutoCopy,
@@ -2136,6 +2140,7 @@ export function renderDashboardFirstScreenBand(input: {
 }
 
 export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<DashboardAction> {
+  await awaitGlobalPersonaLoad().catch(() => {});
   const dashboardQuitConfirmationState = createQuitConfirmationState();
   const signalQuitConfirmationState = createQuitConfirmationState();
   let disposeDashboardEventLoopMonitor = (): void => {};
@@ -2639,6 +2644,19 @@ When a user's request matches an installed skill (they will see a "hint: /run-sk
 Mode- and sync-specific instructions are injected per-turn when relevant — do not assume sync/diff context unless the current turn's Context: block explicitly mentions them.`,
   );
   let chatLines: string[] = []; // chat log — increasingly reserved for transcript / LLM speech
+  const tuiSeatAskClientId = getTuiSeatAskClientId();
+  const tuiSeatAskDeps = {
+    channel: 'tui' as const, clientId: tuiSeatAskClientId,
+    send: async (_origin: import('../seat-dispatch/seat-ask.js').AskOrigin, answer: string) => {
+      chatLines.push(C.info(answer));
+      chatScrollOffset = -1;
+      draw();
+    },
+  };
+  const pollTuiSeatAnswers = (): void => {
+    void deliverSeatAnswers(tuiSeatAskDeps).catch((error) => debug.log('seat.ask', 'delivery-failed', { via: 'tui', error: String(error) }, { level: 'warn' }));
+  };
+  let tuiSeatAskTimer: ReturnType<typeof setInterval> | undefined;
   let debugLines: string[] = [
     C.muted('Dashboard ready. Press / for slash, Ctrl+L for plain input.'),
     C.muted('Debug window ready. Use /debug window open.'),
@@ -3121,6 +3139,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // the laptop left off. `/telegram attach` creates this, `/telegram
   // detach` clears it. Lives for the dashboard lifetime.
   let attachedSessionId: string | null = null;
+  const chatPersonaSelection = new TuiChatPersonaSelection();
+  let chatPersonaConversationId = crypto.randomUUID();
+  const currentChatPersonaSessionId = () => attachedSessionId ?? chatPersonaConversationId;
   let attachedChatId: number | null = null;
   const forkableSessionHistory = (source: ChatMessage[] = chat.history): ForkableSessionTurn[] =>
     flattenForkableSessionHistory(source);
@@ -3134,7 +3155,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       messages: forkableSessionHistory(),
     });
     const prev = attachedSessionId;
+    const selectedPersona = chatPersonaSelection.get(currentChatPersonaSessionId());
     attachedSessionId = forked.meta.id;
+    if (selectedPersona) chatPersonaSelection.set(forked.meta.id, selectedPersona);
     try { _setActive(forked.meta.id); } catch { /* best-effort */ }
     chatLines.push('');
     chatLines.push(prev
@@ -3174,7 +3197,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       messages: forkableSessionHistory(truncatedChat),
     });
     const prev = attachedSessionId;
+    const selectedPersona = chatPersonaSelection.get(currentChatPersonaSessionId());
     attachedSessionId = forked.meta.id;
+    if (selectedPersona) chatPersonaSelection.set(forked.meta.id, selectedPersona);
     try { setActiveForTimetravel(forked.meta.id); } catch { /* best-effort */ }
     // in-memory 히스토리도 동일 경계로 절단 — 스토어와 문맥 일치 보장.
     chat.history.length = 0;
@@ -15522,20 +15547,23 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                 rich: false,
               })
             : [];
-          return buildDashboardTurnPreamble({
-            userText,
-            sessionId,
-            cwd: getSessionCwd(),
-            turnProfile: acpTurnRef.turnProfile,
-            userConfig: getUserConfig(),
-            // Resolved per-turn so a mid-session model switch (codex →
-            // claude or vice-versa) takes effect immediately. Drives the
-            // codex-only behavioral addendum (fix L-1) inside the
-            // universal preamble.
-            modelFamily: getModelFamily(inspectActiveProvider().model),
-            rich: false,
-            enabledTools: tools.map(t => t.name),
-          });
+          return [
+            ...tuiChatPersonaMessages(currentChatPersonaSessionId(), chatPersonaSelection),
+            ...buildDashboardTurnPreamble({
+              userText,
+              sessionId,
+              cwd: getSessionCwd(),
+              turnProfile: acpTurnRef.turnProfile,
+              userConfig: getUserConfig(),
+              // Resolved per-turn so a mid-session model switch (codex →
+              // claude or vice-versa) takes effect immediately. Drives the
+              // codex-only behavioral addendum (fix L-1) inside the
+              // universal preamble.
+              modelFamily: getModelFamily(inspectActiveProvider().model),
+              rich: false,
+              enabledTools: tools.map(t => t.name),
+            }),
+          ];
         },
         getTools: ({ userText }) => {
           const runtime = acpToolRuntime;
@@ -15819,6 +15847,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       observe: (data) => { try { debug.log('dashboard.first-screen-band', 'resolved', data); } catch { /* observation is best-effort */ } },
     });
 
+    tuiSeatAskTimer = setInterval(pollTuiSeatAnswers, 10_000);
+    tuiSeatAskTimer.unref();
+    pollTuiSeatAnswers();
     while (true) {
       draw();
       let wdInputExited = false;   // set true when the input-mode loop exits this iter
@@ -17571,6 +17602,18 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           const cmdText = submitIntent.kind === 'control-turn'
             ? (submitIntent.commandText ?? '')
             : submitIntent.text;
+          if (submitIntent.kind === 'submit-turn' && parseSeatAsk(submitIntent.text)) {
+            try {
+              const receipt = await askSeat(submitIntent.text, { channel: 'tui', clientId: tuiSeatAskClientId },
+                ceoTaskDeps(getUserConfig(), null), tuiSeatAskDeps);
+              chatLines.push(C.info(receipt));
+            } catch (error) {
+              chatLines.push(C.error(`CTO 질문 전송 실패: ${String(error)}`));
+            }
+            chatScrollOffset = -1;
+            draw();
+            continue;
+          }
           if (submitIntent.kind === 'submit-turn' && submitIntent.route === 'sticky-acp') {
             await runDashboardChatMainSubmitIntent({
               submit: createDashboardChatMainTurnSubmit(submitIntent),
@@ -18198,6 +18241,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               },
               getAttachedSessionId: () => attachedSessionId,
               setAttachedSessionId: (id) => { attachedSessionId = id; },
+              chatPersona: {
+                sessionId: currentChatPersonaSessionId,
+                selection: chatPersonaSelection,
+                newConversation: () => { chatPersonaConversationId = crypto.randomUUID(); },
+              },
               getAttachedChatId: () => attachedChatId,
               setAttachedChatId: (id) => { attachedChatId = id; },
               sessionSlash: {
@@ -19010,14 +19058,17 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                     rich: false,
                   })
                 : [];
-              return buildDashboardTurnPreamble({
-                userText: args.userText,
-                cwd: args.cwd,
-                turnProfile: args.turnProfile as SessionTurnProfile,
-                userConfig: args.userConfig,
-                rich: false,
-                enabledTools: tools.map(t => t.name),
-              });
+              return [
+                ...tuiChatPersonaMessages(currentChatPersonaSessionId(), chatPersonaSelection),
+                ...buildDashboardTurnPreamble({
+                  userText: args.userText,
+                  cwd: args.cwd,
+                  turnProfile: args.turnProfile as SessionTurnProfile,
+                  userConfig: args.userConfig,
+                  rich: false,
+                  enabledTools: tools.map(t => t.name),
+                }),
+              ];
             },
             runAutoCompact: async ({ preamble, chatHistory, userMsg }) => {
               const compactMod = await import('../compact/index.js');
@@ -19427,5 +19478,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   } catch (err) {
     closeDashboardTui();
     throw err;
+  } finally {
+    if (tuiSeatAskTimer) clearInterval(tuiSeatAskTimer);
   }
 }