Expose embeddable run/task state and read-model APIs

[ethan-tyler]

Summary

Embedders currently need to rebuild run and task persistence, callback application, read models, and control endpoints to expose Arco orchestration state.

Severity: high

Downstream evidence

We had to implement our own:

• run and task persistence layer
• callback state application logic
• run list and detail read models
• cancel and retry mutations
• task token lookup and validation
• object store concurrency handling for updates

Requested outcome

• Reusable upstream interfaces for create, load, list, and detail run or task state
• Centralized callback application semantics
• Cancel and retry primitives
• Storage backend abstractions or a documented projection format for object stores
• Documentation for the intended embedding pattern

Why upstream

This is core orchestration state management, not product-specific logic. Each adopter rebuilding it separately increases semantic drift and operational risk.

[ethan-tyler]

Additional downstream evidence from our embedding work:

Implementing claim/sweep/cancel semantics locally introduced two race classes that seem like strong evidence for upstream run/task state primitives rather than per-adopter reimplementation:

1. A claimed-but-not-started task can be terminally cancelled before the worker has actually observed the cancel request. In our local implementation, dispatch claim only records that the task was dispatched, while worker-side cancellation is only observed on heartbeat. That creates a window where orchestration reports cancelled while the worker can still execute side effects.

2. Sweep decisions made from a stale snapshot can retry or fail a task after a completed callback has already won the race. Without centralized upstream mutation semantics, local store mutators can reopen or overwrite a just-succeeded run.

Both of these came from downstream ownership of authoritative run/task state transitions. They reinforce the need for upstream create/load/list/mutate primitives with canonical concurrency and state-transition rules.