elanous 0.2.38 → 0.2.40

package/src/self-implement/run-stop.ts

@@ -40,6 +40,15 @@ export interface RunStopRecord {
 export const RUN_STOP_EVENT = 'stop';
 export const RUN_STOP_CAUSE_MAX = 120;
 
+type RunStopListener = (entry: RunLedgerEntry) => void;
+const runStopListeners = new Set<RunStopListener>();
+
+/** Subscribe to live terminal run-stop facts. The durable ledger remains the source of truth. */
+export function onRunStop(listener: RunStopListener): () => void {
+  runStopListeners.add(listener);
+  return () => { runStopListeners.delete(listener); };
+}
+
 export interface RunStopInput {
   runId: string;
   goalId?: string;
@@ -121,6 +130,9 @@ export function recordRunStop(input: RunStopInput, write: RunLedgerWriter = appe
   write(entry);
   if (recordedThisProcess.size >= RECORDED_MAX) recordedThisProcess.clear();
   recordedThisProcess.add(input.runId);
+  for (const listener of runStopListeners) {
+    try { listener(entry); } catch { /* wake consumers cannot change run outcome */ }
+  }
   try {
     debug.log('self-implement.run-stop', 'recorded', { runId: input.runId, site: input.site ?? null, ...record, requestedClass: input.class ?? null });
   } catch { /* observation is fail-soft */ }

package/src/self-implement/seams.ts

@@ -2236,7 +2236,10 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       };
       if (failedTest) {
         const worktreeLog = failedTest.output ?? '';
-        const failedFiles = [...new Set(extractGateTestFailures(worktreeLog)
+        // A supplied gate runner can report a virtual checkout, just like gate-cli's injected runner.
+        const currentFileExists = o.runIntegrityGate ? undefined : (file: string) => existsSync(resolve(cwd, file));
+        const worktreeFailures = extractGateTestFailures(worktreeLog, currentFileExists);
+        const failedFiles = [...new Set(worktreeFailures
           .flatMap((failure) => failure.file ? [failure.file] : []))];
         // 워크트리와 같은 묶음으로 베이스라인을 돌려 파일 간 간섭을 재현한다. 스코프가 없으면 실패 파일로 폴백.
         const testArgs = gateOpts.testArgs;
@@ -2246,14 +2249,14 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         const baseline = (o.runGateBaseline ?? runGateBaseline)(cwd, baselineFiles, baselineRefs.get(cwd));
         const rerun = (o.rerunBunTimeoutFailures ?? rerunBunTimeoutFailures)(
           cwd,
-          extractGateTestFailures(worktreeLog),
+          worktreeFailures,
           undefined,
           baseline.status === 'unknown' ? undefined : (baseline.output ?? ''),
           baseline.missingAtBase ?? [],
         );
         const rerunObservations = rerun instanceof Map ? rerun : rerun.observations;
         const rerunNotRun = rerun instanceof Map ? 0 : rerun.rerunNotRun;
-        const report = buildGateBaselineReport(worktreeLog, baseline, rerunObservations, rerunNotRun);
+        const report = buildGateBaselineReport(worktreeLog, baseline, rerunObservations, rerunNotRun, currentFileExists);
         baselineReport = report;
         baselineFailures = report.failures;
         const unknownReason = baseline.unknownReason;

package/src/self-implement/self-implement-cli.ts

@@ -23,6 +23,8 @@ import { readDecomposeProposals } from '../self-dev/decompose-proposal.js';
 
 /** self implement CLI 옵션(commander) — `--no-draft` 는 draft:false 로, `--max-wait` 는 문자열로 도착. */
 export interface SelfImplementCliOpts {
+  /** Managed tool dispatch cancellation signal, forwarded through the pipeline to the active implementation child. */
+  signal?: AbortSignal;
   base?: string;
   draft?: boolean;
   openPr?: boolean;
@@ -228,8 +230,8 @@ export async function runSelfImplementCliCommand(
       entry: opts.entry ?? 'external-verbatim', // CLI = 외부 창구(외부가 프롬프트 엔지니어 → verbatim 존중)
     });
     spec.entrance = opts.naturalLanguageDispatch ? 'nl-self-implement' : 'cli-self-implement';
-    const pipelineDeps = opts.approver || opts.progress
-      ? { ...deps.pipelineDeps, ...(opts.approver ? { approver: opts.approver } : {}), ...(opts.progress ? { progress: opts.progress } : {}) }
+    const pipelineDeps = opts.approver || opts.progress || opts.signal
+      ? { ...deps.pipelineDeps, ...(opts.approver ? { approver: opts.approver } : {}), ...(opts.progress ? { progress: opts.progress } : {}), ...(opts.signal ? { signal: opts.signal } : {}) }
       : deps.pipelineDeps;
     const exec = deps.executeReroute ?? executeSelfImplementReroute;
     let { result, exitCode } = await exec(spec, pipelineDeps ? { pipelineDeps } : undefined);

package/src/session/chat.ts

@@ -285,7 +285,8 @@ const childContextComposedSessions = new Set<string>();
 export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
   const loaded = loadSession(opts.sessionId);
   if (!loaded) throw new Error(`session not found: ${opts.sessionId}`);
-  const { meta, messages } = loaded;
+  const { meta } = loaded;
+  let messages = loaded.messages;
 
   // Memory injection: build the block once per turn, folded into the
   // system prompt. Never fails loud — if the store isn't set up, we
@@ -368,6 +369,19 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
   };
   appendMessage(opts.sessionId, userMsg);
 
+  const explicitTier = opts.llmOpts?.model ? undefined : explicitTurnTier(opts.userConfig, opts.sessionId);
+  const llmOpts = explicitTier ? {
+    ...(opts.llmOpts ?? {}), model: explicitTier.model,
+    ...(explicitTier.reasoningEffort && !opts.llmOpts?.reasoningEffort ? { reasoningEffort: explicitTier.reasoningEffort } : {}),
+  } : opts.llmOpts;
+  if (explicitTier) {
+    debug.log('llm.tier', 'turn-tier-applied', {
+      sessionId: opts.sessionId, tier: explicitTier.tier, source: explicitTier.source, model: explicitTier.model,
+      reasoningEffort: llmOpts?.reasoningEffort ?? null,
+    });
+  }
+  const provider = opts.provider ?? getProviderForConfig(opts.userConfig, llmOpts?.model);
+
   // 2) Assemble, trim, call. When images are attached for THIS turn,
   //    swap the string content of the latest user message for
   //    ContentBlock[] so the provider adapter sends them multimodally.
@@ -386,18 +400,67 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     return trimToBudget(wire, opts.maxTokens ?? DEFAULT_TOKEN_BUDGET);
   };
 
-  const explicitTier = opts.llmOpts?.model ? undefined : explicitTurnTier(opts.userConfig, opts.sessionId);
-  const llmOpts = explicitTier ? {
-    ...(opts.llmOpts ?? {}), model: explicitTier.model,
-    ...(explicitTier.reasoningEffort && !opts.llmOpts?.reasoningEffort ? { reasoningEffort: explicitTier.reasoningEffort } : {}),
-  } : opts.llmOpts;
-  if (explicitTier) {
-    debug.log('llm.tier', 'turn-tier-applied', {
-      sessionId: opts.sessionId, tier: explicitTier.tier, source: explicitTier.source, model: explicitTier.model,
-      reasoningEffort: llmOpts?.reasoningEffort ?? null,
-    });
-  }
-  const provider = opts.provider ?? getProviderForConfig(opts.userConfig, llmOpts?.model);
+  let measuredProviderRequests = 0;
+  const requestSizeGuard: NonNullable<LLMOpts['requestSizeGuard']> | undefined =
+    meta.source === 'tui' && provider.name === 'openai-codex'
+      ? {
+          maxChars: 400_000,
+          compactMessages: async (currentMessages) => {
+            // The first request has only the persisted transcript plus this
+            // user turn, so use the shared session compactor and rebuild from
+            // the rewritten history. Later tool rounds compact their live
+            // message list so no just-produced tool context is lost.
+            if (measuredProviderRequests === 0) {
+              const { compactSessionHistory } = await import('./compact-session.js');
+              const result = await compactSessionHistory(opts.sessionId, {
+                config: opts.userConfig.chat.autoCompact,
+                force: true,
+                modelId: llmOpts?.model ?? provider.defaultModel,
+              });
+              if (result.fired) {
+                const refreshed = loadSession(opts.sessionId);
+                if (refreshed) {
+                  // The persisted compacted session includes this turn's
+                  // user message. Drop that final persisted row here, then
+                  // assembleTurnMessages re-adds the canonical userMsg and
+                  // any image blocks from opts.userImages exactly once.
+                  messages = refreshed.messages.slice(0, -1);
+                  const rebuilt = assembleTurnMessages(effectiveSystemPrompt).kept;
+                  return { messages: rebuilt, reason: `session-${result.reason}` };
+                }
+              }
+            }
+
+            const { runCompactPipeline } = await import('../compact/pipeline.js');
+            const { getDefaultCompactProvider } = await import('../compact/provider.js');
+            const compacted = await runCompactPipeline(currentMessages, {
+              sessionId: opts.sessionId,
+              provider: getDefaultCompactProvider(),
+              activeModelId: llmOpts?.model ?? provider.defaultModel,
+              policy: {
+                preserveLastN: opts.userConfig.chat.autoCompact.preserveLastN,
+                archiveEnabled: opts.userConfig.chat.compact.archiveEnabled,
+              },
+            });
+            const diagnostics = compacted.diagnostics;
+            const changed = diagnostics.layer1ResponsesTrimmed > 0
+              || diagnostics.layer2MicrocompactCleared > 0
+              || diagnostics.layer3SummaryApplied === 1
+              || diagnostics.layer5FallbackTruncated === 1;
+            return changed
+              ? { messages: compacted.messages, reason: 'live-request-compact' }
+              : null;
+          },
+          onMeasured: (measurement) => {
+            measuredProviderRequests += 1;
+            opts.onStatusLine?.(
+              `ctx ${measurement.requestChars.toLocaleString()} chars / ${measurement.maxChars.toLocaleString()}`
+              + (measurement.compacted ? ` · compact ${measurement.reason}` : ''),
+            );
+          },
+        }
+      : undefined;
+
   let kept: LLMMessage[] = [];
   let dropped = 0;
   let used = 0;
@@ -432,6 +495,9 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
       effectiveSystemPrompt = terminal.systemPromptParts.join('\n\n');
     }
     const turnLlmOpts = terminal ? terminal.llmOpts : llmOpts;
+    const guardedTurnLlmOpts = requestSizeGuard
+      ? { ...(turnLlmOpts ?? {}), requestSizeGuard: turnLlmOpts?.requestSizeGuard ?? requestSizeGuard }
+      : turnLlmOpts;
     ({ kept, dropped, used } = assembleTurnMessages(effectiveSystemPrompt));
     // Durable tool telemetry (추적성) — pair each call's args (onToolCall) with its
     // result (onToolResult) and persist a role:'tool' message so later "어떤 도구
@@ -471,6 +537,8 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
         userText: opts.userText,
         messages: kept,
         tools: turnTools,
+        ...(guardedTurnLlmOpts?.requestSizeGuard
+          ? { requestSizeGuard: guardedTurnLlmOpts.requestSizeGuard } : {}),
         dispatchTool: async (name, args, ctx) => dispatchTool(name, args, ctx),
         signal: opts.signal ?? new AbortController().signal,
         callbacks: {
@@ -491,6 +559,8 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
         },
         ...(turnLlmOpts?.model ? { modelOverride: turnLlmOpts.model } : {}),
         ...(turnLlmOpts?.budgetGrant ? { budgetGrant: turnLlmOpts.budgetGrant } : {}),
+        ...(guardedTurnLlmOpts?.requestSizeGuard
+          ? { requestSizeGuard: guardedTurnLlmOpts.requestSizeGuard } : {}),
       };
       const maxIterations = opts.goalLoopMaxIterations ?? goalLoopCfg?.maxIterations;
       const gl = await runGoalLoop(coreCtx, maxIterations !== undefined ? { maxIterations } : {});
@@ -513,7 +583,7 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
         },
       },
       {
-        ...(turnLlmOpts ?? {}),
+        ...(guardedTurnLlmOpts ?? {}),
         tools: turnTools,
         provider,
         // ★ /cancel 범용화(대표 2026-07-12) — per-turn abort signal 을 tool 루프·llm 호출에 전파.
@@ -527,7 +597,11 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     }
   } else {
     ({ kept, dropped, used } = assembleTurnMessages(effectiveSystemPrompt));
-    const plainOpts = opts.signal ? { ...(llmOpts ?? {}), signal: opts.signal } : (llmOpts ?? {});
+    const plainOpts = {
+      ...(llmOpts ?? {}),
+      ...(requestSizeGuard ? { requestSizeGuard: llmOpts?.requestSizeGuard ?? requestSizeGuard } : {}),
+      ...(opts.signal ? { signal: opts.signal } : {}),
+    };
     const stream = provider.streamChat
       ? provider.streamChat(kept, plainOpts)
       : wrapTextOnly(provider.chat(kept, plainOpts));

package/src/session-runtime/provider-circuit.ts

@@ -0,0 +1,140 @@
+/**
+ * ⚡ SURVIVAL-PROVIDER-CIRCUIT — 공급자별 회로 차단기 (S2)
+ * 정본: 내부 문서 `RFC-tui-never-stop-survival-ladder-2026-10-27` §3 S2 · §6 B
+ *
+ * 턴 «안»의 공급자 전환(src/llm.ts decideProviderFallback → provider-fallback)은
+ * 이미 있지만, 턴이 끝나면 «방금 누가 고장 났나»를 잊는다. 다음 턴은 다시
+ * 1순위부터 열어 매번 무응답 대기를 먼저 치른다. 이 모듈은 프로세스 안에
+ * 공급자별 회로 상태를 남겨 턴을 넘어 건강을 기억한다.
+ *
+ * ⭐ 사람 의도가 이긴다(src/oauth/fallback-chain.ts 규율 ②) — 회로는 어디까지나
+ * 폴백 판정 보조다. opts.provider 로 명시·고정된 턴은 회로를 보지 않는다.
+ *
+ * 상태기계:
+ *   closed  —(10분 창 안 «전환 사유» 연속 2회 실패)→ open (냉각 5분)
+ *   open    —(냉각 경과)→ half-open
+ *   half-open —(다음 시도 1회)→ 성공: closed / 실패: open (냉각 2배, 상한 30분)
+ *
+ * 전환 사유 범주는 `isProviderFallbackEligible` 이 참인 범주
+ * (network-transient · rate-limit · overloaded · malformed) ⊕
+ * `StreamIdleTimeoutError`(stream-idle-timeout) · `OverloadFailoverError`
+ * (overload-failover) 로 한정한다. 그 외 범주(context-window · safety-blocked
+ * 등 사용자 탓)는 회로에 기록하지 않는다 — 사용자가 문면을 고치기 전까지
+ * 다른 공급자로 도망갈 이유가 없다.
+ */
+import { debug } from '../debug/log.js';
+import { isProviderFallbackEligible, type RetryCategory } from './retry-policy.js';
+
+export type ProviderCircuitState = 'closed' | 'open' | 'half-open';
+
+/** 회로 실패로 세는 «전환 사유» 범주에 추가로 들어가는 두 에러의 범주명. */
+export const CIRCUIT_EXTRA_CATEGORIES = ['stream-idle-timeout', 'overload-failover'] as const;
+
+/** 10분 창 — 같은 공급자의 «전환 사유» 실패 2회가 이 창 안에 있어야 열린다. */
+export const CIRCUIT_FAILURE_WINDOW_MS = 10 * 60_000;
+/** 첫 냉각 5분 — 다시 열릴 때마다 2배. */
+export const CIRCUIT_COOLDOWN_BASE_MS = 5 * 60_000;
+export const CIRCUIT_COOLDOWN_MAX_MS = 30 * 60_000;
+export const CIRCUIT_FAILURE_THRESHOLD = 2;
+
+interface CircuitEntry {
+  /** «전환 사유» 실패 시각(에포크 ms) — 10분 창 밖은 다듬는다. */
+  eligibleFailures: number[];
+  state: 'closed' | 'open';
+  cooldownMs: number;
+  openedAt: number;
+}
+
+/** 프로세스 안 상태 — 턴을 넘어 살아 있어야 하니 모듈 스코프에 둔다. */
+const circuits = new Map<string, CircuitEntry>();
+
+/** 실패 범주가 회로 실패(«전환 사유»)로 세는가 — 순수 판정. */
+export function isCircuitFailureCategory(category: string): boolean {
+  if ((CIRCUIT_EXTRA_CATEGORIES as readonly string[]).includes(category)) return true;
+  return isProviderFallbackEligible(
+    new Error(`circuit:${category}`),
+    category as RetryCategory,
+  );
+}
+
+function entry(name: string): CircuitEntry {
+  let entry = circuits.get(name);
+  if (!entry) {
+    entry = { eligibleFailures: [], state: 'closed', cooldownMs: CIRCUIT_COOLDOWN_BASE_MS, openedAt: 0 };
+    circuits.set(name, entry);
+  }
+  return entry;
+}
+
+function logState(
+  event: 'circuit-open' | 'circuit-half-open' | 'circuit-closed',
+  provider: string,
+  failures: number,
+  cooldownMs: number,
+): void {
+  debug.log('tui.survival', event, { provider, failures, cooldownMs });
+}
+
+/** 회로 차단기에 실패를 기록한다. «전환 사유» 범주만 세며, half-open 시험
+ * 실패는 냉각을 2배(상한 30분)로 갈아 open 을 다시 연다. */
+export function recordProviderFailure(name: string, category: string, now: number): void {
+  if (!isCircuitFailureCategory(category)) return;
+  const e = entry(name);
+  if (e.state === 'open' && now >= e.openedAt + e.cooldownMs) {
+    // half-open 시험 실패 — 다시 열리고 냉각은 2배(상한 30분).
+    e.cooldownMs = Math.min(e.cooldownMs * 2, CIRCUIT_COOLDOWN_MAX_MS);
+    e.openedAt = now;
+    e.eligibleFailures.push(now);
+    logState('circuit-open', name, e.eligibleFailures.length, e.cooldownMs);
+    return;
+  }
+  e.eligibleFailures = e.eligibleFailures.filter((t) => now - t <= CIRCUIT_FAILURE_WINDOW_MS);
+  e.eligibleFailures.push(now);
+  if (e.state === 'closed' && e.eligibleFailures.length >= CIRCUIT_FAILURE_THRESHOLD) {
+    e.state = 'open';
+    e.openedAt = now;
+    e.cooldownMs = CIRCUIT_COOLDOWN_BASE_MS;
+    logState('circuit-open', name, e.eligibleFailures.length, e.cooldownMs);
+  }
+}
+
+/** 성공 — half-open 이면 closed 로 회복하고, closed 의 실패 이력 창을 정리한다. */
+export function recordProviderSuccess(name: string, now: number): void {
+  const e = circuits.get(name);
+  if (!e) return;
+  if (e.state === 'open' && now >= e.openedAt + e.cooldownMs) {
+    e.state = 'closed';
+    e.cooldownMs = CIRCUIT_COOLDOWN_BASE_MS;
+    e.eligibleFailures = [];
+    logState('circuit-closed', name, 0, e.cooldownMs);
+    return;
+  }
+  if (e.eligibleFailures.length > 0) e.eligibleFailures = [];
+}
+
+/** 현재 회로 상태 — 주입 시계로만 판정한다. */
+export function circuitState(name: string, now: number): ProviderCircuitState {
+  const e = circuits.get(name);
+  if (!e || e.state === 'closed') return 'closed';
+  return now < e.openedAt + e.cooldownMs ? 'open' : 'half-open';
+}
+
+/** 턴의 첫 공급자 후보 — 체인 순서 그대로 첫 `closed`, 없으면 첫 `half-open`,
+ * 모두 `open` 이면 `undefined`(호출부가 원래 1순위로 열며 `circuit-all-open` 을 남긴다). */
+export function pickInitialProvider(
+  chainNames: readonly string[],
+  now: number,
+): string | undefined {
+  let firstHalfOpen: string | undefined;
+  for (const name of chainNames) {
+    const state = circuitState(name, now);
+    if (state === 'closed') return name;
+    if (state === 'half-open' && firstHalfOpen === undefined) firstHalfOpen = name;
+  }
+  return firstHalfOpen;
+}
+
+/** 테스트 전용 — 프로세스 안 회로 상태를 리셋한다. */
+export function resetProviderCircuitForTest(): void {
+  circuits.clear();
+}

package/src/shell-runner/file-engine.ts

@@ -368,6 +368,7 @@ function buildResult(
   const aggCapped = capString(agg, meta.maxOutputBytes);
   const r: ShellResult = {
     ...(meta.exitCode !== undefined ? { exitCode: meta.exitCode } : {}),
+    ...(meta.spawnError !== undefined ? { failureReason: meta.spawnError } : {}),
     stdout: stdout.toStream(meta.maxOutputBytes),
     stderr: stderr.toStream(meta.maxOutputBytes),
     aggregated: aggCapped,

package/src/shell-runner/types.ts

@@ -213,6 +213,10 @@ export interface StreamOutput {
 
 export interface ShellResult {
   exitCode?: number;
+  /** Failure detail captured at the execution boundary (for example,
+   *  the original spawn error). Kept separate from outcome so callers
+   *  can explain why no process exit status exists. */
+  failureReason?: string;
   stdout: StreamOutput;
   stderr: StreamOutput;
   /** Merged (interleaved) stream in spawn order. For File engine

package/src/sidetab-core/model.ts

@@ -0,0 +1,176 @@
+import { resolveInstanceName } from '../instance-identity.js';
+import { listPtyManifestRows, type PtyManifestRow } from '../pty-shell/pty-manifest.js';
+import { describePtyRunState } from '../pty-shell/tui-run-state.js';
+
+const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+
+export type SidetabBadge = 'busy' | 'idle' | 'stale' | 'unknown' | 'exited';
+
+export interface SidetabRow {
+  readonly id: string;
+  readonly label: string;
+  readonly kind: string;
+  readonly badge: SidetabBadge;
+  readonly sessionId?: string;
+  readonly ptyId?: string;
+  readonly nestDepth?: number;
+  readonly ownerPid?: number;
+  readonly currentProcess?: boolean;
+}
+
+export interface SidetabState {
+  readonly open: boolean;
+  readonly selected: number;
+}
+
+export interface SidetabScope {
+  readonly all?: boolean;
+  readonly currentPtyId?: string;
+  readonly currentPid?: number;
+  /** Current classic chat session; classic shell rows carry it in their purpose tag. */
+  readonly currentSessionId?: string;
+}
+
+export type SidetabKey = 'toggle' | 'up' | 'down' | 'other';
+
+export function createSidetabState(): SidetabState {
+  return { open: false, selected: 0 };
+}
+
+export function sidetabWidthForTerminal(columns: number): number {
+  return columns < 34 ? 0 : Math.min(28, Math.max(12, Math.floor(columns / 3)));
+}
+
+export function sidetabRowIndexAtTerminalRow(rowCount: number, selected: number, panelHeight: number, terminalRow: number): number | null {
+  const rowCapacity = Math.max(0, Math.floor(panelHeight) - 3);
+  const visibleCount = Math.min(rowCount, rowCapacity);
+  const offset = terminalRow - 3;
+  if (visibleCount === 0 || offset < 0 || offset >= visibleCount) return null;
+  const start = rowCount <= visibleCount
+    ? 0
+    : Math.max(0, Math.min(selected - visibleCount + 1, rowCount - visibleCount));
+  return start + offset;
+}
+
+export function applySidetabKey(state: SidetabState, key: SidetabKey, rowCount: number): SidetabState {
+  if (key === 'toggle') return { ...state, open: !state.open, selected: Math.min(state.selected, Math.max(0, rowCount - 1)) };
+  if (!state.open || rowCount === 0 || (key !== 'up' && key !== 'down')) return state;
+  const delta = key === 'up' ? -1 : 1;
+  return { ...state, selected: (state.selected + delta + rowCount) % rowCount };
+}
+
+export function sidetabRowsFromManifest(
+  rows: readonly PtyManifestRow[],
+  instance: string,
+  runState: (row: PtyManifestRow) => { turn: string; stale: boolean | null } = describePtyRunState,
+  scope?: SidetabScope,
+): SidetabRow[] {
+  const currentPid = scope?.currentPid ?? process.pid;
+  const currentSessionId = scope?.currentSessionId;
+  const eligible = rows.filter((row) => row.instance === instance && (
+    (row.kind === 'tui' && Boolean(row.sessionId))
+    || Boolean(row.parentPtyId)
+    || row.purpose?.startsWith('next-tui-sidetab:')
+    || (row.kind === 'shell'
+      && currentSessionId !== undefined
+      && row.parentPid === currentPid
+      && row.purpose?.includes(`:session:${currentSessionId}:terminal:`))
+  ));
+  let scoped = eligible;
+  if (scope) {
+    const parent = eligible.find((row) => row.kind === 'tui'
+      && (row.id === (scope.currentPtyId ?? `tui:${currentPid}`) || row.ownerPid === currentPid));
+    if (!scope.all) {
+      const includedIds = new Set<string>(parent ? [parent.id] : []);
+      const includedPids = new Set<number>(parent ? [parent.ownerPid, parent.ptyPid, currentPid] : [currentPid]);
+      let changed = true;
+      while (changed) {
+        changed = false;
+        for (const row of eligible) {
+          if (row.kind === 'tui' || includedIds.has(row.id)) continue;
+          if ((row.parentPtyId && includedIds.has(row.parentPtyId)) || (row.parentPid > 0 && includedPids.has(row.parentPid))) {
+            includedIds.add(row.id);
+            if (row.ownerPid > 0) includedPids.add(row.ownerPid);
+            if (row.ptyPid > 0) includedPids.add(row.ptyPid);
+            changed = true;
+          }
+        }
+      }
+      scoped = eligible.filter((row) => includedIds.has(row.id));
+    }
+    if (!scope.all) scoped = scoped.filter((row) => row.alive);
+  }
+  return scoped
+    .map((row) => {
+      const badge: SidetabBadge = !row.alive
+        ? 'exited'
+        : (() => {
+            const state = runState(row);
+            return state.stale === true ? 'stale' : state.turn === 'busy' ? 'busy' : state.turn === 'idle' ? 'idle' : 'unknown';
+          })();
+      const sessionId = row.purpose?.startsWith('next-tui-sidetab:') ? row.purpose.slice('next-tui-sidetab:'.length) : undefined;
+      const classicTerminalSessionId = currentSessionId !== undefined && row.kind === 'shell'
+        ? row.purpose?.split(`:session:${currentSessionId}:terminal:`)[1]
+        : undefined;
+      return {
+        id: row.id,
+        label: `${'  '.repeat(Math.min(2, row.nestDepth ?? 0))}${row.nickname || row.purpose || row.cmd || row.kind}`,
+        ...(row.sessionId ? { sessionId: row.sessionId } : {}),
+        kind: row.kind,
+        badge,
+        ptyId: row.id,
+        nestDepth: row.nestDepth,
+        ownerPid: row.ownerPid,
+        currentProcess: row.kind === 'tui' && row.ownerPid === process.pid,
+        ...(sessionId ? { sessionId } : classicTerminalSessionId ? { sessionId: classicTerminalSessionId } : {}),
+      };
+    });
+}
+
+export function loadSidetabRows(all = false, currentSessionId?: string): SidetabRow[] {
+  return sidetabRowsFromManifest(listPtyManifestRows(), resolveInstanceName(), describePtyRunState, {
+    all,
+    ...(currentSessionId ? { currentSessionId } : {}),
+  });
+}
+
+export function formatSidetabLines(
+  rows: readonly SidetabRow[],
+  selected: number,
+  width: number,
+  height = Number.POSITIVE_INFINITY,
+  mode: 'list' | 'new' = 'list',
+): string[] {
+  const fit = (value: string): string => {
+    const segments = [...graphemes.segment(value)].map(({ segment }) => segment);
+    const truncated = Bun.stringWidth(value) > width;
+    const limit = truncated ? Math.max(0, width - 1) : width;
+    let result = '';
+    let used = 0;
+    for (const segment of segments) {
+      const cells = Bun.stringWidth(segment);
+      if (used + cells > limit) break;
+      result += segment;
+      used += cells;
+    }
+    if (truncated && width > 0) { result += '…'; used++; }
+    return result + ' '.repeat(Math.max(0, width - used));
+  };
+  const lines = mode === 'new'
+    ? [fit(' 새 PTY'), fit(' s shell · e elanous'), fit(' c codex · l claude · Esc')]
+    : [fit(' 세션 · PTY'), fit(' ↑↓ 전환 · 클릭 선택')];
+  const rowCapacity = Math.max(0, Math.floor(height) - lines.length - (mode === 'list' ? 1 : 0));
+  const visibleCount = Math.min(rows.length || 1, rowCapacity);
+  const start = rows.length <= visibleCount
+    ? 0
+    : Math.max(0, Math.min(selected - visibleCount + 1, rows.length - visibleCount));
+  if (mode === 'list' && rows.length === 0 && visibleCount > 0) lines.push(fit(' 항목 없음'));
+  for (let offset = 0; offset < visibleCount && rows.length > 0; offset++) {
+    const index = start + offset;
+    const row = rows[index]!;
+    const marker = index === selected ? '›' : ' ';
+    lines.push(fit(` ${marker} ${row.badge} ${row.label}`));
+  }
+  if (mode === 'list' && lines.length < Math.floor(height)) lines.push(fit(' + new · /side new'));
+  return lines;
+}

package/src/skills/tools/schedule-wakeup.ts

@@ -449,8 +449,30 @@ export function createDashboardWakeupScheduler(
   gate: Pick<InternalTurnGate, 'startTurnIfIdle' | 'isInternalTurnActive' | 'lastTurnId'>,
   deps: Omit<WakeupSchedulerDeps, 'startTurnIfIdle' | 'isTurnActive'> = {},
 ): WakeupScheduler {
+  // The N03 real-TUI scenario must cover a scheduled wake while a turn is busy,
+  // then the one-minute retry after it settles. Keep the logical clock exact,
+  // but let that isolated fake-LLM fixture advance timer deadlines quickly.
+  // Both opt-ins are required; ordinary TUI sessions always use wall-clock time.
+  const acceleratedTestClock = process.env.ELANOUS_TEST_FAKE_LLM === '1'
+    && process.env.ELANOUS_TEST_FAST_WAKEUP_CLOCK === '1';
+  let testNow = Date.now();
+  let testTimerCount = 0;
+  const schedulerDeps: Omit<WakeupSchedulerDeps, 'startTurnIfIdle' | 'isTurnActive'> = acceleratedTestClock
+    ? {
+      ...deps,
+      now: () => testNow,
+      setTimer: (callback, logicalDelayMs) => {
+        const realDelayMs = testTimerCount++ === 0 ? 3_000 : 8_000;
+        return setTimeout(() => {
+          testNow += logicalDelayMs;
+          callback();
+        }, realDelayMs);
+      },
+      clearTimer: (timer) => clearTimeout(timer as ReturnType<typeof setTimeout>),
+    }
+    : deps;
   return createWakeupScheduler({
-    ...deps,
+    ...schedulerDeps,
     startTurnIfIdle: (text, opts) => gate.startTurnIfIdle(text, opts),
     isTurnActive: (turnId) => gate.isInternalTurnActive() && gate.lastTurnId() === turnId,
     // 한 턴 호출 상한의 턴 경계 = H2 가 아는 마지막 턴 id(사람 제출마다 human-N · 내부 턴마다 auto-N).