@bastani/atomic 0.9.18-alpha.5 → 0.9.18-alpha.7

package/dist/builtin/workflows/README.md

@@ -58,7 +58,7 @@ Workflow lifecycle notices are enabled by default. They send steer prompts into
 
 Set `enabled` to `false` to disable all lifecycle notices, or narrow `notifyOn` to a non-empty list of selected events. Completion, failure, and blocked lifecycle notices are emitted for top-level workflow runs, use steer delivery, and wake an idle model so the lifecycle update enters the model context when it happens. When a fulfilled workflow body leaves admitted tool failures, the engine promotes the first admission and persists that exact tool origin for the failed notice. Ordinary body rejections retain their original error and failed graph nodes without claiming a tool origin because transparent native promises do not expose the source promise; this prevents a caught tool rejection from being misattributed when body code later throws the same object or primitive. Nested child workflow completion/failure is reflected inside the expanded parent graph instead of producing separate top-level completion cards. Awaiting-input states are tracked for dedupe/restore, but workflows do not enqueue main-chat `/workflow connect` cards for them; prompt state remains visible through workflow status/connect surfaces, avoiding stale actionable cards if a prompt resolves while the main chat is streaming.
 
-Treat a blocked run as continuable by default; the blocked notice text itself carries this instruction. On a `WORKFLOW BLOCKED` notice or a blocked status, keep the work moving: resume a resumable block, answer the pending prompt, steer the stage past the obstacle, or start a follow-up workflow that carries the remaining tracked work past a terminal block — continue inline only if the remaining work is minimal. Stop for user input only when the task is so ambiguous that competing interpretations lead to materially different outcomes and judgment cannot infer intent from the stated objective and repository evidence; mine git history, commits, PRs, issues, and the user's own comments before asking. When `ask_user_question` or another human input channel is unavailable, continue fully autonomously on the interpretation best supported by that evidence, and record the assumption in the result or an artifact. A budget-exceeded stop (the resumable `budget_exceeded` blocked rail) is the exception, and its notice says so: the exhausted budget is a boundary someone chose, so summarize progress and the estimated next steps, ask the user whether to proceed — prefer the `ask_user_question` tool when it is available — and resume with a raised `budget` only after approval.
+Treat blocked runs as continuable by default: resume, answer pending prompts, steer, or use a follow-up workflow. Explicit task-scoped inline/no-workflow requests override that default even for complex work. Safely hold/stop the affected run, reconcile completed work and in-flight effects, then continue inline without duplication; completed work is not undone. Keep safety, authorization and validation requirements. A `budget_exceeded` stop still requires approval before raising the chosen limit. See [verification and evidence](../coding-agent/docs/workflows/verification.md) for execution-mode scope, environment-aware browser/terminal/desktop verification, qlty setup and native GitHub attachments.
 
 Control notices report deliberate actions on a top-level run: `/workflow <name>` produces a `WORKFLOW STARTED` card (`▶`), `/workflow pause` a `WORKFLOW PAUSED` card (`⏸`, warning tone), `/workflow quit` a `WORKFLOW QUIT` card (`⏹`, warning tone, plus a `resumable` field), and `/workflow resume` a `WORKFLOW RESUMED` card (`▶`). All four travel the same steer delivery, capped-backoff retry, and card path as the failure notice. The paused and quit text says the stop was deliberate and user-requested and instructs the model not to resume the run or take the work over unless asked, hinting `/workflow resume <run-id>`; the resumed text does not, since the run is progressing again.
 
@@ -451,7 +451,7 @@ When an item configures both `schema` and `output`, its successful `structured_o
 
 `subagent` is available as a default workflow-stage tool on the same terms as main chat: a stage is a top-level session, so it can delegate once, and the children it launches cannot delegate further. Delegation is one level deep and nothing configures it. `tools` allowlists apply to bundled extension tools as well as built-ins; if a stage sets `tools`, list every non-mandatory tool it should see. Ordinary `intercom` remains registered and active in every workflow model stage even under `noTools: "all"`, restrictive allowlists, or exclusions. Restrictions on `subagent`, `web_search`, `fetch_content`, and every other tool are unchanged. Bundled `@bastani/subagents` agent definitions are available to the `subagent` tool in workflow stages, including workflows launched from a subagent child process.
 
-Send material updates through Intercom to every affected workflow stage, including stages that have not started. Address a known pending stage on a nonterminal run with ordinary `intercom send` at `<runId>:<stageKey>`; Atomic queues the message with workflow state and delivers it through the existing inbound Intercom path when the stage session initializes, before its first model turn. Live stage delivery is immediate. Status surfaces never advertise a retained pending stage after its run terminates. Use `ask` once the stage session is live and can reply. Unknown stage identities retain the ordinary unknown-target failure. Workflow `answer` handles pending human-input prompts, and workflow `resume` handles paused run control.
+Send material updates through Intercom to every affected workflow stage, including stages that have not started. Join `workflow:<rootRunId>` and use `intercom list` to see live, pending, and possible future targets, then send to `workflow:<rootRunId>/<segment>[/<segment>...]`; segments may be stage names, run ids, or globs (`*` matches one segment, `**` any depth). Name and pattern sends remain sticky for every future match until root termination. When shared scope or acceptance criteria change, broadcast one authoritative update to `workflow:<rootRunId>/**` (or a narrower pattern) rather than enumerating stages; live matches receive it immediately and future matches receive it before their first model turn. A valid target outside the known set queues with a `notInKnownSet` warning and settles undeliverable at terminal only if never delivered. Use `ask` only once the target is live and can reply. Workflow `answer` handles pending human-input prompts, and workflow `resume` handles paused run control.
 
 ### Model fallbacks
 
@@ -492,7 +492,7 @@ export default workflow({
 
 Set `model` and `fallbackModels` on the authored stage/task/chain/parallel item that needs them.
 
-For authored workflows, choose thinking effort by stage role and failure cost rather than copying a benchmark's level onto every stage. Before launch, record each model stage's role, failure cost, primary model, thinking level, and fallback policy, then print a compact `Stage | Model | Thinking | Role` assignment with a short rationale. Reserve `max` for high-cost-of-error roles or an explicit user request; use `high` for demanding analysis, planning, and repair; use `medium` for user-impact review and reporting; and keep deterministic checks as tool nodes with no model call. Apply the same role policy independently to every fallback, not a mechanical `max` inheritance. Use only levels listed in the configured catalog's `availableThinkingLevels`; if a level is unsupported, choose another catalog model or leave the stage unpinned rather than inventing a suffix.
+For authored workflows, choose thinking effort by stage role and failure cost rather than copying a benchmark's level onto every stage. Pick the model for each stage from the measured evidence in `packages/coding-agent/docs/models/evals.md` (its task-type picker maps stage types to the eval that measures them) and the role guidance in `packages/coding-agent/docs/models/model-selection.md`. Before launch, record each model stage's role, failure cost, primary model, thinking level, and fallback policy, then print a compact `Stage | Model | Thinking | Role` assignment with a short rationale. Reserve `max` for high-cost-of-error roles or an explicit user request; use `high` for demanding analysis, planning, and repair; use `medium` for user-impact review and reporting; and keep deterministic checks as tool nodes with no model call. Apply the same role policy independently to every fallback, not a mechanical `max` inheritance. Use only levels listed in the configured catalog's `availableThinkingLevels`; if a level is unsupported, choose another catalog model or leave the stage unpinned rather than inventing a suffix.
 
 When pi exposes its model registry, workflow runs validate user-specified `model` / `fallbackModels` before starting model-backed work and report all unavailable or ambiguous IDs together. Bare model IDs are accepted only when they resolve uniquely or match the current provider; otherwise use `provider/model`. Fallback attempts may send the same prompt/context to a different provider, so choose fallbacks that fit your cost, privacy, and data-handling requirements.
 
@@ -668,13 +668,13 @@ Named workflow launches always run as **background tasks** in interactive sessio
 
 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.
 
-At normal widths, the persistent `BACKGROUND` panel and interactive `/workflow status` list/detail name materialized pending stages by display name and canonical ID. They show `<runId>:<stageId>` only when pre-start Intercom delivery is available on a nonterminal owning run and label unavailable delivery otherwise; retained pending stages on ended runs, including ended nested child runs projected into a live root, never advertise a target. Interactive status cards and run detail wrap a full target onto continuation rows when needed, and narrow status cards preserve the full canonical stage ID rather than ellipsizing it. The single-line panel uses only pending-stage forms that fit its remaining metadata budget; if none fit, it omits the pending label entirely so mode, progress, live-tool, and elapsed/status metadata remains intact. The narrow widget remains aggregate-only.
+At normal widths, the persistent `BACKGROUND` panel and interactive `/workflow status` list/detail name materialized pending stages by display name and canonical ID. They show the canonical `workflow:<rootRunId>/<segment>[/<segment>...]` path only when pre-start Intercom delivery is available on a nonterminal owning run and label unavailable delivery otherwise; retained pending stages on ended runs, including ended nested child runs projected into a live root, never advertise a target. Interactive status cards and run detail wrap a full target onto continuation rows when needed, and narrow status cards preserve the full canonical stage ID rather than ellipsizing it. The single-line panel uses only pending-stage forms that fit its remaining metadata budget; if none fit, it omits the pending label entirely so mode, progress, live-tool, and elapsed/status metadata remains intact. The narrow widget remains aggregate-only.
 
 Named launches return only after startup admission, while the admitted workflow body and stages remain background work. Pre-body setup failures (including invalid input-bound reusable worktrees) are returned immediately from the original tool call as structured failed results with the concrete error and allocated run id; Atomic does not first claim that the workflow started, and it removes the unadmitted run so corrected inputs can be retried immediately. Failures after admission continue to use normal background status and lifecycle notices.
 
 Graceful quit is idempotent for already-paused runs and preserves unresolved `ctx.ui` prompts in DBOS. Pausing or interrupting a stage also holds every queued steering and follow-up item in place: no queued turn, late context-bearing delivery, or workflow continuation starts while the stage is paused, and the existing `resume` action releases the items once in their existing per-queue order without queue release itself starting a provider turn. Stable author-callsite-and-composed-nested-scope reservations are created before prompting and released by exact current-format token generation after answer checkpoint, rejection, or abort. Answering while quit/paused cannot advance workflow code until explicit resume.
 
-Workflow durability uses DBOS/Postgres as its only persistent backend. Atomic initializes it lazily on the first workflow action, reuses that process-wide instance, and awaits readiness before durable execution or control. `DBOS_SYSTEM_DATABASE_URL` selects an existing database when supplied. Otherwise Atomic first provisions its embedded Postgres (npm-distributed binaries, directly spawned under `~/.atomic/postgres` on port 5439, shared across sessions) and tries DBOS's reusable `dbos-db` Docker container if embedded provisioning fails without leaving retained-process cleanup pending. Linux root execution clears inherited supplementary groups before dropping Postgres to an unprivileged primary GID/UID; when that account cannot traverse the installed binaries, Atomic publishes one exact package-content runtime generation under a root-owned cache, where it stays readable/executable but not writable by Postgres. Reuse and publication re-snapshot the current source, validate the deterministic path after rename, and fail closed on source mutation, corruption, or setup-lease displacement without accumulating unbounded repair copies. If DBOS still cannot become ready, Atomic logs a loud warning and runs against one process-local in-memory backend: workflow execution continues, but its state does not survive the process and `/workflow resume` after exit has nothing to restore. Once DBOS is ready, query or write failures fail the workflow action and do not switch backends. Abrupt Atomic exit releases the retained native process lease without killing Postgres. Orderly shutdown sends fast shutdown and waits on that exact retained process; sessions attached to an already-running cluster never own or stop it. Concurrent Atomic sessions safely share one database: unique per-process executor ids, owner/heartbeat metadata on running workflows, and first-writer-wins claims on contended status transitions prevent double dispatch. Running workflows never appear as resume targets in any session; stale-heartbeat (crashed) ones surface as red `crashed` rows, paused rows render yellow, failed/blocked red, completed green, and the open picker live-updates on local changes plus a bounded cross-session poll.
+Workflow durability uses DBOS/Postgres as its only persistent backend. Atomic initializes it lazily on the first workflow action, reuses that process-wide instance, and awaits readiness before durable execution or control. `DBOS_SYSTEM_DATABASE_URL` selects an existing database when supplied. Otherwise Atomic first provisions its embedded Postgres (npm-distributed binaries, directly spawned under `~/.atomic/postgres` on port 5439, shared across sessions) and tries DBOS's reusable `dbos-db` Docker container if embedded provisioning fails without leaving retained-process cleanup pending. Linux root execution clears inherited supplementary groups before dropping Postgres to an unprivileged primary GID/UID; when that account cannot traverse the installed binaries, Atomic publishes one exact package-content runtime generation under a root-owned cache, where it stays readable/executable but not writable by Postgres. Reuse and publication re-snapshot the current source, validate the deterministic path after rename, and fail closed on source mutation, corruption, or setup-lease displacement without accumulating unbounded repair copies. If DBOS still cannot become ready, Atomic shows interactive and RPC actions a display-only warning notification that is not added to agent/model context, then runs against one process-local in-memory backend. Print and other headless actions without a usable UI write the same actionable warning to the console instead. Workflow execution continues, but its state does not survive the process and `/workflow resume` after exit has nothing to restore. Once DBOS is ready, query or write failures fail the workflow action and do not switch backends. Abrupt Atomic exit releases the retained native process lease without killing Postgres. Orderly shutdown sends fast shutdown and waits on that exact retained process; sessions attached to an already-running cluster never own or stop it. Concurrent Atomic sessions safely share one database: unique per-process executor ids, owner/heartbeat metadata on running workflows, and first-writer-wins claims on contended status transitions prevent double dispatch. Running workflows never appear as resume targets in any session; stale-heartbeat (crashed) ones surface as red `crashed` rows, paused rows render yellow, failed/blocked red, completed green, and the open picker live-updates on local changes plus a bounded cross-session poll.
 
 DBOS is the only durable catalog for resume, completed inspection, deletion, and targeted lookup. Session JSONL files remain chat transcripts only. Atomic reads one current durable format and does not convert prior local state or pre-current DBOS records. A completed current-format child checkpoint created before boundary-start or invocation-fingerprint identity existed is shown only when its child checkpoints reciprocally prove the same root, parent run, boundary, child owner, and scope. Active checkpoints without a provable invocation fingerprint, and malformed, duplicate, stale, nonreciprocal, mixed, aliased, cyclic, orphaned, or unsupported topology, fail closed before cache exposure or child/control dispatch: Atomic does not invent a child link or execute child code to repair it.
 
@@ -689,7 +689,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/atomic/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, answer pending prompts only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. When steering or communication is useful, use Intercom. Before steering a stage, join its invocation group. Use the Intercom `groups` action to discover it. Workflow invocation groups are named `workflow:<rootRunId>`. Then address the stage as `<runId>:<stageKey>`. Live delivery is immediate; a known stage that has not started is queued and receives the message before its first model turn. Use `ask` only for a reply-capable live session. Treat a blocked run as continuable by default: resume resumable blocks, answer pending prompts, steer past the obstacle, or start a follow-up workflow past a terminal block, and escalate to the user only when the blocked result is so ambiguous that human input or steering must settle it; when ask_user_question or human input is unavailable, continue fully autonomously on the interpretation best supported by the objective and repository evidence, and record the assumption. For action 'run' and 'resume', budget accepts per-field duration, token, cost, and warning overrides; fields resolve over the workflow declaration and config, and 0 disables a field. Pass budget only when the user asked for a limit; otherwise omit it entirely and inherit the declaration and config rather than inventing a cap. 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.",
+  "description": "Run named builtin, project, user, or package workflows; custom definitions may import reusable project/package workflows or builtin definitions from @bastani/atomic/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, answer pending prompts only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. When steering or communication is useful, use Intercom. Before steering a stage, join its invocation group. Use the Intercom `groups` action to discover it. Workflow invocation groups are named `workflow:<rootRunId>`. Then address the stage as `workflow:<rootRunId>/<segment>[/<segment>...]`; each segment may be a stage name, run id, or glob (`*` matches one segment and `**` any depth). Use `intercom list` inside the invocation group to see live, pending, and possible future targets. Live delivery is immediate; a known stage that has not started is queued and receives the message before its first model turn. Name and pattern sends remain sticky for every future matching stage until the root run terminates. When shared scope or acceptance criteria change, broadcast one authoritative update to `workflow:<rootRunId>/**` (or a narrower path pattern) rather than enumerating stages. A syntactically valid target outside the known set queues with a `notInKnownSet` warning and settles undeliverable at terminal only if never delivered. Use `ask` only for a reply-capable live session. Treat a blocked run as continuable by default unless the user requests inline/no-workflow execution: then safely hold/stop it, reconcile completed work and in-flight side effects, and continue inline without duplication. Otherwise resume resumable blocks, answer pending prompts, steer past the obstacle, or start a follow-up workflow past a terminal block; resolve material ambiguity from user intent and repository evidence without bypassing safety or authorization. For action 'run' and 'resume', budget accepts per-field duration, token, cost, and warning overrides; fields resolve over the workflow declaration and config, and 0 disables a field. Pass budget only when the user asked for a limit; otherwise omit it entirely and inherit the declaration and config rather than inventing a cap. 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",
@@ -717,7 +717,7 @@ Raw stage-chat prompt answer replay is live-memory only. `StageSnapshot.promptAn
 - **`transcript`** — path-only by default when a transcript file exists: use `status`, `stages`, or `stage` to identify the stage and its `sessionFile`/`transcriptPath`, quote the exact path without changing platform separators (for example, preserve Windows backslashes), then search that file with `rg`/`grep` for targeted terms and read only small surrounding ranges. Default text results include JSON-escaped `sessionFileJson`/`transcriptPathJson` lines for copy-safe path literals plus a `lazyReadPrompt`, with `entries: not inlined` so transcript bodies and tool outputs stay out of model context. Passing explicit `tail` or `limit` opts into a bounded inline preview for quick context checks. If no transcript path is available, the action falls back to a bounded preview of up to 5 recent entries with a `fallbackNote`. A registered live stage handle is used when one exists, even before live messages arrive; otherwise the action falls back to stored stage snapshots. Snapshot entries are ordered chronologically before `tail`/`limit` is applied, with terminal result/error entries kept after tool entries when timestamps are missing or tied. `includeToolOutput` applies only to inlined snapshot previews or no-path fallback previews; live session transcripts may not expose tool output.
 - **`answer`** — answers one pending primitive or structured workflow prompt while the authoritative root is nonterminal. It accepts `promptId` plus `response`, `text`, or `message`, but never sends stage chat, steers work, resumes a stage, or starts a model turn.
 
-Free-form workflow-stage communication uses ordinary Intercom, not the workflow tool. Send to `<runId>:<stageKey>`; Atomic delivers immediately to live stages and queues messages for known stages that have not started.
+Free-form workflow-stage communication uses ordinary Intercom, not the workflow tool. Send to `workflow:<rootRunId>/<segment>[/<segment>...]`; `*` matches one segment and `**` any depth. `workflow:<rootRunId>/**` reaches live stages immediately and remains sticky for every future stage until root termination; narrower name and pattern targets likewise deliver to every future match. Use `intercom list` inside the invocation group to see live, pending, and possible future targets. Valid paths outside the known set queue with a `notInKnownSet` warning and settle undeliverable at terminal only if never delivered; use `ask` only on live targets.
 The concise model-facing status listing enumerates pending stages with their display name, canonical ID, literal `pending` lifecycle, `pendingStageDeliveryAvailable` value, and an exact Intercom target only when that target is usable on a nonterminal owning run. Retained pending stages on ended root or nested child runs report unavailable delivery and no target, including when a child stage is projected through a live root. Duplicate names remain distinct through canonical IDs. Live `send` delivery is immediate, a known pending-stage `send` queues before the first model turn, and `ask` requires a live reply-capable stage.
 - **`reload`** — refreshes workflow resources directly in-process instead of queuing a literal `/workflow reload` chat follow-up.
 - **`models`** — returns safe model-catalog metadata from the configured registry. Each entry contains `provider` (e.g. `openai`), `id` (e.g. `gpt-4`), `fullId` (e.g. `openai/gpt-4`), `isCurrent` (whether this is the active model), and `availableThinkingLevels`, canonically derived from the registry model's `reasoning` and `thinkingLevelMap` metadata. The result is a configured-auth snapshot: it shows which models are present in the registry with configured authentication, not proof of credentials, entitlements, OAuth freshness, or live provider access. No secrets, tokens, or authentication details are returned.

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

@@ -1,12 +1,12 @@
 import {
   adversarial_verification_default
-} from "./chunk-qwzvgxnq.js";
+} from "./chunk-reqr3sr3.js";
 import"./chunk-7at6dnkr.js";
 import"./chunk-7430zyas.js";
 import"./chunk-wpckd35c.js";
 import"./chunk-cg9tmks0.js";
 import"./chunk-bfkmzv9h.js";
-import"./chunk-0x6e303p.js";
+import"./chunk-zbekjqew.js";
 export {
   adversarial_verification_default as default
 };

package/dist/builtin/workflows/builtin/{chunk-szz1ajz9.js → chunk-42s7sw0b.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-bfkmzv9h.js";
 import {
   withSteeringPropagationContext
-} from "./chunk-0x6e303p.js";
+} from "./chunk-zbekjqew.js";
 
 // dist/builtin/workflows/builtin/open-claude-design.ts
 import { Type as Type2 } from "typebox";
@@ -806,8 +806,13 @@ async function runOpenClaudeDesignWorkflow(ctx) {
     }
   };
   const designModelConfig = {
-    model: "anthropic/claude-opus-5:high",
+    model: "openai-codex/gpt-6-astra:high",
     fallbackModels: [
+      "github-copilot/gpt-6-astra:high",
+      "openai/gpt-6-astra:high",
+      "anthropic/claude-fable-5-1:high",
+      "github-copilot/claude-fable-5-1:high",
+      "anthropic/claude-opus-5:high",
       "github-copilot/claude-opus-5:high",
       "anthropic/claude-fable-5:high",
       "github-copilot/claude-fable-5:high",
@@ -827,6 +832,8 @@ async function runOpenClaudeDesignWorkflow(ctx) {
       "zai-coding-cn/glm-5.3-flash:high",
       "baseten/zai-org/GLM-5.3:high",
       "baseten/zai-org/GLM-5.3-Flash:high",
+      "openrouter/openai/gpt-6-astra:high",
+      "openrouter/anthropic/claude-fable-5-1:high",
       "openrouter/anthropic/claude-opus-5:high",
       "openrouter/anthropic/claude-fable-5:high",
       "openrouter/anthropic/claude-opus-4-8:high",

package/dist/builtin/workflows/builtin/{chunk-2dqb5s2q.js → chunk-79fjkcvh.js}

@@ -19,7 +19,7 @@ import {
 } from "./chunk-bfkmzv9h.js";
 import {
   withSteeringPropagationContext
-} from "./chunk-0x6e303p.js";
+} from "./chunk-zbekjqew.js";
 
 // dist/builtin/workflows/builtin/tournament.ts
 import { Type as Type2 } from "typebox";

package/dist/builtin/workflows/builtin/{chunk-n58a7v26.js → chunk-b0v2xab1.js}

@@ -16,6 +16,37 @@ import { randomUUID } from "node:crypto";
 import { mkdir, readdir, rm, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { getAgentDir, getEnvValue } from "@bastani/atomic";
+// dist/builtin/workflows/src/durable/backend-process-owner.ts
+var DURABLE_BACKEND_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/durable-backend-process-owner@1");
+function emptyOwner() {
+  return {
+    version: 1,
+    injectedBackend: undefined,
+    initializedBackend: undefined,
+    initializing: undefined,
+    warningSink: undefined,
+    warningReported: false
+  };
+}
+function ownerBag() {
+  return globalThis;
+}
+function getDurableBackendProcessOwner() {
+  const bag = ownerBag();
+  const existing = bag[DURABLE_BACKEND_PROCESS_OWNER_KEY];
+  if (existing !== undefined && existing.version === 1)
+    return existing;
+  const created = emptyOwner();
+  bag[DURABLE_BACKEND_PROCESS_OWNER_KEY] = created;
+  return created;
+}
+// dist/builtin/workflows/src/shared/possible-stages.ts
+var BUILTIN_BARREL_SPECIFIERS = new Set([
+  "@bastani/atomic/workflows/builtin",
+  "@bastani/workflows/builtin"
+]);
+var TRACKED_NODE_METHODS = new Set(["stage", "task", "chain", "parallel", "workflow", "tool"]);
+
 // dist/builtin/workflows/src/shared/workflow-failures-contract.ts
 var WORKFLOW_FAILURE_KINDS = new Set([
   "auth",
@@ -110,7 +141,7 @@ var STATUS_RELATED_MESSAGE_REFINEMENT_CODES = new Set([
 ]);
 // dist/builtin/workflows/src/durable/dbos-process-owner.ts
 var DBOS_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/dbos-process-owner@1");
-function emptyOwner() {
+function emptyOwner2() {
   return {
     version: 1,
     state: "uninitialized",
@@ -122,15 +153,15 @@ function emptyOwner() {
     wrappers: undefined
   };
 }
-function ownerBag() {
+function ownerBag2() {
   return globalThis;
 }
 function getDbosProcessOwner() {
-  const bag = ownerBag();
+  const bag = ownerBag2();
   const existing = bag[DBOS_PROCESS_OWNER_KEY];
   if (existing !== undefined && existing.version === 1)
     return existing;
-  const created = emptyOwner();
+  const created = emptyOwner2();
   bag[DBOS_PROCESS_OWNER_KEY] = created;
   return created;
 }
@@ -177,14 +208,13 @@ function dbosLifecycleState() {
 }
 
 // dist/builtin/workflows/src/durable/factory.ts
-var injectedBackend;
-var initializedBackend;
 function isMemoizedBackendUsable(backend) {
   return !backend.persistent || dbosLifecycleState() === "ready";
 }
 function getDurableBackend() {
-  const memoized = initializedBackend !== undefined && isMemoizedBackendUsable(initializedBackend) ? initializedBackend : undefined;
-  const backend = injectedBackend ?? memoized ?? getReadyDbosBackendSync();
+  const owner2 = getDurableBackendProcessOwner();
+  const memoized = owner2.initializedBackend !== undefined && isMemoizedBackendUsable(owner2.initializedBackend) ? owner2.initializedBackend : undefined;
+  const backend = owner2.injectedBackend ?? memoized ?? getReadyDbosBackendSync();
   if (backend === undefined)
     throw new DbosNotReadyError;
   return backend;
@@ -244,6 +274,96 @@ function queueStageMessage(messages, input, senderGroup, runGroup, stageIdentity
     deduplicated: false
   };
 }
+function queueStickyStageMessage(messages, input, senderGroup, runGroup) {
+  if (normalizeDeliveryGroup(senderGroup) !== normalizeDeliveryGroup(runGroup)) {
+    return { ok: false, reason: "group_mismatch", runId: input.runId, stageKey: input.targetPath };
+  }
+  const messageId = input.message.id;
+  const existing = messages.find((entry2) => entry2.runId === input.runId && entry2.id === messageId);
+  if (existing !== undefined) {
+    if (pendingStageMessageSignature(existing) !== pendingStageMessageSignature(input)) {
+      return {
+        ok: false,
+        reason: "message_id_conflict",
+        runId: input.runId,
+        stageKey: input.targetPath,
+        messageId
+      };
+    }
+    const queuedForTarget = queuedStickyCount(messages, input.runId, input.targetPath);
+    return {
+      ok: true,
+      messages,
+      entry: existing,
+      ...existing.status === "queued" ? { position: queuedForTarget } : {},
+      deduplicated: true
+    };
+  }
+  if (queuedStickyCount(messages, input.runId, input.targetPath) >= PENDING_STAGE_MESSAGE_LIMIT) {
+    return {
+      ok: false,
+      reason: "capacity",
+      limit: PENDING_STAGE_MESSAGE_LIMIT,
+      runId: input.runId,
+      stageKey: input.targetPath
+    };
+  }
+  const entry = {
+    ...input,
+    id: messageId,
+    stageKey: input.targetPath,
+    sticky: true,
+    deliveries: [],
+    deliveryCount: 0,
+    admissionOrder: nextAdmissionOrder(messages, input.runId),
+    status: "queued"
+  };
+  return {
+    ok: true,
+    messages: [...messages, entry],
+    entry,
+    position: queuedStickyCount(messages, input.runId, input.targetPath) + 1,
+    deduplicated: false
+  };
+}
+function queuedStickyCount(messages, runId, targetPath) {
+  return messages.filter((entry) => entry.runId === runId && entry.sticky === true && entry.targetPath === targetPath && entry.status === "queued").length;
+}
+function recordPendingStageMessageDeliveries(messages, runId, messageId, records, deliveredAt) {
+  const index = messages.findIndex((entry2) => entry2.runId === runId && entry2.id === messageId && entry2.sticky === true && entry2.status === "queued");
+  if (index < 0)
+    return messages;
+  const entry = messages[index];
+  const recorded = new Set((entry.deliveries ?? []).map((delivery) => `${delivery.runId}\x00${delivery.stageId}`));
+  const additions = [];
+  for (const record of records) {
+    const key = `${record.runId}\x00${record.stageId}`;
+    if (recorded.has(key))
+      continue;
+    recorded.add(key);
+    additions.push({
+      runId: record.runId,
+      stageId: record.stageId,
+      ...record.stageName === undefined ? {} : { stageName: record.stageName },
+      deliveredAt
+    });
+  }
+  if (additions.length === 0)
+    return messages;
+  const deliveries = [...entry.deliveries ?? [], ...additions];
+  const next = { ...entry, deliveries, deliveryCount: deliveries.length };
+  const result = [...messages];
+  result[index] = next;
+  return result;
+}
+function settleStickyPendingStageMessageDelivered(messages, runId, messageId, settledAt) {
+  const index = messages.findIndex((entry) => entry.runId === runId && entry.id === messageId && entry.sticky === true && entry.status === "queued" && (entry.deliveryCount ?? 0) > 0);
+  if (index < 0)
+    return messages;
+  const next = [...messages];
+  next[index] = { ...next[index], status: "delivered", deliveredAt: settledAt };
+  return next;
+}
 function pendingStageMessagesFor(messages, runId, stageKey, stageIdentity) {
   return messages.map((entry, index) => ({ entry, index })).filter(({ entry }) => matchesPendingStage(entry, runId, stageKey, stageIdentity) && entry.status === "queued").sort((left, right) => (left.entry.admissionOrder ?? left.index + 1) - (right.entry.admissionOrder ?? right.index + 1) || left.index - right.index).map(({ entry }) => entry);
 }
@@ -263,7 +383,7 @@ function markPendingStageMessageUndeliverable(messages, runId, stageKey, message
   }));
 }
 function markPendingStageMessageUndeliverableNotified(messages, runId, stageKey, messageId, notificationId, notifiedAt) {
-  const index = messages.findIndex((entry) => matchesPendingStage(entry, runId, stageKey) && entry.id === messageId && entry.status === "undeliverable" && entry.undeliverableNotificationId === notificationId && entry.undeliverableNotifiedAt === undefined);
+  const index = messages.findIndex((entry) => (entry.sticky === true ? entry.runId === runId : matchesPendingStage(entry, runId, stageKey)) && entry.id === messageId && entry.status === "undeliverable" && entry.undeliverableNotificationId === notificationId && entry.undeliverableNotifiedAt === undefined);
   if (index < 0)
     return messages;
   const next = [...messages];
@@ -279,14 +399,21 @@ function pendingStageUndeliverableNotificationId(entry) {
   ].join(":");
 }
 function updateQueuedPendingStageMessage(messages, runId, stageKey, messageId, stageIdentity, update) {
-  const index = messages.findIndex((entry) => matchesPendingStage(entry, runId, stageKey, stageIdentity) && entry.id === messageId && entry.status === "queued");
+  const index = messages.findIndex((entry) => queuedEntryMatches(entry, runId, stageKey, messageId, stageIdentity));
   if (index < 0)
     return messages;
   const next = [...messages];
   next[index] = update(next[index]);
   return next;
 }
+function queuedEntryMatches(entry, runId, stageKey, messageId, stageIdentity) {
+  if (entry.runId !== runId || entry.id !== messageId || entry.status !== "queued")
+    return false;
+  return entry.sticky === true || matchesPendingStage(entry, runId, stageKey, stageIdentity);
+}
 function matchesPendingStage(entry, runId, stageKey, stageIdentity) {
+  if (entry.sticky === true)
+    return false;
   if (entry.runId !== runId)
     return false;
   if (stageIdentity === undefined)
@@ -1058,6 +1185,50 @@ function createPendingStageDeliveryStoreMethods(context) {
         context.bumpAndNotify();
         return true;
       });
+    },
+    async queueStickyStageMessage(input, senderGroup, runGroup, backend) {
+      return await serialize(input.runId, async () => {
+        const run = context.findRun(input.runId);
+        if (run === undefined)
+          return;
+        const result = queueStickyStageMessage(run.pendingStageMessages ?? [], input, senderGroup, runGroup);
+        if (result.ok && !result.deduplicated) {
+          await persistTransition(backend, input.runId, result.messages);
+          run.pendingStageMessages = [...result.messages];
+          context.bumpAndNotify();
+        }
+        return result;
+      });
+    },
+    async recordPendingStageMessageDeliveries(runId, messageId, records, deliveredAt, backend) {
+      return await serialize(runId, async () => {
+        const run = context.findRun(runId);
+        if (run === undefined)
+          return false;
+        const current = run.pendingStageMessages ?? [];
+        const next = recordPendingStageMessageDeliveries(current, runId, messageId, records, deliveredAt);
+        if (next === current)
+          return false;
+        await persistTransition(backend, runId, next);
+        run.pendingStageMessages = [...next];
+        context.bumpAndNotify();
+        return true;
+      });
+    },
+    async settleStickyPendingStageMessageDelivered(runId, messageId, settledAt, backend) {
+      return await serialize(runId, async () => {
+        const run = context.findRun(runId);
+        if (run === undefined)
+          return false;
+        const current = run.pendingStageMessages ?? [];
+        const next = settleStickyPendingStageMessageDelivered(current, runId, messageId, settledAt);
+        if (next === current)
+          return false;
+        await persistTransition(backend, runId, next);
+        run.pendingStageMessages = [...next];
+        context.bumpAndNotify();
+        return true;
+      });
     }
   };
 }

package/dist/builtin/workflows/builtin/{chunk-fghhy2a5.js → chunk-ed4jfn5t.js}

@@ -9,7 +9,7 @@ import {
   reviewerFailureText,
   summarizeReviewConvergence,
   workflowArtifactDirectoryPath
-} from "./chunk-n58a7v26.js";
+} from "./chunk-b0v2xab1.js";
 import {
   fold_usage
 } from "./chunk-7at6dnkr.js";
@@ -27,6 +27,7 @@ import {
   EVIDENCE_CLOSURE_POLICY,
   FINDINGS_CONSOLIDATION_CONTRACT,
   LITERAL_OBJECTIVE_CONTRACT,
+  MEDIA_PUBLICATION_GUIDANCE,
   REGRESSION_EVIDENCE_CONTRACT,
   REPO_INTENT_MINING_GUIDANCE,
   REVIEWER_CALIBRATION_RULES,
@@ -41,7 +42,7 @@ import {
   keepContext,
   renderE2eQaVideoReviewGuidance,
   withSteeringPropagationContext
-} from "./chunk-0x6e303p.js";
+} from "./chunk-zbekjqew.js";
 
 // dist/builtin/workflows/builtin/goal.ts
 import { Type as Type2 } from "typebox";
@@ -112,8 +113,13 @@ var reviewDecisionSchema = Type.Object({
 
 // dist/builtin/workflows/builtin/goal-models.ts
 var orchestratorModelConfig = {
-  model: "anthropic/claude-opus-5:high",
+  model: "openai-codex/gpt-6-astra:high",
   fallbackModels: [
+    "github-copilot/gpt-6-astra:high",
+    "openai/gpt-6-astra:high",
+    "anthropic/claude-fable-5-1:high",
+    "github-copilot/claude-fable-5-1:high",
+    "anthropic/claude-opus-5:high",
     "github-copilot/claude-opus-5:high",
     "openai-codex/gpt-5.6-sol:xhigh",
     "github-copilot/gpt-5.6-sol:xhigh",
@@ -136,6 +142,8 @@ var orchestratorModelConfig = {
     "zai-coding-cn/glm-5.3-flash:high",
     "baseten/zai-org/GLM-5.3:high",
     "baseten/zai-org/GLM-5.3-Flash:high",
+    "openrouter/openai/gpt-6-astra:high",
+    "openrouter/anthropic/claude-fable-5-1:high",
     "openrouter/anthropic/claude-opus-5:high",
     "openrouter/openai/gpt-5.6-sol:xhigh",
     "openrouter/anthropic/claude-fable-5:high",
@@ -150,8 +158,13 @@ var orchestratorModelConfig = {
   excludedTools: ["ask_user_question"]
 };
 var reviewerModelConfig = {
-  model: "anthropic/claude-opus-5:high",
+  model: "openai-codex/gpt-6-astra:xhigh",
   fallbackModels: [
+    "github-copilot/gpt-6-astra:xhigh",
+    "openai/gpt-6-astra:xhigh",
+    "anthropic/claude-fable-5-1:high",
+    "github-copilot/claude-fable-5-1:high",
+    "anthropic/claude-opus-5:high",
     "github-copilot/claude-opus-5:high",
     "anthropic/claude-fable-5:high",
     "github-copilot/claude-fable-5:high",
@@ -174,6 +187,8 @@ var reviewerModelConfig = {
     "zai-coding-cn/glm-5.3-flash:high",
     "baseten/zai-org/GLM-5.3:high",
     "baseten/zai-org/GLM-5.3-Flash:high",
+    "openrouter/openai/gpt-6-astra:xhigh",
+    "openrouter/anthropic/claude-fable-5-1:high",
     "openrouter/anthropic/claude-opus-5:high",
     "openrouter/anthropic/claude-fable-5:high",
     "openrouter/openai/gpt-5.6-sol:xhigh",
@@ -702,7 +717,7 @@ function renderReviewerPrompt(args) {
     ["project_guidance", [
       "Apply AGENTS.md/CLAUDE.md and nearby code, test, script, config, generated-artifact, and CI conventions; specific project guidance overrides general guidance.",
       "Choose the smallest relevant targeted tests, lint, typecheck, build, generated checks, CI-equivalent scripts, or user-flow proof from repository evidence.",
-      "When dependencies or tools are missing, use repository-approved setup commands rather than bypassing or mocking checks. After reasonable recovery fails, record the limitation in overall_explanation and reviewer_error and do not approve."
+      "For missing required validation dependencies, use repository-approved setup when the environment permits rather than bypassing or mocking checks. If required evidence remains unavailable after reasonable recovery or a known restriction, record the limitation in overall_explanation and reviewer_error and do not approve. An unavailable optional mechanism alone is not a blocker when adequate objective-relevant proof and authoritative checks are present."
     ].join(`
 `)],
     ["finding_contract", [
@@ -1088,6 +1103,9 @@ async function runGoalWorkflow(ctx, options) {
     ];
     const prResult = await ctx.task("pull-request", {
       prompt: taggedPrompt([
+        ["e2e_verification", E2E_VERIFICATION_GUIDANCE],
+        ["code_quality_verification", CODE_QUALITY_VERIFICATION_GUIDANCE],
+        ["media_publication", MEDIA_PUBLICATION_GUIDANCE],
         [
           "final_report",
           [