elanous 0.2.12 → 0.2.14

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

@@ -1,5 +1,8 @@
-import { redactSecretText } from '../debug/log.js';
+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,15 +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' | '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(),
@@ -43,47 +81,176 @@ 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 events = (deps.events ?? (from => listCoordEvents({ since: from })))(new Date(start - DAY_MS).toISOString());
+  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 ?? 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' && event.refs.seat !== 'harness-child'
+        && Number.isFinite(time) && time >= start - DAY_MS && time < start) {
+        earlierStarts.push(event);
+      }
+      continue;
+    }
+    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;
+    }
+    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)!;
+    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)
+      ? `${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, droppedHarnessChild }); }
+  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));
+
+  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;
+    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 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; }
+    bump(funnel.summarized, source.seat);
+    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; }
+    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.
@@ -103,6 +270,16 @@ 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));
+  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. */ }
+  try { debug.log('context.condense', 'funnel', funnel); }
+  catch { /* Observation must not stop condensation. */ }
+  return { cards, skipped, folded, droppedHarnessChild, funnel };
 }

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/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);
   }
 }

package/src/dashboard/slash-runtime/chat-persona.ts

@@ -0,0 +1,66 @@
+import { awaitGlobalPersonaLoad, getGlobalPersonaRegistry } from '../../persona/global-registry.js';
+import { resolvePersonaAddress } from '../../intake-plane/persona-answer.js';
+import { loadSession, updateSessionMeta } from '../../session/index.js';
+import { assemblePersonaPrompt } from '../../persona/prompt-assembler.js';
+import type { LLMMessage } from '../../llm.js';
+
+/** Unattached conversations use a dashboard-local id; attached sessions use persisted metadata. */
+export class TuiChatPersonaSelection {
+  private readonly selected = new Map<string, string>();
+
+  get(sessionId: string): string | undefined {
+    return loadSession(sessionId)?.meta.chatPersonaId ?? this.selected.get(sessionId);
+  }
+
+  set(sessionId: string, personaId: string | undefined): void {
+    const meta = updateSessionMeta(sessionId, (m) => {
+      if (personaId) m.chatPersonaId = personaId;
+      else delete m.chatPersonaId;
+    });
+    if (!meta) {
+      if (personaId) this.selected.set(sessionId, personaId);
+      else this.selected.delete(sessionId);
+    } else {
+      this.selected.delete(sessionId);
+    }
+  }
+}
+
+export async function handleTuiChatPersona(
+  args: readonly string[], sessionId: string,
+  selection: TuiChatPersonaSelection,
+): Promise<string> {
+  if (args[0] === '-') {
+    if (args.length !== 1) return '쓰는 법: /persona [이름|-]';
+    selection.set(sessionId, undefined);
+    return '이 대화의 페르소나를 뺐습니다';
+  }
+  try {
+    await awaitGlobalPersonaLoad();
+    const registry = getGlobalPersonaRegistry();
+    if (!args.length) {
+      const selected = selection.get(sessionId);
+      const personas = registry.list().sort((a, b) => a.displayName.localeCompare(b.displayName));
+      const current = personas.find(p => p.personaId === selected);
+      return `이 대화의 페르소나: ${current ? `${current.displayName} (${current.personaId})` : '없음'}\n고를 수 있는 페르소나: ${personas.map(p => `${p.displayName} (${p.personaId})${p.personaId === selected ? ' (지금)' : ''}`).join(' · ') || '없음'}\n고르기: /persona <이름> · 빼기: /persona -`;
+    }
+    const name = args.join(' ');
+    const persona = resolvePersonaAddress(name, registry);
+    if (!persona) return `그런 페르소나가 없습니다: ${name}`;
+    selection.set(sessionId, persona.personaId);
+    return `${persona.displayName} 페르소나를 이 대화에 골랐습니다`;
+  } catch {
+    return '페르소나 목록을 읽지 못했습니다';
+  }
+}
+
+export function tuiChatPersonaMessages(
+  sessionId: string, selection: TuiChatPersonaSelection,
+): LLMMessage[] {
+  const id = selection.get(sessionId);
+  if (!id) return [];
+  const persona = getGlobalPersonaRegistry().get(id);
+  if (!persona) return [];
+  const prompt = assemblePersonaPrompt(persona, '').systemPrompt;
+  return prompt ? [{ role: 'system', content: prompt }] : [];
+}