elanous 0.2.35 → 0.2.37

package/src/tui-client/next-wakeup.ts

@@ -0,0 +1,191 @@
+// ── next TUI 의 자기 예약 깨움 (TUI-NEXT-QUEUE-AND-WAKE · 0.2.36 · 2026-10-22) ──────────────────────
+//
+// 🚨 무엇을 푸는가: 클래식 대시보드엔 `ScheduleWakeup`(H5) ⊕ 내부 턴 문(H2)이 있는데 next TUI 엔 없었다 —
+//   next 에서 모델이 «다음 점검 HH:MM» 이라고 적고 턴을 끝내면 그 시각에 아무것도 안 열린다.
+// ⭐ 재구현 0: 스케줄러 = 클래식 `createDashboardWakeupScheduler` · 문 = 클래식 `createInternalTurnGate` ·
+//   도구 문면·인자 = 클래식 `buildScheduleWakeupHostTool` 그대로. 바쁘면 미룸(#30291)도 스케줄러 몫 그대로다.
+// 새 것은 «한 홉»뿐이다: next 의 턴은 REPL 자식(`elanous repl --stdin-jsonl`)에서 돌아 도구도 자식에서 불린다.
+//   스케줄러는 TUI(부모)에 산다 — 자식은 Esc·/new 때 죽으므로 거기 타이머를 두면 예약이 같이 죽는다.
+//   ⇒ 자식의 `ScheduleWakeup` 은 Bun IPC(`process.send`)로 부모에 묻고, 부모가 클래식 도구 handler 로 답한다.
+//   stdin 은 턴 단위 JSONL 이라 도는 턴 «안»에 답을 실을 수 없다 — IPC 는 턴과 따로 흐른다.
+// ⛔ 하니스 자식(`ELANOUS_HARNESS_ROLE`)은 무인 런이라 도구를 안 싣는다(클래식 `registerScheduleWakeupHostTool` 과 같은 경계).
+//
+// 세 얼굴(클래식과 같다):
+//   관측 = debug.log('tui.wakeup', …) · debug.log('tui.autoturn', …) — 스케줄러·문이 이미 남긴다
+//   인지 = 예약 시각 도래 ∧ 문 판정(NotIdle · HumanTyping …)
+//   힐링 = 문이 열리면 next 가 내부 턴 한 번 · 바쁘면 1분마다 미룸(상한 30분) · 끝내 못 열면 «⏰ 예약 깨움 놓침» 한 줄
+
+import { createInternalTurnGate, formatInternalTurnBanner, isInternalTurnEnabledByEnv, type InternalTurnGate, type InternalTurnRequest } from '../dashboard/input/internal-turn.js';
+import type { LLMToolSpec } from '../llm.js';
+import type { LLMToolDef, PluginContext } from '../plugins/core/types.js';
+import {
+  SCHEDULE_WAKEUP_TOOL_NAME,
+  buildScheduleWakeupHostTool,
+  createDashboardWakeupScheduler,
+  createWakeupScheduler,
+  type WakeupScheduler,
+  type WakeupTimerHandle,
+} from '../skills/tools/schedule-wakeup.js';
+
+/** 부모(next TUI)가 REPL 자식에 «IPC 홉이 열렸다»고 알리는 표지. 없으면 자식은 도구를 안 싣는다. */
+export const NEXT_TUI_WAKEUP_IPC_ENV = 'ELANOUS_NEXT_TUI_WAKEUP_IPC';
+const CALL_TYPE = 'elanous.wakeup.call';
+const RESULT_TYPE = 'elanous.wakeup.result';
+const DEFAULT_CALL_TIMEOUT_MS = 15_000;
+
+export interface WakeupCallMessage { type: typeof CALL_TYPE; callId: string; args: Record<string, unknown> }
+export interface WakeupResultMessage { type: typeof RESULT_TYPE; callId: string; result: unknown }
+
+export function isWakeupCallMessage(message: unknown): message is WakeupCallMessage {
+  const m = message as Partial<WakeupCallMessage> | null;
+  return !!m && m.type === CALL_TYPE && typeof m.callId === 'string' && !!m.args && typeof m.args === 'object';
+}
+
+function isWakeupResultMessage(message: unknown): message is WakeupResultMessage {
+  const m = message as Partial<WakeupResultMessage> | null;
+  return !!m && m.type === RESULT_TYPE && typeof m.callId === 'string';
+}
+
+/** 부모 쪽: 자식의 호출 한 건을 클래식 도구 handler 로 풀어 답 메시지를 만든다(던지면 오류 결과). */
+export async function answerWakeupCall(tool: LLMToolDef, message: WakeupCallMessage): Promise<WakeupResultMessage> {
+  let result: unknown;
+  try {
+    // 클래식 handler 는 ctx 를 안 본다 — 대시보드도 같은 handler 를 플러그인 문맥 없이 부른다.
+    result = await tool.handler(message.args, {} as PluginContext);
+  } catch (error) {
+    result = { error: `ScheduleWakeup failed: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  return { type: RESULT_TYPE, callId: message.callId, result };
+}
+
+/** 자식이 쓰는 IPC 구멍 — `process` 의 그 부분만(시험이 같은 함수에 가짜를 넘긴다). */
+export interface WakeupIpcProcess {
+  send?: (message: unknown) => boolean | void;
+  on(event: 'message', listener: (message: unknown) => void): unknown;
+  off(event: 'message', listener: (message: unknown) => void): unknown;
+}
+
+/** 도구 문면만 꺼내는 데 쓰는 스케줄러 — handler 는 자식에서 불리지 않는다(부모가 진짜를 부른다). */
+const SPEC_ONLY_SCHEDULER: WakeupScheduler = createWakeupScheduler({
+  startTurnIfIdle: () => ({ opened: false, reason: 'Disabled' }),
+  log: () => {},
+});
+
+/**
+ * 자식(REPL) 쪽: 부모가 홉을 열었을 때만(`NEXT_TUI_WAKEUP_IPC_ENV=1` ∧ `process.send`) 클래식 `ScheduleWakeup`
+ * 문면 그대로의 도구 하나를 낸다. dispatch 는 부모에 묻고 답을 그대로 돌려준다 — 부모가 안 답하면 오류 결과.
+ */
+export function createReplWakeupTool(
+  proc: WakeupIpcProcess,
+  env: NodeJS.ProcessEnv = process.env,
+  opts: { timeoutMs?: number } = {},
+): { spec: LLMToolSpec; dispatch: (args: Record<string, unknown>) => Promise<unknown> } | null {
+  if (env[NEXT_TUI_WAKEUP_IPC_ENV] !== '1' || typeof proc.send !== 'function') return null;
+  const send = proc.send.bind(proc);
+  const { name, description, parameters } = buildScheduleWakeupHostTool(SPEC_ONLY_SCHEDULER);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
+  const waiting = new Map<string, (result: unknown) => void>();
+  let seq = 0;
+  const listener = (message: unknown): void => {
+    if (!isWakeupResultMessage(message)) return;
+    const resolve = waiting.get(message.callId);
+    if (!resolve) return;
+    waiting.delete(message.callId);
+    resolve(message.result);
+  };
+  proc.on('message', listener);
+  return {
+    spec: { name, description, parameters },
+    dispatch: (args) => new Promise<unknown>((resolve) => {
+      const callId = `c${++seq}`;
+      const timer = setTimeout(() => {
+        if (!waiting.delete(callId)) return;
+        resolve({ error: `${SCHEDULE_WAKEUP_TOOL_NAME}: next TUI did not answer` });
+      }, timeoutMs);
+      waiting.set(callId, (result) => { clearTimeout(timer); resolve(result); });
+      try {
+        send({ type: CALL_TYPE, callId, args } satisfies WakeupCallMessage);
+      } catch (error) {
+        waiting.delete(callId);
+        clearTimeout(timer);
+        resolve({ error: `${SCHEDULE_WAKEUP_TOOL_NAME}: IPC send failed: ${error instanceof Error ? error.message : String(error)}` });
+      }
+    }),
+  };
+}
+
+export interface NextTuiWakeupDeps {
+  /** next 의 `busy`(채팅 턴·압축·provider·harness 명령 중). */
+  isTurnRunning: () => boolean;
+  /** 입력칸 글 — 비어 있지 않으면 문이 HumanTyping 으로 거부한다. */
+  getBufferText: () => string;
+  /** 턴 중 쌓인 대기 제출 수 — 있으면 사람 몫이 먼저다(HumanTyping). */
+  getQueuedCount: () => number;
+  /** 문이 열렸을 때 입력 루프를 깨운다(next 는 감시 키 하나를 넣는다). true = 깨웠다. */
+  requestYield: () => boolean;
+  /** 화면 한 줄(⏰ 예약 깨움 … · 놓침). */
+  notify: (line: string) => void;
+  env?: NodeJS.ProcessEnv;
+  now?: () => number;
+  setTimer?: (fn: () => void, ms: number) => WakeupTimerHandle;
+  clearTimer?: (handle: WakeupTimerHandle) => void;
+  lastHumanKeyAt?: () => number;
+  pendingKeyCount?: () => number;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+export interface NextTuiWakeup {
+  readonly gate: InternalTurnGate;
+  readonly scheduler: WakeupScheduler;
+  /** REPL 자식이 부를 도구(부모 handler) — 하니스 자식이면 null. */
+  readonly tool: LLMToolDef | null;
+  banner(request: Pick<InternalTurnRequest, 'origin' | 'reason'>): string;
+  dispose(): void;
+}
+
+/** next TUI 에 클래식 문 ⊕ 클래식 스케줄러를 잇는다. */
+export function createNextTuiWakeup(deps: NextTuiWakeupDeps): NextTuiWakeup {
+  const env = deps.env ?? process.env;
+  const gate = createInternalTurnGate({
+    isTurnRunning: deps.isTurnRunning,
+    getBufferText: deps.getBufferText,
+    getTypeaheadCount: deps.getQueuedCount,
+    isEnabled: () => isInternalTurnEnabledByEnv(env),
+    ...(deps.now ? { now: deps.now } : {}),
+    ...(deps.lastHumanKeyAt ? { lastHumanKeyAt: deps.lastHumanKeyAt } : {}),
+    ...(deps.pendingKeyCount ? { pendingKeyCount: deps.pendingKeyCount } : {}),
+    ...(deps.log ? { log: deps.log } : {}),
+  });
+  gate.port.attach(deps.requestYield);
+  const scheduler = createDashboardWakeupScheduler(gate, {
+    notify: deps.notify,
+    ...(deps.now ? { now: deps.now } : {}),
+    ...(deps.setTimer ? { setTimer: deps.setTimer } : {}),
+    ...(deps.clearTimer ? { clearTimer: deps.clearTimer } : {}),
+    ...(deps.log ? { log: deps.log } : {}),
+  });
+  const tool = env.ELANOUS_HARNESS_ROLE?.trim() ? null : buildScheduleWakeupHostTool(scheduler);
+  return {
+    gate,
+    scheduler,
+    tool,
+    banner: formatInternalTurnBanner,
+    dispose() {
+      scheduler.dispose();
+      gate.port.detach({ yielded: true });
+    },
+  };
+}
+
+// ── 부모 쪽 홉 등록 — local-chat-turn 이 REPL 자식을 띄울 때 읽는다 ─────────────────────────────
+
+let activeWakeupTool: LLMToolDef | null = null;
+
+/** next TUI 가 부팅 때 자기 도구를 건다(끝날 때 null). 이후 띄우는 REPL 자식에만 홉이 열린다. */
+export function setNextTuiWakeupTool(tool: LLMToolDef | null): void {
+  activeWakeupTool = tool;
+}
+
+export function nextTuiWakeupTool(): LLMToolDef | null {
+  return activeWakeupTool;
+}

package/src/tui.ts

@@ -7,6 +7,7 @@ import { StringDecoder } from 'node:string_decoder';
 import { perf } from './perf-counters.js';
 import { noteInputLagKey, noteInputLagPaint } from './tui/input-lag-probe.js';
 import { debug } from './debug/log.js';
+import { startForegroundGuard } from './tty-foreground.js';
 
 // ── ANSI escape sequences ──
 const CSI = '\x1b[';
@@ -441,8 +442,12 @@ function trailingUtf8Carry(data: Buffer): Buffer {
 let _raw = false;
 let _alt = false;
 let _cancelReadKey: (() => void) | undefined;
+/** TUI-SIGTTIN-SUSPEND — stops the tty-foreground guard (src/tty-foreground.ts). */
+let _stopForegroundGuard: (() => void) | undefined;
 
 function cleanup(): void {
+  _stopForegroundGuard?.();
+  _stopForegroundGuard = undefined;
   resetRenderCache();
   _cancelReadKey?.();
   resetInputState();
@@ -473,11 +478,40 @@ function runExitNotice(): void {
   try { fn?.(); } catch { /* 알림 실패가 종료를 막지 않는다 */ }
 }
 
+/**
+ * TUI-SIGCONT-RESTORE-TERM (0.2.36 · 2026-10-22) — 멈췄다(SIGTSTP·SIGTTIN · 상태 T) `fg` 로 돌아오면 셸의 작업 제어가
+ * 터미널을 cooked 로 돌려놓았다. raw 모드·kitty/modifyOtherKeys·마우스·붙여넣기·alt 화면을 다시 세우지 않으면
+ * Enter 가 «^M», Ctrl+C 가 «^[[99;5u» 로 입력창에 박혀 먹통이 된다(10-22 OPT 실물).
+ * 지금 켜 둔 것만 다시 켜고, 렌더 캐시를 비운 뒤 `resize` 를 내 화면 전체를 다시 그리게 한다.
+ */
+export interface TerminalRestoreIo {
+  stdin: { isTTY?: boolean; setRawMode?: (mode: boolean) => unknown; resume?: () => unknown };
+  stdout: { write: (chunk: string) => unknown; emit?: (event: string) => unknown };
+}
+export function restoreTerminalAfterContinue(state: { raw: boolean; alt: boolean }, io: TerminalRestoreIo): boolean {
+  if (!state.raw && !state.alt) return false;
+  if (state.raw && io.stdin.isTTY) {
+    io.stdin.setRawMode?.(true);
+    io.stdin.resume?.();
+  }
+  io.stdout.write(ansi.mouseOn + ansi.pasteOn + ansi.kittyKbOn + ansi.modKeysOn);
+  io.stdout.write(state.alt ? ansi.altOn + ansi.hideCursor : ansi.hideCursor);
+  resetRenderCache();
+  debug.log('tui.lifecycle', 'sigcont-restored', { raw: state.raw, alt: state.alt });
+  // 화면 주인(대시보드·next)은 resize 에서 전체를 다시 그린다.
+  io.stdout.emit?.('resize');
+  return true;
+}
+
 let _exitHandlersRegistered = false;
 function registerExitHandlers(): void {
   if (_exitHandlersRegistered) return;
   _exitHandlersRegistered = true;
   process.on('exit', cleanup);
+  process.on('SIGCONT', () => {
+    try { restoreTerminalAfterContinue({ raw: _raw, alt: _alt }, { stdin: process.stdin, stdout: process.stdout }); }
+    catch { /* fail-soft: 복구 실패가 프로세스를 죽이지 않는다 */ }
+  });
   process.on('SIGINT',  () => { cleanup(); runExitNotice(); process.exit(130); });
   process.on('SIGTERM', () => { cleanup(); runExitNotice(); process.exit(143); });
 }
@@ -490,6 +524,9 @@ export function initTui(altScreen = true): void {
   process.stdin.setEncoding('utf8'); // decode UTF-8 for CJK/IME support
   process.stdin.resume();
   _raw = true;
+  // TUI-SIGTTIN-SUSPEND (10-23 n8n): a child that steals the terminal's foreground group would leave
+  // us to be stopped by SIGTTIN on the next keystroke. The guard takes it back from our own children.
+  _stopForegroundGuard ??= startForegroundGuard();
   // Enable mouse + paste globally. Kitty keyboard protocol + xterm
   // modifyOtherKeys are ALSO enabled dashboard-wide so Ctrl+M / Ctrl+J /
   // Ctrl+I / Ctrl+H can be distinguished from Enter / Tab / Backspace

package/src/ui/modal-adapter.ts

@@ -46,7 +46,7 @@ import type { ClickRegion, ClickRegistry } from './click-registry.js';
 import type { MouseEvent, MouseEventType } from './mouse-events.js';
 import { DragMachine } from './drag-machine.js';
 import type { ContextKeyService, ContextKeys } from '../input-core/context-keys.js';
-import { getDashboardContextKeyService } from '../dashboard/context/keys.js';
+import { getRuntimeContextKeyService } from '../input-core/context-key-runtime.js';
 import { ansiForPair, resolveWidgetTokens, type ThemeTokens } from '../theme/tokens.js';
 import type { BoxDecoration } from './attributes/box-decoration.js';
 import { resolveColorToken } from './chrome/resolve-color.js';
@@ -706,7 +706,7 @@ export function mountViewAsModalSurface(spec: ViewSurfaceSpec): ViewSurfaceHandl
   // least one modal of that tier exists. Proper stack-counting lands
   // in IDX-2c with the ModalTier enum + registry.
   const ctxSvc = spec.tier
-    ? (spec.contextKeyService ?? getDashboardContextKeyService())
+    ? (spec.contextKeyService ?? getRuntimeContextKeyService())
     : null;
   const ctxKey = spec.tier ? MODAL_TIER_CONTEXT_KEY[spec.tier] : null;
   if (ctxSvc && ctxKey) {

package/src/user-config.ts

@@ -3391,8 +3391,22 @@ export function parseSubscriptionReviewerSpec(raw: unknown): SubscriptionReviewe
   return { provider: 'claude-acp', ...(v.executor ? { executor: v.executor as 'cct' | 'cc' } : {}) };
 }
 
+/** Stable PR-number allocation for the three self-review lanes. Zero disables a lane. */
+export interface ReviewerMixSpec { sol: number; claude: number; glm: number }
+
+export function parseReviewerMixSpec(raw: unknown): ReviewerMixSpec | undefined {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
+  const value = raw as Record<string, unknown>;
+  if (Object.keys(value).some(key => key !== 'sol' && key !== 'claude' && key !== 'glm')) return undefined;
+  const weights = [value.sol, value.claude, value.glm];
+  if (weights.some(weight => !Number.isSafeInteger(weight) || (weight as number) < 0) ||
+      weights.every(weight => weight === 0) ||
+      !Number.isSafeInteger(weights.reduce<number>((sum, weight) => sum + (weight as number), 0))) return undefined;
+  return { sol: value.sol as number, claude: value.claude as number, glm: value.glm as number };
+}
+
 /** 역할별 LLM 선택(sparse). `reviewer` is the opt-in harness ACP lane. */
-export type RoleLlmConfig = Partial<Record<ModelRole, RoleLlmSpec>> & { reviewer?: SubscriptionReviewerSpec };
+export type RoleLlmConfig = Partial<Record<ModelRole, RoleLlmSpec>> & { reviewer?: SubscriptionReviewerSpec; reviewerMix?: ReviewerMixSpec };
 
 export type ModelResolutionSource = 'config' | 'tier' | 'environment' | 'default';
 
@@ -4354,6 +4368,10 @@ function parseRoleLlmConfig(raw: unknown): RoleLlmConfig | undefined {
     parsed.reviewer = parseSubscriptionReviewerSpec(values.reviewer);
     if (!parsed.reviewer) warnUserConfigDrop('roleLlm.reviewer', 'claude-acp reviewer 설정이 유효하지 않아 무시');
   }
+  if (values.reviewerMix !== undefined) {
+    parsed.reviewerMix = parseReviewerMixSpec(values.reviewerMix);
+    if (!parsed.reviewerMix) warnUserConfigDrop('roleLlm.reviewerMix', '리뷰 비율 설정이 유효하지 않아 무시');
+  }
   // ⛔ config 로딩은 «나머지를 살리려고» 잘못된 칸을 버리는데, 그 사실이 어디에도 안 남으면
   //   사용자는 「왜 내 설정이 안 먹지」를 영영 못 푼다(CLI 는 이름을 대며 거부하는데 여기만 조용했다).
   //   ⇒ 버린 것을 «이름과 이유»로 남긴다. 로딩 자체는 계속한다.

package/src/ux-sim/boot-daemon-tools-pty-shell-device.ts

@@ -0,0 +1,136 @@
+// ux-sim device — boot daemon-tools PtyShellStart stage (L2: env injection).
+//
+// TUI-NO-SELF-NEST (#27) needs evidence that travels the REAL call path, not
+// a source-string check: the stage below injects a TUI PTY context
+// (ELANOUS_PARENT_PTY_ID / ELANOUS_NEST_DEPTH — the same material
+// src/pty-shell/registry.ts stamps into a child's identity) and then calls
+// the production dispatcher `dispatchPtyShellTool` in
+// src/boot/daemon-tools/pty-shell.ts, which is where PtyShellStart is
+// actually served. The stage records command · rc · output tail so the run
+// transcript can go straight into a PR body.
+//
+// The stage never wants a live nested TUI: when a scenario is expected to be
+// refused, the dispatcher answers with `{ output: guidance }` and no PTY is
+// created. If a scenario slips through, the stage kills the spawned PTY
+// before reporting so the run leaves nothing behind.
+
+import { dispatchPtyShellTool } from '../boot/daemon-tools/pty-shell.js';
+import {
+  decideTuiSelfNest,
+  TUI_SELF_NEST_REJECT_MARKER,
+  type TuiSelfNestDecision,
+} from '../agent/terminal-surface.js';
+
+export interface PtyShellStageInput {
+  /** argv of the spawn request — e.g. ['eln'] or ['/usr/bin/eln', 'chat']. */
+  argv: string[];
+  /** Injected "inside a TUI" material. null ⇒ no TUI context. */
+  parentPtyId?: string | null;
+  /** Injected nest depth (ELANOUS_NEST_DEPTH). */
+  nestDepth?: number;
+  /** Extra PtyShellStart args (workdir, env, …) merged into the call. */
+  extraArgs?: Record<string, unknown>;
+}
+
+export interface PtyShellStageResult {
+  /** The argv as it crossed the production dispatcher. */
+  command: string;
+  /** 0 = the stage produced the outcome the scenario asked for. */
+  rc: number;
+  /** True when the production path refused the spawn with guidance. */
+  rejected: boolean;
+  /** Full output returned by the production dispatcher. */
+  output: string;
+  /** Last 3 lines of output — what the PR body quotes. */
+  outputTail: string;
+  /** A PTY that was created despite the scenario (leak guard). */
+  spawnedPid: string | null;
+}
+
+const ENV_KEYS = ['ELANOUS_PARENT_PTY_ID', 'ELANOUS_NEST_DEPTH', 'ELANOUS_PTY_ID'] as const;
+
+function snapshotEnv(): Record<string, string | undefined> {
+  const saved: Record<string, string | undefined> = {};
+  for (const key of ENV_KEYS) saved[key] = process.env[key];
+  return saved;
+}
+
+function restoreEnv(saved: Record<string, string | undefined>): void {
+  for (const key of ENV_KEYS) {
+    const value = saved[key];
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+}
+
+function tailOf(output: string, lines = 3): string {
+  return output.split('\n').filter((l) => l.length > 0).slice(-lines).join('\n');
+}
+
+/** Apply the scenario's TUI context to this process, exactly as a TUI-owned
+ *  seat shell would have it, then run the production PtyShellStart path. */
+export async function runPtyShellStartStage(input: PtyShellStageInput): Promise<PtyShellStageResult> {
+  const saved = snapshotEnv();
+  const parentPtyId = input.parentPtyId ?? null;
+  const nestDepth = input.nestDepth ?? 0;
+  try {
+    if (parentPtyId) {
+      process.env.ELANOUS_PARENT_PTY_ID = parentPtyId;
+      // pty-identity's getCurrentPtyId() reads its own pty id; mirror it so
+      // the stage exercises both halves of readTuiNestEnv's source chain.
+      process.env.ELANOUS_PTY_ID = parentPtyId;
+    } else {
+      delete process.env.ELANOUS_PARENT_PTY_ID;
+      delete process.env.ELANOUS_PTY_ID;
+    }
+    if (nestDepth > 0) process.env.ELANOUS_NEST_DEPTH = String(nestDepth);
+    else delete process.env.ELANOUS_NEST_DEPTH;
+
+    const [cmd, ...args] = input.argv;
+    const result = await dispatchPtyShellTool('PtyShellStart', {
+      ...(input.extraArgs ?? {}),
+      cmd: cmd ?? '',
+      args,
+    });
+
+    const shaped = (result ?? {}) as { output?: unknown; process_id?: unknown; id?: unknown };
+    const output = typeof shaped.output === 'string' ? shaped.output : JSON.stringify(result ?? null);
+    const rejected = output.includes(TUI_SELF_NEST_REJECT_MARKER);
+    const rawPid = shaped.process_id ?? shaped.id;
+    const spawnedPid = rejected || rawPid === undefined ? null : String(rawPid);
+    if (spawnedPid) {
+      try { await dispatchPtyShellTool('PtyShellKill', { process_id: spawnedPid }); } catch { /* leak guard */ }
+    }
+    return {
+      command: input.argv.join(' '),
+      rc: rejected ? 0 : 1,
+      rejected,
+      output,
+      outputTail: tailOf(output),
+      spawnedPid,
+    };
+  } finally {
+    restoreEnv(saved);
+  }
+}
+
+/** Classifier-only view of the same scenario — used for the allow-list rows
+ *  (commands that must keep running) without spawning anything. */
+export function inspectPtyShellStartStage(input: PtyShellStageInput): TuiSelfNestDecision {
+  const saved = snapshotEnv();
+  try {
+    if (input.parentPtyId) {
+      process.env.ELANOUS_PARENT_PTY_ID = input.parentPtyId;
+      process.env.ELANOUS_PTY_ID = input.parentPtyId;
+    } else {
+      delete process.env.ELANOUS_PARENT_PTY_ID;
+      delete process.env.ELANOUS_PTY_ID;
+    }
+    if ((input.nestDepth ?? 0) > 0) process.env.ELANOUS_NEST_DEPTH = String(input.nestDepth);
+    else delete process.env.ELANOUS_NEST_DEPTH;
+    const [cmd, ...args] = input.argv;
+    return decideTuiSelfNest([cmd ?? '', ...args]);
+  } finally {
+    restoreEnv(saved);
+  }
+}