elanous 0.2.37 → 0.2.40

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/runner.ts

@@ -700,6 +700,9 @@ export interface ExecuteSkillOpts {
 export interface ExecuteSkillResult {
   provider: string;
   model: string;
+  /** Final assistant answer, without the rendered tool-call transcript. */
+  finalResponse: string;
+  /** Rendered skill transcript used by interactive surfaces. */
   fullResponse: string;
 }
 
@@ -1199,6 +1202,7 @@ async function executeSkillUnrecorded(
         return {
           provider: provider.name,
           model: modelHint || provider.defaultModel,
+          finalResponse: '',
           fullResponse: display,
         };
       }
@@ -2036,9 +2040,9 @@ async function executeSkillUnrecorded(
   return {
     provider: provider.name,
     model: modelHint || provider.defaultModel,
-    // streamLLMWithTools returns LLM text only; dashboard echo uses
-    // `display` (text + bash IO) — but callers of executeSkill rarely
-    // need the raw text so we keep the public contract stable.
+    // Keep both products: interactive surfaces need the rendered transcript,
+    // while programmatic callers (e.g. skill_exec) need only the final answer.
+    finalResponse: typeof fullResponse === 'string' ? fullResponse : '',
     fullResponse: display || fullResponse,
   };
 }

package/src/skills/tools/dev-harness.ts

@@ -383,7 +383,7 @@ export async function dispatchRunDevHarness(
   const { runStagedHarnessOnSurface } = await import('../../harness/harness-membrane.js');
   const { groundMissionInCodebase } = await import('../../autopilot/mission-codebase-gate.js'); // ★ 이식 §3.1 — 하니스 Planner grounding
   const { analyzeGoalAmbiguity } = await import('../../autopilot/mission-intake-clarify.js'); // ⓪ clarify(인터뷰·경량)
-  const { invokeResearch } = await import('../../research-bridge/invoke.js'); // ★ H3 외부 research(상황부·게이트)
+  const { runResearchQuestionLadder, researchTurnForGrounding } = await import('../../auto-research/research-turn.js'); // ★ Bloom 질문을 실제 조사 호출에 연결
   const { buildSkillHint } = await import('../../harness/skill-hint.js'); // ★ H3 skill 힌트(결정론·상황부)
   const { selectHarnessSkill } = await import('../../harness/skill-select.js'); // ★ S1 실행형(luna 주경로·substring fallback)
   const { buildAttractivenessSignal } = await import('../../harness/signal-gate.js'); // ★ R3 신호 게이트(판단층·부작용0)
@@ -532,7 +532,7 @@ export async function dispatchRunDevHarness(
     // ⓪ clarify(인터뷰·경량) — phase='scope'·heavy=false 로 과도한 조사 방지(대표 원칙: 명확하면 0질문·최상위 1개만).
     analyzeGoal: (obj) => analyzeGoalAmbiguity(obj, { phase: 'scope', heavy: false }),
     // ★ H3 외부 research(상황부) — objective 가 외부지식 요할 때만(intent-gate) web 조사 → grounding 에 얹음.
-    research: (topic) => invokeResearch(topic).then((r) => ({ ok: r.ok, output: r.output })),
+    research: (topic) => runResearchQuestionLadder(topic).then(researchTurnForGrounding),
     // ★ H3 skill 힌트(상황부) — objective 의 explicit 트리거가 특정 skill 을 강하게 가리키면 grounding 힌트
     //   (결정론·실행 안 함·luna 보완축). getSkillIndex 는 프로세스 캐시. fail-soft(index 로드 실패=null).
     skillHint: (objective) => { try { return buildSkillHint(objective, getSkillIndex()); } catch { return null; } },

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

@@ -402,7 +402,7 @@ export function buildScheduleWakeupHostTool(scheduler: WakeupScheduler): LLMTool
     name: SCHEDULE_WAKEUP_TOOL_NAME,
     description:
       'Wake THIS TUI later with an internal turn: when you would write «다음 점검 HH:MM» and end the turn, call this instead so the check actually happens. '
-      + 'action=schedule (default) needs reason plus one of at ("HH:MM" local, past → tomorrow) / delaySeconds (≥60) / repeatMinutes (≥1; repeats expire after 7 days). Never provide both at and delaySeconds; the schema requires one timing variant. '
+      + 'action=schedule (default) needs reason plus one of at ("HH:MM" local, past → tomorrow) / delaySeconds (≥60) / repeatMinutes (≥1; repeats expire after 7 days). Never provide both at and delaySeconds; the scheduler validates the timing choice. '
       + 'ONE-SHOT (wake once): give only delaySeconds or at and OMIT repeatMinutes (0 also means one-shot). Set repeatMinutes only when you really want it to repeat. '
       + `action=list shows pending wakeups; action=cancel needs id. Limits: ≥60s ahead, ≤7 days, at most 5 pending, at most ${WAKEUP_MAX_CALLS_PER_TURN} schedule/cancel calls per turn. `
       + 'If the TUI is busy or the human is typing at that time it retries once a minute later, then gives up (repeats move to the next tick). '
@@ -418,11 +418,6 @@ export function buildScheduleWakeupHostTool(scheduler: WakeupScheduler): LLMTool
         id: { type: 'string', description: 'Wakeup id for action=cancel (from schedule/list).' },
       },
       required: [],
-      oneOf: [
-        { not: { anyOf: [{ required: ['at'] }, { required: ['delaySeconds'] }] } },
-        { required: ['at'], not: { required: ['delaySeconds'] } },
-        { required: ['delaySeconds'], not: { required: ['at'] } },
-      ],
     },
     handler: async (args) => {
       const action = typeof args.action === 'string' ? args.action : 'schedule';
@@ -454,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).

package/src/skills/tools/shell.ts

@@ -586,6 +586,8 @@ export interface ShellCompletionNoticeInput {
   ok: boolean;
   exitCode: number | null;
   durationMs: number;
+  /** Full bounded runner result, when the runner resolved normally. */
+  result?: RunnerResult;
   /** Set when ok === false — the runner's failure reason. */
   errorMessage?: string;
   /** Caller-supplied free-form label (RunShell's `description` arg). */
@@ -598,6 +600,29 @@ export interface ShellCompletionNoticeInput {
  *  settle (an id-keyed record here would). */
 const notifiedHandles = new WeakSet<ShellHandle>();
 let nextShellCompletionNoticeId = 0;
+const SHELL_NOTICE_STREAM_TAIL_CHARS = 64;
+
+function shellNoticeTail(output: RunnerResult['stdout'] | undefined): { text: string; truncated: boolean } {
+  if (!output) return { text: '', truncated: false };
+  const source = output.tail ?? output.text;
+  const safe = redactSecretText(source);
+  const chars = Array.from(safe);
+  return {
+    text: shellNoticeJsonField(chars.slice(-SHELL_NOTICE_STREAM_TAIL_CHARS).join('')),
+    truncated: chars.length > SHELL_NOTICE_STREAM_TAIL_CHARS,
+  };
+}
+
+function shellNoticeReason(value: string): string {
+  return redactSecretText(value);
+}
+
+function shellNoticeJsonField(value: string): string {
+  return JSON.stringify(redactSecretText(value)).replace(/\p{White_Space}/gu, (char) => {
+    const hex = char.codePointAt(0)!.toString(16).padStart(4, '0');
+    return `\\u${hex}`;
+  });
+}
 
 /** Enqueue one bg shell-handle completion notice. Returns true when this
  *  handle had not notified before (the notice was handed to `queue`),
@@ -614,15 +639,35 @@ export function enqueueShellCompletionNotice(
   if (notifiedHandles.has(input.handle)) return false;
   notifiedHandles.add(input.handle);
   const header = `RunShell bg handle=${input.handle.id} ${input.ok ? 'completed' : 'failed'}`;
-  const output = `${header}${input.ok || input.exitCode !== null ? ` exitCode=${input.exitCode ?? 'null'}` : ''} elapsed=${input.durationMs}ms${input.errorMessage ? ` error=${input.errorMessage}` : ''}`;
+  const taskId = `shell:${input.handle.id}:${++nextShellCompletionNoticeId}`;
+  const result = input.result;
+  const reason = input.errorMessage ?? result?.failureReason;
+  const reportedExitCode = result?.exitCode ?? input.exitCode;
+  const stdoutTail = shellNoticeTail(result?.stdout);
+  const stderrTail = shellNoticeTail(result?.stderr);
+  const truncated = (result?.truncated ?? false) || stdoutTail.truncated || stderrTail.truncated;
+  const output = [
+    header,
+    `taskId=${taskId}`,
+    `outcome=${result?.outcome ?? 'unknown'}`,
+    ...(result ? [`exitCode=${reportedExitCode ?? 'null'}`]
+      : reportedExitCode !== null ? [`exitCode=${reportedExitCode}`] : []),
+    `elapsed=${input.durationMs}ms`,
+    ...(result ? [`stdoutTail=${stdoutTail.text}`, `stderrTail=${stderrTail.text}`] : []),
+    ...(stdoutTail.truncated ? ['stdoutTailTruncated=true'] : []),
+    ...(stderrTail.truncated ? ['stderrTailTruncated=true'] : []),
+    ...(truncated ? ['truncated=true'] : []),
+    ...(result?.outputFilePath ? [`outputFile=${shellNoticeJsonField(result.outputFilePath)}`] : []),
+    ...(reason ? [`failureReason=${shellNoticeJsonField(reason)}`] : []),
+  ].join(' ');
   queue.enqueue({
-    taskId: `shell:${input.handle.id}:${++nextShellCompletionNoticeId}`,
+    taskId,
     agentName: 'RunShell',
     ...(input.label ? { label: input.label } : {}),
     state: input.ok ? 'done' : 'error',
     output,
-    truncated: false,
-    ...(input.errorMessage ? { errorMessage: input.errorMessage } : {}),
+    truncated,
+    ...(reason ? { errorMessage: shellNoticeReason(reason) } : {}),
     durationMs: input.durationMs,
     finishedAt: Date.now(),
   });
@@ -748,8 +793,9 @@ async function dispatchViaRunner(args: {
           ok,
           exitCode: result.exitCode ?? null,
           durationMs: result.durationMs,
+          result,
           ...(!ok ? { errorMessage: result.exitCode !== undefined
-            ? `exitCode=${result.exitCode}` : `outcome=${result.outcome}` } : {}),
+            ? `exitCode=${result.exitCode}` : result.failureReason ?? `outcome=${result.outcome}` } : {}),
           ...(args.description !== undefined ? { label: args.description } : {}),
         });
       },

package/src/status/bar.ts

@@ -322,7 +322,7 @@ function truncateAtParamSize(model: string): string {
 /** Current active LLM model pill. Pink matches Claude Code's palette.
  *
  *  2026-05-05 — provider name omitted (cloud) / `<node>:<model>` for
- *  local. Node name (e.g. `local`, `node-b`) doubles as the local-LLM
+ *  local. Node name (e.g. `local`, `node-a`) doubles as the local-LLM
  *  indicator (cloud entries have no `<node>:` prefix). When
  *  `opts.compact` is true (caller decides via terminal width), the
  *  model id portion truncates at the first parameter-size marker.
@@ -330,13 +330,13 @@ function truncateAtParamSize(model: string): string {
  *  Render shape examples:
  *   - Cloud:                       `claude-opus-4-6`, `grok-4.3`
  *   - Local (multi-node spec):     `local:qwen3.6-35b-a3b-ud-mlx`
- *                                  `node-b:qwen2.5-72b-instruct`
+ *                                  `node-a:qwen2.5-72b-instruct`
  *   - Local (legacy `local:<m>`):  `local:llama-3-8b` (unchanged)
  *   - Local (bare model):          `local:tinyllama-1b`
  *   - No model:                    bare provider name fallback.
  *  With `compact: true`:
  *   - `local:qwen3.6-35b-a3b-ud-mlx` → `local:qwen3.6-35b`
- *   - `node-b:qwen2.5-72b-instruct`    → `node-b:qwen2.5-72b`
+ *   - `node-a:qwen2.5-72b-instruct`  → `node-a:qwen2.5-72b`
  *   - `claude-opus-4-6`              → unchanged (no `\d+b` marker) */
 export function modelSegment(info: StatusModelInfo, opts: StatusBarRenderOptions = {}): string {
   // 이번 턴 실제 실행이 있으면 그 값이 «지금» 이다 — 설정/런타임 값은 실행 전 기본값일 뿐.