Skip to content

117. Steer a running cycle with admitted entity updates ​

Date: 2026-11-02

Status ​

Accepted

Partially supersedes two sentences of ADR 0141, for the steer path only. Every other ADR 0141 rule stays current.

  • "An explicitly configured host-side extension may fetch a kind outside the snapshot": the host-side steer path may also fetch newer revisions of the snapshot's own kinds for the bound entity during a cycle, through the same pipeline and fail-closed rules, exposing no raw payload. Sandbox forge reads stay denied.
  • "requires a versioned schema that lists its path in the manifest": "the manifest" there is the snapshot's index.json. Steer output is listed instead in its own manifest, steer envelope v1, under the same filtering, digest, permissions, exact-path, and cleanup rules.

Reason: a steer carries newer revisions of what the snapshot holds, and the snapshot, whose digest is the cycle's admitted input, cannot change mid-cycle.

This is the first of five steer decisions. The later ones build on it: ADR 0118 (runtime delivery), ADR 0119 (GitHub Actions signal), ADR 0120 (receipts for absorbed steers), and ADR 0121 (on by default).

Context ​

ADR 0106 coalesces later events into one pending follow-up, and ADR 0144 runs it as a new cycle in the same fullsend run process. Neither reaches a running sandbox, so a turn that started on old state posts output that the entity has already moved past, such as a review of a replaced head (#1207), and a person who adds direction mid-run waits for the next cycle. On GitHub Actions, event-only harnesses get no wake listener from ADR 0144, so their follow-up starts only after the current job ends.

Any answer keeps per-record admission with no data-only lane (ADR 0133) and wakes that never consume pending work (ADR 0144).

This ADR aims to let a running sandbox cycle take in admitted entity updates without weakening those rules.

Options ​

OptionWhy not chosen
Rely on ADR 0144 cycles aloneThe stale turn still finishes and may post; nobody can redirect work in flight
Ask the agent to re-check the entity at turn endAdvisory, reads the forge from the sandbox (ADR 0141 denies it), and still pays for the stale turn
Steer the running cycle (chosen)— see Decision

Decision ​

We adopt steering, the delivery of freshly admitted, filtered entity records into a running sandbox cycle, to let the agent's next turn work from the entity's current state.

Steering is an optional fast path inside one ADR 0144 cycle; the next cycle stays the correctness backstop.

Place in the cycle ​

  • A steer is one delivery into the current sandbox, not a cycle.
  • A steer never takes, fills, consumes, or replaces the newest-pending slot or the pending platform execution. The prompting notification still schedules the follow-up cycle, which runs CEL and the pre-script as usual.
  • A steer refused before anything is published, in steps 1 to 4a or by a failing release check, leaves the cycle as if no steer was attempted.
  • Once its files or envelope are published, a steer whose acknowledgement never arrives has an unknown outcome. It keeps its sequence number and its entry in the manifest chain. It is recorded as possibly delivered, is never counted as absorbed, and Fullsend never claims the model did not see it. The cycle takes no further steers, so a later steer never builds on records the agent may not hold. The next cycle is the backstop.
  • A lost runtime session fails the cycle.
  • A steer never changes the cycle's platform-verified result revision. It stays the revision of the cycle's admitted input, as ADR 0144 records it.

When a steer is attempted ​

While a cycle's sandbox runs, a notification for its serialization key (an ADR 0144 event or wake) prompts a steer attempt, unless the running harness's own App identity caused it; updates from other registered agents still prompt an attempt. That filter is routing, not admission.

A cycle runs at most one steer attempt at a time, from step 1 to step 6. The sequence number is assigned and the cap is checked in step 1, inside that serialization, so every candidate is prepared against the latest published manifest. A notification that arrives during an attempt starts a new attempt after the current one ends. Each attempt runs on the host, in order:

StepWhat happensIf it fails
1. EligibilitySteering is enabled for the harness, the entity is a forge entity, the runtime can take a message into the running session, and the cycle is under its steer cap with time left for a full turnNo steer
2. Still selectedRe-resolve the entity, check ADR 0149 source membership for entity-source harnesses, and evaluate harness CEL (see below)False or unknown: no steer
3. AcquireFetch records new or changed since the snapshot and earlier steersFetch error, or nothing new or changed: no steer
4. Filter and admitADR 0141 pipeline, then the admission rule belowDropped records are counted, never delivered. No admitted record and no head move, or a newer revision of a record the agent already holds failing admission or filtering: no steer
4a. Pre-script gateFor a harness with a pre-script, run it on the host under the ADR 0072 protocol with the steer input belowA skip, an error, a timeout, or no steer_checked=true in its output: no steer; the records wait for the follow-up cycle
5. ReleaseUnder the sandbox write lock: run the release check per record, write the steer files, and append the envelope; then, with the lock released, wait for the acknowledgementAny record failing the release check declines the whole steer, so the delivered set is always the set the pre-script gate saw; the records wait for the follow-up cycle
6. RecordAdd a child event to the cycle's span. Steers count toward the ADR 0106 and ADR 0144 circuit breakers and do not change run status—

Steer input for the pre-script. In a steer-gate run the host sets FULLSEND_CONTEXT_DIR to the cycle's snapshot, as usual, and FULLSEND_STEER_DIR to a host-side, read-only, digest-verified copy of every steer directory of this cycle so far plus the candidate steer, in steer order. Later revisions of a record replace earlier ones by record key, so the pre-script sees the cumulative state the agent will hold. A pre-script that reads this input signals it by writing steer_checked=true, a new key in the pre-script output protocol added under its versioning rules. A pre-script that does not write it, including every pre-script written before steering, never lets a steer through, so its harness steers only once its pre-script is updated. A steer-gate run is a check only: Fullsend relays none of its outputs and posts no status for it, and after it exits the host re-verifies the candidate's manifest and file digests against host-private state before release.

Still selected. CEL runs over the current entity with the cycle's retained prompting event (null for an eventless cycle). The event is reused only so an event-only harness, whose CEL needs one, stays eligible; it never grants authorization. The event's entity and state fields are refreshed from the re-resolved entity, so a closed entity or a removed label is seen as it is now. In the same step the event is revalidated fresh through its own admission path, and a failure means no steer:

  • an ordinary human actor must meet the harness's effective human_min_role (ADR 0151), or the Authorization v1 threshold on legacy non-CEL routes;
  • a registered bot must pass the ADR 0107bot_role gate;
  • an exact verified label addition uses Authorization v2's label-transition grant, and passes only while the label is still present: for a human it satisfies only a triage minimum, and a provider-classified bot uses its own transition grant without a bot_role.

A bot or a label grant is never declined only because actor.role is none. This is not a new ADR 0144 check: it runs inside the cycle that consumed the event and can only decline, so ADR 0144's rule that later checks "do not reuse" the event is unchanged.

Admission ​

A steer release is a "Fullsend-controlled capability invoked after sandbox initialization", so each release runs the contract's check on each record's current-revision actor. That check "MUST resolve authorization immediately before releasing each result to the model" (Authorization v1 and v2).

  • Human records must meet the admission threshold of the cycle's snapshot records, so one cycle never admits records at two thresholds. Steer envelope v1 pairs only with entity-context-snapshot v1, whose threshold is triage (observation) or write (mutation). Moving to the harness's human_min_role needs entity-context-snapshot v2 and, with it, steer envelope v2.
  • Bot records need a registered ADR 0107 bot_role.
  • Records that fail, or cannot be attributed or verified, are dropped and counted as omissions.
  • Event-carried evidence, the route job's verdict, earlier CEL results, and the ADR 0148 role cache never satisfy the check.

Content ​

Records take the ADR 0141 host-side path and filter pipeline; the sandbox-visible format is steer envelope v1. A steer is content, never capability: it cannot change tools, role, model, credentials, routing, or network policy.

Dependencies ​

Steering stays off, regardless of configuration, until per-record admission at the snapshot's threshold, the ADR 0141 filter pipeline and host-side extension path, and the ADR 0144 cycle lifecycle are in place. Delivery is correct without any handled-state receipt; each steered cycle is then followed by a full cycle.

Forge scope ​

Steering applies wherever a running cycle receives a verified signal:

  • GitHub: through ADR 0144 events and wakes. On GitHub Actions, event-only harnesses get no ADR 0144 wake listener, so this ADR alone does not steer them.
  • GitLab and Forgejo: through ADR 0144 events and wakes, once ADR 0144 is implemented there; the rules here are forge-neutral.
  • Jira and other non-forge entities: steering is declined, since entity-context-snapshot v1 does not stage them.

Consequences ​

  • Updates during a cycle reach the running agent, so fewer outputs are built from replaced state.
  • A steered sandbox stays up longer, and each release adds a fresh permission lookup per actor.
  • A harness's pre-script gates every steer over the cumulative steer input, so steering adds no path past it; a harness with a pre-script steers only after that pre-script opts in, and pays one extra pre-script run per steer.

Open questions ​

  • A head move needs the new Git objects inside the running sandbox. Which provisioning path supplies them mid-cycle? Until one exists, a steer omits the head and the follow-up cycle handles it.