elanous 0.2.41 → 0.2.43

package/src/dashboard/side-basic-runtime.ts

@@ -12,6 +12,59 @@ export function registerClassicSideSlash(
 ): void {
   registry.register(['side'], async (args, ctx) => {
     const sub = (args[0] ?? 'list').toLowerCase();
+    const getRows = (): SidetabRow[] => ctx.classicSidetabAgent?.loadRows(ctx.chatPersona?.sessionId())
+      ?? loadRows(ctx.chatPersona?.sessionId());
+    if (sub === 'open') {
+      const agent = (args[1] ?? '').toLowerCase();
+      if (args.length !== 2 || (agent !== 'codex' && agent !== 'claude')) {
+        ctx.chatLines.push(ctx.warning('  사용법: /side open codex|claude'));
+      } else if (!ctx.classicSidetabAgent) {
+        ctx.chatLines.push(ctx.warning('  classic agent sidetab을 사용할 수 없습니다'));
+      } else {
+        ctx.classicSidetabAgent.openAgent(agent);
+      }
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (sub === 'mission') {
+      const agent = (args[1] ?? '').toLowerCase();
+      const missionArgs = args.slice(2);
+      let outputPath: string | undefined;
+      const outputFlag = missionArgs.indexOf('--out');
+      if (outputFlag >= 0) {
+        outputPath = missionArgs[outputFlag + 1];
+        if (!outputPath) {
+          ctx.chatLines.push(ctx.warning('  사용법: /side mission codex|claude [--out <path>] <mission>'));
+          ctx.setChatScrollOffset(-1);
+          return;
+        }
+        missionArgs.splice(outputFlag, 2);
+      }
+      const mission = missionArgs.join(' ').trim();
+      if ((agent !== 'codex' && agent !== 'claude') || !mission) {
+        ctx.chatLines.push(ctx.warning('  사용법: /side mission codex|claude [--out <path>] <mission>'));
+      } else if (!ctx.classicSidetabAgent) {
+        ctx.chatLines.push(ctx.warning('  classic agent sidetab을 사용할 수 없습니다'));
+      } else {
+        const result = await ctx.classicSidetabAgent.runMission(agent, mission, outputPath);
+        if (result.ok) {
+          ctx.chatLines.push(ctx.success(`  ${agent} 미션 완료`));
+          ctx.chatLines.push(ctx.muted(`  promptReady=${Boolean(result.promptReady)}`));
+          ctx.chatLines.push(ctx.muted(`  missionVisible=${Boolean(result.missionVisible)}`));
+          ctx.chatLines.push(ctx.muted(`  promptReturned=${Boolean(result.promptReturned)}`));
+          ctx.chatLines.push(ctx.muted(`  completionMarker=${Boolean(result.completionMarker)}`));
+          ctx.chatLines.push(ctx.muted(`  결과 파일: ${result.path}${result.firstLine ? ` · ${result.firstLine}` : ''}`));
+        } else {
+          ctx.chatLines.push(ctx.muted(`  promptReady=${Boolean(result.promptReady)}`));
+          ctx.chatLines.push(ctx.muted(`  missionVisible=${Boolean(result.missionVisible)}`));
+          ctx.chatLines.push(ctx.muted(`  promptReturned=${Boolean(result.promptReturned)}`));
+          ctx.chatLines.push(ctx.muted(`  completionMarker=${Boolean(result.completionMarker)}`));
+          ctx.chatLines.push(ctx.warning(`  ${agent} 미션 실패 · ${result.error ?? '결과 확인 실패'}${result.path ? ` · ${result.path}` : ''}`));
+        }
+      }
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
     if (sub === 'new') {
       if (args.length > 1) ctx.chatLines.push(ctx.warning('  사용법: /side new'));
       else ctx.termSlash.openNewTerminal();
@@ -25,7 +78,7 @@ export function registerClassicSideSlash(
     }
     // Use the same filtered manifest rows for display and numeric resolution;
     // never let an exited row shift the number shown to the user.
-    const rows = loadRows(ctx.chatPersona?.sessionId()).filter(row => row.badge !== 'exited');
+    const rows = getRows().filter(row => row.badge !== 'exited');
     if (sub === 'list') {
       if (rows.length === 0) ctx.chatLines.push(ctx.muted('  사이드탭 없음'));
       rows.forEach((row, i) => ctx.chatLines.push(ctx.muted(`  ${i + 1}. ${row.badge} ${row.label}`)));

package/src/dashboard/sidetab-runtime.ts

@@ -3,6 +3,82 @@ import type { ModalSurface } from '../display/modal-stack.js';
 import type { Key } from '../tui.js';
 import { loadSidetabRows, type SidetabRow } from '../sidetab-core/model.js';
 
+export interface DashboardLocalAgentSession {
+  id: string;
+  title: string;
+  kind: 'shell' | 'coding-agent';
+  agentBrand?: 'claude-code' | 'codex' | 'gemini' | 'grok';
+  state: 'foreground' | 'background' | 'exited';
+}
+
+export interface DashboardMissionResult {
+  ok: boolean;
+  path: string;
+  content?: string;
+  firstLine?: string;
+  promptReady: boolean;
+  missionVisible: boolean;
+  promptReturned: boolean;
+  completionMarker: boolean;
+  error?: string;
+}
+
+/** Convert popup startup/adapter exceptions into the same explicit mission outcome. */
+export async function runDashboardAgentMission<TSession, TModal>(deps: {
+  agent: string;
+  requestedOutputPath?: string;
+  open: () => TSession | undefined;
+  modal: (session: TSession) => TModal | null | undefined;
+  outputPath: (session: TSession, requested?: string) => string;
+  run: (session: TSession, modal: TModal, outputPath: string) => Promise<DashboardMissionResult>;
+  close: (session: TSession) => void;
+}): Promise<DashboardMissionResult> {
+  let session: TSession | undefined;
+  let resultPath = deps.requestedOutputPath ?? '';
+  try {
+    session = deps.open();
+    if (session === undefined) throw new Error(`${deps.agent} PTY could not start`);
+    const modal = deps.modal(session);
+    if (!modal) throw new Error(`${deps.agent} PTY could not start`);
+    resultPath = deps.outputPath(session, deps.requestedOutputPath);
+    return await deps.run(session, modal, resultPath);
+  } catch (error) {
+    return {
+      ok: false,
+      path: resultPath,
+      promptReady: false,
+      missionVisible: false,
+      promptReturned: false,
+      completionMarker: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  } finally {
+    if (session !== undefined) {
+      try { deps.close(session); } catch { /* closing a failed popup must not replace its mission result */ }
+    }
+  }
+}
+
+/** Keep locally spawned coding-agent tabs attachable even when no PTY manifest row exists. */
+export function mergeLocalAgentSessions(
+  rows: readonly SidetabRow[],
+  sessions: readonly DashboardLocalAgentSession[],
+): SidetabRow[] {
+  const knownSessionIds = new Set(rows.map((row) => row.sessionId).filter((id): id is string => Boolean(id)));
+  const localAgents = sessions
+    .filter((session) => session.kind === 'coding-agent' && session.state !== 'exited' && !knownSessionIds.has(session.id))
+    .map((session): SidetabRow => ({
+      id: session.id,
+      label: session.title,
+      kind: session.agentBrand ?? 'coding-agent',
+      // Terminal foreground/background says where the session is attached,
+      // not whether the agent is currently working. Do not infer turn state.
+      badge: 'unknown',
+      sessionId: session.id,
+    }));
+  return [...rows, ...localAgents];
+}
+
 export interface DashboardSidetabRuntimeDeps {
   currentSessionId: () => string | undefined;
   termSize: () => { cols: number; rows: number };
@@ -10,6 +86,8 @@ export interface DashboardSidetabRuntimeDeps {
   pushModal: (surface: ModalSurface) => { dispose: () => void };
   attach: (row: SidetabRow) => void;
   spawnShell: () => void;
+  spawnAgent: (agent: 'codex' | 'claude') => void;
+  runMission: (agent: 'codex' | 'claude', mission: string, outputPath?: string) => Promise<DashboardMissionResult>;
   detach: (row: SidetabRow | null) => void;
   kill: (row: SidetabRow) => void;
   returnToParent: () => void;
@@ -17,8 +95,11 @@ export interface DashboardSidetabRuntimeDeps {
 }
 
 export interface DashboardSidetabRuntime {
+  loadRows: (sessionId?: string) => SidetabRow[];
   routeKey: (key: Key) => boolean;
   beginPrefix: () => void;
+  openAgent: DashboardSidetabRuntimeDeps['spawnAgent'];
+  runMission: DashboardSidetabRuntimeDeps['runMission'];
   close: () => void;
 }
 
@@ -196,6 +277,11 @@ export function createDashboardSidetabRuntime(
         deps.spawnShell();
         return true;
       }
+      if (!key.ctrl && !key.alt && (name === 'c' || name === 'a')) {
+        closePanel();
+        deps.spawnAgent(name === 'c' ? 'codex' : 'claude');
+        return true;
+      }
       if (!key.ctrl && !key.alt && name === 'd') {
         closePanel();
         deps.detach(null);
@@ -207,7 +293,7 @@ export function createDashboardSidetabRuntime(
         confirmKill(row);
         return true;
       }
-      deps.status('사이드탭 키: s 목록 · p 부모 · 1–9 연결 · n 새 셸 · d 분리 · k 종료');
+      deps.status('사이드탭 키: s 목록 · p 부모 · 1–9 연결 · c Codex · a Claude · n 새 셸 · d 분리 · k 종료');
       return true;
     }
     if (key.ctrl && !key.alt && (key.name === '\\' || key.name === 'backslash')) {
@@ -218,8 +304,11 @@ export function createDashboardSidetabRuntime(
   };
 
   return {
+    loadRows: (sessionId) => getRows(sessionId ?? deps.currentSessionId()),
     routeKey,
     beginPrefix,
+    openAgent: deps.spawnAgent,
+    runMission: deps.runMission,
     close() {
       prefixPending = false;
       closePanel();

package/src/dashboard/skill-catalog-preamble.ts

@@ -0,0 +1,101 @@
+import { estimateTokens } from '../tokens.js';
+
+export interface InstalledSkillSummary {
+  name: string;
+  description: string;
+}
+
+export interface InstalledSkillCatalogMessage {
+  role: 'system';
+  content: string;
+}
+
+export interface InstalledSkillCatalogBuild {
+  message: InstalledSkillCatalogMessage | null;
+  estimatedTokens: number;
+  budgetTokens: number;
+  mode: 'full' | 'short-description' | 'names-only' | 'names-truncated' | 'empty';
+  skillCount: number;
+}
+
+const CONTEXT_WINDOW_FALLBACK = 32_000;
+const CATALOG_CONTEXT_FRACTION = 0.02;
+const OMITTED_SKILLS_NOTE = 'Use elanous_skills_list to inspect other installed skills.';
+
+let cachedKey: string | null = null;
+let cachedBuild: InstalledSkillCatalogBuild | null = null;
+
+function render(entries: readonly InstalledSkillSummary[], descriptionChars: number, omittedCount = 0): string {
+  const lines = entries.map(({ name, description }) => {
+    const summary = descriptionChars === 0 ? '' : description.trim().slice(0, descriptionChars).trim();
+    return summary ? `- ${name}: ${summary}` : `- ${name}`;
+  });
+  if (omittedCount > 0) lines.push(`- ${omittedCount} more omitted. ${OMITTED_SKILLS_NOTE}`);
+  return [
+    '[Installed skills]',
+    'When a listed skill fits, call skill_exec with its exact name and the user task. Call elanous_skills_list only when the needed skill is absent from this list.',
+    ...lines,
+  ].join('\n');
+}
+
+/** Build a stable prompt-prefix snapshot from frontmatter summaries only; skill bodies stay lazy. */
+export function buildInstalledSkillCatalogMessage(
+  input: readonly InstalledSkillSummary[],
+  contextWindow?: number | null,
+): InstalledSkillCatalogBuild {
+  const entries = [...input]
+    .filter(entry => entry.name.trim().length > 0)
+    .map(entry => ({ name: entry.name.trim(), description: entry.description.trim() }))
+    .sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  const resolvedWindow = Number.isSafeInteger(contextWindow) && (contextWindow as number) > 0
+    ? contextWindow as number
+    : CONTEXT_WINDOW_FALLBACK;
+  const budgetTokens = Math.max(1, Math.floor(resolvedWindow * CATALOG_CONTEXT_FRACTION));
+  const key = JSON.stringify([budgetTokens, entries]);
+  if (cachedKey === key && cachedBuild) return cachedBuild;
+
+  if (entries.length === 0) {
+    cachedKey = key;
+    cachedBuild = { message: null, estimatedTokens: 0, budgetTokens, mode: 'empty', skillCount: 0 };
+    return cachedBuild;
+  }
+
+  let content = render(entries, Number.MAX_SAFE_INTEGER);
+  let estimatedTokens = estimateTokens(content);
+  let mode: InstalledSkillCatalogBuild['mode'] = 'full';
+  if (estimatedTokens > budgetTokens) {
+    const maxDescriptionChars = Math.max(...entries.map(entry => entry.description.length));
+    let descriptionChars = maxDescriptionChars;
+    while (descriptionChars > 0 && estimatedTokens > budgetTokens) {
+      descriptionChars = Math.floor(descriptionChars / 2);
+      content = render(entries, descriptionChars);
+      estimatedTokens = estimateTokens(content);
+    }
+    mode = descriptionChars === 0 ? 'names-only' : 'short-description';
+  }
+
+  let skillCount = entries.length;
+  if (estimatedTokens > budgetTokens) {
+    mode = 'names-truncated';
+    let included: InstalledSkillSummary[] = [];
+    for (let index = 0; index < entries.length; index += 1) {
+      const candidate = [...included, entries[index]!];
+      const candidateContent = render(candidate, 0, entries.length - candidate.length);
+      if (estimateTokens(candidateContent) > budgetTokens) break;
+      included = candidate;
+    }
+    content = render(included, 0, entries.length - included.length);
+    estimatedTokens = estimateTokens(content);
+    skillCount = included.length;
+  }
+
+  cachedKey = key;
+  cachedBuild = {
+    message: { role: 'system', content },
+    estimatedTokens,
+    budgetTokens,
+    mode,
+    skillCount,
+  };
+  return cachedBuild;
+}

package/src/dashboard/skill-detection-runtime.ts

@@ -72,13 +72,25 @@ export async function detectDashboardSkillRoute(
   visibleIndex: SkillIndexEntry[],
   deps: DashboardSkillDetectionRuntimeDeps,
 ): Promise<DetectResult> {
+  const detectionStartedAt = performance.now();
   const detectKeyword = deps.detectKeyword ?? detectSkillTrigger;
   const detectWithLLM = deps.detectWithLLM ?? detectLLM;
   const parseClassifier = deps.parseClassifier ?? parseClassifierJson;
   const keywordDetection = detectKeyword(userText, visibleIndex, {});
-  if (!deps.llmFallback) return keywordDetection;
+  if (!deps.llmFallback) {
+    try {
+      debug.log('skill.router.timing', 'detection-complete', {
+        mode: 'keyword',
+        elapsedMs: Math.round((performance.now() - detectionStartedAt) * 10) / 10,
+        skillCount: visibleIndex.length,
+        candidateCount: keywordDetection.candidates.length,
+      });
+    } catch { /* observation must never delay routing */ }
+    return keywordDetection;
+  }
 
   const classify = async (prompt: string, signal?: AbortSignal): Promise<LLMClassifyResult> => {
+    const roleStartedAt = performance.now();
     const resolved = resolveRoleLlm('classify');
     const provider = llm.PROVIDERS[resolved.provider];
     if (!provider) throw new Error(`Unknown classify provider: ${resolved.provider}`);
@@ -89,21 +101,49 @@ export async function detectDashboardSkillRoute(
       provider: resolved.provider,
       source: resolved.source,
     });
-    const raw = await deps.streamLLM(
-      [{ role: 'user', content: prompt }],
-      () => {},
-      { signal, maxTokens: 120, temperature: 0, model: resolved.model, provider, usageRole: 'classify' },
-    );
+    try {
+      debug.log('skill.router.timing', 'classifier-role-ready', {
+        elapsedMs: Math.round((performance.now() - roleStartedAt) * 10) / 10,
+        provider: resolved.provider,
+        source: resolved.source,
+      });
+    } catch { /* observation must never delay routing */ }
+    const streamStartedAt = performance.now();
+    let raw: string;
+    try {
+      raw = await deps.streamLLM(
+        [{ role: 'user', content: prompt }],
+        () => {},
+        { signal, maxTokens: 120, temperature: 0, model: resolved.model, provider, usageRole: 'classify' },
+      );
+    } finally {
+      try {
+        debug.log('skill.router.timing', 'classifier-stream-complete', {
+          elapsedMs: Math.round((performance.now() - streamStartedAt) * 10) / 10,
+          provider: resolved.provider,
+        });
+      } catch { /* observation must never delay routing */ }
+    }
     return parseClassifier(raw);
   };
 
-  return detectWithLLM(userText, visibleIndex, {
-    classify,
-    keywordScoreThreshold: deps.keywordScoreThreshold,
-    llmConfidenceThreshold: deps.llmConfidenceThreshold,
-    ...(deps.signal ? { signal: deps.signal } : {}),
-    ...(deps.activeTier ? { activeTier: deps.activeTier } : {}),
-    ...(deps.fullMenuTier ? { fullMenuTier: deps.fullMenuTier } : {}),
-    ...(deps.fullMenuConfidenceThreshold != null ? { fullMenuConfidenceThreshold: deps.fullMenuConfidenceThreshold } : {}),
-  });
+  try {
+    return await detectWithLLM(userText, visibleIndex, {
+      classify,
+      keywordScoreThreshold: deps.keywordScoreThreshold,
+      llmConfidenceThreshold: deps.llmConfidenceThreshold,
+      ...(deps.signal ? { signal: deps.signal } : {}),
+      ...(deps.activeTier ? { activeTier: deps.activeTier } : {}),
+      ...(deps.fullMenuTier ? { fullMenuTier: deps.fullMenuTier } : {}),
+      ...(deps.fullMenuConfidenceThreshold != null ? { fullMenuConfidenceThreshold: deps.fullMenuConfidenceThreshold } : {}),
+    });
+  } finally {
+    try {
+      debug.log('skill.router.timing', 'detection-complete', {
+        mode: 'llm-fallback',
+        elapsedMs: Math.round((performance.now() - detectionStartedAt) * 10) / 10,
+        skillCount: visibleIndex.length,
+      });
+    } catch { /* observation must never delay routing */ }
+  }
 }

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

@@ -422,6 +422,21 @@ const COST_SLASH_DESCRIPTOR = buildCostSlashCommand();
 const MEMORY_SLASH_DESCRIPTOR = buildMemorySlashCommand();
 
 export interface DashboardSlashContext {
+  /** Classic /side agent commands supplied by the dashboard host. */
+  classicSidetabAgent?: {
+    loadRows(sessionId?: string): import('../../sidetab-core/model.js').SidetabRow[];
+    openAgent(agent: 'codex' | 'claude'): void;
+    runMission(agent: 'codex' | 'claude', mission: string, outputPath?: string): Promise<{
+      ok: boolean;
+      path: string;
+      firstLine?: string;
+      promptReady: boolean;
+      missionVisible: boolean;
+      promptReturned: boolean;
+      completionMarker: boolean;
+      error?: string;
+    }>;
+  };
   // Chat surface refs / mutators
   chatLines: string[];
   /** Same status-line producer the agent immediate executor uses. Absent in tests → empty. */

package/src/dashboard/terminal-popup-runtime.ts

@@ -1,10 +1,10 @@
 import type { TerminalSession } from '../terminal/session-registry.js';
 
-export type DashboardTerminalPopupAgentBrand = 'claude-code' | 'codex' | 'gemini';
+export type DashboardTerminalPopupAgentBrand = 'claude-code' | 'codex' | 'gemini' | 'grok';
 
 export type DashboardTerminalPopupRequest =
   | { kind: 'shell'; cwd: string; command?: string; env?: Record<string, string> }
-  | { kind: 'coding-agent'; brand: DashboardTerminalPopupAgentBrand; cwd: string; extraArgs?: readonly string[] };
+  | { kind: 'coding-agent'; brand: DashboardTerminalPopupAgentBrand; cwd: string; extraArgs?: readonly string[]; env?: Record<string, string>; id?: string };
 
 export interface DashboardTerminalPopupRuntimeDeps {
   onMissingCwd: () => void;
@@ -15,6 +15,7 @@ export interface DashboardTerminalPopupBuilder {
   cwd(cwd: string): DashboardTerminalPopupBuilder;
   command(command: string): DashboardTerminalPopupBuilder;
   env(env: Record<string, string>): DashboardTerminalPopupBuilder;
+  id(id: string): DashboardTerminalPopupBuilder;
   args(extraArgs: readonly string[]): DashboardTerminalPopupBuilder;
   open(): TerminalSession | null;
 }
@@ -34,11 +35,13 @@ export function createDashboardTerminalPopupRuntime(
     let cwd: string | null = null;
     let command: string | undefined;
     let env: Record<string, string> | undefined;
+    let id: string | undefined;
     let args: readonly string[] | undefined;
     return {
       cwd(next) { cwd = next; return this; },
       command(next) { command = next; return this; },
       env(next) { env = next; return this; },
+      id(next) { id = next; return this; },
       args(next) { args = next; return this; },
       open() {
         if (cwd === null) {
@@ -47,7 +50,7 @@ export function createDashboardTerminalPopupRuntime(
         }
         const req: DashboardTerminalPopupRequest = kind === 'shell'
           ? { kind: 'shell', cwd, command, env }
-          : { kind: 'coding-agent', brand: kind, cwd, extraArgs: args };
+          : { kind: 'coding-agent', brand: kind, cwd, ...(args ? { extraArgs: args } : {}), ...(env ? { env } : {}), ...(id ? { id } : {}) };
         return deps.openInteractiveTerminalPopup(req);
       },
     };

package/src/dashboard/turn-preamble.ts

@@ -41,6 +41,8 @@ import {
 import type { getUserConfig } from '../user-config.js';
 import { isNativeStructureEnabledForProvider, resolveActiveProvider } from '../user-config.js';
 import { measureInputLagTurnStart } from '../tui/input-lag-probe.js';
+import { resolveModelContextWindow } from '../models/context-window.js';
+import { buildInstalledSkillCatalogMessage, type InstalledSkillSummary } from './skill-catalog-preamble.js';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
 import { buildSelfHealthLine, type InstalledRecord, type SelfHealthErrors } from '../pty-shell/tui-run-state.js';
 import type { PtyBuildIdentity } from '../pty-shell/pty-manifest.js';
@@ -71,6 +73,12 @@ 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[];
+  /** Installed frontmatter summaries for the stable skill-routing prompt prefix. */
+  skillCatalog?: readonly InstalledSkillSummary[];
+  /** Active model context size, when known. Unknown models use the conservative helper default. */
+  skillCatalogContextWindow?: number | null;
+  /** Runtime-selected model can differ from the configured default model. */
+  skillCatalogModelId?: string;
   /** 🪪 L1 자리 부트 카드를 싣나(`seat-boot-preamble.ts`). 대화형 TUI 호출부만 켠다 — 기본 꺼짐이라
    *  다른 호출부·시험은 셸의 `COORD_ID` 에 따라 출력이 갈리지 않는다. */
   seatBoot?: boolean | SeatBootDeps;
@@ -100,6 +108,12 @@ export interface DashboardTurnPreambleContext {
   };
 }
 
+/** Flag per-prompt system layers so the Codex Responses serializer keeps
+ *  them out of the cached `instructions` prefix (TUI-PROMPT-CACHE-PREFIX). */
+function markCacheVolatile(messages: readonly LLMMessage[]): LLMMessage[] {
+  return messages.map((m) => (m.role === 'system' ? { ...m, cacheVolatile: true } : m));
+}
+
 export function buildControllerSystemMessage(controller: string, channels?: string): LLMMessage {
   return {
     role: 'system',
@@ -172,6 +186,15 @@ function buildDashboardTurnPreambleUnmeasured(
 ): LLMMessage[] {
   const builderMs: BuilderMs | null = debug.enabled ? {} : null;
   const startedAt = builderMs === null ? 0 : performance.now();
+  // This is the first stable block in the system preamble. Its cached content changes only
+  // when the installed/visible skill list or model context budget changes.
+  const skillCatalogBuild = ctx.skillCatalog
+    ? timed(builderMs, 'skillCatalog', () => buildInstalledSkillCatalogMessage(
+      ctx.skillCatalog!,
+      ctx.skillCatalogContextWindow ?? resolveModelContextWindow(ctx.skillCatalogModelId ?? ctx.userConfig.llm.model),
+    ))
+    : null;
+  const skillCatalogSystemMsgs = skillCatalogBuild?.message ? [skillCatalogBuild.message] : [];
   // Universal preamble — surface-agnostic anchor (AGENTS.md +
   // CLAUDE.md). Spread first so the project context lands BEFORE any
   // surface-specific guidance, mirroring Claude Code's Phase 0
@@ -294,21 +317,30 @@ function buildDashboardTurnPreambleUnmeasured(
   const controllerSystemMsgs = controller
     ? timed(builderMs, 'controller', () => [buildControllerSystemMessage(controller, controlEnv.channels)])
     : [];
-  const preamble = [
+  // TUI-PROMPT-CACHE-PREFIX — only the universal anchor (AGENTS.md ·
+  // CLAUDE.md · tool discipline) is stable for the life of a session. Every
+  // other layer can change between prompts (boot card · memory · git
+  // snapshot · plan/approval mode · per-userText guidance · self health), so
+  // it is flagged `cacheVolatile`: the Codex serializer then keeps it out of
+  // `instructions` and sends it as a developer item after the cached history.
+  const preamble: LLMMessage[] = [
+    ...skillCatalogSystemMsgs,
     ...universalPreamble,
-    ...seatBootSystemMsgs,
-    ...planModeSystemMsgs,
-    ...askSystemMsgs,
-    ...approvalSystemMsgs,
-    ...sandboxSystemMsgs,
-    ...memorySystemMsgs,
-    ...gitSnapshotSystemMsgs,
-    ...surfaceSystemMsgs,
-    ...selfOpsSystemMsgs,
-    ...selfHealthSystemMsgs,
-    ...controllerSystemMsgs,
-    ...implDisciplineSystemMsgs,
-    ...concisenessSystemMsgs,
+    ...markCacheVolatile([
+      ...seatBootSystemMsgs,
+      ...planModeSystemMsgs,
+      ...askSystemMsgs,
+      ...approvalSystemMsgs,
+      ...sandboxSystemMsgs,
+      ...memorySystemMsgs,
+      ...gitSnapshotSystemMsgs,
+      ...surfaceSystemMsgs,
+      ...selfOpsSystemMsgs,
+      ...selfHealthSystemMsgs,
+      ...controllerSystemMsgs,
+      ...implDisciplineSystemMsgs,
+      ...concisenessSystemMsgs,
+    ]),
   ];
   // Capture exactly what the ACP path's getPreamble emits so we can
   // verify what codex actually sees as system prompt at turn-start.
@@ -328,7 +360,9 @@ function buildDashboardTurnPreambleUnmeasured(
       if (notificationOnlyWake) {
         preamble.push({ role: 'system', content: '[알림 전용 턴] 이것은 완료 알림을 전달한 비요청 status receipt다. 작업 요청으로 취급하지 말고 Agent 또는 SelfImplement 위임을 시작하지 않는다. 포함된 결과를 바탕으로 한 번의 간결한 상태 요약만 답하고 멈춘다. 결과가 전달되지 않았다면 결과가 아직 제공되지 않았다고 알리고 내용을 추측하지 않는다.' });
       }
-      const pendingNotifications = globalTaskNotificationQueue.drain();
+      const pendingNotifications = ctx.sessionId
+        ? globalTaskNotificationQueue.drainForParentSessionOrUnscoped(ctx.sessionId)
+        : globalTaskNotificationQueue.drain();
       taskNotificationCount = pendingNotifications.length;
       if (pendingNotifications.length === 0) {
         if (notificationOnlyWake) {
@@ -370,6 +404,7 @@ function buildDashboardTurnPreambleUnmeasured(
       hasTurnProfile: ctx.turnProfile != null,
       builderCounts: {
         universal: universalPreamble.length,
+        ...(ctx.skillCatalog ? { skillCatalog: skillCatalogSystemMsgs.length } : {}),
         seatBoot: seatBootSystemMsgs.length,
         planMode: planModeSystemMsgs.length,
         ask: askSystemMsgs.length,
@@ -390,6 +425,9 @@ function buildDashboardTurnPreambleUnmeasured(
       builderTotalMs: Math.round((performance.now() - startedAt) * 10) / 10,
       totalMessageCount: preamble.length,
       taskNotificationCount,
+      skillCatalogTokens: skillCatalogBuild?.estimatedTokens ?? 0,
+      skillCatalogBudgetTokens: skillCatalogBuild?.budgetTokens ?? 0,
+      skillCatalogMode: skillCatalogBuild?.mode ?? 'not-provided',
       totalChars: total,
       userTextPreview: ctx.userText.length > 80 ? `${ctx.userText.slice(0, 80)}…` : ctx.userText,
     });

package/src/dashboard/turn-prompt-runtime.ts

@@ -5,7 +5,7 @@ import {
   type PromptBankStore,
 } from '../prompt-bank/index.js';
 import {
-  resolveSessionTurnProfile,
+  resolveSessionTurnProfileWithHistory,
   type SessionTurnProfile,
 } from '../session-runtime/index.js';
 import type { InputSourceRef } from '../input/input-source-kind.js';
@@ -39,6 +39,7 @@ export function buildDashboardTurnPromptRuntime(
   turnId: string,
   deps: DashboardTurnPromptRuntimeDeps,
   inputSource?: InputSourceRef | null,
+  priorUserTexts: readonly string[] = [],
 ): DashboardTurnPromptRuntimeResult {
   const turnIntents = ['chat', ...classifyUserIntents(userText)];
   const promptBankInjection = deps.promptBankConfig.enabled && deps.promptBankConfig.dashboardTurns
@@ -62,8 +63,9 @@ export function buildDashboardTurnPromptRuntime(
         slots: ['context', 'tool-hint', 'user-prefix'],
       })
     : '';
-  const turnProfile = resolveSessionTurnProfile({
+  const turnProfile = resolveSessionTurnProfileWithHistory({
     userText,
+    priorUserTexts,
     chatModeState: deps.chatModeState,
     inputSource,
   });