@bastani/atomic 0.9.13 → 0.9.14-alpha.2

package/dist/builtin/subagents/src/slash/prompt-template-bridge.ts

@@ -4,7 +4,7 @@ import {
 	readBridgeRequestSettlement,
 	registerBridgeRequestSettlement,
 	rejectStoppedBridgeRequest,
-} from "./bridge-settlement.ts";
+} from "./bridge-settlement.js";
 export const PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT = "prompt-template:subagent:request";
 export const PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT = "prompt-template:subagent:started";
 export const PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT = "prompt-template:subagent:response";

package/dist/builtin/subagents/src/slash/slash-bridge.ts

@@ -1,6 +1,6 @@
 import type { ExtensionContext } from "@bastani/atomic";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
+import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.js";
 import {
 	type Details,
 	SLASH_SUBAGENT_CANCEL_EVENT,
@@ -8,13 +8,13 @@ import {
 	SLASH_SUBAGENT_RESPONSE_EVENT,
 	SLASH_SUBAGENT_STARTED_EVENT,
 	SLASH_SUBAGENT_UPDATE_EVENT,
-} from "../shared/types.ts";
+} from "../shared/types.js";
 import {
 	type BridgeRequestSettlement,
 	emitBridgeEvent,
 	readBridgeRequestSettlement,
 	rejectStoppedBridgeRequest,
-} from "./bridge-settlement.ts";
+} from "./bridge-settlement.js";
 
 interface SlashSubagentRequest {
 	requestId: string;

package/dist/builtin/subagents/src/slash/slash-commands.ts

@@ -8,8 +8,8 @@ import {
 	keyHintIfBound,
 } from "@bastani/atomic";
 import { Key, matchesKey } from "@earendil-works/pi-tui";
-import { discoverAgents } from "../agents/agents.ts";
-import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
+import { discoverAgents } from "../agents/agents.js";
+import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.js";
 import {
 	type SingleResult,
 	SLASH_RESULT_TYPE,
@@ -19,10 +19,10 @@ import {
 	SLASH_SUBAGENT_STARTED_EVENT,
 	SLASH_SUBAGENT_UPDATE_EVENT,
 	type SubagentState,
-} from "../shared/types.ts";
-import { registerBridgeRequestSettlement } from "./bridge-settlement.ts";
-import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
-import { applySlashUpdate, buildSlashInitialResult, failSlashResult, finalizeSlashResult } from "./slash-live-state.ts";
+} from "../shared/types.js";
+import { registerBridgeRequestSettlement } from "./bridge-settlement.js";
+import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.js";
+import { applySlashUpdate, buildSlashInitialResult, failSlashResult, finalizeSlashResult } from "./slash-live-state.js";
 
 interface InlineConfig {
 	output?: string | false;

package/dist/builtin/subagents/src/slash/slash-live-state.ts

@@ -1,8 +1,8 @@
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { Message } from "@earendil-works/pi-ai/compat";
-import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
-import { type Details, type SingleResult, SLASH_RESULT_TYPE, type Usage } from "../shared/types.ts";
-import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
+import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.js";
+import { type Details, type SingleResult, SLASH_RESULT_TYPE, type Usage } from "../shared/types.js";
+import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.js";
 
 export interface SlashMessageDetails {
 	requestId: string;

package/dist/builtin/subagents/src/tui/render-event-formatting.ts

@@ -1,5 +1,5 @@
-import { formatModelThinking } from "../shared/formatters.ts";
-import type { Theme } from "./render-layout.ts";
+import { formatModelThinking } from "../shared/formatters.js";
+import type { Theme } from "./render-layout.js";
 
 export function modelThinkingBadge(theme: Theme, model?: string, thinking?: string, fastMode?: boolean): string {
 	const label = formatModelThinking(model, thinking, fastMode);

package/dist/builtin/subagents/src/tui/render-layout.ts

@@ -1,6 +1,6 @@
 import type { ExtensionContext } from "@bastani/atomic";
 import { visibleWidth } from "@earendil-works/pi-tui";
-import type { AgentProgress } from "../shared/types.ts";
+import type { AgentProgress } from "../shared/types.js";
 
 export type Theme = ExtensionContext["ui"]["theme"];
 

package/dist/builtin/subagents/src/tui/render-progress.ts

@@ -1,5 +1,5 @@
-import { formatAgentRunningLabel } from "../shared/status-format.ts";
-import type { Details } from "../shared/types.ts";
+import { formatAgentRunningLabel } from "../shared/status-format.js";
+import type { Details } from "../shared/types.js";
 
 export function isDoneResult(result: Details["results"][number]): boolean {
 	const status = result.progress?.status;

package/dist/builtin/subagents/src/tui/render-result-compact.ts

@@ -1,11 +1,11 @@
 import { keyHintIfBound } from "@bastani/atomic";
 import { type Component, Container, Text } from "@earendil-works/pi-tui";
-import { shortenPath } from "../shared/formatters.ts";
-import type { AgentProgress, Details } from "../shared/types.ts";
-import { getSingleResultOutput } from "../shared/utils.ts";
-import { modelThinkingBadge } from "./render-event-formatting.ts";
-import { getTermWidth, pulseGlyph, type Theme, truncLine } from "./render-layout.ts";
-import { buildMultiProgressLabel, resultRowLabel } from "./render-progress.ts";
+import { shortenPath } from "../shared/formatters.js";
+import type { AgentProgress, Details } from "../shared/types.js";
+import { getSingleResultOutput } from "../shared/utils.js";
+import { modelThinkingBadge } from "./render-event-formatting.js";
+import { getTermWidth, pulseGlyph, type Theme, truncLine } from "./render-layout.js";
+import { buildMultiProgressLabel, resultRowLabel } from "./render-progress.js";
 import {
 	buildLiveStatusLine,
 	compactCurrentActivity,
@@ -18,7 +18,7 @@ import {
 	snapshotNowForProgress,
 	statJoin,
 	themeBold,
-} from "./render-status-progress.ts";
+} from "./render-status-progress.js";
 
 export function renderSingleCompact(
 	d: Details,

package/dist/builtin/subagents/src/tui/render-result.ts

@@ -1,19 +1,19 @@
 import { getMarkdownTheme, keyHintIfBound } from "@bastani/atomic";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { type Component, Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
-import { formatDuration, formatTokens, formatUsage, shortenPath } from "../shared/formatters.ts";
-import type { AgentProgress, Details } from "../shared/types.ts";
-import { getSingleResultOutput } from "../shared/utils.ts";
-import { modelThinkingBadge } from "./render-event-formatting.ts";
-import { getTermWidth, type Theme, truncLine } from "./render-layout.ts";
-import { buildMultiProgressLabel, resultRowLabel } from "./render-progress.ts";
+import { formatDuration, formatTokens, formatUsage, shortenPath } from "../shared/formatters.js";
+import type { AgentProgress, Details } from "../shared/types.js";
+import { getSingleResultOutput } from "../shared/utils.js";
+import { modelThinkingBadge } from "./render-event-formatting.js";
+import { getTermWidth, type Theme, truncLine } from "./render-layout.js";
+import { buildMultiProgressLabel, resultRowLabel } from "./render-progress.js";
 import {
 	advanceResultPulseFrame,
 	clearResultAnimationTimer,
 	type ResultAnimationContext,
-} from "./render-result-animation.ts";
-import { renderMultiCompact, renderSingleCompact } from "./render-result-compact.ts";
-import { subagentResultRenderKey } from "./render-stable-output.ts";
+} from "./render-result-animation.js";
+import { renderMultiCompact, renderSingleCompact } from "./render-result-compact.js";
+import { subagentResultRenderKey } from "./render-stable-output.js";
 import {
 	buildLiveStatusLine,
 	displayProgressDurationMs,
@@ -22,7 +22,7 @@ import {
 	getToolCallLines,
 	hasEmptyTextOutputWithoutOutputTarget,
 	snapshotNowForProgress,
-} from "./render-status-progress.ts";
+} from "./render-status-progress.js";
 
 export function renderLiveSubagentResult(
 	result: AgentToolResult<Details>,

package/dist/builtin/subagents/src/tui/render-stable-output.ts

@@ -1,5 +1,5 @@
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { AgentProgress, Details } from "../shared/types.ts";
+import type { AgentProgress, Details } from "../shared/types.js";
 
 export function progressRenderKey(progress: Partial<AgentProgress> | undefined): string {
 	if (!progress) return "";

package/dist/builtin/subagents/src/tui/render-status-progress.ts

@@ -1,8 +1,8 @@
-import { formatDuration, formatTokens, formatToolCall } from "../shared/formatters.ts";
-import { formatActivityLabel } from "../shared/status-format.ts";
-import type { AgentProgress, Details } from "../shared/types.ts";
-import { getDisplayItems } from "../shared/utils.ts";
-import { getTermWidth, pulseGlyph, type Theme } from "./render-layout.ts";
+import { formatDuration, formatTokens, formatToolCall } from "../shared/formatters.js";
+import { formatActivityLabel } from "../shared/status-format.js";
+import type { AgentProgress, Details } from "../shared/types.js";
+import { getDisplayItems } from "../shared/utils.js";
+import { getTermWidth, pulseGlyph, type Theme } from "./render-layout.js";
 
 export function extractOutputTarget(task: string): string | undefined {
 	const writeToMatch = task.match(/\[Write to:\s*([^\]\n]+)\]/i);

package/dist/builtin/subagents/src/tui/render.ts

@@ -12,12 +12,12 @@ export {
 	RUNNING_ANIMATION_MS,
 	RUNNING_FRAMES,
 	runningPulseGlyph,
-} from "./render-layout.ts";
-export { renderLiveSubagentResult, renderSubagentResult } from "./render-result.ts";
-export type { SubagentResultRenderState } from "./render-result-animation.ts";
+} from "./render-layout.js";
+export { renderLiveSubagentResult, renderSubagentResult } from "./render-result.js";
+export type { SubagentResultRenderState } from "./render-result-animation.js";
 export {
 	advanceResultPulseFrame,
 	clearLegacyResultAnimationTimer,
 	clearResultAnimationTimer,
 	stopResultAnimations,
-} from "./render-result-animation.ts";
+} from "./render-result-animation.js";

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

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.13",
+  "version": "0.9.14-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": [
@@ -31,7 +31,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.84.1"
+    "@earendil-works/pi-tui": "^0.84.2"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,63 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.14-alpha.2] - 2026-08-17
+
+### Breaking Changes
+
+- `open-claude-design` removes the `max_refinements` input, the `approved_for_export` and `refinements_completed` outputs, and the `<artifact_dir>/feedback/` feedback artifact. A run now performs one `generate-1`, an optional live review, and export; callers must stop supplying, reading, or expecting those fields and artifacts ([#2401](https://github.com/bastani-inc/atomic/issues/2401)).
+
+### Added
+
+- Added optional per-attempt `timeoutMs` deadlines to `ctx.tool`. Expiry aborts the attempt signal, records a timeout-specific diagnostic, participates in retries, and follows the existing throwing or typed `failureMode: "return"` behavior; each retry gets a fresh signal and deadline, while omitted timeouts preserve existing behavior ([#2424](https://github.com/bastani-inc/atomic/issues/2424)).
+- Stage control registries expose `has(runId)` so a pruned registration map is distinguishable from an empty one after `clearDetached()` ([#2462](https://github.com/bastani-inc/atomic/issues/2462)).
+- Refined `ctx.tool` graph inspection into one read-only agent-chat-style tool message block. Enter, click, or switcher selection opens it collapsed by default with the tool call and a compact bounded result/error preview; the configured `app.tools.expand` action (`ctrl+o` by default) toggles full bounded args, result/error, callback source, timing, and cached/replayed markers. The block preserves keyboard and mouse scrolling, narrow-terminal layout, status styling, Escape/return navigation, `attachable: false`, and no attach, steer, interrupt, resume, or editable transcript affordances. Hostile payloads now cross precise typed boundaries with one own-key discovery call and bounded descriptor/value work for both retention and display, explicit cycle/accessor/conversion placeholders, and collision-safe truncation markers; the runtime's own key-list materialization remains outside the module's control, while durable checkpoints still keep exact output and raw-args `argsHash` identity ([#2427](https://github.com/bastani-inc/atomic/issues/2427)).
+
+### Removed
+
+- Removed find-in-stage-chat. `Ctrl+Shift+F` in an attached workflow stage chat no longer opens a search box over that chat.
+
+### Changed
+
+- Redesigned the `ctx.tool` inspection surface as a shaded host-style operator card: a `$` call header, a tail preview taken from the fully bounded result/error body with an exact earlier-lines expand hint, `Took`/`Elapsed` timing, status-tinted tool backgrounds that cover every cell of the card, callback source only in the expanded view, and a graph statusline that advertises the configured expand key as `expand`/`collapse` alongside return-to-graph and scroll controls. Plain rendering remains ANSI-free at narrow widths, and capped payload wrapping now scans once without changing its visual output. The forensic ARGS/RESULT/SOURCE/TIMING/MARKERS field table is gone from the operator surface.
+- Synchronized the complete bundled `impeccable` skill tree from upstream `skill-v4.0.3` (`68b1129634a1cdd9a0ba50b27376c71b4b083ae8`) to `skill-v4.1.1` (`5a149f3fdb1b5793f10567233b1dcab98fc305fd`), adding persisted Live roots, framework-aware injection, prompt embedding, CSS acceptance checks, Svelte AST support, mount verification, UI-surface contracts, and the latest detector and design guidance. The sync removes obsolete `scripts/live/ui-core.mjs`, keeps the Cursor-only `scripts/hook-before-edit.mjs` omitted, and retains Atomic's package-path and security adaptations ([#2382](https://github.com/bastani-inc/atomic/issues/2382)).
+- Impeccable concept rolls now include platform, grain, register, and card-kind fields and use a bounded `impeccable.style` fallback when no local catalog exists. The OpenAI image fallback supports reference-image edits and generated images only when `OPENAI_API_KEY` is present, warns about account spend, and embeds each prompt in the image or a sidecar ([#2382](https://github.com/bastani-inc/atomic/issues/2382)).
+- Removed upstream Impeccable's outbound telemetry and update check from the bundled skill. Upstream 4.1.1 posts an anonymous attended-choice ping to `impeccable.style` unless `IMPECCABLE_NO_TELEMETRY` or `DO_NOT_TRACK` is set, and polls `/api/version` once a day to suggest `npx impeccable update`. Atomic ships neither: the ping is removed outright rather than defaulted off, and the update check is dropped because a vendored skill cannot self-update and its version ships with Atomic releases. The only request the concept roll can still make is the catalog `GET /api/roll`, which carries scope, mode, an eight-hex seed key, and a re-roll counter, and no project files, prompts, code, or conversation context ([#2382](https://github.com/bastani-inc/atomic/issues/2382)).
+- The `open-claude-design` run-level review gate and the session-start stage now state how a review ends — exit in the Impeccable overlay, closing the browser tab, or `exit live` — that the session waits indefinitely until then, and that ending it exports the design as it stands with no further round ([#2401](https://github.com/bastani-inc/atomic/issues/2401)).
+- The live review session is the final review boundary: the workflow-owned poll loop dispatches `generate`, `steer`, `manual_edit_apply`, and failed variant mounts to model stages, keeps successful mounts journal-only, ends on the helper's `exit` event, and exports the preview as it stands without a summary, second opinion, decision, or later review session ([#2401](https://github.com/bastani-inc/atomic/issues/2401), [#2382](https://github.com/bastani-inc/atomic/issues/2382)).
+- The run-level gate retains `Start live review` and `Skip remaining review rounds and export as-is`; the skip choice exports immediately without opening the session ([#2401](https://github.com/bastani-inc/atomic/issues/2401)).
+- Added model-visible workflow source-layout guidance: keep compact workflows in one entry file, and extract only cohesive prompt, schema/type, model-policy, deterministic-helper, or child-workflow concerns at meaningful boundaries while keeping graph control flow visible in the entry file ([#2451](https://github.com/bastani-inc/atomic/issues/2451)).
+- Migrated the built-in Goal, Ralph, and open-claude-design model chains from active GLM-5.2 entries to direct Z.AI `zai/glm-5.3:high` and `zai-coding-cn/glm-5.3:high` fallbacks. OpenRouter's unavailable GLM-5.3 model is intentionally omitted rather than shipped as a placeholder ([#2459](https://github.com/bastani-inc/atomic/issues/2459)).
+
+### Fixed
+
+- Hardened the synced Impeccable executables against shell-based browser launch, remote browser URLs, project-root and symlink escapes, unsafe persisted roots and injection journals, non-atomic generated writes, untrusted live instructions, read failures reported as clean, and unbounded or malformed live protocol values. The `open-claude-design` loop now handles 4.1.1 mount failures, preserves the full event payload, replies with the required event id and status, and fails on helper process errors ([#2382](https://github.com/bastani-inc/atomic/issues/2382)).
+- Operator-card wrapping no longer drops a `/` or punctuation that could not fit on a truncated row.
+- An unbound `app.tools.expand` no longer leaves a keyless `expand`/`collapse` label on the `ctx.tool` operator-card statusline. The card body already dropped the key from `... (N earlier lines)`; the statusline now matches.
+- Workflow run-scoped singletons now survive `/reload`'s module re-evaluation. The replacement extension instance re-binds its store, stage-control registry, cancellation registry, tool-control registry, job tracker, and stage UI broker to the host session-scoped state, so an in-flight run stays visible and controllable instead of vanishing behind empty replacements. Adopting a previously unseen host session creates a fresh instance instead of handing that session the previous session's live object, so controls invoked from the new session cannot cancel or mutate the prior run ([#2462](https://github.com/bastani-inc/atomic/issues/2462) by [@makgunay](https://github.com/makgunay)).
+- Process-preserving session boundaries (`/reload`, `/fork`, `/new`, `/resume`) no longer kill in-flight workflow runs or drop live executor stage handles; the run keeps executing. `/reload` reuses the host event bus, so the replacement session can still list a run, report its real state, and answer a stage awaiting input. `/new`, `/resume`, and `/fork` build a new event bus, so the successor session gets fresh registries and does not list the run. `startup` and unrecognised start reasons still clear, and a real `quit` still pauses, clears the registry, and shuts DBOS down exactly once ([#2462](https://github.com/bastani-inc/atomic/issues/2462), [#2247](https://github.com/bastani-inc/atomic/issues/2247) by [@makgunay](https://github.com/makgunay)).
+- DBOS lifecycle state and the registered `atomicWorkflowHandle` / `atomicWorkflowCheckpoint` wrappers now live in a process-global `globalThis` slot keyed with `Symbol.for`, so a re-evaluated workflows bundle reuses the original registrations instead of colliding with the still-live SDK registry and silently falling back to an in-memory backend. A later `configureDbosDurableBackend` call after `DBOS.launch` recovers those wrappers and does not call `setConfig` again. A real quit still flushes and shuts DBOS down exactly once ([#2462](https://github.com/bastani-inc/atomic/issues/2462), [#2022](https://github.com/bastani-inc/atomic/issues/2022) by [@makgunay](https://github.com/makgunay)).
+- A duplicate DBOS operation registration is no longer reported as a Postgres provisioning failure. The durability error and the non-durable fallback warning now name the registration conflict and no longer suggest changing `DBOS_SYSTEM_DATABASE_URL`. Classification uses the SDK `Error.DBOSConflictingRegistrationError` class and `dbosErrorCode`, not message wording. A wrapper whose `cause`, `name`, or `message` getter throws stays `other` and keeps the original failure in the diagnostic instead of replacing it with the inspection trap. Reading the failure detail for the wrapper itself also uses the guarded accessor, so a throwing `message` getter cannot escape as a raw exception ([#2462](https://github.com/bastani-inc/atomic/issues/2462), [#2022](https://github.com/bastani-inc/atomic/issues/2022) by [@makgunay](https://github.com/makgunay)).
+- Fixed `workflow send` answers for primitive human-in-the-loop prompts. Confirm answers now preserve booleans and accept the documented yes/no labels, select answers resolve case-insensitive labels or 1-based indexes instead of silently choosing the first option, and unusable answers remain pending with a helpful no-op response ([#2417](https://github.com/bastani-inc/atomic/pull/2417) by [@makgunay](https://github.com/makgunay)).
+- Separated schema-backed workflow result data from runner-owned output artifacts. When a stage configures both `schema` and `output`, the successful `structured_output` arguments now remain the typed machine-readable result while ordered ordinary text blocks from that exact tool-call message become the human-readable artifact. The runner snapshots both against the successful tool-call id so correction attempts and late admitted turns cannot replace either result; missing prose is written empty with an explicit warning instead of silently persisting JSON ([#2198](https://github.com/bastani-inc/atomic/issues/2198)).
+- Separated schema-backed workflow result data from runner-owned output artifacts. When a stage configures both `schema` and `output`, the successful `structured_output` arguments now remain the typed machine-readable result while ordered ordinary text blocks from that exact tool-call message become the human-readable artifact. The runner snapshots both against the successful tool-call id so correction attempts and later admitted turns cannot replace either result, and never serializes the tool arguments into the artifact. When the successful message carries no ordinary text — including after a model-fallback session recreation that leaves the live session without that message — the artifact falls back to the most recent earlier assistant text that made no `structured_output` call, and only when no such text exists is it written empty with an explicit warning. Corrective prompts for schema-and-output stages keep the validation-failure guidance, schema-only stages keep their existing result-text behavior, and the builtin `adversarial-verification`, `generate-and-filter`, `tournament`, and `loop-until-done` workflows now persist their structured decisions themselves so their `*.json` inter-stage artifacts remain machine-readable ([#2198](https://github.com/bastani-inc/atomic/issues/2198)).
+
+### Removed
+
+- Removed the live-review feedback module and all `<artifact_dir>/feedback/` artifacts, including the JSON record, `iteration-N.md` copy, and annotated-snapshot copies. No feedback directory is written during a run ([#2401](https://github.com/bastani-inc/atomic/issues/2401)).
+
+## [0.9.14-alpha.1] - 2026-08-14
+
+### Added
+
+- Added `heartbeatIntervalMinutes` to the workflow authoring surface: an optional cadence in minutes that resolves to the `15`-minute default when omitted, treats `0` as an explicit disable, and rejects negative and non-finite values with a `TypeError` while the definition is authored, so a bad cadence fails at authoring rather than at schedule time. Every compiled definition carries the resolved value, and a distinct `workflows:workflow-heartbeat` event contract is declared alongside it — run id, workflow name, start time, scheduled time, and interval, with heartbeat identity keyed by run id plus scheduled time. The default interval constant, heartbeat custom type, and heartbeat event types are exported from the `@bastani/workflows` package root ([#1975](https://github.com/bastani-inc/atomic/issues/1975)).
+- Added workflow heartbeat scheduling and queued parent delivery for `heartbeatIntervalMinutes`, so a positive cadence now produces real heartbeats. While a top-level run is active, one heartbeat is raised per `startedAt + n × interval` boundary computed from the run's persisted start time — never from the previous delivery — so a slow send, a retry, or a process restart cannot shift the cadence. A resolved interval of `0` creates no timer and no durable record at all. One globally-next-due wake-up serves every enabled run rather than one recurring timer per run. At most one heartbeat per run is outstanding at a time: an outstanding heartbeat holds its slot until its card is actually consumed into the conversation — not merely until the parent's turn ends, which can happen while the card is still queued or its queue is paused — so a boundary that falls before that is skipped rather than stacked behind it, and the cadence then resumes at the first future boundary. However long a turn runs, and however often the queue is paused, only one unread heartbeat per run is ever waiting on a host that reports message consumption, which Atomic's chat host does. Delivery reuses the lifecycle-notice parent path (`triggerTurn`, `deliverAs: "steer"`, `persistWhenStreaming`) under the distinct `workflows:workflow-heartbeat` custom type with the five-field payload, so a busy parent chat is queued and never interrupted. Paused runs emit nothing and receive no backfill; a resumed or restarted run takes the first future boundary. Simultaneously due heartbeats reach the parent in scheduled-time order with the run id as the stable tie-break — a heartbeat being retried holds its place rather than letting a later one overtake it — terminal state is re-checked immediately before enqueue, again immediately before processing, and again before every delivery attempt including retries, and nested child workflow runs never heartbeat the parent chat. A run keeps the cadence its own definition was authored with, so editing, renaming, deleting, or reloading a workflow mid-run changes what the next launch uses and leaves runs already in flight on their launch cadence; the anchor record carries that cadence too, so it survives a durable resume. A run that launched with heartbeats disabled writes no durable record at all, so if it is resumed in a new process it adopts whatever the workflow then declares. A cadence below a millisecond schedules at the finest representable instant, and the cadence range carries a documented representable upper limit: above roughly 3 × 10^303 minutes `startedAt + interval` exceeds the largest finite timestamp, so no first boundary exists, nothing is scheduled, no durable record is written, and `ATOMIC_WORKFLOW_DEBUG=1` says so — such a cadence stays a valid positive interval but delivers no heartbeat, and `0` remains the only value that declares heartbeats off. A durable resume re-dispatches under the original run id but records a fresh start time, so each run also writes one reserved durable cadence-anchor record as soon as it has durable progress of its own, before its first boundary comes due; the anchor is read only as the earlier of itself and the run's current start time, so it keeps a resumed run on its original cadence without being able to move a boundary or raise a missed one. The delivered card names the workflow, run id, cadence, and elapsed run time and hints `/workflow status <run-id>`, rendered through the existing workflow notice-card renderer ([#1975](https://github.com/bastani-inc/atomic/issues/1975)).
+- Added terminal heartbeat cleanup and restart recovery, so a workflow's heartbeats stop when the run does. Reaching any terminal status — completed, failed, blocked, skipped, cancelled, or killed — drops everything that run's cadence held in one pass: its armed wake-up, its next scheduled boundary, its outstanding slot and the card text held for it, any heartbeat of its own still waiting in the delivery queue along with the retry timer that belonged to it, and its cadence and durable-anchor memos. No pending timer and no queued heartbeat outlives the run that owns it. The pass is idempotent: repeating it creates no state, resurrects no schedule, and does not throw, including for a run the scheduler never saw. Both completion races converge on suppression — a run that finishes before its due boundary is enqueued has that boundary dropped and is refused at enqueue, and one that finishes after enqueue but before processing has its queued identity discarded rather than sent. Cleanup keys on the run's observed state rather than on a transition event, so it also covers the paths that reach a terminal snapshot without a normal end transition — durable replay, completed-catalog reconstruction, and a restore that inserts an already-failed run — and the same pass runs at startup, making it the recovery pass: a stale durable anchor or leftover queued record belonging to an already-terminal run is discarded rather than replayed, its anchor is neither read nor rewritten, and a run the store no longer holds is dropped the same way. An active run is never affected by another run's cleanup, a paused run keeps the floor that stops it re-raising a boundary it already delivered, and recovery for an active run still selects the first future boundary rather than replaying a missed one. A late durable acknowledgement or a send that settles after cleanup re-creates nothing. A heartbeat the chat host had already accepted into the parent's queue is past that pass, because no queued message can be withdrawn, so it is invalidated at the moment the parent reads it instead: a heartbeat whose run has since reached a terminal state, or whose run this process no longer knows at all, is excluded from the model's context and never steers the parent about a run that is over. That closes both remaining stale paths — a card parked through a long turn while its run finished, and a card recovered from a previous process at startup, which would otherwise replay a boundary raised before the restart. The card already rendered in the transcript is deliberately left in place as a true record that the heartbeat was raised; only the model-facing steer is invalidated ([#1975](https://github.com/bastani-inc/atomic/issues/1975)).
+  A run that is only blocked on a recoverable provider or rate-limit failure remains stored as `running` and resumable: it raises no new heartbeat while blocked, but keeps its cadence state and any card already waiting with the parent. Cleanup runs only when the run's own status is terminal.
+  Parent pickup is keyed by the typed `workflows:workflow-heartbeat` entry and exact run id plus scheduled time rather than rendered card text, so a foreign custom message cannot release an unread heartbeat's slot and a durable resume that reuses the run id cannot revive an old admitted card after terminal cleanup ([#1975](https://github.com/bastani-inc/atomic/issues/1975)).
+  The cadence-anchor record is now written at the durability boundary itself, so it is durable before the checkpoint that made the run resumable is acknowledged. The scheduler's own write is guarded against runs with no durable progress and can therefore only be issued after resumability already exists; a process that exited inside that window left a resumable run carrying no record of what it launched with, and the next process then took both a freshly minted start time and whatever cadence the definition declared by then, shifting the phase and the cadence of a run already in flight ([#1975](https://github.com/bastani-inc/atomic/issues/1975)).
+- Every bundled builtin workflow now states its heartbeat cadence rather than inheriting it. `adversarial-verification`, `classify-and-act`, `fan-out-and-synthesize`, `generate-and-filter`, `goal`, `loop-until-done`, `ralph`, and `tournament` declare the `15`-minute default explicitly, so these long autonomous runs report to the parent chat on a known cadence and a future change to the global default cannot silently re-cadence them. `open-claude-design` sets `0` and runs quiet: it is driven by the user reviewing generated HTML turn by turn, so the parent chat is already holding it to its goal and a periodic alignment steer would interrupt that review rather than inform it. Behaviour is unchanged for the eight that were already resolving to the default; only `open-claude-design` changes ([#1975](https://github.com/bastani-inc/atomic/issues/1975)).
+
 ## [0.9.13] - 2026-08-13
 
 Cumulative release of the `0.9.13-alpha.1` – `0.9.13-alpha.4` prereleases. The summary below covers the user-visible outcome of that work; the per-change detail remains in the prerelease sections below.

package/dist/builtin/workflows/README.md

@@ -82,6 +82,23 @@ Sketch branches, loops, and nested boundaries before launch. Bounded loops must
 
 Execution, replay, and DBOS hydration are the authoritative topology-validation points. Runtime topology changes should add incremental edge checks and DBOS hydration validation; prompt guidance and TypeScript types cannot replace these checks.
 
+### Workflow source layout
+
+Keep a small, readable workflow in one entry file. Do not split short one-use prompts, create one file per stage, add wrapper-only modules, hide the graph across files, or use line counts alone as a module boundary.
+
+At a meaningful source boundary that improves clarity, reuse, ownership, or testability, keep the graph and control flow in the top-level workflow entry file and extract cohesive concerns: long or reused prompt builders; shared TypeBox schemas and workflow-specific types; model-policy constants shared by several stages; deterministic helpers with their own testable behavior; or reusable child workflow definitions.
+
+Put support modules in a subdirectory below the top-level discovery directory — either one owned by a single workflow or a shared support directory for several workflows. Project and user discovery scans only top-level `.ts`/`.js`/`.mjs`/`.cjs` files in the workflow directory; the scan is non-recursive, so support modules in subdirectories are not scanned as extra top-level workflow candidates. Use `.js` import extensions from TypeScript source.
+
+The existing `.atomic/workflows/release-docs.ts` keeps its graph in the entry file and imports deterministic helpers from `.atomic/workflows/lib/release-docs.ts`, a shared support directory that also holds the separate `publish-release` helper. For example:
+
+```text
+.atomic/workflows/code-review.ts
+.atomic/workflows/code-review/prompts.ts
+.atomic/workflows/code-review/schemas.ts
+.atomic/workflows/code-review/model-policy.ts
+```
+
 ### Workflow-owned side effects
 
 Prefer `ctx.tool(name, args, fn)` for workflow-owned TypeScript operations with side effects, including filesystem writes, network mutations, external API actions, and similar deterministic operations orchestrated directly by the workflow definition. Each invocation creates a non-chat, non-attachable durable graph node before `fn` runs; it may appear before, between, after, or without model stages. Atomic durably caches a completed call's serializable result, so resume returns that result without rerunning `fn` or repeating the side effect. Tool-only workflows are valid tracked execution, while a normal return with no stage, child, tool, or explicit exit remains invalid. Keep pure computation and side-effect-free transformations as ordinary TypeScript. Do not wrap agent-stage internals or every function call indiscriminately. The executor closes tool admission before publishing any terminal outcome; calling a retained `ctx.tool` function afterward returns a rejected native promise and creates no callback, retry, graph node, or checkpoint.
@@ -422,6 +439,8 @@ const decision = await ctx.stage("review-gate", { schema: Decision }).prompt(
 
 Atomic registers the canonical `structured_output` tool only for schema-enabled items and automatically adds it to explicit `tools` allowlists. The schema is used directly as the tool argument contract. A schema-backed `StageContext` supports one `prompt()` call because the final-answer tool is a single result contract; create another `ctx.stage(..., { schema })` for another structured prompt. If a turn completes without calling `structured_output`, or the tool call fails schema validation, Atomic sends up to three corrective follow-up prompts that include the exact contract/validation error before failing the item. `ctx.task`/`ctx.chain`/`ctx.parallel` results expose the captured value as `result.structured` and keep `result.text` as formatted JSON for handoffs.
 
+When an item configures both `schema` and `output`, its successful `structured_output` turn has two separate channels: all ordinary assistant text blocks from that exact message, in order, form the human-readable artifact written to `output`, while the successful tool arguments remain the typed machine-readable workflow result. Atomic never serializes those arguments into the artifact. The runner snapshots the result together with the exact successful tool-call id, so corrective attempts, another call with the same tool name, and later admitted turns cannot replace either side of the pairing. When the successful message has no ordinary text — including after a model-fallback session recreation that leaves the live session without that message — Atomic falls back to the most recent earlier assistant text that made no `structured_output` call; only when no such text exists is the artifact written empty, with the standard empty-artifact warning in the receipt. Items with `schema` but no `output` keep their existing result-text behavior.
+
 `subagent` is available as a default workflow-stage tool with the same five-level nesting budget as main chat: a stage can launch recursively delegated subagents until the shared depth guard reaches five delegated levels, then deeper calls are blocked. `tools` allowlists apply to bundled extension tools as well as built-ins; if a stage sets `tools`, list every tool it should see. Workflow stages can explicitly list `subagent`, `web_search`, `fetch_content`, `intercom`, and other loaded extension tools, while `excludedTools` and `noTools: "all"` still win. Bundled `@bastani/subagents` agent definitions are available to the `subagent` tool in workflow stages, including workflows launched from a subagent child process.
 
 ### Model fallbacks
@@ -635,7 +654,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. 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.
+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, click a visible graph node, or choose one from the switcher to open a `ctx.tool` node's one read-only agent-chat-style tool message block, never a modal dialog or editable transcript. Tool nodes remain non-attachable: their graph card body is always the constant `durable tool`, and the message block is collapsed by default with the tool name/call and a compact bounded result or error preview. The configured `app.tools.expand` action (`ctrl+o` by default) toggles full bounded args, result or error, callback source, timing, and cached/replayed markers. `↑`/`↓`, `PageUp`/`PageDown`, `Home`/`End`, the wheel, and the scrollbar scroll the block; Escape or `ctrl+x` returns to the graph. It is read-only and offers no attach, steer, interrupt, or resume action. `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. `esc`, `ctrl+c`, and graph `h` close/hide behavior are 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.
 
@@ -658,7 +677,7 @@ Raw stage-chat prompt answer replay is live-memory only. `StageSnapshot.promptAn
 ```json
 {
   "name": "workflow",
-  "description": "Run named builtin, project, user, or package workflows; custom definitions may import reusable project/package workflows or builtin definitions from @bastani/workflows/builtin and nest them with ctx.workflow(...), including deeper composition within the configured maxDepth; when workflow execution fits but another shape would better achieve the task, author a custom TypeScript workflow({...}) inline with normal coding tools, reload it, and run it; after successfully creating and reloading a newly authored custom workflow, report the folder containing its generated code as 'Custom workflow created. You can inspect its code at: <workflow-folder-path>'; do this only for newly created custom workflows, never builtin or pre-existing workflows; discover with list/get/inputs/models, list session runs with status (no runId; statusFilter narrows the list), inspect status/stages/stage details, send prompt answers or steering only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. For large stage handoffs, write context to files/artifacts, pass paths via reads, and prompt downstream agents to 'Read the file at <path>...' instead of injecting large previous text. Wrap critical parts of run inputs and steering messages in <keepContext>...</keepContext> so compaction preserves them verbatim in the stages that inherit them; tag role constraints, prohibitions, must-hold criteria, and identifiers, not background or bulk reference material. For transcripts, prefer status/stages/stage to get sessionFile/transcriptPath, quote the exact path without rewriting separators (Windows backslashes are valid), then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview. Use action 'models' to inspect models in the configured catalog; the result is a configured-auth snapshot showing what's present in the registry with configured authentication, not proof of credentials, entitlements, OAuth freshness, or live provider access. When authoring a workflow that should dynamically select a model, first call workflow({ action: 'models' }) to inspect the configured catalog, then select from the returned provider/id entries considering the isCurrent marker and available thinking levels.",
+  "description": "Run named builtin, project, user, or package workflows; custom definitions may import reusable project/package workflows or builtin definitions from @bastani/workflows/builtin and nest them with ctx.workflow(...), including deeper composition within the configured maxDepth; when workflow execution fits but another shape would better achieve the task, author a custom TypeScript workflow({...}) inline with normal coding tools, reload it, and run it; after successfully creating and reloading a newly authored custom workflow, report the folder containing its generated code as 'Custom workflow created. You can inspect its code at: <workflow-folder-path>'; do this only for newly created custom workflows, never builtin or pre-existing workflows; discover with list/get/inputs/models, list session runs with status (no runId; statusFilter narrows the list), inspect status/stages/stage details, send prompt answers or steering only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. For primitive prompt answers, use booleans or the documented confirm labels, exact case-insensitive select labels or 1-based indexes, and text strings for input/editor; an invalid answer remains pending and returns guidance instead of choosing a default. For large stage handoffs, write context to files/artifacts, pass paths via reads, and prompt downstream agents to 'Read the file at <path>...' instead of injecting large previous text. Wrap critical parts of run inputs and steering messages in <keepContext>...</keepContext> so compaction preserves them verbatim in the stages that inherit them; tag role constraints, prohibitions, must-hold criteria, and identifiers, not background or bulk reference material. For transcripts, prefer status/stages/stage to get sessionFile/transcriptPath, quote the exact path without rewriting separators (Windows backslashes are valid), then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview. Use action 'models' to inspect models in the configured catalog; the result is a configured-auth snapshot showing what's present in the registry with configured authentication, not proof of credentials, entitlements, OAuth freshness, or live provider access. When authoring a workflow that should dynamically select a model, first call workflow({ action: 'models' }) to inspect the configured catalog, then select from the returned provider/id entries considering the isCurrent marker and available thinking levels.",
   "parameters": {
     "workflow": "string (optional) — workflow ID or normalized name",
     "inputs": "object (optional) — key/value map of workflow inputs",
@@ -702,6 +721,14 @@ Because human input is runtime-only and workflows no longer carry a declaration-
 
 For library or package authoring, define reusable workflows with `workflow({...})` and export the returned definition. Hand-written objects with `__piWorkflow: true` are rejected by discovery and composition; `workflow({...})` is the public authoring surface. Standalone TypeScript workflow packages import `workflow` from `@bastani/workflows` and `Type` from `typebox` directly with no local `.d.ts` file or `declare module` shim. Migration from the removed builder API is mechanical: move `.description(...)` to `description`, `.input(key, schema)` calls into `inputs`, `.output(key, schema)` calls into `outputs`, `.worktreeFromInputs(...)` to `worktreeFromInputs`, and the `.run(fn)` callback to `run: fn`; delete `.compile()`. The former imperative `runWorkflow` object-form API is removed; use workflow definitions with the exported `run()` / registry helpers for programmatic execution.
 
+Set `heartbeatIntervalMinutes` to declare the workflow's heartbeat cadence in minutes. Omitting it uses the `15`-minute default; `0` explicitly disables heartbeats. Negative and non-finite values are rejected when the workflow definition is authored. The scheduler consumes this validated setting directly: while a top-level run is active it raises one heartbeat per `startedAt + n × interval` boundary, computed from the run's persisted start time rather than the previous delivery, so retries and restarts cannot shift the cadence. The example below heartbeats every 30 minutes, so a run started at 09:00 raises boundaries at 09:30, 10:00, 10:30, and so on.
+
+Each heartbeat reaches the parent chat as a `workflows:workflow-heartbeat` card through the same queued-steer delivery lifecycle notices use (`triggerTurn`, `deliverAs: "steer"`, `persistWhenStreaming`), so a busy parent is never interrupted — the steer lands at its next protocol-safe boundary. At most one heartbeat per run is outstanding at a time: it holds its slot until its card is actually consumed into the conversation, not merely until the parent's turn ends, so a boundary that falls before that is skipped rather than stacked behind it and the cadence then resumes at the first future boundary. Parent pickup follows the typed heartbeat entry and releases the slot only for the exact `runId + scheduledAt` identity; another custom message cannot release it by copying the rendered text. Paused runs emit nothing and are never backfilled, a resumed or restarted run takes the first future boundary rather than bursting missed ones, simultaneous heartbeats process in `scheduledAt` order with the run id as the tie-break, and a run that reaches a terminal state is suppressed before every delivery attempt.
+
+When a run reaches any terminal status — completed, failed, blocked, skipped, cancelled, or killed — one idempotent cleanup pass drops its wake-up timer, its next boundary, its outstanding slot, any heartbeat of its own still queued inside the scheduler with the retry timer that belonged to it, and its cadence and durable-anchor memos. Repeating the pass creates nothing and resurrects nothing. Because it reads observed state rather than transition events, it is also the recovery pass: a later process discards a stale durable anchor or leftover queued record for an already-terminal run instead of replaying it, and never replays a missed boundary for an active one. A heartbeat the host already accepted into the parent's queue is past that pass, since nothing withdraws a queued message, so it is invalidated when the parent reads it instead: its exact `runId + scheduledAt` must still be pending for a current nonterminal run. A same-ID durable resume therefore cannot revive an old card, and a heartbeat whose run is terminal or absent from this process is excluded from the model's context. That covers a card parked through a long turn and a card recovered from a previous process alike. The rendered card stays in the transcript as a record of what was raised; only the model-facing steer is invalidated ([#1975](https://github.com/bastani-inc/atomic/issues/1975)).
+
+A recoverable provider or rate-limit block is not the terminal `blocked` status: the run remains stored as `running` and resumable. It raises no new heartbeat while blocked, but keeps its cadence state and any card already waiting with the parent; cleanup runs only once the run's own status becomes terminal.
+
 ```ts
 import { workflow } from "@bastani/workflows";
 import { Type } from "typebox";
@@ -709,6 +736,7 @@ import { Type } from "typebox";
 export default workflow({
   name: "audit-auth",
   description: "Audit the authentication module.",
+  heartbeatIntervalMinutes: 30,
   inputs: {
     prompt: Type.String({ default: "Investigate the auth module" }),
   },
@@ -811,23 +839,26 @@ For either workflow, keep PR/MR creation out of the task text and pass the origi
 
 ### `open-claude-design`
 
-Combined discovery/init → design-system/reference research → curated reference discovery with user preference check → separate forked generate and user-feedback chains → export/handoff pipeline. The `discovery` stage asks for output type and references, then runs impeccable init in the same stage so PRODUCT.md/DESIGN.md are detected, created, or reconciled. `ds-*` stages handle user-provided URL/file reference extraction directly, then `reference-discovery` uses that context and asks which curated direction you prefer (or asks for a reference image/path/URL if none fit). Export is only `exporter` plus `final-display`.
+Combined discovery/init → design-system/reference research → curated reference discovery with user preference check → one generation → one live review session → export/handoff pipeline. The `discovery` stage asks for output type and references, then runs impeccable init in the same stage so PRODUCT.md/DESIGN.md are detected, created, or reconciled. `ds-*` stages handle user-provided URL/file reference extraction directly, then `reference-discovery` uses that context and asks which curated direction you prefer (or asks for a reference image/path/URL if none fit). Export is only `exporter` plus `final-display`.
+
+The live session is unbounded: accepted variants and steered edits are written into `preview.html` in place as you go. A deterministic run-level gate offers `Start live review` or `Skip remaining review rounds and export as-is`; the latter exports without opening a session. The workflow-owned poll loop ends on the helper's `exit` event, and the exporter receives the preview exactly as it stands. There is no second opinion, decision stage, or later review session.
+
+The session starts at `user-feedback-N-start`; durable `live-poll-N-M` and `live-reply-N-M` tool nodes own polling and acknowledgements, while `live-generate-*`, `live-steer-*`, `live-manual_edit_apply-*`, and `live-variant_mount_failed-*` mint model stages. Replies pass the event id before the status. Successful `variant_mounted` events are journal-only; `accept`, `discard`, and `prefetch` mint no model stage, and `timeout` is absorbed in the poll node. Nonzero helper exits fail the run rather than looking like timeouts. No `<artifact_dir>/feedback/` directory or per-session record is written.
 
-Each refinement round pauses at a deterministic run-level prompt before its `user-feedback-*` stage starts (the stage's browser long-poll never sets `awaiting_input`, so the gate is where the wait surfaces). The prompt fires the needs-attention badge and names the preview path and `file://` URL; choose `Start live review` to open the browser session (the stage prints the live `http://` review URL first — see it with `/workflow connect`), or `Skip remaining review rounds and export as-is` to accept the current design. Headless runs skip the gate. A feedback stage that fails outright fails the run; only a completed review with no requested changes counts as approval.
+Impeccable 4.1.1 persists the selected app root for all Live helpers and supports SvelteKit, Nuxt, TanStack Start, Astro, Next.js, Vite, and static HTML injection. Configured files and generated adapter paths must remain project-relative, inside the real app root, and outside symlinked parents; the browser opener accepts only loopback HTTP(S) review URLs.
 
-Research context moves between stages as artifact files, not inline prompt payloads: the project design context is written to `<artifact_dir>/design-context.md` and the curated references brief to `<artifact_dir>/references.md`; `reference-discovery` reads the design context, and the generate and exporter stages read both files via `reads`. Only verbatim user annotations and the word-capped prior design summary travel inline.
+Research context moves between stages as artifact files, not inline prompt payloads: the project design context is written to `<artifact_dir>/design-context.md` and the curated references brief to `<artifact_dir>/references.md`; `reference-discovery`, `generate-1`, and `exporter` read the required files via `reads`.
 
 ```text
 /workflow open-claude-design prompt="Design a kanban board component"
 ```
 
 | Input                 | Type      | Required | Default | Description                                                                 |
-| --------------------- | --------- | -------- | ------- | --------------------------------------------------------------------------- |
+| --------------------- | --------- | -------- | ------- | ------------------------------------------------------------------------- |
 | `prompt`              | `text`    | ✓        | —       | Design brief or description.                                                |
 | `discover_references` | `boolean` | —        | `true`  | Discover current gallery references with browser tooling; set false to skip. |
-| `max_refinements`     | `number`  | —        | `3`     | Maximum generate/user-feedback loop iterations.                              |
 
-Child workflow outputs: `output_type`, `design_system`, `artifact`, `handoff`, `approved_for_export`, `refinements_completed`, `import_context`, `run_id`, `artifact_dir`, `preview_path`, `preview_file_url`, `spec_path`, `spec_file_url`, and `playwright_cli_status`. `open-claude-design` has no `result` output; it exposes only the declared fields listed here.
+Child workflow outputs: `output_type`, `design_system`, `artifact`, `handoff`, `import_context`, `run_id`, `artifact_dir`, `preview_path`, `preview_file_url`, `spec_path`, `spec_file_url`, and `playwright_cli_status`. `open-claude-design` has no `result` output; it exposes only the declared fields listed here.
 
 ---
 

package/dist/builtin/workflows/builtin/adversarial-verification-runner.ts

@@ -42,7 +42,11 @@ function isVerifier(value: WorkflowSerializableValue): value is VerifierDecision
 function isReducer(value: WorkflowSerializableValue): value is ReducerDecision {
   return isRecord(value) && (value.decision === "accept" || value.decision === "reject" || value.decision === "repair") && typeof value.rationale === "string" && Array.isArray(value.remaining_work) && value.remaining_work.every((item) => typeof item === "string");
 }
-
+const INVALID_VERIFIER_REPORT: VerifierDecision = {
+  verdict: "fail",
+  evidence: [],
+  blocking_findings: ["Verifier stage produced no valid structured report."],
+};
 export async function runAdversarialVerification(ctx: WorkflowRunContext<Inputs>): Promise<AdversarialVerificationResult> {
   const root = await stableArtifactRoot(ctx, "adversarial-verification");
   const rubricPath = join(root, "rubric.md");
@@ -56,15 +60,20 @@ export async function runAdversarialVerification(ctx: WorkflowRunContext<Inputs>
   let decision: ReducerDecision = { decision: "reject", rationale: "No valid reducer decision was produced.", remaining_work: ["Reducer did not return a valid structured decision."] };
   for (;;) {
     verifierArtifactPaths = Array.from({ length: ctx.inputs.verifier_count }, (_, index) => join(root, `verification-${repairsCompleted}-${index + 1}.json`));
-    const reports = await ctx.parallel(verifierArtifactPaths.map((path, index) => ({
+    const reports = await ctx.parallel(verifierArtifactPaths.map((_, index) => ({
       name: `verifier-${repairsCompleted}-${index + 1}`,
       prompt: renderVerifierPrompt(ctx.inputs.task, candidatePath, rubricPath),
       context: "fresh" as const,
       reads: [candidatePath, rubricPath],
       schema: verifierSchema,
-      output: path,
-      outputMode: "file-only" as const,
     })), { concurrency: Math.min(ctx.inputs.verifier_count, 4), failFast: false });
+    // Verifier reports are inter-stage data: the reducer reads schema-shaped
+    // JSON from these paths, so the runner persists the structured decisions
+    // itself rather than routing them through the stage artifact channel.
+    await Promise.all(verifierArtifactPaths.map(async (path, index) => {
+      const report = structured(reports[index]?.structured, isVerifier) ?? INVALID_VERIFIER_REPORT;
+      await writeFile(path, `${JSON.stringify(report, null, 2)}\n`);
+    }));
     const validReports = reports.map((report) => structured(report.structured, isVerifier)).filter((report): report is VerifierDecision => report !== undefined);
     const allVerifiersPassed = validReports.length === ctx.inputs.verifier_count && validReports.every((report) => report.verdict === "pass");
     await writeFile(join(root, `verification-summary-${repairsCompleted}.json`), JSON.stringify(validReports, null, 2));
@@ -72,9 +81,11 @@ export async function runAdversarialVerification(ctx: WorkflowRunContext<Inputs>
     const reduced = await ctx.task(`reducer-${repairsCompleted}`, {
       prompt: renderReducerPrompt(ctx.inputs.task, candidatePath, verifierArtifactPaths, repairsCompleted, ctx.inputs.max_repairs),
       context: "fresh", reads: [candidatePath, rubricPath, ...verifierArtifactPaths], schema: reducerSchema,
-      output: reviewReportPath, outputMode: "file-only",
     });
     decision = structured(reduced.structured, isReducer) ?? decision;
+    // Same inter-stage contract as the verifier reports above: the repair
+    // stage reads this path as the reducer's structured decision.
+    await writeFile(reviewReportPath, `${JSON.stringify(decision, null, 2)}\n`);
     if (decision.decision === "accept" && !allVerifiersPassed) {
       const remaining = validReports.flatMap((report) => report.blocking_findings);
       decision = repairsCompleted < ctx.inputs.max_repairs

package/dist/builtin/workflows/builtin/adversarial-verification.ts

@@ -6,6 +6,10 @@ import { runAdversarialVerification } from "./adversarial-verification-runner.js
 export default workflow({
   name: "adversarial-verification",
   description: "Produce a candidate, challenge it with fresh-context rubric-based verifiers, and reduce their evidence through a bounded repair loop.",
+  // The 15-minute default, stated rather than inherited: this is a per-workflow
+  // product decision, so a future change to the global default must not silently
+  // re-cadence a long autonomous run.
+  heartbeatIntervalMinutes: 15,
   inputs: {
     task: Type.String({ description: "Task whose candidate result must be independently verified." }),
     verifier_count: Type.Integer({ minimum: 1, maximum: 5, default: 3, description: "Number of independent verifiers per review round." }),

package/dist/builtin/workflows/builtin/classify-and-act.ts

@@ -8,6 +8,10 @@ export const DEFAULT_ACTION_CATEGORIES = ["analysis", "implementation", "researc
 export default workflow({
   name: "classify-and-act",
   description: "Classify a task with structured confidence, route deterministically to an isolated category action, and ask for human selection when confidence is low.",
+  // The 15-minute default, stated rather than inherited: this is a per-workflow
+  // product decision, so a future change to the global default must not silently
+  // re-cadence a long autonomous run.
+  heartbeatIntervalMinutes: 15,
   inputs: {
     prompt: Type.String({ description: "Task to classify and execute." }),
     categories: Type.Array(Type.String({ minLength: 1 }), {

package/dist/builtin/workflows/builtin/fan-out-and-synthesize.ts

@@ -6,6 +6,10 @@ import { runFanOutAndSynthesize } from "./fan-out-and-synthesize-runner.js";
 export default workflow({
   name: "fan-out-and-synthesize",
   description: "Partition a task, run bounded independent artifact branches, then synthesize all evidence at an explicit barrier.",
+  // The 15-minute default, stated rather than inherited: this is a per-workflow
+  // product decision, so a future change to the global default must not silently
+  // re-cadence a long autonomous run.
+  heartbeatIntervalMinutes: 15,
   inputs: {
     prompt: Type.String({ description: "Task to partition, investigate, and synthesize." }),
     max_branches: Type.Integer({

package/dist/builtin/workflows/builtin/generate-and-filter-runner.ts

@@ -48,11 +48,16 @@ export async function runGenerateAndFilter(ctx: WorkflowRunContext<Inputs>): Pro
   const filterPath = join(root, "filter.json");
   const filtered = await ctx.task("dedupe-and-filter", {
     prompt: renderFilterPrompt(ctx.inputs.prompt, candidatePaths, shortlistLimit), context: "fresh",
-    reads: [manifestPath, ...candidatePaths], schema: filterSchema, output: filterPath, outputMode: "file-only",
+    reads: [manifestPath, ...candidatePaths], schema: filterSchema,
   });
+  const filteredDecision = filterDecision(filtered.structured);
+  // The filter report is inter-stage data: the judge and final-shortlist
+  // stages read schema-shaped JSON from this path, so the runner persists the
+  // structured decision itself rather than routing it through the artifact.
+  await writeFile(filterPath, `${JSON.stringify(filteredDecision ?? { shortlist: [], discarded: [] }, null, 2)}\n`);
   const selectCandidates = (paths: readonly string[]): string[] => [...new Set(paths.filter((path) => candidatePaths.includes(path)))].slice(0, shortlistLimit);
   const fallbackShortlist = candidatePaths.slice(0, shortlistLimit);
-  const filteredShortlist = selectCandidates(filterDecision(filtered.structured)?.shortlist ?? []);
+  const filteredShortlist = selectCandidates(filteredDecision?.shortlist ?? []);
   let shortlist = filteredShortlist.length > 0 ? filteredShortlist : fallbackShortlist;
   let judgePath: string | null = null;
   let decisionPath = filterPath;
@@ -60,9 +65,12 @@ export async function runGenerateAndFilter(ctx: WorkflowRunContext<Inputs>): Pro
     judgePath = join(root, "judge.json");
     const judged = await ctx.task("judge", {
       prompt: renderJudgePrompt(ctx.inputs.prompt, filterPath, shortlistLimit), context: "fresh",
-      reads: [filterPath, ...shortlist], schema: judgeSchema, output: judgePath, outputMode: "file-only",
+      reads: [filterPath, ...shortlist], schema: judgeSchema,
     });
-    const judgedShortlist = selectCandidates(judgeDecision(judged.structured)?.shortlist ?? []);
+    const judgedDecision = judgeDecision(judged.structured);
+    // Same inter-stage contract as the filter report above.
+    await writeFile(judgePath, `${JSON.stringify(judgedDecision ?? { shortlist: [], rationale: "Judge stage produced no valid structured decision." }, null, 2)}\n`);
+    const judgedShortlist = selectCandidates(judgedDecision?.shortlist ?? []);
     shortlist = judgedShortlist.length > 0 ? judgedShortlist : shortlist;
     decisionPath = judgePath;
   }