elanous 0.2.37 → 0.2.40

package/src/task-orchestrator/surfaces/self-implement.ts

@@ -19,7 +19,8 @@
  * Cf. PLAN-parallel-self-dev-orchestrator-2026-07-21.
  */
 import { lstatSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import type { ReviewRework } from '../../self-dev/run-types.js';
+import type { ReviewRework, SelfDevJobResult } from '../../self-dev/run-types.js';
+import type { SelfImplementGateResult } from '../../self-implement/orchestrator.js';
 import type { WarmWorkerCommand } from './pod-warm-worker-protocol.js';
 import { oldDoorInternalEnv } from '../../self-dev/old-door.js';
 import { selfDevRunsDir } from '../../self-dev/run-store.js';
@@ -52,11 +53,15 @@ export interface SelfImplementJobDone {
 export interface SelfImplementDisposition {
   stage?: string;
   ok?: boolean;
+  /** Measured child gate receipt, forwarded only for a failed gate. */
+  gate?: SelfImplementGateResult;
   worktreePath?: string;
   branch?: string;
   harvestable?: true;
   prUrl?: string;
   prNumber?: number;
+  /** Parent-side observation carried from the child's run ledger when available. */
+  goalPlanRevision?: SelfDevJobResult['goalPlanRevision'];
   /** Head SHA checked by the Pod before host regate. */
   checkedHeadCommit?: string;
   /** Review verdict only when the child bound a real pass to a clean, unchanged worktree head. */
@@ -99,6 +104,21 @@ export interface SelfImplementDisposition {
   childEvidence?: PodChildEvidence;
 }
 
+function isGoalPlanRevisionObservation(value: unknown): value is NonNullable<SelfDevJobResult['goalPlanRevision']> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const row = value as Record<string, unknown>;
+  if (row.status === 'read') {
+    return Number.isSafeInteger(row.attempted) && Number(row.attempted) >= 0
+      && Number.isSafeInteger(row.applied) && Number(row.applied) >= 0
+      && Array.isArray(row.failureReasons) && row.failureReasons.every((reason) => typeof reason === 'string');
+  }
+  return row.status === 'read-failed'
+    && ['directory-missing', 'unreadable-directory', 'unreadable-files'].includes(String(row.reason))
+    && Number.isSafeInteger(row.scannedFiles) && Number(row.scannedFiles) >= 0
+    && Number.isSafeInteger(row.unreadableFiles) && Number(row.unreadableFiles) >= 0
+    && typeof row.ledgerDirectory === 'string';
+}
+
 export interface PodChildEvidence {
   /** Bounded, redacted diagnostics copied only from a failed child terminal result. */
   error?: string;
@@ -130,6 +150,10 @@ export interface PodChildEvidence {
     candidateCardId?: string;
     blockingCardId?: string;
   };
+  /** Harvest pointer and revision observation copied before the parent Pod stop is finalized. */
+  harvestable?: true;
+  prNumber?: number;
+  goalPlanRevision?: SelfDevJobResult['goalPlanRevision'];
 }
 
 const SCOPE_STOP_REASON_ORDER: readonly ScopeStopReason[] = SCOPE_STOP_REASONS;
@@ -208,6 +232,9 @@ export function podChildEvidenceFromResult(o: Record<string, unknown>): PodChild
     ...(o.goalCauseObserved === true ? { goalCauseObserved: true } : {}),
     ...(o.terminationReason !== undefined ? { terminationReason: scrubValue(o.terminationReason) } : {}),
     ...(accountAvailability ? { accountAvailability } : {}),
+    ...(o.harvestable === true && typeof o.branch === 'string' && o.branch.trim() ? { harvestable: true } : {}),
+    ...(typeof o.prNumber === 'number' && Number.isSafeInteger(o.prNumber) && o.prNumber > 0 ? { prNumber: o.prNumber } : {}),
+    ...(isGoalPlanRevisionObservation(o.goalPlanRevision) ? { goalPlanRevision: o.goalPlanRevision } : {}),
   };
   if (o.ok === false && typeof o.error === 'string'
     && /draft PR 생성 실패|PR (?:gh|guard) 실패|same-cell reuse:/u.test(o.error)) {
@@ -625,11 +652,15 @@ export function parseSelfImplementJson(stdout: string): SelfImplementDisposition
       const mapped: SelfImplementDisposition = {
         ...(typeof o.stage === 'string' ? { stage: o.stage } : {}),
         ...(typeof o.ok === 'boolean' ? { ok: o.ok } : {}),
+        ...(o.stage === 'gate-failed' && o.ok === false && o.gate && typeof o.gate === 'object'
+          && !Array.isArray(o.gate) && (o.gate as { passed?: unknown }).passed === false
+          ? { gate: o.gate as SelfImplementGateResult } : {}),
         ...(typeof o.worktreePath === 'string' ? { worktreePath: o.worktreePath } : {}),
         ...(typeof o.branch === 'string' ? { branch: o.branch } : {}),
         ...(o.harvestable === true && typeof o.branch === 'string' && o.branch.trim() ? { harvestable: true } : {}),
         ...(typeof o.prUrl === 'string' ? { prUrl: o.prUrl } : {}),
-        ...(typeof o.prNumber === 'number' ? { prNumber: o.prNumber } : {}),
+        ...(Number.isSafeInteger(o.prNumber) && Number(o.prNumber) > 0 ? { prNumber: Number(o.prNumber) } : {}),
+        ...(isGoalPlanRevisionObservation(o.goalPlanRevision) ? { goalPlanRevision: o.goalPlanRevision } : {}),
         ...(typeof o.checkedHeadCommit === 'string' ? { checkedHeadCommit: o.checkedHeadCommit } : {}),
         ...(o.reviewedHeadCommit && typeof o.reviewedHeadCommit === 'string' && /^[0-9a-f]{40}$/i.test(o.reviewedHeadCommit)
           && o.review && typeof o.review === 'object' && !Array.isArray(o.review)

package/src/terminal/session-registry.ts

@@ -157,6 +157,7 @@ export class TerminalSessionRegistry {
         shell: spec.shell,
         shellArgs: spec.shellArgs,
         env: spec.env,
+        unsetEnv: spec.unsetEnv,
         termName: spec.termName,
         useRegistry: spec.useRegistry,
         registryKind: spec.registryKind,

package/src/terminal/terminal-modal-router.ts

@@ -0,0 +1,156 @@
+// Shared key routing for interactive terminal modals in dashboard and TUI.
+//
+// Holds singleton state for "which interactive terminal modal is
+// currently foregrounded" + the key-intercept policy:
+//
+//   • while a modal is present, ESC / Ctrl-G dispose it
+//   • all other keys forward to modal.surface.onKey(ev) so the PTY
+//     receives them without the chat readKey loop trying to
+//     interpret them
+//
+// Kept separate from either renderer so both can use the same routing policy.
+//
+// P10 will extend this with Ctrl-B prefix handling (d=detach,
+// s=switch, etc.) once a session registry exists to act on.
+
+import type { InteractiveTerminalModalHandle } from '../interactive-terminal-modal.js';
+import type { KeyEvent } from '../display/types.js';
+import { debug } from '../debug/log.js';
+
+export type KeyRouteResult = 'consumed' | 'passthrough' | 'closed';
+
+export interface TerminalModalRouter {
+  current(): InteractiveTerminalModalHandle | null;
+  /** Install a modal handle. Optional closePolicy controls what
+   *  ESC/Ctrl-G does: 'kill' disposes the modal + PTY (default);
+   *  'detach' calls handle.dispose({keepPreview:true}) so the PTY
+   *  survives for re-attach (session registry flow). An explicit
+   *  onClose hook wins over closePolicy — that's how dashboard
+   *  wires the owning session registry's detach action on Esc. */
+  set(
+    handle: InteractiveTerminalModalHandle | null,
+    opts?: { closePolicy?: 'kill' | 'detach'; onClose?: () => void },
+  ): void;
+  close(): void;
+  handleKey(ev: KeyEvent): KeyRouteResult;
+}
+
+// `exit` typed cleanly + Enter closes the popup. claude / codex don't
+// recognize plain `exit` (their command is /exit or /quit), so a user
+// typing `exit\n` would otherwise be stuck — the popup stays open
+// because the child never exits, and the typed text just becomes chat
+// input. elanous intercepts the exact sequence at the router so:
+//   • plain shell: same end result (we close before shell evaluates)
+//   • claude / codex: popup closes as the user expected
+// Sequence is reset on any non-letter key (other than backspace, which
+// rewinds), Ctrl/Alt modifiers, or any character outside `e/x/i/t` —
+// so genuine words containing "exit" (e.g. typing "exit this loop"
+// into a claude prompt without Enter) DON'T trigger the close. The
+// trigger is specifically `e`, `x`, `i`, `t`, Enter with nothing else.
+const EXIT_CHARS = ['e', 'x', 'i', 't'] as const;
+
+export function createTerminalModalRouter(): TerminalModalRouter {
+  let handle: InteractiveTerminalModalHandle | null = null;
+  let closePolicy: 'kill' | 'detach' = 'kill';
+  let onClose: (() => void) | null = null;
+  let exitProgress = 0; // how many of EXIT_CHARS have been typed in order
+
+  const close = (): void => {
+    if (!handle) return;
+    const h = handle;
+    const cb = onClose;
+    if (debug.enabled) debug.log('window.terminalModalRouter.close', h.id, { id: h.id, closePolicy, hasOnClose: !!cb });
+    handle = null;
+    onClose = null;
+    exitProgress = 0;
+    try {
+      if (cb) cb();
+      else if (closePolicy === 'detach') h.dispose({ keepPreview: true });
+      else h.dispose();
+    } catch { /* already disposed */ }
+    closePolicy = 'kill';
+  };
+
+  return {
+    current: () => handle,
+    set: (h, opts) => {
+      if (handle && h && handle.id !== h.id) close();
+      handle = h;
+      closePolicy = opts?.closePolicy ?? 'kill';
+      onClose = opts?.onClose ?? null;
+      exitProgress = 0;
+      if (debug.enabled) {
+        debug.log('window.terminalModalRouter.set', h?.id ?? '(null)', {
+          id: h?.id ?? null,
+          closePolicy,
+          hasOnClose: !!onClose,
+        });
+      }
+    },
+    close,
+    handleKey: (ev) => {
+      if (!handle) return 'passthrough';
+      const name = (ev.name ?? '').toLowerCase();
+      // ESC must NOT close the modal — claude / codex inside the popup
+      // use ESC to cancel an in-progress chat / tool turn. Closing the
+      // wrapper window on ESC made the only-way-to-cancel kill the
+      // whole popup. iTerm / ghostty don't close their own windows on
+      // ESC either; the wrapper should match. Modal close is reserved
+      // for: Ctrl+G (close + focus log), Ctrl+Shift+T (toggle off),
+      // typed `exit\n`, and the child's own `exit`. ESC just forwards.
+      if (ev.ctrl && (name === 'g' || name === 'ㅎ')) {
+        if (debug.enabled) debug.log('window.terminalModalRouter.handleKey.close', 'ctrl-g', { id: handle.id });
+        close();
+        return 'closed';
+      }
+
+      // Track typed `exit` followed by Enter so the user's natural
+      // mental model ("type exit to quit") works inside agent popups
+      // (claude / codex) where the child app doesn't recognize a bare
+      // `exit` command. See EXIT_CHARS comment above for false-positive
+      // avoidance.
+      const noMods = !ev.ctrl && !ev.alt;
+      if (noMods && name === 'enter' && exitProgress === EXIT_CHARS.length) {
+        if (debug.enabled) {
+          debug.log('window.terminalModalRouter.handleKey.close', 'typed-exit', {
+            id: handle.id,
+          });
+        }
+        close();
+        return 'closed';
+      }
+      if (noMods && name === 'backspace') {
+        if (exitProgress > 0) exitProgress--;
+      } else if (noMods && name.length === 1 && exitProgress < EXIT_CHARS.length && name === EXIT_CHARS[exitProgress]) {
+        exitProgress++;
+      } else if (noMods && name === 'enter') {
+        // Enter without a complete `exit` prefix — reset and forward.
+        exitProgress = 0;
+      } else if (name.length === 1 || name === 'space' || ev.ctrl || ev.alt) {
+        // Any other printable key OR a modifier keystroke breaks the
+        // streak. Multi-char named keys (arrow / fn / etc.) leave the
+        // streak alone — the child may consume them without affecting
+        // the user's typed prompt buffer.
+        exitProgress = 0;
+      }
+
+      if (debug.enabled) {
+        debug.log('window.terminalModalRouter.handleKey.forward', name || '(empty)', {
+          id: handle.id,
+          name,
+          ctrl: ev.ctrl ?? false,
+          shift: ev.shift ?? false,
+          alt: ev.alt ?? false,
+          exitProgress,
+        });
+      }
+      try {
+        handle.surface.onKey?.(ev);
+      } catch { /* surface disposed mid-event; treat as no-op */ }
+      return 'consumed';
+    },
+  };
+}
+
+/** Singleton used by renderers; the factory remains available for isolated tests. */
+export const terminalModalRouter = createTerminalModalRouter();

package/src/tool-hints/gate.ts

@@ -171,17 +171,19 @@ export function evaluateGate(
 
   // ─── Step 6: model-tier budget cap ─────────────────────────────
   // Weak/cheap models pay a per-tool token tax. On codex/gpt-5 we
-  // cap the prompt at top-8 after boost sort to keep the per-call
-  // overhead bounded. Claude/Opus/Grok don't need this.
+  // cap the prompt after boost sort to keep per-call overhead bounded.
+  // Research already has an intent signal; it needs more source tools but
+  // still has a finite cap. Claude/Opus/Grok don't need this cap.
   let keep: string[] = [...enabled];
   const capped = signals.modelFamily === 'codex' || signals.modelFamily === 'gpt';
   if (capped) {
     const beforeModelFamilyCap = keep.length;
-    if (keep.length > 8) {
+    const cap = signals.researchAgent ? 16 : 8;
+    if (keep.length > cap) {
       keep = keep
         .map(id => ({ id, score: boost.get(id) ?? 0 }))
         .sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
-        .slice(0, 8)
+        .slice(0, cap)
         .map(x => x.id);
     }
     stages.modelFamilyCap = executedStage(beforeModelFamilyCap, keep.length);

package/src/tool-hints/signals.ts

@@ -29,6 +29,8 @@ export interface SignalSnapshot {
 
   // Recent conversation
   intentResearch: boolean;
+  /** Deep multi-source research route; quick fact lookups remain capped. */
+  researchAgent?: boolean;
   intentDiagram: boolean;
   recentNetworkError: boolean;
 
@@ -116,6 +118,34 @@ const NETWORK_ERROR_RE = /\b(ETIMEDOUT|ENOTFOUND|ECONNREFUSED|ECONNRESET|EHOSTUN
 // positive rate is fine because these signals only nudge a boost.
 const RESEARCH_ASCII_RE = /\b(research|find out|look up|investigate|latest (on|news)|what (are|is|does))\b/i;
 const RESEARCH_KO_RE = /(최신|뉴스|찾아(?:줘|봐)|알아봐|조사|리서치)/;
+const RESEARCH_SKILL_RE = /\b(?:omni[ -]market|omni[ -]crawl|social[ -]pulse)\b/i;
+const RESEARCH_EXPLANATION_RE = /(?:왜|이유|원인|전망|분석|비교|조사|\bwhy\b|\bcause\b|\boutlook\b|\banalysis\b|\bcompare\b)/i;
+const RESEARCH_TOPIC_RE = /(?:금리|채권|시장|경제|물가|환율|주가|기업|산업|정책|선거|역사|기후|질병|의학|과학|\bbond\b|\byield\b|\bmarket\b|\beconomy\b|\binflation\b|\bstock\b|\bpolicy\b|\belection\b|\bhistory\b|\bclimate\b|\bhealth\b|\bscience\b)/i;
+const RESEARCH_CODING_RE = /(?:코드|함수|버그|테스트|빌드|커밋|하니스|설정|오류|구현|수리|고쳐|수정|저장소|\brepo\b|\bcode\b|\bfunction\b|\bbug\b|\btest\b|\bbuild\b|\bcommit\b|\bconfig\b|\bimplement\b|\bfix\b)/i;
+const DEEP_RESEARCH_INTENT_TERMS = [
+  'research', 'deep research', 'triangulate', 'compare sources',
+  'multiple sources', 'community reaction', 'reddit reaction',
+  'x reaction', 'trend', 'sentiment', '여러 소스', '깊게 조사',
+  '리서치', '반응', '트렌드', '여론', '비교 조사', '교차검증',
+] as const;
+
+function hasResearchTurnIntent(text: string | undefined): boolean {
+  if (!text) return false;
+  if (matchesIntent(text, RESEARCH_ASCII_RE, RESEARCH_KO_RE)) return true;
+  return isResearchAgentIntent(text);
+}
+
+/** Shared research/agent verdict for surface routing and the tool catalog.
+ *  Keep the historical deep-research words before the new coding veto so
+ *  existing explicit surface choices retain their meaning. */
+export function isResearchAgentIntent(text: string | undefined): boolean {
+  if (!text) return false;
+  const lower = text.toLowerCase();
+  if (DEEP_RESEARCH_INTENT_TERMS.some((term) => lower.includes(term))) return true;
+  if (RESEARCH_CODING_RE.test(text)) return false;
+  return RESEARCH_SKILL_RE.test(text)
+    || (RESEARCH_EXPLANATION_RE.test(text) && RESEARCH_TOPIC_RE.test(text));
+}
 const DIAGRAM_ASCII_RE = /\b(diagrams?|flowcharts?|sequence|mermaid|graphs?|charts?|visuali[sz]e|architecture)\b/i;
 const DIAGRAM_KO_RE = /(시퀀스|플로우|다이어그램|도식|그래프|시각화|아키텍처|구조도)/;
 
@@ -213,7 +243,8 @@ export function collectSignals(ctx: SignalContext = {}): SignalSnapshot {
     hasNodeProject: existsSync(joinPath(cwd, 'package.json')),
     hasGitRemote: detectGitRemote(cwd),
 
-    intentResearch: matchesIntent(ctx.recentUserText, RESEARCH_ASCII_RE, RESEARCH_KO_RE),
+    intentResearch: hasResearchTurnIntent(ctx.recentUserText),
+    researchAgent: isResearchAgentIntent(ctx.recentUserText),
     intentDiagram: matchesIntent(ctx.recentUserText, DIAGRAM_ASCII_RE, DIAGRAM_KO_RE),
     recentNetworkError: hasRecentNetworkError(ctx.recentToolResults),
 
@@ -284,6 +315,7 @@ function fingerprintOf(s: SignalSnapshot): string {
     s.hasNodeProject ? 'node' : '-',
     s.hasGitRemote ? 'git' : '-',
     s.intentResearch ? 'research' : '-',
+    s.researchAgent ? 'research-agent' : '-',
     s.intentDiagram ? 'diagram' : '-',
     s.recentNetworkError ? 'neterr' : '-',
     s.modelFamily ?? '-',

package/src/tool-runtime/skill-exec-runtime.ts

@@ -7,6 +7,15 @@ import { getUserConfig } from '../user-config.js';
 import type { LLMToolSpec } from '../llm.js';
 import type { ToolRuntime } from './types.js';
 
+/** Whole nested-skill budget; the inner LLM idle timer only bounds one stream. */
+export const SKILL_EXEC_TIMEOUT_MS = 300_000;
+
+export interface SkillExecRunOptions {
+  signal?: AbortSignal;
+  /** Test seam for a short deterministic whole-skill deadline. */
+  timeoutMs?: number;
+}
+
 export interface SkillExecArgs {
   /** Exact name of the skill to execute. */
   skill: string;
@@ -19,6 +28,11 @@ export interface SkillExecResult extends Record<string, unknown> {
   output: string;
   ok: boolean;
   error?: string;
+  discoveryCard?: string;
+}
+
+export interface SkillExecDiscoveryDeps {
+  discoverPlugin?: (gap: string, deps?: { signal?: AbortSignal }) => Promise<{ card: string }>;
 }
 
 export type SkillExecIndexProvider = () => readonly SkillIndexEntry[];
@@ -76,7 +90,11 @@ export function buildSkillExecTool(): LLMToolSpec {
   };
 }
 
-export async function dispatchSkillExec(args: SkillExecArgs): Promise<SkillExecResult> {
+export async function dispatchSkillExec(
+  args: SkillExecArgs,
+  deps: SkillExecDiscoveryDeps = {},
+  options: SkillExecRunOptions = {},
+): Promise<SkillExecResult> {
   const { skill, task } = args;
   const extra = getUserConfig().skillRouter.harnessExecAllowlist;
   const index = obtainSkillIndex();
@@ -116,11 +134,83 @@ export async function dispatchSkillExec(args: SkillExecArgs): Promise<SkillExecR
     };
   }
 
-  const result = await invokeResearch(task, { skill });
+  if (options.signal?.aborted) {
+    return { skill, ok: false, error: 'skill-exec-cancelled', output: '스킬 실행이 취소됐습니다. 현재 근거로 다음 단계를 결정하세요.' };
+  }
+
+  // Race the whole invocation so even a provider that ignores abort gives the
+  // parent a failed tool result. Cooperative LLM and child tools get the same
+  // signal and stop their own work.
+  const child = new AbortController();
+  const timeoutMs = options.timeoutMs ?? SKILL_EXEC_TIMEOUT_MS;
+  let settled = false;
+  let finishEarly: ((reason: 'skill-exec-timeout' | 'skill-exec-cancelled') => void) | undefined;
+  const interrupted = new Promise<'skill-exec-timeout' | 'skill-exec-cancelled'>((resolve) => {
+    finishEarly = (reason) => {
+      if (settled) return;
+      settled = true;
+      resolve(reason);
+      child.abort();
+    };
+  });
+  const onParentAbort = () => finishEarly?.('skill-exec-cancelled');
+  options.signal?.addEventListener('abort', onParentAbort, { once: true });
+  const timer = setTimeout(() => finishEarly?.('skill-exec-timeout'), timeoutMs);
+  observe('started', { skill, timeoutMs });
+  let progressChunks = 0;
+  let progressBytes = 0;
+  let result: Awaited<ReturnType<typeof invokeResearch>> | undefined;
+  let interruption: 'skill-exec-timeout' | 'skill-exec-cancelled' | undefined;
+  try {
+    const outcome = await Promise.race([
+      invokeResearch(task, { skill, signal: child.signal, onProgress: (delta) => {
+        progressChunks += 1;
+        progressBytes += delta.length;
+        if (progressChunks === 1 || progressChunks % 32 === 0) {
+          observe('progress', { skill, progressChunks, progressBytes });
+        }
+      } }).then((value) => ({ result: value })),
+      interrupted.then((reason) => ({ interruption: reason })),
+    ]);
+    settled = true;
+    if ('interruption' in outcome) interruption = outcome.interruption;
+    else result = outcome.result;
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener('abort', onParentAbort);
+  }
+  if (interruption) {
+    observe('interrupted', { skill, reason: interruption, timeoutMs });
+    return {
+      skill,
+      ok: false,
+      error: interruption,
+      output: interruption === 'skill-exec-timeout'
+        ? `스킬 실행 시간이 초과됐습니다 (${timeoutMs}ms). 범위를 좁혀 다시 시도하거나 현재 근거로 답하세요.`
+        : '스킬 실행이 취소됐습니다. 현재 근거로 다음 단계를 결정하세요.',
+    };
+  }
+  if (!result) throw new Error('skill_exec completed without a result');
+  observe('completed', { skill, ok: result.ok, progressChunks, progressBytes, durationMs: result.durationMs });
+  // A low-quality research result is a capability gap. Keep the original failure,
+  // and attach a bounded discovery card rather than silently switching tools.
+  let discoveryCard: string | undefined;
+  if (!result.ok && /\b(?:no data|no evidence|missing|unavailable|not found|empty)\b|(?:자료가 없|데이터가 없|자료 부족|미확인|찾지 못)/i
+    .test(`${result.output} ${result.error ?? ''}`)) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new Error('plugin discovery time budget exhausted')), 10_000);
+    try {
+      const discovery = deps.discoverPlugin ?? (await import('../research/plugin-discovery.js')).discoverResearchPlugin;
+      const found = await discovery(task, { signal: controller.signal });
+      discoveryCard = found.card;
+    } catch { /* The skill failure remains the authoritative result. */ }
+    finally { clearTimeout(timer); }
+  }
   return {
     skill,
     ok: result.ok,
-    output: result.output,
+    output: discoveryCard ? `${result.output}\n\n${discoveryCard}` : result.output,
+    ...(discoveryCard ? { discoveryCard } : {}),
     ...(result.error ? { error: result.error } : {}),
   };
 }
@@ -128,7 +218,7 @@ export async function dispatchSkillExec(args: SkillExecArgs): Promise<SkillExecR
 export const skillExecRuntime: ToolRuntime<SkillExecArgs, SkillExecResult> = {
   id: 'skill_exec',
   spec: buildSkillExecTool(),
-  async run(req) {
-    return dispatchSkillExec(req);
+  async run(req, ctx) {
+    return dispatchSkillExec(req, {}, { signal: ctx.signal });
   },
 };

package/src/tui/chat/background-job-status.ts

@@ -13,13 +13,15 @@ function nonnegativeCount(value: unknown): value is number {
 export class BackgroundJobStatus {
   private sessionId: string | null;
   private current: BackgroundJobSnapshot | null = null;
+  private readonly bySession = new Map<string, BackgroundJobSnapshot>();
 
   constructor(sessionId: string | null) { this.sessionId = sessionId; }
 
   setSessionId(sessionId: string): void {
     if (this.sessionId === sessionId) return;
+    if (this.sessionId && this.current) this.bySession.set(this.sessionId, this.current);
     this.sessionId = sessionId;
-    this.current = null;
+    this.current = this.bySession.get(sessionId) ?? null;
   }
 
   accept(json: string): boolean {
@@ -35,12 +37,16 @@ export class BackgroundJobStatus {
       running: frame.running,
       pending: frame.pending,
     }) as BackgroundJobSnapshot;
+    this.bySession.set(frame.sessionId as string, this.current);
     return true;
   }
 
   snapshot(): BackgroundJobSnapshot | null { return this.current; }
 
-  clear(): void { this.current = null; }
+  clear(): void {
+    this.current = null;
+    if (this.sessionId) this.bySession.delete(this.sessionId);
+  }
 
   line(): string {
     const state = this.current;