elanous 0.2.28 → 0.2.31

package/src/dashboard/slash-runtime/help-from-registry.ts

@@ -16,7 +16,8 @@ const ESSENTIAL_KEYS = [
   ['Home / End', 'Move to start / end of line'],
   ['Ctrl+A / E', 'Move to start / end of line'],
   ['PgUp / PgDn', 'Scroll chat log'],
-  ['Ctrl+↑', 'Recall a queued line (Enter while answering queues it)'],
+  // 10-14 — 줄 수는 그대로(행 예산) · 큐는 다음 도구 경계에 들어가고, 빈 Enter 가 «지금 밀어 넣기»다.
+  ['Ctrl+↑', 'Recall all queued lines (Enter while answering queues · empty Enter pushes now)'],
 ] as const;
 
 function fitLine(text: string, width: number): string {

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

@@ -13,3 +13,16 @@ export {
   type SkillToolSlashExecutor,
   type SkillToolSlashResult,
 } from './dashboard-handlers.js';
+// TUI-SLASH-SPLIT-MISSION(D4b) — 새 집 src/tui/slash/mission.ts 의 공개 심볼을 옛 입구에서도 낸다(re-export shim · RFC A5).
+export {
+  handleMissionSlash,
+  registerMissionSlash,
+  type MissionSlashContext,
+} from '../../tui/slash/mission.js';
+// TUI-SLASH-SPLIT-TERM(D4b) — 새 집 src/tui/slash/term.ts 의 공개 심볼을 옛 입구에서도 낸다(re-export shim · RFC A5).
+export {
+  handleTermSlash,
+  registerTermSlash,
+  type TermSlashContext,
+  type TermSlashHost,
+} from '../../tui/slash/term.js';

package/src/dashboard/slash-runtime/model-choices.ts

@@ -123,3 +123,38 @@ export function modelChangeLine(
   const providerNote = resolution.target.provider === before.provider ? '' : `  · provider ${resolution.target.provider}`;
   return `모델: ${currentLabel(before.provider, before.model, before.reasoning)} → ${after} (${resolution.target.model}${reasoningNote})${providerNote}`;
 }
+
+/** `/model` arguments: the choice word plus the `--global` flag (TUI-MODEL-SESSION-SCOPE · 10-14). */
+export function parseModelSlashArgs(args: readonly string[]): { arg: string; global: boolean } {
+  const global = args.some((a) => a.trim().toLowerCase() === '--global');
+  const arg = args.find((a) => !a.trim().startsWith('--'))?.trim().toLowerCase() ?? '';
+  return { arg, global };
+}
+
+/**
+ * Where a `/model` choice lands. The default is this TUI session only (a pin that the next turn sends as an
+ * explicit model, so it beats the Codex tier policy); `--global` writes config. A choice on another provider
+ * can't be a session pin — the turn carries a model, not a provider — so it needs `--global`.
+ */
+export function modelSwitchScope(
+  targetProvider: LLMProviderName,
+  currentProvider: LLMProviderName,
+  global: boolean,
+): 'session' | 'global' | 'needs-global' {
+  if (global) return 'global';
+  return targetProvider === currentProvider ? 'session' : 'needs-global';
+}
+
+/** The muted line under a switch: what scope it took and when it applies — no promise the code doesn't keep. */
+export function modelScopeLine(
+  scope: 'session' | 'global',
+  reasoning?: { tier: ReasoningLevel; current: ReasoningLevel },
+): string {
+  const where = scope === 'session'
+    ? '  └─ 이 세션만 · 다음 턴부터 · 설정 파일은 그대로 (전역은 /model <이름> --global · 해제 /model reset)'
+    : '  └─ 설정 파일(전역)에 저장 · 이 세션은 다음 턴부터 · 다른 세션은 그 세션의 routePolicy 를 따른다 (codex 기본 정책이면 단계 모델이 이긴다)';
+  const think = reasoning && reasoning.tier !== reasoning.current
+    ? ` · 생각 깊이는 그대로 ${reasoning.current} (이 단계는 ${reasoning.tier} — /reasoning ${reasoning.tier})`
+    : '';
+  return where + think;
+}

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

@@ -1,3 +1,17 @@
+import { resolve } from 'node:path';
+
+/** The workdir is the source of truth for a seat shell; env is only a fallback. */
+export function resolveTuiShellSeat(cwd: string, coordId?: string): string {
+  const parts = resolve(cwd).split(/[\\/]/);
+  const seatIndex = parts.lastIndexOf('seats');
+  const fromPath = seatIndex >= 0 ? parts[seatIndex + 1] : undefined;
+  const valid = (value: string | undefined): value is string =>
+    value !== undefined && /^[A-Za-z0-9_-]{1,64}$/.test(value);
+  if (valid(fromPath)) return fromPath;
+  const fromEnv = coordId?.trim();
+  return valid(fromEnv) ? fromEnv : 'unknown';
+}
+
 export interface DashboardPersistedSessionEntry {
   id: string;
   title: string;
@@ -109,6 +123,7 @@ export function createDashboardTermSlashRuntime(
       '',
       deps.accent('\u276f /term'),
       deps.muted('Usage:'),
+      deps.muted('  /term new [command]       Open a shell PTY (Ctrl+Shift+T or Alt+T).'),
       deps.muted('  /term list                List all alive sessions (fg / bg / exited).'),
       deps.muted('  /term attach <id>         Bring a backgrounded session to foreground.'),
       deps.muted('  /term detach              Send foreground session to background (PTY survives).'),

package/src/dashboard/turn-busy-teardown.ts

@@ -0,0 +1,50 @@
+// ── 턴 busy 표지 마감 (TUI-STALE-BUSY-MARKER · 0.2.31 · tui-op-issues #36·#37·#45·#54·#55·#58) ──
+//
+// S: 턴이 시작되면 `streamingInFlight = true` ⊕ `reportTuiTurn('busy')` 가 켜지고, 마감 closure 가
+//    끄기 전까지 외부 입력 대기열(`isTurnActive`)·`eln pty state` 는 «바쁨»으로 본다.
+// C: 마감 closure 안의 한 단계가 던지면(10-14 «✘ 실패 line.startsWith») 끄는 줄에 못 닿아 70분+ busy 가 남았다.
+//    #27721 이 settle 단계 하나를 try/finally 로 감쌌지만, 그 «앞» 단계(키 리스너 떼기 · ESC 게이트 정리)는
+//    여전히 맨몸이었다 — 거기서 던지면 키 층은 유휴(리스너 떨어짐)·턴 층은 busy 인 이원 판정이 그대로 재현된다.
+//    그리고 실패는 `dashboard.turn settle-failed` 한 곳에서만 보였다(#58 — 턴 본문 실패는 tui 범주 0).
+// A: 마감 단계마다 이 함수로 격리해 «다음 단계 ⊕ idle 전이»가 반드시 돌게 하고,
+//    던진 것은 한 범주 `tui.turn turn-threw {error, phase}` 로 남긴다.
+
+import { debug, redactSecretText } from '../debug/log.js';
+
+/** 4번째 인자로 `{ level: 'warn' }` 를 받는다 — 주입 기록기도 warn 수준을 그대로 넘겨야 한다(#58). */
+export type TurnThrewLog = (
+  category: string,
+  event: string,
+  payload: Record<string, unknown>,
+  opts?: { level?: 'warn' },
+) => void;
+
+const ERROR_HEAD_CHARS = 200;
+
+const warnLog: TurnThrewLog = (category, event, payload, opts) => debug.log(category, event, payload, opts);
+
+/** 턴 경로에서 던진 것을 한 범주로 남긴다(warn — #58 «warn/error 0» 의 몫). 관측 실패가 턴 마감을 막지 않는다. */
+export function logTurnThrew(phase: string, err: unknown, log: TurnThrewLog = warnLog): void {
+  try {
+    const message = err instanceof Error ? err.message : String(err);
+    const stackHead = err instanceof Error
+      ? err.stack?.split('\n').slice(1, 3).map((line) => line.trim()).join(' | ')
+      : undefined;
+    log('tui.turn', 'turn-threw', {
+      error: redactSecretText(message).slice(0, ERROR_HEAD_CHARS),
+      phase,
+      ...(stackHead ? { stackHead: redactSecretText(stackHead) } : {}),
+    }, { level: 'warn' });
+  } catch { /* fail-soft — 관측이 마감을 막지 않는다 */ }
+}
+
+/** 턴 마감의 한 단계 — 던져도 삼키고 `turn-threw` 로 남긴다. 다음 단계·idle 전이는 계속 돈다. */
+export function runTurnTeardownStep(phase: string, step: () => void, log?: TurnThrewLog): boolean {
+  try {
+    step();
+    return true;
+  } catch (err) {
+    logTurnThrew(phase, err, log);
+    return false;
+  }
+}

package/src/dashboard/turn-preamble.ts

@@ -18,6 +18,7 @@ import type { ModelFamily } from '../models/prompts.js';
 import { debug } from '../debug/log.js';
 import type { NativeToolCatalogEntry } from '../native-tool-catalog.js';
 import { buildUniversalPreamble } from '../prompt-library/universal-preamble.js';
+import { buildSeatBootSystemMessages, type SeatBootDeps } from './seat-boot-preamble.js';
 import { buildPlanModeSystemMessages } from '../plan-mode/system-prompt.js';
 import { buildImplDisciplineSystemMessages } from '../impl-discipline/index.js';
 import { buildConcisenessSystemMessages } from '../prompt-library/chat-conciseness.js';
@@ -29,7 +30,8 @@ import {
 import { buildExecutionAskSystemMessages } from '../ask-user-question/index.js';
 import { buildApprovalPolicySystemMessages } from '../code-edit/index.js';
 import { buildSandboxEscalationSystemMessages } from '../shell-primitive/index.js';
-import { elanousSelfAccessPrompt, elanousSelfAmbientParts } from '../agent/self-ambient.js';
+import { elanousSelfAccessPrompt, investigationRecallAmbient } from '../agent/self-ambient.js';
+import { sessionMemoryLayer, sessionSelfAmbientParts } from './turn-session-layers.js';
 import { localRefGroundingAmbient } from '../agent/ref-grounding.js';
 import {
   globalTaskNotificationQueue,
@@ -66,9 +68,14 @@ export interface DashboardTurnPreambleContext {
    *  one-liner directives (e.g. AskUserQuestion → use for tool-deny
    *  clarification). Pass `tools.map(t => t.name)` from the caller. */
   enabledTools?: readonly string[];
+  /** 🪪 L1 자리 부트 카드를 싣나(`seat-boot-preamble.ts`). 대화형 TUI 호출부만 켠다 — 기본 꺼짐이라
+   *  다른 호출부·시험은 셸의 `COORD_ID` 에 따라 출력이 갈리지 않는다. */
+  seatBoot?: boolean | SeatBootDeps;
   /** Explicit controller provenance for tests and embedded callers. When
    *  omitted, the controller environment is used. */
   controlEnv?: { controller?: string; channels?: string };
+  /** File-memory layer seam: a store root and env for scope resolution (tests), or false to omit it. */
+  memory?: { root?: string; env?: NodeJS.ProcessEnv } | false;
 }
 
 export function buildControllerSystemMessage(controller: string, channels?: string): LLMMessage {
@@ -91,10 +98,22 @@ export function buildDashboardTurnPreamble(
     ...(ctx.modelFamily !== undefined ? { modelFamily: ctx.modelFamily } : {}),
     ...(ctx.enabledTools !== undefined ? { enabledTools: ctx.enabledTools } : {}),
   });
+  // 🪪 L1 — 자리 부트 카드(세션마다 한 번 만든 스냅샷). 정체성(앵커) 바로 뒤. 자리가 아니면 [].
+  const seatBootSystemMsgs = ctx.seatBoot
+    ? buildSeatBootSystemMessages(
+      { cwd: ctx.cwd, ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}) },
+      ctx.seatBoot === true ? {} : ctx.seatBoot,
+    )
+    : [];
   const planModeSystemMsgs = buildPlanModeSystemMessages();
   const askSystemMsgs = buildExecutionAskSystemMessages() as LLMMessage[];
   const approvalSystemMsgs = buildApprovalPolicySystemMessages() as LLMMessage[];
   const sandboxSystemMsgs = buildSandboxEscalationSystemMessages() as LLMMessage[];
+  // Session-scoped (built once, rebuilt on change) — see turn-session-layers.ts.
+  const sessionKey = ctx.sessionId ?? 'tui';
+  const memorySystemMsgs = ctx.memory === false
+    ? []
+    : sessionMemoryLayer({ sessionKey, cwd: ctx.cwd, ...(ctx.memory ?? {}) });
   const gitSnapshotSystemMsgs = buildSessionRuntimeSystemMessages({
     cwd: ctx.cwd,
   });
@@ -137,7 +156,12 @@ export function buildDashboardTurnPreamble(
   //   성립한다. fail-soft: ambient 조회 실패가 턴을 막지 않는다.
   let selfOpsSystemMsgs: LLMMessage[] = [];
   try {
-    selfOpsSystemMsgs = [elanousSelfAccessPrompt(ctx.sessionId), ...elanousSelfAmbientParts(ctx.userText), localRefGroundingAmbient(ctx.userText)]
+    selfOpsSystemMsgs = [
+      elanousSelfAccessPrompt(ctx.sessionId),
+      ...sessionSelfAmbientParts(sessionKey),
+      investigationRecallAmbient(ctx.userText),
+      localRefGroundingAmbient(ctx.userText),
+    ]
       .filter(Boolean)
       .map((content): LLMMessage => ({ role: 'system', content }));
   } catch { /* fail-soft */ }
@@ -150,10 +174,12 @@ export function buildDashboardTurnPreamble(
     : [];
   const preamble = [
     ...universalPreamble,
+    ...seatBootSystemMsgs,
     ...planModeSystemMsgs,
     ...askSystemMsgs,
     ...approvalSystemMsgs,
     ...sandboxSystemMsgs,
+    ...memorySystemMsgs,
     ...gitSnapshotSystemMsgs,
     ...surfaceSystemMsgs,
     ...selfOpsSystemMsgs,
@@ -190,10 +216,12 @@ export function buildDashboardTurnPreamble(
       rich: ctx.rich === true,
       builderCounts: {
         universal: universalPreamble.length,
+        seatBoot: seatBootSystemMsgs.length,
         planMode: planModeSystemMsgs.length,
         ask: askSystemMsgs.length,
         approval: approvalSystemMsgs.length,
         sandbox: sandboxSystemMsgs.length,
+        memory: memorySystemMsgs.length,
         gitSnapshot: gitSnapshotSystemMsgs.length,
         surface: surfaceSystemMsgs.length,
         selfOps: selfOpsSystemMsgs.length,

package/src/dashboard/turn-session-layers.ts

@@ -0,0 +1,176 @@
+// TUI-SEAT-MEMORY-SCOPE (RFC-tui-self-awareness L2 ①③) — the TUI turn preamble's session layers.
+//
+// ① File memory: until now only chat.ts (telegram · discord · repl · a2a) injected buildMemoryInjection;
+//    the TUI preamble had no memory layer at all. Here it does, scoped to global ⊕ this seat/project:
+//    a context card tagged with another seat (or another project) is left out — index line included.
+// ③ Injection cadence: the preamble is rebuilt every turn, but these layers are not. They are built once
+//    per session and rebuilt only when their source changed (file signature for memory, a short TTL
+//    plus content hash for self ambient). Unchanged layers come back byte-identical, which keeps the
+//    provider's prompt-cache prefix and skips the per-turn store reads.
+//
+// Both layers are fail-soft: an error drops the layer (observed), it never blocks the turn.
+
+import { createHash } from 'node:crypto';
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import type { LLMMessage } from '../llm.js';
+import { debug } from '../debug/log.js';
+import { buildMemoryInjection, memoryRoot, type MemoryEntry } from '../memory.js';
+import { elanousSelfAmbientParts } from '../agent/self-ambient.js';
+
+/** Token budget for the TUI memory layer — the same default chat.ts gives buildMemoryInjection. */
+export const TUI_MEMORY_BUDGET_TOKENS = 1500;
+/** How long cached self ambient is trusted before the stores are read again. */
+export const SELF_AMBIENT_TTL_MS = 60_000;
+/** Sessions remembered per cache; the least recently used one is dropped beyond this. */
+export const SESSION_LAYER_CACHE_MAX = 32;
+
+export interface MemoryScope {
+  seat?: string;
+  project?: string;
+}
+
+/** This session's seat: `/seats/<seat>` in the cwd first, then COORD_ID. Project comes only from
+ *  ELANOUS_PROJECT — a path guess would silently drop cards whose project string does not match it. */
+export function resolveMemoryScope(cwd: string, env: NodeJS.ProcessEnv = process.env): MemoryScope {
+  const fromCwd = /(?:^|\/)seats\/([^/]+)/.exec(cwd)?.[1]?.trim();
+  const seat = fromCwd || env.COORD_ID?.trim() || undefined;
+  const project = env.ELANOUS_PROJECT?.trim() || undefined;
+  return { ...(seat ? { seat } : {}), ...(project ? { project } : {}) };
+}
+
+const same = (a: string, b: string): boolean => a.trim().toLowerCase() === b.trim().toLowerCase();
+
+/** Global memories (no context card, or a card with an empty seat) stay. A card tagged with a seat
+ *  stays only for that seat; a card tagged with a project is dropped only when the scope names another one. */
+export function memoryInScope(entry: MemoryEntry, scope: MemoryScope): boolean {
+  const card = entry.contextCard;
+  if (!card) return true;
+  if (card.seat.trim() && !(scope.seat && same(card.seat, scope.seat))) return false;
+  if (card.project.trim() && scope.project && !same(card.project, scope.project)) return false;
+  return true;
+}
+
+/** This seat's own cards are injected in full, like pinned memories. */
+export function isSeatCard(entry: MemoryEntry, scope: MemoryScope): boolean {
+  const seat = entry.contextCard?.seat.trim();
+  return Boolean(seat && scope.seat && same(seat, scope.seat));
+}
+
+/** Cheap change signal for the file store: names, sizes and mtimes of its markdown files. */
+export function memoryStoreSignature(root: string): string {
+  let names: string[];
+  try { names = readdirSync(root).filter(name => name.endsWith('.md')).sort(); }
+  catch { return 'missing'; }
+  const hash = createHash('sha256');
+  for (const name of names) {
+    try {
+      const st = statSync(join(root, name));
+      hash.update(`${name}\0${st.size}\0${st.mtimeMs}\n`);
+    } catch { hash.update(`${name}\0gone\n`); }
+  }
+  return hash.digest('hex').slice(0, 16);
+}
+
+const contentHash = (text: string): string => createHash('sha256').update(text).digest('hex').slice(0, 16);
+
+interface MemoryCacheEntry { key: string; messages: LLMMessage[]; hash: string }
+interface AmbientCacheEntry { parts: string[]; hash: string; at: number }
+
+const memoryCache = new Map<string, MemoryCacheEntry>();
+const ambientCache = new Map<string, AmbientCacheEntry>();
+
+/** Map insertion order doubles as recency: re-insert on use, drop the oldest beyond the cap. */
+function remember<V>(cache: Map<string, V>, key: string, value: V): void {
+  cache.delete(key);
+  cache.set(key, value);
+  while (cache.size > SESSION_LAYER_CACHE_MAX) cache.delete(cache.keys().next().value as string);
+}
+
+/** Test seam — forget every session's cached layers. */
+export function resetTurnSessionLayers(): void {
+  memoryCache.clear();
+  ambientCache.clear();
+}
+
+export interface SessionMemoryLayerOpts {
+  sessionKey: string;
+  cwd: string;
+  root?: string;
+  env?: NodeJS.ProcessEnv;
+  maxTokens?: number;
+}
+
+/** The file-memory system message for this session. Rebuilt only when the store or the scope changed. */
+export function sessionMemoryLayer(opts: SessionMemoryLayerOpts): LLMMessage[] {
+  try {
+    const root = opts.root ?? memoryRoot();
+    const scope = resolveMemoryScope(opts.cwd, opts.env);
+    const maxTokens = opts.maxTokens ?? TUI_MEMORY_BUDGET_TOKENS;
+    const key = JSON.stringify([root, scope.seat ?? '', scope.project ?? '', maxTokens, memoryStoreSignature(root)]);
+    const cached = memoryCache.get(opts.sessionKey);
+    if (cached && cached.key === key) {
+      remember(memoryCache, opts.sessionKey, cached);
+      debug.log('chat.memory-layer', 'reused', { session: opts.sessionKey, seat: scope.seat ?? null, hash: cached.hash });
+      return cached.messages;
+    }
+    // Empty user text on purpose: keyword hits would change with every prompt and break the cached prefix.
+    // Per-prompt recall is the memory_recall tool's job (it is on every TUI route).
+    const inj = buildMemoryInjection('', {
+      maxTokens,
+      filter: entry => memoryInScope(entry, scope),
+      alwaysInject: entry => isSeatCard(entry, scope),
+    }, root);
+    const messages: LLMMessage[] = inj.block ? [{ role: 'system', content: inj.block }] : [];
+    const hash = contentHash(inj.block);
+    debug.log('chat.memory-layer', cached ? 'changed' : 'built', {
+      session: opts.sessionKey, seat: scope.seat ?? null, project: scope.project ?? null,
+      injected: inj.injectedIds.length, tokens: inj.tokens, hash,
+      ...(cached ? { previousHash: cached.hash, sameContent: cached.hash === hash } : {}),
+    });
+    // Same content (e.g. an unrelated file touched) keeps the previous array — byte-identical prefix.
+    const kept = cached && cached.hash === hash ? cached.messages : messages;
+    remember(memoryCache, opts.sessionKey, { key, hash, messages: kept });
+    return kept;
+  } catch (error) {
+    // The layer is dropped for this turn and rebuilt on the next one.
+    memoryCache.delete(opts.sessionKey);
+    debug.log('chat.memory-layer', 'failed', { session: opts.sessionKey, error: String(error) });
+    return [];
+  }
+}
+
+export interface SessionSelfAmbientOpts {
+  now?: number;
+  ttlMs?: number;
+  build?: () => string[];
+}
+
+/** The task-independent self ambient (recent changes · autonomy · ops health · mission incident),
+ *  read at most once per TTL per session. The task-dependent investigation recall stays per turn. */
+export function sessionSelfAmbientParts(sessionKey: string, opts: SessionSelfAmbientOpts = {}): string[] {
+  const now = opts.now ?? Date.now();
+  const ttl = opts.ttlMs ?? SELF_AMBIENT_TTL_MS;
+  const cached = ambientCache.get(sessionKey);
+  if (cached && now - cached.at < ttl) {
+    remember(ambientCache, sessionKey, cached);
+    return cached.parts;
+  }
+  try {
+    const parts = (opts.build ?? (() => elanousSelfAmbientParts()))();
+    const hash = contentHash(parts.join('\0'));
+    if (cached && cached.hash === hash) {
+      remember(ambientCache, sessionKey, { ...cached, at: now });
+      debug.log('chat.self-ambient', 'unchanged', { session: sessionKey, hash });
+      return cached.parts;
+    }
+    remember(ambientCache, sessionKey, { parts, hash, at: now });
+    debug.log('chat.self-ambient', cached ? 'changed' : 'built', { session: sessionKey, parts: parts.length, hash });
+    return parts;
+  } catch (error) {
+    // Fail-soft means the layer is left out, not replayed stale; the next turn reads again.
+    ambientCache.delete(sessionKey);
+    debug.log('chat.self-ambient', 'failed', { session: sessionKey, error: String(error) });
+    return [];
+  }
+}

package/src/dashboard/turn-stream-formatter.ts

@@ -166,6 +166,12 @@ export interface TurnStreamFormatter {
 export function createTurnStreamFormatter(
   deps: TurnStreamFormatterDeps,
 ): TurnStreamFormatter {
+  const groupingKind = (name: string, args: Record<string, unknown>): string | undefined => {
+    const kind = toolOperationKind(name, args);
+    return deps.foldMode === 'kind-unit' || (deps.foldMode === 'task-unit' && kind === 'RunShell')
+      ? kind
+      : undefined;
+  };
   // Per-tool-round 누적기. cross-turn 에서 이전 round 의 텍스트를
   // 가져오지 않음. clear-and-commit (onText('', '')) 또는 tool call
   // 발생 시 reset.
@@ -278,8 +284,8 @@ export function createTurnStreamFormatter(
           callId: call.id,
           lines: rendered,
           args: call.args,
-          ...(deps.foldMode === 'kind-unit'
-            ? { operationKind: toolOperationKind(call.name, call.args) }
+          ...(groupingKind(call.name, call.args)
+            ? { operationKind: groupingKind(call.name, call.args) }
             : {}),
         });
         closeRound();
@@ -293,8 +299,8 @@ export function createTurnStreamFormatter(
         callId: call.id,
         lines: [deps.muted(`${deps.brainIcon} tool: ${call.name} — running`)],
         args: call.args,
-        ...(deps.foldMode === 'kind-unit'
-          ? { operationKind: toolOperationKind(call.name, call.args) }
+        ...(groupingKind(call.name, call.args)
+          ? { operationKind: groupingKind(call.name, call.args) }
           : {}),
       });
       debug.log('dashboard.chat.generic-tool', 'formatter.genericCall', { toolName: call.name });
@@ -331,8 +337,10 @@ export function createTurnStreamFormatter(
         callId: call.id,
         collapsedLines: variants.collapsed,
         expandedLines: variants.expanded,
-        ...(deps.foldMode === 'kind-unit'
-          ? { operationKind: ('operationKind' in variants ? variants.operationKind : undefined) ?? toolOperationKind(call.name, args) }
+        ...(groupingKind(call.name, args)
+          ? { operationKind: deps.foldMode === 'task-unit'
+            ? 'RunShell'
+            : ('operationKind' in variants ? variants.operationKind : undefined) ?? toolOperationKind(call.name, args) }
           : {}),
       });
       toolArgsByCallId.delete(call.id);

package/src/dashboard/turn-stream-presentation-applier.ts

@@ -99,6 +99,13 @@ export function createTurnStreamPresentationApplier(
       switch (event.type) {
         case 'assistant.replaceBlock': {
           const beforeLen = deps.chatLines.length;
+          if (assistantStart > deps.chatLines.length) {
+            debug.log('dashboard.chat.stream', 'presentation.assistant-start-clamped', {
+              assistantStart,
+              chatLinesLen: deps.chatLines.length,
+            });
+            assistantStart = deps.chatLines.length;
+          }
           deps.chatLines.length = assistantStart;
           deps.chatLines.push(...event.lines);
           logEvent('assistant.replaceBlock', {
@@ -158,6 +165,7 @@ export function createTurnStreamPresentationApplier(
             event.expandedLines,
             event.operationKind ? { operationKind: event.operationKind } : undefined,
           );
+          assistantStart = Math.min(assistantStart, deps.chatLines.length);
           deps.renderedToolRuntime.deleteArgs(event.callId);
           logEvent('tool.replaceBlock', {
             callId: event.callId,

package/src/decisions/decision-ledger.ts

@@ -7,6 +7,7 @@ import { createVersionResolver, type VersionOptions, type Versions } from '../di
 import { getUserConfig } from '../user-config.js';
 import { registeredSeats, resolveSeat } from '../seat-address/seat-address.js';
 import { isSeatId } from '../seat-dispatch/seat-questions.js';
+import { openMsgStore } from '../msg/msg-store.js';
 
 export type DecisionCategory = 'secret' | 'publish' | 'money' | 'security' | 'scope' | 'irreversible' | 'other';
 /** Old track letters (S·T·F·O) stay readable; seat names (OP·MK·TC·UX) are the current identities. */
@@ -42,10 +43,22 @@ export interface SeatDecisionRecord {
 }
 export type SeatDecisionInput = Pick<SeatDecisionRecord, 'title' | 'decision' | 'seat' | 'delegation' | 'refs'> & { decidedAt?: string };
 type Event = { type: 'raised'; entry: DecisionEntry } | { type: 'seat-recorded'; entry: SeatDecisionRecord } | { 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 }
+export interface DecisionLedgerOptions extends VersionOptions { stateDir?: string; now?: () => Date; resolveVersion?: (at: string) => Versions; writeAnswer?: typeof writePendingQuestionAnswer; postDecisionNotice?: (entry: DecisionEntry, stateDir: string, seat: string) => number }
 
 /** null = the decision resumes no run; otherwise whether the answer file was written (or already matched). */
 export type AnswerDelivery = null | { ok: true; questionId: string } | { ok: false; questionId: string; reason: string };
+export type DecisionNotice = { status: 'skipped' } | { status: 'sent'; seat: string; messageId: number } | { status: 'failed'; seat: string; reason: string };
+
+function postDecisionNotice(entry: DecisionEntry, stateDir: string, seat: string): number {
+  const selected = entry.options.find(option => option.key === entry.choice);
+  if (!selected || !entry.choice) throw new Error('recorded choice not found');
+  const recommendedWhy = 'option' in entry.recommendation && entry.recommendation.option === entry.choice ? entry.recommendation.why : undefined;
+  const rationale = (entry.note ?? recommendedWhy ?? entry.scqa.c).replace(/\s+/g, ' ').trim();
+  const body = `**[OP]** 결정 ${entry.id} · ${entry.title} · 선택 ${entry.choice}: ${selected.label} · 근거 ${rationale}`;
+  const store = openMsgStore(join(stateDir, 'msg', 'messages.db'));
+  try { return store.appendWithProvenance({ from: 'OP', to: seat, kind: 'info', body }, `decision:${entry.id}:${seat}`).id; }
+  finally { store.close(); }
+}
 
 /** The decision is durable even when delivery fails; retryAnswer(id) only retries delivery. */
 export class DecisionAnswerDeliveryError extends Error {
@@ -144,6 +157,7 @@ export class DecisionLedger {
   private readonly lockPath: string;
   private readonly now: () => Date;
   private readonly writeAnswer: typeof writePendingQuestionAnswer;
+  private readonly postDecisionNotice: NonNullable<DecisionLedgerOptions['postDecisionNotice']>;
   private readonly stateDir: string;
   private versionResolver?: (at: string) => Versions;
   private readonly versionOptions: DecisionLedgerOptions;
@@ -153,6 +167,7 @@ export class DecisionLedger {
     this.lockPath = `${this.path}.lock`;
     this.now = options.now ?? (() => new Date());
     this.writeAnswer = options.writeAnswer ?? writePendingQuestionAnswer;
+    this.postDecisionNotice = options.postDecisionNotice ?? postDecisionNotice;
     this.versionOptions = options;
     this.versionResolver = options.resolveVersion;
   }
@@ -300,13 +315,13 @@ export class DecisionLedger {
     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 } {
+  decideWithDelivery(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery; notice: DecisionNotice } {
     return this.decideLocked(id, choice, by, note, decidedAt);
   }
   decide(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): DecisionEntry {
     return this.decideLocked(id, choice, by, note, decidedAt).entry;
   }
-  private decideLocked(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery } {
+  private decideLocked(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery; notice: DecisionNotice } {
     if (!by || (by.kind !== 'human' && by.kind !== 'auto')) throw new Error('decidedBy is required');
     if (by.kind === 'auto') {
       single(by.delegation, 'delegation'); single(by.agent, 'agent');
@@ -322,9 +337,35 @@ export class DecisionLedger {
       this.append({ type: 'decided', id, at, by, choice, version: this.version(at), ...(note ? { note: safe(single(note, 'note')) } : {}) });
       debug.log('decisions', 'decided', { id, category: old.category, by: by.kind });
       const decided = this.show(id);
-      return { entry: decided, delivery: this.deliverAnswer(decided) };
+      return { entry: decided, delivery: this.deliverAnswer(decided), notice: this.notifyDecided(decided) };
+    });
+  }
+  /** Retry only the seat notice; the message provenance key prevents duplicate delivery. */
+  retryNotice(id: string): DecisionNotice {
+    return this.locked(() => {
+      const entry = this.show(id);
+      if (entry.status !== 'decided') throw new Error(`decision is not decided: ${id}`);
+      return this.notifyDecided(entry);
     });
   }
+  private notifyDecided(entry: DecisionEntry): DecisionNotice {
+    const track = entry.raisedBy.track;
+    if (!track) return { status: 'skipped' };
+    const seat = resolveSeat(track)?.id;
+    if (!seat) {
+      debug.log('decisions', 'decided-notify-unknown-seat', { id: entry.id, track });
+      return { status: 'failed', seat: track, reason: '올린 자리 미상' };
+    }
+    try {
+      const messageId = this.postDecisionNotice(entry, this.stateDir, seat);
+      debug.log('decisions', 'decided-notify-sent', { id: entry.id, seat, messageId });
+      return { status: 'sent', seat, messageId };
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      debug.log('decisions', 'decided-notify-failed', { id: entry.id, seat, reason });
+      return { status: 'failed', seat, reason };
+    }
+  }
   /** Retry delivery of the recorded choice without adding another decided event or changing its actor/note. */
   retryAnswer(id: string): DecisionEntry {
     return this.locked(() => {

package/src/discord-self-message.ts

@@ -66,7 +66,7 @@ import { localOcrText } from './telegram-card-followup.js';
 import type { runGraph } from './graph-runner/runner.js';
 import { readSlashContextNow, renderContextFirstNow, renderTelegramNow } from './context-bus/context-now-surfaces.js';
 import { contextNow, type ContextNowDeps } from './context-bus/context-now.js';
-import { createContextFirstGate, renderContextFirst } from './context-bus/context-first.js';
+import { createContextFirstGate, renderContextFirst, takeContextFirstOpening } from './context-bus/context-first.js';
 import { telegramLoopsStatus, type LoopsSources } from './telegram-loops-command.js';
 import { botUnavailableSlashReply, deriveTuiSlashAvailability, type TuiSlashAvailability } from './maturity/tui-slash-availability.js';
 
@@ -157,8 +157,8 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
   const log = deps.log ?? ((): void => {});
   const cfg = deps.userConfig;
   const contextFirstGate = createContextFirstGate({ now: deps.contextFirstNow ?? Date.now });
-  const maybeSendContextFirst = async (channelId: string): Promise<void> => {
-    if (!contextFirstGate.take(channelId) || cfg.discord?.contextFirst === false) return;
+  const maybeSendContextFirst = async (channelId: string, text?: string): Promise<void> => {
+    if (!takeContextFirstOpening({ gate: contextFirstGate, key: channelId, text, enabled: cfg.discord?.contextFirst !== false })) return;
     try {
       await deps.getBot()?.sendMessage(channelId, renderContextFirst(contextNow, deps.nowDeps, renderContextFirstNow));
     } catch (err) {
@@ -426,7 +426,7 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
       if (unavailable) return unavailable;
     }
     const cmd = parseDiscordAcpCommand(ctx.text);
-    if (!cmd && !/^[!/]/.test(ctx.text.trim())) await maybeSendContextFirst(ctx.channelId);
+    if (!cmd && !/^[!/]/.test(ctx.text.trim())) await maybeSendContextFirst(ctx.channelId, ctx.text);
     log(`◀ ${ctx.userName ?? ctx.userId}: ${ctx.text.slice(0, 80)}${ctx.attachments.length ? ` (+첨부 ${ctx.attachments.length})` : ''}`);
     debug.log('discord.self.turn', 'inbound', { channelId: ctx.channelId, chars: ctx.text.length, attachments: ctx.attachments.length });
     // C2+ — 첨부 기억(사진만 먼저 올리는 패턴 지원). 명령 여부와 무관.