@bastani/atomic 0.8.25 → 0.8.26-alpha.2

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.8.25",
+  "version": "0.8.26-alpha.2",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [

package/dist/builtin/web-access/result-renderers.ts

@@ -0,0 +1,364 @@
+import type { ToolDefinition } from "@bastani/atomic";
+import { Box, Text } from "@mariozechner/pi-tui";
+import { formatSeconds } from "./utils.js";
+
+type ToolResultRenderer = NonNullable<ToolDefinition["renderResult"]>;
+type ToolRenderResultArgs = Parameters<ToolResultRenderer>;
+type ToolRenderResult = ReturnType<ToolResultRenderer>;
+type RenderedResult = ToolRenderResultArgs[0];
+type TextContentBlock = Extract<RenderedResult["content"][number], { type: "text" }>;
+
+type QueryDetail = {
+	query: string;
+	provider: string | null;
+	answer: string | null;
+	sources: Array<{ title: string; url: string }>;
+	error: string | null;
+};
+
+type WebSearchResultDetails = {
+	queryCount?: number;
+	successfulQueries?: number;
+	totalResults?: number;
+	error?: string;
+	fetchId?: string;
+	fetchUrls?: string[];
+	phase?: string;
+	progress?: number;
+	currentQuery?: string;
+	curated?: boolean;
+	curatedFrom?: number;
+	curatedQueries?: QueryDetail[];
+	cancelled?: boolean;
+	cancelReason?: string;
+	summary?: {
+		text: string;
+		workflow: "summary-review";
+		model: string | null;
+		durationMs: number;
+		tokenEstimate: number;
+		fallbackUsed: boolean;
+		fallbackReason?: string;
+		edited?: boolean;
+	};
+};
+
+type CodeSearchResultDetails = {
+	query?: string;
+	maxTokens?: number;
+	error?: string;
+};
+
+type FetchContentResultDetails = {
+	urlCount?: number;
+	successful?: number;
+	totalChars?: number;
+	error?: string;
+	title?: string;
+	truncated?: boolean;
+	responseId?: string;
+	phase?: string;
+	progress?: number;
+	hasImage?: boolean;
+	imageCount?: number;
+	prompt?: string;
+	timestamp?: string;
+	frames?: number;
+	duration?: number;
+};
+
+type GetSearchContentResultDetails = {
+	error?: string;
+	query?: string;
+	url?: string;
+	title?: string;
+	resultCount?: number;
+	contentLength?: number;
+};
+
+function isTextContentBlock(block: RenderedResult["content"][number]): block is TextContentBlock {
+	return block.type === "text";
+}
+
+function firstTextContent(result: RenderedResult): string {
+	return result.content.find(isTextContentBlock)?.text ?? "";
+}
+
+function progressBar(progress: number): string {
+	const filled = Math.floor(progress * 10);
+	return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+}
+
+export const renderWebSearchResult: ToolResultRenderer = (result, { expanded, isPartial }, theme) => {
+	const details = result.details as WebSearchResultDetails | undefined;
+
+	if (isPartial) {
+		if (details?.phase === "curating") {
+			return new Text(theme.fg("accent", "waiting for summary approval..."), 0, 0);
+		}
+		if (details?.phase === "searching") {
+			const progress = details?.progress ?? 0;
+			const bar = progressBar(progress);
+			const query = details?.currentQuery || "";
+			const display = query.length > 40 ? query.slice(0, 37) + "..." : query;
+			return new Text(theme.fg("accent", `[${bar}] ${display}`), 0, 0);
+		}
+		const progress = details?.progress ?? 0;
+		const bar = progressBar(progress);
+		return new Text(theme.fg("accent", `[${bar}] ${details?.phase || "searching"}`), 0, 0);
+	}
+
+	if (details?.error) {
+		return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+	}
+
+	let statusLine: string;
+	const queryInfo = details?.queryCount === 1 ? "" : `${details?.successfulQueries}/${details?.queryCount} queries, `;
+	statusLine = theme.fg("success", `${queryInfo}${details?.totalResults ?? 0} sources`);
+	if (details?.curated && details?.curatedFrom) {
+		statusLine += theme.fg("muted", ` (${details.queryCount}/${details.curatedFrom} queries curated)`);
+	}
+	if (details?.fetchId && details?.fetchUrls) {
+		statusLine += theme.fg("muted", ` (fetching ${details.fetchUrls.length} URLs)`);
+	} else if (details?.fetchId) {
+		statusLine += theme.fg("muted", " (content ready)");
+	}
+
+	// Build expanded lines first so collapsed view can reference total count
+	const lines = [statusLine];
+	if (details?.summary?.text) {
+		lines.push("");
+		lines.push(theme.fg("accent", `── Summary (${details.summary.workflow}) ` + "─".repeat(32)));
+		lines.push("");
+		for (const line of details.summary.text.split("\n")) {
+			lines.push(`  ${line}`);
+		}
+		lines.push("");
+		const metaParts = [
+			details.summary.model ? `model=${details.summary.model}` : "model=deterministic",
+			`duration=${details.summary.durationMs}ms`,
+			`tokens~${details.summary.tokenEstimate}`,
+			details.summary.fallbackUsed ? "fallback=true" : "fallback=false",
+			details.summary.edited ? "edited=true" : "edited=false",
+		];
+		if (details.summary.fallbackReason) {
+			metaParts.push(`reason=${details.summary.fallbackReason}`);
+		}
+		lines.push(theme.fg("dim", "  " + metaParts.join(" · ")));
+	}
+
+	const queryDetails = details?.curatedQueries;
+	if (queryDetails?.length) {
+		const kept = queryDetails.length;
+		const from = details?.curatedFrom ?? kept;
+		lines.push("");
+		lines.push(theme.fg("accent", `\u2500\u2500 Curated Results (${kept} of ${from} queries kept) ` + "\u2500".repeat(24)));
+
+		for (const cq of queryDetails) {
+			lines.push("");
+			const dq = cq.query.length > 65 ? cq.query.slice(0, 62) + "..." : cq.query;
+			const providerLabel = cq.provider ? ` (${cq.provider})` : "";
+			lines.push(theme.fg("accent", `  "${dq}"${providerLabel}`));
+
+			if (cq.error) {
+				lines.push(theme.fg("error", `  ${cq.error}`));
+			} else if (cq.answer) {
+				lines.push("");
+				for (const line of cq.answer.split("\n")) {
+					lines.push(`  ${line}`);
+				}
+			}
+
+			if (cq.sources.length > 0) {
+				lines.push("");
+				for (const s of cq.sources) {
+					const domain = s.url.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+					const title = s.title.length > 50 ? s.title.slice(0, 47) + "..." : s.title;
+					lines.push(theme.fg("muted", `  \u25b8 ${title}`) + theme.fg("dim", ` \u00b7 ${domain}`));
+				}
+			}
+		}
+		lines.push("");
+	} else {
+		const textContent = firstTextContent(result);
+		const preview = textContent.length > 500 ? textContent.slice(0, 500) + "..." : textContent;
+		for (const line of preview.split("\n")) {
+			lines.push(theme.fg("dim", line));
+		}
+	}
+
+	if (details?.fetchUrls && details.fetchUrls.length > 0) {
+		if (details.curated) {
+			lines.push(theme.fg("muted", `Fetching ${details.fetchUrls.length} URLs in background`));
+		} else {
+			lines.push(theme.fg("muted", "Fetching:"));
+			for (const u of details.fetchUrls.slice(0, 5)) {
+				const display = u.length > 60 ? u.slice(0, 57) + "..." : u;
+				lines.push(theme.fg("dim", "  " + display));
+			}
+			if (details.fetchUrls.length > 5) {
+				lines.push(theme.fg("dim", `  ... and ${details.fetchUrls.length - 5} more`));
+			}
+		}
+	}
+
+	const totalLines = lines.length;
+
+	if (!expanded) {
+		const box = new Box(1, 0, (t) => theme.bg("toolSuccessBg", t));
+		box.addChild(new Text(statusLine, 0, 0));
+
+		let collapsedLines = 1; // statusLine
+		const summaryPreview = details?.summary?.text?.trim() || "";
+		if (summaryPreview) {
+			const preview = summaryPreview.length > 120 ? summaryPreview.slice(0, 117) + "..." : summaryPreview;
+			box.addChild(new Text(theme.fg("dim", preview), 0, 0));
+			collapsedLines++;
+		} else if (details?.curatedQueries?.length) {
+			for (const cq of details.curatedQueries.slice(0, 3)) {
+				const dq = cq.query.length > 55 ? cq.query.slice(0, 52) + "..." : cq.query;
+				const srcCount = cq.sources?.length ?? 0;
+				const suffix = cq.error ? theme.fg("error", " (error)") : theme.fg("dim", ` · ${srcCount} sources`);
+				box.addChild(new Text(theme.fg("accent", `  "${dq}"`) + suffix, 0, 0));
+				collapsedLines++;
+			}
+			if (details.curatedQueries.length > 3) {
+				box.addChild(new Text(theme.fg("dim", `  ... and ${details.curatedQueries.length - 3} more`), 0, 0));
+				collapsedLines++;
+			}
+		} else {
+			const textContent = firstTextContent(result);
+			const firstContentLine = textContent.split("\n").find(l => {
+				const t = l.trim();
+				return t && !t.startsWith("[") && !t.startsWith("#") && !t.startsWith("---");
+			});
+			const fallbackLine = (firstContentLine?.trim() || "").replace(/\*\*/g, "");
+			if (fallbackLine) {
+				const preview = fallbackLine.length > 120 ? fallbackLine.slice(0, 117) + "..." : fallbackLine;
+				box.addChild(new Text(theme.fg("dim", preview), 0, 0));
+				collapsedLines++;
+			}
+		}
+		const moreLines = Math.max(0, totalLines - collapsedLines);
+		if (moreLines > 0) {
+			box.addChild(new Text(theme.fg("muted", `\n... (${moreLines} more lines, ${totalLines} total, CTRL+O Expand)`), 0, 0));
+		}
+		return box;
+	}
+
+	return new Text(lines.join("\n"), 0, 0);
+};
+
+export const renderCodeSearchResult: ToolResultRenderer = (result, { expanded }, theme) => {
+	const details = result.details as CodeSearchResultDetails | undefined;
+	if (details?.error) {
+		return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+	}
+
+	const summary = theme.fg("success", "code context returned") +
+		theme.fg("muted", ` (${details?.maxTokens ?? 5000} tokens max)`);
+	if (!expanded) return new Text(summary, 0, 0);
+
+	const textContent = firstTextContent(result);
+	const preview = textContent.length > 500 ? textContent.slice(0, 500) + "..." : textContent;
+	return new Text(summary + "\n" + theme.fg("dim", preview), 0, 0);
+};
+
+export const renderFetchContentResult: ToolResultRenderer = (result, { expanded, isPartial }, theme) => {
+	const details = result.details as FetchContentResultDetails | undefined;
+
+	if (isPartial) {
+		const progress = details?.progress ?? 0;
+		const bar = progressBar(progress);
+		return new Text(theme.fg("accent", `[${bar}] ${details?.phase || "fetching"}`), 0, 0);
+	}
+
+	if (details?.error) {
+		return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+	}
+
+	if (details?.urlCount === 1) {
+		const title = details?.title || "Untitled";
+		const imgCount = details?.imageCount ?? (details?.hasImage ? 1 : 0);
+		const imageBadge = imgCount > 1
+			? theme.fg("accent", ` [${imgCount} images]`)
+			: imgCount === 1
+				? theme.fg("accent", " [image]")
+				: "";
+		let statusLine = theme.fg("success", title) + theme.fg("muted", ` (${details?.totalChars ?? 0} chars)`) + imageBadge;
+		if (details?.truncated) {
+			statusLine += theme.fg("warning", " [truncated]");
+		}
+		if (typeof details?.duration === "number") {
+			statusLine += theme.fg("muted", ` | ${formatSeconds(Math.floor(details.duration))} total`);
+		}
+		const textContent = firstTextContent(result);
+		if (!expanded) {
+			const brief = textContent.length > 200 ? textContent.slice(0, 200) + "..." : textContent;
+			return new Text(statusLine + "\n" + theme.fg("dim", brief), 0, 0);
+		}
+		const lines = [statusLine];
+		if (details?.prompt) {
+			const display = details.prompt.length > 250 ? details.prompt.slice(0, 247) + "..." : details.prompt;
+			lines.push(theme.fg("dim", `  prompt: "${display}"`));
+		}
+		if (details?.timestamp) {
+			lines.push(theme.fg("dim", `  timestamp: ${details.timestamp}`));
+		}
+		if (typeof details?.frames === "number") {
+			lines.push(theme.fg("dim", `  frames: ${details.frames}`));
+		}
+		const preview = textContent.length > 500 ? textContent.slice(0, 500) + "..." : textContent;
+		lines.push(theme.fg("dim", preview));
+		return new Text(lines.join("\n"), 0, 0);
+	}
+
+	const countColor = (details?.successful ?? 0) > 0 ? "success" : "error";
+	const statusLine = theme.fg(countColor, `${details?.successful}/${details?.urlCount} URLs`) + theme.fg("muted", " (content stored)");
+	if (!expanded) {
+		return new Text(statusLine, 0, 0);
+	}
+	const textContent = firstTextContent(result);
+	const preview = textContent.length > 500 ? textContent.slice(0, 500) + "..." : textContent;
+	return new Text(statusLine + "\n" + theme.fg("dim", preview), 0, 0);
+};
+
+export const renderGetSearchContentResult: ToolResultRenderer = (result, { expanded }, theme) => {
+	const details = result.details as GetSearchContentResultDetails | undefined;
+
+	if (details?.error) {
+		return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+	}
+
+	let statusLine: string;
+	if (details?.query) {
+		statusLine = theme.fg("success", `"${details.query}"`) + theme.fg("muted", ` (${details.resultCount} results)`);
+	} else {
+		statusLine = theme.fg("success", details?.title || "Content") + theme.fg("muted", ` (${details?.contentLength ?? 0} chars)`);
+	}
+
+	if (!expanded) {
+		return new Text(statusLine, 0, 0);
+	}
+
+	const textContent = firstTextContent(result);
+	const preview = textContent.length > 500 ? textContent.slice(0, 500) + "..." : textContent;
+	return new Text(statusLine + "\n" + theme.fg("dim", preview), 0, 0);
+};
+
+export function renderWebAccessToolResult(name: string, args: ToolRenderResultArgs): ToolRenderResult {
+	switch (name) {
+		case "web_search":
+			return renderWebSearchResult(...args);
+		case "code_search":
+			return renderCodeSearchResult(...args);
+		case "fetch_content":
+			return renderFetchContentResult(...args);
+		case "get_search_content":
+			return renderGetSearchContentResult(...args);
+		default: {
+			const theme = args[2];
+			return new Text(theme.fg("error", `Result renderer not found: ${name}`), 0, 0);
+		}
+	}
+}

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,27 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.8.26-alpha.2] - 2026-06-05
+
+### Changed
+
+- Updated the `research-codebase` skill to capture a `breaking_changes_allowed` compatibility posture before research fanout, carry it through sub-agent prompts, and record it in research documents so downstream specs and workflows do not preserve legacy APIs by default when breaking changes are allowed ([#1225](https://github.com/bastani-inc/atomic/issues/1225)).
+
+### Fixed
+
+- Fixed stage-local workflow HIL `input` and `editor` prompts losing draft text across Ctrl+D detach/reattach; drafts are kept live-only in memory and cleared when the prompt or run/stage exits ([#1179](https://github.com/bastani-inc/atomic/issues/1179)).
+- Fixed workflow worktree Git commands to strip ambient repository-local Git environment variables before inspecting or creating targeted worktrees.
+- Suppressed intermediate model fallback failure warnings from successful workflow stages while preserving final failures and raw per-attempt diagnostics ([#1226](https://github.com/bastani-inc/atomic/issues/1226)).
+
+## [0.8.26-alpha.1] - 2026-06-05
+
+### Fixed
+
+- Fixed the inline-form "snapshot lost" renderer and the `workflow.run.start`/`workflow.run.end` banner renderers returning bare strings, which crashed the host TUI with `child.render is not a function` when resuming a session containing persisted workflow custom messages. These renderers now return proper render components ([#1236](https://github.com/bastani-inc/atomic/issues/1236)).
+- Fixed the workflow input form (the `/workflow <name>` argument selector) leaking into model context: spawning the picker and exiting without running the workflow no longer sends the form to the LLM. The input-form card is now emitted with `excludeFromContext` since it is transient UI, not conversation.
+- Fixed the workflow input widget re-rendering in chat after `/resume`. Inline-form state is now cleared on `session_start`, and a rehydrated `workflows:input-form` card whose backing state is gone now renders nothing (returns `null`) instead of a stale form or "snapshot lost" placeholder.
+- Stage sessions now emit `session_shutdown` before `dispose()` (mirroring the host `AgentSessionRuntime` teardown) so bound extensions receive a graceful shutdown signal instead of being silently invalidated. This stops disposed stage sessions from leaking child MCP servers and from triggering spurious stale-context "MCP initialization failed" errors when an extension's deferred `session_start` work races with stage disposal.
+
 ## [0.8.25] - 2026-06-04
 
 ### Changed

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.8.25",
+  "version": "0.8.26-alpha.2",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [

package/dist/builtin/workflows/skills/research-codebase/SKILL.md

@@ -24,14 +24,24 @@ The user's research question/request is: **$ARGUMENTS**
     - **CRITICAL**: Read these files yourself in the main context before spawning any sub-tasks
     - This ensures you have full context before decomposing the research
 
-2. **Analyze and decompose the research question:**
+2. **Determine the compatibility posture:**
+    - Before decomposing the research request, identify whether this project must preserve backward compatibility for real downstream users.
+    - If the user explicitly allows breaking changes, public API changes, cleanup, or says there are no real users/downstream dependencies, set `breaking_changes_allowed: true`.
+    - If the user mentions production users, published APIs, downstream consumers, migration safety, or compatibility requirements, set `breaking_changes_allowed: false`.
+    - If the posture is not inferable from the request, ask the user once before continuing, using the available structured question tool when possible.
+    - Carry this posture into the research plan, every sub-agent prompt, the final research document frontmatter, and the `## Compatibility Context` section.
+    - When `breaking_changes_allowed: true`, document existing legacy behavior, compatibility shims, optional flags, and public APIs as current state, not as constraints future specs must preserve unless the user explicitly asks for preservation.
+    - When `breaking_changes_allowed: false`, document public APIs, compatibility-sensitive surfaces, downstream callers, migration constraints, and behavior that future work must preserve.
+
+3. **Analyze and decompose the research question:**
     - Break the research question down into composable research areas
     - Take time to ultrathink about the underlying patterns, connections, and architectural implications the user might be seeking
     - Identify specific components, patterns, or concepts to investigate
     - Create a research plan using TodoWrite to track all subtasks
+    - Include the compatibility posture in the plan so later synthesis and spec creation inherit the same constraint.
     - Consider which directories, files, or architectural patterns are relevant
 
-3. **Spawn parallel sub-agent tasks:**
+4. **Spawn parallel sub-agent tasks:**
     - Create multiple Task agents to research different aspects concurrently
     - We now have specialized agents that know how to do specific research tasks:
 
@@ -67,8 +77,9 @@ The user's research question/request is: **$ARGUMENTS**
     - Each agent knows its job - just tell it what you're looking for
     - Don't write detailed prompts about HOW to search - the agents already know
     - Remind agents they are documenting, not evaluating or improving
+    - Include `breaking_changes_allowed: true` or `breaking_changes_allowed: false` in each sub-agent prompt so compatibility-sensitive findings are documented with the right posture.
 
-4. **Wait for all sub-agents to complete and synthesize:**
+5. **Wait for all sub-agents to complete and synthesize:**
     - IMPORTANT: Wait for ALL sub-agent tasks to complete before proceeding
     - Compile all sub-agent results (both codebase and research findings)
     - Prioritize live codebase findings as primary source of truth
@@ -79,7 +90,7 @@ The user's research question/request is: **$ARGUMENTS**
     - Answer the user's research question with concrete evidence
     - **If findings reveal the original question was misframed** (e.g., the system works differently than assumed, or the components don't exist where expected), flag this to the user before finalizing the document. This is valuable signal — don't bury it.
 
-5. **Generate research document:**
+6. **Generate research document:**
     - Follow the directory structure for research documents:
 
 ```
@@ -117,6 +128,8 @@ research/
     status: complete
     last_updated: !`date '+%Y-%m-%d'`
     last_updated_by: [Researcher name]
+    breaking_changes_allowed: [true or false]
+    compatibility_context: "[Short explanation of downstream-user/API compatibility posture]"
     ---
 
     # Research
@@ -125,6 +138,10 @@ research/
 
     [Original user query]
 
+    ## Compatibility Context
+
+    [State whether breaking changes are allowed. If true, note that existing compatibility shims, optional flags, legacy APIs, and public APIs are documented as current state rather than preservation constraints. If false, summarize compatibility-sensitive surfaces, downstream users/callers, migration constraints, and behavior future work must preserve.]
+
     ## Summary
 
     [High-level documentation of what was found, answering the user's question by describing what exists]
@@ -167,19 +184,19 @@ research/
     [Any areas that need further investigation]
     ```
 
-1. **Add GitHub permalinks (if applicable):**
+7. **Add GitHub permalinks (if applicable):**
     - Check if on main branch or if commit is pushed: `git branch --show-current` and `git status`
     - If on main/master or pushed, generate GitHub permalinks:
         - Get repo info: `gh repo view --json owner,name`
         - Create permalinks: `https://github.com/{owner}/{repo}/blob/{commit}/{file}#L{line}`
     - Replace local file references with permalinks in the document
 
-2. **Present findings:**
+8. **Present findings:**
     - Present a concise summary of findings to the user
     - Include key file references for easy navigation
     - Ask if they have follow-up questions or need clarification
 
-3. **Handle follow-up questions:**
+9. **Handle follow-up questions:**
 
 - If the user has follow-up questions, append to the same research document
 - Update the frontmatter fields `last_updated` and `last_updated_by` to reflect the update
@@ -207,10 +224,12 @@ research/
 - **REMEMBER**: Document what IS, not what SHOULD BE
 - **NO RECOMMENDATIONS**: Only describe the current state of the codebase
 - **File reading**: Always read mentioned files FULLY (no limit/offset) before spawning sub-tasks
+- **Compatibility posture**: Always determine `breaking_changes_allowed` before decomposing the question. This is a single project/research posture, not a request to add compatibility flags. Use it to document whether old APIs and shims are constraints for future work.
 - **Critical ordering**: Follow the numbered steps exactly
     - ALWAYS read mentioned files first before spawning sub-tasks (step 1)
-    - ALWAYS wait for all sub-agents to complete before synthesizing (step 4)
-    - ALWAYS gather metadata before writing the document (step 5 before step 6)
+    - ALWAYS determine compatibility posture before decomposing the question (step 2)
+    - ALWAYS wait for all sub-agents to complete before synthesizing (step 5)
+    - ALWAYS gather metadata before writing the document (as part of step 6)
     - NEVER write the research document with placeholder values
 
 - **Frontmatter consistency**:

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

@@ -54,6 +54,7 @@ import {
   openInlineInputsForm,
   registerInlineFormRenderer,
 } from "../tui/inline-form-overlay.js";
+import { clearForms } from "../tui/inline-form-store.js";
 import {
   registerChatSurfaceRenderer,
   emitChatSurface,
@@ -166,7 +167,7 @@ export interface PiMessageRenderOptions {
   expanded: boolean;
 }
 
-export type PiMessageRendererResult = string | PiMessageRenderComponent | undefined;
+export type PiMessageRendererResult = string | PiMessageRenderComponent | null | undefined;
 export type PiMessageRenderer = (
   payload: unknown,
   options?: PiMessageRenderOptions,
@@ -3756,11 +3757,14 @@ function factory(pi: ExtensionAPI): void {
   // duplicating it into chat scroll just creates visual noise and pushes
   // older chat content out of view every time a stage transitions.
   if (typeof pi.registerMessageRenderer === "function") {
+    // Wrap the string-producing banners in a render component: the host adds a
+    // renderer's result directly as a TUI child, so a bare string would crash
+    // `Container.render()` with "child.render is not a function".
     pi.registerMessageRenderer("workflow.run.start", (payload) =>
-      renderRunBanner(payload as RunStartPayload),
+      dynamicTextRenderComponent(() => renderRunBanner(payload as RunStartPayload)),
     );
     pi.registerMessageRenderer("workflow.run.end", (payload) =>
-      renderRunSummary(payload as RunEndPayload),
+      dynamicTextRenderComponent(() => renderRunSummary(payload as RunEndPayload)),
     );
     // Inline workflow-input form (Option C in the design conversation):
     // a sticky chat-history card driven by a custom EditorComponent. The
@@ -3834,6 +3838,12 @@ function factory(pi: ExtensionAPI): void {
         persistence: persistenceRef.current,
       });
       store.clear();
+      // Drop any inline input-form state from a previous session in this pi
+      // process. A resumed/replaced session must not render a stale live form,
+      // and rehydrated `workflows:input-form` cards then resolve to no backing
+      // state so their renderer suppresses output (input widget hidden after
+      // /resume).
+      clearForms();
       resetWorkflowLifecycleNotificationState(lifecycleNotificationState);
       resetWorkflowHilAnswerNotificationState(hilAnswerNotificationState);
       stageControlRegistry.clear();

package/dist/builtin/workflows/src/runs/foreground/stage-runner.ts

@@ -285,6 +285,57 @@ function terminatingToolResultText(
   return undefined;
 }
 
+/**
+ * A stage session backed by a real Atomic `AgentSession` exposes its
+ * `extensionRunner`. When workflow wiring binds extensions to a stage session it
+ * replays the `session_start` lifecycle (see wiring.ts `bindExtensions`), so
+ * extensions such as MCP begin per-session initialization. Tearing that session
+ * down with `dispose()` alone invalidates the extension runtime WITHOUT emitting
+ * `session_shutdown`, so those extensions never receive a graceful teardown
+ * signal: MCP, for example, logs a spurious stale-context "initialization
+ * failed" error when its deferred init races with disposal, and leaves any child
+ * MCP servers running.
+ *
+ * The test stub session (createTestAgentSession) has no `extensionRunner`, so the
+ * capability is optional and feature-detected at runtime.
+ */
+type StageSessionExtensionRunner = {
+  hasHandlers(eventType: string): boolean;
+  emit(event: { readonly type: "session_shutdown"; readonly reason: "quit" }): Promise<unknown>;
+};
+
+function stageSessionExtensionRunner(
+  current: StageSessionRuntime,
+): StageSessionExtensionRunner | undefined {
+  const runner = (current as StageSessionRuntime & { extensionRunner?: StageSessionExtensionRunner })
+    .extensionRunner;
+  if (runner && typeof runner.hasHandlers === "function" && typeof runner.emit === "function") {
+    return runner;
+  }
+  return undefined;
+}
+
+/**
+ * Dispose a stage session, mirroring the host `AgentSessionRuntime` teardown:
+ * emit `session_shutdown` before `dispose()` whenever the session exposes a
+ * compatible extension runner, so extensions tear down per-session resources
+ * (and bump their lifecycle generation) instead of being silently invalidated.
+ * A throwing shutdown handler must never strand the session, so disposal always
+ * runs.
+ */
+async function disposeStageSession(current: StageSessionRuntime | undefined): Promise<void> {
+  if (!current) return;
+  const runner = stageSessionExtensionRunner(current);
+  if (runner?.hasHandlers("session_shutdown")) {
+    try {
+      await runner.emit({ type: "session_shutdown", reason: "quit" });
+    } catch (error) {
+      console.error("atomic-workflows: stage session_shutdown handler failed", error);
+    }
+  }
+  await current.dispose();
+}
+
 function asAgentSession(activeSession: StageSessionRuntime | undefined): AgentSession | undefined {
   if (!activeSession) return undefined;
   const candidate = activeSession as StageSessionRuntime & Partial<Pick<AgentSession, "state" | "sessionManager" | "modelRegistry" | "getContextUsage">>;
@@ -535,6 +586,7 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
   let selectedModel: string | undefined;
   const modelAttempts: WorkflowModelAttempt[] = [];
   const modelWarnings: string[] = [];
+  const pendingFallbackWarnings: string[] = [];
   const modelCatalog = opts.models === undefined
     ? undefined
     : {
@@ -675,7 +727,7 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
     unsubscribeTerminateWatcher?.();
     unsubscribeTerminateWatcher = undefined;
     terminatingToolCallIds.clear();
-    await current?.dispose();
+    await disposeStageSession(current);
   }
 
   async function promptWithPauseResume(
@@ -745,15 +797,19 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
       try {
         await promptWithPauseResume(activeSession, text, sdkOptions);
         modelAttempts.push({ model: candidate.id, success: true, ...modelAttemptReasoning(candidate) });
+        pendingFallbackWarnings.length = 0;
         return;
       } catch (err) {
         const message = errorMessage(err);
         modelAttempts.push({ model: candidate.id, success: false, ...modelAttemptReasoning(candidate), error: message });
         if (signal?.aborted || !isRetryableModelFailure(message) || index === candidates.length - 1) {
+          modelWarnings.push(...pendingFallbackWarnings);
+          pendingFallbackWarnings.length = 0;
+          notifyModelFallbackMetaChange();
           throw err;
         }
         const nextCandidate = candidates[index + 1]!;
-        modelWarnings.push(`[fallback] ${candidateLabel(candidate)} failed: ${message}. Retrying with ${candidateLabel(nextCandidate)}.`);
+        pendingFallbackWarnings.push(`[fallback] ${candidateLabel(candidate)} failed: ${message}. Retrying with ${candidateLabel(nextCandidate)}.`);
         await disposeCurrentSession();
         index += 1;
       }
@@ -895,7 +951,7 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
       unsubscribeTerminateWatcher?.();
       unsubscribeTerminateWatcher = undefined;
       terminatingToolCallIds.clear();
-      await session?.dispose();
+      await disposeStageSession(session);
     },
 
     __getLastAssistantText() {