elanous 0.2.36 → 0.2.38

package/src/tui/slash/resume-command.ts

@@ -0,0 +1,23 @@
+/** Lightweight `/resume` and `/session` command parsing for Next TUI startup. */
+export const RESUME_BUSY_STATUS = '응답 중에는 /resume 을 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
+/** Rows shown by `/resume` and `/session list`. */
+export const RESUME_LIST_LIMIT = 12;
+
+export type ResumeCommand =
+  | { readonly kind: 'list' }
+  | { readonly kind: 'load'; readonly prefix: string };
+
+/** `/resume` · `/session` · `/session list|ls` → list; `/resume <id>` · `/session load|resume <id>` → load. */
+export function parseResumeCommand(text: string): ResumeCommand | null {
+  const [cmd, sub, arg, ...rest] = text.trim().split(/\s+/);
+  if (rest.length > 0) return null;
+  if (cmd === '/resume') {
+    if (arg !== undefined) return null;
+    return sub === undefined ? { kind: 'list' } : { kind: 'load', prefix: sub };
+  }
+  if (cmd === '/session' || cmd === '/sessions') {
+    if (sub === undefined || ((sub === 'list' || sub === 'ls') && arg === undefined)) return { kind: 'list' };
+    if ((sub === 'load' || sub === 'resume') && arg !== undefined) return { kind: 'load', prefix: arg };
+  }
+  return null;
+}

package/src/tui/slash/resume.ts

@@ -3,73 +3,76 @@
 // 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';
-
-export const RESUME_BUSY_STATUS = '응답 중에는 /resume 을 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
-/** Rows shown by `/resume` · `/session list`. */
-export const RESUME_LIST_LIMIT = 12;
-
-export type ResumeCommand =
-  | { readonly kind: 'list' }
-  | { readonly kind: 'load'; readonly prefix: string };
-
-/** `/resume` · `/session` · `/session list|ls` → list; `/resume <id>` · `/session load|resume <id>` → load. */
-export function parseResumeCommand(text: string): ResumeCommand | null {
-  const [cmd, sub, arg, ...rest] = text.trim().split(/\s+/);
-  if (rest.length > 0) return null;
-  if (cmd === '/resume') {
-    if (arg !== undefined) return null;
-    return sub === undefined ? { kind: 'list' } : { kind: 'load', prefix: sub };
-  }
-  if (cmd === '/session' || cmd === '/sessions') {
-    if (sub === undefined || ((sub === 'list' || sub === 'ls') && arg === undefined)) return { kind: 'list' };
-    if ((sub === 'load' || sub === 'resume') && arg !== undefined) return { kind: 'load', prefix: arg };
-  }
-  return null;
-}
+import { RESUME_BUSY_STATUS, RESUME_LIST_LIMIT } from './resume-command.js';
+import { idPrefixCell, sessionIdPrefixes, sessionListTime } from '../../session/id-prefix.js';
+export { RESUME_BUSY_STATUS, RESUME_LIST_LIMIT, parseResumeCommand } from './resume-command.js';
+export type { ResumeCommand } from './resume-command.js';
 
 /** Recent conversations, newest first — the rows `/resume` shows (empty scratch sessions hidden, the active one kept). */
 export function resumeCandidates(activeId: string | null, limit = RESUME_LIST_LIMIT): SessionMeta[] {
   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,72 @@
+/** 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.',
+      '  /side         Open the Next TUI session/PTY sidetab.',
+      '  Unknown cwd or exit codes are shown as unknown.',
+      '  Next TUI mutations use explicit /side new and /side kill commands.',
+    );
+  } 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

@@ -2,8 +2,14 @@
 import type { NextTuiCompactDeps, NextTuiCompactOutcome } from '../tui/slash/compact.js';
 import { NEXT_TUI_WAKEUP_IPC_ENV, answerWakeupCall, isWakeupCallMessage, nextTuiWakeupTool } from './next-wakeup.js';
 import { isNextTuiSelfHealthSnapshot, type NextTuiSelfHealthSnapshot } from '../tui/chat/self-health-status.js';
+import { answerNextSidetabCall, isNextSidetabCall, type NextSidetabHandler } from '../tui/sidetab/nl-tool.js';
 
 const STATUS_PREFIX = 'ELANOUS_TUI_BG_STATUS\t';
+let nextSidetabHandler: NextSidetabHandler | null = null;
+
+export function setNextSidetabHandler(handler: NextSidetabHandler | null): void {
+  nextSidetabHandler = handler;
+}
 
 interface TurnResult {
   event?: string | null;
@@ -18,6 +24,7 @@ interface TurnResult {
 interface WaitingTurn {
   turnId: string;
   onDelta?: (text: string) => void;
+  onStatus?: (text: string) => void;
   resolve: (result: TurnResult) => void;
   reject: (error: Error) => void;
 }
@@ -37,6 +44,7 @@ class LocalChatSession {
     // TUI-NEXT-QUEUE-AND-WAKE: the child's ScheduleWakeup asks this process over Bun IPC — the scheduler
     // lives here because the child dies on Esc and /new. No tool registered → no IPC, env unchanged.
     const wakeupTool = nextTuiWakeupTool();
+    const sidetabHandler = nextSidetabHandler;
     this.child = Bun.spawn({
       cmd: [process.execPath, cli, 'repl', '--session', sessionId, '--json', '--stdin-jsonl'],
       stdin: 'pipe', stdout: 'pipe', stderr: 'pipe',
@@ -44,13 +52,19 @@ class LocalChatSession {
         ...process.env, ELANOUS_NEXT_TUI_BG_STATUS: '1', ELANOUS_NEXT_TUI_STREAM: '1',
         ELANOUS_NEXT_TUI_SELF_HEALTH: '1',
         ...(wakeupTool ? { [NEXT_TUI_WAKEUP_IPC_ENV]: '1' } : {}),
+        ELANOUS_NEXT_TUI_SIDETAB_IPC: sidetabHandler ? '1' : '0',
       },
-      ...(wakeupTool ? {
+      ...(wakeupTool || sidetabHandler ? {
         ipc: (message: unknown, child: { send(message: unknown): unknown }) => {
-          if (!isWakeupCallMessage(message)) return;
-          void answerWakeupCall(wakeupTool, message).then((reply) => {
-            try { child.send(reply); } catch { /* the child exited mid-call; its dispatch times out */ }
-          });
+          if (wakeupTool && isWakeupCallMessage(message)) {
+            void answerWakeupCall(wakeupTool, message).then((reply) => {
+              try { child.send(reply); } catch { /* the child exited mid-call; its dispatch times out */ }
+            });
+          } else if (sidetabHandler && isNextSidetabCall(message)) {
+            void answerNextSidetabCall(sidetabHandler, message).then((reply) => {
+              try { child.send(reply); } catch { /* the child exited mid-call; its dispatch times out */ }
+            });
+          }
         },
       } : {}),
     });
@@ -86,6 +100,12 @@ class LocalChatSession {
         }
         return;
       }
+      if (result.event === 'status') {
+        if (result.turnId === waiting.turnId && typeof result.text === 'string') {
+          try { waiting.onStatus?.(result.text); } catch { /* renderer cannot break the turn */ }
+        }
+        return;
+      }
       // Future side-channel events cannot complete a turn. Legacy final
       // frames have no event; typed final frames use event=result.
       if ('event' in result && result.event !== 'result') return;
@@ -155,12 +175,12 @@ 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[] = [], onStatus?: (text: string) => void): 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 response = new Promise<TurnResult>((resolve, reject) => { this.waiting = { turnId, onDelta, resolve, reject }; });
+    const payload = JSON.stringify({ prompt, id: turnId, ...(attachments.length ? { attachments } : {}) }) + '\n';
+    const response = new Promise<TurnResult>((resolve, reject) => { this.waiting = { turnId, onDelta, onStatus, resolve, reject }; });
     try {
       if (writePrompt) await writePrompt(payload);
       else await this.writeInput(payload);
@@ -237,6 +257,8 @@ export async function runLocalChatTurn(
   writePrompt?: (payload: string) => Promise<void>,
   onDelta?: (text: string) => void,
   compact: LocalChatTurnCompact = {},
+  attachments: readonly string[] = [],
+  onStatus?: (line: string) => void,
 ): Promise<void> {
   if (signal.aborted) throw new Error('응답을 취소했습니다');
   if (!cli) throw new Error('elanous CLI entry is unavailable');
@@ -258,7 +280,7 @@ export async function runLocalChatTurn(
   try {
     result = await session.turn(text, writePrompt, (delta) => {
       if (!signal.aborted) onDelta?.(delta);
-    });
+    }, attachments, (line) => { if (!signal.aborted) onStatus?.(line); });
   } catch (error) {
     if (signal.aborted) throw new Error('응답을 취소했습니다');
     await closeLocalChatSession(sessionId);

package/src/user-config.ts

@@ -864,7 +864,7 @@ function normalizeReportChannel(raw: unknown): TelegramReportChannel | undefined
 export interface TelegramTestChannel {
   botToken: string;
   allowedUsers?: number[];
-  /** 무인 주입(scripts/telegram-inject.ts·#24)의 대상 봇 username(예: `@example_temp_bot`). 봇이 여럿일
+  /** 무인 주입(scripts/telegram-inject.ts·#24)의 대상 봇 username(예: `@test_helper_bot`). 봇이 여럿일
    *  때 어느 봇(테스트 채널용)에 objective 를 주입할지 명시. env `TELEGRAM_TEST_BOT`/`--to` 로도 지정 가능. */
   botUsername?: string;
 }
@@ -901,7 +901,7 @@ export interface TelegramChannel {
   chatId: number;
   interactive: boolean;
   roles: string[];
-  /** 봇 username(예: `example_monad_bot`). 무인 유틸(scripts/telegram-inject.ts)이
+  /** 봇 username(예: `primary_bot`). 무인 유틸(scripts/telegram-inject.ts)이
    *  role/name 으로 대상 봇을 config 한 곳에서 찾도록 하는 조회용 필드. 선택. */
   botUsername?: string;
 }
@@ -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';
 
@@ -3887,6 +3901,8 @@ function parseProjectsConfig(raw: unknown): Record<string, ProjectConfig> | unde
 }
 
 export interface UserConfig {
+  /** Next TUI sidetab visibility: off disables it, collapsed starts folded, open starts visible. */
+  tui?: { sidetab?: 'off' | 'collapsed' | 'open' };
   projects?: Record<string, ProjectConfig>;
   /** Default personal topic watch; absent = enabled when user sources exist. */
   watch?: { enabled?: boolean };
@@ -4354,6 +4370,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 는 이름을 대며 거부하는데 여기만 조용했다).
   //   ⇒ 버린 것을 «이름과 이유»로 남긴다. 로딩 자체는 계속한다.
@@ -4374,6 +4394,7 @@ function parseRoleLlmConfig(raw: unknown): RoleLlmConfig | undefined {
 
 function defaultConfig(): UserConfig {
   return {
+    tui: { sidetab: 'collapsed' },
     cli: { helpRole: 'owner' },
     coo: { linearProject: '외부 행정·큰 일 (COO)' },
     decisions: { linearProjection: { enabled: false }, requireCrossCheck: false,
@@ -5110,9 +5131,11 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
 
   const nexus = rawObj.nexus && typeof rawObj.nexus === 'object' && !Array.isArray(rawObj.nexus)
     ? rawObj.nexus as Record<string, unknown> : {};
+  const tuiRaw = rawObj.tui && typeof rawObj.tui === 'object' && !Array.isArray(rawObj.tui) ? rawObj.tui as Record<string, unknown> : {};
   const gateRemoteConfig = parseGateRemoteConfig(rawObj.gateRemote);
   const projects = parseProjectsConfig(rawObj.projects);
   return {
+    tui: { sidetab: tuiRaw.sidetab === 'off' || tuiRaw.sidetab === 'open' ? tuiRaw.sidetab : 'collapsed' },
     ...(projects ? { projects } : {}),
     ...(rawObj.starter && typeof rawObj.starter === 'object' && !Array.isArray(rawObj.starter)
       && Array.isArray((rawObj.starter as Record<string, unknown>).topics)
@@ -6469,6 +6492,8 @@ export function saveUserConfig(
     },
   };
   const rawRest = { ...(cfg.raw ?? {}) };
+  const rawTui = rawRest.tui && typeof rawRest.tui === 'object' && !Array.isArray(rawRest.tui)
+    ? rawRest.tui as Record<string, unknown> : {};
   // projects: raw entries are kept verbatim — an invalid entry loaded from disk is preserved, not blocked (its error
   // surfaces in resolveRubricAxes) — and typed axes handed to save are validated (invalid ones refuse the save).
   const rawProjectsValue = rawRest.projects;
@@ -6751,6 +6776,8 @@ export function saveUserConfig(
     debug: cfg.debug,
     logs: cfg.logs,
     shell: cfg.shell,
+    // Preserve newer/unknown TUI settings while the typed config only knows sidetab.
+    tui: { ...rawTui, ...cfg.tui },
     errorReports: cfg.errorReports ? stripUndef({ ...cfg.errorReports }) : undefined,
     chat: stripUndef({
       fastPath: cfg.chat.fastPath,

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