@automatalabs/workflows 0.48.1 → 0.50.0

package/dist/mcp-server.js

@@ -26205,6 +26205,7 @@ var JSONRPCErrorResponseSchema = object2({
   })
 }).strict();
 var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
+var isJSONRPCError = isJSONRPCErrorResponse;
 var JSONRPCMessageSchema = union([
   JSONRPCRequestSchema,
   JSONRPCNotificationSchema,
@@ -32487,7 +32488,7 @@ var workflowRunLimitsSchema = external_exports.object({
 var authContextSchema = external_exports.object({
   backendId: external_exports.string().optional(),
   methods: external_exports.array(
-    external_exports.object({ id: external_exports.string(), type: external_exports.enum(["agent", "terminal", "env_var"]), name: external_exports.string().optional() })
+    external_exports.object({ id: external_exports.string(), type: external_exports.enum(["agent", "terminal"]), name: external_exports.string().optional() })
   )
 });
 var checkpointContextSchema = external_exports.object({
@@ -33078,7 +33079,7 @@ function callKey(scope, callIndex) {
 }
 
 // ../mcp-server/src/generated/authoring-prompt-content.ts
-var AUTHORING_PROMPT_CONTENT = '# Writing AgentPrism workflow scripts\n\nA workflow script is plain JavaScript, passed around as a **string**, not a module. The engine runs it in a deterministic sandboxed realm. Each `agent()` call opens a session on an [Agent Client Protocol](https://agentclientprotocol.com) (ACP) backend \u2014 Claude Code, OpenAI Codex, OpenCode, pi, or a custom ACP agent server. The backend runs its own tool loop to completion and returns final text or a schema-validated object. One script can mix backends per call.\n\nThe **Workflow script reference** section at the end of this document holds the exhaustive option tables, routing grammar, and error codes.\n\n## The guide, by task\n\nEvery section of the guide is inlined below, after the core: Running workflows (the MCP server and `workflow` tool), backends and structured output, composition and failure, quality helpers and checkpoints, the execution environment, determinism and resume, and worked examples with validation.\n\n## The mental model\n\n- **The script is the orchestrator; agents are workers.** All control flow \u2014 loops, fan-out, dedup, aggregation, conditionals \u2014 lives in script code. Agents cannot spawn agents and cannot see each other. Give each agent one self-contained task.\n- **Each `agent()` call opens a fresh session with no memory.** Interpolate everything a later call needs into its prompt. (Sole exception: resume can continue the same usage/auth-interrupted occurrence \u2014 see Determinism and resume.)\n- **Agents are real coding agents, not chat completions.** They have file access, shells, and tools, rooted at the run\'s working directory. "Read the failing test and fix it" is a valid prompt; the agent will edit files.\n- **The DSL primitives are realm globals, not imports.** There is nothing to `import` \u2014 `agent`, `parallel`, `pipeline`, `gate`, `checkpoint`, `args`, \u2026 are injected. Top-level `await` and a top-level `return` are valid. The script\'s return value becomes the run\'s `result`.\n- **Scripts are plain JavaScript, not TypeScript.** Type annotations fail to parse. The realm has no Node APIs (no `require`, `import`, `fs`, `fetch`, timers). All side effects happen through agents.\n- **Live observability needs no script annotations.** Journaling runs publish redacted progress and transcript upserts at `workflow://runs/{runId}/events`. Author labels for human correlation, not to enable this behavior.\n\n## Minimal script\n\n```js\nexport const meta = {\n  name: "repo-summary",\n  description: "Summarize what a repository does",\n};\n\nconst summary = await agent(\n  `Read the README and the package manifests under ${args.path}, then ` +\n  `summarize what this project does in five sentences.`,\n  { label: "summarize" },\n);\nreturn { summary };\n```\n\nRun scripts through the MCP server\'s `workflow` tool \u2014 registration, the run/await/inspect/stop actions, and the `args`/`cwd` globals are covered in the **Running workflows** section below.\n\n## Pre-flight checklist\n\n- [ ] `export const meta = { name, description }` is the first statement, a pure literal.\n- [ ] No `Date.now()` / `Math.random()` / no-arg `new Date()` / `Date()`; no imports, no Node APIs. Timestamps and randomness come in through `args`.\n- [ ] Every `parallel` element is a **thunk**; results are `.filter(Boolean)`-ed or null-checked.\n- [ ] Every prompt is self-contained: prior results are interpolated in, and every file path a prompt references was written by an earlier call, supplied through `args`, or created by that prompt\'s own instructions.\n- [ ] Schemas: object root, `additionalProperties: false`, everything `required`, a `description` on every field.\n- [ ] Model ids, effort values, and `configOptions` come from `npx @automatalabs/workflows config` or a validator report, never from memory. `mode` only on calls with a pinned `model`.\n- [ ] Worktree-isolated agents return their work as data \u2014 their edits are discarded when the call ends.\n- [ ] Replay is intentional: completed calls with matching identity and input fingerprints replay. Change a hashed field (normally the prompt) when a completed call must run again.\n- [ ] Loops terminate on bounds the script controls; caps and drops are `log()`-ed, not silent.\n- [ ] `checkpoint()` guards irreversible actions, with a sane headless `default` or an intentional `headless: "pause"`.\n- [ ] `return` a compact, structured result \u2014 it is the run\'s `result`, not a transcript.\n- [ ] `npx @automatalabs/workflows validate <file> --args \'<json>\'` exits 0 with no surprising warnings.\n\nFor the complete `agent()` option table, model-routing grammar, checkpoint options, error codes, `meta.backends` config fields, and the MCP tool input shapes, see the **Workflow script reference** section below.\n\n\n## Running workflows \u2014 the MCP `workflow` tool\n\nAgents run workflows through the `workflow` tool served by `@automatalabs/mcp-server` (the server also registers a separate `repl` tool for interactive REPL orchestration, out of scope here). Register it once in the host\'s MCP configuration (project-scoped is typical):\n\n```json\n{ "mcpServers": { "agentprism-workflows": { "command": "npx", "args": ["-y", "@automatalabs/mcp-server@latest"] } } }\n```\n\nThe stdio command the host spawns is a thin **shim**. It proxies to a shared per-user **workflow daemon** (Streamable HTTP on loopback, auto-started on first use). Runs execute in the daemon, so they survive session end, host restarts, and tool timeouts; only daemon exit can interrupt in-flight work. Any later session can await, inspect, or stop a run. Runs, journals, and logs persist under `~/.agentprism/workflows/` per project namespace.\n\nEvery `run` call names its project with the required `projectDir` argument \u2014 an absolute path, normally the workspace root. One registration serves every project. `inspect`/`await`/`stop` take only a `runId`; the runId locates its project store automatically. Add `--in-process` to the args for the pre-daemon single-process behavior (`projectDir` is then optional), or register the daemon\'s HTTP endpoint directly in HTTP-capable hosts (`agentprism-workflow daemon url` prints snippets). The command resolves at spawn time, so a reconnect (`/mcp` in Claude Code) picks up the latest published version.\n\n### The `workflow` tool, by action\n\n- **Run** (default, no `action`): supply exactly one of `script` (the raw source string, no Markdown fences) or `scriptPath` (an absolute path on the server\'s filesystem), plus `projectDir`. A path is read once at admission and its content snapshotted; later edits affect only a new run. `args` arrives in the script as the `args` global; the run\'s base directory is the `cwd` global. Some hosts hand `args` through as a JSON **string** \u2014 tolerate both shapes (`typeof args === "string" ? JSON.parse(args) : args`). Foreground streams progress but is bound to the request and its timeout. Pass `background: true` for anything that may outlive one request; it acknowledges after durable admission with a `runId`.\n- **Await** (`{ action: "await", runId, waitMs }`): bounded collection for background runs. A timeout is progress, not failure \u2014 call again (`waitMs: 20000` is typical). At terminal status the response adds `outcome`: the authored result or pause context, plus `replayEligibility`, `resumeReport`, `fallbacks`, and `checkpointsTaken`.\n- **Inspect** (`{ action: "inspect", runId, lastN, labelGlob, logLines }`): a bounded snapshot \u2014 the latest matching calls with compact result previews plus the newest log lines. Use a narrow `labelGlob` to diagnose before deciding whether to resume, edit, or stop. Inspection never executes or resumes a script.\n- **Stop**: `{ action: "stop", runId }` durably aborts the whole run and returns its final snapshot; stopping a terminal run is a successful no-op. `{ action: "stop", runId, callIndex }` cancels exactly that in-flight agent: its slot settles to `null` with `AGENT_CANCELLED` and the run stays live. `labelGlob` only filters the returned snapshot; it never selects what to cancel.\n- **Resume**: a NEW run with `resumeFromRunId` plus the script content re-sent (the same `script` or `scriptPath`) and the desired `args` (+ `checkpointReplies` when answering a durable checkpoint). Read the returned `replayEligibility` for the predicted and observed replay prefix; never assume a prefix hit. Full semantics: **Determinism and resume**.\n\n### Operating rules\n\n- **Always retain the returned `runId`.** A paused, failed, or aborted response carries a redacted final-20 `logTail`. Read it before you change anything. Every admitted script is also an immutable resource at `workflow://runs/{runId}/script`, so a later session can recover a lost inline script.\n- **Two fingerprints control replay.** The identity hash covers the prompt, the resolved model, `mode` when set, non-empty sorted `configOptions`, `tier`, `phase`, `agentType`, the resolved agent definition, and the schema. The input fingerprint covers the resolved label, per-call `cwd` and isolation, `keepSession`, images, MCP servers, session/prompt metadata, and the approved script-backend digest.\n- **Operational bounds are not replay inputs.** Host `concurrency`, `agentRetries`, and `agentTimeoutMs`, plus per-call `timeoutMs` and `retries`, enter neither fingerprint. A resume does not inherit them from its source run; pass the values you want on every run. `agentTimeoutMs` caps the wall-clock time of each attempt; it is not an idle timer. A per-call `timeoutMs` can tighten that ceiling but cannot escape it. Each retry gets a fresh clock, so the envelope is `(resolved retries + 1) \xD7 resolved timeout`, with retries clamped to 3.\n- **Old journals stay usable.** Input formats below 2 replay positionally with `fallbackReason: "inputs-format-legacy"`. A current-format crash snapshot uses identity matching even without terminal-environment capture. Ancestor-scoped rows carried from \u22640.23 resume chains replay only while that ancestor run is still persisted. Journals resume across filesystem, environment, engine, Node, and V8 changes; `replayEligibility` reports those differences as diagnostics, never as gates.\n- **A background start returns immediately.** It sends no progress after it returns; collect progress with later bounded awaits. Background runs have no live checkpoint channel, so authored `headless` checkpoint modes apply. When a run\'s owner process dies, cold preflights reconcile stale `pending`/`running` state to `paused` with `pauseReason: "interrupted"`; a live owner is left alone.\n- A run paused with `reason: "auth_required"` resumes as a new run after you log in the backend\'s own CLI out of band.\n\n### Execution logs \u2014 the events resource\n\nEvery journaling run publishes an MCP resource at `workflow://runs/{runId}/events`. Subscribe to the canonical URI for advisory `resources/updated` hints, then read and paginate with `after`, `limit`, and `streamId`. Progress is coarse and redacted: `agentTranscript` rows are assistant/tool upserts partitioned by `(scope, callIndex, executionStartSeq)` and reduced by greatest revision per entry index. The durable cursor is authoritative when hints coalesce or a subscriber falls behind.\n\nEmbedding hosts can drive the same contract with `runDynamicWorkflow` / `WorkflowManager` from `@automatalabs/workflows`; the script contract is identical either way.\n\n## Choosing the agent for each call\n\nThe backend is selected **per `agent()` call** from its effective `model` string. One script can plan on one vendor\'s agent, implement on another\'s, and review on a third\'s, handing structured results between them.\n\nThe built-in names (`claude`, `codex`, `opencode`, `pi`) come from the runtime backend registry. Registered custom names extend that set.\n\n- **Omit `model` entirely** for maximum portability \u2014 the call runs on whatever default backend the host configured (`AGENTPRISM_DEFAULT_BACKEND`, or the host\'s session model). A script with no model specs anywhere runs unchanged on any backend.\n- **Route by one registered first segment.** Split on the first `/`; ASCII-case-insensitive `claude`, `codex`, `opencode`, `pi`, or a registered custom backend name selects that harness and is stripped exactly once. A custom registration wins on a built-in-name collision.\n- **Use a backend name alone** (`claude`, `codex`, `opencode`, `pi`, or a custom name) to preserve the harness\'s configured default model. No model config call is made.\n- **Everything else goes intact to the default backend.** `anthropic/\u2026`, `openai/\u2026`, bare `opus`, and bare `gpt-\u2026` are not routing aliases. When an id remains after routing, it is sent byte-for-byte: no catalog matching, case folding, bracket parsing, effort/Fast option driving, retry, or fallback. Harness rejection is an agent error.\n- **`tier`** (`"small" | "medium" | "big"`) is a coarse alternative resolved from the host\'s tier config \u2014 use it for "a cheap model" without naming a vendor.\n\nThe published examples use ids verified against live harness catalogs: `claude/opus[1m]`, `codex/gpt-5.6-sol`, and `opencode/zai/glm-5.2`. For Pi, `pi/openrouter/vendor/model-id` strips only `pi/`; Pi then splits provider `openrouter` from model id `vendor/model-id`. Prefer backend-only forms when the desired model is configured inside the harness.\n\nNever guess model ids, effort values, or option names from memory \u2014 read the live catalog first:\n\n```bash\nnpx @automatalabs/workflows config                # every routable harness (claude, codex, opencode, pi + registered customs)\nnpx @automatalabs/workflows config codex --json   # one harness, machine-readable\n```\n\nOne no-prompt session per harness, zero tokens: the table lists every negotiable session option \u2014 model ids (including bracket variants like `opus[1m]`), effort levels, modes \u2014 exactly as the installed harness advertises them. One caveat: the bare `config` probe reads each harness with its **default model** selected, and option domains are **model-specific**. An option can appear only after a particular model is selected. Ceilings differ per model. Provider-served variants of the same model can advertise different domains. The authoritative per-model probe is the validator run on your real script: it selects each authored `{ backend, model }` pair first and echoes that pair\'s advertised table. Confirm every pinned model against its own echoed table; do not read package internals to discover options.\n\n```js\nconst plan   = await agent(PLAN_PROMPT,          { label: "plan",      model: "opencode/zai/glm-5.2", schema: PLAN });\nconst impl   = await agent(implPrompt(plan),     { label: "implement", model: "codex/gpt-5.6-sol" });\nconst review = await agent(reviewPrompt(impl),   { label: "review",    model: "claude/opus[1m]", schema: REVIEW });\n```\n\nUse `configOptions` only for exact ACP session options advertised by that routed harness. Read the per-harness advertised-options table first \u2014 `npx @automatalabs/workflows config <harness>`, or the same table in every validator report \u2014 before choosing ids or select values; catalogs vary by harness version, login, and machine.\n\n```js\nconst impl = await agent(implPrompt(plan), {\n  label: "implement",\n  model: "codex",\n  configOptions: { "fast-mode": true, reasoning_effort: "high" },\n});\n```\n\nIds and string/boolean values pass through verbatim in ascending id order, after model selection and before the prompt. There are no aliases, coercion, client-side vocabulary, defaults, or cached catalogs. Copy option ids character-for-character from the catalog, punctuation included \u2014 `"fast-mode"`, not `fast_mode` \u2014 and quote ids that are not valid identifiers. Never put `"model"` in `configOptions`; use the dedicated `model` field. A harness rejection follows the ordinary agent-error path.\n\nPi\'s thought-level option is named `thinkingLevel`, and its choices depend on the exact model in the same call:\n\n```js\nconst review = await agent(REVIEW_PROMPT, {\n  label: "pi-review",\n  model: "pi/openrouter/vendor/model-id",\n  configOptions: { thinkingLevel: "high" },\n});\n```\n\nValidation selects `openrouter/vendor/model-id` before reading Pi\'s choices. A listed value passes unchanged. A recognized value above an ordered model\'s ceiling, or in a model-specific gap, passes with a warning that names the effective clamp target. Pi advertises its SDK-derived domain directly. Claude and Codex are also ordered: when their options omit domain metadata, validation enumerates the advertised models and merges their per-model effort orders. A Claude model without an `effort` option does not support effort, and `default` never becomes a ceiling target. OpenCode and custom backends have no declared value order, so validation is exact-set. An unrecognized or unadvertised value fails with exit code `2`. Enumeration stops at 32 advertised models; a larger or inconsistently ordered catalog warns and falls back to exact advertised-value validation.\n\n**The harness is authoritative.** The client never substitutes a nearby model or silently falls back. A rejected id follows the existing agent-error path; a harness that accepts or ignores it determines the outcome. The public `fallbacks`/`onModelFallback` fields remain for compatibility but model resolution does not emit them.\n\n## Structured output\n\nPass `schema` \u2014 a **plain JSON Schema object literal** (no schema builders exist inside the realm) \u2014 and the call resolves to a **validated object** instead of text:\n\n```js\nconst FINDINGS = {\n  type: "object",\n  additionalProperties: false,\n  required: ["findings"],\n  properties: {\n    findings: {\n      type: "array",\n      items: {\n        type: "object",\n        additionalProperties: false,\n        required: ["file", "line", "summary"],\n        properties: {\n          file:    { type: "string", description: "Repo-relative path \u2014 copy it exactly, never invent one" },\n          line:    { type: "number", description: "1-indexed line the finding anchors to" },\n          summary: { type: "string", description: "One sentence stating the defect, grounded in code you actually read" },\n        },\n      },\n    },\n  },\n};\n\nconst report = await agent("Review the diff on this branch for correctness bugs.", {\n  label: "review", schema: FINDINGS,\n});\nreport.findings.forEach((f) => log(`${f.file}:${f.line} ${f.summary}`));\n```\n\nThe same schema works on **every** backend; only the fulfillment channel differs, and the runner picks it for you: Claude uses its `outputFormat`, Codex its strict `outputSchema`, while Pi, OpenCode, and eligible custom ACP agents receive a client-hosted `StructuredOutput` MCP tool when they advertise HTTP MCP support. Pi accepts stdio, Streamable HTTP, and SSE MCP servers. If no valid tool capture exists, Pi retains the runner\'s common prompt-embedded schema and validated final-text JSON fallback. In every channel the runner validates the value client-side (with type coercion) and re-prompts a bounded number of times before failing the call with non-recoverable `SCHEMA_NONCOMPLIANCE`.\n\nSchema authoring rules that keep all channels healthy:\n\n- Root must be an object; set `additionalProperties: false` and list every property in `required`.\n- Put a `description` on every field \u2014 descriptions are the per-field prompt.\n- Keep schemas structurally simple. Exotic keywords (`oneOf`, `patternProperties`, unusual `format`s, backreference regexes) are normalized or stripped on the wire for some backends \u2014 validation still enforces them client-side, which shows up as re-prompt churn. Prefer `anyOf`, `enum`, and plain types.\n- Keep free-text fields small (tens of lines). An oversized structured output can exhaust schema repair and fail the call.\n- Validation checks structure, not truth. Check load-bearing values in script code (for example, reject findings whose `file` is not in a known file list) before spending more agents on them.\n\n## The `meta` header\n\nEvery script must **begin** with `export const meta = {...}` as a plain object literal (no computed values \u2014 it is parsed from the source text before anything runs):\n\n```js\nexport const meta = {\n  name: "fix-flaky-tests",                        // required\n  description: "Find flaky tests and fix them",   // required\n  phases: [                                        // optional; one { title, detail?, model? } entry\n    { title: "Find", model: "opencode/zai/glm-5.2" },  // per phase() call, matched by exact title;\n    { title: "Fix" },                                  // a phase model is that phase\'s default\n  ],\n  model: "claude/sonnet",                          // optional run-wide default model\n  backends: { /* optional custom ACP agents \u2014 see "Custom ACP backends" */ },\n};\n```\n\nPer-agent model resolution order: explicit `agent({ model })` > `agent({ tier })` > the current phase\'s `model` > `meta.model` > the host session\'s default. So `meta.phases[].model` gives a whole phase a backend without repeating it on every call.\n\n## Fan-out: `parallel` and `pipeline`\n\n```js\n// parallel: an array of THUNKS (not promises!) run concurrently \u2014 a barrier that\n// resolves in input order. A failed slot resolves to null; filter before use.\nconst sweeps = (await parallel([\n  () => agent("Audit error handling in src/server", { label: "sweep:errors", schema: FINDINGS }),\n  () => agent("Audit input validation in src/api",  { label: "sweep:input",  schema: FINDINGS }),\n])).filter(Boolean);\n\n// pipeline: each item flows through the stages independently \u2014 NO barrier between\n// stages, so item A can be in stage 2 while item B is still in stage 1.\n// Stages receive (previousResult, originalItem, index).\nconst verified = (await pipeline(\n  sweeps.flatMap((s) => s.findings),\n  (f) => agent(`Adversarially verify this finding \u2014 try to refute it:\\n${JSON.stringify(f)}`,\n               { label: `verify:${f.file}`, schema: VERDICT }),\n  (verdict, f) => ({ ...f, real: verdict.real }),\n)).filter(Boolean).filter((f) => f.real);\n```\n\n**Default to `pipeline`** for multi-stage work. Add a `parallel` barrier only when the next stage needs *all* prior results at once: dedup across the full set, early-exit on a zero count, or prompts that compare "the other findings". The test is the **information dependency** \u2014 a barrier\'s cost is real, because the fastest worker idles for the slowest. All coordination lives in script code: agents cannot see each other, so never ask an agent to "check with the other reviewers" or "spawn helpers". Passing a promise instead of a thunk to `parallel` is a `TypeError` \u2014 wrap every call: `() => agent(...)`.\n\nFan-out also contends for the **working tree**, not just the concurrency limiter. Two agents running builds or test suites in the same checkout collide on build outputs, caches, and lockfiles, and concurrent `git fetch`es contend on the same `.git`. Give run-things agents `isolation: "worktree"` when the commits they must inspect are reachable from the run cwd\'s repository, or serialize them; fan out freely only the agents that just read.\n\nThe host caps concurrent agents per run (default 8); hand `parallel`/`pipeline` as many items as the task needs and let the limiter schedule them. The cap counts active agent attempts, not authored branches: queued branches begin as other attempts finish, and a branch that exhausts its timeout settles to `null` and frees its slot. `workflow(nameOrScript, args)` nests another workflow inline (one level deep, sharing this run\'s limiter) \u2014 inline script strings always work; saved names resolve when the host serves a workflows folder (see the reference section below).\n\n## Failure semantics \u2014 design for `null`\n\n- A **recoverable** failure (timeout, empty output, transient execution error) is retried per the call\'s `retries` (default 0), then the call **resolves to `null`** \u2014 inside `parallel`/`pipeline` *and* as a bare `await agent(...)`. Null-check anything load-bearing, and set `retries: 1\u20132` on steps you can\'t afford to lose.\n- A host can settle one runaway in-flight call with MCP `{ action: "stop", runId, callIndex }` or SDK `manager.cancelAgentCall(runId, callIndex)`. The call resolves to `null` with `AGENT_CANCELLED`, skips every configured retry, and does not abort the run or its siblings. Its failed call record is not cached as a journal result, so a later resume runs that occurrence live.\n- A **non-recoverable** failure (schema never validated, script bug) throws and fails the run. You *may* `try/catch` around an `agent()` call to degrade gracefully \u2014 rethrow anything you can\'t meaningfully handle. In particular, **always rethrow pause-class errors** (`err.code === "PROVIDER_USAGE_LIMIT"` or `"AUTH_REQUIRED"`): they must propagate out of the script so the engine can pause the run resumably \u2014 swallowing one converts that pause into a fake, lossy completion.\n- A **provider quota wall, missing backend authentication, or opted-in durable checkpoint pauses a managed run instead of failing it** \u2014 the journal checkpoints and the host can resume after the provider quota refills, authentication completes, or a checkpoint decision is supplied. Direct `runner.run()` calls still receive the `AUTH_REQUIRED` error because they have no manager lifecycle.\n- Per-call knobs: `timeoutMs` and `retries`. A finite `timeoutMs` may shorten the host\'s run-level `agentTimeoutMs` ceiling; `null` or omission is uncapped only when the host supplied no ceiling. The timeout is total wall-clock time per attempt, and every retry gets a fresh clock.\n\n## Phases\n\n```js\nphase("Explore");   // open a named phase: subsequent agents group under it\n\nconst found = [];\nwhile (found.length < 20) {\n  const r = await agent("Find one more edge case not in: " + JSON.stringify(found.map((f) => f.name)),\n                        { label: `edge:${found.length}`, schema: EDGE });\n  if (!r) break;\n  found.push(r);\n}\n```\n\nTerminate every loop on a bound the script controls. The agent-count limit (`maxAgents`) is hard: once exhausted, further `agent()` calls throw `AGENT_LIMIT_EXCEEDED`. `phase()` groups agents in progress UIs and run logs; `log(msg)` (and `console.log`) append to the run log \u2014 narrate what matters, especially anything you drop.\n\n## Built-in quality loops\n\nThese helpers spawn their own subagents (on the default model \u2014 hand-roll with `parallel` + `agent` when you want panel members on specific backends). Full signatures in the reference section below.\n\n| helper | shape | use for |\n|---|---|---|\n| `gate(produce, validate, { attempts })` | produce \u2192 validate \u2192 feed `feedback` back; return `{ ok, value, verdict, attempts }` | produce-until-a-reviewer-approves loops that need the final review evidence |\n| `retry(thunk, { attempts, until })` | bounded retry until `until(result)` holds | flaky single steps |\n| `verify(item, { reviewers, threshold, lens })` | N adversarial reviewers vote `real`/not | killing plausible-but-wrong findings |\n| `judgePanel(attempts, { judges, rubric })` | score candidates 0\u20131 against a rubric, return the best | picking among independent solutions |\n| `loopUntilDry({ round, key, consecutiveEmpty, maxRounds })` | repeat a round, dedup by `key`, stop when dry | unknown-size discovery (bugs, edge cases) |\n| `completenessCheck(args, results)` | one critic lists what\'s still missing | a final "what did we not cover?" pass |\n\nThe `gate` pattern, spelled out \u2014 note how the producer thunk threads the validator\'s feedback into a *fresh* agent\'s prompt (sessions have no memory):\n\n```js\nconst outcome = await gate(\n  (feedback, attempt) => agent(\n    `Implement the fix described here:\\n${JSON.stringify(plan)}\\n` +\n    (feedback ? `\\nA reviewer rejected attempt ${attempt}: ${feedback}\\nAddress every point.` : ""),\n    { label: `fix:${attempt + 1}`, model: "codex/gpt-5.6-sol" },\n  ),\n  (result) => agent(\n    `Run the test suite and review this change summary:\\n${result}\\n` +\n    `Return ok=true only if tests pass and the fix is correct; include the reviewed commit SHA.`,\n    { label: "gate-review", model: "claude/opus[1m]", schema: { type: "object", additionalProperties: false,\n      required: ["ok"], properties: { ok: { type: "boolean" }, feedback: { type: "string" },\n        commitSha: { type: "string" } } } },\n  ),\n  { attempts: 3 },\n);\nif (!outcome.ok) log(`reviewer never approved after ${outcome.attempts} attempts`);\nelse log(`reviewer approved commit ${outcome.verdict?.commitSha ?? "(unspecified)"}`);\n```\n\nFeedback is the producer\'s only context for the next attempt. Interpolate everything it needs, and name only files that provably exist.\n\n## Human gates: `checkpoint()`\n\n`checkpoint(promptText, options?)` is a zero-token, journaled human gate. With MCP elicitation (or a live SDK `confirm` callback) it waits for that reply; without a live channel, its default mode takes `default ?? true` immediately, so detached runs never hang.\n\n```js\nconst proceed = await checkpoint(`Apply this plan?\\n${JSON.stringify(plan, null, 2)}`, {\n  kind: "confirm",          // "confirm" | "input" | "select"\n  default: false,           // default headless mode takes this (or true)\n  // headless: "abort",     // abort when no live human is attached\n  // headless: "pause",     // or persist a resumable human-decision pause\n});\nif (!proceed) return { applied: false, plan };\n```\n\n`kind: "input"` resolves to free text, `kind: "select"` to one of `choices`. How the question reaches a human is the host\'s job (elicitation in the MCP server; `ExecOptions.confirm` in the SDK). With no live channel, `headless: "default"` (the default) takes `default ?? true`, `"abort"` aborts, and `"pause"` returns a managed run with `reason: "checkpoint_required"` plus non-secret `checkpointContext`. Resume the last mode with `checkpointReplies: { [context.callIndex]: decision }` or a live confirm. For `resumeFromRunId`, that key is the source context index; an unambiguous identity match may journal the injected answer at a shifted current index. Put a checkpoint before anything hard to reverse \u2014 applying diffs, pushing, publishing, or the first commit into a working copy the workflow did not create (`default: true` keeps detached runs moving).\n\n## Working directory, isolation, confinement\n\n- Every agent session runs in the run\'s base `cwd` unless the call narrows it: `agent({ cwd: "packages/api" })` (relative resolves against the base).\n- `isolation: "worktree"` runs the agent in a **throwaway git worktree** (`<repoRoot>/.agentprism/worktrees/\u2026`) so parallel agents can edit without colliding. The worktree and its branch are **always deleted when the call ends \u2014 an isolated agent\'s file edits are discarded**. Have isolated agents *return their work as data* (a unified diff, a file map, a report) and apply it in a later non-isolated step; use worktrees for experiments, builds, and verification, not for persistent edits. Outside a git repo, isolation degrades to the shared tree with a logged notice.\n- `resume: { filesystem: "read-only" }` is a deprecated compatibility annotation. It is not a runner mode and has no effect on replay; completed calls replay by journal correspondence whether they read or write. Use `mode`, tool policy, prompts, and worktrees when you actually need confinement.\n- `mode` requests an agent-advertised ACP session mode and is **strict** \u2014 an unsupported mode fails the call rather than running unconfined. Mode ids are backend-specific and drift with harness versions: read the advertised `mode` select from `npx @automatalabs/workflows config <harness>` or a validator report (Codex-family examples: `read-only`, `agent`; Claude-family advertises permission modes such as `plan` and `acceptEdits`; OpenCode via its mode option; Pi advertises thinking-level config rather than modes). Only set `mode` on calls whose `model` you also pin. Use read-only/plan modes for reviewers and auditors that must not write.\n- `agentType: "<name>"` binds a reusable subagent definition \u2014 a Markdown file at `<cwd>/.agentprism/agents/<name>.md` (project) or `~/.agentprism/agents/<name>.md` (user; project wins) whose frontmatter sets tool allow/deny lists, a model, and isolation, and whose body is the role prompt. An unknown name logs a warning and degrades to defaults.\n\n## Where a mutating workflow runs\n\nThe run\'s base `cwd` is the USER\'S checkout \u2014 the working copy they launched the host from. Treat it as borrowed: committing onto whatever branch is checked out, switching branches, or resetting it are defects unless the user asked for exactly that. A script that commits should verify its target workspace in a preflight step, or create its own workspace idempotently, and refuse on a mismatch rather than adapt. `isolation: "worktree"` is NOT such a workspace \u2014 it is per-call and throwaway. Note also that a throwaway worktree branches from the run cwd\'s repository: an isolated agent sees another agent\'s commits only when they are reachable there.\n\n## Wiring tools and inputs into a call\n\n- `mcpServers: [{ name, command, args: [], env: [] }]` attaches MCP servers to that agent\'s session \u2014 the portable way to hand any backend a capability (image generation, a browser, a ticket system). The agent sees the server\'s tools natively. Note `env` is a list of `{ name, value }` pairs (ACP shape), not an object map; HTTP/SSE servers use `{ type: "http", name, url, headers: [] }`.\n- `images: [...]` appends base64 image blocks to the prompt (backends without image support receive a bracketed text note instead).\n- `meta` / `promptMeta` pass generic ACP `_meta` through to `session/new` / `session/prompt` \u2014 the escape hatch for driving a custom agent\'s extension surface.\n- `keepSession: true` keeps a successful agent\'s ACP session re-openable after the run: the re-attach record (sessionId, backend, effective pool identity, cwd, reopen capabilities) lands in `WorkflowRunResult.agentSessions`, and the HOST can continue that conversation later via `runner.loadSession()`. Usage/auth pause failures are kept open automatically so managed resume can continue the interrupted occurrence. Scripts themselves never request reattach.\n\n### Custom ACP backends\n\nAny process that speaks ACP over stdio can serve `agent()` calls \u2014 an in-house browser-QA agent, an image generator, a domain-specific executor. Two ways in:\n\n1. **Host-registered** (preferred): the embedder passes `createAcpRunner({ backends: { browser: { command: "/abs/browser-acp" } } })`; the script just routes with `model: "browser"`.\n2. **Script-declared**: the script itself declares the backend in `meta.backends` \u2014 but declarations are **inert until the host approves them** (an elicitation in the MCP server; `allowScriptBackends` in the SDK), because they spawn commands on the host machine. Don\'t rely on them silently working.\n\n```js\nexport const meta = {\n  name: "checkout-qa",\n  description: "Implement, then QA the checkout flow in a real browser",\n  backends: {\n    browser: { command: "browser-acp", args: ["--headless"] },  // requires host approval\n  },\n};\n\nconst change = await agent("Implement the coupon-code field per the spec in docs/coupon.md.",\n                           { label: "implement" });              // default backend\nconst verdict = await agent(\n  `Open the app, walk through checkout with coupon SAVE20, and verify the discount line. Change summary:\\n${change}`,\n  { label: "qa", model: "browser",                               // the custom agent\n    schema: { type: "object", additionalProperties: false, required: ["passed"],\n              properties: { passed: { type: "boolean" }, notes: { type: "string" } } } },\n);\nreturn { change, qa: verdict };\n```\n\nStructured output works on custom backends through the same injected-tool/fallback ladder as OpenCode \u2014 no special-casing in the script.\n\n## Determinism and resume\n\nRuns are journaled: every `agent()` and `checkpoint()` result is recorded under a deterministic call index. A new run may reuse eligible results from a terminal source run. Uncertainty always means live execution.\n\n> **Resume rule:** replay is content-addressed and fail-to-live on correspondence: a completed call replays when its identity and input fingerprint match uniquely. Filesystem or world state never gates replay.\n\n- Direct `Date.now()`, `Math.random()`, and no-arg `new Date()` / `Date()` calls fail static validation. The realm also blocks aliased or computed forms at runtime; `new Date(isoString)` is fine. Pass timestamps and random seeds through `args`.\n- The replay identity of an `agent()` call hashes: the prompt, the resolved `model`, `mode` when set, `configOptions` when non-empty (sorted keys), `tier`, `phase`, `agentType`, the resolved agent definition, and `schema`. The resolved agent definition includes its tool allowlist and denylist, model, isolation, and body prompt \u2014 editing a definition invalidates the calls that use it.\n- A separate input fingerprint hashes: the resolved label, per-call `cwd`, resolved isolation, `keepSession`, `images`, `mcpServers`, `meta`, `promptMeta`, and the approved script-backend digest.\n- Host `agentTimeoutMs`, `agentRetries`, and `concurrency`, plus per-call `timeoutMs` and `retries`, are operational bounds. They enter neither hash and may change freely on resume. A new run resolves them from its own request; it does not inherit the source values.\n- `args` is not hashed directly. New args that only raise a loop cap leave earlier identities unchanged, so those calls can replay. New args that change a prompt, model selection, phase, schema, call order, or runner-visible input make the affected calls run live. Unchanged independent calls may still replay.\n- Matching tries a unique exact `(kind, call path, identity hash)` row first (`"path-hash"`), then a unique `(kind, identity hash, input fingerprint)` row, so an unchanged call can replay as `"unique-hash"` after insertions or deletions. Source and current input fingerprints must be equal. Duplicate identities, duplicate content, consumed candidates, missing facts, and empty schema-less results run live. The engine never guesses by source order or occurrence.\n- Source admission requires: exact `cwd`, compatible call-path/input/checkpoint fingerprint formats, complete call/journal/allocation metadata, and a valid manifest and seed. Git HEAD and dirty digest, `environmentKey`, captured environment values, Node/V8, and producing engine version are diagnostics only. Environment differences may appear in `replayEligibility.provenanceChanges`; they never gate admission or matching.\n- A completed writer replays exactly like a reader. A live call, nested workflow, host checkpoint callback, or degraded worktree does not clear unrelated candidates. Nested child calls run live \u2014 they are outside the parent\'s journal \u2014 while matching root calls around them still replay. The engine does not reproduce file writes; a later live agent navigates the world it finds.\n- Replay costs zero current provider usage: a cached call returns its recorded result without spawning a session. Replayed session records keep their backend and session identity, rebound to the current call index, label, and phase.\n- A root call interrupted by `PROVIDER_USAGE_LIMIT` or `AUTH_REQUIRED` can continue its recorded session on either resume API. Continuation requires: the exact call index, identity hash, complete input fingerprint, non-worktree isolation, identical existing cwd, a coherent recorded session, and the runner\'s current backend/`poolKey`/reopen gates. A successful continuation finishes the unfinished turn and charges only its usage delta. Every failed gate runs fresh, and `fallbacks` records the reopen method or the exact skip reason. No script option controls this.\n- Completed checkpoint results replay when the identity and the `default`/`headless`/`timeoutMs` fingerprint match \u2014 headless results included. `checkpointReplies` keys always name the checkpoint index in the source run. A moved reply can follow intact prior correspondence; after a live divergence it must reach the exact recorded call site, so a different same-text branch cannot consume it.\n- `resumePolicy: "positional"` is a migration escape hatch for index/prefix matching. It cannot bypass format, metadata, manifest, cwd, or input checks. Marker-less, manual, and same-ID legacy journals keep historical hash-only positional behavior. Input formats below 2 use the `inputs-format-legacy` positional bridge and are rewritten under the current format on the next hop. A current-format crash snapshot with a valid identity manifest uses identity matching even without terminal-environment capture.\n- `label`, `cwd`, `mcpServers`, `images`, `meta`, `promptMeta`, and `keepSession` are not identity-hashed: changing one does not invalidate an ordinary replay. They are in the input fingerprint: changing one rejects continuation of an interrupted turn, and that occurrence runs fresh. To force a completed call to run again, change a hashed field \u2014 normally the prompt.\n- Keep call order deterministic. Derive iteration from `args` and prior agent results, never from ambient state.\n\nEvery `resumeFromRunId` result has a bounded `replayEligibility` summary. Background admission, foreground completion, both await shapes, and inspect expose the same fields: strategy, predicted replayable-prefix length, observed replayed prefix and counts, and the first non-replay when known. Active correspondence reasons include `strategy-live`, `positional-miss`, `positional-suffix`, `not-recorded`, `path-missing`, `inputs-missing`, `inputs-changed`, `ambiguous-identity`, `ambiguous-content`, `candidate-consumed`, `empty-output`, `worktree-degraded`, `seed-persistence-error`, and `resume-fatal-latch`. Older reason literals stay exported only so historical journals parse. Engine and input-format versions and environment provenance ride along as diagnostics.\n\nAn all-live outcome means correspondence could not be established \u2014 not that the world changed. Missing resume metadata, incompatible format literals, or an invalid manifest or seed disable new-format replay. If any source row lacks a captured path or input fact (possible past the raw-frame cap, or with a non-strict-JSON `meta` value), the whole source is `"manifest-invalid"`: dropping the row could make an ambiguous sibling look unique.\n\n### Worked resume \u2014 raise a loop cap\n\nThe following workflow (shipped as `examples/resume-loop-cap.workflow.js`) requires eight reviews but lets the caller cap how many are attempted in one run:\n\n```js\nexport const meta = {\n  name: "resume-loop-cap",\n  description: "Run expensive review rounds up to an args-controlled cap",\n  phases: [{ title: "Review" }],\n};\n\nconst input = args && typeof args === "object" && !Array.isArray(args) ? args : {};\nconst numericCap = Number(input.maxRounds);\nconst maxRounds = Number.isInteger(numericCap) && numericCap > 0 ? numericCap : 8;\n\nphase("Review");\nconst rounds = [];\nfor (let i = 0; i < maxRounds; i += 1) {\n  rounds.push(\n    await agent(\n      `Review round ${i + 1}: inspect the repository and report unresolved release blockers.`,\n      { label: `review:${i + 1}`, phase: "Review" },\n    ),\n  );\n}\n\nif (maxRounds < 8) throw new Error(`review cap ${maxRounds} reached before 8 rounds`);\nreturn { rounds };\n```\n\nRun it with `args: { "maxRounds": 6 }`. Then send the same content (via `script`, or the absolute `scriptPath` you edit) with `args: { "maxRounds": 8 }` and the first result\'s `runId` as `resumeFromRunId`. Rounds 1\u20136 replay for zero current provider tokens; only rounds 7\u20138 run live, because the cap controls call count but is not interpolated into the round prompt. If every round prompt included `maxRounds`, all eight identities would change and all would run live. Resume always states its content; a bare `resumeFromRunId` never silently reuses the old script.\n\nGive repeated calls stable, descriptive labels and narrate decisions with `log()` \u2014 inspection by `labelGlob` then turns a pause or failure into a diagnosis instead of a guess.\n\n### Kill, patch, resume\n\nStop the live run with `{ action: "stop", runId }`. The returned `aborted` snapshot is the durable acknowledgement: resume is safe immediately, and a further await adds nothing. Edit the file. Start a new run with its absolute `scriptPath` and `resumeFromRunId`. Every completed call whose recorded identity and input fingerprint correspond replays, regardless of filesystem or environment drift. Read `replayEligibility` and the full `resumeReport` for the per-call decisions. A repeated stop of a terminal run is a successful no-op.\n\nRegistration, the per-action contracts, background collection, and the events resource are covered in the **Running workflows** section above. Resume a durable checkpoint pause by re-sending the script with `resumeFromRunId` and `checkpointReplies` keyed by the source run\'s `checkpointContext.callIndex`.\n\n## Worked example \u2014 cross-vendor build with every major primitive\n\n```js\nexport const meta = {\n  name: "feature-build",\n  description: "Plan, gate on approval, implement, cross-vendor review, fix until green",\n  phases: [{ title: "Plan" }, { title: "Implement" }, { title: "Review" }],\n};\n\nconst PLAN = { type: "object", additionalProperties: false, required: ["steps", "risks"],\n  properties: {\n    steps: { type: "array", items: { type: "string", description: "One concrete implementation step" } },\n    risks: { type: "array", items: { type: "string" } } } };\nconst VERDICT = { type: "object", additionalProperties: false, required: ["ok"],\n  properties: { ok: { type: "boolean" },\n                feedback: { type: "string", description: "Required when ok=false: concretely what to change" } } };\n\nphase("Plan");\nconst plan = await agent(\n  `Study this repo, then write an implementation plan for: ${args.feature}. Keep steps concrete.`,\n  { label: "plan", model: "opencode/zai/glm-5.2", schema: PLAN },\n);\n\nconst approved = await checkpoint(\n  `Implement "${args.feature}" with this plan?\\n- ${plan.steps.join("\\n- ")}\\nRisks: ${plan.risks.join("; ")}`,\n  { kind: "confirm", default: true },\n);\nif (!approved) return { implemented: false, plan };\n\nphase("Implement");\nconst outcome = await gate(\n  (feedback, attempt) => agent(\n    `Implement: ${args.feature}\\nPlan:\\n- ${plan.steps.join("\\n- ")}\\n` +\n    `Run the project\'s tests before finishing and report results.` +\n    (feedback ? `\\n\\nReviewer feedback on attempt ${attempt}:\\n${feedback}\\nAddress every point.` : ""),\n    { label: `implement:${attempt + 1}`, model: "codex/gpt-5.6-sol", retries: 1 },\n  ),\n  async (report) => {\n    if (!report) return { ok: false, feedback: "implementation agent produced no result" };\n    phase("Review");\n    const reviews = (await parallel([   // two reviewers on different vendors\n      () => agent(`Review the working-tree diff for correctness. Implementer\'s report:\\n${report}`,\n                  { label: "review:correctness", model: "claude/opus[1m]", schema: VERDICT }),\n      () => agent(`Review the working-tree diff for regressions and missing tests. Report:\\n${report}`,\n                  { label: "review:coverage", model: "opencode/zai/glm-5.2", schema: VERDICT }),\n    ])).filter(Boolean);\n    const rejections = reviews.filter((r) => !r.ok);\n    return rejections.length\n      ? { ok: false, feedback: rejections.map((r) => r.feedback).join("\\n"), reviews }\n      : { ok: true, reviews };\n  },\n  { attempts: 3 },\n);\n\nreturn { implemented: outcome.ok, attempts: outcome.attempts, reviewVerdict: outcome.verdict, plan };\n```\n\n(The planner would ideally run read-only, but mode ids are backend-specific \u2014 this call routes to OpenCode, so it leaves `mode` unset rather than guessing; a Claude-routed planner could safely say `mode: "plan"`.)\n\n## Worked example \u2014 fully backend-agnostic audit\n\nNo `model` anywhere: this script runs unchanged on whatever backend the host defaults to.\n\n```js\nexport const meta = {\n  name: "edge-case-audit",\n  description: "Exhaustively hunt edge-case bugs in a target dir, verify each, report gaps",\n  phases: [{ title: "Hunt" }, { title: "Verify" }],\n};\n\nconst BUGS = { type: "object", additionalProperties: false, required: ["bugs"],\n  properties: { bugs: { type: "array", items: { type: "object", additionalProperties: false,\n    required: ["file", "scenario"], properties: {\n      file: { type: "string", description: "Repo-relative path you actually opened" },\n      scenario: { type: "string", description: "Concrete input/state \u2192 wrong behavior" } } } } } };\n\nphase("Hunt");\nconst seen = [];   // what earlier rounds reported, threaded into each new prompt\nconst candidates = await loopUntilDry({\n  round: async (i) => {\n    const r = await agent(\n      `Round ${i + 1}: find edge-case bugs in ${args.target} not already in this list:\\n` +\n      JSON.stringify(seen) + `\\nOnly report what you can ground in code you read.`,\n      { label: `hunt:${i + 1}`, schema: BUGS },\n    );\n    const bugs = r ? r.bugs : [];\n    seen.push(...bugs);\n    return bugs;      // loopUntilDry dedups these by `key` across rounds\n  },\n  key: (b) => `${b.file}:${b.scenario}`,\n  consecutiveEmpty: 2,\n  maxRounds: 8,\n});\n\nphase("Verify");\nconst confirmed = (await pipeline(\n  candidates,\n  (bug) => verify(bug, { reviewers: 3, threshold: 0.66, lens: ["correctness", "reproducibility"] }),\n  (v, bug) => (v.real ? bug : null),\n)).filter(Boolean);\n\nconst gaps = await completenessCheck(args, confirmed);\nlog(`${confirmed.length}/${candidates.length} confirmed; complete=${gaps.complete}`);\nreturn { confirmed, missing: gaps.missing ?? [] };\n```\n\n## Full-scale example scripts\n\nWhen the inline examples above aren\'t enough, study the complete, validated scripts that ship with the published authoring skill:\n\n- [`repo-triage.workflow.js`](https://github.com/agentprism/agentprism-workflows/blob/main/skills/agentprism-workflow-authoring/examples/repo-triage.workflow.js) \u2014 an autonomous cross-vendor repo triage and the broadest support-API tour: `pipeline` with no inter-stage barrier, a cross-vendor verification panel, `gate()` where writer and reviewer are different vendors, nesting a saved workflow by name, `completenessCheck()`, stage gating on tracked counters, string-form `args` hardening, path guards on schema outputs, and pause-class error rethrow.\n- `quick-wins.workflow.js` (included in full at the end of this document) \u2014 a small hunter that runs standalone *or* nested: `loopUntilDry()` with per-round vendor rotation, dedup threading via a `seen` list, and a tracked round bound (nested runs share the parent\'s limiter).\n- [`resume-loop-cap.workflow.js`](https://github.com/agentprism/agentprism-workflows/blob/main/skills/agentprism-workflow-authoring/examples/resume-loop-cap.workflow.js) \u2014 content-addressed replay: run with a low `maxRounds`, resume with a higher one; unchanged rounds replay for zero tokens (worked through in Determinism and resume).\n\n[`examples/README.md`](https://github.com/agentprism/agentprism-workflows/blob/main/skills/agentprism-workflow-authoring/examples/README.md) maps each script to what it teaches.\n\n## Validate before you run\n\nThe SDK ships a validator that costs **zero tokens** \u2014 always run it on a script you just wrote or edited:\n\n```bash\nnpx @automatalabs/workflows validate my-workflow.js --args \'{"target":"src/"}\'\n```\n\nIt does three passes. First, a **static parse**: the `meta` literal, syntax, and direct\nnondeterministic call expressions. Second, a **dry run**: the engine runs the script\'s control flow\nin its realm, with every `agent()` call served by a mock backend that fabricates\nschema-conforming results \u2014 no real agent runs, and validation is not an execution of the\nworkflow. Third, one no-prompt session for each distinct routed `{ backend, model\n}` pair. The third pass spends no tokens, selects each authored call model, and echoes that pair\'s\nmodel-specific config-options table in the report. Read that table before picking `configOptions`\nvalues; unknown ids, bad select values, wrong value types, and the reserved `"model"` key fail\nvalidation with the call label, authored value, and alternatives. If a routed pair cannot spawn,\nauthenticate, select its model, or open a session, validation emits one warning, marks it\n`probed:false`, skips only that pair\'s checks, and stays valid \u2014 the offline degradation behavior. A\nmock live confirm answers checkpoints with `default ?? true`, so `headless: "pause"` dry-runs\ncleanly; `headless: "abort"` warns because a truly unattended run would abort. Script-declared\n`meta.backends` are treated as approved. The report lists every call with its backend attribution,\nplus warnings for undeclared phases, `headless: "abort"` checkpoints, and zero agent calls.\n(Option-domain clamping rules are in Backends and structured output; the full flag table and\nmock-answer grammar are in `reference.md`.)\n\nThe default fabricator returns `true` for every boolean. Do not accept that all-true path as proof that a convergence loop works: script its control labels with `--mock-answers` or a reusable `--mock-answers-file`. Use a finite `$sequence` such as reject-then-approve so validation executes the revision branch and proves the loop stops; the report identifies every consumed and unused fixture without printing answer bodies.\n\nSave reusable mock answers beside the workflow file (`<name>.mock.json`). When a default-fabrication dry run leaves declared phases unexecuted, your guard branches fired \u2014 script the mocks that reach past them instead of shrugging at the warnings.\n\nExit codes: `0` valid \xB7 `1` parse failure \xB7 `2` dry-run or config-option failure. The full flag table, mock-answers grammar, and limits are in `reference.md`.\n\nThe third pass\'s table is also available standalone \u2014 before any script exists \u2014 as validate\'s sibling command: `npx @automatalabs/workflows config [harness ...]` (default: every routable harness; `--json`; exit `1` when a probe fails). Use `config` while authoring to pick values; validate\'s copy then confirms the script you wrote against the same live catalog.\n\nIf the script nests saved workflows by name (`workflow("review-pr")`), pass the folder so names resolve \u2014 and the positional itself may then be a name: `npx @automatalabs/workflows validate review-pr --workflows-dir ./workflows`. A green dry run proves structure, not judgment \u2014 prompts and schemas still deserve review.\n\n---\n\n# Workflow script reference\n\nExhaustive tables for the AgentPrism workflow script DSL. The guide above covers authoring; this section is the lookup companion. Everything here is verified against `@automatalabs/workflow-engine` / `@automatalabs/acp-agents` as shipped with `@automatalabs/workflows`.\n\n## `agent(prompt, options?)` \u2014 full option table\n\nReturns the agent\'s final assistant text, or the schema-validated object when `schema` is set. Resolves to `null` when a *recoverable* failure survives all retries.\n\n| option | type | meaning |\n|---|---|---|\n| `label` | `string` | Display/telemetry name; also stamped on every live ACP event for this call. Always set it. Not part of the resume hash. |\n| `phase` | `string` | Assign this call to a phase explicitly (needed inside concurrent stages where the global `phase()` state would race). |\n| `schema` | JSON Schema object | Structured output. Plain object literal only \u2014 no schema builders exist in the realm. Part of the resume hash. |\n| `model` | `string` | Model spec: optional registered harness prefix plus a verbatim id, or a backend-only name. See [Model specs & routing](#model-specs--routing). Part of the resume hash. |\n| `tier` | `"small" \\| "medium" \\| "big"` | Coarse tier resolved from host config; beats phase/meta model, loses to explicit `model`. Part of the resume hash. |\n| `mode` | `string` | ACP session mode id advertised by the selected backend. **Strict**: unsupported/unadvertised ids fail the call (never silently unconfined). Ids are backend-specific and drift with harness versions \u2014 read the advertised `mode` select from the config probe or a validator report (Codex-family examples: `read-only`, `agent`, `agent-full-access`; Claude-family advertises permission modes such as `plan`, `acceptEdits`, and `dontAsk`). Part of the resume hash when set. |\n| `configOptions` | `Record<string, string \\| boolean>` | Exact ACP session option ids and authored values. Applied in ascending id order after model and before the prompt, with no aliases or coercion. `"model"` is reserved for the dedicated `model` field. Part of the resume hash only when non-empty, with sorted keys. Read the advertised-options table first (`agentprism-workflows config <harness>`, or any validate report) before choosing values. |\n| `agentType` | `string` | Bind a named subagent definition (tools allow/deny, model, isolation, role prompt). See [agentType definitions](#agenttype-definitions). Part of the resume hash. |\n| `isolation` | `"worktree"` | Run in a throwaway git worktree branched from the run cwd. **Always removed (worktree + branch) when the call ends** \u2014 edits are discarded; return work as data. Degrades to the shared tree outside a git repo (logged). |\n| `resume` | `{ filesystem: "read-only" }` | Deprecated compatibility annotation. It is recorded as legacy diagnostic provenance, is not sent to the runner or hashed, and has no effect on replay. New scripts should omit it. |\n| `cwd` | `string` | Per-session working directory; relative resolves against the run\'s base cwd. Overridden by worktree isolation. Not hashed. |\n| `timeoutMs` | `number \\| null` | Total wall-clock cap for each attempt. A finite value may tighten a finite host `agentTimeoutMs` ceiling but cannot raise or disable it. With no host ceiling, a finite value applies and `null`/omitted is uncapped. |\n| `retries` | `number` | Retries after *recoverable* failures (default 0, host-overridable). Exhausted retries \u21D2 the call resolves `null`. |\n| `mcpServers` | `McpServerConfig[]` | MCP servers attached to this session. Stdio shape: `{ name, command, args: [], env: [{ name, value }] }` (`args`/`env` required, `env` is name/value pairs, not a map); `{ type: "http" \\| "sse", name, url, headers: [] }` also accepted. Not hashed. |\n| `images` | `PromptImage[]` | Base64 image blocks appended to the prompt; backends without image support get a bracketed text note. Not hashed. |\n| `meta` | `object` | ACP `_meta` merged into `session/new` \u2014 session-scoped extension passthrough (pairs with custom backends). Not hashed. |\n| `promptMeta` | `object` | ACP `_meta` merged into `session/prompt` \u2014 turn-scoped passthrough. Backend-computed keys win on conflict. Not hashed. |\n| `keepSession` | `boolean` | Skip release-time best-effort `session/close`; the non-secret re-attach record lands in `WorkflowRunResult.agentSessions` for host-side `loadSession()` / `resumeSession()`. Usage/auth pause failures are kept open automatically for managed continuation. Not identity-hashed; included in the input fingerprint. |\n\nThe timeout clock measures the whole attempt, including backend startup, model/config setup, tool\nwork, and streamed output; it is not an idle timer. Each retry starts a fresh clock, so the maximum\ntimeout envelope is `(retries + 1) \xD7 resolved timeoutMs` (retries are clamped to 3). An exhausted\ntimeout is recoverable `AGENT_TIMEOUT`: the call resolves to `null`, releases its concurrency slot,\nand asks the ACP session to cancel. A session that keeps running after the cancellation grace is\nclosed where supported and its pooled child is recycled.\n\nEvery new run, including one admitted with `resumeFromRunId`, resolves host limits from that run\'s\nrequest. It does not inherit `agentTimeoutMs`, retries, concurrency, or agent-count values from\nits source, so pass every operational bound the resumed execution should use.\n\n## Model specs & routing\n\nA `model` string is resolved solely from its first segment, then delegated to the harness:\n\n| spec shape | routes to | notes |\n|---|---|---|\n| *(omitted)* | host default backend | `AGENTPRISM_DEFAULT_BACKEND` (`claude` \\| `codex` \\| `opencode` \\| `pi` \\| custom name; default `claude`), session default model. Most portable. |\n| `claude`, `codex`, `opencode`, `pi`, or `<custom-name>` | that registered harness | Backend-only: no model config call; the harness default remains active. |\n| `claude/<id>`, `codex/<id>`, `opencode/<id>`, `pi/<id>`, or `<custom-name>/<id>` | that registered harness | Match the first segment ASCII-case-insensitively and strip exactly one segment. Custom names take priority on collision. The remaining `<id>` is sent verbatim, including further `/` characters. For Pi, that remainder is its `<provider>/<model-id>` and Pi preserves any further slashes in the model id. |\n| any other string, including `anthropic/\u2026`, `openai/\u2026`, bare `opus`, or bare `gpt-\u2026` | host default backend | The **entire** authored string is sent verbatim; these are not routing aliases. |\n\nSelection is a single `session/set_config_option` with `configId: "model"` and the exact remaining string. There is no catalog matching, case folding, normalization, bracket parsing, nearest-neighbor selection, sibling effort/Fast option driving, retry, or echo verification. Brackets, dots, and provider-style prefixes are ordinary model-id characters.\n\nWhatever the harness returns is the outcome. A rejection follows the existing agent-error path with no resolution-specific code or model fallback event. `onModelFallback` and `WorkflowRunResult.fallbacks` remain public compatibility surfaces; model resolution does not emit entries, while pause recovery emits `kind: "continuation"` reattach/skip notices.\n\n## Structured output channels\n\nOne author API (`schema`), four fulfillment paths \u2014 chosen automatically per backend:\n\n| backend | channel |\n|---|---|\n| Claude | native `outputFormat`, schema normalized to Anthropic\'s structured-outputs subset (e.g. `oneOf` \u2192 `anyOf`; unsupported keywords/formats stripped on the wire) |\n| Codex | native strict `outputSchema` (OpenAI strict subset normalization) |\n| Pi | a client-hosted `StructuredOutput` MCP tool injected when the agent advertises HTTP MCP support; common prompt-embedded schema and validated final-text JSON fallback |\n| OpenCode / custom ACP | a client-hosted **`StructuredOutput` MCP tool** injected into the session when the agent advertises HTTP MCP support (an agent may show it as `structured_output_StructuredOutput`); otherwise prompt-embedded schema + JSON parse of the final message. Custom backends can opt out of tool injection with `structuredOutputTool: false`. |\n\nPi accepts stdio, Streamable HTTP, and SSE MCP servers; ACP-transport MCP hosting remains client-side.\n\nIn every channel the runner coerces + validates client-side and re-prompts a bounded number of times; the final miss fails the call with non-recoverable `SCHEMA_NONCOMPLIANCE`. Constraints stripped from the wire are still enforced client-side \u2014 an exotic schema keyword shows up as re-prompt churn, so keep schemas simple.\n\n## DSL globals \u2014 complete signatures\n\n```\nagent(prompt, options?)                    \u2192 Promise<string | object | null>\nparallel(thunks)                           \u2192 Promise<results[]>   // barrier; input order; failed slot = null\npipeline(items, ...stages)                 \u2192 Promise<results[]>   // no inter-stage barrier; stage(prev, original, index); failed item = null\nworkflow(nameOrScript, args?)              \u2192 Promise<unknown>     // one nesting level; names resolve from the host\'s workflows folder, inline scripts always work\ngate(thunk, validator, { attempts = 3 })   \u2192 { ok, value, verdict, attempts }\n    // thunk(feedback, attempt); validator(result) \u2192 { ok, feedback?, ... } | boolean | null (may be async / an agent call)\nretry(thunk, { attempts = 3, until? })     \u2192 last result           // thunk(attempt); stops early when until(result)\nverify(item, { reviewers = 2, threshold = 0.5, lens? })\n    \u2192 { real, realCount, total, votes: [{ real?, reason? }] }\n    // N adversarial reviewers prompted to REFUTE; lens (string | string[]) rotates focus per reviewer\njudgePanel(attempts, { judges = 3, rubric = "overall quality and correctness" })\n    \u2192 { index, attempt, score, judgments }  // mean 0\u20131 score per candidate; stable tie-break by index\nloopUntilDry({ round, key = JSON.stringify, consecutiveEmpty = 2, maxRounds = 50 })\n    \u2192 unique items[]   // round(i) returns items; stops after N dry rounds; agent-limit exhaustion returns the partial result\ncompletenessCheck(taskArgs, results)       \u2192 { complete, missing?: string[] }\ncheckpoint(promptText, options?)           \u2192 Promise<reply>       // journaled human gate; zero tokens\nphase(title)                               \u2192 void                 // open a named phase\nlog(message)                               \u2192 void                 // console.log/info/warn/error route here too\nargs                                       // the host-provided input value, verbatim\ncwd                                        // the run\'s base working directory (string); process.cwd() returns it too\n```\n\nFor `gate()`, `value` is the final producer result and `verdict` is the exact last completed\nvalidator return, including any extra structured fields. `{ ok: true }` and bare `true` pass;\n`{ ok: false, feedback? }`, bare `false`, and `null` reject. Only object feedback is threaded into\nthe next producer attempt. A producer result of `null` is still passed to the validator. Producer\nor validator exceptions propagate immediately, so no partial gate result is returned and no later\nattempt runs. An explicit unsupported `undefined` validator return is a rejection represented as\n`verdict: null`. If the script returns the gate result, its complete verdict is persisted and may\nreach the host; keep evidence concise and never put credentials or other secrets in verdict data.\n\n`verify`, `judgePanel`, and `completenessCheck` spawn their subagents on the run\'s default model \u2014 hand-roll with `parallel` + `agent` to pin panel members to specific backends.\n\n## `checkpoint()` options\n\n| option | type | meaning |\n|---|---|---|\n| `kind` | `"confirm" \\| "input" \\| "select"` | Reply shape: boolean-ish / free text / one of `choices`. Affects the journal hash and the host UI widget. |\n| `choices` | `string[]` | For `kind: "select"`. |\n| `default` | `unknown` | Reply taken in the default headless mode \u2014 journaled like a real reply. Defaults to `true`. |\n| `headless` | `"default" \\| "abort" \\| "pause"` | No live channel: `"default"` takes `default ?? true`, `"abort"` aborts, and `"pause"` creates a persisted `checkpoint_required` pause. Default `"default"`. |\n| `timeoutMs` | `number` | Deadline for the interactive prompt. |\n\nThe host supplies the live human channel (elicitation in the MCP server; `ExecOptions.confirm` in the SDK), and that channel wins even when `headless: "pause"` is declared. A durable pause carries non-secret `checkpointContext`; resume with `ExecOptions.checkpointReplies: { [context.callIndex]: decision }` or attach a live channel. On a new `resumeFromRunId` execution, reply keys always name indexes in the **source** recording; identity matching may inject that decision at a shifted current index. Completed host and headless checkpoint results both replay when identity and the checkpoint-options fingerprint over `default`, `headless`, and `timeoutMs` match. A changed option or ambiguous match runs fresh. Detached runs never pause for a checkpoint unless the author opts into `"pause"`.\n\n## Error codes (`WorkflowError.code`)\n\n| code | recoverable | engine behavior |\n|---|---|---|\n| `AGENT_TIMEOUT` | yes | Total wall-clock attempt cap exhausted. Every retry gets a fresh clock; after the final attempt the call resolves `null`, and ACP cancel escalates to close/recycle when the turn does not stop. |\n| `AGENT_CANCELLED` | yes | The host selected this in-flight call for cancellation. It resolves `null` immediately through an engine race, skips retries, leaves the run live, and is recorded as a failed call rather than a replayable journal result. |\n| `AGENT_EMPTY_OUTPUT` | yes | No assistant text on a schema-less call; same retry-then-`null`. |\n| `AGENT_EXECUTION_ERROR` | yes* | Generic agent failure (*refusal/truncation variants are non-recoverable). |\n| `SCHEMA_NONCOMPLIANCE` | no | Structured output never validated after the re-prompt ladder. Halts the run (catchable in-script). |\n| `PROVIDER_USAGE_LIMIT` | no | Quota/rate wall \u2014 the run **pauses** (journaled, resumable), with the provider\'s reset hint. |\n| `AGENT_LIMIT_EXCEEDED` | no | `maxAgents` cap hit. |\n| `AUTH_REQUIRED` | no | Backend needs authentication. `WorkflowManager` returns a resumable pause with `reason: "auth_required"` and redacted `authContext`; a direct runner throws. The host completes auth before resuming/retrying. |\n| `CHECKPOINT_REQUIRED` | no | `headless: "pause"` reached without a live channel. `WorkflowManager` returns `reason: "checkpoint_required"` plus non-secret `checkpointContext`; resume with `checkpointReplies` or live confirm. |\n| `SCRIPT_VALIDATION_ERROR` | no | Script failed parse/validation (bad meta, nondeterministic API, bad `meta.backends` shape). |\n| `SCRIPT_ERROR` | no | The script itself crashed (uncaught throw, floated rejection). |\n| `WORKFLOW_ABORTED` | \u2014 | Real cancellation (pause/stop/host signal) \u2014 never used for crashes. |\n\n`loopUntilDry` absorbs `AGENT_LIMIT_EXCEEDED` from its rounds and returns the partial result; everywhere else it propagates.\n\n## Determinism & the resume journal\n\n> **Resume rule:** replay is content-addressed and fail-to-live on correspondence: a completed call replays when its identity and input fingerprint match uniquely. Filesystem or world state never gates replay.\n\nThe guide section **Determinism and resume** carries the full semantics: what each hash contains, matching, admission, continuation of interrupted calls, and checkpoint replay. Wire-level specifics for lookup:\n\n- Each `agent()` result is journaled under a monotonic call index and a SHA-256 identity hash. The canonical identity fields, in order, are `prompt`, resolved `model`, `mode` only when set, `configOptions` only when non-empty, `tier`, `phase`, `agentType`, resolved `agentDef`, and `schema`. Config-option keys are sorted before serialization. Missing fields other than `mode` and `configOptions` serialize as `null`; an unset `mode` and an unset/empty `configOptions` key are omitted for compatibility with older journals.\n- `agentDef` is the resolved definition\'s tools, disallowed tools, model, isolation, and body prompt. Changing a named definition therefore invalidates its call even when the `agentType` name is unchanged.\n- The legacy `resume: { filesystem: "read-only" }` annotation has no effect on admission or matching. Writers, readers, worktree calls, and unannotated calls follow the same journal rule.\n- `resumePolicy: "positional"` requests index/prefix correspondence but cannot bypass new-format format, metadata, manifest, cwd, or input checks. Marker-less journals and permanently marked manual/same-run legacy resumes retain historical hash-only positional behavior. Sources below input format 2 use `inputs-format-legacy`. Ancestor-scoped rows carried by a \u22640.23 resume hop replay only while that ancestor is still persisted; engine-minted nested scopes and deleted ancestor scopes stay live.\n- There is no `require`, `import`, Node API, or network API in the realm. `Date.now()`, `Math.random()`, and no-arg `new Date()` / `Date()` fail static validation; aliased or computed forms are blocked at runtime; `new Date(value)` works.\n\nEvery new-run resume exposes `replayEligibility` on admission, polling, inspection, and the terminal result. It reports strategy, predicted/observed replayable prefix and counts, first non-replay/reason/detail, engine/input-format diagnostics, non-gating runtime/environment `provenanceChanges`, and non-gating operational changes; `resumeReport` retains the complete terminal per-call correspondence.\n\nAn all-live outcome is expected when correspondence cannot be established, not when the world changed. Missing resume metadata, incompatible format literals, or an invalid manifest/seed can disable reuse. A new-format source containing any result row without a captured call path/input fact\u2014possible with a call stack deeper than the raw-frame cap or a non-strict-JSON `meta` value\u2014is source-wide `"manifest-invalid"`; excluding the row could make an ambiguous sibling look unique. Format-1 bytes are never reinterpreted; they enter the positional bridge and replayed rows are recorded under format 2.\n\nAn args-controlled cap is the useful case: a cap that changes how many calls are reachable, but\ndoes not appear in an earlier call\'s prompt, lets those calls replay on resume. The worked example\nlives in the determinism-and-resume guide document and ships as\n`examples/resume-loop-cap.workflow.js`. This changed-args pattern is specific to new-run entry\npoints that accept current args with `resumeFromRunId`. The MCP `workflow` tool does, as does\n`WorkflowManager.runSync(script, newArgs, { resumeFromRunId })`. MCP resume always requires\nexplicit content; a bare `resumeFromRunId` is invalid. `WorkflowManager.resume(runId)` is a\ndifferent same-ID recovery API: it reloads the persisted original script/args and permanently uses\nlegacy positional replay semantics, while the independent default-on channel may still continue an\neligible usage/auth-interrupted live call.\n\n## <a name="custom-backends-metabackends"></a>Custom backends \u2014 `meta.backends`\n\n```js\nexport const meta = {\n  name: "\u2026", description: "\u2026",\n  backends: {\n    browser: {\n      command: "browser-acp",          // required: executable (absolute or on PATH)\n      args: ["--headless"],            // default []\n      env: { BROWSER_PROFILE: "qa" },  // merged OVER the child\'s inherited env \u2014 per-backend secrets go here\n      sessionMeta: { viewport: "desktop" },  // static ACP _meta on every session/new (per-call `meta` merges over it)\n      structuredOutputTool: true,      // default true; false = keep this backend on the prompt/_meta schema fallback\n    },\n  },\n};\n```\n\nScript-declared backends are **trust-gated**: they spawn commands on the host machine, so they stay inert until the composition root approves them \u2014 elicitation approval in the MCP server, `allowScriptBackends: true` (or a per-backend callback) on `runDynamicWorkflow`, `ExecOptions.scriptBackends` on a manager, or `AGENTPRISM_ALLOW_SCRIPT_BACKENDS=1`. A *declined* backend aborts the run rather than silently rerouting its calls to the default backend. Host-registered names always win over script declarations. Prefer host registration (`createAcpRunner({ backends })` / `AGENTPRISM_BACKENDS` env JSON) when you control the host.\n\n## <a name="agenttype-definitions"></a>`agentType` definitions\n\nMarkdown files at `<runCwd>/.agentprism/agents/<name>.md` (project) and `~/.agentprism/agents/<name>.md` (user); project wins on name collision. Frontmatter + body:\n\n```markdown\n---\ndescription: Read-only security auditor\ntools: [read, grep, glob]        # allowlist of tool names (omit = all)\ndisallowedTools: [bash]          # denylist, applied after the allowlist\nmodel: claude/opus[1m]           # verified id; agent({ model }) overrides it\nisolation: worktree              # optional\n---\nYou are a security auditor. Report findings; never modify files.\n```\n\nThe body is prepended to the agent\'s task as role guidance. An unknown `agentType` logs a warning and runs with default tools/model (the name degrades to a prose hint).\n\n## How hosts run scripts (what authors can assume)\n\nThe MCP route (`npx @automatalabs/mcp-server`, tool name `workflow`) is the canonical way an agent\nruns an authored script; registration and the per-action contracts are in the Running workflows\nguide section. The `workflow` tool is the server\'s whole *workflow* surface: run/resume/inspect/await/stop\nare action branches, not separate tools, and this input does not resolve a saved workflow name.\n(The server also registers a second, separate model-facing tool, `repl`, for interactive REPL\norchestration \u2014 outside this authoring guide\'s scope.) A\nrun that pauses with `reason: "auth_required"` resumes via a new run after the backend\'s own CLI is\nlogged in out-of-band (see below). Prompt-capable MCP hosts (e.g. Claude Code, where it surfaces as\na slash command) also get this entire guide from the server itself as the **`author-workflow`**\nprompt, with an optional `task` argument.\n\nEnvironment knobs shared by the MCP server and the SDK: `AGENTPRISM_DEFAULT_BACKEND`,\n`AGENTPRISM_ACP_POOL_SIZE` (schema-run parallelism on OpenCode/custom backends scales with the\npool; one injected-tool registry per process), `AGENTPRISM_BACKENDS`,\n`AGENTPRISM_ALLOW_SCRIPT_BACKENDS`, `AGENTPRISM_PERSISTENCE_ROOT`, plus per-backend spawn\noverrides. Pi uses `AGENTPRISM_PI_ACP_CMD` with optional `AGENTPRISM_PI_ACP_ARGS`; otherwise the\ninstalled exact-pinned package bin is used before the `npx -y @automatalabs/pi-acp` fallback.\n\nEmbedding hosts drive the same contract directly through the SDK \u2014 `runDynamicWorkflow` /\n`WorkflowManager` from `@automatalabs/workflows`, with `exec` limits (`maxAgents`, `concurrency`,\n`agentTimeoutMs`, `agentRetries`), a live `confirm` checkpoint channel, and\n`exec.resumeFromRunId` for edited-script resume. See `docs/api.md` in the repository. The shapes\nbelow are the `workflow` tool\'s MCP surface, which is what script authors interact with.\n\nExact MCP tool input/output types:\n\n```ts\ninterface WorkflowExecuteToolInputBase {\n  action?: "run";\n  args?: unknown;\n  maxAgents?: number;\n  concurrency?: number;\n  agentRetries?: number;\n  agentTimeoutMs?: number | null;\n  resumeFromRunId?: string;\n  resumePolicy?: "auto" | "positional";\n  checkpointReplies?: Record<number, unknown>;\n  background?: boolean; // default false\n}\n\ntype WorkflowExecuteToolInput = WorkflowExecuteToolInputBase & (\n  | { script: string; scriptPath?: never }\n  | { script?: never; scriptPath: string } // absolute path on the server\n);\n// WorkflowExecuteToolInputBase also carries projectDir?: string \u2014 the absolute project\n// directory selecting the project-scoped run store and default execution cwd. REQUIRED for\n// run on the shared workflow daemon (one registration serves every project); optional on a\n// single-project (--in-process) server. inspect/await/stop never take it: a runId locates\n// its project store automatically.\n\ninterface WorkflowAwaitToolInput {\n  action: "await";\n  runId: string;\n  waitMs?: number;      // default 20_000; integer 0..25_000\n  lastN?: number;       // default 20; integer 1..50\n  labelGlob?: string;   // same whole-label glob as inspect\n  logLines?: number;    // default 20; integer 0..50\n}\n\ninterface WorkflowBackgroundAccepted {\n  runId: string;\n  status: "running";\n  scriptSource: "inline" | "path";\n  scriptUri: string;\n  limits: WorkflowRunLimits;\n  replayEligibility?: WorkflowReplayEligibility;\n}\n\ninterface WorkflowAwaitMetadata {\n  requestedMs: number;\n  elapsedMs: number;\n  returnedBecause: "terminal" | "timeout" | "immediate";\n}\n\ninterface WorkflowRunAwaitResult<T = unknown> extends WorkflowRunStatus {\n  wait: WorkflowAwaitMetadata;\n  tokenUsage?: TokenUsage;\n  outcome?: Omit<WorkflowExecutionToolResult<T>, "scriptSource">; // exactly when terminal\n  scriptUri: string;\n  lineage: Array<{ runId: string; uri: string; available: boolean }>;\n}\n\ninterface WorkflowStopToolInput {\n  action: "stop";\n  runId: string;\n  callIndex?: number;  // omitted = whole-run abort; present = cancel one in-flight agent\n  lastN?: number;\n  labelGlob?: string;\n  logLines?: number;\n  script?: never;\n  scriptPath?: never;\n  waitMs?: never;\n}\n```\n\nThe selected stop form requires a live, uniquely addressable agent attempt. Settled/unallocated\nindexes, checkpoints, duplicate scoped indexes, and terminal runs are errors that enumerate the\ncurrently in-flight call-index/label pairs. A successful selected cancellation returns the ordinary\nlive `WorkflowRunStatus`; whole-run stop returns the terminal `WorkflowStopResult`.\n\n`WorkflowRunResult.fallbacks?: WorkflowRunFallback[]` retains the compatibility shape\n`{ callIndex, label, phase?, requestedSpec, resolvedModel?, backendId?, kind, message, continuation? }`.\n`kind` is `model | modifier | continuation`; continuation details report either a reattached\n`resume | load` method or an exact skip reason. The model-resolution pipeline itself produces no entries.\n`WorkflowRunResult.checkpointsTaken?: WorkflowCheckpointTaken[]` records resolved checkpoints as\n`{ callIndex, kind, decision, source }`, where source is `live`, `headless-default`,\n`journal-replay`, or `injected`. A paused checkpoint is not resolved. Both fields are persisted and\nappear in foreground results plus terminal await `outcome`; neither appears on `WorkflowRunStatus`.\n\nAt most four background runs may be active or starting per server instance. Foreground, inspect,\nawait, and stop consume no slot; a durably stopped background run frees its slot immediately even\nwhile backend session wind-down remains. A timeout returns the freshest status and partial cumulative usage; replay\nhits cost/add zero. Terminal results have no MCP TTL and are reconstructed after restart while the\nproject run record remains readable. The inherited status fields stay redacted/bounded at 24,576\nstructured bytes and 8,192 text bytes. The full script lineage is never truncated; when lineage\nalone exceeds the status budget, `truncation.maxStructuredBytes` reports the larger actual envelope\nlimit. Terminal `outcome` preserves the raw authored result/full logs and has no new total cap, but\nit is never copied into text. It includes `scriptUri` but not the unpersisted admission-only\n`scriptSource`.\n\nThe background start has no enduring request signal, progress channel, or live checkpoint channel.\nIt returns immediately and emits no progress after returning, even if the initiating request\nsupplied a progress token. A later bounded `action:"await"` is a separate request; when that await\ncarries a progress token, it can stream coarse phase and distinct started/ended-call progress while\npending. The legacy/inconsistent-log polling fallback emits no progress notifications. A headless\ncheckpoint default continues; abort fails with `WORKFLOW_ABORTED`; pause returns\n`checkpoint_required` plus `outcome.checkpointContext`. Auth pauses return non-secret\n`outcome.authContext`; log the backend CLI in before resume. Background execution lives in the\nserving process (the daemon, or the single process under `--in-process`): that process\'s death can\ninterrupt an in-flight call, and stale durable `pending`/`running` state reconciles under its lease\nto `paused` / `interrupted`.\n\nEvery resumed background run durably seeds its inherited prefix (including a manager-owned\ncheckpoint injection) beneath its new run ID before acknowledgement, so later resume hops remain\nself-contained. The MCP layer never rewrites that seed. Await and inspect never execute or resume\nthe script; their cold preflight may only reconcile a dead owner\'s stale `pending`/`running` state\nto `paused` / `interrupted`.\n\nEvery admitted script is an immutable persistence-backed MCP resource at\n`workflow://runs/{runId}/script`. Run results link the new script; inspect/await link the full\nresume lineage oldest-to-newest as structured `{ runId, uri, available }` entries. Listing and\ncompletion include only the 50 newest runs, but a direct URI read works for any retained project\nrun. A path is never persisted or implicitly re-read, and the MCP layer retains no scripts, args,\nor synthetic lineage metadata in process memory.\n\n`action:"stop"` durably aborts a `running` or `paused` run live in the serving process: it cancels\nany pending agent/checkpoint request, appends `stopped`, releases the lease, and returns the final\ninspection projection with `stopped:true`. Only backend session wind-down can remain, observable\nthrough inspect\'s agent states. A repeated stop on a terminal run succeeds with `stopped:false,\nalreadyTerminal:true`. An in-flight stop may lack a quiescent terminal-environment proof, so the\nmanager can conservatively run the following resume live; inspect `replayEligibility` and\n`resumeReport` rather than assuming a prefix replay.\n\nRetain the run ID and inspect halted runs before guessing. The exact inspection input is:\n\n```ts\ninterface WorkflowInspectToolInput {\n  action: "inspect";\n  runId: string;       // /^[a-z0-9]+-[a-z0-9]+$/, at most 128 characters\n  lastN?: number;      // default 20; integer 1..50\n  labelGlob?: string;  // non-empty; at most 128 Unicode code points\n  logLines?: number;   // default 20; integer 0..50\n  script?: never;\n  scriptPath?: never;\n}\n```\n\n`labelGlob` matches the whole raw agent label case-sensitively: `*` is zero or more Unicode code\npoints, `?` is exactly one, and backslash escapes the next character (a trailing backslash is\nliteral). Checkpoints and unknown legacy calls are excluded when a glob is present. Filtering\nhappens before `lastN`; selected calls return in ascending call-index order.\n\n```ts\ninterface WorkflowLogTail {\n  lines: string[];\n  totalLines: number;\n  omittedLines: number;\n  truncatedLines: number;\n  redactedLines: number;\n}\n\ninterface WorkflowRunCallStatus {\n  index: number;\n  kind: "agent" | "checkpoint" | "unknown";\n  label?: string;\n  phase?: string;\n  model?: string;\n  backendId?: string;\n  timeoutMs?: number | null;\n  errorCode?: string;\n  resultPreview: string;\n  resultRedacted: boolean;\n  resultTruncated: boolean;\n}\n\ninterface WorkflowRunStatus {\n  runId: string;\n  status: "pending" | "running" | "paused" | "completed" | "failed" | "aborted";\n  workflowName: string;\n  phases: string[];\n  currentPhase?: string;\n  reason?: string;\n  errorCode?: string;\n  limits?: WorkflowRunLimits; // absent only on legacy persisted records\n  replayEligibility?: WorkflowReplayEligibility;\n  logTail: WorkflowLogTail;\n  calls: WorkflowRunCallStatus[];\n  filter: { lastN: number; logLines: number; labelGlob?: string };\n  truncation: {\n    maxStructuredBytes: number;\n    byteCapApplied: boolean;\n    phases: { total: number; returned: number; shortened: number };\n    logs: { total: number; returned: number; shortened: number; redacted: number };\n    calls: {\n      total: number;\n      matched: number;\n      returned: number;\n      shortenedResults: number;\n      redactedResults: number;\n    };\n  };\n}\n\ninterface WorkflowRunLimits {\n  maxAgents: number;\n  tokenBudget: null; // persisted-shape compatibility field; new runs always report null\n  concurrency: number;\n  agentRetries: number;\n  agentTimeoutMs: number | null;\n}\n```\n\nInspection returns only this allowlisted projection: never raw script, args, prompts, histories,\nhashes, session IDs, cwd, checkpoint/auth details, or raw results. Credential-shaped data is\nredacted, results are structurally compacted, every outward text scalar/preview is capped at 512\nUTF-8 bytes, inherited status JSON at 24,576 bytes, and inspection text at 8,192 bytes. Full lineage\ncan raise the structured envelope limit as reported by `truncation.maxStructuredBytes`. An unknown ID is\na tool error with no structured content; reading an existing failed run succeeds and reports\n`status:"failed"`. Every paused, failed, or aborted execution result also carries a redacted\nfinal-20 `logTail` (present when empty) and renders it in the immediate terminal text. Completed\nexecution results omit that extra field while retaining their full `logs` array.\n\nBackend auth comes from the machine the host runs on: Claude via a logged-in Claude Code install or `ANTHROPIC_API_KEY`; Codex via `~/.codex/auth.json`; OpenCode via `opencode auth login` (its CLI must be installed \u2014 it is not bundled); Pi via one of `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, `XAI_API_KEY`, `OPENROUTER_API_KEY`, or ambient credentials in `~/.pi/agent/auth.json`. A script only needs auth for the backends it actually routes to.\n\n## The validator \u2014 `agentprism-workflows validate`\n\n```bash\nnpx @automatalabs/workflows validate <workflow-file> [options]\n```\n\nZero tokens; three passes \u2014 static parse, mocked dry run, then one no-prompt config probe per\nrouted `{ backend, model }` pair \u2014 described in the guide\'s Validate before you run section. The\ntables and grammar below are the exhaustive contract.\n\n| flag | meaning |\n|---|---|\n| `--args <json>` / `--args-file <path>` | the script\'s `args` global for the dry run |\n| `--mock-answers <json>` | label-glob answers for dry-run calls; mutually exclusive with the file form |\n| `--mock-answers-file <path>` | read the same JSON object from a UTF-8 file resolved against the process cwd |\n| `--workflows-dir <dir>` | repeatable; a folder of workflow scripts (name = filename stem). Lets the positional be a NAME and resolves nested `workflow("<name>")` calls |\n| `--parse-only` | static parse only |\n| `--cwd <dir>` | dry-run base cwd (default: throwaway temp dir, so `isolation: "worktree"` no-ops; a real repo cwd creates and cleans up real worktrees) |\n| `--max-agents <n>` | cap on dry-run agent calls |\n| `--timeout-ms <n>` | dry-run wall-clock limit (default 30000) |\n| `--json` | machine-readable `ValidateWorkflowReport` on stdout |\n\nInline false-branch fixture (exact shell form):\n\n```bash\nagentprism-workflows validate flow.workflow.js \\\n  --mock-answers \'{"refute:*":{"real":false}}\'\n```\n\nEquivalent reusable file with a reject-then-approve sequence:\n\n```json\n{\n  "refute:*": { "real": false },\n  "quality:review": {\n    "$sequence": [\n      { "ok": false, "feedback": "exercise the revision path" },\n      { "ok": true }\n    ]\n  }\n}\n```\n\n```bash\nagentprism-workflows validate flow.workflow.js --mock-answers-file mock-answers.json\n```\n\nRules match the final resolved label case-sensitively across the whole string. `*` matches zero or more characters (including `:` and `/`), `?` one character, and `\\` escapes the next character; empty globs and trailing escapes are invalid. Object order is captured once and the **last matching rule wins**, so put `"*"` before narrower exceptions. Raw canonical array-index keys (`"0"` or a non-zero, no-leading-zero decimal through `"4294967294"`) are reserved because ECMAScript reorders them. To match numeric label `10`, use JSON key `"\\\\10"`; `"01"` and `"4294967295"` are ordinary keys.\n\nA single answer is reusable. `{ "$sequence": [...] }` is finite and only the winning rule consumes it; a raw array is one array result, and a sequence element is ordinary answer data even when it contains `$sequence`. Exhaustion fails instead of repeating the last item or falling back. The machine report uses zero-based `sequenceIndex`; human lines render one-based `[position/length]`. Earlier matching rules count the match even when shadowed, and `dryRun.mockAnswers.unused` distinguishes `no-match`, `shadowed`, and partially consumed `not-reached` items. Unused fixtures warn but do not fail validation.\n\nFor schema calls, each answer deep-merges over a **fresh** fabricated base: JSON objects merge recursively; arrays, `null`, falsy primitives, and other scalars replace. The merged value is TypeBox-checked without coercion. Any answer-caused violation fails non-recoverably with `SCHEMA_NONCOMPLIANCE`; a failure already present at the identical untouched path/message in the simple fabricated base may be accepted with a grouped inherited-fabrication warning. A valid override can repair such a base limitation. Schema-less answers must be nonblank strings. Fixture failure messages, attribution, and warnings contain only labels, globs, positions, paths, and counts\u2014not answer values.\n\nLimits: 256 KiB raw UTF-8 for either CLI source and canonical JSON for programmatic input; 256 rules; 1\u2013256 UTF-16 code units per glob; 256 entries per sequence; answer depth 32. Inputs must be plain JSON data. Mock-enabled validation serves agent calls serially for deterministic FIFO sequence allocation; it is not a concurrency/load simulation. Fixture values still flow into the script like real agent results, so author code can expose them via `log()` or its returned result\u2014never store credentials or production data in fixtures.\n\nExit codes: `0` valid \xB7 `1` parse/static failure \xB7 `2` dry-run failure \xB7 `3` usage error. The report also lists every checkpoint with the mock reply (`default ?? true`) and warnings for backend approval, phase mismatch, `headless: "abort"`, and agent-less scripts. `headless: "pause"` dry-runs cleanly. A saved nested workflow still needs `--workflows-dir`.\n\nProgrammatic: `validateWorkflowScript(script, { args, workflows, dryRun, cwd, maxAgents, timeoutMs, mockAnswers })` from `@automatalabs/workflows` returns the same report. Invalid workflow scripts resolve to reports; invalid `mockAnswers` supplied from untyped JavaScript throws `TypeError` before parsing.\n\n## Harness config discovery \u2014 `agentprism-workflows config`\n\nValidate\'s sibling: the same no-prompt config probe, standalone \u2014 no script required. Run it BEFORE authoring to read each harness\'s advertised, negotiable session surface (model ids including bracket variants, effort levels, modes, boolean knobs) instead of guessing values or writing a throwaway probe workflow.\n\n```bash\nnpx @automatalabs/workflows config                  # every routable harness\nnpx @automatalabs/workflows config codex opencode   # only the named harnesses\nnpx @automatalabs/workflows config claude --json    # machine-readable report\n```\n\nHarness names are the routing names: built-in `claude` / `codex` / `opencode` / `pi` plus any custom backend registered via the `AGENTPRISM_BACKENDS` env var (registered customs also join the no-argument default set). Each harness opens one session without a prompt \u2014 zero tokens \u2014 and its catalog is read fresh; a harness that cannot spawn or authenticate reports `probed: false` with the reason and never blocks the others.\n\nThe no-argument built-in sequence comes from `BUILTIN_BACKEND_IDS`; authoring prose describes the\ncurrent registry rows and does not define a separate supported-backend list.\n\n| flag | meaning |\n|---|---|\n| `--cwd <dir>` | session cwd for the probes (default: the current directory \u2014 harnesses may resolve project-level config, and hence their catalog, from it) |\n| `--timeout-ms <n>` | per-harness probe bound (default 60000); a timed-out harness reports `probed:false` |\n| `--json` | machine-readable `HarnessConfigReport` on stdout (`harnessOptions` uses the same per-harness shape as validate\'s report) |\n\nExit codes: `0` all probed \xB7 `1` at least one probe failed \xB7 `3` usage error.\n\nProgrammatic: `probeHarnessConfig({ harnesses, backends, cwd, timeoutMs })` from `@automatalabs/workflows` returns the same report (`backends` merges over `AGENTPRISM_BACKENDS` exactly like `createAcpRunner`); `formatHarnessConfigReport(report)` renders the human table.\n\n## Workflow folders\n\nHosts that keep versioned folders of workflow scripts serve them by name (the SDK\'s\n`openWorkflowDir` \u2014 see `docs/api.md`). The filename stem is the name (`review-pr.workflow.js` \u21D2\n`review-pr`; `.workflow.js` beats `.js`). For script AUTHORS the takeaway is simply:\n`workflow("<name>")` works when the host serves a folder; keep names equal to filename stems.\n\n---\n\n# Complete example \u2014 quick-wins.workflow.js\n\nA complete, validated script (`loopUntilDry()` with per-round vendor rotation, dedup threading via a `seen` list, and an args-controlled round cap; runs standalone or nested):\n\n```js\n// quick-wins \u2014 a small, self-contained hunter that repo-triage nests by name\n// (`workflow("quick-wins", {...})`) and that also runs standalone:\n//\n//   npm start -- --workflow quick-wins\n//   npx agentprism-workflows validate quick-wins --workflows-dir workflows\n//\n// Demonstrates loopUntilDry(): keep spawning hunt rounds \u2014 each on the next vendor\n// in the pool \u2014 until two consecutive rounds add nothing new (or the round cap\n// stops it first). Workflow scripts are self-contained strings with no imports, so\n// the vendor pool is repeated here rather than shared with repo-triage.\nexport const meta = {\n  name: "quick-wins",\n  description: "Hunt small, high-confidence quick wins across the repo until two consecutive rounds come up dry",\n  phases: [{ title: "Hunt" }],\n};\n\n// args \u2014 every knob optional; hosts may hand args through as a JSON string.\nconst raw = typeof args === "string" ? (() => { try { return JSON.parse(args); } catch { return {}; } })() : args;\nconst opt = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};\nconst rounds = Number.isFinite(Number(opt.rounds)) && Number(opt.rounds) >= 1 ? Math.floor(Number(opt.rounds)) : 4;\nconst focus =\n  typeof opt.focus === "string" && opt.focus.trim().length > 0\n    ? opt.focus.trim()\n    : "small, safe, high-confidence improvements";\nconst avoid = Array.isArray(opt.avoid) ? opt.avoid.filter((x) => typeof x === "string") : [];\n\n// These registered-prefix specs use ids verified against each live harness catalog.\nconst POOL = [\n  { name: "claude", model: "claude/opus[1m]", mode: "plan" },\n  { name: "codex", model: "codex/gpt-5.6-sol", mode: "read-only" },\n  { name: "opencode", model: "opencode/zai/glm-5.2" },\n];\n\nconst WINS = {\n  type: "object",\n  additionalProperties: false,\n  required: ["wins"],\n  properties: {\n    wins: {\n      type: "array",\n      items: {\n        type: "object",\n        additionalProperties: false,\n        required: ["file", "summary", "action"],\n        properties: {\n          file: {\n            type: "string",\n            description: "Repo-relative path of a file you actually opened \u2014 copy it exactly, never invent one",\n          },\n          summary: { type: "string", description: "One sentence: the small problem or missed improvement" },\n          action: { type: "string", description: "The concrete, low-risk change that fixes it, in one clause" },\n        },\n      },\n    },\n  },\n};\n\nphase("Hunt");\nconst seen = [];\nconst wins = await loopUntilDry({\n  round: async (i) => {\n    const v = POOL[i % POOL.length];\n    const r = await agent(\n      `Hunt round ${i + 1}: find up to 3 quick wins in this repository \u2014 ${focus}. ` +\n        "A quick win is a small, safe, self-contained improvement (a missing guard, a stale doc line, an obvious dead branch), " +\n        "not a refactor. Open files and ground every entry in code you actually read; never emit a placeholder.\\n" +\n        `Already known \u2014 do NOT repeat anything on this list: ${JSON.stringify([...avoid, ...seen])}`,\n      { label: `hunt:${i + 1}:${v.name}`, phase: "Hunt", schema: WINS, model: v.model, mode: v.mode },\n    );\n    const found = (r?.wins ?? []).filter((w) => typeof w.file === "string" && w.file.length > 0 && !w.file.startsWith("/"));\n    seen.push(...found.map((w) => `${w.file}: ${w.summary}`));\n    return found.map((w) => ({ ...w, foundBy: v.name }));\n  },\n  key: (w) => `${w.file}::${w.summary}`,\n  consecutiveEmpty: 2,\n  maxRounds: rounds,\n});\n\nlog(`quick-wins: ${wins.length} unique wins across the hunt`);\nreturn { wins };\n```\n';
+var AUTHORING_PROMPT_CONTENT = '# Writing AgentPrism workflow scripts\n\nA workflow script is plain JavaScript, passed around as a **string**, not a module. The engine runs it in a deterministic sandboxed realm. Each `agent()` call opens a session on an [Agent Client Protocol](https://agentclientprotocol.com) (ACP) backend \u2014 Claude Code, OpenAI Codex, OpenCode, pi, or a custom ACP agent server. The backend runs its own tool loop to completion and returns final text or a schema-validated object. One script can mix backends per call.\n\nThe **Workflow script reference** section at the end of this document holds the exhaustive option tables, routing grammar, and error codes.\n\n## The guide, by task\n\nEvery section of the guide is inlined below, after the core: Running workflows (the MCP server and `workflow` tool), backends and structured output, composition and failure, quality helpers and checkpoints, the execution environment, determinism and resume, and worked examples with validation.\n\n## The mental model\n\n- **The script is the orchestrator; agents are workers.** All control flow \u2014 loops, fan-out, dedup, aggregation, conditionals \u2014 lives in script code. Agents cannot spawn agents and cannot see each other. Give each agent one self-contained task.\n- **Each `agent()` call opens a fresh session with no memory.** Interpolate everything a later call needs into its prompt. (Sole exception: resume can continue the same usage/auth-interrupted occurrence \u2014 see Determinism and resume.)\n- **Agents are real coding agents, not chat completions.** They have file access, shells, and tools, rooted at the run\'s working directory. "Read the failing test and fix it" is a valid prompt; the agent will edit files.\n- **The DSL primitives are realm globals, not imports.** There is nothing to `import` \u2014 `agent`, `parallel`, `pipeline`, `gate`, `checkpoint`, `args`, \u2026 are injected. Top-level `await` and a top-level `return` are valid. The script\'s return value becomes the run\'s `result`.\n- **Scripts are plain JavaScript, not TypeScript.** Type annotations fail to parse. The realm has no Node APIs (no `require`, `import`, `fs`, `fetch`, timers). All side effects happen through agents.\n- **Live observability needs no script annotations.** Journaling runs publish redacted progress and transcript upserts at `workflow://runs/{runId}/events`. Author labels for human correlation, not to enable this behavior.\n\n## Minimal script\n\n```js\nexport const meta = {\n  name: "repo-summary",\n  description: "Summarize what a repository does",\n};\n\nconst summary = await agent(\n  `Read the README and the package manifests under ${args.path}, then ` +\n  `summarize what this project does in five sentences.`,\n  { label: "summarize" },\n);\nreturn { summary };\n```\n\nRun scripts through the MCP server\'s `workflow` tool \u2014 registration, the run/await/inspect/stop actions, and the `args`/`cwd` globals are covered in the **Running workflows** section below.\n\n## Pre-flight checklist\n\n- [ ] `export const meta = { name, description }` is the first statement, a pure literal.\n- [ ] No `Date.now()` / `Math.random()` / no-arg `new Date()` / `Date()`; no imports, no Node APIs. Timestamps and randomness come in through `args`.\n- [ ] Every `parallel` element is a **thunk**; results are `.filter(Boolean)`-ed or null-checked.\n- [ ] Every prompt is self-contained: prior results are interpolated in, and every file path a prompt references was written by an earlier call, supplied through `args`, or created by that prompt\'s own instructions.\n- [ ] Schemas: object root, `additionalProperties: false`, everything `required`, a `description` on every field.\n- [ ] Model ids, effort values, and `configOptions` come from `npx @automatalabs/workflows config` or a validator report, never from memory. `mode` only on calls with a pinned `model`.\n- [ ] Worktree-isolated agents return their work as data \u2014 their edits are discarded when the call ends.\n- [ ] Replay is intentional: completed calls with matching identity and input fingerprints replay. Change a hashed field (normally the prompt) when a completed call must run again.\n- [ ] Loops terminate on bounds the script controls; caps and drops are `log()`-ed, not silent.\n- [ ] `checkpoint()` guards irreversible actions, with a sane headless `default` or an intentional `headless: "pause"`.\n- [ ] `return` a compact, structured result \u2014 it is the run\'s `result`, not a transcript.\n- [ ] `npx @automatalabs/workflows validate <file> --args \'<json>\'` exits 0 with no surprising warnings.\n\nFor the complete `agent()` option table, model-routing grammar, checkpoint options, error codes, `meta.backends` config fields, and the MCP tool input shapes, see the **Workflow script reference** section below.\n\n\n## Running workflows \u2014 the MCP `workflow` tool\n\nAgents run workflows through the `workflow` tool served by `@automatalabs/mcp-server` (the server also registers a separate `repl` tool for interactive REPL orchestration, out of scope here). Register it once in the host\'s MCP configuration (project-scoped is typical):\n\n```json\n{ "mcpServers": { "agentprism-workflows": { "command": "npx", "args": ["-y", "@automatalabs/mcp-server@latest"] } } }\n```\n\nThe stdio command the host spawns is a thin **shim**. It proxies to a shared per-user **workflow daemon** (Streamable HTTP on loopback, auto-started on first use). Runs execute in the daemon, so they survive session end, host restarts, and tool timeouts; only daemon exit can interrupt in-flight work. Any later session can await, inspect, or stop a run. Runs, journals, and logs persist under `~/.agentprism/workflows/` per project namespace.\n\nEvery `run` call names its project with the required `projectDir` argument \u2014 an absolute path, normally the workspace root. One registration serves every project. `inspect`/`await`/`stop` take only a `runId`; the runId locates its project store automatically. Add `--in-process` to the args for the pre-daemon single-process behavior (`projectDir` is then optional), or register the daemon\'s HTTP endpoint directly in HTTP-capable hosts (`agentprism-workflow daemon url` prints snippets). The command resolves at spawn time, so a reconnect (`/mcp` in Claude Code) picks up the latest published version.\n\n### The `workflow` tool, by action\n\n- **Run** (default, no `action`): supply exactly one of `script` (the raw source string, no Markdown fences) or `scriptPath` (an absolute path on the server\'s filesystem), plus `projectDir`. A path is read once at admission and its content snapshotted; later edits affect only a new run. `args` arrives in the script as the `args` global; the run\'s base directory is the `cwd` global. Some hosts hand `args` through as a JSON **string** \u2014 tolerate both shapes (`typeof args === "string" ? JSON.parse(args) : args`). Foreground streams progress but is bound to the request and its timeout. Pass `background: true` for anything that may outlive one request; it acknowledges after durable admission with a `runId`.\n- **Await** (`{ action: "await", runId, waitMs }`): bounded collection for background runs. A timeout is progress, not failure \u2014 call again (`waitMs: 20000` is typical). At terminal status the response adds `outcome`: the authored result or pause context, plus `replayEligibility`, `resumeReport`, `fallbacks`, and `checkpointsTaken`.\n- **Inspect** (`{ action: "inspect", runId, lastN, labelGlob, logLines }`): a bounded snapshot \u2014 the latest matching calls with compact result previews plus the newest log lines. Use a narrow `labelGlob` to diagnose before deciding whether to resume, edit, or stop. Inspection never executes or resumes a script.\n- **Stop**: `{ action: "stop", runId }` durably aborts the whole run and returns its final snapshot; stopping a terminal run is a successful no-op. `{ action: "stop", runId, callIndex }` cancels exactly that in-flight agent: its slot settles to `null` with `AGENT_CANCELLED` and the run stays live. `labelGlob` only filters the returned snapshot; it never selects what to cancel.\n- **Resume**: a NEW run with `resumeFromRunId` plus the script content re-sent (the same `script` or `scriptPath`) and the desired `args` (+ `checkpointReplies` when answering a durable checkpoint). Read the returned `replayEligibility` for the predicted and observed replay prefix; never assume a prefix hit. Full semantics: **Determinism and resume**.\n\n### Operating rules\n\n- **Always retain the returned `runId`.** A paused, failed, or aborted response carries a redacted final-20 `logTail`. Read it before you change anything. Every admitted script is also an immutable resource at `workflow://runs/{runId}/script`, so a later session can recover a lost inline script.\n- **Two fingerprints control replay.** The identity hash covers the prompt, the resolved model, `mode` when set, non-empty sorted `configOptions`, `tier`, `phase`, `agentType`, the resolved agent definition, and the schema. The input fingerprint covers the resolved label, per-call `cwd` and isolation, `keepSession`, images, MCP servers, session/prompt metadata, and the approved script-backend digest.\n- **Operational bounds are not replay inputs.** Host `concurrency`, `agentRetries`, and `agentTimeoutMs`, plus per-call `timeoutMs` and `retries`, enter neither fingerprint. A resume does not inherit them from its source run; pass the values you want on every run. `agentTimeoutMs` caps the wall-clock time of each attempt; it is not an idle timer. A per-call `timeoutMs` can tighten that ceiling but cannot escape it. Each retry gets a fresh clock, so the envelope is `(resolved retries + 1) \xD7 resolved timeout`, with retries clamped to 3.\n- **Old journals stay usable.** Input formats below 2 replay positionally with `fallbackReason: "inputs-format-legacy"`. A current-format crash snapshot uses identity matching even without terminal-environment capture. Ancestor-scoped rows carried from \u22640.23 resume chains replay only while that ancestor run is still persisted. Journals resume across filesystem, environment, engine, Node, and V8 changes; `replayEligibility` reports those differences as diagnostics, never as gates.\n- **A background start returns immediately.** It sends no progress after it returns; collect progress with later bounded awaits. Background runs have no live checkpoint channel, so authored `headless` checkpoint modes apply. When a run\'s owner process dies, cold preflights reconcile stale `pending`/`running` state to `paused` with `pauseReason: "interrupted"`; a live owner is left alone.\n- A run paused with `reason: "auth_required"` resumes as a new run after you log in the backend\'s own CLI out of band.\n\n### Execution logs \u2014 the events resource\n\nEvery journaling run publishes an MCP resource at `workflow://runs/{runId}/events`. Subscribe to the canonical URI for advisory `resources/updated` hints, then read and paginate with `after`, `limit`, and `streamId`. Progress is coarse and redacted: `agentTranscript` rows are assistant/tool upserts partitioned by `(scope, callIndex, executionStartSeq)` and reduced by greatest revision per entry index. The durable cursor is authoritative when hints coalesce or a subscriber falls behind.\n\nEmbedding hosts can drive the same contract with `runDynamicWorkflow` / `WorkflowManager` from `@automatalabs/workflows`; the script contract is identical either way.\n\n## Choosing the agent for each call\n\nThe backend is selected **per `agent()` call** from its effective `model` string. One script can plan on one vendor\'s agent, implement on another\'s, and review on a third\'s, handing structured results between them.\n\nThe built-in names (`claude`, `codex`, `opencode`, `pi`) come from the runtime backend registry. Registered custom names extend that set.\n\n- **Omit `model` entirely** for maximum portability \u2014 the call runs on whatever default backend the host configured (`AGENTPRISM_DEFAULT_BACKEND`, or the host\'s session model). A script with no model specs anywhere runs unchanged on any backend.\n- **Route by one registered first segment.** Split on the first `/`; ASCII-case-insensitive `claude`, `codex`, `opencode`, `pi`, or a registered custom backend name selects that harness and is stripped exactly once. A custom registration wins on a built-in-name collision.\n- **Use a backend name alone** (`claude`, `codex`, `opencode`, `pi`, or a custom name) to preserve the harness\'s configured default model. No model config call is made.\n- **Everything else goes intact to the default backend.** `anthropic/\u2026`, `openai/\u2026`, bare `opus`, and bare `gpt-\u2026` are not routing aliases. When an id remains after routing, it is sent byte-for-byte: no catalog matching, case folding, bracket parsing, effort/Fast option driving, retry, or fallback. Harness rejection is an agent error.\n- **`tier`** (`"small" | "medium" | "big"`) is a coarse alternative resolved from the host\'s tier config \u2014 use it for "a cheap model" without naming a vendor.\n\nThe published examples use ids verified against live harness catalogs: `claude/opus[1m]`, `codex/gpt-5.6-sol`, and `opencode/zai/glm-5.2`. For Pi, `pi/openrouter/vendor/model-id` strips only `pi/`; Pi then splits provider `openrouter` from model id `vendor/model-id`. Prefer backend-only forms when the desired model is configured inside the harness.\n\nNever guess model ids, effort values, or option names from memory \u2014 read the live catalog first:\n\n```bash\nnpx @automatalabs/workflows config                # every routable harness (claude, codex, opencode, pi + registered customs)\nnpx @automatalabs/workflows config codex --json   # one harness, machine-readable\n```\n\nOne no-prompt session per harness, zero tokens: the table lists every negotiable session option \u2014 model ids (including bracket variants like `opus[1m]`), effort levels, modes \u2014 exactly as the installed harness advertises them. One caveat: the bare `config` probe reads each harness with its **default model** selected, and option domains are **model-specific**. An option can appear only after a particular model is selected. Ceilings differ per model. Provider-served variants of the same model can advertise different domains. The authoritative per-model probe is the validator run on your real script: it selects each authored `{ backend, model }` pair first and echoes that pair\'s advertised table. Confirm every pinned model against its own echoed table; do not read package internals to discover options.\n\n```js\nconst plan   = await agent(PLAN_PROMPT,          { label: "plan",      model: "opencode/zai/glm-5.2", schema: PLAN });\nconst impl   = await agent(implPrompt(plan),     { label: "implement", model: "codex/gpt-5.6-sol" });\nconst review = await agent(reviewPrompt(impl),   { label: "review",    model: "claude/opus[1m]", schema: REVIEW });\n```\n\nUse `configOptions` only for exact ACP session options advertised by that routed harness. Read the per-harness advertised-options table first \u2014 `npx @automatalabs/workflows config <harness>`, or the same table in every validator report \u2014 before choosing ids or select values; catalogs vary by harness version, login, and machine.\n\n```js\nconst impl = await agent(implPrompt(plan), {\n  label: "implement",\n  model: "codex",\n  configOptions: { "fast-mode": true, reasoning_effort: "high" },\n});\n```\n\nIds and string/boolean values pass through verbatim in ascending id order, after model selection and before the prompt. There are no aliases, coercion, client-side vocabulary, defaults, or cached catalogs. Copy option ids character-for-character from the catalog, punctuation included \u2014 `"fast-mode"`, not `fast_mode` \u2014 and quote ids that are not valid identifiers. Never put `"model"` in `configOptions`; use the dedicated `model` field. A harness rejection follows the ordinary agent-error path.\n\nPi\'s thought-level option is named `thinkingLevel`, and its choices depend on the exact model in the same call:\n\n```js\nconst review = await agent(REVIEW_PROMPT, {\n  label: "pi-review",\n  model: "pi/openrouter/vendor/model-id",\n  configOptions: { thinkingLevel: "high" },\n});\n```\n\nValidation selects `openrouter/vendor/model-id` before reading Pi\'s choices. A listed value passes unchanged. A recognized value above an ordered model\'s ceiling, or in a model-specific gap, passes with a warning that names the effective clamp target. Pi advertises its SDK-derived domain directly. Claude and Codex are also ordered: when their options omit domain metadata, validation enumerates the advertised models and merges their per-model effort orders. A Claude model without an `effort` option does not support effort, and `default` never becomes a ceiling target. OpenCode and custom backends have no declared value order, so validation is exact-set. An unrecognized or unadvertised value fails with exit code `2`. Enumeration stops at 32 advertised models; a larger or inconsistently ordered catalog warns and falls back to exact advertised-value validation.\n\n**The harness is authoritative.** The client never substitutes a nearby model or silently falls back. A rejected id follows the existing agent-error path; a harness that accepts or ignores it determines the outcome. The public `fallbacks`/`onModelFallback` fields remain for compatibility but model resolution does not emit them.\n\n## Structured output\n\nPass `schema` \u2014 a **plain JSON Schema object literal** (no schema builders exist inside the realm) \u2014 and the call resolves to a **validated object** instead of text:\n\n```js\nconst FINDINGS = {\n  type: "object",\n  additionalProperties: false,\n  required: ["findings"],\n  properties: {\n    findings: {\n      type: "array",\n      items: {\n        type: "object",\n        additionalProperties: false,\n        required: ["file", "line", "summary"],\n        properties: {\n          file:    { type: "string", description: "Repo-relative path \u2014 copy it exactly, never invent one" },\n          line:    { type: "number", description: "1-indexed line the finding anchors to" },\n          summary: { type: "string", description: "One sentence stating the defect, grounded in code you actually read" },\n        },\n      },\n    },\n  },\n};\n\nconst report = await agent("Review the diff on this branch for correctness bugs.", {\n  label: "review", schema: FINDINGS,\n});\nreport.findings.forEach((f) => log(`${f.file}:${f.line} ${f.summary}`));\n```\n\nThe same schema works on **every** backend; only the fulfillment channel differs, and the runner picks it for you: Claude uses its `outputFormat`, Codex its strict `outputSchema`, while Pi, OpenCode, and eligible custom ACP agents receive a client-hosted `StructuredOutput` MCP tool when they advertise HTTP MCP support. Pi accepts stdio, Streamable HTTP, and SSE MCP servers. If no valid tool capture exists, Pi retains the runner\'s common prompt-embedded schema and validated final-text JSON fallback. In every channel the runner validates the value client-side (with type coercion) and re-prompts a bounded number of times before failing the call with non-recoverable `SCHEMA_NONCOMPLIANCE`.\n\nSchema authoring rules that keep all channels healthy:\n\n- Root must be an object; set `additionalProperties: false` and list every property in `required`.\n- Put a `description` on every field \u2014 descriptions are the per-field prompt.\n- Keep schemas structurally simple. Exotic keywords (`oneOf`, `patternProperties`, unusual `format`s, backreference regexes) are normalized or stripped on the wire for some backends \u2014 validation still enforces them client-side, which shows up as re-prompt churn. Prefer `anyOf`, `enum`, and plain types.\n- Keep free-text fields small (tens of lines). An oversized structured output can exhaust schema repair and fail the call.\n- Validation checks structure, not truth. Check load-bearing values in script code (for example, reject findings whose `file` is not in a known file list) before spending more agents on them.\n\n## The `meta` header\n\nEvery script must **begin** with `export const meta = {...}` as a plain object literal (no computed values \u2014 it is parsed from the source text before anything runs):\n\n```js\nexport const meta = {\n  name: "fix-flaky-tests",                        // required\n  description: "Find flaky tests and fix them",   // required\n  phases: [                                        // optional; one { title, detail?, model? } entry\n    { title: "Find", model: "opencode/zai/glm-5.2" },  // per phase() call, matched by exact title;\n    { title: "Fix" },                                  // a phase model is that phase\'s default\n  ],\n  model: "claude/sonnet",                          // optional run-wide default model\n  backends: { /* optional custom ACP agents \u2014 see "Custom ACP backends" */ },\n};\n```\n\nPer-agent model resolution order: explicit `agent({ model })` > `agent({ tier })` > the current phase\'s `model` > `meta.model` > the host session\'s default. So `meta.phases[].model` gives a whole phase a backend without repeating it on every call.\n\n## Fan-out: `parallel` and `pipeline`\n\n```js\n// parallel: an array of THUNKS (not promises!) run concurrently \u2014 a barrier that\n// resolves in input order. A failed slot resolves to null; filter before use.\nconst sweeps = (await parallel([\n  () => agent("Audit error handling in src/server", { label: "sweep:errors", schema: FINDINGS }),\n  () => agent("Audit input validation in src/api",  { label: "sweep:input",  schema: FINDINGS }),\n])).filter(Boolean);\n\n// pipeline: each item flows through the stages independently \u2014 NO barrier between\n// stages, so item A can be in stage 2 while item B is still in stage 1.\n// Stages receive (previousResult, originalItem, index).\nconst verified = (await pipeline(\n  sweeps.flatMap((s) => s.findings),\n  (f) => agent(`Adversarially verify this finding \u2014 try to refute it:\\n${JSON.stringify(f)}`,\n               { label: `verify:${f.file}`, schema: VERDICT }),\n  (verdict, f) => ({ ...f, real: verdict.real }),\n)).filter(Boolean).filter((f) => f.real);\n```\n\n**Default to `pipeline`** for multi-stage work. Add a `parallel` barrier only when the next stage needs *all* prior results at once: dedup across the full set, early-exit on a zero count, or prompts that compare "the other findings". The test is the **information dependency** \u2014 a barrier\'s cost is real, because the fastest worker idles for the slowest. All coordination lives in script code: agents cannot see each other, so never ask an agent to "check with the other reviewers" or "spawn helpers". Passing a promise instead of a thunk to `parallel` is a `TypeError` \u2014 wrap every call: `() => agent(...)`.\n\nFan-out also contends for the **working tree**, not just the concurrency limiter. Two agents running builds or test suites in the same checkout collide on build outputs, caches, and lockfiles, and concurrent `git fetch`es contend on the same `.git`. Give run-things agents `isolation: "worktree"` when the commits they must inspect are reachable from the run cwd\'s repository, or serialize them; fan out freely only the agents that just read.\n\nThe host caps concurrent agents per run (default 8); hand `parallel`/`pipeline` as many items as the task needs and let the limiter schedule them. The cap counts active agent attempts, not authored branches: queued branches begin as other attempts finish, and a branch that exhausts its timeout settles to `null` and frees its slot. `workflow(nameOrScript, args)` nests another workflow inline (one level deep, sharing this run\'s limiter) \u2014 inline script strings always work; saved names resolve when the host serves a workflows folder (see the reference section below).\n\n## Failure semantics \u2014 design for `null`\n\n- A **recoverable** failure (timeout, empty output, transient execution error) is retried per the call\'s `retries` (default 0), then the call **resolves to `null`** \u2014 inside `parallel`/`pipeline` *and* as a bare `await agent(...)`. Null-check anything load-bearing, and set `retries: 1\u20132` on steps you can\'t afford to lose.\n- A host can settle one runaway in-flight call with MCP `{ action: "stop", runId, callIndex }` or SDK `manager.cancelAgentCall(runId, callIndex)`. The call resolves to `null` with `AGENT_CANCELLED`, skips every configured retry, and does not abort the run or its siblings. Its failed call record is not cached as a journal result, so a later resume runs that occurrence live.\n- A **non-recoverable** failure (schema never validated, script bug) throws and fails the run. You *may* `try/catch` around an `agent()` call to degrade gracefully \u2014 rethrow anything you can\'t meaningfully handle. In particular, **always rethrow pause-class errors** (`err.code === "PROVIDER_USAGE_LIMIT"` or `"AUTH_REQUIRED"`): they must propagate out of the script so the engine can pause the run resumably \u2014 swallowing one converts that pause into a fake, lossy completion.\n- A **provider quota wall, missing backend authentication, or opted-in durable checkpoint pauses a managed run instead of failing it** \u2014 the journal checkpoints and the host can resume after the provider quota refills, authentication completes, or a checkpoint decision is supplied. Direct `runner.run()` calls still receive the `AUTH_REQUIRED` error because they have no manager lifecycle.\n- Per-call knobs: `timeoutMs` and `retries`. A finite `timeoutMs` may shorten the host\'s run-level `agentTimeoutMs` ceiling; `null` or omission is uncapped only when the host supplied no ceiling. The timeout is total wall-clock time per attempt, and every retry gets a fresh clock.\n\n## Phases\n\n```js\nphase("Explore");   // open a named phase: subsequent agents group under it\n\nconst found = [];\nwhile (found.length < 20) {\n  const r = await agent("Find one more edge case not in: " + JSON.stringify(found.map((f) => f.name)),\n                        { label: `edge:${found.length}`, schema: EDGE });\n  if (!r) break;\n  found.push(r);\n}\n```\n\nTerminate every loop on a bound the script controls. The agent-count limit (`maxAgents`) is hard: once exhausted, further `agent()` calls throw `AGENT_LIMIT_EXCEEDED`. `phase()` groups agents in progress UIs and run logs; `log(msg)` (and `console.log`) append to the run log \u2014 narrate what matters, especially anything you drop.\n\n## Built-in quality loops\n\nThese helpers spawn their own subagents (on the default model \u2014 hand-roll with `parallel` + `agent` when you want panel members on specific backends). Full signatures in the reference section below.\n\n| helper | shape | use for |\n|---|---|---|\n| `gate(produce, validate, { attempts })` | produce \u2192 validate \u2192 feed `feedback` back; return `{ ok, value, verdict, attempts }` | produce-until-a-reviewer-approves loops that need the final review evidence |\n| `retry(thunk, { attempts, until })` | bounded retry until `until(result)` holds | flaky single steps |\n| `verify(item, { reviewers, threshold, lens })` | N adversarial reviewers vote `real`/not | killing plausible-but-wrong findings |\n| `judgePanel(attempts, { judges, rubric })` | score candidates 0\u20131 against a rubric, return the best | picking among independent solutions |\n| `loopUntilDry({ round, key, consecutiveEmpty, maxRounds })` | repeat a round, dedup by `key`, stop when dry | unknown-size discovery (bugs, edge cases) |\n| `completenessCheck(args, results)` | one critic lists what\'s still missing | a final "what did we not cover?" pass |\n\nThe `gate` pattern, spelled out \u2014 note how the producer thunk threads the validator\'s feedback into a *fresh* agent\'s prompt (sessions have no memory):\n\n```js\nconst outcome = await gate(\n  (feedback, attempt) => agent(\n    `Implement the fix described here:\\n${JSON.stringify(plan)}\\n` +\n    (feedback ? `\\nA reviewer rejected attempt ${attempt}: ${feedback}\\nAddress every point.` : ""),\n    { label: `fix:${attempt + 1}`, model: "codex/gpt-5.6-sol" },\n  ),\n  (result) => agent(\n    `Run the test suite and review this change summary:\\n${result}\\n` +\n    `Return ok=true only if tests pass and the fix is correct; include the reviewed commit SHA.`,\n    { label: "gate-review", model: "claude/opus[1m]", schema: { type: "object", additionalProperties: false,\n      required: ["ok"], properties: { ok: { type: "boolean" }, feedback: { type: "string" },\n        commitSha: { type: "string" } } } },\n  ),\n  { attempts: 3 },\n);\nif (!outcome.ok) log(`reviewer never approved after ${outcome.attempts} attempts`);\nelse log(`reviewer approved commit ${outcome.verdict?.commitSha ?? "(unspecified)"}`);\n```\n\nFeedback is the producer\'s only context for the next attempt. Interpolate everything it needs, and name only files that provably exist.\n\n## Human gates: `checkpoint()`\n\n`checkpoint(promptText, options?)` is a zero-token, journaled human gate. With MCP elicitation (or a live SDK `confirm` callback) it waits for that reply; without a live channel, its default mode takes `default ?? true` immediately, so detached runs never hang.\n\n```js\nconst proceed = await checkpoint(`Apply this plan?\\n${JSON.stringify(plan, null, 2)}`, {\n  kind: "confirm",          // "confirm" | "input" | "select"\n  default: false,           // default headless mode takes this (or true)\n  // headless: "abort",     // abort when no live human is attached\n  // headless: "pause",     // or persist a resumable human-decision pause\n});\nif (!proceed) return { applied: false, plan };\n```\n\n`kind: "input"` resolves to free text, `kind: "select"` to one of `choices`. How the question reaches a human is the host\'s job (elicitation in the MCP server; `ExecOptions.confirm` in the SDK). With no live channel, `headless: "default"` (the default) takes `default ?? true`, `"abort"` aborts, and `"pause"` returns a managed run with `reason: "checkpoint_required"` plus non-secret `checkpointContext`. Resume the last mode with `checkpointReplies: { [context.callIndex]: decision }` or a live confirm. For `resumeFromRunId`, that key is the source context index; an unambiguous identity match may journal the injected answer at a shifted current index. Put a checkpoint before anything hard to reverse \u2014 applying diffs, pushing, publishing, or the first commit into a working copy the workflow did not create (`default: true` keeps detached runs moving).\n\n## Working directory, isolation, confinement\n\n- Every agent session runs in the run\'s base `cwd` unless the call narrows it: `agent({ cwd: "packages/api" })` (relative resolves against the base).\n- `isolation: "worktree"` runs the agent in a **throwaway git worktree** (`<repoRoot>/.agentprism/worktrees/\u2026`) so parallel agents can edit without colliding. The worktree and its branch are **always deleted when the call ends \u2014 an isolated agent\'s file edits are discarded**. Have isolated agents *return their work as data* (a unified diff, a file map, a report) and apply it in a later non-isolated step; use worktrees for experiments, builds, and verification, not for persistent edits. Outside a git repo, isolation degrades to the shared tree with a logged notice.\n- `resume: { filesystem: "read-only" }` is a deprecated compatibility annotation. It is not a runner mode and has no effect on replay; completed calls replay by journal correspondence whether they read or write. Use `mode`, tool policy, prompts, and worktrees when you actually need confinement.\n- `mode` requests an agent-advertised ACP session mode and is **strict** \u2014 an unsupported mode fails the call rather than running unconfined. Mode ids are backend-specific and drift with harness versions: read the advertised `mode` select from `npx @automatalabs/workflows config <harness>` or a validator report (Codex-family examples: `read-only`, `agent`; Claude-family advertises permission modes such as `plan` and `acceptEdits`; OpenCode via its mode option; Pi advertises thinking-level config rather than modes). Only set `mode` on calls whose `model` you also pin. Use read-only/plan modes for reviewers and auditors that must not write.\n- `agentType: "<name>"` binds a reusable subagent definition \u2014 a Markdown file at `<cwd>/.agentprism/agents/<name>.md` (project) or `~/.agentprism/agents/<name>.md` (user; project wins) whose frontmatter sets tool allow/deny lists, a model, and isolation, and whose body is the role prompt. An unknown name logs a warning and degrades to defaults.\n\n## Where a mutating workflow runs\n\nThe run\'s base `cwd` is the USER\'S checkout \u2014 the working copy they launched the host from. Treat it as borrowed: committing onto whatever branch is checked out, switching branches, or resetting it are defects unless the user asked for exactly that. A script that commits should verify its target workspace in a preflight step, or create its own workspace idempotently, and refuse on a mismatch rather than adapt. `isolation: "worktree"` is NOT such a workspace \u2014 it is per-call and throwaway. Note also that a throwaway worktree branches from the run cwd\'s repository: an isolated agent sees another agent\'s commits only when they are reachable there.\n\n## Wiring tools and inputs into a call\n\n- `mcpServers: [{ name, command, args: [], env: [] }]` attaches MCP servers to that agent\'s session \u2014 the portable way to hand any backend a capability (image generation, a browser, a ticket system). The agent sees the server\'s tools natively. Note `env` is a list of `{ name, value }` pairs (ACP shape), not an object map; HTTP/SSE servers use `{ type: "http", name, url, headers: [] }`.\n- `images: [...]` appends base64 image blocks to the prompt (backends without image support receive a bracketed text note instead).\n- `meta` / `promptMeta` pass generic ACP `_meta` through to `session/new` / `session/prompt` \u2014 the escape hatch for driving a custom agent\'s extension surface.\n- `keepSession: true` keeps a successful agent\'s ACP session re-openable after the run: the re-attach record (sessionId, backend, effective pool identity, cwd, reopen capabilities) lands in `WorkflowRunResult.agentSessions`, and the HOST can continue that conversation later via `runner.loadSession()`. Usage/auth pause failures are kept open automatically so managed resume can continue the interrupted occurrence. Scripts themselves never request reattach.\n\n### Custom ACP backends\n\nAny process that speaks ACP over stdio can serve `agent()` calls \u2014 an in-house browser-QA agent, an image generator, a domain-specific executor. Two ways in:\n\n1. **Host-registered** (preferred): the embedder passes `createAcpRunner({ backends: { browser: { command: "/abs/browser-acp" } } })`; the script just routes with `model: "browser"`.\n2. **Script-declared**: the script itself declares the backend in `meta.backends` \u2014 but declarations are **inert until the host approves them** (an elicitation in the MCP server; `allowScriptBackends` in the SDK), because they spawn commands on the host machine. Don\'t rely on them silently working.\n\n```js\nexport const meta = {\n  name: "checkout-qa",\n  description: "Implement, then QA the checkout flow in a real browser",\n  backends: {\n    browser: { command: "browser-acp", args: ["--headless"] },  // requires host approval\n  },\n};\n\nconst change = await agent("Implement the coupon-code field per the spec in docs/coupon.md.",\n                           { label: "implement" });              // default backend\nconst verdict = await agent(\n  `Open the app, walk through checkout with coupon SAVE20, and verify the discount line. Change summary:\\n${change}`,\n  { label: "qa", model: "browser",                               // the custom agent\n    schema: { type: "object", additionalProperties: false, required: ["passed"],\n              properties: { passed: { type: "boolean" }, notes: { type: "string" } } } },\n);\nreturn { change, qa: verdict };\n```\n\nStructured output works on custom backends through the same injected-tool/fallback ladder as OpenCode \u2014 no special-casing in the script.\n\n## Determinism and resume\n\nRuns are journaled: every `agent()` and `checkpoint()` result is recorded under a deterministic call index. A new run may reuse eligible results from a terminal source run. Uncertainty always means live execution.\n\n> **Resume rule:** replay is content-addressed and fail-to-live on correspondence: a completed call replays when its identity and input fingerprint match uniquely. Filesystem or world state never gates replay.\n\n- Direct `Date.now()`, `Math.random()`, and no-arg `new Date()` / `Date()` calls fail static validation. The realm also blocks aliased or computed forms at runtime; `new Date(isoString)` is fine. Pass timestamps and random seeds through `args`.\n- The replay identity of an `agent()` call hashes: the prompt, the resolved `model`, `mode` when set, `configOptions` when non-empty (sorted keys), `tier`, `phase`, `agentType`, the resolved agent definition, and `schema`. The resolved agent definition includes its tool allowlist and denylist, model, isolation, and body prompt \u2014 editing a definition invalidates the calls that use it.\n- A separate input fingerprint hashes: the resolved label, per-call `cwd`, resolved isolation, `keepSession`, `images`, `mcpServers`, `meta`, `promptMeta`, and the approved script-backend digest.\n- Host `agentTimeoutMs`, `agentRetries`, and `concurrency`, plus per-call `timeoutMs` and `retries`, are operational bounds. They enter neither hash and may change freely on resume. A new run resolves them from its own request; it does not inherit the source values.\n- `args` is not hashed directly. New args that only raise a loop cap leave earlier identities unchanged, so those calls can replay. New args that change a prompt, model selection, phase, schema, call order, or runner-visible input make the affected calls run live. Unchanged independent calls may still replay.\n- Matching tries a unique exact `(kind, call path, identity hash)` row first (`"path-hash"`), then a unique `(kind, identity hash, input fingerprint)` row, so an unchanged call can replay as `"unique-hash"` after insertions or deletions. Source and current input fingerprints must be equal. Duplicate identities, duplicate content, consumed candidates, missing facts, and empty schema-less results run live. The engine never guesses by source order or occurrence.\n- Source admission requires: exact `cwd`, compatible call-path/input/checkpoint fingerprint formats, complete call/journal/allocation metadata, and a valid manifest and seed. Git HEAD and dirty digest, `environmentKey`, captured environment values, Node/V8, and producing engine version are diagnostics only. Environment differences may appear in `replayEligibility.provenanceChanges`; they never gate admission or matching.\n- A completed writer replays exactly like a reader. A live call, nested workflow, host checkpoint callback, or degraded worktree does not clear unrelated candidates. Nested child calls run live \u2014 they are outside the parent\'s journal \u2014 while matching root calls around them still replay. The engine does not reproduce file writes; a later live agent navigates the world it finds.\n- Replay costs zero current provider usage: a cached call returns its recorded result without spawning a session. Replayed session records keep their backend and session identity, rebound to the current call index, label, and phase.\n- A root call interrupted by `PROVIDER_USAGE_LIMIT` or `AUTH_REQUIRED` can continue its recorded session on either resume API. Continuation requires: the exact call index, identity hash, complete input fingerprint, non-worktree isolation, identical existing cwd, a coherent recorded session, and the runner\'s current backend/`poolKey`/reopen gates. A successful continuation finishes the unfinished turn and charges only its usage delta. Every failed gate runs fresh, and `fallbacks` records the reopen method or the exact skip reason. No script option controls this.\n- Completed checkpoint results replay when the identity and the `default`/`headless`/`timeoutMs` fingerprint match \u2014 headless results included. `checkpointReplies` keys always name the checkpoint index in the source run. A moved reply can follow intact prior correspondence; after a live divergence it must reach the exact recorded call site, so a different same-text branch cannot consume it.\n- `resumePolicy: "positional"` is a migration escape hatch for index/prefix matching. It cannot bypass format, metadata, manifest, cwd, or input checks. Marker-less, manual, and same-ID legacy journals keep historical hash-only positional behavior. Input formats below 2 use the `inputs-format-legacy` positional bridge and are rewritten under the current format on the next hop. A current-format crash snapshot with a valid identity manifest uses identity matching even without terminal-environment capture.\n- `label`, `cwd`, `mcpServers`, `images`, `meta`, `promptMeta`, and `keepSession` are not identity-hashed: changing one does not invalidate an ordinary replay. They are in the input fingerprint: changing one rejects continuation of an interrupted turn, and that occurrence runs fresh. To force a completed call to run again, change a hashed field \u2014 normally the prompt.\n- Keep call order deterministic. Derive iteration from `args` and prior agent results, never from ambient state.\n\nEvery `resumeFromRunId` result has a bounded `replayEligibility` summary. Background admission, foreground completion, both await shapes, and inspect expose the same fields: strategy, predicted replayable-prefix length, observed replayed prefix and counts, and the first non-replay when known. Active correspondence reasons include `strategy-live`, `positional-miss`, `positional-suffix`, `not-recorded`, `path-missing`, `inputs-missing`, `inputs-changed`, `ambiguous-identity`, `ambiguous-content`, `candidate-consumed`, `empty-output`, `worktree-degraded`, `seed-persistence-error`, and `resume-fatal-latch`. Older reason literals stay exported only so historical journals parse. Engine and input-format versions and environment provenance ride along as diagnostics.\n\nAn all-live outcome means correspondence could not be established \u2014 not that the world changed. Missing resume metadata, incompatible format literals, or an invalid manifest or seed disable new-format replay. If any source row lacks a captured path or input fact (possible past the raw-frame cap, or with a non-strict-JSON `meta` value), the whole source is `"manifest-invalid"`: dropping the row could make an ambiguous sibling look unique.\n\n### Worked resume \u2014 raise a loop cap\n\nThe following workflow (shipped as `examples/resume-loop-cap.workflow.js`) requires eight reviews but lets the caller cap how many are attempted in one run:\n\n```js\nexport const meta = {\n  name: "resume-loop-cap",\n  description: "Run expensive review rounds up to an args-controlled cap",\n  phases: [{ title: "Review" }],\n};\n\nconst input = args && typeof args === "object" && !Array.isArray(args) ? args : {};\nconst numericCap = Number(input.maxRounds);\nconst maxRounds = Number.isInteger(numericCap) && numericCap > 0 ? numericCap : 8;\n\nphase("Review");\nconst rounds = [];\nfor (let i = 0; i < maxRounds; i += 1) {\n  rounds.push(\n    await agent(\n      `Review round ${i + 1}: inspect the repository and report unresolved release blockers.`,\n      { label: `review:${i + 1}`, phase: "Review" },\n    ),\n  );\n}\n\nif (maxRounds < 8) throw new Error(`review cap ${maxRounds} reached before 8 rounds`);\nreturn { rounds };\n```\n\nRun it with `args: { "maxRounds": 6 }`. Then send the same content (via `script`, or the absolute `scriptPath` you edit) with `args: { "maxRounds": 8 }` and the first result\'s `runId` as `resumeFromRunId`. Rounds 1\u20136 replay for zero current provider tokens; only rounds 7\u20138 run live, because the cap controls call count but is not interpolated into the round prompt. If every round prompt included `maxRounds`, all eight identities would change and all would run live. Resume always states its content; a bare `resumeFromRunId` never silently reuses the old script.\n\nGive repeated calls stable, descriptive labels and narrate decisions with `log()` \u2014 inspection by `labelGlob` then turns a pause or failure into a diagnosis instead of a guess.\n\n### Kill, patch, resume\n\nStop the live run with `{ action: "stop", runId }`. The returned `aborted` snapshot is the durable acknowledgement: resume is safe immediately, and a further await adds nothing. Edit the file. Start a new run with its absolute `scriptPath` and `resumeFromRunId`. Every completed call whose recorded identity and input fingerprint correspond replays, regardless of filesystem or environment drift. Read `replayEligibility` and the full `resumeReport` for the per-call decisions. A repeated stop of a terminal run is a successful no-op.\n\nRegistration, the per-action contracts, background collection, and the events resource are covered in the **Running workflows** section above. Resume a durable checkpoint pause by re-sending the script with `resumeFromRunId` and `checkpointReplies` keyed by the source run\'s `checkpointContext.callIndex`.\n\n## Worked example \u2014 cross-vendor build with every major primitive\n\n```js\nexport const meta = {\n  name: "feature-build",\n  description: "Plan, gate on approval, implement, cross-vendor review, fix until green",\n  phases: [{ title: "Plan" }, { title: "Implement" }, { title: "Review" }],\n};\n\nconst PLAN = { type: "object", additionalProperties: false, required: ["steps", "risks"],\n  properties: {\n    steps: { type: "array", items: { type: "string", description: "One concrete implementation step" } },\n    risks: { type: "array", items: { type: "string" } } } };\nconst VERDICT = { type: "object", additionalProperties: false, required: ["ok"],\n  properties: { ok: { type: "boolean" },\n                feedback: { type: "string", description: "Required when ok=false: concretely what to change" } } };\n\nphase("Plan");\nconst plan = await agent(\n  `Study this repo, then write an implementation plan for: ${args.feature}. Keep steps concrete.`,\n  { label: "plan", model: "opencode/zai/glm-5.2", schema: PLAN },\n);\n\nconst approved = await checkpoint(\n  `Implement "${args.feature}" with this plan?\\n- ${plan.steps.join("\\n- ")}\\nRisks: ${plan.risks.join("; ")}`,\n  { kind: "confirm", default: true },\n);\nif (!approved) return { implemented: false, plan };\n\nphase("Implement");\nconst outcome = await gate(\n  (feedback, attempt) => agent(\n    `Implement: ${args.feature}\\nPlan:\\n- ${plan.steps.join("\\n- ")}\\n` +\n    `Run the project\'s tests before finishing and report results.` +\n    (feedback ? `\\n\\nReviewer feedback on attempt ${attempt}:\\n${feedback}\\nAddress every point.` : ""),\n    { label: `implement:${attempt + 1}`, model: "codex/gpt-5.6-sol", retries: 1 },\n  ),\n  async (report) => {\n    if (!report) return { ok: false, feedback: "implementation agent produced no result" };\n    phase("Review");\n    const reviews = (await parallel([   // two reviewers on different vendors\n      () => agent(`Review the working-tree diff for correctness. Implementer\'s report:\\n${report}`,\n                  { label: "review:correctness", model: "claude/opus[1m]", schema: VERDICT }),\n      () => agent(`Review the working-tree diff for regressions and missing tests. Report:\\n${report}`,\n                  { label: "review:coverage", model: "opencode/zai/glm-5.2", schema: VERDICT }),\n    ])).filter(Boolean);\n    const rejections = reviews.filter((r) => !r.ok);\n    return rejections.length\n      ? { ok: false, feedback: rejections.map((r) => r.feedback).join("\\n"), reviews }\n      : { ok: true, reviews };\n  },\n  { attempts: 3 },\n);\n\nreturn { implemented: outcome.ok, attempts: outcome.attempts, reviewVerdict: outcome.verdict, plan };\n```\n\n(The planner would ideally run read-only, but mode ids are backend-specific \u2014 this call routes to OpenCode, so it leaves `mode` unset rather than guessing; a Claude-routed planner could safely say `mode: "plan"`.)\n\n## Worked example \u2014 fully backend-agnostic audit\n\nNo `model` anywhere: this script runs unchanged on whatever backend the host defaults to.\n\n```js\nexport const meta = {\n  name: "edge-case-audit",\n  description: "Exhaustively hunt edge-case bugs in a target dir, verify each, report gaps",\n  phases: [{ title: "Hunt" }, { title: "Verify" }],\n};\n\nconst BUGS = { type: "object", additionalProperties: false, required: ["bugs"],\n  properties: { bugs: { type: "array", items: { type: "object", additionalProperties: false,\n    required: ["file", "scenario"], properties: {\n      file: { type: "string", description: "Repo-relative path you actually opened" },\n      scenario: { type: "string", description: "Concrete input/state \u2192 wrong behavior" } } } } } };\n\nphase("Hunt");\nconst seen = [];   // what earlier rounds reported, threaded into each new prompt\nconst candidates = await loopUntilDry({\n  round: async (i) => {\n    const r = await agent(\n      `Round ${i + 1}: find edge-case bugs in ${args.target} not already in this list:\\n` +\n      JSON.stringify(seen) + `\\nOnly report what you can ground in code you read.`,\n      { label: `hunt:${i + 1}`, schema: BUGS },\n    );\n    const bugs = r ? r.bugs : [];\n    seen.push(...bugs);\n    return bugs;      // loopUntilDry dedups these by `key` across rounds\n  },\n  key: (b) => `${b.file}:${b.scenario}`,\n  consecutiveEmpty: 2,\n  maxRounds: 8,\n});\n\nphase("Verify");\nconst confirmed = (await pipeline(\n  candidates,\n  (bug) => verify(bug, { reviewers: 3, threshold: 0.66, lens: ["correctness", "reproducibility"] }),\n  (v, bug) => (v.real ? bug : null),\n)).filter(Boolean);\n\nconst gaps = await completenessCheck(args, confirmed);\nlog(`${confirmed.length}/${candidates.length} confirmed; complete=${gaps.complete}`);\nreturn { confirmed, missing: gaps.missing ?? [] };\n```\n\n## Full-scale example scripts\n\nWhen the inline examples above aren\'t enough, study the complete, validated scripts that ship with the published authoring skill:\n\n- [`repo-triage.workflow.js`](https://github.com/agentprism/agentprism-workflows/blob/main/skills/agentprism-workflow-authoring/examples/repo-triage.workflow.js) \u2014 an autonomous cross-vendor repo triage and the broadest support-API tour: `pipeline` with no inter-stage barrier, a cross-vendor verification panel, `gate()` where writer and reviewer are different vendors, nesting a saved workflow by name, `completenessCheck()`, stage gating on tracked counters, string-form `args` hardening, path guards on schema outputs, and pause-class error rethrow.\n- `quick-wins.workflow.js` (included in full at the end of this document) \u2014 a small hunter that runs standalone *or* nested: `loopUntilDry()` with per-round vendor rotation, dedup threading via a `seen` list, and a tracked round bound (nested runs share the parent\'s limiter).\n- [`resume-loop-cap.workflow.js`](https://github.com/agentprism/agentprism-workflows/blob/main/skills/agentprism-workflow-authoring/examples/resume-loop-cap.workflow.js) \u2014 content-addressed replay: run with a low `maxRounds`, resume with a higher one; unchanged rounds replay for zero tokens (worked through in Determinism and resume).\n\n[`examples/README.md`](https://github.com/agentprism/agentprism-workflows/blob/main/skills/agentprism-workflow-authoring/examples/README.md) maps each script to what it teaches.\n\n## Validate before you run\n\nThe SDK ships a validator that costs **zero tokens** \u2014 always run it on a script you just wrote or edited:\n\n```bash\nnpx @automatalabs/workflows validate my-workflow.js --args \'{"target":"src/"}\'\n```\n\nIt does three passes. First, a **static parse**: the `meta` literal, syntax, and direct\nnondeterministic call expressions. Second, a **dry run**: the engine runs the script\'s control flow\nin its realm, with every `agent()` call served by a mock backend that fabricates\nschema-conforming results \u2014 no real agent runs, and validation is not an execution of the\nworkflow. Third, one no-prompt session for each distinct routed `{ backend, model\n}` pair. The third pass spends no tokens, selects each authored call model, and echoes that pair\'s\nmodel-specific config-options table in the report. Read that table before picking `configOptions`\nvalues; unknown ids, bad select values, wrong value types, and the reserved `"model"` key fail\nvalidation with the call label, authored value, and alternatives. If a routed pair cannot spawn,\nauthenticate, select its model, or open a session, validation emits one warning, marks it\n`probed:false`, skips only that pair\'s checks, and stays valid \u2014 the offline degradation behavior. A\nmock live confirm answers checkpoints with `default ?? true`, so `headless: "pause"` dry-runs\ncleanly; `headless: "abort"` warns because a truly unattended run would abort. Script-declared\n`meta.backends` are treated as approved. The report lists every call with its backend attribution,\nplus warnings for undeclared phases, `headless: "abort"` checkpoints, and zero agent calls.\n(Option-domain clamping rules are in Backends and structured output; the full flag table and\nmock-answer grammar are in `reference.md`.)\n\nThe default fabricator returns `true` for every boolean. Do not accept that all-true path as proof that a convergence loop works: script its control labels with `--mock-answers` or a reusable `--mock-answers-file`. Use a finite `$sequence` such as reject-then-approve so validation executes the revision branch and proves the loop stops; the report identifies every consumed and unused fixture without printing answer bodies.\n\nSave reusable mock answers beside the workflow file (`<name>.mock.json`). When a default-fabrication dry run leaves declared phases unexecuted, your guard branches fired \u2014 script the mocks that reach past them instead of shrugging at the warnings.\n\nExit codes: `0` valid \xB7 `1` parse failure \xB7 `2` dry-run or config-option failure. The full flag table, mock-answers grammar, and limits are in `reference.md`.\n\nThe third pass\'s table is also available standalone \u2014 before any script exists \u2014 as validate\'s sibling command: `npx @automatalabs/workflows config [harness ...]` (default: every routable harness; `--json`; exit `1` when a probe fails). Use `config` while authoring to pick values; validate\'s copy then confirms the script you wrote against the same live catalog.\n\nIf the script nests saved workflows by name (`workflow("review-pr")`), pass the folder so names resolve \u2014 and the positional itself may then be a name: `npx @automatalabs/workflows validate review-pr --workflows-dir ./workflows`. A green dry run proves structure, not judgment \u2014 prompts and schemas still deserve review.\n\n---\n\n# Workflow script reference\n\nExhaustive tables for the AgentPrism workflow script DSL. The guide above covers authoring; this section is the lookup companion. Everything here is verified against `@automatalabs/workflow-engine` / `@automatalabs/acp-agents` as shipped with `@automatalabs/workflows`.\n\n## `agent(prompt, options?)` \u2014 full option table\n\nReturns the agent\'s final assistant text, or the schema-validated object when `schema` is set. Resolves to `null` when a *recoverable* failure survives all retries.\n\n| option | type | meaning |\n|---|---|---|\n| `label` | `string` | Display/telemetry name; also stamped on every live ACP event for this call. Always set it. Not part of the resume hash. |\n| `phase` | `string` | Assign this call to a phase explicitly (needed inside concurrent stages where the global `phase()` state would race). |\n| `schema` | JSON Schema object | Structured output. Plain object literal only \u2014 no schema builders exist in the realm. Part of the resume hash. |\n| `model` | `string` | Model spec: optional registered harness prefix plus a verbatim id, or a backend-only name. See [Model specs & routing](#model-specs--routing). Part of the resume hash. |\n| `tier` | `"small" \\| "medium" \\| "big"` | Coarse tier resolved from host config; beats phase/meta model, loses to explicit `model`. Part of the resume hash. |\n| `mode` | `string` | ACP session mode id advertised by the selected backend. **Strict**: unsupported/unadvertised ids fail the call (never silently unconfined). Ids are backend-specific and drift with harness versions \u2014 read the advertised `mode` select from the config probe or a validator report (Codex-family examples: `read-only`, `agent`, `agent-full-access`; Claude-family advertises permission modes such as `plan`, `acceptEdits`, and `dontAsk`). Part of the resume hash when set. |\n| `configOptions` | `Record<string, string \\| boolean>` | Exact ACP session option ids and authored values. Applied in ascending id order after model and before the prompt, with no aliases or coercion. `"model"` is reserved for the dedicated `model` field. Part of the resume hash only when non-empty, with sorted keys. Read the advertised-options table first (`agentprism-workflows config <harness>`, or any validate report) before choosing values. |\n| `agentType` | `string` | Bind a named subagent definition (tools allow/deny, model, isolation, role prompt). See [agentType definitions](#agenttype-definitions). Part of the resume hash. |\n| `isolation` | `"worktree"` | Run in a throwaway git worktree branched from the run cwd. **Always removed (worktree + branch) when the call ends** \u2014 edits are discarded; return work as data. Degrades to the shared tree outside a git repo (logged). |\n| `resume` | `{ filesystem: "read-only" }` | Deprecated compatibility annotation. It is recorded as legacy diagnostic provenance, is not sent to the runner or hashed, and has no effect on replay. New scripts should omit it. |\n| `cwd` | `string` | Per-session working directory; relative resolves against the run\'s base cwd. Overridden by worktree isolation. Not hashed. |\n| `timeoutMs` | `number \\| null` | Total wall-clock cap for each attempt. A finite value may tighten a finite host `agentTimeoutMs` ceiling but cannot raise or disable it. With no host ceiling, a finite value applies and `null`/omitted is uncapped. |\n| `retries` | `number` | Retries after *recoverable* failures (default 0, host-overridable). Exhausted retries \u21D2 the call resolves `null`. |\n| `mcpServers` | `McpServerConfig[]` | MCP servers attached to this session. Stdio shape: `{ name, command, args: [], env: [{ name, value }] }` (`args`/`env` required, `env` is name/value pairs, not a map); `{ type: "http" \\| "sse", name, url, headers: [] }` also accepted. Not hashed. |\n| `images` | `PromptImage[]` | Base64 image blocks appended to the prompt; backends without image support get a bracketed text note. Not hashed. |\n| `meta` | `object` | ACP `_meta` merged into `session/new` \u2014 session-scoped extension passthrough (pairs with custom backends). Not hashed. |\n| `promptMeta` | `object` | ACP `_meta` merged into `session/prompt` \u2014 turn-scoped passthrough. Backend-computed keys win on conflict. Not hashed. |\n| `keepSession` | `boolean` | Skip release-time best-effort `session/close`; the non-secret re-attach record lands in `WorkflowRunResult.agentSessions` for host-side `loadSession()` / `resumeSession()`. Usage/auth pause failures are kept open automatically for managed continuation. Not identity-hashed; included in the input fingerprint. |\n\nThe timeout clock measures the whole attempt, including backend startup, model/config setup, tool\nwork, and streamed output; it is not an idle timer. Each retry starts a fresh clock, so the maximum\ntimeout envelope is `(retries + 1) \xD7 resolved timeoutMs` (retries are clamped to 3). An exhausted\ntimeout is recoverable `AGENT_TIMEOUT`: the call resolves to `null`, releases its concurrency slot,\nand asks the ACP session to cancel. A session that keeps running after the cancellation grace is\nclosed where supported and its pooled child is recycled.\n\nEvery new run, including one admitted with `resumeFromRunId`, resolves host limits from that run\'s\nrequest. It does not inherit `agentTimeoutMs`, retries, concurrency, or agent-count values from\nits source, so pass every operational bound the resumed execution should use.\n\n## Model specs & routing\n\nA `model` string is resolved solely from its first segment, then delegated to the harness:\n\n| spec shape | routes to | notes |\n|---|---|---|\n| *(omitted)* | host default backend | `AGENTPRISM_DEFAULT_BACKEND` (`claude` \\| `codex` \\| `opencode` \\| `pi` \\| custom name; default `claude`), session default model. Most portable. |\n| `claude`, `codex`, `opencode`, `pi`, or `<custom-name>` | that registered harness | Backend-only: no model config call; the harness default remains active. |\n| `claude/<id>`, `codex/<id>`, `opencode/<id>`, `pi/<id>`, or `<custom-name>/<id>` | that registered harness | Match the first segment ASCII-case-insensitively and strip exactly one segment. Custom names take priority on collision. The remaining `<id>` is sent verbatim, including further `/` characters. For Pi, that remainder is its `<provider>/<model-id>` and Pi preserves any further slashes in the model id. |\n| any other string, including `anthropic/\u2026`, `openai/\u2026`, bare `opus`, or bare `gpt-\u2026` | host default backend | The **entire** authored string is sent verbatim; these are not routing aliases. |\n\nSelection is a single `session/set_config_option` with `configId: "model"` and the exact remaining string. There is no catalog matching, case folding, normalization, bracket parsing, nearest-neighbor selection, sibling effort/Fast option driving, retry, or echo verification. Brackets, dots, and provider-style prefixes are ordinary model-id characters.\n\nWhatever the harness returns is the outcome. A rejection follows the existing agent-error path with no resolution-specific code or model fallback event. `onModelFallback` and `WorkflowRunResult.fallbacks` remain public compatibility surfaces; model resolution does not emit entries, while pause recovery emits `kind: "continuation"` reattach/skip notices.\n\n## Structured output channels\n\nOne author API (`schema`), four fulfillment paths \u2014 chosen automatically per backend:\n\n| backend | channel |\n|---|---|\n| Claude | native `outputFormat`, schema normalized to Anthropic\'s structured-outputs subset (e.g. `oneOf` \u2192 `anyOf`; unsupported keywords/formats stripped on the wire) |\n| Codex | native strict `outputSchema` (OpenAI strict subset normalization) |\n| Pi | a client-hosted `StructuredOutput` MCP tool injected when the agent advertises HTTP MCP support; common prompt-embedded schema and validated final-text JSON fallback |\n| OpenCode / custom ACP | a client-hosted **`StructuredOutput` MCP tool** injected into the session when the agent advertises HTTP MCP support (an agent may show it as `structured_output_StructuredOutput`); otherwise prompt-embedded schema + JSON parse of the final message. Custom backends can opt out of tool injection with `structuredOutputTool: false`. |\n\nPi accepts stdio, Streamable HTTP, and SSE MCP servers; ACP-transport MCP hosting remains client-side.\n\nIn every channel the runner coerces + validates client-side and re-prompts a bounded number of times; the final miss fails the call with non-recoverable `SCHEMA_NONCOMPLIANCE`. Constraints stripped from the wire are still enforced client-side \u2014 an exotic schema keyword shows up as re-prompt churn, so keep schemas simple.\n\n## DSL globals \u2014 complete signatures\n\n```\nagent(prompt, options?)                    \u2192 Promise<string | object | null>\nparallel(thunks)                           \u2192 Promise<results[]>   // barrier; input order; failed slot = null\npipeline(items, ...stages)                 \u2192 Promise<results[]>   // no inter-stage barrier; stage(prev, original, index); failed item = null\nworkflow(nameOrScript, args?)              \u2192 Promise<unknown>     // one nesting level; names resolve from the host\'s workflows folder, inline scripts always work\ngate(thunk, validator, { attempts = 3 })   \u2192 { ok, value, verdict, attempts }\n    // thunk(feedback, attempt); validator(result) \u2192 { ok, feedback?, ... } | boolean | null (may be async / an agent call)\nretry(thunk, { attempts = 3, until? })     \u2192 last result           // thunk(attempt); stops early when until(result)\nverify(item, { reviewers = 2, threshold = 0.5, lens? })\n    \u2192 { real, realCount, total, votes: [{ real?, reason? }] }\n    // N adversarial reviewers prompted to REFUTE; lens (string | string[]) rotates focus per reviewer\njudgePanel(attempts, { judges = 3, rubric = "overall quality and correctness" })\n    \u2192 { index, attempt, score, judgments }  // mean 0\u20131 score per candidate; stable tie-break by index\nloopUntilDry({ round, key = JSON.stringify, consecutiveEmpty = 2, maxRounds = 50 })\n    \u2192 unique items[]   // round(i) returns items; stops after N dry rounds; agent-limit exhaustion returns the partial result\ncompletenessCheck(taskArgs, results)       \u2192 { complete, missing?: string[] }\ncheckpoint(promptText, options?)           \u2192 Promise<reply>       // journaled human gate; zero tokens\nphase(title)                               \u2192 void                 // open a named phase\nlog(message)                               \u2192 void                 // console.log/info/warn/error route here too\nargs                                       // the host-provided input value, verbatim\ncwd                                        // the run\'s base working directory (string); process.cwd() returns it too\n```\n\nFor `gate()`, `value` is the final producer result and `verdict` is the exact last completed\nvalidator return, including any extra structured fields. `{ ok: true }` and bare `true` pass;\n`{ ok: false, feedback? }`, bare `false`, and `null` reject. Only object feedback is threaded into\nthe next producer attempt. A producer result of `null` is still passed to the validator. Producer\nor validator exceptions propagate immediately, so no partial gate result is returned and no later\nattempt runs. An explicit unsupported `undefined` validator return is a rejection represented as\n`verdict: null`. If the script returns the gate result, its complete verdict is persisted and may\nreach the host; keep evidence concise and never put credentials or other secrets in verdict data.\n\n`verify`, `judgePanel`, and `completenessCheck` spawn their subagents on the run\'s default model \u2014 hand-roll with `parallel` + `agent` to pin panel members to specific backends.\n\n## `checkpoint()` options\n\n| option | type | meaning |\n|---|---|---|\n| `kind` | `"confirm" \\| "input" \\| "select"` | Reply shape: boolean-ish / free text / one of `choices`. Affects the journal hash and the host UI widget. |\n| `choices` | `string[]` | For `kind: "select"`. |\n| `default` | `unknown` | Reply taken in the default headless mode \u2014 journaled like a real reply. Defaults to `true`. |\n| `headless` | `"default" \\| "abort" \\| "pause"` | No live channel: `"default"` takes `default ?? true`, `"abort"` aborts, and `"pause"` creates a persisted `checkpoint_required` pause. Default `"default"`. |\n| `timeoutMs` | `number` | Deadline for the interactive prompt. |\n\nThe host supplies the live human channel (elicitation in the MCP server; `ExecOptions.confirm` in the SDK), and that channel wins even when `headless: "pause"` is declared. A durable pause carries non-secret `checkpointContext`; resume with `ExecOptions.checkpointReplies: { [context.callIndex]: decision }` or attach a live channel. On a new `resumeFromRunId` execution, reply keys always name indexes in the **source** recording; identity matching may inject that decision at a shifted current index. Completed host and headless checkpoint results both replay when identity and the checkpoint-options fingerprint over `default`, `headless`, and `timeoutMs` match. A changed option or ambiguous match runs fresh. Detached runs never pause for a checkpoint unless the author opts into `"pause"`.\n\n## Error codes (`WorkflowError.code`)\n\n| code | recoverable | engine behavior |\n|---|---|---|\n| `AGENT_TIMEOUT` | yes | Total wall-clock attempt cap exhausted. Every retry gets a fresh clock; after the final attempt the call resolves `null`, and ACP cancel escalates to close/recycle when the turn does not stop. |\n| `AGENT_CANCELLED` | yes | The host selected this in-flight call for cancellation. It resolves `null` immediately through an engine race, skips retries, leaves the run live, and is recorded as a failed call rather than a replayable journal result. |\n| `AGENT_EMPTY_OUTPUT` | yes | No assistant text on a schema-less call; same retry-then-`null`. |\n| `AGENT_EXECUTION_ERROR` | yes* | Generic agent failure (*refusal/truncation variants are non-recoverable). |\n| `SCHEMA_NONCOMPLIANCE` | no | Structured output never validated after the re-prompt ladder. Halts the run (catchable in-script). |\n| `PROVIDER_USAGE_LIMIT` | no | Quota/rate wall \u2014 the run **pauses** (journaled, resumable), with the provider\'s reset hint. |\n| `AGENT_LIMIT_EXCEEDED` | no | `maxAgents` cap hit. |\n| `AUTH_REQUIRED` | no | Backend needs authentication. `WorkflowManager` returns a resumable pause with `reason: "auth_required"` and redacted `authContext`; a direct runner throws. The host completes auth before resuming/retrying. |\n| `CHECKPOINT_REQUIRED` | no | `headless: "pause"` reached without a live channel. `WorkflowManager` returns `reason: "checkpoint_required"` plus non-secret `checkpointContext`; resume with `checkpointReplies` or live confirm. |\n| `SCRIPT_VALIDATION_ERROR` | no | Script failed parse/validation (bad meta, nondeterministic API, bad `meta.backends` shape). |\n| `SCRIPT_ERROR` | no | The script itself crashed (uncaught throw, floated rejection). |\n| `WORKFLOW_ABORTED` | \u2014 | Real cancellation (pause/stop/host signal) \u2014 never used for crashes. |\n\n`loopUntilDry` absorbs `AGENT_LIMIT_EXCEEDED` from its rounds and returns the partial result; everywhere else it propagates.\n\n## Determinism & the resume journal\n\n> **Resume rule:** replay is content-addressed and fail-to-live on correspondence: a completed call replays when its identity and input fingerprint match uniquely. Filesystem or world state never gates replay.\n\nThe guide section **Determinism and resume** carries the full semantics: what each hash contains, matching, admission, continuation of interrupted calls, and checkpoint replay. Wire-level specifics for lookup:\n\n- Each `agent()` result is journaled under a monotonic call index and a SHA-256 identity hash. The canonical identity fields, in order, are `prompt`, resolved `model`, `mode` only when set, `configOptions` only when non-empty, `tier`, `phase`, `agentType`, resolved `agentDef`, and `schema`. Config-option keys are sorted before serialization. Missing fields other than `mode` and `configOptions` serialize as `null`; an unset `mode` and an unset/empty `configOptions` key are omitted for compatibility with older journals.\n- `agentDef` is the resolved definition\'s tools, disallowed tools, model, isolation, and body prompt. Changing a named definition therefore invalidates its call even when the `agentType` name is unchanged.\n- The legacy `resume: { filesystem: "read-only" }` annotation has no effect on admission or matching. Writers, readers, worktree calls, and unannotated calls follow the same journal rule.\n- `resumePolicy: "positional"` requests index/prefix correspondence but cannot bypass new-format format, metadata, manifest, cwd, or input checks. Marker-less journals and permanently marked manual/same-run legacy resumes retain historical hash-only positional behavior. Sources below input format 2 use `inputs-format-legacy`. Ancestor-scoped rows carried by a \u22640.23 resume hop replay only while that ancestor is still persisted; engine-minted nested scopes and deleted ancestor scopes stay live.\n- There is no `require`, `import`, Node API, or network API in the realm. `Date.now()`, `Math.random()`, and no-arg `new Date()` / `Date()` fail static validation; aliased or computed forms are blocked at runtime; `new Date(value)` works.\n\nEvery new-run resume exposes `replayEligibility` on admission, polling, inspection, and the terminal result. It reports strategy, predicted/observed replayable prefix and counts, first non-replay/reason/detail, engine/input-format diagnostics, non-gating runtime/environment `provenanceChanges`, and non-gating operational changes; `resumeReport` retains the complete terminal per-call correspondence.\n\nAn all-live outcome is expected when correspondence cannot be established, not when the world changed. Missing resume metadata, incompatible format literals, or an invalid manifest/seed can disable reuse. A new-format source containing any result row without a captured call path/input fact\u2014possible with a call stack deeper than the raw-frame cap or a non-strict-JSON `meta` value\u2014is source-wide `"manifest-invalid"`; excluding the row could make an ambiguous sibling look unique. Format-1 bytes are never reinterpreted; they enter the positional bridge and replayed rows are recorded under format 2.\n\nAn args-controlled cap is the useful case: a cap that changes how many calls are reachable, but\ndoes not appear in an earlier call\'s prompt, lets those calls replay on resume. The worked example\nlives in the determinism-and-resume guide document and ships as\n`examples/resume-loop-cap.workflow.js`. This changed-args pattern is specific to new-run entry\npoints that accept current args with `resumeFromRunId`. The MCP `workflow` tool does, as does\n`WorkflowManager.runSync(script, newArgs, { resumeFromRunId })`. MCP resume always requires\nexplicit content; a bare `resumeFromRunId` is invalid. `WorkflowManager.resume(runId)` is a\ndifferent same-ID recovery API: it reloads the persisted original script/args and permanently uses\nlegacy positional replay semantics, while the independent default-on channel may still continue an\neligible usage/auth-interrupted live call.\n\n## <a name="custom-backends-metabackends"></a>Custom backends \u2014 `meta.backends`\n\n```js\nexport const meta = {\n  name: "\u2026", description: "\u2026",\n  backends: {\n    browser: {\n      command: "browser-acp",          // required: executable (absolute or on PATH)\n      args: ["--headless"],            // default []\n      env: { BROWSER_PROFILE: "qa" },  // merged OVER the child\'s inherited env \u2014 per-backend secrets go here\n      sessionMeta: { viewport: "desktop" },  // static ACP _meta on every session/new (per-call `meta` merges over it)\n      structuredOutputTool: true,      // default true; false = keep this backend on the prompt/_meta schema fallback\n    },\n  },\n};\n```\n\nScript-declared backends are **trust-gated**: they spawn commands on the host machine, so they stay inert until the composition root approves them \u2014 elicitation approval in the MCP server, `allowScriptBackends: true` (or a per-backend callback) on `runDynamicWorkflow`, `ExecOptions.scriptBackends` on a manager, or `AGENTPRISM_ALLOW_SCRIPT_BACKENDS=1`. A *declined* backend aborts the run rather than silently rerouting its calls to the default backend. Host-registered names always win over script declarations. Prefer host registration (`createAcpRunner({ backends })` / `AGENTPRISM_BACKENDS` env JSON) when you control the host.\n\n## <a name="agenttype-definitions"></a>`agentType` definitions\n\nMarkdown files at `<runCwd>/.agentprism/agents/<name>.md` (project) and `~/.agentprism/agents/<name>.md` (user); project wins on name collision. Frontmatter + body:\n\n```markdown\n---\ndescription: Read-only security auditor\ntools: [read, grep, glob]        # allowlist of tool names (omit = all)\ndisallowedTools: [bash]          # denylist, applied after the allowlist\nmodel: claude/opus[1m]           # verified id; agent({ model }) overrides it\nisolation: worktree              # optional\n---\nYou are a security auditor. Report findings; never modify files.\n```\n\nThe body is prepended to the agent\'s task as role guidance. An unknown `agentType` logs a warning and runs with default tools/model (the name degrades to a prose hint).\n\n## How hosts run scripts (what authors can assume)\n\nThe MCP route (`npx @automatalabs/mcp-server`, tool name `workflow`) is the canonical way an agent\nruns an authored script; registration and the per-action contracts are in the Running workflows\nguide section. The `workflow` tool is the server\'s whole *workflow* surface: run/resume/inspect/await/stop\nare action branches, not separate tools, and this input does not resolve a saved workflow name.\n(The server also registers a second, separate model-facing tool, `repl`, for interactive REPL\norchestration \u2014 outside this authoring guide\'s scope.) A\nrun that pauses with `reason: "auth_required"` resumes via a new run after the backend\'s own CLI is\nlogged in out-of-band (see below). Prompt-capable MCP hosts (e.g. Claude Code, where it surfaces as\na slash command) also get this entire guide from the server itself as the **`author-workflow`**\nprompt, with an optional `task` argument.\n\nEnvironment knobs shared by the MCP server and the SDK: `AGENTPRISM_DEFAULT_BACKEND`,\n`AGENTPRISM_ACP_POOL_SIZE` (schema-run parallelism on OpenCode/custom backends scales with the\npool; one injected-tool registry per process), `AGENTPRISM_BACKENDS`,\n`AGENTPRISM_ALLOW_SCRIPT_BACKENDS`, `AGENTPRISM_PERSISTENCE_ROOT`, plus per-backend spawn\noverrides. Pi uses `AGENTPRISM_PI_ACP_CMD` with optional `AGENTPRISM_PI_ACP_ARGS`; otherwise the\ninstalled exact-pinned package bin is used before the `npx -y @automatalabs/pi-acp` fallback.\n\nEmbedding hosts drive the same contract directly through the SDK \u2014 `runDynamicWorkflow` /\n`WorkflowManager` from `@automatalabs/workflows`, with `exec` limits (`maxAgents`, `concurrency`,\n`agentTimeoutMs`, `agentRetries`), a live `confirm` checkpoint channel, and\n`exec.resumeFromRunId` for edited-script resume. See `docs/api.md` in the repository. The shapes\nbelow are the `workflow` tool\'s MCP surface, which is what script authors interact with.\n\nExact MCP tool input/output types:\n\n```ts\ninterface WorkflowExecuteToolInputBase {\n  action?: "run";\n  args?: unknown;\n  maxAgents?: number;\n  concurrency?: number;\n  agentRetries?: number;\n  agentTimeoutMs?: number | null;\n  resumeFromRunId?: string;\n  resumePolicy?: "auto" | "positional";\n  checkpointReplies?: Record<number, unknown>;\n  background?: boolean; // default false\n}\n\ntype WorkflowExecuteToolInput = WorkflowExecuteToolInputBase & (\n  | { script: string; scriptPath?: never }\n  | { script?: never; scriptPath: string } // absolute path on the server\n);\n// WorkflowExecuteToolInputBase also carries projectDir?: string \u2014 the absolute project\n// directory selecting the project-scoped run store and default execution cwd. REQUIRED for\n// run on the shared workflow daemon (one registration serves every project); optional on a\n// single-project (--in-process) server. inspect/await/stop never take it: a runId locates\n// its project store automatically.\n\ninterface WorkflowAwaitToolInput {\n  action: "await";\n  runId: string;\n  waitMs?: number;      // default 20_000; integer 0..25_000\n  lastN?: number;       // default 20; integer 1..50\n  labelGlob?: string;   // same whole-label glob as inspect\n  logLines?: number;    // default 20; integer 0..50\n}\n\ninterface WorkflowBackgroundAccepted {\n  runId: string;\n  status: "running";\n  scriptSource: "inline" | "path";\n  scriptUri: string;\n  limits: WorkflowRunLimits;\n  replayEligibility?: WorkflowReplayEligibility;\n}\n\ninterface WorkflowAwaitMetadata {\n  requestedMs: number;\n  elapsedMs: number;\n  returnedBecause: "terminal" | "timeout" | "immediate";\n}\n\ninterface WorkflowRunAwaitResult<T = unknown> extends WorkflowRunStatus {\n  wait: WorkflowAwaitMetadata;\n  tokenUsage?: TokenUsage;\n  outcome?: Omit<WorkflowExecutionToolResult<T>, "scriptSource">; // exactly when terminal\n  scriptUri: string;\n  lineage: Array<{ runId: string; uri: string; available: boolean }>;\n}\n\ninterface WorkflowStopToolInput {\n  action: "stop";\n  runId: string;\n  callIndex?: number;  // omitted = whole-run abort; present = cancel one in-flight agent\n  lastN?: number;\n  labelGlob?: string;\n  logLines?: number;\n  script?: never;\n  scriptPath?: never;\n  waitMs?: never;\n}\n```\n\nThe selected stop form requires a live, uniquely addressable agent attempt. Settled/unallocated\nindexes, checkpoints, duplicate scoped indexes, and terminal runs are errors that enumerate the\ncurrently in-flight call-index/label pairs. A successful selected cancellation returns the ordinary\nlive `WorkflowRunStatus`; whole-run stop returns the terminal `WorkflowStopResult`.\n\n`WorkflowRunResult.fallbacks?: WorkflowRunFallback[]` retains the compatibility shape\n`{ callIndex, label, phase?, requestedSpec, resolvedModel?, backendId?, kind, message, continuation? }`.\n`kind` is `model | modifier | continuation`; continuation details report either a reattached\n`resume | load` method or an exact skip reason. The model-resolution pipeline itself produces no entries.\n`WorkflowRunResult.checkpointsTaken?: WorkflowCheckpointTaken[]` records resolved checkpoints as\n`{ callIndex, kind, decision, source }`, where source is `live`, `headless-default`,\n`journal-replay`, or `injected`. A paused checkpoint is not resolved. Both fields are persisted and\nappear in foreground results plus terminal await `outcome`; neither appears on `WorkflowRunStatus`.\n\nAt most four background runs may be active or starting per server instance. Foreground, inspect,\nawait, and stop consume no slot; a durably stopped background run frees its slot immediately even\nwhile backend session wind-down remains. A timeout returns the freshest status and partial cumulative usage; replay\nhits cost/add zero. Terminal results have no MCP TTL and are reconstructed after restart while the\nproject run record remains readable. The inherited status fields stay redacted/bounded at 24,576\nstructured bytes and 8,192 text bytes. The full script lineage is never truncated; when lineage\nalone exceeds the status budget, `truncation.maxStructuredBytes` reports the larger actual envelope\nlimit. Terminal `outcome` preserves the raw authored result/full logs and has no new total cap, but\nit is never copied into text. It includes `scriptUri` but not the unpersisted admission-only\n`scriptSource`.\n\nThe background start has no enduring request signal, progress channel, or live checkpoint channel.\nIt returns immediately and emits no progress after returning, even if the initiating request\nsupplied a progress token. A later bounded `action:"await"` is a separate request; when that await\ncarries a progress token, it can stream coarse phase and distinct started/ended-call progress while\npending. The legacy/inconsistent-log polling fallback emits no progress notifications. A headless\ncheckpoint default continues; abort fails with `WORKFLOW_ABORTED`; pause returns\n`checkpoint_required` plus `outcome.checkpointContext`. Auth pauses return non-secret\n`outcome.authContext`; log the backend CLI in before resume. Background execution lives in the\nserving process (the daemon, or the single process under `--in-process`): that process\'s death can\ninterrupt an in-flight call, and stale durable `pending`/`running` state reconciles under its lease\nto `paused` / `interrupted`.\n\nEvery resumed background run durably seeds its inherited prefix (including a manager-owned\ncheckpoint injection) beneath its new run ID before acknowledgement, so later resume hops remain\nself-contained. The MCP layer never rewrites that seed. Await and inspect never execute or resume\nthe script; their cold preflight may only reconcile a dead owner\'s stale `pending`/`running` state\nto `paused` / `interrupted`.\n\nEvery admitted script is an immutable persistence-backed MCP resource at\n`workflow://runs/{runId}/script`. Run results link the new script; inspect/await link the full\nresume lineage oldest-to-newest as structured `{ runId, uri, available }` entries. Listing and\ncompletion include only the 50 newest runs, but a direct URI read works for any retained project\nrun. A path is never persisted or implicitly re-read, and the MCP layer retains no scripts, args,\nor synthetic lineage metadata in process memory.\n\n`action:"stop"` durably aborts a `running` or `paused` run live in the serving process: it cancels\nany pending agent/checkpoint request, appends `stopped`, releases the lease, and returns the final\ninspection projection with `stopped:true`. Only backend session wind-down can remain, observable\nthrough inspect\'s agent states. A repeated stop on a terminal run succeeds with `stopped:false,\nalreadyTerminal:true`. An in-flight stop may lack a quiescent terminal-environment proof, so the\nmanager can conservatively run the following resume live; inspect `replayEligibility` and\n`resumeReport` rather than assuming a prefix replay.\n\nRetain the run ID and inspect halted runs before guessing. The exact inspection input is:\n\n```ts\ninterface WorkflowInspectToolInput {\n  action: "inspect";\n  runId: string;       // /^[a-z0-9]+-[a-z0-9]+$/, at most 128 characters\n  lastN?: number;      // default 20; integer 1..50\n  labelGlob?: string;  // non-empty; at most 128 Unicode code points\n  logLines?: number;   // default 20; integer 0..50\n  script?: never;\n  scriptPath?: never;\n}\n```\n\n`labelGlob` matches the whole raw agent label case-sensitively: `*` is zero or more Unicode code\npoints, `?` is exactly one, and backslash escapes the next character (a trailing backslash is\nliteral). Checkpoints and unknown legacy calls are excluded when a glob is present. Filtering\nhappens before `lastN`; selected calls return in ascending call-index order.\n\n```ts\ninterface WorkflowLogTail {\n  lines: string[];\n  totalLines: number;\n  omittedLines: number;\n  truncatedLines: number;\n  redactedLines: number;\n}\n\ninterface WorkflowRunCallStatus {\n  index: number;\n  kind: "agent" | "checkpoint" | "unknown";\n  label?: string;\n  phase?: string;\n  model?: string;\n  backendId?: string;\n  timeoutMs?: number | null;\n  errorCode?: string;\n  resultPreview: string;\n  resultRedacted: boolean;\n  resultTruncated: boolean;\n}\n\ninterface WorkflowRunStatus {\n  runId: string;\n  status: "pending" | "running" | "paused" | "completed" | "failed" | "aborted";\n  workflowName: string;\n  phases: string[];\n  currentPhase?: string;\n  reason?: string;\n  errorCode?: string;\n  limits?: WorkflowRunLimits; // absent only on legacy persisted records\n  replayEligibility?: WorkflowReplayEligibility;\n  logTail: WorkflowLogTail;\n  calls: WorkflowRunCallStatus[];\n  filter: { lastN: number; logLines: number; labelGlob?: string };\n  truncation: {\n    maxStructuredBytes: number;\n    byteCapApplied: boolean;\n    phases: { total: number; returned: number; shortened: number };\n    logs: { total: number; returned: number; shortened: number; redacted: number };\n    calls: {\n      total: number;\n      matched: number;\n      returned: number;\n      shortenedResults: number;\n      redactedResults: number;\n    };\n  };\n}\n\ninterface WorkflowRunLimits {\n  maxAgents: number;\n  tokenBudget: null; // persisted-shape compatibility field; new runs always report null\n  concurrency: number;\n  agentRetries: number;\n  agentTimeoutMs: number | null;\n}\n```\n\nInspection returns only this allowlisted projection: never raw script, args, prompts, histories,\nhashes, session IDs, cwd, checkpoint/auth details, or raw results. Credential-shaped data is\nredacted, results are structurally compacted, every outward text scalar/preview is capped at 512\nUTF-8 bytes, inherited status JSON at 24,576 bytes, and inspection text at 8,192 bytes. Full lineage\ncan raise the structured envelope limit as reported by `truncation.maxStructuredBytes`. An unknown ID is\na tool error with no structured content; reading an existing failed run succeeds and reports\n`status:"failed"`. Every paused, failed, or aborted execution result also carries a redacted\nfinal-20 `logTail` (present when empty) and renders it in the immediate terminal text. Completed\nexecution results omit that extra field while retaining their full `logs` array.\n\nBackend auth comes from the machine the host runs on: Claude via a logged-in Claude Code install or `ANTHROPIC_API_KEY`; Codex via `~/.codex/auth.json`; OpenCode via `opencode auth login` (its CLI must be installed \u2014 it is not bundled); Pi via one of `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, `XAI_API_KEY`, `OPENROUTER_API_KEY`, or ambient credentials in `~/.pi/agent/auth.json`. A script only needs auth for the backends it actually routes to.\n\n## The validator \u2014 `agentprism-workflows validate`\n\n```bash\nnpx @automatalabs/workflows validate <workflow-file> [options]\n```\n\nZero tokens; three passes \u2014 static parse, mocked dry run, then one no-prompt config probe per\nrouted `{ backend, model }` pair \u2014 described in the guide\'s Validate before you run section. The\ntables and grammar below are the exhaustive contract.\n\n| flag | meaning |\n|---|---|\n| `--args <json>` / `--args-file <path>` | the script\'s `args` global for the dry run |\n| `--mock-answers <json>` | label-glob answers for dry-run calls; mutually exclusive with the file form |\n| `--mock-answers-file <path>` | read the same JSON object from a UTF-8 file resolved against the process cwd |\n| `--workflows-dir <dir>` | repeatable; a folder of workflow scripts (name = filename stem). Lets the positional be a NAME and resolves nested `workflow("<name>")` calls |\n| `--parse-only` | static parse only |\n| `--cwd <dir>` | dry-run base cwd (default: throwaway temp dir, so `isolation: "worktree"` no-ops; a real repo cwd creates and cleans up real worktrees) |\n| `--max-agents <n>` | cap on dry-run agent calls |\n| `--timeout-ms <n>` | dry-run wall-clock limit (default 30000) |\n| `--json` | machine-readable `ValidateWorkflowReport` on stdout |\n\nInline false-branch fixture (exact shell form):\n\n```bash\nagentprism-workflows validate flow.workflow.js \\\n  --mock-answers \'{"refute:*":{"real":false}}\'\n```\n\nEquivalent reusable file with a reject-then-approve sequence:\n\n```json\n{\n  "refute:*": { "real": false },\n  "quality:review": {\n    "$sequence": [\n      { "ok": false, "feedback": "exercise the revision path" },\n      { "ok": true }\n    ]\n  }\n}\n```\n\n```bash\nagentprism-workflows validate flow.workflow.js --mock-answers-file mock-answers.json\n```\n\nRules match the final resolved label case-sensitively across the whole string. `*` matches zero or more characters (including `:` and `/`), `?` one character, and `\\` escapes the next character; empty globs and trailing escapes are invalid. Object order is captured once and the **last matching rule wins**, so put `"*"` before narrower exceptions. Raw canonical array-index keys (`"0"` or a non-zero, no-leading-zero decimal through `"4294967294"`) are reserved because ECMAScript reorders them. To match numeric label `10`, use JSON key `"\\\\10"`; `"01"` and `"4294967295"` are ordinary keys.\n\nA single answer is reusable. `{ "$sequence": [...] }` is finite and only the winning rule consumes it; a raw array is one array result, and a sequence element is ordinary answer data even when it contains `$sequence`. Exhaustion fails instead of repeating the last item or falling back. The machine report uses zero-based `sequenceIndex`; human lines render one-based `[position/length]`. Earlier matching rules count the match even when shadowed, and `dryRun.mockAnswers.unused` distinguishes `no-match`, `shadowed`, and partially consumed `not-reached` items. Unused fixtures warn but do not fail validation.\n\nFor schema calls, each answer deep-merges over a **fresh** fabricated base: JSON objects merge recursively; arrays, `null`, falsy primitives, and other scalars replace. The merged value is TypeBox-checked without coercion. Any answer-caused violation fails non-recoverably with `SCHEMA_NONCOMPLIANCE`; a failure already present at the identical untouched path/message in the simple fabricated base may be accepted with a grouped inherited-fabrication warning. A valid override can repair such a base limitation. Schema-less answers must be nonblank strings. Fixture failure messages, attribution, and warnings contain only labels, globs, positions, paths, and counts\u2014not answer values.\n\nLimits: 256 KiB raw UTF-8 for either CLI source and canonical JSON for programmatic input; 256 rules; 1\u2013256 UTF-16 code units per glob; 256 entries per sequence; answer depth 32. Inputs must be plain JSON data. Mock-enabled validation serves agent calls serially for deterministic FIFO sequence allocation; it is not a concurrency/load simulation. Fixture values still flow into the script like real agent results, so author code can expose them via `log()` or its returned result\u2014never store credentials or production data in fixtures.\n\nExit codes: `0` valid \xB7 `1` parse/static failure \xB7 `2` dry-run failure \xB7 `3` usage error. The report also lists every checkpoint with the mock reply (`default ?? true`) and warnings for backend approval, phase mismatch, `headless: "abort"`, and agent-less scripts. `headless: "pause"` dry-runs cleanly. A saved nested workflow still needs `--workflows-dir`.\n\nProgrammatic: `validateWorkflowScript(script, { args, workflows, dryRun, cwd, maxAgents, timeoutMs, mockAnswers })` from `@automatalabs/workflows` returns the same report. Invalid workflow scripts resolve to reports; invalid `mockAnswers` supplied from untyped JavaScript throws `TypeError` before parsing.\n\n## Harness config discovery \u2014 `agentprism-workflows config`\n\nValidate\'s sibling: the same no-prompt config probe, standalone \u2014 no script required. Run it BEFORE authoring to read each harness\'s advertised, negotiable session surface (model ids including bracket variants, effort levels, modes, boolean knobs) instead of guessing values or writing a throwaway probe workflow.\n\n```bash\nnpx @automatalabs/workflows config                  # every routable harness\nnpx @automatalabs/workflows config codex opencode   # only the named harnesses\nnpx @automatalabs/workflows config claude --json    # machine-readable report\nnpx @automatalabs/workflows config opencode --models          # provider/group breakdown\nnpx @automatalabs/workflows config pi --models=anthropic      # only matching model ids\n```\n\nHarness names are the routing names: built-in `claude` / `codex` / `opencode` / `pi` plus any custom backend registered via the `AGENTPRISM_BACKENDS` env var (registered customs also join the no-argument default set). Each harness opens one session without a prompt \u2014 zero tokens \u2014 and its catalog is read fresh; a harness that cannot spawn or authenticate reports `probed: false` with the reason and never blocks the others.\n\nThe no-argument built-in sequence comes from `BUILTIN_BACKEND_IDS`; authoring prose describes the\ncurrent registry rows and does not define a separate supported-backend list.\n\nA harness with a large model catalog (today pi and opencode advertise hundreds) would otherwise\nflood your context, so any select option above ~24 choices \u2014 in practice the `model` option \u2014 is\nrendered as a grouped **summary** (total + per-provider/group counts) rather than the full leaf\nlist. This applies to BOTH the human table and `--json`, so neither surface dumps the whole catalog;\nsmall catalogs (claude, codex, and every effort/mode/boolean option) are unaffected and print\nverbatim. The complete list is reachable only through `--models`, and there is deliberately no\nunfiltered full-leaf dump on any surface:\n\n- `config <harness> --models` \u2014 the provider/group breakdown with counts (no leaf ids)\n- `config <harness> --models=<filter>` \u2014 the leaf model ids matching `<filter>`, where `<filter>` is\n  a provider name / case-insensitive substring, or a `/regex/`\n\n| flag | meaning |\n|---|---|\n| `--cwd <dir>` | session cwd for the probes (default: the current directory \u2014 harnesses may resolve project-level config, and hence their catalog, from it) |\n| `--timeout-ms <n>` | per-harness probe bound (default 60000); a timed-out harness reports `probed:false` |\n| `--models[=<filter>]` | list a harness\'s model catalog: bare prints the provider/group breakdown; `=<provider\\|substring\\|/regex/>` prints the matching leaf ids. The only way to reach the leaves of a summarized catalog; never dumps them all unfiltered. With `--json`, emits the structured model view (`{ harnessModels: [...] }`) |\n| `--json` | machine-readable `HarnessConfigReport` on stdout (`harnessOptions` uses the same per-harness shape as validate\'s report). An oversized select\'s `options` array is replaced by `{ truncated: true, choiceSummary: { total, groups, expand } }` \u2014 the same summary the human table shows |\n\nExit codes: `0` all probed \xB7 `1` at least one probe failed \xB7 `3` usage error.\n\nProgrammatic: `probeHarnessConfig({ harnesses, backends, cwd, timeoutMs })` from `@automatalabs/workflows` returns the same report (`backends` merges over `AGENTPRISM_BACKENDS` exactly like `createAcpRunner`); `formatHarnessConfigReport(report)` renders the human table.\n\n## Workflow folders\n\nHosts that keep versioned folders of workflow scripts serve them by name (the SDK\'s\n`openWorkflowDir` \u2014 see `docs/api.md`). The filename stem is the name (`review-pr.workflow.js` \u21D2\n`review-pr`; `.workflow.js` beats `.js`). For script AUTHORS the takeaway is simply:\n`workflow("<name>")` works when the host serves a folder; keep names equal to filename stems.\n\n---\n\n# Complete example \u2014 quick-wins.workflow.js\n\nA complete, validated script (`loopUntilDry()` with per-round vendor rotation, dedup threading via a `seen` list, and an args-controlled round cap; runs standalone or nested):\n\n```js\n// quick-wins \u2014 a small, self-contained hunter that repo-triage nests by name\n// (`workflow("quick-wins", {...})`) and that also runs standalone:\n//\n//   npm start -- --workflow quick-wins\n//   npx agentprism-workflows validate quick-wins --workflows-dir workflows\n//\n// Demonstrates loopUntilDry(): keep spawning hunt rounds \u2014 each on the next vendor\n// in the pool \u2014 until two consecutive rounds add nothing new (or the round cap\n// stops it first). Workflow scripts are self-contained strings with no imports, so\n// the vendor pool is repeated here rather than shared with repo-triage.\nexport const meta = {\n  name: "quick-wins",\n  description: "Hunt small, high-confidence quick wins across the repo until two consecutive rounds come up dry",\n  phases: [{ title: "Hunt" }],\n};\n\n// args \u2014 every knob optional; hosts may hand args through as a JSON string.\nconst raw = typeof args === "string" ? (() => { try { return JSON.parse(args); } catch { return {}; } })() : args;\nconst opt = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};\nconst rounds = Number.isFinite(Number(opt.rounds)) && Number(opt.rounds) >= 1 ? Math.floor(Number(opt.rounds)) : 4;\nconst focus =\n  typeof opt.focus === "string" && opt.focus.trim().length > 0\n    ? opt.focus.trim()\n    : "small, safe, high-confidence improvements";\nconst avoid = Array.isArray(opt.avoid) ? opt.avoid.filter((x) => typeof x === "string") : [];\n\n// These registered-prefix specs use ids verified against each live harness catalog.\nconst POOL = [\n  { name: "claude", model: "claude/opus[1m]", mode: "plan" },\n  { name: "codex", model: "codex/gpt-5.6-sol", mode: "read-only" },\n  { name: "opencode", model: "opencode/zai/glm-5.2" },\n];\n\nconst WINS = {\n  type: "object",\n  additionalProperties: false,\n  required: ["wins"],\n  properties: {\n    wins: {\n      type: "array",\n      items: {\n        type: "object",\n        additionalProperties: false,\n        required: ["file", "summary", "action"],\n        properties: {\n          file: {\n            type: "string",\n            description: "Repo-relative path of a file you actually opened \u2014 copy it exactly, never invent one",\n          },\n          summary: { type: "string", description: "One sentence: the small problem or missed improvement" },\n          action: { type: "string", description: "The concrete, low-risk change that fixes it, in one clause" },\n        },\n      },\n    },\n  },\n};\n\nphase("Hunt");\nconst seen = [];\nconst wins = await loopUntilDry({\n  round: async (i) => {\n    const v = POOL[i % POOL.length];\n    const r = await agent(\n      `Hunt round ${i + 1}: find up to 3 quick wins in this repository \u2014 ${focus}. ` +\n        "A quick win is a small, safe, self-contained improvement (a missing guard, a stale doc line, an obvious dead branch), " +\n        "not a refactor. Open files and ground every entry in code you actually read; never emit a placeholder.\\n" +\n        `Already known \u2014 do NOT repeat anything on this list: ${JSON.stringify([...avoid, ...seen])}`,\n      { label: `hunt:${i + 1}:${v.name}`, phase: "Hunt", schema: WINS, model: v.model, mode: v.mode },\n    );\n    const found = (r?.wins ?? []).filter((w) => typeof w.file === "string" && w.file.length > 0 && !w.file.startsWith("/"));\n    seen.push(...found.map((w) => `${w.file}: ${w.summary}`));\n    return found.map((w) => ({ ...w, foundBy: v.name }));\n  },\n  key: (w) => `${w.file}::${w.summary}`,\n  consecutiveEmpty: 2,\n  maxRounds: rounds,\n});\n\nlog(`quick-wins: ${wins.length} unique wins across the hunt`);\nreturn { wins };\n```\n';
 
 // ../mcp-server/src/authoring-prompt.ts
 var AUTHORING_PROMPT_NAME = "author-workflow";
@@ -33556,6 +33557,19 @@ var ReplPresenceLedger = class {
   drainingCount() {
     return this.draining.size;
   }
+  /**
+   * True when any workspace the session has affinity with has a subagent turn running. The
+   * lame-duck migration keeps such sessions: closing one would drain the workspace here while
+   * the migrated client re-opens it on the successor — a workspace split across two daemons.
+   */
+  sessionHasBusyWorkspace(clientId) {
+    const projects = this.bySession.get(clientId);
+    if (projects === void 0) return false;
+    for (const state of projects) {
+      if (state.broker !== null && state.broker.busySessionCount() > 0) return true;
+    }
+    return false;
+  }
   /** Drop every session's presence (daemon shutdown): the scheduled
    *  drains see the projects' client sets emptied and run to completion
    *  on the already-disposed brokers — a no-op there, cleared here. */
@@ -33581,8 +33595,10 @@ var DAEMON_PORT_ENV = "AGENTPRISM_DAEMON_PORT";
 var DAEMON_ALLOWED_ORIGINS_ENV = "AGENTPRISM_DAEMON_ALLOWED_ORIGINS";
 var DAEMON_IDLE_TTL_MS = 15 * 6e4;
 var DAEMON_IDLE_TTL_ENV = "AGENTPRISM_DAEMON_IDLE_TTL_MS";
-var SESSION_IDLE_TTL_MS = 2 * 60 * 6e4;
+var SESSION_IDLE_TTL_MS = 5 * 6e4;
 var SESSION_IDLE_TTL_ENV = "AGENTPRISM_SESSION_TTL_MS";
+var REPL_DRAIN_BOUND_MS = 2 * 60 * 6e4;
+var REPL_DRAIN_BOUND_ENV = "AGENTPRISM_REPL_DRAIN_BOUND_MS";
 var REAPER_INTERVAL_MS = 6e4;
 var EVENT_STORE_MAX_EVENTS_PER_STREAM = 1e3;
 var EVENT_STORE_MAX_TOTAL_EVENTS = 1e4;
@@ -34066,7 +34082,7 @@ var WorkflowScriptResources = class {
 // ../mcp-server/src/server.ts
 var SERVER_NAME = "agentprism-workflow";
 var require2 = createRequire(import.meta.url);
-var SERVER_VERSION = require2("../package.json").version;
+var SERVER_VERSION = true ? "0.30.0" : require2("../package.json").version;
 var SERVER_INSTRUCTIONS = [
   "This server exposes two model-facing tools for orchestrating multi-agent work. Both spawn subagents over the same ACP backends \u2014 the registry built-ins Claude, Codex, OpenCode, and pi, plus any registered custom agents \u2014 and key their durable state by an absolute projectDir (required on the shared daemon; defaults to the server's own project in single-project mode). Backend credentials come from each agent's own login (claude, codex, opencode, pi), so there is nothing auth-shaped to configure here.",
   '\u2022 workflow \u2014 DETERMINISTIC BATCH orchestration. Supply a JavaScript workflow script (inline or by absolute scriptPath) that fans out agent() subagents and optional checkpoint() gates; it runs to completion in the foreground, or background:true returns a durable runId for bounded action:"await"/"inspect"/"stop" calls, with journaling, replay, and resumeFromRunId. Reach for it when the orchestration is known up front and you want it repeatable and resumable. The user-invocable author-workflow prompt helps write scripts.',
@@ -34884,7 +34900,7 @@ function createWorkflowServer(runner, options = {}) {
   const defaultContext = requireProjectDir ? void 0 : projects.adopt(options.manager ?? new WorkflowManager3({ agent: runner }), options.backgroundRuns);
   const scriptResources = new WorkflowScriptResources(mcp, { router: projects });
   const backendApprovals = /* @__PURE__ */ new Set();
-  const replPresence = options.replPresence ?? new ReplPresenceLedger(options.replDrainBoundMs ?? SESSION_IDLE_TTL_MS);
+  const replPresence = options.replPresence ?? new ReplPresenceLedger(options.replDrainBoundMs ?? REPL_DRAIN_BOUND_MS);
   const resolveContext2 = (input) => {
     if (input.action === "inspect" || input.action === "await" || input.action === "stop") {
       return projects.storeFor(input.runId) ?? defaultContext;
@@ -35418,6 +35434,7 @@ import { createHash } from "node:crypto";
 import {
   chmodSync,
   mkdirSync,
+  readdirSync as readdirSync2,
   readFileSync as readFileSync3,
   renameSync as renameSync2,
   rmSync,
@@ -35438,11 +35455,20 @@ async function probeHealthz(port, timeoutMs = 2e3) {
     return void 0;
   }
 }
-function daemonInfoPath() {
-  return join2(workflowHomeDir2(), "daemon.json");
+function daemonsDir() {
+  return join2(workflowHomeDir2(), "daemons");
 }
-function daemonLockPath() {
-  return join2(workflowHomeDir2(), "daemon.lock");
+function daemonInfoPath(fingerprint = envFingerprint()) {
+  return join2(daemonsDir(), `${fingerprint}.json`);
+}
+function daemonLockPath(fingerprint = envFingerprint()) {
+  return join2(daemonsDir(), `${fingerprint}.lock`);
+}
+function daemonInstancePath(pid) {
+  return join2(daemonsDir(), "instances", `${pid}.json`);
+}
+function legacyDaemonInfoPath() {
+  return join2(workflowHomeDir2(), "daemon.json");
 }
 function daemonLogPath() {
   return join2(workflowHomeDir2(), "logs", "daemon.log");
@@ -35457,9 +35483,9 @@ function pidIsAlive(pid) {
     return false;
   }
 }
-function readDaemonInfo() {
+function readInfoFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync3(daemonInfoPath(), "utf-8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
     if (parsed.name !== DAEMON_NAME || typeof parsed.pid !== "number" || typeof parsed.port !== "number" || typeof parsed.url !== "string" || typeof parsed.version !== "string") {
       return void 0;
     }
@@ -35468,34 +35494,97 @@ function readDaemonInfo() {
     return void 0;
   }
 }
-function writeDaemonInfo(info) {
-  const path = daemonInfoPath();
+function readDaemonInfo(fingerprint = envFingerprint()) {
+  return readInfoFile(daemonInfoPath(fingerprint));
+}
+function writeInfoFile(path, info) {
   mkdirSync(dirname(path), { recursive: true });
-  const tmp = `${path}.${info.pid}.tmp`;
+  const tmp = `${path}.${info.pid}.${randomUUID().slice(0, 8)}.tmp`;
   writeFileSync(tmp, `${JSON.stringify(info, null, 2)}
 `, { mode: 384 });
   chmodSync(tmp, 384);
   renameSync2(tmp, path);
 }
+function writeDaemonInfo(info) {
+  writeInfoFile(daemonInfoPath(info.envFingerprint), info);
+  writeInfoFile(daemonInstancePath(info.pid), info);
+}
 function clearDaemonInfo(pid) {
-  const current = readDaemonInfo();
-  if (current === void 0 || current.pid !== pid) return;
+  const instance = readInfoFile(daemonInstancePath(pid));
+  const fingerprint = instance?.envFingerprint ?? envFingerprint();
+  const current = readDaemonInfo(fingerprint);
+  try {
+    if (current !== void 0 && current.pid === pid) rmSync(daemonInfoPath(fingerprint), { force: true });
+  } catch {
+  }
   try {
-    rmSync(daemonInfoPath(), { force: true });
+    rmSync(daemonInstancePath(pid), { force: true });
   } catch {
   }
 }
-function isSupersededBy(ownPid) {
-  const info = readDaemonInfo();
+function isSupersededBy(ownPid, fingerprint = envFingerprint()) {
+  const info = readDaemonInfo(fingerprint);
   return info !== void 0 && info.pid !== ownPid;
 }
+function listDaemonInstances() {
+  const instances = [];
+  const seen = /* @__PURE__ */ new Set();
+  const dir = join2(daemonsDir(), "instances");
+  let files = [];
+  try {
+    files = readdirSync2(dir);
+  } catch {
+    files = [];
+  }
+  for (const file2 of files) {
+    if (!file2.endsWith(".json")) continue;
+    const path = join2(dir, file2);
+    const info = readInfoFile(path);
+    if (info === void 0 || !pidIsAlive(info.pid)) {
+      try {
+        rmSync(path, { force: true });
+      } catch {
+      }
+      continue;
+    }
+    if (seen.has(info.pid)) continue;
+    seen.add(info.pid);
+    instances.push({ info, legacy: false });
+  }
+  const legacy = readInfoFile(legacyDaemonInfoPath());
+  if (legacy !== void 0 && pidIsAlive(legacy.pid) && !seen.has(legacy.pid)) {
+    instances.push({ info: legacy, legacy: true });
+  }
+  return instances;
+}
+function findDaemonInstanceOnPort(port) {
+  return listDaemonInstances().find((instance) => instance.info.port === port);
+}
 var ENV_FINGERPRINT_PREFIXES = ["AGENTPRISM_", "OPENCODE_ACP_", "PI_ACP_", "CODEX_ACP_"];
+var ENV_FINGERPRINT_EXCLUDED = /* @__PURE__ */ new Set([DAEMON_IDLE_TTL_ENV, SESSION_IDLE_TTL_ENV, REPL_DRAIN_BOUND_ENV]);
 function envFingerprint(env = process.env) {
-  const relevant = Object.entries(env).filter(([key, value]) => value !== void 0 && ENV_FINGERPRINT_PREFIXES.some((p2) => key.startsWith(p2))).filter(([key]) => key !== "AGENTPRISM_DAEMON_IDLE_TTL_MS" && key !== "AGENTPRISM_SESSION_TTL_MS").sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, value]) => `${key}=${value}`).join("\n");
+  const relevant = Object.entries(env).filter(([key, value]) => value !== void 0 && ENV_FINGERPRINT_PREFIXES.some((p2) => key.startsWith(p2))).filter(([key]) => !ENV_FINGERPRINT_EXCLUDED.has(key)).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, value]) => `${key}=${value}`).join("\n");
   return createHash("sha256").update(relevant).digest("hex").slice(0, 16);
 }
-function claimSpawnLock() {
-  const path = daemonLockPath();
+function compareVersions(a, b) {
+  const parse3 = (value) => {
+    const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value.trim());
+    if (match === null) return void 0;
+    return { nums: [Number(match[1]), Number(match[2]), Number(match[3])], pre: match[4] };
+  };
+  const pa = parse3(a);
+  const pb = parse3(b);
+  if (pa === void 0 || pb === void 0) return a < b ? -1 : a > b ? 1 : 0;
+  for (let i = 0; i < 3; i++) {
+    if (pa.nums[i] !== pb.nums[i]) return pa.nums[i] - pb.nums[i];
+  }
+  if (pa.pre === void 0 && pb.pre === void 0) return 0;
+  if (pa.pre === void 0) return 1;
+  if (pb.pre === void 0) return -1;
+  return pa.pre < pb.pre ? -1 : pa.pre > pb.pre ? 1 : 0;
+}
+function claimSpawnLock(fingerprint = envFingerprint()) {
+  const path = daemonLockPath(fingerprint);
   mkdirSync(dirname(path), { recursive: true });
   const lock = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString(), token: randomUUID() };
   for (let attempt = 0; attempt < 2; attempt++) {
@@ -35520,8 +35609,8 @@ function claimSpawnLock() {
   }
   return null;
 }
-function releaseSpawnLock(lock) {
-  const path = daemonLockPath();
+function releaseSpawnLock(lock, fingerprint = envFingerprint()) {
+  const path = daemonLockPath(fingerprint);
   try {
     const holder = JSON.parse(readFileSync3(path, "utf-8"));
     if (holder.token !== lock.token) return;
@@ -35531,27 +35620,21 @@ function releaseSpawnLock(lock) {
 }
 
 // ../mcp-server/src/shim/ensure-daemon.ts
-function isDivergent(live, fingerprint) {
-  return live.version !== SERVER_VERSION || live.envFingerprint !== fingerprint;
+function isStale(live) {
+  return compareVersions(live.version, SERVER_VERSION) < 0;
 }
-async function probeLiveDaemon() {
-  const info = readDaemonInfo();
+async function probeLiveDaemon(fingerprint) {
+  const info = readDaemonInfo(fingerprint);
   if (info === void 0 || !pidIsAlive(info.pid)) return void 0;
   const health = await probeHealthz(info.port);
   if (health === void 0 || health.pid !== info.pid) return void 0;
-  return {
-    info,
-    sessions: health.sessions,
-    activeRuns: health.activeRuns,
-    version: health.version,
-    envFingerprint: health.envFingerprint
-  };
+  return { info, sessions: health.sessions, activeRuns: health.activeRuns, version: health.version };
 }
 async function waitForCurrentDaemon(fingerprint, timeoutMs) {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
-    const live = await probeLiveDaemon();
-    if (live !== void 0 && !isDivergent(live, fingerprint)) return live.info;
+    const live = await probeLiveDaemon(fingerprint);
+    if (live !== void 0 && !isStale(live)) return live.info;
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
   return void 0;
@@ -35588,29 +35671,32 @@ function spawnDetachedDaemon(args) {
 async function ensureDaemonRunning(options) {
   const fingerprint = envFingerprint();
   const spawnDaemon = options.spawn ?? ((args) => spawnDetachedDaemon(args));
-  const live = await probeLiveDaemon();
-  if (live !== void 0 && !isDivergent(live, fingerprint)) return live.info;
-  if (live !== void 0) {
-    const reasons = [];
-    if (live.version !== SERVER_VERSION) reasons.push(`version v${live.version} \u2192 v${SERVER_VERSION}`);
-    if (live.envFingerprint !== fingerprint) {
-      reasons.push(`env fingerprint ${live.envFingerprint} \u2192 ${fingerprint}`);
+  const adopt = (live2) => {
+    if (compareVersions(live2.version, SERVER_VERSION) > 0) {
+      options.log(
+        `[${DAEMON_NAME}] adopting daemon v${live2.version} (pid ${live2.info.pid}), newer than this client v${SERVER_VERSION}`
+      );
     }
+    return live2.info;
+  };
+  const live = await probeLiveDaemon(fingerprint);
+  if (live !== void 0 && !isStale(live)) return adopt(live);
+  if (live !== void 0) {
     options.log(
-      `[${DAEMON_NAME}] superseding stale daemon (pid ${live.info.pid}, ${live.sessions} session(s), ${live.activeRuns} run(s)): ${reasons.join(", ")} \u2014 spawning a v${SERVER_VERSION} successor and repointing discovery`
+      `[${DAEMON_NAME}] superseding stale daemon (pid ${live.info.pid}, ${live.sessions} session(s), ${live.activeRuns} run(s)): version v${live.version} \u2192 v${SERVER_VERSION} \u2014 spawning a successor and repointing discovery`
     );
   }
-  const lock = claimSpawnLock();
+  const lock = claimSpawnLock(fingerprint);
   if (lock === null) {
     const info = await waitForCurrentDaemon(fingerprint, SPAWN_HEALTH_TIMEOUT_MS);
     if (info !== void 0) return info;
     throw new Error(
-      `[${DAEMON_NAME}] another process is starting the daemon but no current-version daemon became healthy; see ${daemonLogPath()}`
+      `[${DAEMON_NAME}] another process is starting the daemon but no current daemon became healthy; see ${daemonLogPath()}`
     );
   }
   try {
-    const raced = await probeLiveDaemon();
-    if (raced !== void 0 && !isDivergent(raced, fingerprint)) return raced.info;
+    const raced = await probeLiveDaemon(fingerprint);
+    if (raced !== void 0 && !isStale(raced)) return adopt(raced);
     const superseding = raced !== void 0;
     spawnDaemon({ bundlePath: options.bundlePath, port: options.port, supersede: superseding });
     const info = await waitForCurrentDaemon(fingerprint, SPAWN_HEALTH_TIMEOUT_MS);
@@ -35621,12 +35707,12 @@ async function ensureDaemonRunning(options) {
     }
     if (superseding) {
       options.log(
-        `[${DAEMON_NAME}] succession complete: connected to v${info.version} daemon (pid ${info.pid}) at ${info.url}; the superseded daemon will finish its work and exit`
+        `[${DAEMON_NAME}] succession complete: connected to v${info.version} daemon (pid ${info.pid}) at ${info.url}; the superseded daemon will migrate its sessions, finish its work, and exit`
       );
     }
     return info;
   } finally {
-    releaseSpawnLock(lock);
+    releaseSpawnLock(lock, fingerprint);
   }
 }
 
@@ -35644,19 +35730,43 @@ function installDaemonLifecycle(options) {
   const log = options.log ?? ((line) => console.error(line));
   let shutdownPromise;
   let idleSince;
+  let supersessionAnnounced = false;
   const onSigint = () => void lifecycle.shutdown("SIGINT");
   const onSigterm = () => void lifecycle.shutdown("SIGTERM");
   const reaper = setInterval(() => {
-    const evicted = options.daemon.sessions.evictIdle(options.sessionTtlMs);
-    if (evicted.length > 0) {
-      log(`[agentprism-daemon] evicted ${evicted.length} idle session(s): ${evicted.join(", ")}`);
+    const daemon = options.daemon;
+    const superseded = daemon.isSuperseded();
+    if (superseded) {
+      if (!supersessionAnnounced) {
+        supersessionAnnounced = true;
+        log(
+          `[agentprism-daemon] superseded by a newer daemon; draining \u2014 ${daemon.sessions.size} session(s), ${daemon.activeRunCount()} run(s), ${daemon.inflightRequestCount()} request(s) in flight`
+        );
+      }
+      if (daemon.activeRunCount() === 0) {
+        const migrated = daemon.evictDrainableSessions();
+        if (migrated.length > 0) {
+          log(`[agentprism-daemon] migrated ${migrated.length} idle session(s) to the successor: ${migrated.join(", ")}`);
+        }
+      }
+    } else {
+      supersessionAnnounced = false;
+      const evicted = daemon.sessions.evictIdle(options.sessionTtlMs);
+      if (evicted.length > 0) {
+        log(`[agentprism-daemon] evicted ${evicted.length} idle session(s): ${evicted.join(", ")}`);
+      }
     }
-    if (options.idleTtlMs <= 0) return;
-    const busy = options.daemon.sessions.size > 0 || options.daemon.activeRunCount() > 0 || options.daemon.activeReplDrainCount() > 0;
+    const busy = daemon.sessions.size > 0 || daemon.activeRunCount() > 0 || daemon.activeReplDrainCount() > 0;
     if (busy) {
       idleSince = void 0;
       return;
     }
+    if (superseded) {
+      log("[agentprism-daemon] superseded and nothing in flight; exiting");
+      void lifecycle.shutdown("superseded");
+      return;
+    }
+    if (options.idleTtlMs <= 0) return;
     idleSince ??= Date.now();
     if (Date.now() - idleSince >= options.idleTtlMs) {
       log(`[agentprism-daemon] idle for ${options.idleTtlMs}ms with no sessions, runs, or repl drains; shutting down`);
@@ -37174,7 +37284,7 @@ var SessionRegistry = class {
    */
   onSessionDeleted;
   add(record2) {
-    this.sessions.set(record2.sessionId, record2);
+    this.sessions.set(record2.sessionId, { ...record2, inflightRequests: record2.inflightRequests ?? 0 });
   }
   get(sessionId) {
     return this.sessions.get(sessionId);
@@ -37204,6 +37314,22 @@ var SessionRegistry = class {
       this.onLastConnectionClosed?.(sessionId);
     }
   }
+  /** A request (POST) started being processed on the session. */
+  requestStarted(sessionId) {
+    const record2 = this.sessions.get(sessionId);
+    if (record2 !== void 0) record2.inflightRequests++;
+  }
+  /** The request's response finished (or its connection closed). */
+  requestFinished(sessionId) {
+    const record2 = this.sessions.get(sessionId);
+    if (record2 !== void 0) record2.inflightRequests = Math.max(0, record2.inflightRequests - 1);
+  }
+  /** Requests being processed right now, across every session. */
+  inflightCount() {
+    let total = 0;
+    for (const record2 of this.sessions.values()) total += record2.inflightRequests;
+    return total;
+  }
   get size() {
     return this.sessions.size;
   }
@@ -37221,6 +37347,21 @@ var SessionRegistry = class {
     }
     return evicted;
   }
+  /**
+   * Close every session with NO request in flight — the lame-duck migration: the client's
+   * next frame (or its standalone GET stream ending) makes it re-initialize on the successor.
+   * `keep` can veto a session (the daemon keeps sessions whose REPL workspace is mid-turn).
+   */
+  evictDrainable(keep = () => false) {
+    const evicted = [];
+    for (const record2 of this.sessions.values()) {
+      if (record2.inflightRequests > 0) continue;
+      if (keep(record2.sessionId)) continue;
+      evicted.push(record2.sessionId);
+      void record2.transport.close().catch(() => void 0);
+    }
+    return evicted;
+  }
   async closeAll() {
     const records = [...this.sessions.values()];
     await Promise.allSettled(records.map((record2) => record2.transport.close()));
@@ -37251,7 +37392,8 @@ async function createDaemon(options) {
   const isSuperseded = options.isSuperseded ?? (() => isSupersededBy(ownPid));
   const sessions = new SessionRegistry();
   const projects = new WorkflowProjectRegistry(options.runner);
-  const replPresence = new ReplPresenceLedger(options.sessionTtlMs ?? SESSION_IDLE_TTL_MS);
+  const replDrainBoundMs = options.replDrainBoundMs ?? options.sessionTtlMs ?? REPL_DRAIN_BOUND_MS;
+  const replPresence = new ReplPresenceLedger(replDrainBoundMs);
   sessions.onConnectionOpened = (sessionId) => replPresence.reconnect(sessionId);
   sessions.onLastConnectionClosed = (sessionId) => replPresence.disconnect(sessionId);
   sessions.onSessionDeleted = (sessionId) => replPresence.forget(sessionId);
@@ -37266,7 +37408,12 @@ async function createDaemon(options) {
         return;
       }
       sessions.connectionOpened(sessionId);
-      res.on("close", () => sessions.connectionClosed(sessionId));
+      const isRequest = req.method === "POST";
+      if (isRequest) sessions.requestStarted(sessionId);
+      res.on("close", () => {
+        if (isRequest) sessions.requestFinished(sessionId);
+        sessions.connectionClosed(sessionId);
+      });
       await record2.transport.handleRequest(req, res);
       return;
     }
@@ -37300,7 +37447,7 @@ async function createDaemon(options) {
       replRunner: options.replRunner,
       replPresence,
       replClientId: () => transport.sessionId,
-      replDrainBoundMs: options.sessionTtlMs ?? SESSION_IDLE_TTL_MS,
+      replDrainBoundMs,
       replEvalBreakChannel: options.evalBreakChannel
     });
     await server.connect(transport);
@@ -37341,7 +37488,8 @@ async function createDaemon(options) {
             activeRuns: projects.activeRunCount(),
             envFingerprint: envFingerprint(env),
             projects: projects.snapshot(),
-            lameDuck: isSuperseded()
+            lameDuck: isSuperseded(),
+            inflightRequests: sessions.inflightCount()
           })
         );
         return;
@@ -37376,6 +37524,9 @@ async function createDaemon(options) {
     projects,
     activeRunCount: () => projects.activeRunCount(),
     activeReplDrainCount: () => replPresence.drainingCount(),
+    inflightRequestCount: () => sessions.inflightCount(),
+    isSuperseded,
+    evictDrainableSessions: () => sessions.evictDrainable((sessionId) => replPresence.sessionHasBusyWorkspace(sessionId)),
     async close() {
       const closed = new Promise((resolvePromise) => {
         httpServer.close(() => resolvePromise());
@@ -37412,22 +37563,37 @@ async function runDaemon(options = {}) {
   const supersede = options.supersede ?? false;
   let daemon;
   const sessionTtlMs = envInt(SESSION_IDLE_TTL_ENV, SESSION_IDLE_TTL_MS);
+  const replDrainBoundMs = envInt(REPL_DRAIN_BOUND_ENV, REPL_DRAIN_BOUND_MS);
+  const describePortHolder = (port) => {
+    const holder = findDaemonInstanceOnPort(port);
+    if (holder === void 0) return `port ${port} is taken by another process`;
+    return `port ${port} is still held by ${holder.legacy ? "a legacy " : ""}daemon pid ${holder.info.pid} (v${holder.info.version}, started ${holder.info.startedAt})`;
+  };
   const evalBreakChannel = createEvalBreakChannel2();
+  const daemonOptions = { runner, log, replDrainBoundMs, evalBreakChannel };
   if (supersede) {
-    log(`[${DAEMON_NAME}] starting as a successor to a superseded daemon (ephemeral port)`);
-    daemon = await createDaemon({ runner, port: 0, log, sessionTtlMs, evalBreakChannel });
+    let port = options.port ?? 0;
+    try {
+      daemon = await createDaemon({ ...daemonOptions, port });
+    } catch (error51) {
+      if (!(error51 instanceof DaemonPortInUseError) || port === 0) throw error51;
+      log(`[${DAEMON_NAME}] ${describePortHolder(port)}; successor falling back to an ephemeral port`);
+      port = 0;
+      daemon = await createDaemon({ ...daemonOptions, port });
+    }
+    log(`[${DAEMON_NAME}] starting as a successor to a superseded daemon (port ${daemon.port})`);
   } else {
     const port = resolveDaemonPort(options.port);
     try {
-      daemon = await createDaemon({ runner, port, log, sessionTtlMs, evalBreakChannel });
+      daemon = await createDaemon({ ...daemonOptions, port });
     } catch (error51) {
       if (!(error51 instanceof DaemonPortInUseError)) throw error51;
       if (await ownDaemonAlreadyRunning()) {
         log(`[${DAEMON_NAME}] already running (port ${port}); nothing to do`);
         return "already-running";
       }
-      log(`[${DAEMON_NAME}] port ${port} is taken by another process; falling back to an ephemeral port`);
-      daemon = await createDaemon({ runner, port: 0, log, sessionTtlMs, evalBreakChannel });
+      log(`[${DAEMON_NAME}] ${describePortHolder(port)}; falling back to an ephemeral port`);
+      daemon = await createDaemon({ ...daemonOptions, port: 0 });
     }
   }
   writeDaemonInfo({
@@ -37445,7 +37611,7 @@ async function runDaemon(options = {}) {
     runner,
     ownPid: process.pid,
     idleTtlMs: envInt(DAEMON_IDLE_TTL_ENV, DAEMON_IDLE_TTL_MS),
-    sessionTtlMs: envInt(SESSION_IDLE_TTL_ENV, SESSION_IDLE_TTL_MS),
+    sessionTtlMs,
     log
   });
   log(
@@ -37459,8 +37625,9 @@ var DAEMON_USAGE = `Usage: daemon <command>
 
 Commands:
   start            Start the daemon in the background (no-op when already running)
-  stop             Stop the running daemon (SIGTERM, waits for exit)
-  status           Show pid, port, version, uptime, sessions, and active runs
+  stop [--all]     Stop this env's daemon (SIGTERM, waits for exit); --all stops every daemon
+                   on this machine, including draining (superseded) and legacy ones
+  status           Show every daemon: pid, port, version, uptime, sessions, active runs
   url              Print the MCP endpoint URL and client registration snippets
   run              Run the daemon in the foreground (logs to stderr)
   logs [-n LINES]  Print the tail of the daemon log
@@ -37478,9 +37645,53 @@ function formatUrlSnippets(url2) {
     "",
     "One registration serves every project: each workflow run names its project via the",
     "required `projectDir` tool argument (inspect/await/stop locate a runId automatically).",
-    "Stdio clients need no registration changes: the default stdio command proxies to this daemon automatically."
+    "Stdio clients need no registration changes: the default stdio command proxies to this daemon automatically.",
+    "Note: a direct HTTP registration pins this daemon's port; after a version upgrade the current",
+    "daemon may listen elsewhere \u2014 re-run `daemon url`. The stdio command follows upgrades automatically."
   ].join("\n");
 }
+async function probeAll() {
+  const instances = listDaemonInstances();
+  return Promise.all(
+    instances.map(async (instance) => {
+      const health = await probeHealthz(instance.info.port);
+      return { ...instance, health: health !== void 0 && health.pid === instance.info.pid ? health : void 0 };
+    })
+  );
+}
+function formatInstance(instance, currentPid) {
+  const { info, health } = instance;
+  const role = instance.legacy ? "legacy (pre-family daemon; stop it with `daemon stop --all`)" : info.pid === currentPid ? "current for this env" : health?.lameDuck ? "draining (superseded by a newer daemon; admits no new sessions)" : "other env family";
+  const lines = [
+    `${DAEMON_NAME} v${health?.version ?? info.version}`,
+    `  pid:         ${info.pid}`,
+    `  url:         ${info.url}`,
+    `  role:        ${role}`
+  ];
+  if (health === void 0) {
+    lines.push("  health:      not responding (pid alive, /healthz unreachable)");
+    return lines;
+  }
+  const uptimeMs = Date.now() - Date.parse(health.startedAt);
+  lines.push(
+    `  uptime:      ${Math.round(uptimeMs / 1e3)}s`,
+    `  sessions:    ${health.sessions}`,
+    `  active runs: ${health.activeRuns}`,
+    ...health.inflightRequests !== void 0 ? [`  in flight:   ${health.inflightRequests} request(s)`] : [],
+    ...health.projects.map((p2) => `    ${p2.projectDir}: ${p2.activeRuns} active run(s)`)
+  );
+  return lines;
+}
+async function stopInstance(instance, timeoutMs) {
+  const stopped = await stopDaemon(instance.info.pid, timeoutMs);
+  if (stopped) {
+    if (!instance.legacy) clearDaemonInfo(instance.info.pid);
+    console.log(`${DAEMON_NAME} (pid ${instance.info.pid}, v${instance.info.version}) stopped`);
+  } else {
+    console.error(`${DAEMON_NAME} (pid ${instance.info.pid}) did not exit within ${Math.round(timeoutMs / 1e3)}s`);
+  }
+  return stopped;
+}
 async function runDaemonCommand(args, options) {
   const [command, ...rest] = args;
   switch (command) {
@@ -37498,41 +37709,44 @@ async function runDaemonCommand(args, options) {
       return 0;
     }
     case "stop": {
+      if (rest.includes("--all")) {
+        const instances = listDaemonInstances();
+        if (instances.length === 0) {
+          console.log(`${DAEMON_NAME} is not running`);
+          return 0;
+        }
+        const results = await Promise.all(instances.map((instance) => stopInstance(instance, 7e3)));
+        return results.every(Boolean) ? 0 : 1;
+      }
       const info = readDaemonInfo();
       if (info === void 0 || !pidIsAlive(info.pid)) {
         if (info !== void 0) clearDaemonInfo(info.pid);
-        console.log(`${DAEMON_NAME} is not running`);
+        const others = listDaemonInstances();
+        console.log(
+          `${DAEMON_NAME} is not running for this env` + (others.length > 0 ? ` (${others.length} other daemon(s) alive \u2014 see \`daemon status\`, stop with \`daemon stop --all\`)` : "")
+        );
         return 0;
       }
-      const stopped = await stopDaemon(info.pid, 7e3);
-      if (!stopped) {
-        console.error(`${DAEMON_NAME} (pid ${info.pid}) did not exit within 7s`);
-        return 1;
-      }
-      console.log(`${DAEMON_NAME} (pid ${info.pid}) stopped`);
-      return 0;
+      const stopped = await stopInstance({ info, legacy: false }, 7e3);
+      return stopped ? 0 : 1;
     }
     case "status": {
-      const info = readDaemonInfo();
-      const health = info !== void 0 && pidIsAlive(info.pid) ? await probeHealthz(info.port) : void 0;
-      if (info === void 0 || health === void 0 || health.pid !== info.pid) {
-        console.log(`${DAEMON_NAME}: not running (client v${SERVER_VERSION}, default port ${resolveDaemonPort()})`);
+      const current = readDaemonInfo();
+      const currentPid = current !== void 0 && pidIsAlive(current.pid) ? current.pid : void 0;
+      const instances = await probeAll();
+      if (instances.length === 0) {
+        console.log(
+          `${DAEMON_NAME}: not running (client v${SERVER_VERSION}, env family ${envFingerprint()}, default port ${resolveDaemonPort()})`
+        );
         return 1;
       }
-      const uptimeMs = Date.now() - Date.parse(health.startedAt);
-      console.log(
-        [
-          `${DAEMON_NAME} v${health.version}`,
-          `  pid:         ${health.pid}`,
-          `  url:         ${info.url}`,
-          `  uptime:      ${Math.round(uptimeMs / 1e3)}s`,
-          `  sessions:    ${health.sessions}`,
-          `  active runs: ${health.activeRuns}`,
-          ...health.lameDuck ? ["  lame duck:   yes (superseded by a newer daemon \u2014 draining, admits no new sessions)"] : [],
-          ...health.projects.map((p2) => `    ${p2.projectDir}: ${p2.activeRuns} active run(s)`)
-        ].join("\n")
-      );
-      return 0;
+      const blocks = instances.sort((a, b) => a.info.pid === currentPid ? -1 : b.info.pid === currentPid ? 1 : 0).map((instance) => formatInstance(instance, currentPid).join("\n"));
+      console.log(blocks.join("\n\n"));
+      if (currentPid === void 0) {
+        console.log(`
+(no current daemon for this env \u2014 client v${SERVER_VERSION}, env family ${envFingerprint()})`);
+      }
+      return currentPid === void 0 ? 1 : 0;
     }
     case "url": {
       const info = readDaemonInfo();
@@ -39131,15 +39345,26 @@ var StreamableHTTPClientTransport = class {
 };
 
 // ../mcp-server/src/shim/shim.ts
+var RECOVERY_WINDOW_MS = 6e4;
+var RECOVERY_MAX_PER_WINDOW = 6;
 function initializeResultProtocolVersion(message) {
   if (!isJSONRPCResponse(message)) return void 0;
   const version2 = message.result.protocolVersion;
   return typeof version2 === "string" ? version2 : void 0;
 }
+function isRecoverableError(error51) {
+  if (error51 instanceof StreamableHTTPError) return error51.code === 404 || error51.code === 503;
+  if (error51 instanceof TypeError) return true;
+  if (error51 instanceof Error) {
+    return /Maximum reconnection attempts|Failed to reconnect|Failed to open SSE stream/.test(error51.message);
+  }
+  return false;
+}
 async function runShim(options) {
   const log = (line) => console.error(line);
   const info = await ensureDaemonRunning({ bundlePath: options.bundlePath, port: options.port, log });
   let replBreakUrl = info.replBreakUrl;
+  let exiting = false;
   function fireOutOfBandBreak(projectDir) {
     if (typeof projectDir !== "string" || replBreakUrl === void 0) return;
     let key;
@@ -39166,14 +39391,56 @@ async function runShim(options) {
   const queue = [];
   const subscribedUris = /* @__PURE__ */ new Set();
   const swallowedIds = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
+  const keyOf = (id) => `${typeof id}:${String(id)}`;
+  const retired = /* @__PURE__ */ new WeakSet();
+  const recoveryTimes = [];
+  function recoveryAllowed(now = Date.now()) {
+    while (recoveryTimes.length > 0 && now - recoveryTimes[0] > RECOVERY_WINDOW_MS) recoveryTimes.shift();
+    return recoveryTimes.length < RECOVERY_MAX_PER_WINDOW;
+  }
   const makeHttpTransport = (url2) => {
     const transport = new StreamableHTTPClientTransport(new URL(url2));
-    transport.onmessage = onDaemonMessage;
-    transport.onerror = (error51) => log(`[${DAEMON_NAME} shim] http transport error: ${String(error51)}`);
+    transport.onmessage = (message) => onDaemonMessage(message, transport);
+    transport.onerror = (error51) => onTransportError(transport, error51);
     return transport;
   };
   let http2 = makeHttpTransport(info.url);
-  function onDaemonMessage(message) {
+  function failPendingOn(transport, reason) {
+    let failed = 0;
+    for (const [key, entry] of [...pending.entries()]) {
+      if (entry.transport !== transport) continue;
+      pending.delete(key);
+      failed++;
+      void stdio.send({
+        jsonrpc: "2.0",
+        id: entry.message.id,
+        error: {
+          code: -32603,
+          message: `workflow daemon session lost before the response arrived (${reason}); the request may or may not have completed \u2014 inspect before retrying`
+        }
+      }).catch(() => void 0);
+    }
+    return failed;
+  }
+  function retireTransport(transport, reason) {
+    retired.add(transport);
+    void transport.close().catch(() => void 0);
+    setImmediate(() => {
+      const failed = failPendingOn(transport, reason);
+      if (failed > 0) log(`[${DAEMON_NAME} shim] ${failed} in-flight request(s) failed with the lost session (${reason})`);
+    });
+  }
+  function onTransportError(transport, error51) {
+    if (retired.has(transport) || exiting) return;
+    log(`[${DAEMON_NAME} shim] http transport error: ${String(error51)}`);
+    if (isRecoverableError(error51)) void startReinitialize(`stream error: ${String(error51)}`);
+  }
+  function onDaemonMessage(message, transport) {
+    if ((isJSONRPCResponse(message) || isJSONRPCError(message)) && message.id !== null && message.id !== void 0) {
+      pending.delete(keyOf(message.id));
+    }
+    if (retired.has(transport)) return;
     if (pendingReinitId !== void 0 && isJSONRPCResponse(message) && message.id === pendingReinitId) {
       pendingReinitId = void 0;
       const version2 = initializeResultProtocolVersion(message);
@@ -39193,7 +39460,7 @@ async function runShim(options) {
       }).catch((error51) => failPump(`re-initialize handshake failed: ${String(error51)}`));
       return;
     }
-    if (isJSONRPCResponse(message) && typeof message.id === "string" && swallowedIds.delete(message.id)) {
+    if ((isJSONRPCResponse(message) || isJSONRPCError(message)) && typeof message.id === "string" && swallowedIds.delete(message.id)) {
       return;
     }
     if (clientInitializeId !== void 0 && isJSONRPCResponse(message) && message.id === clientInitializeId) {
@@ -39211,15 +39478,21 @@ async function runShim(options) {
     log(`[${DAEMON_NAME} shim] fatal: ${reason}`);
     void shutdown(1);
   }
-  async function startReinitialize() {
-    if (reinitializing) return;
+  async function startReinitialize(reason) {
+    if (reinitializing || exiting) return;
+    if (!recoveryAllowed()) {
+      failPump(`daemon session recovery is looping (${RECOVERY_MAX_PER_WINDOW} attempts within ${RECOVERY_WINDOW_MS}ms; last: ${reason})`);
+      return;
+    }
+    recoveryTimes.push(Date.now());
     reinitializing = true;
     if (cachedInitialize === void 0) {
       failPump("daemon session lost before the client ever initialized");
       return;
     }
+    log(`[${DAEMON_NAME} shim] recovering the daemon session (${reason})`);
     try {
-      await http2.close().catch(() => void 0);
+      retireTransport(http2, reason);
       const fresh = await ensureDaemonRunning({ bundlePath: options.bundlePath, port: options.port, log });
       replBreakUrl = fresh.replBreakUrl;
       http2 = makeHttpTransport(fresh.url);
@@ -39228,28 +39501,29 @@ async function runShim(options) {
       const reinit = { ...cachedInitialize, id: pendingReinitId };
       await http2.send(reinit);
     } catch (error51) {
+      if (isRecoverableError(error51) && recoveryAllowed()) {
+        reinitializing = false;
+        pendingReinitId = void 0;
+        setTimeout(() => void startReinitialize(`retry after: ${String(error51)}`), 250);
+        return;
+      }
       failPump(`could not re-establish a daemon session: ${String(error51)}`);
     }
   }
-  let recoveryStreak = 0;
-  function isRecoverableSendError(error51) {
-    if (error51 instanceof StreamableHTTPError && error51.code === 404) return true;
-    return error51 instanceof TypeError;
-  }
-  let sendChain = Promise.resolve();
   async function pumpSend(message) {
     if (reinitializing) {
       queue.push(message);
       return;
     }
+    const transport = http2;
+    if (isJSONRPCRequest(message)) pending.set(keyOf(message.id), { transport, message });
     try {
-      await http2.send(message);
-      recoveryStreak = 0;
+      await transport.send(message);
     } catch (error51) {
-      if (isRecoverableSendError(error51) && recoveryStreak < 3) {
-        recoveryStreak++;
+      if (isJSONRPCRequest(message)) pending.delete(keyOf(message.id));
+      if (isRecoverableError(error51)) {
         queue.push(message);
-        void startReinitialize();
+        void startReinitialize(`send failed: ${String(error51)}`);
         return;
       }
       log(`[${DAEMON_NAME} shim] send failed: ${String(error51)}`);
@@ -39262,6 +39536,7 @@ async function runShim(options) {
       }
     }
   }
+  let sendChain = Promise.resolve();
   stdio.onmessage = (message) => {
     if (isJSONRPCRequest(message)) {
       if (message.method === "initialize") {
@@ -39285,7 +39560,6 @@ async function runShim(options) {
     }
     sendChain = sendChain.then(() => pumpSend(message)).catch(() => void 0);
   };
-  let exiting = false;
   async function shutdown(code) {
     if (exiting) return;
     exiting = true;