@bastani/atomic 0.9.14-alpha.1 → 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.14-alpha.1",
+  "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,51 @@ 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

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",
@@ -820,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/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;
   }

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

@@ -19,9 +19,9 @@ export const orchestratorModelConfig = {
       "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:xhigh",
-      "zai-coding-cn/glm-5.2:xhigh",
+      "xai/grok-4.6:high",
+      "zai/glm-5.3:high",
+      "zai-coding-cn/glm-5.3:high",
       "openrouter/anthropic/claude-opus-5:high",
       "openrouter/openai/gpt-5.6-sol:xhigh",
       "openrouter/anthropic/claude-fable-5:high",
@@ -29,8 +29,7 @@ export const orchestratorModelConfig = {
       "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:xhigh"
+      "openrouter/x-ai/grok-4.6",
     ],
     excludedTools: ["ask_user_question"],
 };
@@ -54,9 +53,9 @@ export const reviewerModelConfig = {
       "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:xhigh",
-      "zai-coding-cn/glm-5.2:xhigh",
+      "xai/grok-4.6:high",
+      "zai/glm-5.3:high",
+      "zai-coding-cn/glm-5.3:high",
       "openrouter/anthropic/claude-opus-5:high",
       "openrouter/anthropic/claude-fable-5:high",
       "openrouter/openai/gpt-5.6-sol:xhigh",
@@ -64,8 +63,7 @@ export const reviewerModelConfig = {
       "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:xhigh"
+      "openrouter/x-ai/grok-4.6",
     ],
     excludedTools: ["ask_user_question"],
     schema: reviewDecisionSchema,

package/dist/builtin/workflows/builtin/index.d.ts

@@ -21,20 +21,16 @@ export type OpenClaudeDesignOutputType = "prototype" | "wireframe" | "page" | "c
 export type OpenClaudeDesignWorkflowInputs = {
   readonly prompt: string;
   readonly discover_references: boolean;
-  readonly max_refinements: number;
 };
 export type OpenClaudeDesignWorkflowRunInputs = {
   readonly prompt: string;
   readonly discover_references?: boolean;
-  readonly max_refinements?: number;
 };
 export type OpenClaudeDesignWorkflowOutputs = WorkflowOutputValues & {
   readonly output_type?: string;
   readonly design_system?: string;
   readonly artifact?: string;
   readonly handoff?: string;
-  readonly approved_for_export?: boolean;
-  readonly refinements_completed?: number;
   readonly import_context?: string;
   readonly run_id?: string;
   readonly artifact_dir?: string;

package/dist/builtin/workflows/builtin/loop-until-done-runner.ts

@@ -129,10 +129,12 @@ export async function runLoopUntilDone(ctx: WorkflowRunContext<LoopInputs>) {
       context: "fresh",
       reads: [ledgerPath, iterationPath],
       schema: evaluationSchema,
-      output: evaluationPath,
-      outputMode: "file-only",
     });
     const decision = evaluationFrom(evaluator);
+    // Evaluation reports are declared workflow outputs consumed as data: the
+    // runner persists the structured decision itself so evaluation-N.json
+    // stays schema-shaped JSON rather than stage prose.
+    await writeFile(evaluationPath, `${JSON.stringify(evaluator.structured, null, 2)}\n`);
     entries.push({
       iteration,
       artifact_path: iterationPath,