elanous 0.2.41 → 0.2.42

package/src/dashboard/mission-cli-consumer.ts

@@ -0,0 +1,153 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnElanous } from '../instance/spawn-elanous.js';
+
+export interface ClassicMissionCliResult {
+  ok: boolean;
+  status: 'completed' | 'cancelled' | 'failed';
+  interactionId?: string;
+  path: string;
+  content?: string;
+  error?: string;
+}
+interface MissionStatus {
+  missionId: string;
+  status: 'running' | 'done' | 'completed' | 'cancelled' | 'failed';
+  result?: string;
+}
+
+const MISSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+// Status is persisted by the CLI bridge; polling every 500 ms would launch up to
+// 7,200 short-lived CLI processes for a one-hour mission. Five seconds keeps
+// eventual completion observable without turning the dashboard into a process loop.
+const POLL_MS = 5_000;
+const MAX_WAIT_MS = 60 * 60 * 1_000;
+
+function runCli(args: string[]): Promise<{ code: number | null; stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    // `process.argv[1]` belongs to the parent surface and can be a TUI-only
+    // entry. Always route detached mission operations through the installed
+    // CLI command, whose `mission` router owns run/status/cancel.
+    const child = spawnElanous(args, { executable: 'eln',
+      cwd: process.cwd(),
+      env: { ...process.env, ELANOUS_FAST_ROUTER: '0' },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (!child.stdout || !child.stderr) { reject(new Error('Installed CLI streams could not be opened')); return; }
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk: string) => { stdout = `${stdout}${chunk}`.slice(-64_000); });
+    child.stderr.on('data', (chunk: string) => { stderr = `${stderr}${chunk}`.slice(-8_000); });
+    child.once('error', reject);
+    child.once('close', (code) => resolve({ code, stdout, stderr }));
+  });
+}
+
+function parseJson<T>(result: { code: number | null; stdout: string; stderr: string }): T {
+  if (result.code !== 0) throw new Error('Mission CLI command failed');
+  try { return JSON.parse(result.stdout) as T; }
+  catch { throw new Error('Mission CLI returned invalid JSON'); }
+}
+
+const delay = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+
+export interface MissionCliConsumerDeps {
+  runCli?: typeof runCli;
+  delay?: (ms: number) => Promise<void>;
+  now?: () => number;
+}
+
+export interface StartedClassicMissionCliJob {
+  ok: true;
+  status: 'running';
+  interactionId: string;
+  path: string;
+  startedAt: number;
+  completion: Promise<ClassicMissionCliResult>;
+}
+
+export type StartClassicMissionCliResult = StartedClassicMissionCliJob | ClassicMissionCliResult;
+
+export function redactMissionResultPath(text: string, path?: string): string {
+  return path ? text.replaceAll(path, '[internal result]') : text;
+}
+
+export function isClassicMissionId(value: string): boolean {
+  return MISSION_ID.test(value);
+}
+
+/** Explicitly cancel a detached sidetab mission; parent-turn aborts never call this. */
+export async function cancelClassicMissionCli(interactionId: string, executeCli: typeof runCli = runCli): Promise<boolean> {
+  if (!isClassicMissionId(interactionId)) return false;
+  const result = parseJson<{ missionId: string; status: string; cancelled: boolean }>(
+    await executeCli(['mission', 'cancel', interactionId, '--json']),
+  );
+  return result.missionId === interactionId && result.cancelled === true && result.status === 'cancelled';
+}
+
+/** Start a detached mission and return its identity immediately; poll results independently. */
+export async function startClassicMissionCli(input: {
+  agent: 'codex' | 'claude';
+  prompt: string;
+  onInteractionId?: (interactionId: string) => void;
+}, deps: MissionCliConsumerDeps = {}): Promise<StartClassicMissionCliResult> {
+  const executeCli = deps.runCli ?? runCli;
+  const wait = deps.delay ?? delay;
+  const now = deps.now ?? Date.now;
+  const tempRoot = mkdtempSync(join(tmpdir(), 'elanous-classic-mission-'));
+  const promptPath = join(tempRoot, 'prompt.txt');
+  const outputPath = join(tempRoot, 'result.md');
+  let interactionId: string | undefined;
+  const startedAt = now();
+  try {
+    writeFileSync(promptPath, input.prompt, { encoding: 'utf8', mode: 0o600 });
+    const launched = parseJson<{ missionId: string; status: 'running' }>(await executeCli([
+      'mission', 'run', '--agent', input.agent, '--prompt-file', promptPath, '--out', outputPath, '--json',
+    ]));
+    if (!isClassicMissionId(launched.missionId) || launched.status !== 'running') throw new Error('Mission CLI returned an invalid interaction ID');
+    interactionId = launched.missionId;
+    try { input.onInteractionId?.(interactionId); } catch { /* telemetry must not interrupt mission startup */ }
+    const completion = (async (): Promise<ClassicMissionCliResult> => {
+      try {
+        while (now() - startedAt < MAX_WAIT_MS) {
+          const status: MissionStatus = parseJson<MissionStatus>(await executeCli(['mission', 'status', interactionId!, '--json']));
+          if (status.missionId !== interactionId) throw new Error('Mission status did not match its interaction ID');
+          // `eln mission status --json` exposes completed records as `done`.
+          // Keep `completed` accepted for compatible bridges and existing callers.
+          if (status.status === 'done' || status.status === 'completed') {
+            if (typeof status.result !== 'string' || !status.result.trim()) throw new Error('Mission completed without a final answer');
+            return { ok: true, status: 'completed', interactionId, path: outputPath, content: status.result };
+          }
+          if (status.status !== 'running') return {
+            ok: false,
+            status: status.status === 'cancelled' ? 'cancelled' : 'failed',
+            interactionId,
+            path: outputPath,
+            error: 'Mission did not complete successfully',
+          };
+          await wait(POLL_MS);
+        }
+        await executeCli(['mission', 'cancel', interactionId!, '--json']).catch(() => undefined);
+        return { ok: false, status: 'failed', interactionId, path: outputPath, error: 'Mission exceeded the sidetab time limit' };
+      } catch {
+        return { ok: false, status: 'failed', interactionId, path: outputPath, error: 'Mission CLI could not complete the request' };
+      } finally {
+        try { rmSync(tempRoot, { recursive: true, force: true }); } catch { /* temp cleanup cannot replace mission outcome */ }
+      }
+    })();
+    return {
+      ok: true,
+      status: 'running',
+      interactionId,
+      path: outputPath,
+      startedAt,
+      completion,
+    };
+  } catch {
+    try { rmSync(tempRoot, { recursive: true, force: true }); } catch { /* temp cleanup cannot replace mission outcome */ }
+    return { ok: false, status: 'failed', ...(interactionId ? { interactionId } : {}), path: outputPath, error: 'Mission CLI could not complete the request' };
+  }
+}

package/src/dashboard/seat-boot-preamble.ts

@@ -95,6 +95,9 @@ export const SEAT_INTENT_ESCALATION_FLOW =
 export const SEAT_MEMORY_RECALL_PREFIX = '🧠 직전 인계 회상:';
 export const SEAT_MEMORY_RECALL_MAX_CHARS = 360;
 const RECALL_READ_BYTES = 16_384;
+export const SEAT_MEMORY_IMPORT_PREFIX = '🧠 자리 기억 스냅샷:';
+export const SEAT_MEMORY_IMPORT_MAX_CHARS = 2_000;
+const SEAT_MEMORY_HANDOFF_MAX_AGE_MS = 24 * 60 * 60 * 1_000;
 /** 발췌(제목 — 첫 줄)에 남길 최소 글자 — 이보다 모자라면 전문 경로를 짧은 꼴로 바꾼다. */
 const RECALL_MIN_EXCERPT = 60;
 /** 줄에 싣는 파일명 최대 글자. */
@@ -184,6 +187,162 @@ function seatMemoryRecallLine(seatDir: string): string | null {
   return recall.line;
 }
 
+interface SeatMemorySource {
+  path: string | null;
+  mtimeMs: number | null;
+}
+
+function regularMemorySource(path: string): SeatMemorySource {
+  try {
+    const stat = lstatSync(path);
+    return stat.isFile() ? { path, mtimeMs: stat.mtimeMs } : { path: null, mtimeMs: null };
+  } catch {
+    return { path: null, mtimeMs: null };
+  }
+}
+
+function handoffPriorityExcerpt(path: string): { priority: string | null; evidence: string | null } {
+  // Only inspect a bounded prefix and extract explicit priority/evidence labels;
+  // arbitrary handoff prose can contain account values or stale historical claims.
+  const lines = readHead(path).split(/\r\n|[\n\r\u0085\u2028\u2029]/);
+  const priorityLabel = /^\s*(?:[-*]\s*)?(?:#{1,6}\s*)?(?:다음 한 수|현재 우선순위|1순위|최우선|next step|priority)\s*[:：]/i;
+  const evidenceLabel = /^\s*(?:[-*]\s*)?(?:#{1,6}\s*)?(?:근거|증거|evidence|source)\s*[:：]/i;
+  const priorityRaw = lines.find((line) => priorityLabel.test(line.replace(/\*\*/g, '')));
+  const evidenceRaw = lines.find((line) => evidenceLabel.test(line.replace(/\*\*/g, '')));
+  const cleanExcerpt = (line: string | undefined): string | null => {
+    if (!line || SHELL_CHARS.test(line)) return null;
+    const clean = oneLine(line.replace(/\*\*/g, '').replace(/^\s*[-*]\s*/, ''));
+    return clean || null;
+  };
+  const evidencePathStart = /(?:seat-state|docs|src|apps|test)\//gu;
+  const evidencePathPattern = /(?:seat-state|docs|src|apps|test)\/[\p{L}\p{N}._/@+-]+/u;
+  const paths = (line: string | undefined): { values: string[]; complete: boolean } => {
+    if (!line) return { values: [], complete: true };
+    const values: string[] = [];
+    let complete = true;
+    for (const startMatch of line.matchAll(evidencePathStart)) {
+      const start = startMatch.index ?? -1;
+      if (start < 0) {
+        complete = false;
+        continue;
+      }
+      const candidate = line.slice(start).match(evidencePathPattern)?.[0];
+      if (!candidate) {
+        complete = false;
+        continue;
+      }
+      const after = line[start + candidate.length];
+      const afterNext = line[start + candidate.length + 1];
+      const boundary = after === undefined || /\s/u.test(after)
+        || (/[;,!?()[\]{}<>]/u.test(after) && (afterNext === undefined || /\s/u.test(afterNext)));
+      const spacedTail = after === ' '
+        ? line.slice(start + candidate.length).match(/^\s+([^·,;!?]*?)(?=\s*[·,;!?]|$)/u)?.[1]?.trim()
+        : undefined;
+      const looksLikeSpacedPath = Boolean(spacedTail && /\.[\p{L}\p{N}]{1,12}$/u.test(spacedTail));
+      if (!boundary || looksLikeSpacedPath) {
+        // Never publish a prefix when the source may contain a wider path token.
+        complete = false;
+        continue;
+      }
+      values.push(redactSecretText(candidate));
+    }
+    return { values, complete };
+  };
+  const priorityPaths = paths(priorityRaw);
+  const priority = priorityPaths.complete
+    ? cleanExcerpt(priorityRaw)?.replace(new RegExp(evidencePathPattern.source, 'gu'), '〔경로는 근거 포인터 참조〕') ?? null
+    : null;
+  const evidencePaths = [...new Set([...priorityPaths.values, ...paths(evidenceRaw).values])].slice(0, 2);
+  return {
+    priority: priority ? priority.slice(0, 700) : null,
+    evidence: evidencePaths.length ? evidencePaths.join(' · ') : null,
+  };
+}
+
+/** Session-start only: bounded source pointers plus a short, explicitly labeled priority excerpt.
+ *  The card cache keeps this snapshot stable for the conversation; newer files appear next session. */
+function buildSeatMemoryImport(cwd: string, seat: string, home: string, now: Date): string {
+  const seatDir = join(home, 'elanous-hq', 'seat-state', seat);
+  const handoff = newestHandoff(seatDir);
+  const handoffSource = handoff ? { path: handoff.path, mtimeMs: handoff.mtime.getTime() } : { path: null, mtimeMs: null };
+  const memory = regularMemorySource(join(home, 'elanous-hq', 'seat-state', 'memory', 'MEMORY.md'));
+  const knowhowCandidates = [
+    join(cwd, 'docs', 'roles', seat, 'KNOWHOW.md'),
+    join(home, 'elanous-hq', 'seats', seat, 'docs', 'roles', seat, 'KNOWHOW.md'),
+  ];
+  const knowhow = knowhowCandidates.map(regularMemorySource).find((source) => source.path) ?? { path: null, mtimeMs: null };
+  const stamp = (source: SeatMemorySource): string => source.mtimeMs === null ? '미상' : new Date(source.mtimeMs).toISOString();
+  const stale = (source: SeatMemorySource): boolean => source.mtimeMs === null || handoffSource.mtimeMs === null ||
+    now.getTime() - handoffSource.mtimeMs > SEAT_MEMORY_HANDOFF_MAX_AGE_MS ||
+    handoffSource.mtimeMs > now.getTime() || source.mtimeMs > now.getTime() || source.mtimeMs < handoffSource.mtimeMs;
+  const handoffStale = handoffSource.mtimeMs === null || now.getTime() - handoffSource.mtimeMs > SEAT_MEMORY_HANDOFF_MAX_AGE_MS ||
+    handoffSource.mtimeMs > now.getTime();
+  const handoffLabel = handoffSource.path
+    ? `seat-state/${seat}/${redactSecretText(basename(handoffSource.path))}`
+    : `seat-state/${seat}/HANDOFF-*.md 없음`;
+  const memoryLabel = memory.path ? 'seat-state/memory/MEMORY.md' : 'seat-state/memory/MEMORY.md 없음';
+  const knowhowLabel = knowhow.path ? `docs/roles/${seat}/KNOWHOW.md` : `docs/roles/${seat}/KNOWHOW.md 없음`;
+  const sourceLines = [
+    `- 인계 포인터: ${handoffLabel} · 갱신 ${stamp(handoffSource)}${handoffStale ? ' · stale/unknown' : ''}`,
+    `- 공통 기억 색인: ${memoryLabel} · 갱신 ${stamp(memory)}${stale(memory) ? ' · stale/unknown' : ''}`,
+    `- 역할 노하우: ${knowhowLabel} · 갱신 ${stamp(knowhow)}${stale(knowhow) ? ' · stale/unknown' : ''}`,
+  ];
+  let priority: string | null = null;
+  let evidence: string | null = null;
+  if (!handoffStale && handoffSource.path) {
+    try {
+      ({ priority, evidence } = handoffPriorityExcerpt(handoffSource.path));
+    } catch { /* missing/unreadable excerpt is unknown, but pointers remain useful */ }
+  }
+  const priorityPrefix = '- 현재 우선순위(인계 발췌): ';
+  const evidencePrefix = '- 근거 포인터(인계 발췌): ';
+  const priorityAvailable = !handoffStale && Boolean(priority);
+  const evidencePaths = !handoffStale && evidence ? evidence.split(' · ') : [];
+  const summary = priorityAvailable ? priorityPrefix : '- 현재 우선순위: 미관측(오래됐거나 명시된 우선순위 줄이 없음) · unknown';
+  const evidenceLine = evidencePaths.length ? evidencePrefix : '- 근거 포인터: 미관측 · 원본 확인 필요';
+  const guidance = 'stale/unknown 또는 상충하는 기억은 사실로 단정하지 말고 unknown으로 답한 뒤 위 포인터의 정본을 확인한다. 비밀·계정 값은 기억에서 가져오지 않는다.';
+  const fixedLines = [
+    `${SEAT_MEMORY_IMPORT_PREFIX} 읽기 전용 · 세션 시작 스냅샷 · 다음 세션부터 갱신`,
+    ...sourceLines,
+    summary,
+    evidenceLine,
+    guidance,
+  ];
+  // Reserve space separately for each excerpt. Never slice the assembled card:
+  // that could cut a path in half or remove the stale/unknown safety guidance.
+  const excerptRoom = Math.max(0, SEAT_MEMORY_IMPORT_MAX_CHARS - fixedLines.join('\n').length);
+  const excerptCount = Number(priorityAvailable) + Number(evidencePaths.length > 0);
+  const excerptBudget = Math.min(520, Math.floor(excerptRoom / (excerptCount || 1)));
+  const priorityText = priorityAvailable
+    ? (priority!.length > excerptBudget ? `${priority!.slice(0, Math.max(0, excerptBudget - 1))}…` : priority!)
+    : '';
+  const evidenceParts: string[] = [];
+  let evidenceRoom = excerptBudget;
+  let omittedEvidencePaths = 0;
+  for (const path of evidencePaths) {
+    const separator = evidenceParts.length ? ' · ' : '';
+    if (separator.length + path.length <= evidenceRoom) {
+      evidenceParts.push(path);
+      evidenceRoom -= separator.length + path.length;
+    } else {
+      omittedEvidencePaths++;
+    }
+  }
+  let evidenceText = evidenceParts.join(' · ');
+  if (omittedEvidencePaths) {
+    const note = `${evidenceText ? ' · ' : ''}${omittedEvidencePaths}개 긴 경로 생략(원문 인계 포인터 참조)`;
+    if (note.length <= evidenceRoom) evidenceText += note;
+  }
+  const content = [
+    `${SEAT_MEMORY_IMPORT_PREFIX} 읽기 전용 · 세션 시작 스냅샷 · 다음 세션부터 갱신`,
+    ...sourceLines,
+    `${summary}${priorityText}`,
+    `${evidenceLine}${evidenceText}`,
+    guidance,
+  ].join('\n');
+  return content;
+}
+
 function buildCardMessages(cwd: string, deps: SeatBootDeps): { messages: LLMMessage[]; observed: Record<string, unknown> } {
   const detection = detectSeat(cwd, deps.env ?? process.env);
   if (!detection) return { messages: [], observed: { reason: 'no-seat' } };
@@ -194,13 +353,24 @@ function buildCardMessages(cwd: string, deps: SeatBootDeps): { messages: LLMMess
   if (!isSeatDir) return { messages: [], observed: { reason: 'no-seat-state', seat: detection.seat, source: detection.source } };
   const { sections, unread } = collectSeatBootSections(detection.seat, { home, msgPath: deps.msgPath ?? defaultMsgStorePath() });
   const card = renderSeatBootCard(detection.seat, sections, null);
-  const at = (deps.now?.() ?? new Date()).toISOString();
+  const snapshotAt = deps.now?.() ?? new Date();
+  const at = snapshotAt.toISOString();
   const recall = seatMemoryRecallLine(seatDir);
+  const memoryImport = buildSeatMemoryImport(cwd, detection.seat, home, snapshotAt);
+  debug.log('dashboard.seat-boot', 'memory-import', {
+    seat: detection.seat,
+    chars: memoryImport.length,
+    priority: memoryImport.includes('- 현재 우선순위(인계 발췌):'),
+    evidence: memoryImport.includes('- 근거 포인터(인계 발췌):'),
+    unknown: memoryImport.includes('- 현재 우선순위: 미관측'),
+    updatedAt: snapshotAt.toISOString(),
+  });
   const content =
     `## 자리 부트 카드 — 너는 이 작업 디렉터리의 ${detection.seat} 자리에서 일한다\n` +
     `(판정: ${detection.source === 'cwd' ? `cwd 의 /seats/${detection.seat}` : 'COORD_ID'} · 세션 시작 스냅샷 ${at} · 이후 바뀐 값은 다시 조회하라)\n` +
     `사람이 다른 일을 먼저 시키지 않았다면, 첫 답에서 자리 이름·'자리 역할' 절의 역할·안 읽은 우편 수를 각각 명시하고 처리할 일을 제안하라. 역할이 미관측이면 추측하지 말고 미관측이라고 말하라.\n` +
     (recall ? `${recall}\n` : '') +
+    `${memoryImport}\n` +
     '\n' +
     `${SEAT_INTENT_ESCALATION_FLOW}\n\n` +
     card;

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';
+  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;
+}