@bastani/atomic 0.9.13-alpha.1 → 0.9.13-alpha.2

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,51 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.13-alpha.2] - 2026-08-12
+
+### Breaking Changes
+
+- Custom workflow UI components must return `true` when they consume input and `false` when they do not. In fullscreen mode, an unhandled result lets the transcript process matching viewport navigation keys instead of swallowing them.
+- Added `failed` to the `ctx.exit()` status union. Author-initiated failed exits persist their reason and partial declared outputs, return the discriminated `{ exited: true, status: "failed" }` child result instead of throwing, and default to non-resumable unless `resumable: true` is set. Downstream exhaustive switches over `WorkflowExitStatus` must handle the new failed-exit case ([#2242](https://github.com/bastani-inc/atomic/issues/2242)).
+
+### Changed
+
+- Updated the Ralph research stage model configuration. The primary model moves from `openai-codex/gpt-5.6-luna:max` to `anthropic/claude-opus-5:high`, and the fallback chain is rebuilt around high/xhigh thinking levels: GPT-5.6 Sol at `xhigh` replaces the Luna variants, Claude Fable 5 and Claude Opus 4.8 step up from `low`/`medium` to `high`, GPT-5.5 and GLM-5.2 step up to `xhigh`, and Kimi K3 (`kimi-coding`, `moonshotai`, `moonshotai-cn`, and OpenRouter) plus `openrouter/sakana/fugu-ultra:high` join the chain.
+- Extended workflow-authoring guidance with a stacked implementation-slices starter pattern: authors target roughly 100–500 changed lines between verification points by default, route each slice through a child lifecycle, explicitly create or check out each named branch before its child because `base_branch` and `git_worktree_dir` alone do not create feature branches, stack each verified branch and worktree, and stop at the first failed gate while preserving earlier verification ([#2262](https://github.com/bastani-inc/atomic/issues/2262)).
+- Updated authored-workflow model guidance to treat benchmark thinking levels as measurement settings, assign effort by stage role and failure cost, require a compact `Stage | Model | Thinking | Role` declaration before launch, reserve `max` for high-cost-of-error roles or explicit user requests, and apply catalog-aware role policy to primary and fallback attempts ([#2203](https://github.com/bastani-inc/atomic/issues/2203)).
+- Added bounded constructive-quorum deliberation to Goal and Ralph reviewer prompts: reviewers form independent preliminary verdicts, exchange evidence once over Intercom, and record evidence-backed verdict changes before the existing reducer counts final votes ([#2237](https://github.com/bastani-inc/atomic/issues/2237)).
+
+- Rebuilt the workflow graph overlay on pi-tui 0.84.1's `VStack` and `ScrollView` layout primitives. The graph body now adapts to terminal height and resize, supports vertical wheel scrolling and a draggable scrollbar, and keeps wide-graph horizontal panning and existing prompt/navigation key handling ([#2223](https://github.com/bastani-inc/atomic/issues/2223)).
+- Retired the legacy terminal-row callback thread from graph and stage-chat views. The two fullscreen-frame consumers still read `terminal.rows` directly: GraphView uses it for the overlay frame, and StageChatView uses it for the chat line count, falling back to the unhosted `VIEW_LINE_COUNT = 32` frame when no host is present. `PiCustomComponent.render` supplies only a width, so the #2223 viewport-row criterion remains partial at those call paths ([#2223](https://github.com/bastani-inc/atomic/issues/2223)).
+
+- Workflow command, worktree Git/setup-hook, and Playwright CLI subprocesses now receive `AI_AGENT=atomic` for generic child-process attribution without mutating caller-supplied environment objects.
+
+### Fixed
+- Fixed completed `ctx.exit()` runs losing the reserved returned-status convention, legacy child replay records losing their exit discriminator, and failed author-exit resume surfaces falling back to snapshot inspection instead of durable retry.
+- Fixed workflow graph node cards appending the Codex `fast` marker to dependency metadata; cards now show only topology details such as `root`, `1 dep`, or `<n> deps` while fast-mode state remains available to the stage and its model label ([#2337](https://github.com/bastani-inc/atomic/issues/2337)).
+
+- Fixed the workflow graph overlay statusline echoing the `i-have-adhd` extension's `ADHD Mode` badge. The badge remains in the main-chat footer while other extension statuses continue to render in the overlay ([#2341](https://github.com/bastani-inc/atomic/issues/2341)).
+
+- Fixed fullscreen workflow graph and stage-chat mouse routing. Focused workflow overlays now receive SGR/X10 wheel and click press/release sequences through the host's bounded custom-input reply channel before pi-tui's alternate-screen viewport, restoring graph scrolling and click-to-attach without a workflow-owned TTY-tracking seam; the fullscreen route also mirrors consumed left-button events into pi-tui's application-owned selection path ([#2303](https://github.com/bastani-inc/atomic/issues/2303)).
+- Fixed graph overlay rendering to keep its live vertical position in pi-tui's `ScrollView` and preserve OSC-8 hyperlink terminators when normalizing layout rows.
+
+- Fixed switcher wheel input scrolling an obscured graph and the scrollbar covering the final graph column; overflow now reserves its scrollbar column and the switcher owns wheel selection ([#2223](https://github.com/bastani-inc/atomic/issues/2223)).
+- Restored natural graph geometry for unhosted overlays by removing the fixed-height fallback and kept pi-tui's layout metadata aligned with sparse, deeply scrolled content, so large graphs track their natural geometry without corrupting OSC-8 rows ([#2223](https://github.com/bastani-inc/atomic/issues/2223)).
+
+- Fixed the inline workflow form editor not inheriting the host's `autocompleteMaxVisible` setting when Atomic installs it as a custom editor.
+- Fixed late workflow messages and MCP scope cleanup that finish after an extension reload. Stale event-bus calls now stop without retrying through stale APIs, while active routes keep their normal fallback behavior.
+- Fixed workflow stale-context guards by consuming the host's exported predicate instead of copying its error-message marker.
+- Fixed late-message routing to reject stale drops consistently for Intercom and generic batches, so a resolved route means delivery was accepted instead of silently treating a dropped message as routed; non-stale failures still propagate.
+
+- Fixed the `DISPATCHED` confirmation panel being torn apart by any workflow input containing a newline. Input values were truncated by visible width, which a control character does not have, so an embedded newline survived truncation and emitted extra physical lines that no border ever wrapped — the box was destroyed from that row down. Multi-line inputs are ordinary, so this fired for most real launches: a `prompt` or an `acceptance_criteria` block reliably reproduced it. String values and the object/array JSON projection now collapse control characters, `U+2028`, and `U+2029` to single spaces before truncation, so a run card stays one row per value. `U+2028`/`U+2029` are included because `JSON.stringify` does not escape them and some terminals still break lines on them. As a side effect, escape sequences in an input value can no longer inject ANSI styling into the chat surface.
+- Fixed workflow stages being unable to use the `subagent` tool at all. The stage policy set `managementActions: "full"` and `fanoutAuthorized: false` together, which contradict: stages could neither delegate nor, because of the companion subagents defect, run read-only management such as `subagent list`. Workflow stages are top-level sessions rather than subagent children, so the policy now sets `fanoutAuthorized: true`, restoring the delegation the workflow docs already describe. Nesting remains bounded by the typed in-process depth policy and Rust admission’s five-level ceiling ([#2220](https://github.com/bastani-inc/atomic/pull/2220), regression from [#2205](https://github.com/bastani-inc/atomic/pull/2205)).
+- Fixed nested subagents in workflow-stage sessions losing the bundled `subagent` extension. In-process child resource loading now carries the bundled package roots and disables only the workflow extension's repeated stage lifecycle, so a stage can delegate and its nested child receives the bundled tools instead of only the base built-in ones ([#2220](https://github.com/bastani-inc/atomic/pull/2220), regression from [#2205](https://github.com/bastani-inc/atomic/pull/2205)).
+- Fixed a stage chat opened on a stage that was already mid-turn showing an empty transcript. The stage's assistant message joins the handle's message list only when its turn ends, and streaming updates now carry a delta rather than the message so far, so a chat mounted after the stream started had nothing to draw and nothing that would restate it — a stage held mid-turn stayed blank for the whole turn. The chat now seeds itself from the stage session's in-flight assistant message when it mounts, and the deltas that arrive after that continue the same message.
+
+### Removed
+
+- Removed workflow-owned mouse-scroll reporting and attached-stage copy mode. Fullscreen pi-tui now keeps application-owned drag and multi-click selection available over workflow overlays, and `ctrl+t` is left to the host keybindings. Copy still uses OSC 52; terminals that refuse OSC 52 writes require the modifier-drag bypass (Shift/Option, as provided by the terminal).
+
 ## [0.9.13-alpha.1] - 2026-08-05
 
 ### Added

package/dist/builtin/workflows/README.md

@@ -298,6 +298,44 @@ import openClaudeDesignWorkflow from "@bastani/workflows/builtin/open-claude-des
 
 Only `workflow({...})` definitions can be passed to `ctx.workflow(...)`; registry names, strings, and path objects are intentionally not supported for child workflow calls. Missing or invalid module imports fail when the workflow file itself is loaded. A parent receives the child's declared `outputs` from the child `run()` return object. Missing required outputs, schema type mismatches, returning an undeclared output, and non-JSON-serializable returned child values fail the child call before the parent continues.
 
+### Early exit with `ctx.exit()`
+
+Use `ctx.exit()` when the workflow intentionally ends before its normal `run()` return. It accepts `completed | skipped | cancelled | blocked | failed`, an optional reason, partial declared outputs, and `resumable` for an author-initiated failed outcome.
+
+```typescript
+if (allRejected) {
+  return ctx.exit({
+    status: "failed",
+    reason: "The upstream API rejected every candidate",
+    outputs: { attempted: candidates.length },
+    resumable: true, // failed exits default to false
+  });
+}
+```
+
+Choose the status by the outcome:
+
+- `completed` means the objective was met and declared outputs are complete and trustworthy.
+- `skipped` means a precondition made the run a valid no-op; no work was needed.
+- `cancelled` means the work is no longer wanted; it is a decision, not a defect.
+- `blocked` means valid progress needs a changed condition or a later decision. A bounded reviewer or repair loop that does not converge is blocked, not failed.
+- `failed` means required work was attempted and definitively could not complete. Do not use it for a non-converged reviewer loop. Failed exits are non-resumable by default; set `resumable: true` when a later durable retry is intended. `resumable` is valid only with `failed`; another status records a non-resumable authoring failure.
+
+`reason` from a valid author exit is persisted and shown in status and lifecycle notices. An exit rejected during validation is finalized as an ordinary failed run rather than an accepted author exit. `outputs` may be a partial subset of the declared `outputs` contract, but every provided key must be declared, schema-valid, and JSON-serializable. Missing required keys are allowed only on the exit path. A durable retry re-dispatches the workflow with completed checkpoints replayed. The low-level `resumeRun()` helper only inspects terminal runs and reports the durable retry path; it does not silently claim that it resumed one.
+
+When a child uses `ctx.exit()`, `ctx.workflow(child)` returns a discriminated result instead of throwing. Check `child.exited` before reading a required output:
+
+```typescript
+const child = await ctx.workflow(researchWorkflow);
+if (child.exited === true) {
+  // child.status includes failed; outputs may be partial.
+  return ctx.exit({ status: child.status, reason: child.exitReason ?? "research stopped early" });
+}
+return { report: child.outputs.report };
+```
+
+An author-initiated failed exit returns `{ exited: true, status: "failed" }` to its parent with its reason and partial outputs. An unintentional child failure still throws, so `exited` remains an intent discriminator.
+
 ### Reusable Git worktrees
 
 Use `gitWorktreeDir` when a workflow should run in a reusable Git worktree instead of the invoking checkout. The executor creates the worktree if it is missing, reuses it when it already exists as a same-repository worktree root, defaults workflow `ctx.cwd` to the matching path inside that worktree for `worktreeFromInputs`, and defaults stage/task `cwd` to that worktree path.
@@ -425,6 +463,8 @@ export default workflow({
 
 Set `model` and `fallbackModels` on the authored stage/task/chain/parallel item that needs them.
 
+For authored workflows, choose thinking effort by stage role and failure cost rather than copying a benchmark's level onto every stage. Before launch, record each model stage's role, failure cost, primary model, thinking level, and fallback policy, then print a compact `Stage | Model | Thinking | Role` assignment with a short rationale. Reserve `max` for high-cost-of-error roles or an explicit user request; use `high` for demanding analysis, planning, and repair; use `medium` for user-impact review and reporting; and keep deterministic checks as tool nodes with no model call. Apply the same role policy independently to every fallback, not a mechanical `max` inheritance. Use only levels listed in the configured catalog's `availableThinkingLevels`; if a level is unsupported, choose another catalog model or leave the stage unpinned rather than inventing a suffix.
+
 When pi exposes its model registry, workflow runs validate user-specified `model` / `fallbackModels` before starting model-backed work and report all unavailable or ambiguous IDs together. Bare model IDs are accepted only when they resolve uniquely or match the current provider; otherwise use `provider/model`. Fallback attempts may send the same prompt/context to a different provider, so choose fallbacks that fit your cost, privacy, and data-handling requirements.
 
 ### `createRegistry` — grouping workflows
@@ -595,7 +635,7 @@ Tradeoff: `Type.Unsafe<T>()` does not deeply validate at runtime — it trusts t
 
 Input overrides are bare `key=value` tokens (no leading `--`). Values are JSON-parsed when possible, so numbers, booleans, and quoted strings work as expected (e.g. `count=3`, `flag=true`, `prompt="multi word value"`). A whole-object override can be passed as a single JSON token (e.g. `{"prompt":"...","count":3}`). Runtime validation is strict: unknown input keys, missing required values, type mismatches, and invalid `select` choices fail before a named workflow run starts.
 
-Named workflow launches always run as **background tasks** in interactive sessions. Run `/workflow connect <run>` to see agents working and chat with and steer each stage. Foreground launches are reserved for explicit user requests or technical requirements, with notice before launch. Press **F2** to open the same live graph viewer; HIL prompts (`ctx.ui.input/confirm/select/editor/custom`) appear as awaiting-input graph nodes. Press Enter on a focused node, or click a visible graph node directly, to open that stage and answer locally, never as a modal dialog over the chat. `ctrl+x` is the workflow hierarchy chord: attached stage chats show **ctrl+x return to graph**, while graph surfaces show **ctrl+x leave graph · return to main chat**. Workflow surfaces consume it before configurable editor/tool actions. Composer and prompt drafts survive leaving a stage, and pending custom questions remain pending for reattachment. `ctrl+d` and `q` are not workflow navigation controls; ordinary editor/prompt Ctrl+D behavior and printable prompt `q` remain available. Existing `esc`, `ctrl+c`, and graph `h` close/hide behavior is unchanged. While the graph pane is active, vertical wheel/trackpad gestures pan vertically and horizontal gestures pan wide graphs left and right when the terminal reports them, without falling through to the main chat or terminal scrollback. Attached stage chats capture mouse/trackpad wheel events by default so scrolling stays inside the active stage transcript or prompt instead of falling through to terminal/main-chat scrollback. Press `ctrl+t` to toggle **copy mode**: copy mode disables workflow-chat mouse reporting so normal terminal/tmux text selection can work; press `ctrl+t` again to leave copy mode and restore workflow-chat scrolling. Archived read-only stage transcripts show the same copy-mode footer/status, allowing their transcript text to be selected and copied while preserving `esc` close and `ctrl+x` graph navigation. While copy mode is on, wheel/trackpad gestures are handled by the terminal/tmux and may scroll terminal scrollback, so leave copy mode before using the wheel again. Human input is detected when those runtime `ctx.ui.*` calls execute; workflows no longer have a declaration-time HIL flag.
+Named workflow launches always run as **background tasks** in interactive sessions. Run `/workflow connect <run>` to see agents working and chat with and steer each stage. Foreground launches are reserved for explicit user requests or technical requirements, with notice before launch. Press **F2** to open the same live graph viewer; HIL prompts (`ctx.ui.input/confirm/select/editor/custom`) appear as awaiting-input graph nodes. Press Enter on a focused node, or click a visible graph node directly, to open that stage and answer locally, never as a modal dialog over the chat. `ctrl+x` is the workflow hierarchy chord: attached stage chats show **ctrl+x return to graph**, while graph surfaces show **ctrl+x leave graph · return to main chat**. Workflow surfaces consume it before configurable editor/tool actions. Composer and prompt drafts survive leaving a stage, and pending custom questions remain pending for reattachment. `ctrl+d` and `q` are not workflow navigation controls; ordinary editor/prompt Ctrl+D behavior and printable prompt `q` remain available. Existing `esc`, `ctrl+c`, and graph `h` close/hide behavior is unchanged. While the graph pane is active, vertical wheel/trackpad gestures pan vertically and horizontal gestures pan wide graphs left and right when the terminal reports them, without falling through to the main chat or terminal scrollback. Focused graph and stage-chat overlays receive those gestures through the fullscreen application route. Fullscreen pi-tui owns application selection, so drag and multi-click selection also work over workflow overlays; copied text uses OSC 52, and terminals that refuse OSC 52 writes rely on the modifier-drag bypass (Shift/Option, as provided by the terminal). `ctrl+t` is not a workflow control: focused workflow overlays leave it to the host `app.thinking.toggle` action, while inline tree selectors keep `app.tree.filter.noTools`. Human input is detected when those runtime `ctx.ui.*` calls execute; workflows no longer have a declaration-time HIL flag.
 
 Typing into an attached stage chat and pressing Enter steers: the message is consumed after the current assistant response finishes its tool batch and before the next model request, matching normal session steering. Ctrl+F queues a follow-up, consumed only when the agent would otherwise stop. Queued entries belong to the stage session rather than the pane, so leaving the stage and reattaching restores the pending `Steering:` / `Follow-up:` rows, and a detached stage node carries a `✉ N queued` badge in the graph.
 

package/dist/builtin/workflows/builtin/open-claude-design-utils.ts

@@ -3,6 +3,7 @@ import { mkdirSync } from "node:fs";
 import { tmpdir, userInfo } from "node:os";
 import { join } from "node:path";
 import { Type } from "typebox";
+import { createChildProcessEnvironment } from "@bastani/atomic";
 import type { WorkflowTaskResult } from "../src/shared/types.js";
 
 
@@ -229,6 +230,7 @@ export function ensurePlaywrightCli(): PlaywrightCliStatus {
         stdio: "ignore",
         timeout: 15_000,
         shell: isWindows,
+        env: createChildProcessEnvironment(),
       });
       return probe.status === 0;
     } catch {
@@ -265,6 +267,7 @@ export function ensurePlaywrightCli(): PlaywrightCliStatus {
       stdio: "ignore",
       timeout: 180_000,
       shell: isWindows,
+      env: createChildProcessEnvironment(),
     });
     if (install.status === 0) {
       return {

package/dist/builtin/workflows/builtin/ralph-models.ts

@@ -48,29 +48,34 @@ export const promptEngineerModelConfig = {
 };
 
 export const researchModelConfig = {
-    model: "openai-codex/gpt-5.6-luna:max",
+    model: "anthropic/claude-opus-5:high",
     fallbackModels: [
-      "github-copilot/gpt-5.6-luna:max",
-      "openai/gpt-5.6-luna:max",
-      "anthropic/claude-opus-5:low",
-      "github-copilot/claude-opus-5:low",
-      "anthropic/claude-fable-5:low",
-      "github-copilot/claude-fable-5:low",
-      "openai-codex/gpt-5.5:medium",
-      "github-copilot/gpt-5.5:medium",
-      "openai/gpt-5.5:medium",
-      "anthropic/claude-opus-4-8:medium",
-      "github-copilot/claude-opus-4.8:medium",
+      "github-copilot/claude-opus-5:high",
+      "openai-codex/gpt-5.6-sol:xhigh",
+      "github-copilot/gpt-5.6-sol:xhigh",
+      "openai/gpt-5.6-sol:xhigh",
+      "anthropic/claude-fable-5:high",
+      "github-copilot/claude-fable-5:high",
+      "kimi-coding/k3:max",
+      "moonshotai/kimi-k3:max",
+      "moonshotai-cn/kimi-k3:max",
+      "openai-codex/gpt-5.5:xhigh",
+      "github-copilot/gpt-5.5:xhigh",
+      "openai/gpt-5.5:xhigh",
+      "anthropic/claude-opus-4-8:high",
+      "github-copilot/claude-opus-4.8:high",
       "xai/grok-4.5:high",
-      "zai/glm-5.2:high",
-      "zai-coding-cn/glm-5.2:high",
-      "openrouter/openai/gpt-5.6-luna:max",
-      "openrouter/anthropic/claude-opus-5:low",
-      "openrouter/openai/gpt-5.5:medium",
-      "openrouter/anthropic/claude-fable-5:low",
-      "openrouter/anthropic/claude-opus-4-8:medium",
+      "zai/glm-5.2:xhigh",
+      "zai-coding-cn/glm-5.2:xhigh",
+      "openrouter/anthropic/claude-opus-5:high",
+      "openrouter/openai/gpt-5.6-sol:xhigh",
+      "openrouter/anthropic/claude-fable-5:high",
+      "openrouter/moonshotai/kimi-k3:max",
+      "openrouter/sakana/fugu-ultra:high",
+      "openrouter/openai/gpt-5.5:xhigh",
+      "openrouter/anthropic/claude-opus-4-8:high",
       "openrouter/x-ai/grok-4.5",
-      "openrouter/z-ai/glm-5.2:high"
+      "openrouter/z-ai/glm-5.2:xhigh"
     ],
     excludedTools: ["ask_user_question"],
 };

package/dist/builtin/workflows/builtin/shared-prompts.ts

@@ -117,10 +117,13 @@ export const CONTRACT_FIDELITY_AUDIT = [
 ].join("\n");
 
 export const REVIEWER_INTERCOM_COORDINATION_PROTOCOL = [
-  "Concurrent reviewer coordination:",
+  "Concurrent reviewer coordination (constructive quorum):",
   "- At review start, use Intercom to discover sibling reviewers and share validation plans and check ownership.",
   "- Claim, serialize, announce, and release expensive or conflicting shared-checkout/environment work such as suites, builds, package operations, browser/E2E sessions, migrations, and generated-artifact steps; share reusable command evidence.",
-  "- Coordination is operational only: inspect independently and return your own verdict rather than copying or deferring to sibling conclusions.",
+  "- First, inspect independently and form a preliminary assessment before reading or relying on sibling findings or verdicts. After the exchange, inspect independently and return your own verdict rather than copying or deferring to sibling conclusions.",
+  "- Then run exactly one bounded evidence-exchange round over Intercom: share your preliminary verdict, concise findings, and evidence; challenge blocking findings, surface defects a sibling missed, and correct objective/acceptance-criteria misreadings. Do not start a second round or continue substantive discussion.",
+  "- Verdicts change only through concrete evidence, never through deference to a sibling's approval or rejection; inspect shared evidence yourself before deciding.",
+  "- In `overall_explanation`, record whether deliberation changed your preliminary verdict and, if it did, which concrete evidence caused the change. If it did not, say so; return your own structured decision even when dissent remains.",
 ].join("\n");
 
 export const REVIEWER_INDEPENDENT_VERIFICATION_CONTRACT = [

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.13-alpha.1",
+  "version": "0.9.13-alpha.2",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [
@@ -83,7 +83,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.83.0"
+    "@earendil-works/pi-tui": "^0.84.1"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/workflows/src/durable/backend.ts

@@ -231,7 +231,7 @@ export class InMemoryDurableBackend implements DurableWorkflowBackend {
 			...(handle.rootWorkflowId !== undefined ? { rootWorkflowId: handle.rootWorkflowId } : {}),
 			...(handle.resumable !== undefined ? { resumable: handle.resumable } : {}),
 			...workflowFailureFields(
-				handle.error !== undefined ? handle : handle.status === "running" ? undefined : existing?.handle,
+				hasWorkflowFailureMetadata(handle) ? handle : handle.status === "running" ? undefined : existing?.handle,
 			),
 			...(handle.ownerExecutorId !== undefined
 				? { ownerExecutorId: handle.ownerExecutorId }
@@ -371,6 +371,8 @@ export class InMemoryDurableBackend implements DurableWorkflowBackend {
 		rec.handle = {
 			...rec.handle,
 			error: undefined,
+			exited: undefined,
+			exitReason: undefined,
 			failureKind: undefined,
 			failureCode: undefined,
 			failureRecoverability: undefined,
@@ -527,12 +529,27 @@ function isHistoricalHandle(handle: DurableWorkflowHandle): boolean {
 	);
 }
 
+function hasWorkflowFailureMetadata(handle: Partial<DurableWorkflowHandle>): boolean {
+	return (
+		handle.error !== undefined ||
+		handle.exited !== undefined ||
+		handle.exitReason !== undefined ||
+		handle.failureKind !== undefined ||
+		handle.failureCode !== undefined ||
+		handle.failureRecoverability !== undefined ||
+		handle.failureDisposition !== undefined ||
+		handle.failedToolNodeId !== undefined
+	);
+}
+
 function workflowFailureFields(
 	handle: Partial<DurableWorkflowHandle> | undefined,
 ): Partial<DurableWorkflowFailureMetadata> {
 	if (handle === undefined) return {};
 	return {
 		...(handle.error !== undefined ? { error: handle.error } : {}),
+		...(handle.exited !== undefined ? { exited: handle.exited } : {}),
+		...(handle.exitReason !== undefined ? { exitReason: handle.exitReason } : {}),
 		...(handle.failureKind !== undefined ? { failureKind: handle.failureKind } : {}),
 		...(handle.failureCode !== undefined ? { failureCode: handle.failureCode } : {}),
 		...(handle.failureRecoverability !== undefined ? { failureRecoverability: handle.failureRecoverability } : {}),

package/dist/builtin/workflows/src/durable/completed-catalog-stage-groups.ts

@@ -119,15 +119,27 @@ export function validateRunGroups(
 	grouped: Map<string, StageDraft[]>,
 	rootRunId: string,
 	tools: readonly DurableToolCheckpoint[],
+	checkpoints: readonly DurableCheckpoint[],
 ): boolean {
 	const toolsFor = (runId: string) =>
 		tools.filter((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId);
 	const owners = new Map<string, StageDraft>();
+	const syntheticChildIds = new Set<string>();
 	for (const [parentRunId, drafts] of grouped) {
 		for (const draft of drafts) {
 			const childRunId = childRunIdFromDraft(draft);
 			if (childRunId === undefined) continue;
-			if (!grouped.has(childRunId) || childRunId === parentRunId || owners.has(childRunId)) return false;
+			if (childRunId === parentRunId || owners.has(childRunId)) return false;
+			if (!grouped.has(childRunId)) {
+				if (
+					!isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) ||
+					childScopedEvidenceExists(checkpoints, draft.replayKey, childRunId)
+				)
+					return false;
+				syntheticChildIds.add(childRunId);
+				owners.set(childRunId, draft);
+				continue;
+			}
 			const childRun = runTopologyFor(grouped.get(childRunId)!, toolsFor(childRunId));
 			if (
 				childRun?.parentRunId !== parentRunId ||
@@ -146,6 +158,7 @@ export function validateRunGroups(
 			return false;
 	}
 	for (const runId of owners.keys()) {
+		if (syntheticChildIds.has(runId)) continue;
 		const seen = new Set<string>();
 		let current: string | undefined = runId;
 		while (current !== undefined && current !== rootRunId) {
@@ -158,6 +171,48 @@ export function validateRunGroups(
 	return true;
 }
 
+export function isSyntheticExitedChild(
+	draft: StageDraft,
+	parentRunId: string,
+	childRunId: string,
+	rootRunId: string,
+): boolean {
+	const child = workflowChildFromDraft(draft);
+	const boundary = draft.topology?.boundary;
+	return (
+		child?.runId === childRunId &&
+		child.exited === true &&
+		boundary?.event === "terminal" &&
+		boundary.status === "completed" &&
+		boundary.child.runId === childRunId &&
+		boundary.child.parentRunId === parentRunId &&
+		boundary.child.parentStageId === draft.topology?.stageId &&
+		boundary.child.rootRunId === rootRunId
+	);
+}
+
+/** Raw scoped records disprove a zero-stage child reconstruction. */
+export function childScopedEvidenceExists(
+	checkpoints: readonly DurableCheckpoint[],
+	boundaryReplayKey: string,
+	childRunId: string,
+): boolean {
+	const prefix = `${boundaryReplayKey}:`;
+	return checkpoints.some((checkpoint) => {
+		const lookupIdentity =
+			checkpoint.kind === "tool"
+				? checkpoint.argsHash
+				: checkpoint.kind === "ui"
+					? checkpoint.promptHash
+					: checkpoint.replayKey;
+		return (
+			checkpoint.checkpointId.startsWith(prefix) ||
+			lookupIdentity.startsWith(prefix) ||
+			(checkpoint.kind !== "ui" && checkpoint.topology?.run?.runId === childRunId)
+		);
+	});
+}
+
 export function retainReachableRunGroups(grouped: Map<string, StageDraft[]>, rootRunId: string): void {
 	const reachable = new Set([rootRunId]);
 	const pending = [rootRunId];
@@ -267,14 +322,16 @@ function valueOrExisting<
 
 export function workflowChildFromDraft(draft: StageDraft): StageSnapshot["workflowChild"] | undefined {
 	const strict = parseWorkflowChildResult(draft.output);
-	const child = strict ?? (hasCurrentStageIdentity(draft) ? undefined : parseLegacyWorkflowChildResult(draft.output));
+	const legacy = hasCurrentStageIdentity(draft) ? undefined : parseLegacyWorkflowChildResult(draft.output);
+	const child = strict ?? legacy;
 	if (child === undefined) return undefined;
+	const exited = strict?.exited ?? false;
 	return {
 		alias: child.workflow,
 		workflow: child.workflow,
 		runId: child.runId,
 		status: child.status,
-		...(child.exited !== undefined ? { exited: child.exited } : {}),
+		exited,
 		outputs: child.outputs,
 		...(typeof child.exitReason === "string" ? { exitReason: child.exitReason } : {}),
 	};

package/dist/builtin/workflows/src/durable/completed-catalog.ts

@@ -7,7 +7,9 @@ import {
 	boundaryOwner,
 	childRunIdFromDraft,
 	childRunStatus,
+	childScopedEvidenceExists,
 	compareDraftSourceOrder,
+	isSyntheticExitedChild,
 	mergeStageDraft,
 	mergeStageGroup,
 	retainReachableRunGroups,
@@ -107,6 +109,8 @@ export function completedWorkflowRunSnapshots(
 		endedAt: handle.updatedAt,
 		durationMs: rootDuration,
 		...(handle.error !== undefined ? { error: handle.error } : {}),
+		...(handle.exited !== undefined ? { exited: handle.exited } : {}),
+		...(handle.exitReason !== undefined ? { exitReason: handle.exitReason } : {}),
 		...(handle.failureKind !== undefined ? { failureKind: handle.failureKind } : {}),
 		...(handle.failureCode !== undefined ? { failureCode: handle.failureCode } : {}),
 		...(handle.failureRecoverability !== undefined ? { failureRecoverability: handle.failureRecoverability } : {}),
@@ -284,7 +288,26 @@ function runSnapshotsFromCheckpoints(
 	}
 	for (const group of grouped.values()) group.sort(compareDraftSourceOrder);
 	retainReachableRunGroups(grouped, rootRunId);
-	if (!validateRunGroups(grouped, rootRunId, toolCheckpoints)) return [];
+	if (!validateRunGroups(grouped, rootRunId, toolCheckpoints, checkpoints)) return [];
+	const syntheticChildren: Array<{
+		readonly parentRunId: string;
+		readonly owner: StageDraft;
+		readonly child: NonNullable<StageSnapshot["workflowChild"]>;
+	}> = [];
+	for (const [parentRunId, runDrafts] of grouped) {
+		for (const draft of runDrafts) {
+			const child = workflowChildFromDraft(draft);
+			if (child?.exited !== true || grouped.has(child.runId)) continue;
+			if (
+				!isSyntheticExitedChild(draft, parentRunId, child.runId, rootRunId) ||
+				childScopedEvidenceExists(checkpoints, draft.replayKey, child.runId)
+			) {
+				if (strict) return [];
+				continue;
+			}
+			syntheticChildren.push({ parentRunId, owner: draft, child });
+		}
+	}
 
 	const idMaps = new Map<string, Map<string, string>>();
 	for (const [runId, runDrafts] of grouped) {
@@ -321,6 +344,7 @@ function runSnapshotsFromCheckpoints(
 	}
 
 	const runs: RunSnapshot[] = [];
+	const emittedRunIds = new Set<string>();
 	for (const [runId, runDrafts] of grouped) {
 		const ids = idMaps.get(runId)!;
 		const ownedTools = toolCheckpoints.filter(
@@ -361,6 +385,7 @@ function runSnapshotsFromCheckpoints(
 		const parentStageId =
 			declaredParentStageId ??
 			(boundarySourceId === undefined ? undefined : idMaps.get(parentRunId)?.get(boundarySourceId));
+		const ownerChild = owner === undefined ? undefined : workflowChildFromDraft(owner);
 		runs.push({
 			id: runId,
 			name: run?.runName ?? rootRunName,
@@ -374,6 +399,47 @@ function runSnapshotsFromCheckpoints(
 			...(run?.parentRunId !== undefined ? { parentRunId: run.parentRunId } : {}),
 			...(parentStageId !== undefined ? { parentStageId } : {}),
 			...(run?.rootRunId !== undefined ? { rootRunId: run.rootRunId } : {}),
+			...(ownerChild?.exited === true
+				? {
+						result: ownerChild.outputs,
+						exited: true,
+						...(ownerChild.exitReason !== undefined ? { exitReason: ownerChild.exitReason } : {}),
+					}
+				: {}),
+			resumable: false,
+		});
+		emittedRunIds.add(runId);
+	}
+	for (const { parentRunId, owner, child } of syntheticChildren) {
+		if (!emittedRunIds.has(parentRunId)) {
+			if (strict) return [];
+			continue;
+		}
+		const topology = owner.topology!;
+		const boundary = topology.boundary!;
+		const parentStageId = idMaps.get(parentRunId)?.get(topology.stageId);
+		if (parentStageId === undefined) {
+			if (strict) return [];
+			continue;
+		}
+		const startedAt = owner.startedAt ?? owner.firstCompletedAt;
+		const endedAt = owner.endedAt ?? owner.firstCompletedAt;
+		runs.push({
+			id: child.runId,
+			name: boundary.child.runName,
+			inputs: {},
+			status: child.status,
+			stages: [],
+			toolNodes: [],
+			startedAt,
+			endedAt,
+			durationMs: Math.max(0, endedAt - startedAt),
+			parentRunId,
+			parentStageId,
+			rootRunId: boundary.child.rootRunId,
+			result: child.outputs,
+			exited: true,
+			...(child.exitReason !== undefined ? { exitReason: child.exitReason } : {}),
 			resumable: false,
 		});
 	}

package/dist/builtin/workflows/src/durable/completed-subtree.ts

@@ -1,6 +1,7 @@
 import type { RunSnapshot } from "../shared/store-types.js";
 import type { DurableWorkflowBackend } from "./backend.js";
 import { durableNestedRunSnapshots } from "./completed-catalog.js";
+import { parseWorkflowChildResult } from "./workflow-child-result.js";
 
 /** Return one cached boundary's exact subtree only when every selected node is fully terminal. */
 export function durableCompletedNestedRunSubtree(
@@ -10,6 +11,12 @@ export function durableCompletedNestedRunSubtree(
 ): readonly RunSnapshot[] | undefined {
 	const nested = durableNestedRunSnapshots(backend, rootWorkflowId);
 	if (!nested.some((run) => run.id === childRunId)) return undefined;
+	const intentionalExitStatuses = new Map<string, RunSnapshot["status"]>();
+	for (const checkpoint of backend.listCheckpoints(rootWorkflowId)) {
+		if (checkpoint.kind !== "stage") continue;
+		const child = parseWorkflowChildResult(checkpoint.output);
+		if (child?.exited === true) intentionalExitStatuses.set(child.runId, child.status);
+	}
 	const included = new Set([childRunId]);
 	let priorSize = -1;
 	while (priorSize !== included.size) {
@@ -20,16 +27,24 @@ export function durableCompletedNestedRunSubtree(
 	}
 	const subtree = nested.filter((run) => included.has(run.id));
 	const complete =
-		subtree.length === included.size &&
-		subtree.every(
-			(run) =>
-				run.status === "completed" &&
-				run.endedAt !== undefined &&
-				run.stages.every((stage) => isTerminalStage(stage.status) && stage.endedAt !== undefined),
-		);
+		subtree.length === included.size && subtree.every((run) => isCompleteCachedRun(run, intentionalExitStatuses));
 	return complete ? subtree : undefined;
 }
 
+function isCompleteCachedRun(
+	run: RunSnapshot,
+	intentionalExitStatuses: ReadonlyMap<string, RunSnapshot["status"]>,
+): boolean {
+	if (
+		run.endedAt === undefined ||
+		!run.stages.every((stage) => isTerminalStage(stage.status) && stage.endedAt !== undefined)
+	) {
+		return false;
+	}
+	if (run.status === "completed" || run.exited === true) return true;
+	return intentionalExitStatuses.get(run.id) === run.status;
+}
+
 function isTerminalStage(status: RunSnapshot["stages"][number]["status"]): boolean {
 	return status === "completed" || status === "failed" || status === "skipped";
 }

package/dist/builtin/workflows/src/durable/dbos-metadata.ts

@@ -59,6 +59,8 @@ export function encodeMetadata(metadata: DurableWorkflowMetadata): WorkflowSeria
 			...(metadata.label !== undefined ? { label: metadata.label } : {}),
 			...(metadata.rootWorkflowId !== undefined ? { rootWorkflowId: metadata.rootWorkflowId } : {}),
 			...(metadata.resumable !== undefined ? { resumable: metadata.resumable } : {}),
+			...(metadata.exited !== undefined ? { exited: metadata.exited } : {}),
+			...(metadata.exitReason !== undefined ? { exitReason: metadata.exitReason } : {}),
 			...(metadata.error !== undefined ? { error: metadata.error } : {}),
 			...(metadata.failureKind !== undefined ? { failureKind: metadata.failureKind } : {}),
 			...(metadata.failureCode !== undefined ? { failureCode: metadata.failureCode } : {}),
@@ -156,6 +158,8 @@ function parseDurableWorkflowMetadata(
 		(metadata.label !== undefined && typeof metadata.label !== "string") ||
 		(metadata.rootWorkflowId !== undefined && typeof metadata.rootWorkflowId !== "string") ||
 		(metadata.resumable !== undefined && typeof metadata.resumable !== "boolean") ||
+		(metadata.exited !== undefined && typeof metadata.exited !== "boolean") ||
+		(metadata.exitReason !== undefined && typeof metadata.exitReason !== "string") ||
 		(metadata.error !== undefined && typeof metadata.error !== "string") ||
 		(metadata.failureKind !== undefined && !isWorkflowFailureKind(metadata.failureKind)) ||
 		(metadata.failureCode !== undefined && !isWorkflowFailureCode(metadata.failureCode)) ||

package/dist/builtin/workflows/src/durable/local-command.ts

@@ -2,6 +2,7 @@
 
 import { spawn } from "node:child_process";
 import { connect } from "node:net";
+import { createChildProcessEnvironment } from "@bastani/atomic";
 
 export interface LocalCommandResult {
 	readonly exitCode: number;
@@ -27,7 +28,7 @@ export function runLocalCommand(
 		const child = spawn(command, [...args], {
 			stdio: ["ignore", "pipe", "pipe"],
 			windowsHide: true,
-			...(options?.env !== undefined ? { env: { ...process.env, ...options.env } } : {}),
+			env: createChildProcessEnvironment(options?.env ? { ...options.env } : undefined),
 			...(options?.uid !== undefined ? { uid: options.uid } : {}),
 			...(options?.gid !== undefined ? { gid: options.gid } : {}),
 		});