elanous 0.2.37 → 0.2.40

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

@@ -308,6 +308,7 @@ import {
 } from '../../user-config.js';
 import { listProviders } from '../../llm.js';
 import { enabledModels, loadCatalog } from '../../intelligence-map/model-catalog.js';
+import { readTuiSlashAudience, slashMaturity } from '../../maturity/tui-slash-maturity.js';
 import { selfOrchestrateRuntime } from '../../self-dev/self-orchestrate-runtime.js';
 import type { ToolRuntime } from '../../tool-runtime/types.js';
 import { getSessionCwd } from '../../session/working-dir.js';
@@ -383,10 +384,10 @@ import { resolveLocalEndpoints, runLocalLLMCompat } from '../../local-llm-test.j
 import { registerTermSlash, type TermSlashHost } from '../../tui/slash/term.js';
 // 옛 입구 re-export shim 은 slash-runtime/index.ts 한 곳뿐(RFC A5 · /mission 과 같은 꼴).
 import { SlashCommandRegistry } from './registry.js';
-import { readDashboardAskClarification } from './ask-clarification.js';
-export { readDashboardAskClarification };
+export { readDashboardAskClarification } from './ask-clarification.js';
 import { createLoopScheduler, type LoopScheduler } from '../loop-scheduler.js';
 import { registerShellSlash } from './shell-slash.js';
+import { registerClassicSideSlash } from '../side-basic-runtime.js';
 export { registerShellSlash } from './shell-slash.js';
 import { registerMissionSlash } from '../../tui/slash/mission.js';
 // TUI-SLASH-SPLIT-MISSION(D4b) — /mission 은 src/tui/slash/mission.ts 로 이사. 옛 입구 re-export shim 은 slash-runtime/index.ts 한 곳뿐(RFC A5).
@@ -1198,6 +1199,15 @@ export const DASHBOARD_SLASH_CATALOG_BASELINE = {
     'skills-reload', 'spend', 'squeeze',
     'tk', 'tokens',
     'undo', 'w', 'wd',
+    'ad', 'agent-room', 'api', 'api-allow', 'auto-tts', 'autotts',
+    'board', 'capture', 'chat', 'claude', 'codex', 'control', 'conv',
+    'dash', 'dashboard', 'debug', 'default', 'delta', 'design', 'design-check', 'diffs',
+    'directive', 'export', 'fork', 'gemini', 'handoff', 'hist', 'history', 'inject', 'inputs',
+    'lane', 'll', 'local', 'log', 'loops', 'mission', 'p', 'paste', 'persona', 'plan', 'plugin',
+    'plugins', 'prompt', 'prompts', 'provider', 'qc', 'r', 'reasoning', 'rebind', 'relay',
+    'reply', 'research', 'resume-turn', 'rewind', 'rs', 'run', 'run-skill', 's', 'showroom',
+    'surface', 'sync', 'tablet', 'telegram', 'term', 'terminal', 'tg', 'theme', 'think', 'tts',
+    'vc', 'voice-chat', 'widget', 'widgets', 'wish',
   ],
   listedOnly: [
     'acp', 'rsh', 'sr',
@@ -1495,6 +1505,12 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
   });
 
   registry.register('directive', async (args, ctx) => {
+    const { role } = readTuiSlashAudience();
+    if (slashMaturity('directive') === 'ops' && role === 'general') {
+      ctx.pushChatLine(ctx.warning('  /directive는 ops 등급 기능이라 general 역할에서는 실행할 수 없습니다.'));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
     try {
       const { addDirective } = await import('../../steward/directive.js');
       const result = await addDirective(args.join(' '), { source: 'tui' });
@@ -2299,7 +2315,9 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
       return;
     }
     if (sub === 'ask') {
-      const say = args.slice(1).join(' ').replace(/^["'“]|["'”]$/g, '').trim();
+      // `/harness ask` arrives as one raw tail so a pasted path header keeps its line boundary.
+      const askTail = args.length === 2 ? args[1]! : args.slice(1).join(' ');
+      const say = askTail.replace(/^["'“]|["'”]$/g, '').trim();
       ctx.chatLines.push('');
       ctx.chatLines.push(ctx.accent('❯ /harness ask'));
       if (!say) {
@@ -2345,11 +2363,6 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
         print: (line) => { for (const part of line.split('\n')) ctx.chatLines.push(`  ${part}`); },
         log: (event, data, level) => debug.log('dev-pipeline', event, { ...data, surface: 'tui-slash' }, { level }),
         readLine: async () => '',
-        readClarification: (clarification) => readDashboardAskClarification(clarification, ctx.surfaceUx, (line) => {
-          ctx.pushChatLine(line);
-          ctx.setChatScrollOffset(-1);
-          ctx.draw();
-        }),
         readFile: (file) => readFileSync(file, 'utf8'),
         writeFile: (file, data) => writeFileSync(file, data, 'utf8'),
         cwd: () => process.cwd(),
@@ -2577,6 +2590,7 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
 
 
   registerShellSlash(registry);
+  registerClassicSideSlash(registry);
 
   // ── B-3.b ─────────────────────────────────────────────────────────
 

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

@@ -47,7 +47,7 @@ export function buildEssentialHelpLines({
   maxRows,
 }: {
   names: readonly string[];
-  descriptions: readonly Pick<SlashCommand, 'name' | 'aliases' | 'description'>[];
+  descriptions: readonly Pick<SlashCommand, 'name' | 'aliases' | 'description' | 'hidden'>[];
   width: number;
   audience?: { role: Role; showBeta: boolean };
   /** The modal's row budget. When the readable layout overflows it, add columns (shorter descriptions)
@@ -56,7 +56,7 @@ export function buildEssentialHelpLines({
 }): string[] {
   const registered = new Set(names);
   const entries = descriptions
-    .filter((command) => registered.has(command.name) &&
+    .filter((command) => !command.hidden && registered.has(command.name) &&
       ((audience.role === 'owner' && slashMaturity(command.name) === undefined) || slashVisibleFor(command.name, audience.role, { showBeta: audience.showBeta })))
     .map((command) => {
       const aliases = [...new Set(command.aliases ?? [])].filter((alias) => registered.has(alias) && alias !== command.name);

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

@@ -45,6 +45,7 @@ export interface DashboardTermSlashRuntimeDeps {
 
 export interface DashboardTermSlashRuntime {
   helpLines(): string[];
+  experimentalHelpLines(): string[];
   terminalSessionsEmptyLine(): string;
   terminalSessionLine(entry: DashboardTerminalListEntry): string;
   shellRunnerSectionDividerLine(): string;
@@ -122,35 +123,34 @@ export function createDashboardTermSlashRuntime(
     helpLines: () => [
       '',
       deps.accent('\u276f /term'),
-      deps.muted('Usage:'),
+      deps.muted('Formal commands:'),
       deps.muted('  /term new [command]       Open a shell PTY (Ctrl+Shift+T or Alt+T).'),
       deps.muted('  /term list                List all alive sessions (fg / bg / exited).'),
       deps.muted('  /term attach <id>         Bring a backgrounded session to foreground.'),
       deps.muted('  /term detach              Send foreground session to background (PTY survives).'),
+      deps.muted('  Ctrl+B (while streaming)  Background running child tasks; turn continues.'),
+      deps.muted('  Ctrl+X c (chat input)     Enter control mode.'),
       deps.muted('  /term switch              Open the session picker modal.'),
       deps.muted('  /term kill <id>           Stop the PTY and remove the session.'),
       deps.muted('  /term snapshot <id> [tail [bytes]]   Capture current grid (snapshot) or last N bytes (tail).'),
-      deps.muted('  /term move <id> bg|modal|preview|vw   Move terminal between placements (vw uses current foreground VW).'),
-      deps.muted('  /term matrix              Show matrix-wide view (term:<N> | character | placement).'),
-      deps.muted('  /term group list                       Show groups + members.'),
-      deps.muted('  /term group join <id> <group>          Add terminal to a broadcast group.'),
-      deps.muted('  /term group leave <id> <group>         Remove terminal from a broadcast group.'),
-      deps.muted('  /term group send <group> <text>        Broadcast raw bytes to the group.'),
-      deps.muted('  /term channel list                     Show IPC channels + stats.'),
-      deps.muted('  /term channel pub <channel> <text>     Publish on a channel.'),
-      deps.muted('  /term channel tail <id> <channel> [--replay]   Subscribe <id> — msgs stream into PTY stdin.'),
-      deps.muted('  /term channel snapshot <channel> [N=10]        Show last N buffered messages (read-only).'),
-      deps.muted('  /term pipe <id> <channel> [--line]     Publish <id> stdout onto <channel> (raw|line).'),
-      deps.muted('  /term unpipe <pipeId>                  Detach a pipe started with /term pipe.'),
-      deps.muted('  /term pipes                            List every active stdout → channel pipe.'),
-      deps.muted('  /term readonly <id> [on|off]           Toggle read-only (matrix writeTo drops writes).'),
-      deps.muted('  /term recharacter <id> <shell|claude|codex|custom:<name>>  Swap character + reexec.'),
-      deps.muted('  /term vw-sync <windowId> <text>        Broadcast to every terminal-slot in a VW.'),
-      deps.muted('  /term vw-bar [windowId] [on|off]       Toggle per-VW sync input bar (default: current).'),
+      deps.muted('  /term resume <id>          Re-spawn a saved terminal session.'),
+      deps.muted('  /term help experimental   Show experimental commands.'),
       deps.muted(''),
       deps.muted('Shell-runner handles (RunShell) — separate registry:'),
       deps.muted('  /shell list|kill|attach                See /shell help.'),
     ],
+    experimentalHelpLines: () => [
+      '',
+      deps.accent('\u276f /term help experimental'),
+      deps.muted('Experimental commands — behavior may change:'),
+      deps.muted('  /term matrix              Show matrix-wide view.'),
+      deps.muted('  /term move <id> bg|modal|preview   Move terminal between placements.'),
+      deps.muted('  /term group list|join|leave|send    Coordinate terminal groups.'),
+      deps.muted('  /term channel list|pub|tail|snapshot Manage terminal channels.'),
+      deps.muted('  /term pipe|unpipe|pipes             Pipe terminal output to channels.'),
+      deps.muted('  /term readonly <id> [on|off]        Toggle read-only.'),
+      deps.muted('  /term recharacter <id> <character>  Change terminal character.'),
+    ],
     terminalSessionsEmptyLine: () => deps.muted('  No terminal sessions.'),
     terminalSessionLine: (entry) => {
       const brand = entry.agentBrand ? ` [${entry.agentBrand}]` : '';

package/src/dashboard/turn-preamble.ts

@@ -25,6 +25,7 @@ import { buildConcisenessSystemMessages } from '../prompt-library/chat-concisene
 import {
   buildSessionRuntimeSystemMessages,
   buildSessionRuntimeTurnSystemMessages,
+  buildResearchDateSystemMessage,
   type SessionTurnProfile,
 } from '../session-runtime/index.js';
 import { buildExecutionAskSystemMessages } from '../ask-user-question/index.js';
@@ -208,9 +209,15 @@ function buildDashboardTurnPreambleUnmeasured(
     gitSnapshotStaleMs: DASHBOARD_GIT_SNAPSHOT_STALE_MS,
   }));
   const turnProfile = ctx.turnProfile;
+  // Keep the synchronous preamble on the already-resolved surface. Shared
+  // research-intent routing and Bloom evidence guidance are added by core-turn.
+  const researchTurn = turnProfile?.surface.id === 'research/agent';
   const surfaceSystemMsgs = turnProfile
     ? timed(builderMs, 'surface', () => buildSessionRuntimeTurnSystemMessages(turnProfile, ctx.userText))
     : ([] as LLMMessage[]);
+  if (researchTurn) {
+    surfaceSystemMsgs.push(buildResearchDateSystemMessage());
+  }
   // ⭐⭐ `tools.nativeStructure` 는 «어느 provider 에 켤지»를 목록으로 고를 수 있다(2026-08-18).
   //   ⛔ 목록이 없으면 종전대로 «전 provider» — 기존 설정을 쓰는 사람의 값이 안 바뀐다.
   //   ⛔ `config.llm.provider` 를 그대로 읽지 않는다. 그것은 `'auto'` 일 수 있고,
@@ -240,9 +247,9 @@ function buildDashboardTurnPreambleUnmeasured(
     nativeStructureEnabled,
     ...(nativeTools !== undefined ? { enabledTools: nativeTools } : {}),
   }) as LLMMessage[]);
-  const concisenessSystemMsgs = timed(builderMs, 'conciseness', () => buildConcisenessSystemMessages(
-    ctx.userConfig.chat.conciseness,
-  ) as LLMMessage[]);
+  const concisenessSystemMsgs = timed(builderMs, 'conciseness', () => researchTurn
+    ? [] as LLMMessage[]
+    : buildConcisenessSystemMessages(ctx.userConfig.chat.conciseness) as LLMMessage[]);
   // ★ elanous 자기접근 규율 + 자기인지 ambient(P3 · 2026-07-13) — 텔레그램/디스코드
   //   (makeElanousAgentRunTurn)와 단일 출처(agent/self-ambient.ts). TUI 채팅에서도 미션
   //   진단("P2 왜 실패?")·자율 시스템 관측·회상이 규율+ambient+툴(self-ops family) 3박자로
@@ -313,10 +320,29 @@ function buildDashboardTurnPreambleUnmeasured(
   let taskNotificationCount = 0;
   try {
     timed(builderMs, 'taskNotifications', () => {
+      // ACP may ask for a preamble while the session is idle. Keep queued
+      // completion receipts for the next actual user/auto-wake turn.
+      if (!ctx.userText.trim()) return;
+      const notificationOnlyWake = /(?:^|\n)(?:Question: )?\[자동 재개\] 위임 끝: .+ \((?:done|error|aborted)\) — <task-notification> 의 결과를 읽고 이어서 처리$/u
+        .test(ctx.userText);
+      if (notificationOnlyWake) {
+        preamble.push({ role: 'system', content: '[알림 전용 턴] 이것은 완료 알림을 전달한 비요청 status receipt다. 작업 요청으로 취급하지 말고 Agent 또는 SelfImplement 위임을 시작하지 않는다. 포함된 결과를 바탕으로 한 번의 간결한 상태 요약만 답하고 멈춘다. 결과가 전달되지 않았다면 결과가 아직 제공되지 않았다고 알리고 내용을 추측하지 않는다.' });
+      }
       const pendingNotifications = globalTaskNotificationQueue.drain();
       taskNotificationCount = pendingNotifications.length;
-      const taskNotificationsXml = renderTaskNotificationsXml(pendingNotifications);
+      if (pendingNotifications.length === 0) {
+        if (notificationOnlyWake) {
+          debug.log('tui.notify', 'notification-only-turn', { notificationCount: 0, resultAvailable: false });
+        }
+        return;
+      }
+      const taskNotificationsXml = renderTaskNotificationsXml(pendingNotifications, {
+        statusReceipt: notificationOnlyWake,
+      });
       if (taskNotificationsXml) {
+        debug.log('tui.notify', notificationOnlyWake ? 'notification-only-turn' : 'notification-with-user-request', {
+          notificationCount: pendingNotifications.length,
+        });
         preamble.push({ role: 'user', content: taskNotificationsXml });
       }
     });

package/src/domains/guardian-tick.ts

@@ -19,6 +19,8 @@ export interface GuardianDeps {
   execute?: (command: string) => Promise<SpawnOutcome>;
   /** Injected only for deterministic expiry-alert tests. Production reads the local Grok auth file. */
   grokExpiry?: () => string | null;
+  /** Injected in tests; production reevaluates recorded doctor visits without dispatching a prescription. */
+  doctorShadow?: () => void | Promise<void>;
   hostName?: string;
 }
 
@@ -100,6 +102,13 @@ export async function guardianTick(now: Date, plan: GuardianPlan, deps: Guardian
       errorName: error instanceof Error ? error.name : 'unknown',
     });
   }
+  try {
+    await deps.doctorShadow?.();
+  } catch (error) {
+    debug.log('guardian.doctor-shadow', 'reevaluation-failed', {
+      errorName: error instanceof Error ? error.name : 'unknown',
+    });
+  }
   const timeZone = plan.timeZone ?? resolveTimeZone().timeZone;
   const wouldRun: string[] = [];
   let executed = 0;

package/src/domains/knowledge.ts

@@ -52,7 +52,7 @@ export interface KnowledgeDoc {
   //     의미검색으로 회상(domain='elanous'). [[self-awareness]].
   //   memory = M3 consolidation(2026-07-08): 흐린 에피소드 다수를 의미 umbrella 1건으로
   //     압축·영속(에피소드→의미·수면 공고화). 원본은 consolidated 마킹.
-  kind: 'signal' | 'dig' | 'alpha' | 'xreport' | 'morning' | 'outbound' | 'docs' | 'memory' | 'taste';
+  kind: 'signal' | 'dig' | 'alpha' | 'xreport' | 'morning' | 'outbound' | 'docs' | 'memory' | 'taste' | 'reference';
   sector_tags: string | null;
   text: string;
   source_ref: string | null;

package/src/esc-abort-gate.ts

@@ -33,7 +33,7 @@ import type { ModalBounds, ModalSurface } from './display/modal-stack.js';
 import type { KeyEvent } from './display/types.js';
 import type { ThemeTokens } from './theme/tokens.js';
 import { debug } from './debug/log.js';
-import { abortTurnOnly } from './turn-abort-scope.js';
+import { abortAndKillChildren, abortTurnOnly } from './turn-abort-scope.js';
 import { SELF_IMPLEMENT_TOOL_NAMES } from './boot/daemon-tools/self-implement-names.js';
 
 export const DASHBOARD_CLARIFICATION_REQUEST = Symbol.for('elanous.dashboard.clarification-request');
@@ -57,6 +57,10 @@ export interface EscAbortGateDeps {
   getWaitingTargetNames?: () => readonly string[];
   /** Only an identified foreground harness run may bypass the sub-agent confirmation. */
   shouldAbortImmediately?: () => boolean;
+  /** Seat mode can have no operator to answer a confirmation: Esc stops this turn and its children without opening a modal. */
+  forceStopWithoutModal?: () => boolean;
+  /** Non-modal replacement for the approval surface in unattended TUI mode. Timeout/cancel resolves false. */
+  confirmStopInline?: () => Promise<boolean>;
   /** Called before abortTurnOnly so the UI can paint a visible pending state immediately. */
   onAbortPending?: (event: { running: number; repeat: number; targets: readonly string[] }) => void;
   /** Called when another Escape arrives after the first abort request. */
@@ -218,7 +222,9 @@ export function createEscAbortGate(deps: EscAbortGateDeps): EscAbortGate {
   let current: ApprovalModalHandle | null = null;
   let currentDispose: (() => void) | null = null;
   let abortPending = false;
+  let inlineConfirmationPending = false;
   let escapePresses = 0;
+  let disposed = false;
 
   const redraw = (): void => {
     try { deps.requestRedraw?.(); } catch { /* ignore */ }
@@ -282,6 +288,31 @@ export function createEscAbortGate(deps: EscAbortGateDeps): EscAbortGate {
         return;
       }
       const running = deps.getRunningCount();
+      if (running > 0 && deps.forceStopWithoutModal?.()) {
+        if (inlineConfirmationPending) return;
+        if (!deps.confirmStopInline) {
+          debug.log('esc.abort', 'unattended-force-stop', { running, repeat: Math.max(0, escapePresses - 1) });
+          abortAndKillChildren(deps.abortCtrl);
+          redraw();
+          return;
+        }
+        inlineConfirmationPending = true;
+        debug.log('esc.abort', 'unattended-inline-confirmation', { running, repeat: Math.max(0, escapePresses - 1) });
+        void deps.confirmStopInline().then((confirmed) => {
+          if (confirmed && !disposed && !deps.abortCtrl.signal.aborted) {
+            debug.log('esc.abort', 'unattended-inline-confirmed', { running });
+            abortAndKillChildren(deps.abortCtrl);
+          } else {
+            debug.log('esc.abort', 'unattended-inline-cancelled', { running, reason: 'declined-or-timeout' });
+            resetAbortRequestState();
+          }
+        }).catch((error) => {
+          debug.log('esc.abort', 'unattended-inline-failed', { reason: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+          resetAbortRequestState();
+        }).finally(() => { inlineConfirmationPending = false; redraw(); });
+        redraw();
+        return;
+      }
       if (running <= 0 || deps.shouldAbortImmediately?.()) {
         debug.log('esc.abort', 'abort-immediately', { running, repeat: Math.max(0, escapePresses - 1) });
         abortPendingTurn(running);
@@ -347,6 +378,7 @@ export function createEscAbortGate(deps: EscAbortGateDeps): EscAbortGate {
       resetAbortRequestState();
     },
     dispose(): void {
+      disposed = true;
       if (current) current.dispose(false);
       resetAbortRequestState();
       close();

package/src/execution-loop/launch-gate.ts

@@ -1,6 +1,9 @@
 import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
+import { closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, writeSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { assertLedgerPathPolicy } from '../harness/launch-utterance-ledger.js';
 import { extractVerbatimOriginalAsk } from '../self-implement/goal-author.js';
 import { loadRunLedger } from '../self-implement/run-ledger.js';
 import { queryRunningRuns, type QueriedRunningRunsResult } from '../self-implement/running-runs.js';
@@ -252,6 +255,8 @@ export interface PreLaunchGateInput {
 
 export interface PreLaunchGateDeps extends ActiveRunsForGoalDeps {
   activeRuns?: (goalId: string) => ActiveRunsForGoal;
+  /** LAUNCH-SINGLE-DOOR-1C — 주입 우선 단일문: 시험 우주가 격리 루트의 문을 끼워 생산 배선을 그대로 검증한다. */
+  launchDoor?: LaunchRequestDoor;
 }
 
 export interface PreLaunchGateDecision {
@@ -279,3 +284,203 @@ function decidePreLaunch(input: PreLaunchGateInput, deps: PreLaunchGateDeps): Pr
   }
   return { action: 'proceed', sameGoalActiveRuns, budget, reason: sameGoalActiveRuns === 'unknown' ? 'active runs unknown' : input.forceLaunch && sameGoalActiveRuns.length > 0 ? 'duplicate overridden by force-launch' : 'no confirmed duplicate' };
 }
+
+// ─────────────────────────────────────────────────────────────────────────────────────
+// LAUNCH-SINGLE-DOOR-1C — 발사 요청의 단일 문.
+// ─────────────────────────────────────────────────────────────────────────────────────
+
+/** Env contract: hand 가 소비한 requestId 를 자식 say 가 물려받아 같은 문을 다시 두드리지 않게 한다(한 번만 상속). */
+export const LAUNCH_DOOR_RECEIPT_ENV = 'ELANOUS_LAUNCH_DOOR_RECEIPT';
+
+/** append 전용 요청 원장의 행 종류 — 요청(중복 포함)·소비·거절·강제·실패·단일문 사용 불가 관측. */
+export type LaunchRequestLedgerEvent = 'requested' | 'consumed' | 'refused-duplicate' | 'forced-duplicate' | 'launch-failed' | 'door-unavailable';
+
+/** append 전용 요청 원장의 한 행 — 행은 지우거나 고치지 않는다(관측 전용). */
+export interface LaunchRequestLedgerRow {
+  readonly event: LaunchRequestLedgerEvent;
+  readonly requestId: string;
+  readonly at: string;
+  readonly source?: string;
+  readonly receiptId?: string;
+  readonly reason?: string;
+}
+
+/** requestId 단위 소비 영수증 — 최초 1회만 발급된다(O_EXCL 파일이 곧 영수증이다). */
+export interface LaunchRequestReceipt {
+  readonly requestId: string;
+  readonly receiptId: string;
+  readonly at: string;
+  readonly source?: string;
+}
+
+/** `consume` 의 답 — `refused` 는 기존 영수증을 읽어 사유와 함께 거절한 것이다. */
+export type LaunchRequestConsumption =
+  | { readonly status: 'consumed'; readonly requestId: string; readonly receiptId: string; readonly receiptAt: string; readonly inherited?: true }
+  | { readonly status: 'forced'; readonly requestId: string; readonly receiptId: string | null; readonly receiptAt: string | null; readonly reason: string }
+  | { readonly status: 'refused'; readonly requestId: string; readonly receiptId: string | null; readonly receiptAt: string | null; readonly reason: string }
+  | { readonly status: 'unavailable'; readonly requestId: string; readonly reason: string };
+
+/** 발사 요청의 단일 문 — 원장 append · 단일 소비 · 실패 기록 · 원장 조회. */
+export interface LaunchRequestDoor {
+  /** 요청 한 건을 원장에 append 하고 그 requestId 를 돌려준다(중복 재요청도 매번 append 된다). */
+  requestId(ask: string): string;
+  /** requestId 단위 단일 소비 — 영수증은 최초 1회만 발급된다(두 번째는 기존 영수증과 사유로 거절). */
+  consume(requestId: string, opts?: { readonly force?: boolean; readonly inheritedReceipt?: string }): LaunchRequestConsumption;
+  /** 발사 실패 사유를 원장에 append 한다(관측 — 발사를 막지 않는다). */
+  fail(requestId: string, reason: string): void;
+  /** 원장 조회 — 중복 거절·실패·재시도 사유를 읽는다(인자를 주면 그 requestId 의 행만). */
+  rows(requestId?: string): readonly LaunchRequestLedgerRow[];
+}
+
+/** 단일문 deps — 원장 뿌리(기본 = 이 우주의 실효 인스턴스 루트)·시계·요청 출처 표지. */
+export interface LaunchRequestDoorDeps {
+  readonly root?: string;
+  readonly now?: () => Date;
+  readonly source?: string;
+}
+
+const LAUNCH_REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const LAUNCH_REQUEST_DATE_FILE = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
+
+function launchRequestLedgerDir(root: string): string {
+  return join(resolve(root), 'launch-requests');
+}
+
+/** 단일문을 연다 — 문 자체는 상태를 갖지 않고, 원장·영수증은 이 우주의 인스턴스 루트 아래 파일로 남는다. */
+export function openLaunchRequestDoor(deps: LaunchRequestDoorDeps = {}): LaunchRequestDoor {
+  const dir = launchRequestLedgerDir(deps.root ?? effectiveInstanceRoot());
+  const receiptsDir = join(dir, 'receipts');
+  const now = deps.now ?? (() => new Date());
+  const source = deps.source;
+
+  const observe = (event: string, data: Record<string, unknown>): void => {
+    try { debug.log('execution-loop.launch-gate', event, data, { level: 'warn' }); } catch { /* 관측은 fail-soft */ }
+  };
+
+  const appendRow = (row: LaunchRequestLedgerRow): boolean => {
+    try {
+      assertLedgerPathPolicy(dir);
+      mkdirSync(dir, { recursive: true, mode: 0o700 });
+      assertLedgerPathPolicy(dir);
+      if (!lstatSync(dir).isDirectory()) throw new Error(`launch request ledger dir is not a directory: ${dir}`);
+      const file = join(dir, `${row.at.slice(0, 10)}.jsonl`);
+      const fd = openSync(file, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW, 0o600);
+      try {
+        if (!fstatSync(fd).isFile()) throw new Error(`launch request ledger file is not a regular file: ${file}`);
+        writeSync(fd, `${JSON.stringify(row)}\n`);
+      } finally { closeSync(fd); }
+      return true;
+    } catch (error) {
+      observe('request-ledger-unwritten', { event: row.event, requestId: row.requestId, reason: error instanceof Error ? error.message : String(error) });
+      return false;
+    }
+  };
+
+  const readReceipt = (requestId: string): LaunchRequestReceipt | null => {
+    try {
+      const fd = openSync(join(receiptsDir, `${requestId}.json`), constants.O_RDONLY | constants.O_NOFOLLOW);
+      try {
+        if (!fstatSync(fd).isFile()) return null;
+        const parsed = JSON.parse(readFileSync(fd, 'utf8')) as LaunchRequestReceipt;
+        return parsed && typeof parsed === 'object' && parsed.requestId === requestId
+          && typeof parsed.receiptId === 'string' && typeof parsed.at === 'string' ? parsed : null;
+      } finally { closeSync(fd); }
+    } catch { return null; }
+  };
+
+  const requestId = (ask: string): string => {
+    const id = launchRequestId(ask);
+    appendRow({ event: 'requested', requestId: id, at: now().toISOString(), ...(source ? { source } : {}) });
+    return id;
+  };
+
+  const consume = (id: string, opts: { readonly force?: boolean; readonly inheritedReceipt?: string } = {}): LaunchRequestConsumption => {
+    if (!LAUNCH_REQUEST_ID_PATTERN.test(id)) {
+      return { status: 'unavailable', requestId: id, reason: `requestId 가 원장 키로 쓸 수 없다: ${JSON.stringify(id)}` };
+    }
+    const at = now().toISOString();
+    // 부모(hand)가 같은 requestId 를 이미 소비했다면 상속 영수증으로 지나간다 — 새 영수증을 만들지 않는다.
+    if (opts.inheritedReceipt !== undefined && opts.inheritedReceipt === id) {
+      const inherited = readReceipt(id);
+      if (inherited !== null) {
+        try { debug.log('execution-loop.launch-gate', 'request-consumption-inherited', { requestId: id, receiptId: inherited.receiptId }); } catch { /* 관측은 fail-soft */ }
+        return { status: 'consumed', requestId: id, receiptId: inherited.receiptId, receiptAt: inherited.at, inherited: true };
+      }
+    }
+    const receipt: LaunchRequestReceipt = { requestId: id,
+      receiptId: `receipt-${createHash('sha256').update(`${id}:${at}`).digest('hex').slice(0, 12)}`, at,
+      ...(source ? { source } : {}) };
+    let created = true;
+    try {
+      assertLedgerPathPolicy(receiptsDir);
+      mkdirSync(receiptsDir, { recursive: true, mode: 0o700 });
+      assertLedgerPathPolicy(receiptsDir);
+      const fd = openSync(join(receiptsDir, `${id}.json`), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+      try {
+        if (!fstatSync(fd).isFile()) throw new Error(`소비 영수증이 일반 파일이 아니다: ${id}`);
+        writeSync(fd, JSON.stringify(receipt));
+      } finally { closeSync(fd); }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException)?.code !== 'EEXIST') {
+        const reason = error instanceof Error ? error.message : String(error);
+        observe('request-receipt-unavailable', { requestId: id, reason });
+        appendRow({ event: 'door-unavailable', requestId: id, at, ...(source ? { source } : {}), reason });
+        return { status: 'unavailable', requestId: id, reason: `소비 영수증을 만들지 못했다 — 발사를 막지 않는다: ${reason}` };
+      }
+      created = false;
+    }
+    if (created) {
+      appendRow({ event: 'consumed', requestId: id, at, ...(source ? { source } : {}), receiptId: receipt.receiptId });
+      return { status: 'consumed', requestId: id, receiptId: receipt.receiptId, receiptAt: receipt.at };
+    }
+    const existing = readReceipt(id);
+    if (existing === null) {
+      const reason = `requestId ${id} 의 소비 영수증이 이미 있지만 읽지 못했다 — 중복 발사 거절`;
+      appendRow({ event: 'refused-duplicate', requestId: id, at, ...(source ? { source } : {}), reason });
+      return { status: 'refused', requestId: id, receiptId: null, receiptAt: null, reason };
+    }
+    if (opts.force === true) {
+      const reason = `requestId ${id} 는 영수증 ${existing.receiptId} (${existing.at}) 로 이미 소비됐다 — force 로 다시 띄운다`;
+      appendRow({ event: 'forced-duplicate', requestId: id, at, ...(source ? { source } : {}), receiptId: existing.receiptId, reason });
+      return { status: 'forced', requestId: id, receiptId: existing.receiptId, receiptAt: existing.at, reason };
+    }
+    const reason = `requestId ${id} 는 영수증 ${existing.receiptId} (${existing.at}) 로 이미 소비됐다 — 중복 발사 거절`;
+    appendRow({ event: 'refused-duplicate', requestId: id, at, ...(source ? { source } : {}), receiptId: existing.receiptId, reason });
+    return { status: 'refused', requestId: id, receiptId: existing.receiptId, receiptAt: existing.at, reason };
+  };
+
+  const fail = (id: string, reason: string): void => {
+    appendRow({ event: 'launch-failed', requestId: id, at: now().toISOString(),
+      ...(source ? { source } : {}), reason: reason.trim() || '사유 없음' });
+  };
+
+  const rows = (requestId?: string): readonly LaunchRequestLedgerRow[] => {
+    const result: LaunchRequestLedgerRow[] = [];
+    let names: string[];
+    try {
+      assertLedgerPathPolicy(dir);
+      names = readdirSync(dir);
+    } catch { return result; }
+    for (const name of names.filter((candidate) => LAUNCH_REQUEST_DATE_FILE.test(candidate)).sort()) {
+      let text: string;
+      try {
+        const fd = openSync(join(dir, name), constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+          if (!fstatSync(fd).isFile()) continue;
+          text = readFileSync(fd, 'utf8');
+        } finally { closeSync(fd); }
+      } catch { continue; }
+      for (const line of text.split('\n')) {
+        if (!line) continue;
+        try {
+          const row = JSON.parse(line) as LaunchRequestLedgerRow;
+          if (row && typeof row === 'object' && typeof row.event === 'string' && typeof row.requestId === 'string'
+            && typeof row.at === 'string' && (requestId === undefined || row.requestId === requestId)) result.push(row);
+        } catch { /* 찢어진 줄은 건너뛴다 */ }
+      }
+    }
+    return result;
+  };
+
+  return { requestId, consume, fail, rows };
+}