@bastani/atomic 0.8.19-0 → 0.8.20-0

package/dist/builtin/workflows/src/extension/lifecycle-notifications.ts

@@ -0,0 +1,372 @@
+import type {
+  ExtensionAPI,
+  PiMessageRenderComponent,
+  PiMessageRendererResult,
+} from "./index.js";
+import type { Store } from "../shared/store.js";
+import type {
+  PendingPrompt,
+  PromptKind,
+  RunSnapshot,
+  RunStatus,
+  StageSnapshot,
+  StageStatus,
+  StoreSnapshot,
+} from "../shared/store-types.js";
+import { wrapPlainText } from "../tui/text-helpers.js";
+
+export const LIFECYCLE_NOTICE_CUSTOM_TYPE = "workflows:lifecycle-notice";
+export const LIFECYCLE_NOTICE_SNIPPET_LIMIT = 240;
+
+export type WorkflowLifecycleNoticeKind = "completed" | "failed" | "awaiting_input";
+
+export const WORKFLOW_LIFECYCLE_NOTICE_KINDS = [
+  "completed",
+  "failed",
+  "awaiting_input",
+] as const satisfies readonly WorkflowLifecycleNoticeKind[];
+
+export interface WorkflowLifecycleNotificationConfig {
+  readonly enabled: boolean;
+  readonly notifyOn: readonly WorkflowLifecycleNoticeKind[];
+}
+
+export interface WorkflowLifecycleNoticeDetails {
+  readonly kind: WorkflowLifecycleNoticeKind;
+  readonly scope: "run" | "stage";
+  readonly runId: string;
+  readonly workflowName: string;
+  readonly status: RunStatus | StageStatus;
+  readonly stageId?: string;
+  readonly stageName?: string;
+  readonly promptId?: string;
+  readonly promptKind?: PromptKind;
+  readonly promptMessage?: string;
+  readonly error?: string;
+  readonly failedStageId?: string;
+  readonly durationMs?: number;
+  readonly createdAt: number;
+}
+
+export interface WorkflowLifecycleNotificationState {
+  readonly deliveredTerminalRuns: Set<string>;
+  readonly deliveredInputPrompts: Set<string>;
+  suppressionDepth: number;
+}
+
+export interface WorkflowLifecycleNotificationOptions {
+  readonly store: Store;
+  readonly sendMessage?: ExtensionAPI["sendMessage"];
+  readonly registerMessageRenderer?: ExtensionAPI["registerMessageRenderer"];
+  readonly rendererHost?: object;
+  readonly config: WorkflowLifecycleNotificationConfig;
+  readonly state?: WorkflowLifecycleNotificationState;
+  readonly seedExisting?: boolean;
+}
+
+type RawRenderer = (payload: unknown) => PiMessageRendererResult;
+
+// Process-lifetime registration dedupe: extension hosts are object identities
+// and may be garbage-collected, but renderer registrations are not unregistered.
+const rendererRegisteredHosts = new WeakSet<object>();
+
+export function createWorkflowLifecycleNotificationState(): WorkflowLifecycleNotificationState {
+  return {
+    deliveredTerminalRuns: new Set<string>(),
+    deliveredInputPrompts: new Set<string>(),
+    suppressionDepth: 0,
+  };
+}
+
+export function resetWorkflowLifecycleNotificationState(
+  state: WorkflowLifecycleNotificationState,
+): void {
+  state.deliveredTerminalRuns.clear();
+  state.deliveredInputPrompts.clear();
+  state.suppressionDepth = 0;
+}
+
+export function seedWorkflowLifecycleNotificationState(
+  state: WorkflowLifecycleNotificationState,
+  snapshot: StoreSnapshot,
+): void {
+  for (const run of snapshot.runs) {
+    if ((run.status === "completed" || run.status === "failed") && run.endedAt !== undefined) {
+      state.deliveredTerminalRuns.add(terminalRunKey(run.status, run.id));
+    }
+    if (run.pendingPrompt !== undefined) {
+      state.deliveredInputPrompts.add(runAwaitingInputKey(run.id, run.pendingPrompt));
+    }
+    for (const stage of run.stages) {
+      if (stage.status === "awaiting_input") {
+        state.deliveredInputPrompts.add(awaitingInputKey(run.id, stage));
+      }
+    }
+  }
+}
+
+/**
+ * Suppress lifecycle notice emission while still observing snapshot changes and
+ * marking matching lifecycle states as delivered. This is intended for restore
+ * or replay paths where historical workflow states should seed dedupe state
+ * without notifying the current chat; it is not a generic temporary mute that
+ * should emit the same notices later.
+ */
+export function withWorkflowLifecycleNotificationsSuppressed<T>(
+  state: WorkflowLifecycleNotificationState,
+  fn: () => T,
+): T {
+  state.suppressionDepth += 1;
+  try {
+    return fn();
+  } finally {
+    state.suppressionDepth -= 1;
+  }
+}
+
+export function installWorkflowLifecycleNotifications(
+  options: WorkflowLifecycleNotificationOptions,
+): () => void {
+  registerLifecycleNoticeRenderer(options);
+
+  if (!options.config.enabled) return () => undefined;
+  const send = options.sendMessage;
+  if (typeof send !== "function") return () => undefined;
+
+  const notifyOn = new Set<WorkflowLifecycleNoticeKind>(options.config.notifyOn);
+  const state = options.state ?? createWorkflowLifecycleNotificationState();
+  if (options.seedExisting !== false) {
+    seedWorkflowLifecycleNotificationState(state, options.store.snapshot());
+  }
+
+  const emit = (details: WorkflowLifecycleNoticeDetails): void => {
+    const content = formatWorkflowLifecycleNoticeText(details);
+    try {
+      // Store subscribers are notified in a tight loop. A lifecycle notice
+      // failure must never abort sibling subscribers such as status writers.
+      void Promise.resolve(
+        send(
+          {
+            customType: LIFECYCLE_NOTICE_CUSTOM_TYPE,
+            content,
+            display: true,
+            details,
+          },
+          { triggerTurn: true, deliverAs: "steer" },
+        ),
+      ).catch((error: unknown) => warnLifecycleSendFailure(error));
+    } catch (error) {
+      warnLifecycleSendFailure(error);
+      // Best-effort notification only; keep store delivery isolated.
+    }
+  };
+
+  const emitTerminalNoticeOnce = (
+    run: RunSnapshot,
+    kind: "completed" | "failed",
+  ): void => {
+    if (run.status !== kind || run.endedAt === undefined || !notifyOn.has(kind)) {
+      return;
+    }
+
+    const key = terminalRunKey(kind, run.id);
+    if (state.deliveredTerminalRuns.has(key)) return;
+
+    state.deliveredTerminalRuns.add(key);
+    if (state.suppressionDepth > 0) return;
+    emit(makeTerminalNotice(run, kind));
+  };
+
+  const emitStageAwaitingInputNoticeOnce = (
+    run: RunSnapshot,
+    stage: StageSnapshot,
+  ): void => {
+    if (stage.status !== "awaiting_input") return;
+
+    const key = awaitingInputKey(run.id, stage);
+    if (state.deliveredInputPrompts.has(key)) return;
+
+    state.deliveredInputPrompts.add(key);
+    if (state.suppressionDepth > 0) return;
+    emit(makeStageAwaitingInputNotice(run, stage));
+  };
+
+  const emitRunAwaitingInputNoticeOnce = (run: RunSnapshot): void => {
+    if (run.pendingPrompt === undefined) return;
+
+    const key = runAwaitingInputKey(run.id, run.pendingPrompt);
+    if (state.deliveredInputPrompts.has(key)) return;
+
+    state.deliveredInputPrompts.add(key);
+    if (state.suppressionDepth > 0) return;
+    emit(makeRunAwaitingInputNotice(run, run.pendingPrompt));
+  };
+
+  const inspect = (snapshot: StoreSnapshot): void => {
+    for (const run of snapshot.runs) {
+      emitTerminalNoticeOnce(run, "completed");
+      emitTerminalNoticeOnce(run, "failed");
+
+      if (!notifyOn.has("awaiting_input")) continue;
+      emitRunAwaitingInputNoticeOnce(run);
+      for (const stage of run.stages) {
+        emitStageAwaitingInputNoticeOnce(run, stage);
+      }
+    }
+  };
+
+  return options.store.subscribe(inspect);
+}
+
+export function registerLifecycleNoticeRenderer(
+  options: Pick<WorkflowLifecycleNotificationOptions, "registerMessageRenderer" | "rendererHost">,
+): void {
+  const register = options.registerMessageRenderer;
+  if (typeof register !== "function") return;
+
+  const host = options.rendererHost ?? register;
+  if (rendererRegisteredHosts.has(host)) return;
+
+  const renderer: RawRenderer = (raw) => {
+    const message = raw as { details?: WorkflowLifecycleNoticeDetails };
+    if (!message.details) return undefined;
+    return makeNoticeComponent(message.details);
+  };
+
+  register(LIFECYCLE_NOTICE_CUSTOM_TYPE, renderer);
+  rendererRegisteredHosts.add(host);
+}
+
+export function formatWorkflowLifecycleNoticeText(details: WorkflowLifecycleNoticeDetails): string {
+  const workflowName = escapeQuotedText(details.workflowName);
+  if (details.kind === "completed") {
+    return `✅ Workflow "${workflowName}" completed (run ${details.runId}). Inspect: /workflow status ${details.runId}`;
+  }
+  if (details.kind === "failed") {
+    const stage = details.stageName ?? details.failedStageId;
+    const stageText = stage ? `, stage ${stage}` : "";
+    const errorText = details.error ? `: ${details.error}` : "";
+    return `❌ Workflow "${workflowName}" failed (run ${details.runId}${stageText})${errorText}. Inspect: /workflow status ${details.runId}`;
+  }
+  const prompt = details.promptMessage ? ` Prompt: ${details.promptMessage}` : "";
+  if (details.scope === "run") {
+    return `❓ Workflow "${workflowName}" needs input (run ${details.runId}).${prompt} Respond: /workflow connect ${details.runId} to answer this run-level prompt.`;
+  }
+  const stage = details.stageName ?? details.stageId ?? "unknown";
+  const responseHint = details.stageId && details.promptId
+    ? `/workflow connect ${details.runId} or workflow({ action: "send", runId: ${jsonString(details.runId)}, stageId: ${jsonString(details.stageId)}, promptId: ${jsonString(details.promptId)}, response: ... })`
+    : `/workflow connect ${details.runId}`;
+  return `❓ Workflow "${workflowName}" needs input (run ${details.runId}, stage ${stage}).${prompt} Respond: ${responseHint}.`;
+}
+
+function makeTerminalNotice(
+  run: RunSnapshot,
+  kind: "completed" | "failed",
+): WorkflowLifecycleNoticeDetails {
+  const failedStage = run.failedStageId
+    ? run.stages.find((stage) => stage.id === run.failedStageId)
+    : undefined;
+  return {
+    kind,
+    scope: "run",
+    runId: run.id,
+    workflowName: run.name,
+    status: run.status,
+    ...(run.error ? { error: truncateSnippet(run.error) } : {}),
+    ...(run.failedStageId ? { failedStageId: run.failedStageId } : {}),
+    ...(failedStage ? { stageId: failedStage.id, stageName: failedStage.name } : {}),
+    ...(run.durationMs !== undefined ? { durationMs: run.durationMs } : {}),
+    // Normal store paths stamp endedAt; Date.now() is defensive for malformed restored snapshots.
+    createdAt: run.endedAt ?? Date.now(),
+  };
+}
+
+function makeStageAwaitingInputNotice(run: RunSnapshot, stage: StageSnapshot): WorkflowLifecycleNoticeDetails {
+  const prompt = stage.pendingPrompt;
+  return {
+    kind: "awaiting_input",
+    scope: "stage",
+    runId: run.id,
+    workflowName: run.name,
+    status: stage.status,
+    stageId: stage.id,
+    stageName: stage.name,
+    ...(prompt ? promptFields(prompt) : {}),
+    // Normal store paths stamp awaitingInputSince; Date.now() is defensive for malformed restored snapshots.
+    createdAt: prompt?.createdAt ?? stage.awaitingInputSince ?? Date.now(),
+  };
+}
+
+function makeRunAwaitingInputNotice(run: RunSnapshot, prompt: PendingPrompt): WorkflowLifecycleNoticeDetails {
+  return {
+    kind: "awaiting_input",
+    scope: "run",
+    runId: run.id,
+    workflowName: run.name,
+    status: run.status,
+    ...promptFields(prompt),
+    createdAt: prompt.createdAt,
+  };
+}
+
+function warnLifecycleSendFailure(error: unknown): void {
+  if (process.env.ATOMIC_WORKFLOW_DEBUG !== "1") return;
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn("[workflows] workflow lifecycle notice send failed", message);
+}
+
+function escapeQuotedText(value: string): string {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+function jsonString(value: string): string {
+  return JSON.stringify(value);
+}
+
+function terminalRunKey(kind: "completed" | "failed", runId: string): string {
+  return `${kind}:${runId}`;
+}
+
+function promptFields(
+  prompt: PendingPrompt,
+): Pick<WorkflowLifecycleNoticeDetails, "promptId" | "promptKind" | "promptMessage"> {
+  return {
+    promptId: prompt.id,
+    promptKind: prompt.kind,
+    promptMessage: truncateSnippet(prompt.message),
+  };
+}
+
+function awaitingInputKey(runId: string, stage: StageSnapshot): string {
+  const promptId = stage.pendingPrompt?.id;
+  if (promptId) return `awaiting_input:${runId}:stage:${stage.id}:${promptId}`;
+  return `awaiting_input:${runId}:stage:${stage.id}:${stage.awaitingInputSince ?? "active"}`;
+}
+
+function runAwaitingInputKey(runId: string, prompt: PendingPrompt): string {
+  return `awaiting_input:${runId}:run:${prompt.id}`;
+}
+
+function truncateSnippet(value: string): string {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= LIFECYCLE_NOTICE_SNIPPET_LIMIT) return normalized;
+  return `${normalized.slice(0, LIFECYCLE_NOTICE_SNIPPET_LIMIT - 1)}…`;
+}
+
+function makeNoticeComponent(details: WorkflowLifecycleNoticeDetails): PiMessageRenderComponent {
+  const text = formatWorkflowLifecycleNoticeText(details);
+  return {
+    render(width: number): string[] {
+      // Wrap to the render width so a long run id / workflow name never emits a
+      // line wider than the terminal. pi-tui hard-throws ("Rendered line N
+      // exceeds terminal width") on any over-wide rendered line, which would
+      // crash the whole TUI on narrow terminals or after a resize (#1109).
+      // `wrapPlainText` hard-breaks long unbreakable tokens (e.g. UUIDs), so
+      // every returned line is guaranteed to fit within `width`.
+      return wrapPlainText(text, width);
+    },
+    invalidate() {
+      /* stored lifecycle notices are immutable */
+    },
+  };
+}

package/dist/builtin/workflows/src/extension/render-call.ts

@@ -67,7 +67,7 @@ export function renderCall(args: WorkflowToolArgs, opts: RenderCallOpts = {}): s
       line = "workflow: list registered workflows";
       break;
     case "status":
-      line = "workflow: list in-flight runs";
+      line = "workflow: list retained runs";
       break;
     case "inputs":
       line = name === undefined

package/dist/builtin/workflows/src/extension/wiring.ts

@@ -22,8 +22,7 @@
  */
 
 import { basename } from "node:path";
-import type { CreateAgentSessionOptions } from "@bastani/atomic";
-import type { ChatMessageRenderOptions } from "@bastani/atomic";
+import type { ChatMessageRenderOptions, CreateAgentSessionOptions } from "@bastani/atomic";
 import type { StageAdapters, StageSessionRuntime } from "../runs/foreground/stage-runner.js";
 import type { StageExecutionMeta, StageOptions } from "../shared/types.js";
 import { stageUiBroker, type StageUiBroker } from "../shared/stage-ui-broker.js";
@@ -237,6 +236,33 @@ function stripWorkflowOnlyOptions(options: (StageOptions | CreateAgentSessionOpt
   return sessionOptions as CreateAgentSessionOptions;
 }
 
+function makeWorkflowStageOrchestrationContext(meta: StageExecutionMeta): NonNullable<CreateAgentSessionOptions["orchestrationContext"]> {
+  return {
+    kind: "workflow-stage",
+    workflowRunId: meta.runId,
+    workflowStageId: meta.stageId,
+    workflowStageName: meta.stageName,
+    constraints: {
+      disableWorkflowTool: true,
+      maxSubagentDepth: 1,
+    },
+  };
+}
+
+function withWorkflowStageSessionOptions(
+  options: CreateAgentSessionOptions,
+  meta: StageExecutionMeta | undefined,
+): CreateAgentSessionOptions {
+  // Workflow stage sessions should never see the workflow tool, even when older
+  // meta-less callers cannot receive the richer runtime orchestration context.
+  const excludedTools = Array.from(new Set([...(options.excludedTools ?? []), "workflow"]));
+  return {
+    ...options,
+    excludedTools,
+    ...(meta ? { orchestrationContext: makeWorkflowStageOrchestrationContext(meta) } : {}),
+  };
+}
+
 function makeStageExtensionUiContext(
   ui: PiUISurface,
   meta: StageExecutionMeta | undefined,
@@ -325,7 +351,10 @@ export function buildRuntimeAdapters(
         // extensions, tools, prompts, and skills as the parent chat. Callers
         // can still opt into a custom resource set by passing `resourceLoader`
         // through `stage(name, options)`.
-        const sessionOptions: CreateAgentSessionOptions = stripWorkflowOnlyOptions(stageOptions) ?? {};
+        const sessionOptions = withWorkflowStageSessionOptions(
+          stripWorkflowOnlyOptions(stageOptions) ?? {},
+          meta,
+        );
         const result = await createSession(sessionOptions);
         const bindable = result.session as BindableStageSession;
         if ((pi.ui !== undefined || meta !== undefined) && typeof bindable.bindExtensions === "function") {

package/dist/builtin/workflows/src/runs/background/status.ts

@@ -1,5 +1,5 @@
 /**
- * Status / kill / resume control helpers for in-flight workflow runs.
+ * Status / kill / resume helpers for retained workflow runs and live controls.
  *
  * These helpers operate against the singleton store and are consumed by:
  *   - The `workflow` tool execute handler (action: "status" | "kill" | "resume")
@@ -34,10 +34,6 @@ export type KillResult =
   | { ok: true; runId: string; previousStatus: RunStatus }
   | { ok: false; runId: string; reason: "not_found" | "already_ended" };
 
-export type DestroyRunResult =
-  | { ok: true; runId: string; previousStatus: RunStatus; wasInFlight: boolean }
-  | { ok: false; runId: string; reason: "not_found" };
-
 export type ResumeResult =
   | {
       ok: true;
@@ -95,27 +91,22 @@ export type InspectRunResult =
 // ---------------------------------------------------------------------------
 
 /**
- * Returns a summary of all in-flight (not-yet-ended) runs in the store.
- * If `all` is true, returns completed/failed runs too.
+ * Returns a summary of all retained runs in the current store/session.
+ *
+ * Terminal snapshots are retained for inspection and are visible by default;
+ * the legacy `all` option is accepted as a compatibility no-op.
  */
 export function statusRuns(opts?: { all?: boolean; store?: Store }): RunStatusEntry[] {
   const activeStore = opts?.store ?? defaultStore;
-  const runs = activeStore.runs();
-  const result: RunStatusEntry[] = [];
-
-  for (const run of runs) {
-    if (!opts?.all && run.endedAt !== undefined) continue;
-    result.push({
-      runId: run.id,
-      name: run.name,
-      status: run.status,
-      startedAt: run.startedAt,
-      durationMs: run.durationMs,
-      stageCount: run.stages.length,
-    });
-  }
 
-  return result;
+  return activeStore.runs().map((run) => ({
+    runId: run.id,
+    name: run.name,
+    status: run.status,
+    startedAt: run.startedAt,
+    durationMs: run.durationMs,
+    stageCount: run.stages.length,
+  }));
 }
 
 // ---------------------------------------------------------------------------
@@ -179,57 +170,6 @@ export function killAllRuns(opts?: {
   );
 }
 
-// ---------------------------------------------------------------------------
-// destroyRun
-// ---------------------------------------------------------------------------
-
-/**
- * Destructively kills a workflow run and removes it from live history/status.
- *
- * In-flight runs are aborted and persisted with a terminal `killed` entry so
- * session restore will not resurrect them. Ended runs are simply removed from
- * the live store without appending a duplicate terminal event.
- */
-export function destroyRun(
-  runId: string,
-  opts?: { store?: Store; cancellation?: CancellationRegistry; persistence?: WorkflowPersistencePort },
-): DestroyRunResult {
-  const activeStore = opts?.store ?? defaultStore;
-  const run = activeStore.runs().find((r) => r.id === runId);
-
-  if (!run) {
-    return { ok: false, runId, reason: "not_found" };
-  }
-
-  const previousStatus = run.status;
-  const wasInFlight = run.endedAt === undefined;
-
-  if (wasInFlight) {
-    opts?.cancellation?.abort(runId, "workflow killed");
-    if (opts?.persistence) {
-      appendRunEnd(opts.persistence, { runId, status: "killed", ts: Date.now() });
-    }
-  }
-
-  activeStore.removeRun(runId);
-  return { ok: true, runId, previousStatus, wasInFlight };
-}
-
-/**
- * Destructively kills and removes all in-flight runs.
- */
-export function destroyAllRuns(opts?: {
-  store?: Store;
-  cancellation?: CancellationRegistry;
-  persistence?: WorkflowPersistencePort;
-}): DestroyRunResult[] {
-  const activeStore = opts?.store ?? defaultStore;
-  const inFlight = activeStore.runs().filter((r) => r.endedAt === undefined);
-  return inFlight.map((r) =>
-    destroyRun(r.id, { store: activeStore, cancellation: opts?.cancellation, persistence: opts?.persistence }),
-  );
-}
-
 // ---------------------------------------------------------------------------
 // resumeRun
 // ---------------------------------------------------------------------------
@@ -408,7 +348,7 @@ export function pauseAllRuns(opts?: {
 
 /**
  * Interrupt a run in a resumable way by pausing live stage handles when
- * available. Unlike `destroyRun`, this never aborts the workflow controller and
+ * available. This never aborts the workflow controller and
  * never removes the run from status/history.
  */
 export function interruptRun(

package/dist/builtin/workflows/src/shared/persistence-restore.ts

@@ -163,7 +163,7 @@ export function restoreOnSessionStart(
 
   const entries = getEntries.call(sessionManager);
   const sessionEntries = entries as readonly SessionEntry[];
-  restoreEndedFailedRuns(sessionEntries, store);
+  restoreTerminalRuns(sessionEntries, store);
   const inFlight = scanInFlightRuns(sessionEntries);
   if (inFlight.length === 0) return;
 
@@ -300,7 +300,7 @@ function restoreStageStatus(status: unknown): StageStatus {
   }
 }
 
-function restoreEndedFailedRuns(entries: readonly SessionEntry[], store: Store): void {
+function restoreTerminalRuns(entries: readonly SessionEntry[], store: Store): void {
   const started = new Map<string, { readonly name: string; readonly inputs: Readonly<Record<string, unknown>>; readonly startTs: number }>();
   const ended = new Map<string, Record<string, unknown>>();
 
@@ -334,6 +334,7 @@ function restoreEndedFailedRuns(entries: readonly SessionEntry[], store: Store):
 
     const runMeta = findRunStartMetadata(entries, runId);
     const stages = _buildStageSnapshots(entries, runId);
+    if (status === "completed" && stages.some((stage) => stage.status !== "completed")) continue;
     store.recordRunStart({
       id: runId,
       name: start.name,
@@ -365,8 +366,9 @@ function restoreEndedFailedRuns(entries: readonly SessionEntry[], store: Store):
   }
 }
 
-function restoreTerminalRunStatus(status: unknown): "failed" | "killed" | undefined {
+function restoreTerminalRunStatus(status: unknown): "completed" | "failed" | "killed" | undefined {
   switch (status) {
+    case "completed":
     case "failed":
     case "killed":
       return status;

package/dist/builtin/workflows/src/tui/chat-surface-message.ts

@@ -79,12 +79,11 @@ export interface DetailPayload {
   detail: RunDetail;
 }
 
-/** Inline notice after a workflow run is destructively killed and removed. */
+/** Inline notice after a workflow run is killed and retained for inspection. */
 export interface KilledPayload {
   kind: "killed";
   run: RunSnapshot;
   previousStatus: RunStatus;
-  wasInFlight: boolean;
 }
 
 export type ChatSurfacePayload =
@@ -136,16 +135,8 @@ export function registerChatSurfaceRenderer(
     return makeComponent(payload, theme);
   };
 
-  // The project's local `ExtensionAPI` types `registerMessageRenderer` as
-  // returning a plain string. pi's runtime also accepts a Component (see
-  // docs/extensions.md §Custom UI). Cast through `unknown` so the call
-  // typechecks against both shapes. `.call(pi, …)` preserves `this` for
-  // pi's class-backed ExtensionAPI.
-  (register as unknown as (event: string, r: RawRenderer) => void).call(
-    pi,
-    CHAT_SURFACE_CUSTOM_TYPE,
-    renderer,
-  );
+  // `.call(pi, …)` preserves `this` for pi's class-backed ExtensionAPI.
+  register.call(pi, CHAT_SURFACE_CUSTOM_TYPE, renderer);
   rendererRegisteredHosts.add(pi);
 }
 
@@ -234,7 +225,6 @@ function renderPayload(
         theme,
         run: payload.run,
         previousStatus: payload.previousStatus,
-        wasInFlight: payload.wasInFlight,
       }).join("\n");
   }
 }

package/dist/builtin/workflows/src/tui/inline-form-overlay.ts

@@ -124,16 +124,8 @@ export function registerInlineFormRenderer(pi: ExtensionAPI, theme: GraphTheme):
     };
   };
 
-  // The project's local `ExtensionAPI` types `registerMessageRenderer` as
-  // returning a plain string. The real pi runtime also accepts a Component
-  // (see docs/extensions.md §Custom UI). Cast through `unknown` so the call
-  // typechecks against both shapes. Call through `pi` so pi's
-  // class-backed ExtensionAPI keeps its `this` binding.
-  (register as unknown as (event: string, r: RawRenderer) => void).call(
-    pi,
-    CUSTOM_TYPE,
-    renderer,
-  );
+  // Call through `pi` so pi's class-backed ExtensionAPI keeps its `this` binding.
+  register.call(pi, CUSTOM_TYPE, renderer);
   rendererRegisteredHosts.add(pi);
 }
 

package/dist/builtin/workflows/src/tui/overlay-adapter.ts

@@ -19,7 +19,7 @@ import type { Store } from "../shared/store.js";
 import type { ChatMessageRenderOptions, ReadonlyFooterDataProvider } from "@bastani/atomic";
 import { WorkflowAttachPane } from "./workflow-attach-pane.js";
 import { deriveGraphThemeFromPiTheme } from "./graph-theme.js";
-import { destroyRun } from "../runs/background/status.js";
+import { killRun as defaultKillRun } from "../runs/background/status.js";
 import { cancellationRegistry } from "../runs/background/cancellation-registry.js";
 import { stageControlRegistry as defaultStageControlRegistry } from "../runs/foreground/stage-control-registry.js";
 import type { StageControlRegistry } from "../runs/foreground/stage-control-registry.js";
@@ -109,9 +109,9 @@ export interface BuildGraphOverlayAdapterOpts {
   /** Broker used to route stage-local custom UI into attached stage chats. */
   stageUiBroker?: StageUiBroker;
   /**
-   * Destructive kill hook used by graph-mode `q`. The extension factory
-   * supplies this so persistence can record a terminal event before the run is
-   * removed from live history/status.
+   * Kill hook used by graph-mode `q`. The extension factory supplies this so
+   * persistence can record a terminal event while retaining the run for
+   * inspection.
    */
   onKillRun?: (runId: string) => void;
 }
@@ -124,7 +124,7 @@ export function buildGraphOverlayAdapter(
   const registry = buildOpts.stageControlRegistry ?? defaultStageControlRegistry;
   const stageUiBroker = buildOpts.stageUiBroker;
   const killRun = buildOpts.onKillRun ?? ((id: string): void => {
-    destroyRun(id, { store, cancellation: cancellationRegistry });
+    defaultKillRun(id, { store, cancellation: cancellationRegistry });
   });
   let currentView: WorkflowAttachPane | null = null;
   // pi-tui returns an OverlayHandle via `options.onHandle`. We hold onto