elanous 0.2.41 → 0.2.43

package/src/dashboard/input/agent-wake.ts

@@ -28,6 +28,7 @@ import { homedir } from 'node:os';
 import type { TextInputInternalTurnYieldPort } from '../../chat/index.js';
 import { debug } from '../../debug/log.js';
 import type { PendingTaskNotification } from '../../agent/task-notification.js';
+import { CLASSIC_SIDETAB_MISSION_LABEL } from '../classic-sidetab-mission-job.js';
 import { detectSeatTui, type SeatDetection } from '../seat-boot-preamble.js';
 import type { InternalTurnRejectReason, StartTurnIfIdleOptions, StartTurnIfIdleResult } from './internal-turn.js';
 
@@ -77,6 +78,16 @@ function displayName(n: Pick<PendingTaskNotification, 'label' | 'agentName'>): s
   return ((n.label ?? '').trim() || n.agentName).replace(/\s+/g, ' ').slice(0, 60);
 }
 
+/** Late research results remain visible as one compact line without opening a turn. */
+export function formatAgentSupplementNotice(
+  n: Pick<PendingTaskNotification, 'label' | 'agentName' | 'state' | 'output'>,
+): string {
+  const summary = n.output.replace(/\s+/gu, ' ').trim();
+  const excerpt = summary.length > 180 ? `${summary.slice(0, 177)}…` : summary;
+  const status = n.state === 'done' ? '' : ` (${n.state})`;
+  return `↳ 보강: ${displayName(n)}${status}${excerpt ? ` — ${excerpt}` : ' — 결과 없음'}`;
+}
+
 /** 채팅 한 줄 — «✓ 위임 끝: <이름> — 다음 턴에 결과»(실패·중단이면 ✗ ⊕ 상태). */
 export function formatAgentWakeNotice(n: Pick<PendingTaskNotification, 'label' | 'agentName' | 'state'>): string {
   const name = displayName(n);
@@ -86,7 +97,10 @@ export function formatAgentWakeNotice(n: Pick<PendingTaskNotification, 'label' |
 }
 
 /** 자리 TUI 에서 여는 내부 턴의 입력 — 결과 본문은 turn-preamble 이 `<task-notification>` 으로 싣는다. */
-export function formatAgentWakePrompt(n: Pick<PendingTaskNotification, 'label' | 'agentName' | 'state'>): string {
+export function formatAgentWakePrompt(n: Pick<PendingTaskNotification, 'taskId' | 'label' | 'agentName' | 'state'>): string {
+  if (n.label === CLASSIC_SIDETAB_MISSION_LABEL) {
+    return `[자동 재개] 사이드탭 미션 완료: ${n.taskId} (${n.state}) — <task-notification> 결과를 원래 요청과 대조해 수용·부분 수용·기각을 판단하고, 필요하면 원래 대화를 계속 진행`;
+  }
   return `[자동 재개] 위임 끝: ${displayName(n)} (${n.state}) — <task-notification> 의 결과를 읽고 이어서 처리`;
 }
 
@@ -141,6 +155,14 @@ export function createAgentWake(deps: AgentWakeDeps): AgentWakeController {
       return false;
     }
     handled.add(n.taskId);
+    if (n.completionDelivery === 'supplement') {
+      let notifyError: string | null = null;
+      try { deps.notify(formatAgentSupplementNotice(n)); } catch (error) {
+        notifyError = error instanceof Error ? error.message : String(error);
+      }
+      log('tui.agent-wake', 'supplemented', { ...base, shown: notifyError === null, ...(notifyError !== null ? { notifyError } : {}) });
+      return true;
+    }
     // 그리기 실패가 큐·형제 리스너를 막지 않는다 — 대신 관측에 남긴다(알림이 실제로 안 보였음을 볼 수 있게).
     let notifyError: string | null = null;
     try { deps.notify(formatAgentWakeNotice(n)); } catch (error) {

package/src/dashboard/input/chat-main-acp-dispatch.ts

@@ -127,6 +127,29 @@ export function dispatchDashboardChatMainAcpSend(
       else interimBodyRanges.push({ start: assistantBodyStart, end: assistantBodyEnd });
       deps.setChatScrollToTail();
     },
+    replaceText: (fullText) => {
+      const insertionIndex = interimBodyRanges.length > 0
+        ? Math.min(...interimBodyRanges.map((range) => range.start))
+        : deps.chatLines.length;
+      for (const { start, end } of [...interimBodyRanges].reverse()) {
+        deps.chatLines.splice(start, end - start);
+      }
+      interimBodyRanges.length = 0;
+      accumulated = fullText;
+      firstChunk = false;
+      assistantTextActive = true;
+      assistantRunUsesPrefix = true;
+      assistantBodyText = fullText;
+      assistantBodyStart = insertionIndex;
+      const rendered = deps.formatAssistantLines(fullText);
+      rendered.forEach((line, index) => {
+        deps.chatLines.splice(insertionIndex + index, 0,
+          index === 0 ? `${deps.formatAssistantPrefix(display)} ${line}` : `  ${line}`);
+      });
+      assistantBodyEnd = insertionIndex + rendered.length;
+      interimBodyRanges.push({ start: insertionIndex, end: assistantBodyEnd });
+      deps.setChatScrollToTail();
+    },
     foldGoalInterim: (text) => {
       const verdict = classifyInterimReply(text.split('\n'));
       if (verdict.interim && interimBodyRanges.length > 0) {

package/src/dashboard/input/chat-main-plain-turn-runtime.ts

@@ -9,6 +9,7 @@ import type { DashboardTurnBlockAttachLike } from '../turn-message-runtime.js';
 import type { DashboardAssistantRenderState } from '../turn-tail-runtime.js';
 import type { SearchPlannerState } from '../../session-runtime/index.js';
 import { runDashboardPlainTurnStream } from './dashboard-plain-turn-stream.js';
+import { runConfiguredTurnThrowSim, type TurnThrowSim } from '../../ux-sim/turn-throw-sim.js';
 import {
   formatFailureNotice, matchFailureText, recordFailureSignatureMatch,
 } from '../../self-health/signatures.js';
@@ -103,6 +104,8 @@ export interface DashboardChatMainPlainTurnRuntimeDeps {
   readToolDispatchCount?: () => number | null;
 
   attachChatStreamingKeys: (abortCtrl: AbortController) => () => void;
+  /** Test-injectable turn-body failure. Omitted in ordinary callers; the configured simulation remains inert by default. */
+  turnThrowSim?: TurnThrowSim;
   /** ⭐ 관측 심 — 형제 `chat-main-entry-runtime` 과 «같은 형태»다(재발명 0 · `OBS-T124`). */
   debugLog?: (category: string, event: string, payload: Record<string, unknown>, opts?: { level?: 'warn' }) => void;
   createOptionalSpecs: () => Promise<unknown[]>;
@@ -228,6 +231,7 @@ export async function runDashboardChatMainPlainTurn(
       cleanedUp = true;
       attachedCleanupEsc();
     };
+    await (deps.turnThrowSim ?? runConfiguredTurnThrowSim)(stage);
     // ⛔⭐⭐⭐ **「스트리밍 키 사다리가 «이 턴»에 걸렸나」를 값으로 남긴다**(2026-08-19 · `OBS-T124`).
     //
     // 🚨 왜 필요한가 — 대표 제보(*"스트리밍 중 친 발화가 큐에 안 쌓인다"*)를 라이브로 재현했더니
@@ -270,6 +274,7 @@ export async function runDashboardChatMainPlainTurn(
     // message actually carries the pixels/bytes, not just the token.
     await deps.loadAttachments(deps.contextRegistry);
     stage = 'loadAttachments';
+    await (deps.turnThrowSim ?? runConfiguredTurnThrowSim)(stage);
     if (finishIfAborted()) return;
 
     const { userMsg } = deps.buildTurnMessage({
@@ -290,6 +295,7 @@ export async function runDashboardChatMainPlainTurn(
       typeof userMsg.content === 'string' ? userMsg.content : '',
     );
     stage = 'beginCodeEditTurn';
+    await (deps.turnThrowSim ?? runConfiguredTurnThrowSim)(stage);
     if (finishIfAborted()) return;
 
     const preamble = deps.buildTurnPreamble({
@@ -309,6 +315,7 @@ export async function runDashboardChatMainPlainTurn(
     const compactChanged = prePassApplied && (deps.chat.history.length !== beforeCompact.length
       || deps.chat.history.some((message, index) => message !== beforeCompact[index]));
     stage = 'runAutoCompact';
+    await (deps.turnThrowSim ?? runConfiguredTurnThrowSim)(stage);
     if (finishIfAborted()) return;
 
     deps.pushChatLine('');
@@ -317,6 +324,7 @@ export async function runDashboardChatMainPlainTurn(
     let assistantStart = deps.chatLines.length;
     let optionalSpecs = await deps.createOptionalSpecs();
     stage = 'createOptionalSpecs';
+    await (deps.turnThrowSim ?? runConfiguredTurnThrowSim)(stage);
     if (finishIfAborted()) return;
     if (deps.control) {
       const signal = findRecentQuickPassSignal({
@@ -355,6 +363,7 @@ export async function runDashboardChatMainPlainTurn(
     // 기록되므로 request→first-token 구간은 그대로 측정된다. ISO 시각 좌표는
     // pty record 및 TUI-BOOT-TIME(src/index.ts) 부팅 계측과의 대응용이다.
     let firstTokenLogged = false;
+    let modelRequestStartedAt: number | null = null;
     const logFirstToken = (chunk: string): void => {
       if (firstTokenLogged || !chunk || abortCtrl.signal.aborted) return;
       firstTokenLogged = true;
@@ -362,6 +371,7 @@ export async function runDashboardChatMainPlainTurn(
       try {
         deps.debugLog?.('chat.turn', 'first-token', {
           ms: firstTokenAt - deps.turnStartedAt,
+          modelRequestMs: modelRequestStartedAt === null ? null : firstTokenAt - modelRequestStartedAt,
           turnStartedAt: deps.turnStartedAt,
           turnStartedAtIso,
           firstTokenAtIso: new Date(firstTokenAt).toISOString(),
@@ -391,6 +401,13 @@ export async function runDashboardChatMainPlainTurn(
         const attempt = async (stage: string): Promise<boolean> => {
           let emitted = false;
           try {
+            modelRequestStartedAt = Date.now();
+            try {
+              deps.debugLog?.('chat.turn.stage', 'model-request-start', {
+                attempt: stage,
+                msSinceTurnStart: modelRequestStartedAt - deps.turnStartedAt,
+              });
+            } catch { /* observation must never delay a turn */ }
             await deps.acpSession.send({
               ...opts,
               // 라우팅 줄은 브리지가 모델 호출 «전»에 보낸다 — 모델 출력이 아니므로 재시도를 막지 않는다.

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

@@ -0,0 +1,165 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnElanous } from '../instance/spawn-elanous.js';
+import type { AgentCliPreparation } from '../agent-mission/tool-install.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;
+  prepareAgentCli?: (agent: 'codex' | 'claude') => Promise<AgentCliPreparation>;
+}
+
+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;
+  linearIssueId?: 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;
+  if (deps.prepareAgentCli) {
+    try {
+      const prepared = await deps.prepareAgentCli(input.agent);
+      if (!prepared.ready) return { ok: false, status: 'failed', path: '', error: prepared.message };
+    } catch {
+      return { ok: false, status: 'failed', path: '', error: `${input.agent}: 설치·로그인 상태를 확인하지 못했습니다` };
+    }
+  }
+  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,
+      ...(input.linearIssueId ? ['--linear-issue-id', input.linearIssueId] : []), '--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 missionStatus: MissionStatus = parseJson<MissionStatus>(await executeCli(['mission', 'status', interactionId!, '--json']));
+          if (missionStatus.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 (missionStatus.status === 'done' || missionStatus.status === 'completed') {
+            if (typeof missionStatus.result !== 'string' || !missionStatus.result.trim()) throw new Error('Mission completed without a final answer');
+            return { ok: true, status: 'completed', interactionId, path: outputPath, content: missionStatus.result };
+          }
+          if (missionStatus.status !== 'running') return {
+            ok: false,
+            status: missionStatus.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/plugin-wizard-runtime.ts

@@ -0,0 +1,50 @@
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { createTaskPluginWizardHostDeps, type TaskPluginWizardHostResult } from '../cli/task-plugin-wizard-host.js';
+import { defaultTaskLauncher } from '../cli/tasks-cli.js';
+import { handTask, type HandTaskOptions } from '../task-agent/task-hand.js';
+import { TASK_CARD_PREFIX } from '../task-agent/task-card-prefix.js';
+import type { PluginMaker, PluginWizardDeps } from '../graph-wizard/mission-compose.js';
+import { createTuiPluginWizardTool, type TuiPluginWizardTool } from './plugin-wizard-tool.js';
+import type { TuiPluginWizardRequest } from './plugin-wizard-tool.js';
+
+export interface DashboardPluginWizardRuntimePorts {
+  runMissionPair: (request: {
+    runId: string;
+    prompt: string;
+    context?: TuiPluginWizardRequest['context'];
+  }) => Promise<Partial<Record<PluginMaker, TaskPluginWizardHostResult>>>;
+  getWorkspace: () => string;
+  taskHand?: (options: HandTaskOptions) => Promise<unknown>;
+  launcher?: HandTaskOptions['launcher'];
+  onEvent?: PluginWizardDeps['onEvent'];
+}
+
+/** Connect the TUI entry tool to handTask and the existing plugin composer without blocking the ACP turn. */
+export function createDashboardPluginWizardRuntime(ports: DashboardPluginWizardRuntimePorts): TuiPluginWizardTool {
+  return createTuiPluginWizardTool(async (request) => {
+    const pluginWizardDeps = createTaskPluginWizardHostDeps({
+      runMissionPair: ({ prompt }) => ports.runMissionPair({ runId: request.runId, prompt, ...(request.context ? { context: request.context } : {}) }),
+      onEvent: ports.onEvent ?? ((event) => {
+        if (event.step !== 'validate' || !event.detail || typeof event.detail !== 'object') return;
+        const winner = (event.detail as { winner?: unknown }).winner;
+        if (winner) debug.log('wizard.validate', 'winner-adopted', { runId: event.wizardId, ts: event.ts, winner });
+      }),
+    });
+    const runHandTask = ports.taskHand ?? handTask;
+    await runHandTask({
+      id: `${TASK_CARD_PREFIX}plugin-${request.runId.replaceAll('-', '').slice(0, 20)}`,
+      text: request.mission,
+      seat: 'TC',
+      live: true,
+      launcher: ports.launcher ?? defaultTaskLauncher,
+      pluginWizard: {
+        missing: request.missing,
+        root: effectiveInstanceRoot(),
+        workspace: ports.getWorkspace(),
+        wizardId: request.runId,
+      },
+      pluginWizardDeps,
+    });
+  });
+}

package/src/dashboard/plugin-wizard-tool.ts

@@ -0,0 +1,55 @@
+import { randomUUID } from 'node:crypto';
+import { debug } from '../debug/log.js';
+import type { LLMToolSpec } from '../llm.js';
+import type { ClassicSidetabMissionDispatchContext } from './classic-sidetab-mission.js';
+
+export const TUI_PLUGIN_WIZARD_TOOL_NAME = 'StartPluginWizard';
+
+export interface TuiPluginWizardRequest {
+  runId: string;
+  mission: string;
+  missing: string;
+  context?: ClassicSidetabMissionDispatchContext;
+}
+
+export interface TuiPluginWizardTool {
+  getTools(existing: readonly LLMToolSpec[]): LLMToolSpec[];
+  dispatchTool(name: string, args: unknown, context?: ClassicSidetabMissionDispatchContext): Promise<unknown> | undefined;
+}
+
+/** Add a non-blocking TUI entry point; the injected host runs the shared task/plugin-wizard path. */
+export function createTuiPluginWizardTool(start: (request: TuiPluginWizardRequest) => Promise<void>, createId: () => string = randomUUID): TuiPluginWizardTool {
+  const spec: LLMToolSpec = {
+    name: TUI_PLUGIN_WIZARD_TOOL_NAME,
+    description: 'When a needed capability is missing, start the plugin wizard in this TUI session. It asks a short question, searches trusted plugins, and if needed launches the visible Codex and Claude side-tab pair. Returns a run ID immediately; check the task notification for completion.',
+    parameters: {
+      type: 'object',
+      properties: {
+        mission: { type: 'string', minLength: 1, description: 'The active task to complete after installing or creating the tool.' },
+        missing: { type: 'string', minLength: 1, description: 'The missing tool or capability.' },
+      },
+      required: ['mission', 'missing'],
+      additionalProperties: false,
+    },
+  };
+
+  return {
+    getTools: (existing) => [...existing, spec],
+    dispatchTool(name, args, context) {
+      if (name !== TUI_PLUGIN_WIZARD_TOOL_NAME) return undefined;
+      const output = (status: 'running' | 'error', body: string, id: string | null = null) => ({ status, body, artifacts: [], id });
+      if (!args || typeof args !== 'object' || Array.isArray(args)) return Promise.resolve(output('error', 'arguments must be an object'));
+      const input = args as Record<string, unknown>;
+      if (Object.keys(input).some((key) => key !== 'mission' && key !== 'missing')) return Promise.resolve(output('error', 'arguments contain unsupported fields'));
+      const mission = typeof input.mission === 'string' ? input.mission.trim() : '';
+      const missing = typeof input.missing === 'string' ? input.missing.trim() : '';
+      if (!mission || !missing) return Promise.resolve(output('error', 'mission and missing capability are required'));
+      const runId = createId();
+      void Promise.resolve().then(() => start({ runId, mission, missing, ...(context ? { context } : {}) })).catch((error) => {
+        try { debug.log('plugin-wizard.tool', 'start-failed', { runId, reason: error instanceof Error ? error.message : String(error) }, { level: 'error' }); }
+        catch { /* failure reporting must not re-enter the tool boundary */ }
+      });
+      return Promise.resolve(output('running', `Plugin wizard started in the background (run ${runId}).`, runId));
+    },
+  };
+}

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;