elanous 0.2.36 → 0.2.37

package/src/tui/slash/resume.ts

@@ -3,6 +3,7 @@
 // n8n restart «/resume» started an investigation instead of showing the sessions to pick from.
 import { debug } from '../../debug/log.js';
 import { listSessions, resolveSessionId, setActiveSessionId, type SessionMeta } from '../../session/index.js';
+import { idPrefixCell, sessionIdPrefixes, sessionListTime } from '../../session/id-prefix.js';
 
 export const RESUME_BUSY_STATUS = '응답 중에는 /resume 을 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
 /** Rows shown by `/resume` · `/session list`. */
@@ -32,44 +33,66 @@ export function resumeCandidates(activeId: string | null, limit = RESUME_LIST_LI
   return listSessions({ limit, hideEmpty: true, ...(activeId ? { keepIds: [activeId] } : {}) });
 }
 
-/** One line per session: marker · 8-char id · updated · turns · title. */
+/**
+ * One numbered line per session: number · marker · unique id prefix · updated · turns · title.
+ * The number is what `/resume <n>` takes (next TUI has no arrow picker — the list is the picker);
+ * the prefix grows past 8 characters when another stored session shares them.
+ */
 export function resumeListLines(rows: readonly SessionMeta[], activeId: string | null): string[] {
   if (rows.length === 0) return ['저장된 대화 없음'];
+  const prefixes = sessionIdPrefixes(rows.map((m) => m.id));
+  const numberWidth = String(rows.length).length;
   return [
-    `최근 대화 ${rows.length}개 · /resume <id 앞자리> 로 이어 가기`,
-    ...rows.map((m) => {
+    `최근 대화 ${rows.length}개 · /resume <번호> 또는 /resume <id 앞자리> 로 이어 가기`,
+    ...rows.map((m, i) => {
       const marker = m.id === activeId ? '▸' : ' ';
-      const when = m.updatedAt.slice(5, 16).replace('T', ' ');
+      const when = sessionListTime(m.updatedAt);
       const title = (m.title || '(제목 없음)').split('\n')[0]!.slice(0, 48);
-      return `${marker} ${m.id.slice(0, 8)}  ${when}  ${String(m.messageCount).padStart(3)}t  ${title}`;
+      return `${String(i + 1).padStart(numberWidth)}. ${marker} ${idPrefixCell(prefixes, m.id)}  ${when}  ${String(m.messageCount).padStart(3)}t  ${title}`;
     }),
   ];
 }
 
+/** `/resume 3` → the 3rd row of the list the user saw. Only 1–3 digits within the list count as a number. */
+export function resumeRowByNumber(arg: string, rows: readonly SessionMeta[]): SessionMeta | null {
+  if (!/^\d{1,3}$/.test(arg)) return null;
+  const n = Number(arg);
+  return n >= 1 && n <= rows.length ? rows[n - 1]! : null;
+}
+
 export type ResumeTuiSessionResult =
   | { readonly kind: 'started'; readonly id: string; readonly status: string }
   | { readonly kind: 'rejected'; readonly status: string };
 
 /** Resolve the prefix and make that session active; rejects while a turn runs or when the prefix misses. */
-export function requestResumeTuiSession(input: { readonly busy: boolean; readonly from: string | null; readonly prefix: string }): ResumeTuiSessionResult {
+export function requestResumeTuiSession(input: {
+  readonly busy: boolean;
+  readonly from: string | null;
+  readonly prefix: string;
+  /** The rows the last `/resume` list showed, so `/resume <n>` picks the row the user saw. */
+  readonly rows?: readonly SessionMeta[];
+}): ResumeTuiSessionResult {
   const { busy, from, prefix } = input;
   if (busy) {
     debug.log('tui.next', 'session-resume-rejected', { from, prefix, reason: 'busy' });
     return { kind: 'rejected', status: RESUME_BUSY_STATUS };
   }
-  let id: string | null;
+  const byNumber = input.rows ? resumeRowByNumber(prefix, input.rows) : null;
+  let id: string | null = byNumber?.id ?? null;
   try {
-    id = resolveSessionId(prefix);
+    if (!byNumber) id = resolveSessionId(prefix);
   } catch (error) {
     debug.log('tui.next', 'session-resume-rejected', { from, prefix, reason: 'ambiguous' });
     return { kind: 'rejected', status: error instanceof Error ? error.message : String(error) };
   }
   if (!id) {
     debug.log('tui.next', 'session-resume-rejected', { from, prefix, reason: 'not-found' });
-    return { kind: 'rejected', status: `"${prefix}" 로 시작하는 대화 없음 · /resume 으로 목록 보기` };
+    return { kind: 'rejected', status: `"${prefix}" 번호·앞자리에 맞는 대화 없음 · /resume 으로 목록 보기` };
   }
-  if (id === from) return { kind: 'rejected', status: `이미 이 대화다 · ${id.slice(0, 8)}` };
+  const shortId = sessionIdPrefixes([id]).get(id) ?? id;
+  if (id === from) return { kind: 'rejected', status: `이미 이 대화다 · ${shortId}` };
   setActiveSessionId(id);
-  debug.log('tui.next', 'session-resume', { from, to: id });
-  return { kind: 'started', id, status: `대화 이어 가기 · ${id.slice(0, 8)} · 이전 = ${from ? from.slice(0, 8) : '없음'}` };
+  debug.log('tui.next', 'session-resume', { from, to: id, by: byNumber ? 'number' : 'prefix' });
+  const shortFrom = from ? (sessionIdPrefixes([from]).get(from) ?? from) : '없음';
+  return { kind: 'started', id, status: `대화 이어 가기 · ${shortId} · 이전 = ${shortFrom}` };
 }

package/src/tui/slash/signals.ts

@@ -0,0 +1,114 @@
+// TUI-SLASH-SIGNALS — Next TUI `/signals` 슬래시 묶음(관측 전용).
+//
+// classic 의 /signals 는 dashboard 전용 registry/runtime 에 살지만, 이 handler 는 Next TUI 가
+// 직접 소유한다. src/input/control-signal-observer.ts 의 실제 defaultControlSignalObserver()
+// 싱글턴에서 읽기 API(list·latest·countsByKind)만 소비한다 — observer mutation(clear·detach)과
+// signal emission(버스 발행)은 명시적으로 범위 밖이며, dashboard/index.ts 는 import 하지 않는다.
+
+import { defaultControlSignalObserver } from '../../input/control-signal-observer.js';
+import type { ControlSignal } from '../../input/control-signal.js';
+
+/** `/signals`가 ctx 에서 쓰는 것만(구조 타입 — NextTuiContext 가 이 계약을 만족한다). */
+export interface SignalsSlashContext {
+  chatLines: string[];
+  setChatScrollOffset(value: number): void;
+  muted(text: string): string;
+  accent(text: string): string;
+  text(text: string): string;
+  error(text: string): string;
+  warning(text: string): string;
+  info(text: string): string;
+}
+
+const SIGNALS_USAGE = 'usage: /signals [help|status|latest|list [kind]]';
+
+function signalClock(createdAt: string): string {
+  return createdAt.slice(11, 19);
+}
+
+/** 관측된 신호 한 줄 요약 — 관측 API가 보증하는 필드(kind·urgency·createdAt·scope.sessionId)만 읽는다. */
+function signalSummary(signal: ControlSignal): string {
+  const sessionId = signal.scope?.sessionId;
+  return `[${signal.urgency}] ${signal.kind} · ${signalClock(signal.createdAt)}${sessionId ? ` · session ${sessionId}` : ''}`;
+}
+
+function signalsHelp(ctx: SignalsSlashContext): void {
+  ctx.chatLines.push(ctx.accent('❯ /signals help'));
+  ctx.chatLines.push(ctx.warning(`  ${SIGNALS_USAGE}`));
+  ctx.chatLines.push(ctx.muted('  · status — 종류별 관측 신호 수 요약'));
+  ctx.chatLines.push(ctx.muted('  · latest — 최신 신호 1건'));
+  ctx.chatLines.push(ctx.muted('  · list [kind] — 신호 목록(선택 kind 필터)'));
+  ctx.chatLines.push(ctx.muted('  · clear·emit 은 관측 전용 경계상 이 명령 범위 밖입니다'));
+  ctx.setChatScrollOffset(-1);
+}
+
+function signalsStatus(ctx: SignalsSlashContext): void {
+  ctx.chatLines.push(ctx.accent('❯ /signals status'));
+  const counts = defaultControlSignalObserver().countsByKind();
+  const kinds = Object.keys(counts).sort();
+  const total = kinds.reduce((sum, kind) => sum + (counts[kind] ?? 0), 0);
+  if (total === 0) {
+    ctx.chatLines.push(ctx.muted('  관측된 신호 없음 (총 0건)'));
+    ctx.setChatScrollOffset(-1);
+    return;
+  }
+  ctx.chatLines.push(ctx.text(`  신호 총 ${total}건 · 종류 ${kinds.length}종`));
+  for (const kind of kinds) {
+    ctx.chatLines.push(ctx.muted(`  · ${kind} ×${counts[kind] ?? 0}`));
+  }
+  ctx.setChatScrollOffset(-1);
+}
+
+function signalsLatest(ctx: SignalsSlashContext): void {
+  ctx.chatLines.push(ctx.accent('❯ /signals latest'));
+  const latest = defaultControlSignalObserver().latest();
+  if (!latest) {
+    ctx.chatLines.push(ctx.muted('  최신 신호 없음 — 아직 관측된 control-signal 이 없습니다'));
+  } else {
+    ctx.chatLines.push(`  ${ctx.info(signalSummary(latest))}`);
+  }
+  ctx.setChatScrollOffset(-1);
+}
+
+function signalsList(args: string[], ctx: SignalsSlashContext): void {
+  const kind = (args[1] ?? '').trim();
+  const signals = defaultControlSignalObserver().list(kind ? { kind } : undefined);
+  ctx.chatLines.push(ctx.accent(`❯ /signals list${kind ? ` ${kind}` : ''} (${signals.length}건)`));
+  if (signals.length === 0) {
+    ctx.chatLines.push(ctx.muted('  관측된 신호 없음'));
+  }
+  for (const [index, signal] of signals.entries()) {
+    ctx.chatLines.push(`  ${ctx.muted(`${index + 1}. ${signalSummary(signal)}`)}`);
+  }
+  ctx.setChatScrollOffset(-1);
+}
+
+/** `/signals` 본체 — 관측 전용. help·status·latest·list 만 실행하고 clear·emit 은 거절한다. */
+export async function handleSignalsSlash(args: string[], ctx: SignalsSlashContext): Promise<void> {
+  const sub = (args[0] ?? 'status').toLowerCase();
+  ctx.chatLines.push('');
+  if (sub === 'help') {
+    signalsHelp(ctx);
+    return;
+  }
+  if (sub === 'status') {
+    signalsStatus(ctx);
+    return;
+  }
+  if (sub === 'latest') {
+    signalsLatest(ctx);
+    return;
+  }
+  if (sub === 'list') {
+    signalsList(args, ctx);
+    return;
+  }
+  ctx.chatLines.push(ctx.accent(`❯ /signals ${sub}`));
+  if (sub === 'clear' || sub === 'emit') {
+    ctx.chatLines.push(ctx.error(`  ✗ out of scope — /signals는 관측 전용입니다 (${sub} 미지원)`));
+  } else {
+    ctx.chatLines.push(ctx.warning(`  unknown subcommand: ${sub}`));
+  }
+  ctx.chatLines.push(ctx.warning(`  ${SIGNALS_USAGE}`));
+  ctx.setChatScrollOffset(-1);
+}

package/src/tui/slash/term-next.ts

@@ -0,0 +1,71 @@
+/** Read-only terminal view exposed to the Next TUI. Tests can inject an isolated fake. */
+export interface NextTuiTermSession {
+  readonly id: string;
+  readonly title: string;
+  readonly kind: string;
+  readonly status: 'running' | 'backgrounded' | 'completed' | 'killed' | 'exited';
+  readonly cwd?: string;
+  readonly exitCode?: number | null;
+}
+
+export interface NextTuiTermSlashContext {
+  readonly chatLines: string[];
+  readonly setChatScrollOffset: (value: number) => void;
+  readonly sessions: { list(): readonly NextTuiTermSession[] | Promise<readonly NextTuiTermSession[]> };
+}
+
+const isLive = (session: NextTuiTermSession): boolean =>
+  session.status === 'running' || session.status === 'backgrounded';
+
+const unknownOrValue = (value: string | number | null | undefined): string =>
+  value === null || value === undefined || value === '' ? 'unknown' : String(value);
+
+function sessionLines(sessions: readonly NextTuiTermSession[]): string[] {
+  if (sessions.length === 0) return ['  No terminal sessions.'];
+  return sessions.map((session) => {
+    const exit = isLive(session) ? 'not-exited' : unknownOrValue(session.exitCode);
+    return `  ${session.status.padEnd(12)} ${session.id.slice(-8)} ${session.title} · cwd=${unknownOrValue(session.cwd)} · exitCode=${exit}`;
+  });
+}
+
+function matrixLines(sessions: readonly NextTuiTermSession[]): string[] {
+  if (sessions.length === 0) return ['  No terminal sessions.'];
+  return [
+    '  term:ID    character    transport   placement         groups     title',
+    ...sessions.map((session) => {
+      const dead = isLive(session) ? '' : ' exited';
+      return `  ${session.id.padEnd(10)} ${session.kind.padEnd(12)} pty         pty               -          ${session.title}${dead}`;
+    }),
+  ];
+}
+
+/** Next TUI exposes only read-only terminal inventory and status. */
+export async function handleNextTuiTermSlash(args: string[], context: NextTuiTermSlashContext): Promise<void> {
+  const command = (args[0] ?? 'help').trim().toLowerCase();
+  if (command === '' || command === 'help') {
+    context.chatLines.push(
+      '  /term help    Show Next TUI terminal commands.',
+      '  /term list    List terminal sessions.',
+      '  /term status  Show live/exited session counts.',
+      '  /term matrix  Show terminal transport and liveness.',
+      '  Unknown cwd or exit codes are shown as unknown.',
+      '  Mutating terminal commands remain on the classic terminal surface.',
+    );
+  } else if (command === 'status') {
+    const sessions = await context.sessions.list();
+    const live = sessions.filter(isLive).length;
+    const exited = sessions.length - live;
+    context.chatLines.push(`  Terminal sessions: ${live} live · ${exited} exited.`);
+  } else if (command === 'list' || command === 'matrix') {
+    const sessions = await context.sessions.list();
+    context.chatLines.push(...(command === 'list' ? sessionLines(sessions) : matrixLines(sessions)));
+  } else {
+    context.chatLines.push(`  Unsupported /term command in Next TUI: ${command}. Try /term help.`);
+  }
+  context.setChatScrollOffset(-1);
+}
+
+/** The entry point reaches this only for `/term` or `/terminal` input. */
+export async function dispatchNextTermSlash(args: string[], context: NextTuiTermSlashContext): Promise<void> {
+  await handleNextTuiTermSlash(args, context);
+}

package/src/tui-client/local-chat-turn.ts

@@ -155,11 +155,11 @@ class LocalChatSession {
     }
   }
 
-  async turn(prompt: string, writePrompt?: (payload: string) => Promise<void>, onDelta?: (text: string) => void): Promise<TurnResult> {
+  async turn(prompt: string, writePrompt?: (payload: string) => Promise<void>, onDelta?: (text: string) => void, attachments: readonly string[] = []): Promise<TurnResult> {
     if (this.closed) throw new Error('REPL child exited');
     if (this.waiting) throw new Error('REPL turn already running');
     const turnId = `tui-${++this.turnCount}`;
-    const payload = `${JSON.stringify({ prompt, id: turnId })}\n`;
+    const payload = JSON.stringify({ prompt, id: turnId, ...(attachments.length ? { attachments } : {}) }) + '\n';
     const response = new Promise<TurnResult>((resolve, reject) => { this.waiting = { turnId, onDelta, resolve, reject }; });
     try {
       if (writePrompt) await writePrompt(payload);
@@ -237,6 +237,7 @@ export async function runLocalChatTurn(
   writePrompt?: (payload: string) => Promise<void>,
   onDelta?: (text: string) => void,
   compact: LocalChatTurnCompact = {},
+  attachments: readonly string[] = [],
 ): Promise<void> {
   if (signal.aborted) throw new Error('응답을 취소했습니다');
   if (!cli) throw new Error('elanous CLI entry is unavailable');
@@ -258,7 +259,7 @@ export async function runLocalChatTurn(
   try {
     result = await session.turn(text, writePrompt, (delta) => {
       if (!signal.aborted) onDelta?.(delta);
-    });
+    }, attachments);
   } catch (error) {
     if (signal.aborted) throw new Error('응답을 취소했습니다');
     await closeLocalChatSession(sessionId);

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