Deliver answers to suspended workflows for later resumption

[taras]

Story

As a workflow user, I want to deliver a typed answer to one retained suspension and resume explicitly, so a durable wait can continue without an in-memory waiter, hidden transcript reconstruction, or another execution authority.

Current delivery state

Typed durable answer delivery and claim are shipped by PR #479. The remaining work is slice 2: scheduling the ordinary resume path after #301 supplies the real composed consumer. Answer delivery itself remains non-executing.

Settled sequencing

#367 now supplies inspection, suspension, cancellation, executor ownership, and executor-lock release. A suspended run can survive its host, but without an answer every resume reaches the same retained request and suspends again.

This story has two delivery slices:

1. Typed durable answer delivery is shipped by PR 📥 Deliver a typed answer to a suspended workflow run #479. It depends on the retained suspension contract, not on the completed adversarial workflow.
2. Scheduling follows Compose the supervised adversarial implementation workflow #301. It resumes a real composed consumer when an answer becomes available; it does not define another way to execute a run.

Delivery and execution remain separate observable operations. Offering an answer records it only. It does not acquire the executor lock, start a document execution, or call resume. The existing explicit workflow resume path later acquires the lock, claims the answer, and continues the run.

Slice 1: typed durable answer delivery

The public correlation boundary is the retained suspension ID and its retained response schema. An authorized host may offer one JSON value for that exact pending request.

Before durable storage, the host:

• finds the exact retained run and suspension request without executing the document;
• requires the suspension ID to name that run's current unanswered request;
• validates the value against the response schema retained with that request; and
• sends the complete retained answer state through the existing persistence secret gate.

A successful delivery retains pending answer state and returns without changing run status. It appends no answer event and does not consume the value.

On a later explicit resume, only authenticated retained answer state may let suspendFor() continue. The resumed execution publishes one ordinary filtered answer Yield and marks the pending delivery consumed in the same transaction. Only after that commit does suspendFor() return the value to the document. A crash before the transaction commits leaves the answer pending and eligible for the same request; a crash after it commits replays the retained answer event without consuming or publishing another answer.

A contextual handler's return value, document state, props, middleware, a same-named API, or an answer supplied to resume cannot substitute for retained answer state.

Duplicate, late, already-consumed, wrong-run, wrong-request, and schema-invalid delivery is refused without mutation. Cancellation or deletion cannot leave an answer that later authorizes a reused public run ID. Diagnostics retain neither rejected values nor secret matches.

This slice defines the provider-neutral delivery and claim contract and the first local host adapter. It does not combine answer delivery with resume. A public remote-host selector, unattended scheduler, file watcher, or generic untyped resume --answer option is not introduced.

Recording who supplied an answer is a separate provenance decision. This slice authenticates the host's authority to deliver and the retained request/value correlation; it does not invent human actor identity.

Slice 2: explicit scheduling

After #301 supplies the supervised workflow that consumes durable answers, a host may schedule the same existing resume operation when an answer becomes available.

Scheduling:

• acquires the same executor lock as foreground resume;
• observes the same lifecycle admission and cancellation rules;
• calls the same provider-neutral resume operation;
• cannot create a second executor or bypass explicit answer delivery; and
• requires no file watcher, implicit branch movement, document-path lookup, or hidden Agent state.

The first scheduler is explicit host behavior. Configured source watching, unattended iteration-completion arbitration, and a public remote-host selector remain deferred until a concrete product contract requires them.

Acceptance: typed delivery

• One value is correlated to the exact retained suspension ID and response schema.
• Delivery validates before persistence and crosses the existing secret gate.
• Successful delivery changes neither run status nor document-execution history and acquires no executor lock.
• Explicit resume publishes one filtered answer event, consumes the pending delivery atomically, and returns the value from suspendFor().
• A crash before publication leaves the answer pending; replay after publication emits no duplicate event and requests no replacement answer.
• Duplicate, late, consumed, mismatched, invalid, cancelled-run, and deleted-run delivery is refused without mutation.
• Public middleware, contextual return values, props, document code, and same-name APIs cannot manufacture answer authority.
• Strict storage recognition covers any durable input-delivery schema amendment; older development-only schema handling follows the repository's settled pre-release compatibility policy.
• Deno and the compiled binary supply the local durable adapter; unsupported entrypoints refuse before mutation.

Acceptance: scheduling

• Answer availability may schedule only the ordinary resume path.
• Competing schedulers and manual resume are serialized by the same executor lock.
• Process exit requires no in-memory waiter or hidden Agent transcript.
• Duplicate or late scheduling cannot consume an answer twice or start concurrent execution.
• Cancellation at acquisition, answer claim, and resumed execution preserves the existing durable lifecycle outcome rules.
• Local and future remote hosts can implement the same contextual lifecycle API without changing documents.

Dependencies

Typed delivery

• Add workflow inspection, cancellation, suspension, and deletion #367 supplies the retained suspension request, executor ownership, cancellation, and explicit resume path.
• Store WorkflowRuns and filtered journals in SQLite #291 supplies retained run lookup and the filtered durable journal.

Scheduling

• The typed-delivery slice above.
• Compose the supervised adversarial implementation workflow #301 supplies the supervised workflow and the concrete continuation points a scheduler consumes.

End goal: #181.

Out of scope

• Automatically resuming as part of answer delivery.
• Untyped generic answers passed to workflow resume.
• File watchers, branch watchers, or unattended iteration arbitration.
• A public remote-host selector.
• Human actor identity or attestation.
• Replacing the executor lock, lifecycle state machine, journal secret policy, or suspension identity.