From 7f8018a924ed01f408a7a6e1ac7d936976358a4c Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Wed, 30 Sep 2026 07:38:50 +1000 Subject: [PATCH] docs(prds): decide the declared-outputs model for workflow.call --- docs/data/generated/dev-docs.json | 10 ++ docs/prds/workflow-call-outputs.md | 213 +++++++++++++++++++++++++++++ 2 files changed, 223 insertions(+) create mode 100644 docs/prds/workflow-call-outputs.md diff --git a/docs/data/generated/dev-docs.json b/docs/data/generated/dev-docs.json index 6cf09e497..b2f802e2e 100644 --- a/docs/data/generated/dev-docs.json +++ b/docs/data/generated/dev-docs.json @@ -540,6 +540,12 @@ "section": "PRDs", "body": "# Webhook intake security -- decision\n\n**Status:** Approved\n**Date:** 2026-08-22\n**Beads issue:** `archie-core-t2db.5`, blocks `archie-core-t2db.4`\n\n## Why this is decided ahead of the code it constrains\n\n`archie-core-t2db` (no-code playbooks) and `archie-core-7d5u` (typed event\nsources) both land a public intake surface whose eventual output is an agent\nwith tool access and a repo. Neither capture (`t2db.1`) nor the intake family\n(`7d5u.3`) has shipped yet, so this decision exists to be a contract the two\nepics build against, not a retrofit once the surface exists. A webhook URL\nthat can start an agent is remote code execution with extra steps if any of\nthe five points below is missing on day one.\n\n## 1. Per-source authentication\n\nReuse the per-route HMAC-SHA256 scheme already in\n`internal/channels/webhook/webhook.go` (`validateHMAC`), unchanged: a source\nregisters with a shared secret; the signature is checked against the raw\nbody. Do not invent a second scheme for intake.\n\n**Capture and triggering split at the signature, not at a separate flag.** An\nevent with a missing or invalid signature is still captured (visible in the\ninspector, marked unauthenticated) so an operator can diagnose a\nmisconfigured sender -- but an unauthenticated event can never be matched\nagainst a binding. Authentication is what promotes an event from \"something\narrived\" to \"something that can run a workflow.\"\n\n## 2. Human approval before a binding arms\n\nA binding has three states: `draft -\u003e pending_approval -\u003e armed`. Only\n`armed` bindings are evaluated against incoming events. Creating or editing a\nbinding's matcher, mapping, or target workflow always sets it to\n`pending_approval`, including edits to an already-armed binding -- an edit is\nnot silently re-armed, or the approval gate is decorative. Approval requires\nan authenticated dashboard session; there is no unattended approval path.\n\nModel: `internal/channels/telegram`'s dangerous-command approval flow\n(`dangerousAction` / `pendingApproval` in `dangerous.go` / `approval.go`) is\nthe existing precedent for \"a human decision gates code from running\" in this\ncodebase -- follow its shape rather than designing a new approval primitive.\n\n## 3. Rate and volume limits, per source\n\nA token-bucket limiter keyed by source ID, not global -- one noisy or hostile\nsender must not exhaust another source's capture budget. Precedent for\nper-key volume capping: `internal/pairing/store.go`'s `MaxPendingPerPlatform`.\n\nOn limit exceeded, the request is rejected (HTTP 429), not silently dropped.\nA silently dropped event is indistinguishable from a sender that never fired\n-- the same invisible-failure shape the update-verification work\n(`archie-core-522`) exists to prevent. The rejection itself is observable in\nthe inspector as a distinct outcome from \"not received.\"\n\n## 4. Blast radius bounded by code, not by prompt wording\n\nA playbook-triggered task runs through exactly the same enforcement as every\nother task: the `[[repos.gate]]` quality gate, `diff_cap_lines`, the\nsandboxed per-task container (`internal/container`), worktree isolation, and\n\"the model never runs git.\" No new relaxation is introduced for\nplaybook-triggered work, and none is needed -- the existing constraints are\nthe control.\n\nMapped payload fields are treated as ordinary user-controlled text inside an\nagent prompt, exactly like an inbound chat message never as trusted\ninstructions. \"The agent should ignore instructions in the payload\" is not a\ncontrol and must not appear as one anywhere in this feature -- per the\nenvironmental-enforcement principle (`docs/architecture/agent-system.md`,\n\"Existing invariants to preserve\"), the boundary is the gate and the sandbox,\nnot a sentence in the system prompt.\n\n## 5. Retention and redaction of captured payloads\n\n**Retention:** captured events (bound or not) are purged after 7 days,\nconfigurable per deployment. Unbound events exist to be mapped against; nothing\njustifies keeping them indefinitely once that window has passed, and an\nunbounded capture store is the same disk-exhaustion risk item 3 addresses at\nthe request-rate level.\n\n**Redaction:** before a captured payload is persisted, apply the same\nkey-name heuristic `internal/gateway/stream.go`'s `sensitiveParameterKey`\nalready uses for tool-call parameters (matches `token`, `secret`, `password`,\n`passwd`, `api_key`, `apikey`, `authorization`, `credential`, `cookie`,\n`private_key` against normalised JSON keys) and replace matching values with\nthe same `[redacted]` marker. This is best-effort, not a guarantee -- a\nsender that names a secret field something the heuristic misses will still\nhave it captured. Document that limitation where captured payloads are\ndisplayed, rather than implying the redaction is complete.\n\n**Visibility:** captured payloads, redacted or not, are visible only to an\nauthenticated dashboard operator -- the same authorisation boundary as every\nother webui surface, not a separate or lower bar.\n\n## What this does not decide\n\nThe intake family's registration interface (`7d5u.3`), the capture storage\nmechanism (`7d5u.2`, embedded NATS), and the binding data model's persistence\nand versioning (`t2db.4`) are separate decisions. This document constrains\nall three: whatever they build must satisfy points 1-5 above.\n" }, + { + "url": "/dev/prds/workflow-call-outputs/", + "title": "Declared outputs of a workflow run", + "section": "PRDs", + "body": "# Declared outputs of a workflow run\n\n**Status:** Draft\n**Date:** 2026-09-30\n**Bead:** `archie-core-t2db.43`\n**Authority:** `docs/prds/event-automation.md` for what a declared output is,\n`docs/prds/workflow-calls.md` for the call and its grants,\n`docs/prds/state-store-contract.md` for the State Store contract the wire\nchange must satisfy.\n**Supersedes:** `docs/prds/workflow-calls.md`, \"Waiting on the callee\": the\ncallee's transition detail is the human summary, not the stand-in for\nstructured outputs.\n\nA workflow declares named, typed outputs. A run writes each one once. A\n`wait: true` caller receives them, and may publish one as its own.\n\n## Where outputs are declared\n\n`outputs:` on the workflow definition, beside `inputs:`, decoded into\n`task.WorkflowInterface.Outputs map[string]OutputSpec` where\n`OutputSpec{Type, Required}`:\n\n```yaml\nid: firewall-contain\noutputs:\n contained: { type: bool, required: true }\n summary: { type: string }\n```\n\nNames and types are the input grammar: the same identifier shape, the same\ntype set, and the same check in `WorkflowInterface.Validate`, which both\n`ParseDefinition` and `ParseWorkflowInterface` call.\n\n**Forced by:** `ParseDefinition` decodes with `KnownFields(true)`, so a key no\ndecoded struct declares is refused — the declaration must live on\n`WorkflowInterface` for an author to write it at all, and that is where\n`docs/development/workflows.md` puts every field a process without the engine\nmust read. The type set is the shared value vocabulary: `TypeAccepts` and\n`ValueType` already check a mapped parameter and an input with it. `required`\ndefaults to false, and the generated YAML for a builtin that declares no\noutputs is unchanged, because a definition's digest pins a run.\n\n**Rejected:** outputs per step, or per call step, because a workflow returns a\nresult as itself rather than as one of its stages. Also `task.Definition`\ngaining outputs: no reader needs them — a binding offers inputs, and a call's\noutputs assignment is checked against the callee's YAML in the same\ncollection — and a declared field with no reader parses and does nothing.\n\n## How a run writes one\n\nEach declared output is offered to the run's agent stages as a capture tool\nnamed after the output, whose arguments are `{\"value\": ...}`; the accepted\ncall's `value` member is the output's value. The engine holds the accepted\nvalues on the task context and writes them into its own task row in the\n`Store.Update` call the run already makes. A deterministic stage may set the\nsame values in Go, and the run's finish check validates them identically.\n\n**Forced by:** a run's only structured results are capture calls\n(`agentexec.CaptureTool`, `Result.Captures`), and the workflow interface\nalready declares when a stage needs them (`task.WorkflowNeeds.Captures`).\nDeriving the tools from the declaration means an output cannot be written\nunder a name nobody declared, and it keeps one route to structured agent\noutput rather than adding a second beside the capture path. The row write is\nthe run's existing write: the task row is where a run's own state lives, and\nthe container already holds `Update` on its own row.\n\nThe tool is offered with `MaxCalls: 1`, and a stage is not offered an output\nthe run has written, so a run writes each output once: a repeat within a stage\nis answered with the tool's rejection and the agent carries on, and a later\nstage cannot overwrite a value. A stage's own capture tool may not share a\nname with a declared output, because the value would otherwise be ambiguous.\n\n**Rejected:** a `workflow.output` step type, because assigning the run's\nresult from a step needs a grammar for \"the previous stage's result\" that does\nnot exist, and a step that reaches the agent would be the second path\n`docs/development/workflows.md` forbids. Also a write RPC of its own: the\ncontainer's `Update` already reaches its own row, and a second write verb for\none column is a second thing to keep in step.\n\n## How a caller receives one\n\nOn a successful `wait: true` call the caller's stage holds the callee's\noutputs as a `map[string]any`. A call step's `outputs:` setting publishes one\nas one of the caller's own outputs:\n\n```yaml\nsteps:\n - type: workflow.call\n workflow: firewall-contain\n wait: true\n inputs: { src_ip: inputs.src_ip }\n outputs: { contained: outputs.contained }\n```\n\nThe key names the callee's declared name; the value names one of the caller's\nown with the prefix the call's `inputs:` already uses. A published value joins\nthe caller's output set for its run, so a caller returns its callee's result to\nits own caller, and a run may publish a callee's output and write its own\nothers.\n\nLifetime is the attempt. The run starts with an empty output set, every later\nstage of that attempt sees the values, and the finish write replaces the row's\nset wholesale — so nothing an attempt wrote survives into the next, and a run\nthat writes nothing stores nothing. Values reach a caller only from a\nsuccessful terminal state: the caller assigns them after `callSucceeded`, so a\nparked or failed callee delivers nothing whatever its row holds. A call step\nwith `wait: false` and an `outputs:` block is refused when the definition is\nsaved, because nothing has finished when the caller moves on.\n\n**Forced by:** caller and callee are separate runs in separate containers, so\nthe caller's own row is the only durable place to hold a received value. The\nprefix rule is not a new grammar: in `inputs.\u003cname\u003e` the prefixed side is the\ncaller's own value and the map key is the callee's, and `outputs.\u003cname\u003e` reads\nthe same way in the other direction.\n\n**Rejected:** an implicit same-name copy from callee to caller, because the\ncaller's contract would then depend on a callee it does not name, and swapping\nthe callee would silently change what the caller returns. Also letting a later\nstage read a callee's output in its mission text: that needs a stage-result\nreference namespace this model does not define.\n\n## Failure rules\n\n- **Undeclared value.** The agent path cannot produce one — the tool exists\n only for a declared output. A Go stage that sets an undeclared key parks the\n run before its outcome transition, and a stage capture tool sharing a\n declared output's name is refused when the run starts.\n- **Declared but never written.** With `required: true` the run parks naming\n the output and reaches no successful terminal state, so no caller observes a\n success missing a promised value. Without it the key is absent from the\n object rather than null, and a written `null` counts as not written, as\n `CheckInputs` treats a null input. A published output the callee never wrote\n leaves the caller's output absent, which the caller's own `required` then\n judges.\n- **Save time.** `WorkflowInterface.Validate` refuses an unknown type and a\n malformed name. A call step's `outputs:` assignment is checked by a\n `checkCallOutputs` beside `checkCallInputs`: the key must be declared by the\n callee, the reference must name an output the caller declares, and the\n callee's declared type must satisfy the caller's.\n- **Run time.** A captured value is re-validated against the declared type\n when the run reads it back, for the reason `readCaptures` re-checks every\n record: the captures file is writable by the harness user. A published\n callee value is re-checked against the caller's declared type before it\n enters the caller's set; a mismatch parks the caller naming the output.\n\n**Rejected:** typing at save time only, because a captured value has no\nsave-time form; and at run time only, because a definition error would surface\nas a failed run instead of a refused save.\n\n## Storage and wire\n\n- `tasks.outputs`, text, `NOT NULL DEFAULT ''`, written by the run's own row\n write — the shape `tasks.inputs` already has, with `EncodeOutputs` and\n `DecodeOutputs` beside `EncodeInputs`/`DecodeInputs`.\n- The `Task` message carries it as `outputs_json`, because the container's\n `Update` sends the whole row and a column the message cannot carry is a\n column that write drops.\n- `WorkflowCallStatusResponse` carries it as `outputs_json` beside `status`\n and `detail`, read from the callee's row by the handler that already\n verifies `call_parent_task_id`; `detail` keeps carrying the transition\n detail. The Go facade stays the two methods of `task.Caller`; no interface\n method is added.\n\n**Forced by the grant:** a caller authenticates as its own task and may reach\n`WorkflowCallStatus` on its own task ID, `Update`/`Transition`/`InsertEvent`\non its own row, and the step-execution pair on its own execution. It can read\nneither the callee's row nor the callee's steps. `WorkflowCallStatus` is\ntherefore the only channel that exists, and it is already the sanctioned\ncross-run read — this model fills the placeholder it carries. The values live\non the callee's row rather than on the caller's call step because the callee\nwrites them and the caller only receives them.\n\nThe write order is part of the contract: a run persists its outputs before its\noutcome transition, so the status a caller sees when its wait ends already\ncarries them. A set whose encoded form passes the bound the store applies to a\nstructured payload (`clip`, as `ReviewPayload` is stored) is refused rather\nthan clipped, because clipped JSON does not parse.\n\nNo sentinel moves: a missing required output is an engine park reason, and a\ncaller asking about a task that is not its callee still gets `ErrCallNotYours`,\nso nothing new crosses `mapError`/`unmapError` and no canonical message string\nchanges.\n\n**Rejected:**\n- A new read RPC (`WorkflowCallOutputs`) — a second poll of a row the caller\n already polls, whose answer could disagree with the status beside it, and a\n second grant-widening row for the same parent-child check.\n- The step-execution record — `ListSteps` is granted by `read` on a run, so a\n caller cannot read the callee's steps at all, and making them readable would\n hand it the callee's whole step history, which the parent-child check exists\n to prevent. A step's `detail` is text clipped like every other detail.\n- The caller's call step as the store — the value originates in another\n process and must outlive the container that produced it.\n\n## Out of scope\n\n- A run started by a binding: it has no caller, and its outputs live on its\n own row only.\n- A stage reference to a previous stage's captured value.\n- Assigning outputs in a caller cancelled while it waits.\n\n## Verification\n\n- A definition whose output type is not in the vocabulary, and a call\n publishing an output neither side declares, are refused when saved.\n- A `wait: true` caller receives a value its callee wrote, returns it as its\n own output, and the caller's row carries it.\n- A run whose required output is never written parks, and its caller's stage\n fails naming the output.\n- A call step publishing an output over `wait: false` is refused when saved.\n- A retried attempt that writes no outputs leaves an empty set on the row.\n- An example under `examples/workflows/` carries an `outputs:` block and a\n call that publishes one, which `TestExampleWorkflowsParse` covers.\n" + }, { "url": "/dev/prds/workflow-calls/", "title": "Workflows calling workflows", @@ -915,6 +921,10 @@ "title": "Webhook intake security -- decision", "url": "/dev/prds/webhook-intake-security/" }, + { + "title": "Declared outputs of a workflow run", + "url": "/dev/prds/workflow-call-outputs/" + }, { "title": "Workflows calling workflows", "url": "/dev/prds/workflow-calls/" diff --git a/docs/prds/workflow-call-outputs.md b/docs/prds/workflow-call-outputs.md new file mode 100644 index 000000000..4630b3885 --- /dev/null +++ b/docs/prds/workflow-call-outputs.md @@ -0,0 +1,213 @@ +# Declared outputs of a workflow run + +**Status:** Draft +**Date:** 2026-09-30 +**Bead:** `archie-core-t2db.43` +**Authority:** `docs/prds/event-automation.md` for what a declared output is, +`docs/prds/workflow-calls.md` for the call and its grants, +`docs/prds/state-store-contract.md` for the State Store contract the wire +change must satisfy. +**Supersedes:** `docs/prds/workflow-calls.md`, "Waiting on the callee": the +callee's transition detail is the human summary, not the stand-in for +structured outputs. + +A workflow declares named, typed outputs. A run writes each one once. A +`wait: true` caller receives them, and may publish one as its own. + +## Where outputs are declared + +`outputs:` on the workflow definition, beside `inputs:`, decoded into +`task.WorkflowInterface.Outputs map[string]OutputSpec` where +`OutputSpec{Type, Required}`: + +```yaml +id: firewall-contain +outputs: + contained: { type: bool, required: true } + summary: { type: string } +``` + +Names and types are the input grammar: the same identifier shape, the same +type set, and the same check in `WorkflowInterface.Validate`, which both +`ParseDefinition` and `ParseWorkflowInterface` call. + +**Forced by:** `ParseDefinition` decodes with `KnownFields(true)`, so a key no +decoded struct declares is refused — the declaration must live on +`WorkflowInterface` for an author to write it at all, and that is where +`docs/development/workflows.md` puts every field a process without the engine +must read. The type set is the shared value vocabulary: `TypeAccepts` and +`ValueType` already check a mapped parameter and an input with it. `required` +defaults to false, and the generated YAML for a builtin that declares no +outputs is unchanged, because a definition's digest pins a run. + +**Rejected:** outputs per step, or per call step, because a workflow returns a +result as itself rather than as one of its stages. Also `task.Definition` +gaining outputs: no reader needs them — a binding offers inputs, and a call's +outputs assignment is checked against the callee's YAML in the same +collection — and a declared field with no reader parses and does nothing. + +## How a run writes one + +Each declared output is offered to the run's agent stages as a capture tool +named after the output, whose arguments are `{"value": ...}`; the accepted +call's `value` member is the output's value. The engine holds the accepted +values on the task context and writes them into its own task row in the +`Store.Update` call the run already makes. A deterministic stage may set the +same values in Go, and the run's finish check validates them identically. + +**Forced by:** a run's only structured results are capture calls +(`agentexec.CaptureTool`, `Result.Captures`), and the workflow interface +already declares when a stage needs them (`task.WorkflowNeeds.Captures`). +Deriving the tools from the declaration means an output cannot be written +under a name nobody declared, and it keeps one route to structured agent +output rather than adding a second beside the capture path. The row write is +the run's existing write: the task row is where a run's own state lives, and +the container already holds `Update` on its own row. + +The tool is offered with `MaxCalls: 1`, and a stage is not offered an output +the run has written, so a run writes each output once: a repeat within a stage +is answered with the tool's rejection and the agent carries on, and a later +stage cannot overwrite a value. A stage's own capture tool may not share a +name with a declared output, because the value would otherwise be ambiguous. + +**Rejected:** a `workflow.output` step type, because assigning the run's +result from a step needs a grammar for "the previous stage's result" that does +not exist, and a step that reaches the agent would be the second path +`docs/development/workflows.md` forbids. Also a write RPC of its own: the +container's `Update` already reaches its own row, and a second write verb for +one column is a second thing to keep in step. + +## How a caller receives one + +On a successful `wait: true` call the caller's stage holds the callee's +outputs as a `map[string]any`. A call step's `outputs:` setting publishes one +as one of the caller's own outputs: + +```yaml +steps: + - type: workflow.call + workflow: firewall-contain + wait: true + inputs: { src_ip: inputs.src_ip } + outputs: { contained: outputs.contained } +``` + +The key names the callee's declared name; the value names one of the caller's +own with the prefix the call's `inputs:` already uses. A published value joins +the caller's output set for its run, so a caller returns its callee's result to +its own caller, and a run may publish a callee's output and write its own +others. + +Lifetime is the attempt. The run starts with an empty output set, every later +stage of that attempt sees the values, and the finish write replaces the row's +set wholesale — so nothing an attempt wrote survives into the next, and a run +that writes nothing stores nothing. Values reach a caller only from a +successful terminal state: the caller assigns them after `callSucceeded`, so a +parked or failed callee delivers nothing whatever its row holds. A call step +with `wait: false` and an `outputs:` block is refused when the definition is +saved, because nothing has finished when the caller moves on. + +**Forced by:** caller and callee are separate runs in separate containers, so +the caller's own row is the only durable place to hold a received value. The +prefix rule is not a new grammar: in `inputs.` the prefixed side is the +caller's own value and the map key is the callee's, and `outputs.` reads +the same way in the other direction. + +**Rejected:** an implicit same-name copy from callee to caller, because the +caller's contract would then depend on a callee it does not name, and swapping +the callee would silently change what the caller returns. Also letting a later +stage read a callee's output in its mission text: that needs a stage-result +reference namespace this model does not define. + +## Failure rules + +- **Undeclared value.** The agent path cannot produce one — the tool exists + only for a declared output. A Go stage that sets an undeclared key parks the + run before its outcome transition, and a stage capture tool sharing a + declared output's name is refused when the run starts. +- **Declared but never written.** With `required: true` the run parks naming + the output and reaches no successful terminal state, so no caller observes a + success missing a promised value. Without it the key is absent from the + object rather than null, and a written `null` counts as not written, as + `CheckInputs` treats a null input. A published output the callee never wrote + leaves the caller's output absent, which the caller's own `required` then + judges. +- **Save time.** `WorkflowInterface.Validate` refuses an unknown type and a + malformed name. A call step's `outputs:` assignment is checked by a + `checkCallOutputs` beside `checkCallInputs`: the key must be declared by the + callee, the reference must name an output the caller declares, and the + callee's declared type must satisfy the caller's. +- **Run time.** A captured value is re-validated against the declared type + when the run reads it back, for the reason `readCaptures` re-checks every + record: the captures file is writable by the harness user. A published + callee value is re-checked against the caller's declared type before it + enters the caller's set; a mismatch parks the caller naming the output. + +**Rejected:** typing at save time only, because a captured value has no +save-time form; and at run time only, because a definition error would surface +as a failed run instead of a refused save. + +## Storage and wire + +- `tasks.outputs`, text, `NOT NULL DEFAULT ''`, written by the run's own row + write — the shape `tasks.inputs` already has, with `EncodeOutputs` and + `DecodeOutputs` beside `EncodeInputs`/`DecodeInputs`. +- The `Task` message carries it as `outputs_json`, because the container's + `Update` sends the whole row and a column the message cannot carry is a + column that write drops. +- `WorkflowCallStatusResponse` carries it as `outputs_json` beside `status` + and `detail`, read from the callee's row by the handler that already + verifies `call_parent_task_id`; `detail` keeps carrying the transition + detail. The Go facade stays the two methods of `task.Caller`; no interface + method is added. + +**Forced by the grant:** a caller authenticates as its own task and may reach +`WorkflowCallStatus` on its own task ID, `Update`/`Transition`/`InsertEvent` +on its own row, and the step-execution pair on its own execution. It can read +neither the callee's row nor the callee's steps. `WorkflowCallStatus` is +therefore the only channel that exists, and it is already the sanctioned +cross-run read — this model fills the placeholder it carries. The values live +on the callee's row rather than on the caller's call step because the callee +writes them and the caller only receives them. + +The write order is part of the contract: a run persists its outputs before its +outcome transition, so the status a caller sees when its wait ends already +carries them. A set whose encoded form passes the bound the store applies to a +structured payload (`clip`, as `ReviewPayload` is stored) is refused rather +than clipped, because clipped JSON does not parse. + +No sentinel moves: a missing required output is an engine park reason, and a +caller asking about a task that is not its callee still gets `ErrCallNotYours`, +so nothing new crosses `mapError`/`unmapError` and no canonical message string +changes. + +**Rejected:** +- A new read RPC (`WorkflowCallOutputs`) — a second poll of a row the caller + already polls, whose answer could disagree with the status beside it, and a + second grant-widening row for the same parent-child check. +- The step-execution record — `ListSteps` is granted by `read` on a run, so a + caller cannot read the callee's steps at all, and making them readable would + hand it the callee's whole step history, which the parent-child check exists + to prevent. A step's `detail` is text clipped like every other detail. +- The caller's call step as the store — the value originates in another + process and must outlive the container that produced it. + +## Out of scope + +- A run started by a binding: it has no caller, and its outputs live on its + own row only. +- A stage reference to a previous stage's captured value. +- Assigning outputs in a caller cancelled while it waits. + +## Verification + +- A definition whose output type is not in the vocabulary, and a call + publishing an output neither side declares, are refused when saved. +- A `wait: true` caller receives a value its callee wrote, returns it as its + own output, and the caller's row carries it. +- A run whose required output is never written parks, and its caller's stage + fails naming the output. +- A call step publishing an output over `wait: false` is refused when saved. +- A retried attempt that writes no outputs leaves an empty set on the row. +- An example under `examples/workflows/` carries an `outputs:` block and a + call that publishes one, which `TestExampleWorkflowsParse` covers.