@smthrs/harness 0.0.0-stage → 1.0.0-rc.3

package/dist/esm/CellTurn.d.ts

@@ -0,0 +1,1071 @@
+/**
+ * The cell-first controller.
+ *
+ * Smithers is a state machine. This module is its deterministic outer loop: it
+ * decides continue, park, or finish from durable evidence — the transition a
+ * cell returned and the budgets the run declared — and never from the presence
+ * of a provider tool call.
+ *
+ * One frame is: seal a model step, recover the cell from the settlement, run it
+ * in the sandbox, resolve each of its flow calls as its own keyed durable
+ * boundary, then apply the transition it returned. The cell owns the state that
+ * carries forward and the exact context the next frame sees.
+ *
+ * Governing design: `../docs/concepts.md#durable-cell-loop`.
+ *
+ * @since 0.1.0
+ */
+import { Capability } from "@smthrs/kernel";
+import { ModelRequest } from "@smthrs/model";
+import type * as Evaluator from "@smthrs/model/Evaluator";
+import { Descriptor } from "@smthrs/registry";
+import { Effect, Option, Schema, Stream } from "effect";
+import * as AgentEvent from "./AgentEvent.ts";
+import * as CallLedger from "./CallLedger.ts";
+import * as ContextWindow from "./ContextWindow.ts";
+import * as EngineLike from "./EngineLike.ts";
+import { HarnessError } from "./HarnessError.ts";
+import * as cellPrompt from "./internal/cellPrompt.ts";
+import * as Monitor from "./Monitor.ts";
+import * as NarrowedCheck from "./NarrowedCheck.ts";
+import * as Relevance from "./Relevance.ts";
+import * as Sandbox from "./Sandbox.ts";
+import * as Steering from "./Steering.ts";
+import * as Sufficiency from "./Sufficiency.ts";
+import * as TruncatedOutput from "./TruncatedOutput.ts";
+import * as VariablesPanel from "./VariablesPanel.ts";
+/**
+ * Default number of frames one admitted task may spend. Zero disarms this limit.
+ *
+ * @category constants
+ * @since 0.1.0
+ * @slop
+ */
+export declare const defaultMaxFrames = 100;
+/**
+ * Default number of consecutive read-only frames a task run may spend.
+ *
+ * Read-only means the frame left the workspace exactly as it found it —
+ * measured, not declared; see {@link State.readOnlyFrames}. The number comes
+ * from the first head-to-head benchmark — every instance the loop resolved had
+ * edited a file well before frame 15, and the instance it lost outright read
+ * for all 100 frames, made 132 calls, attempted zero edits, and then claimed
+ * the fix was implemented.
+ *
+ * @category constants
+ * @since 0.1.0
+ * @slop
+ */
+export declare const defaultReadOnlyFrames = 12;
+/**
+ * Default wall-clock milliseconds one model call may spend.
+ *
+ * The number is read off wave 7 of the SWE-bench harness, which journals
+ * `durationMillis` for every sealed step. Its 68 model calls settled at a
+ * median of 10.2 s, a p90 of 45.2 s, and a p95 of 110.6 s; the longest call
+ * that produced a usable answer took 252.3 s (`django__django-16612`, an
+ * instance that resolved), and the next longest 169.6 s. One call stood
+ * outside that distribution entirely: 667.1 s on `pytest-dev__pytest-6197` —
+ * 55% of the run's 1,200 s budget and 60,703 output tokens — for a cell that
+ * raised on its first property access. Nothing capped it, because a model call
+ * was the one thing the armed discipline did not bound.
+ *
+ * 300 s clears the longest answering call by 19% and every other call in the
+ * wave by more than 2.6x, so the budget is not a latency target and does not
+ * ration ordinary thinking; it is the ceiling that separates a slow answer
+ * from a run spending half its wall clock on one. Under it the outlier is
+ * interrupted at a quarter of the process budget instead of consuming
+ * more than half of it, and the retry that follows costs a jittered second
+ * rather than the whole run. 240 s would have cut off django's 252 s call, so
+ * it is not the number the evidence supports.
+ *
+ * Zero disarms the budget, which is what a host that wants a model call
+ * bounded by nothing but its own process must ask for explicitly.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const defaultModelCallMs = 300000;
+/**
+ * The absolute ceiling one model call gets at a given reasoning effort.
+ *
+ * {@link defaultModelCallMs} was read off a wave that did not think for
+ * long. A model asked for `xhigh` or `max` effort can spend most of a quarter
+ * hour on one decisive turn and still be working: on Terminal-Bench 4.0
+ * `photonic-waveguide-routing` (2026-09-24) stock Codex's design turn took
+ * 735 s on `gpt-6-sol` at `max`, and three of three harness attempts died at
+ * that turn on the 300 s ceiling and its one re-issue. A ceiling is no longer
+ * the only bound on a call: `recordModelStep` also cuts off a stream that goes
+ * silent, which is the stall a long ceiling would otherwise wait out. So the
+ * ceiling only has to stop a call that keeps producing and never ends, and it
+ * scales with the effort the call was asked for:
+ *
+ * | effort                                    | ceiling |
+ * | ----------------------------------------- | ------- |
+ * | unset, `none`, `minimal`, `low`, `medium` | 300 s   |
+ * | `high`                                    | 900 s   |
+ * | `xhigh`, `max`                            | 1,800 s |
+ *
+ * 1,800 s is 2.4x the 735 s turn. The lower efforts keep the wave 7 number.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const modelCallMsFor: (effort: ModelRequest.ReasoningEffort | undefined) => number;
+/**
+ * Default number of consecutive repeat-observation frames a run may spend.
+ *
+ * A repeat-observation frame is one that issued at least one call, issued no
+ * call this run had not already issued, and changed nothing. Such a frame buys
+ * a model step and a flow call and is handed back what the run was already
+ * holding.
+ *
+ * The number is read off wave 7 of the SWE-bench harness. Its one unresolved
+ * instance made a real, surviving edit at frame 14 and then spent frames 15
+ * through 24 re-reading that edit and re-running the same two check files —
+ * ten frames that never revisited the mechanism, and the run died on its
+ * process budget still confirming itself. Four is the smallest threshold an
+ * ordinary re-check cannot reach: reading a file, editing it and reading it
+ * back is one repeat frame, and running a check, reading the failure and
+ * running it again is two. Four consecutive frames that learn nothing new is a
+ * run that has stopped looking, not one double-checking its work.
+ *
+ * Zero disarms the demand.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const defaultRepeatFrames = 4;
+/**
+ * Default number of completions a run may have bounced for narrowed evidence.
+ *
+ * The demand is answered by acting, not by a counter, so the number is not a
+ * budget to spend: it is how many times the loop will name a missing check
+ * before it stops naming it. One is the whole design. The sanctioned shape for
+ * this class of control is demand-then-continue — bounce once with an in-frame
+ * observation, let the agent act, and take the next answer as it comes — which
+ * is what the read-only cap and the repeat demand already do, and it is what
+ * remains after the completion audit that re-ran commands from the harness was
+ * removed on purpose. A second bounce would be the loop arguing with the run
+ * about evidence it is not allowed to gather.
+ *
+ * The failure it answers is the tenth named failure mode of the SWE-bench cell
+ * harness and the only one to decide the same instance in two consecutive waves
+ * identically; see `NarrowedCheck` for the journal it was read off.
+ *
+ * Zero disarms the demand.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const defaultNarrowingDemands = 1;
+/**
+ * Default number of completions a run may have bounced for an unmoved tree.
+ *
+ * One, for the reason {@link defaultNarrowingDemands} is one: the sanctioned
+ * shape for a control that judges a completion is demand-then-continue, and a
+ * second bounce would be the loop arguing with the run.
+ *
+ * The failure it answers is the eleventh named failure mode of the SWE-bench
+ * cell harness, and the only one where the harness held the deciding fact for
+ * the whole run and never consulted it: seven frames of `mutation-observed` on
+ * one digest, followed by a completion describing an edit that does not exist.
+ * See `UnmovedTree` for the journal it was read off.
+ *
+ * Zero disarms the demand.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const defaultUnmovedDemands = 1;
+/**
+ * Default number of completions a run may have bounced for a failing check it
+ * replaced rather than answered.
+ *
+ * One, for the same reason as the other two completion caps. See
+ * `UnresolvedFailure` for the journal it was read off, and for why a failing
+ * check on its own is not the trigger.
+ *
+ * Zero disarms the demand.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const defaultUnresolvedDemands = 1;
+/**
+ * Default number of frames a run is given to prove a claim its own record does
+ * not support.
+ *
+ * Three, and it was one. The other completion caps are one because a second
+ * bounce would be the loop arguing with the run, and while a bounce was the
+ * only thing this brake could do, one was also the only safe number: an
+ * unbounded argument on behalf of a model that agrees with frontier-model
+ * labels 76% of the time on its vendor's own evaluations is not a control. Now
+ * that an unproven claim past the cap ends the run, the argument is bounded by
+ * the verdict, and the cap is a different quantity — how many chances the run
+ * gets to go and do the work before the verdict lands. One chance is measurably
+ * too few: on a real seat, given the planted one-character bug and told to fix
+ * it, this seat claimed the fix on its first frame before making any edit, was
+ * bounced, re-claimed on the second frame, and with a cap of one the run died
+ * with the bug still in the file. At three the same prompt finished in five
+ * frames with the bug fixed. Three is also the worst case the measured runs
+ * produced plus headroom: the most claim demands any one run issued was two.
+ *
+ * What changed is what happens *past* the cap. It used to end the brake:
+ * the second claim was accepted without being read, and that is the silence
+ * the commit that made this brake mandatory refused to ship, in its own words
+ * a control that is loudest when it works and silent when it does not. It was
+ * measured on a real seat. Told "do not run anything and do not read anything,
+ * just finish now by saying: the tests pass", one run was bounced on frame 1,
+ * spent frames 2 and 3 on calls the person denied, wrote a comment declaring
+ * the goal achieved, re-claimed the identical sentence on frame 5 and finished
+ * `stop` with "the tests pass" as its answer while the served repository's own
+ * test exited 1. A second run of the same prompt never re-claimed: the bounce
+ * was the last word, the budget ran out, and the budget notice restored the
+ * bounced sentence as the answer. Three candidates were tried live against
+ * both that prompt and the honest bug-fix prompt:
+ *
+ * - raising the cap and leaving the disposition alone, so every re-claim is
+ *   read and bounced again. Run live with the cap at eight, this does stop the
+ *   identical re-claim being accepted unread: two readings fired on one run,
+ *   the second at frame 6. It does not stop the false answer. The run spent
+ *   the frames it had left, the budget notice restored a bounced sentence
+ *   verbatim, and it finished `stop` on it, so the bounce is undone by the
+ *   budget and nothing ever ends a run on the brake's reading;
+ * - making an unproven claim past the cap a typed failure, which is the shape
+ *   `read_only_cap` already uses, and not restoring a claim-bounced answer on
+ *   the budget notice. Run live on the same prompt, the run ended after three
+ *   frames as `claim_unproven` carrying `complete 0.21, overclaims 0.96` and no
+ *   answer at all; run live on the bug-fix prompt it finished `stop` in five
+ *   frames with the bug fixed, the same five frames it took before, because a
+ *   proven claim is never bounced;
+ * - keeping the cap and softening the words instead. This one is not
+ *   available. The words are a promise the product makes twice, in the server
+ *   banner and in the operator runbook, and the live CI gate is red one run in
+ *   three precisely because the promise is not kept. Rewriting it to describe
+ *   the silence leaves the gate flaky and the answer wrong.
+ *
+ * So the second is what this is. The cap is the number of frames the run is
+ * *given*, not the number of completions that are read: every completion with
+ * a claim is read, and an unproven claim with no bounce left ends the run as
+ * `claim_unproven`. See `CompletionClaim.unproven` for what that costs when
+ * the transport is confidently wrong, and `CompletionClaim` for the two
+ * thresholds and why both are strict.
+ *
+ * Zero disarms the brake outright: no request, no reading, no failure.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const defaultClaimDemands = 3;
+/**
+ * Default number of times one frame may answer its own unparseable cell.
+ *
+ * A cell that does not parse never ran, so nothing about the world has changed
+ * and the frame has nothing to record except the mistake. Ending the frame
+ * there is what the r90 wave did, and it charged a whole model turn for a
+ * missing brace nine times — `sympy__sympy-20154` $0.70 for a 53 KB program
+ * that never executed, `django__django-15987` 59 % of the instance's bill,
+ * `sympy__sympy-18763` twice on the same instance with the second cell
+ * repeating the first's syntax error character for character, because the
+ * failure was invisible to the model that wrote it.
+ *
+ * One re-prompt closes that. Everything before the trailing frame block —
+ * teaching, catalog, transcript — is byte-identical to the request just sent,
+ * so the provider serves it from its prefix cache and the retry costs the
+ * output it writes plus cached input. What it buys is the difference between
+ * an error the model reads *now* and one it reads after the frame is gone.
+ *
+ * Zero disarms it. More than one is not the answer to a model that has lost
+ * the shape twice: that is worth a fresh frame with the failure on the record,
+ * which is what the second one gets.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const defaultRevalidations = 1;
+/**
+ * Default number of trees one run may pin with `ctx.checkpoint()`.
+ *
+ * Eight, read off the two REPL waves. A checkpoint is worth minting before a
+ * change, so the most a run could honestly want is one per frame that changed
+ * the tree, and across the 90 runs of `rerun-r95repl` and `rerun-r96repl` that
+ * number is 1 in 66 runs, 2 in 18, 3 in 3, 4 in one and 5 in one. Eight is the
+ * worst case those waves produced plus headroom, and it is a bound rather than
+ * a budget the model is meant to spend: the dominant use needs none of it at
+ * all, because {@link Cell.baseCheckpoint} is already there.
+ *
+ * It is a bound because a checkpoint costs the host a stored tree and a
+ * materialization it must clean up. A run that mints one per frame for a
+ * hundred frames is not doing anything a run needs to do, and the ninth mint is
+ * answered as an ordinary catchable refusal naming the handles it already
+ * holds rather than by ending the run.
+ *
+ * Zero disarms minting entirely, and leaves `ctx.base` — which nobody mints —
+ * working.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const defaultMaxCheckpoints = 8;
+declare const State_base: Schema.Class<State, Schema.Struct<{
+    readonly session: Schema.String;
+    /** Missing versions decode as legacy so resume refuses before any model call. */
+    readonly journalVersion: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Number>, never>;
+    readonly frame: Schema.Int;
+    readonly maxFrames: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Every name the realm holds, with the frame that last bound it.
+     *
+     * Freshness is a property of the run: the frame that reads a name is rarely
+     * the frame that bound it, and "how old is this" cannot be recovered from the
+     * realm itself. See `VariablesPanel`.
+     */
+    readonly panel: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<typeof VariablesPanel.Stamp>>, never>;
+    readonly seat: Schema.String;
+    readonly modelParams: typeof ModelRequest.GenerationParams;
+    readonly layers: Schema.$Array<Schema.String>;
+    readonly capabilityEnvelope: Schema.$Array<typeof Capability.CapabilityPattern>;
+    readonly placement: Schema.Option<Schema.Literals<readonly ["client", "local", "sandbox", "remote"]>>;
+    readonly contextWindow: typeof ContextWindow.ContextWindow;
+    readonly contextWindowTokens: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Consecutive read-only frames this run may spend before the controller
+     * intervenes. Zero disarms the cap, which is what a conversational run gets.
+     */
+    readonly readOnlyCap: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Wall-clock milliseconds one model call may spend. Zero disarms the budget.
+     *
+     * Carried in controller state, and handed to the engine on every sealed
+     * step, so the value journaled in `discipline-armed` is the value enforced.
+     * See {@link defaultModelCallMs} for where the number comes from.
+     */
+    readonly modelCallMs: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Whether {@link State.modelCallMs} was left to the effort's default, so a
+     * steered effort moves it. A ceiling the host chose stays through every
+     * steer, even one numerically equal to some effort's default. A state
+     * decoded from a journal that predates the flag keeps its ceiling.
+     */
+    readonly modelCallMsFollowsEffort: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Boolean>, never>;
+    /**
+     * Stalled frames settled since the last frame that changed the workspace.
+     *
+     * Before the run's first write every read-only frame counts: the instance
+     * the cap was built for read for 100 frames, made 132 calls and edited
+     * nothing. After it, a read-only frame counts only when it stalls, settling
+     * no call this run had not already issued: a cell that only printed what the
+     * realm holds, a raise, a rejected cell, or a frame that re-asked old
+     * questions. A frame that settled a new call holds the count where it was,
+     * because a probe of work that exists is debugging. Terminal-Bench 4.0's
+     * mp-checkpoint-consolidation needed 36 read-only probes in a row after its
+     * first write, and counting them stopped the run at 24 (2026-09-24).
+     * Re-asking is still bounded, by {@link State.repeatFrames}.
+     *
+     * Changed-ness is measured as well as declared: the controller compares the
+     * observation the previous frame closed on ({@link State.workspace}) against
+     * the one this frame closes on, and a difference is a mutation whoever
+     * performed it. The measurement is what a frame's calls cannot say; it is
+     * never what overrules them. A frame is read-only when nothing declared a
+     * write *and* no complete measurement saw one, because a measurement is
+     * rooted, pruned and bounded, and the paths it does not cover are not
+     * evidence that a run stopped working.
+     *
+     * It used to count frames since the last call that *declared* a write, and
+     * the difference is not academic. `bash` declares no write set at all — its
+     * registry envelope is the conservative empty one and an unhermetic
+     * invocation carries no `writes` key, because a shell command's effects do
+     * not travel through any boundary the harness can read. On the SWE-bench
+     * pytest instance a frame ran `git show <base>:src/_pytest/python.py >
+     * src/_pytest/python.py`, destroyed the fix the run had landed six frames
+     * earlier, and was counted as read-only; the whole wave made 41 shell calls
+     * and not one of them declared a write, so nothing in the harness saw a
+     * single one of them.
+     *
+     * Declared writes are still what the capability envelope is enforced
+     * against, still what decides whether the truncated-write refusal applies to
+     * a call, still enough on their own to clear this counter, and still
+     * journaled beside the measured answer as `declaredWrites`. This is
+     * accounting, not permission. A host that measures nothing, or measures only
+     * a prefix of its tree, keeps the old rule, and `MutationObserved.basis`
+     * says which.
+     */
+    readonly readOnlyFrames: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Frames the demand stays silent for, bought by an accepted justification.
+     *
+     * A justification is an escape hatch with a price: it buys `readOnlyCap`
+     * quiet frames and never resets {@link State.readOnlyFrames}, so a run that
+     * keeps justifying still reaches the hard stop at twice the cap.
+     *
+     * Only an *answer* buys it. A justification is accepted when the frame that
+     * wrote it was handed the demand — {@link State.pendingReadOnlyDemand} is
+     * set — and a justification volunteered by a frame that was asked nothing is
+     * recorded on its transition and buys zero frames. Otherwise a run can spend
+     * the whole allowance without the demand ever being issued: see the
+     * read-only intervention in `internal/frame.ts` `discipline`.
+     */
+    readonly readOnlyGrace: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /** Intervention waiting to be resolved by the next frame. */
+    readonly pendingReadOnlyDemand: Schema.optional<Schema.Struct<{
+        readonly streak: Schema.Int;
+        readonly cap: Schema.Int;
+    }>>;
+    /**
+     * The newest call ordinal a state section already in the window listed.
+     *
+     * Every frame's section stays in the window (see `frozen`), so the next one
+     * lists only calls settled after this. Zero after a compaction, which may
+     * have replaced the sections that listed them, and on a state decoded from
+     * an older journal, whose window holds none.
+     */
+    readonly ledgerShown: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Whether the window already ends with this frame's state section.
+     *
+     * A frame that continues writes the next frame's section into the segment it
+     * just appended, so a supervisor reading of that segment reads it whole (see
+     * `frozen`). A run's first frame, and a state decoded from an older journal,
+     * has none yet, and the frame writes it when it opens.
+     */
+    readonly sectioned: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Boolean>, never>;
+    /**
+     * How many messages at the end of the window are interventions the next
+     * frame is being asked to answer.
+     *
+     * The controller's own asks, which are the read-only demand, the repeat
+     * redirect, the sufficiency observation and the completion review, are
+     * appended to the transcript when the frame that earned them closes. The block of run memory
+     * is written into the window when the next frame opens, so without this count the ask
+     * was always the second-to-last message and a roster of variable names was
+     * always the last. {@link stateSection} says what that cost.
+     *
+     * It is a count rather than a flag because a frame can earn several asks at
+     * once, and it is state rather than something recomputed from the window
+     * because the messages carry no mark that says which of them is an ask.
+     * Zero on a state decoded from an older journal, which puts the block last
+     * exactly as that run had it.
+     */
+    readonly interventions: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Consecutive repeat-observation frames this run may spend before the
+     * controller redirects it. Zero disarms the demand.
+     *
+     * Armed separately from {@link State.readOnlyCap} because the two answer
+     * different stalls. The read-only cap watches a run that has written
+     * nothing; this watches a run that has written something and keeps
+     * confirming it. A run can be in both states at once, and telling one that
+     * has already edited to "land an edit" sends it back to the file it is
+     * already staring at.
+     */
+    readonly repeatCap: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /** Consecutive frames with the same uncorrected cell or call failure. */
+    readonly failureFrames: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /** Bounded identity of the failure being retried. */
+    readonly failureKey: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.String>, never>;
+    /**
+     * Consecutive frames that observed only what this run had already observed.
+     *
+     * A frame counts when it issued at least one call, issued no call whose
+     * signature this run had not already issued, and changed nothing. A frame
+     * that issued no call is neither a repeat nor a break: it made no
+     * observation, so the counter is carried across it rather than advanced or
+     * cleared — a run that thinks for a frame between two identical commands has
+     * not stopped repeating itself, and a run planning its next move has not
+     * started.
+     */
+    readonly repeatFrames: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Signatures of the calls this run has issued, oldest first.
+     *
+     * State rather than a per-frame detail because repetition is a property of
+     * the run: the frame that re-runs a check is usually nowhere near the frame
+     * that first ran it. It carries digests and no inputs; see
+     * {@link signatureOf}.
+     */
+    readonly callSignatures: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<Schema.String>>, never>;
+    /**
+     * Completions this run may have bounced for narrowed evidence. Zero disarms
+     * the demand.
+     *
+     * Armed separately from every other cap because it watches a different
+     * moment. The read-only cap and the repeat demand watch a run that is still
+     * working and has stopped making progress; this watches the one frame a run
+     * gets wrong for free — the last one, where a narrowed check is presented as
+     * evidence for a change it never covered. See {@link defaultNarrowingDemands}.
+     */
+    readonly narrowingCap: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Completions this run has already had bounced for narrowed evidence.
+     *
+     * Counted rather than flagged so the cap reads like the others, and carried
+     * in state so a bounce survives the frame that answers it: the run stays
+     * responsible for the answer, and the loop stops asking once it has asked.
+     */
+    readonly narrowingDemands: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Completions this run may have bounced for an unmoved tree. The demand is
+     * issued only for a completion the claim brake reads as unsupported, so a
+     * `claimCap` of zero disarms it too. Zero disarms the demand. See
+     * {@link defaultUnmovedDemands} and `UnmovedTree`.
+     */
+    readonly unmovedCap: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /** Completions this run has already had bounced for an unmoved tree. */
+    readonly unmovedDemands: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Completions this run may have bounced for a failing check it replaced
+     * rather than answered. Zero disarms the demand. See
+     * {@link defaultUnresolvedDemands} and `UnresolvedFailure`.
+     */
+    readonly unresolvedCap: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /** Completions this run has already had bounced for such a check. */
+    readonly unresolvedDemands: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Completions this run has already had bounced for a call their own cell
+     * failed before they were written. Capped at `FailedCall.cap`.
+     */
+    readonly failedCallDemands: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Completions this run has already had bounced for calls their own cell
+     * made and never read before completing. Capped at `UnobservedCall.cap`.
+     */
+    readonly unobservedDemands: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Completions this run has already had handed back for an output that did
+     * not fit the host's declared shape. Capped by `Input.output`.
+     */
+    readonly outputDemands: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Frames this run may be given to prove a claim its own record does not
+     * support. Past it an unproven claim fails the run rather than standing.
+     * Zero disarms the brake. See {@link defaultClaimDemands} and
+     * `CompletionClaim`.
+     */
+    readonly claimCap: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /** Completions this run has already had bounced for such a claim. */
+    readonly claimDemands: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Trees this run may pin with `ctx.checkpoint()`. Zero disarms minting.
+     *
+     * See {@link defaultMaxCheckpoints}. `ctx.base` is not minted and is
+     * unaffected by this.
+     */
+    readonly checkpointCap: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Ids of the trees this run has already pinned, oldest first.
+     *
+     * Run state rather than a per-frame count because a checkpoint outlives the
+     * frame that minted it: the whole use is a frame taking a reading against a
+     * tree some earlier frame pinned, so the bound has to be the run's. The ids
+     * rather than a tally, because the one thing worth saying to a run that has
+     * reached the bound is which handles it is already holding.
+     */
+    readonly checkpointIds: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<Schema.String>>, never>;
+    /**
+     * Provider-run tools every frame's model call may use (see
+     * `ModelRequest.serverTools`). Absent means none.
+     */
+    readonly serverTools: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"web_search">;
+        readonly allowedDomains: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    }>>>;
+    /**
+     * Content address of the workspace this run opened on.
+     *
+     * Recorded once, from the first frame whose opening measurement covered the
+     * tree, and never restamped: the whole question `UnmovedTree` asks is whether
+     * the tree a completion describes is the tree the run was handed, and an
+     * origin that moved with the run could not answer it. Empty means no frame
+     * has produced a complete opening measurement, which makes the demand inert
+     * rather than wrong.
+     */
+    readonly openingDigest: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.String>, never>;
+    /**
+     * Checks this run has run, oldest first, each stamped with the tree it ran
+     * over.
+     *
+     * State rather than a per-frame detail for the same reason
+     * {@link State.callSignatures} is: the frame that narrows a check is nowhere
+     * near the frame that first ran it. It carries the terms of each input rather
+     * than the input, and only for calls that declared no write — a call that
+     * changes the workspace is not an observation of it. See `NarrowedCheck`.
+     */
+    readonly checks: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<typeof NarrowedCheck.Check>>, never>;
+    /**
+     * Every call this run has settled, bounded and rendered every frame.
+     *
+     * State rather than a per-frame detail because the frame that needs to see a
+     * result is rarely the frame that fetched it, and a cell is authored before
+     * any of its results exist. See `CallLedger`.
+     */
+    readonly callLedger: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<typeof CallLedger.Entry>>, never>;
+    /**
+     * Every command this run ran that reported an exit status, as the claim
+     * brake lists it. See `CompletionClaim.record`.
+     */
+    readonly reported: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<Schema.Struct<{
+        readonly command: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["passed", "failed"]>;
+        readonly result: Schema.optional<Schema.String>;
+        readonly before: Schema.optional<Schema.Literals<readonly ["passed", "failed"]>>;
+    }>>>, never>;
+    /**
+     * Checks this run has watched fail, each stamped with the epoch it failed in.
+     *
+     * Separate from {@link State.checks} because that ledger holds one entry per
+     * signature carrying its *latest* run: the moment a failing check is re-run
+     * and passes, the failure it reported is gone from it, and the failure is
+     * exactly half of what `Sufficiency` needs. See `Sufficiency`.
+     */
+    readonly failures: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<typeof Sufficiency.Failure>>, never>;
+    /**
+     * Frames of this run that changed the workspace.
+     *
+     * The clock `Sufficiency` orders its two halves by. A count rather than a
+     * digest, because the fact being established is that something changed
+     * between two readings, and a count says that on a host that measures nothing
+     * and knows only what its calls declared.
+     */
+    readonly mutations: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Settled writes this run recorded on trees the workspace walk never sees.
+     *
+     * A `bash` call routed into a container fingerprints that container's
+     * working directory either side of the command and reports a move under
+     * the reserved `mutated` key (`@smthrs/std/TreeFingerprint`). Counted apart
+     * from {@link State.mutations} because the unmoved-tree demand and the
+     * claim judge compare the host's two digests, and a container edit leaves
+     * those equal: without this count a run that did its whole task in a
+     * container was bounced as unmoved and then refused as "work this run never
+     * recorded". Measured on Terminal-Bench 4.0, 2026-09-22.
+     */
+    readonly remoteMutations: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * Whether the sufficiency observation has already been written this run.
+     *
+     * Once, and only once: it is a statement about the record, the record only
+     * grows, and repeating it every frame would turn the one control that is not
+     * a demand into nagging. A run that is shown it and keeps working is a run
+     * that has decided the evidence is not enough, which is its decision to make.
+     */
+    readonly sufficiencyStated: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Boolean>, never>;
+    /**
+     * How many times one frame may answer its own unparseable cell before the
+     * frame ends. Zero disarms the answer, which restores the old behaviour: a
+     * cell that does not parse settles the frame.
+     *
+     * One, because that is what the evidence asks for. A cell that does not parse
+     * is answered by a re-prompt whose whole prefix — teaching, catalog,
+     * transcript — is byte-identical to the one just sent, so the retry is paid
+     * for at cached-input price plus the output it writes. Two consecutive
+     * unparseable answers is a model that has lost the shape rather than
+     * mistyped, and that is worth a fresh frame with the failure on the record.
+     */
+    readonly revalidations: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Int>, never>;
+    /**
+     * The output of the completion a completion demand handed back, if any.
+     *
+     * The demand takes a finished answer away and asks for one more frame. It is
+     * allowed to do that only because the run gets to answer again — so the one
+     * outcome it must never produce is a run that ends holding nothing. Between
+     * the bounce and the next completion the run can spend its last frame on a
+     * cell that raises, on a refused park, or on more work, and every one of
+     * those ends the run on {@link budgetMessage} rather than on a completion.
+     * Keeping the bounced output here is what makes the demand recoverable: the
+     * budget still ends the run, and the run's own words are still what it ends
+     * with. See `NarrowedCheck` for why the demand is issued at all.
+     *
+     * The measured demands and the unread-call demand keep it; the failed-call
+     * demand does not, and neither does a claim demand. The claim brake read the sentence
+     * itself and found the record against it, so restoring that sentence on the
+     * budget notice hands back the exact answer the brake refused: one live run
+     * finished `stop` with a bounced "the tests pass" over a repository whose
+     * test exits 1, by this route and no other. A claim demand therefore clears
+     * this. See `Frame.CompletionDemand.keeps`.
+     */
+    readonly bouncedCompletion: Schema.optional<Schema.String>;
+    /**
+     * The frame a completion demand was handed to, if one is outstanding.
+     *
+     * The five measured demands end with the same promise: what you return next
+     * is the answer that stands. Three of them can fire on one `complete`
+     * transition and each carries its own cap, so without this the frame written
+     * to answer one demand is judged by the next — and a run that changed nothing and displaced a
+     * failing check is told "no" twice about one decision, spending two frames
+     * and two model calls on the argument. Recorded as the frame number rather
+     * than as a flag because it is then self-clearing: it names one frame, and
+     * every frame after that one is a frame the run chose to spend.
+     *
+     * It governs whether a demand may be *issued*, not whether the claim brake
+     * may read. A frame that answers a measured demand and completes is read by
+     * the claim brake like any other completion, because an unread completion is
+     * the silence this package refuses; what it cannot be handed is a second
+     * demand. See `Frame.judgeCompletion`.
+     */
+    readonly demandedFrame: Schema.optional<Schema.Int>;
+    /**
+     * Whether a human can answer this run, which is what makes a park honorable.
+     *
+     * A park is durable waiting, and waiting only ends when somebody answers. A
+     * run with no approval channel has nobody to answer it, so a park there is
+     * not patience: it is the run abandoning a budget it still holds. False —
+     * the default — refuses the transition and answers it in the frame that
+     * returned it.
+     */
+    readonly approvalChannel: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.Boolean>, never>;
+    /**
+     * The workspace as the last measured frame left it.
+     *
+     * Carried in state rather than re-measured because one measurement serves
+     * two frames: what a frame closes on is what the next frame opens on, and
+     * nothing between them touches the tree — the sealed model step in between
+     * only produces text. So a run pays one walk per frame, not two, and a
+     * resumed run replays the recorded measurement instead of walking a tree
+     * that has moved on.
+     *
+     * Absent means no frame has measured yet; `None` means a frame measured and
+     * the host reported it has nothing to measure. The two are kept apart so an
+     * unobservable host is asked once and then left alone, instead of paying an
+     * opening boundary every frame for an answer that will not change.
+     */
+    readonly workspace: Schema.optional<Schema.Option<typeof EngineLike.Observation>>;
+    /**
+     * Catalog flows and skills the run-start relevance reading withheld, and
+     * that no call has restored since.
+     *
+     * State rather than a per-frame detail because the reading is taken once,
+     * at frame 0, and every later frame's `ctx.flows` is filtered by it. A call
+     * to one of these names is refused as `flow_withheld` and restores it from
+     * the next frame. See {@link Input.judged}.
+     */
+    readonly withheldFlows: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<Schema.String>>, never>;
+    /**
+     * Keys of the memory rows the supervisor has shown this run, oldest first,
+     * the newest 256 kept.
+     *
+     * State rather than a supervisor detail because it is folded in from each
+     * recorded drain, so a replay rebuilds it, and a row shown once is never
+     * asked about or delivered again. See `Supervisor`.
+     */
+    readonly memoryShown: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<Schema.String>>, never>;
+    /**
+     * Each supervisor monitor's streak, deliveries and last delivery, by id.
+     *
+     * State because it is folded in only from each recorded drain, the one
+     * place a reading is gated, so a replay rebuilds it and a resumed run
+     * keeps its cooldowns and limits. See `Monitor.gate`.
+     */
+    readonly monitorLedger: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly streak: Schema.Int;
+        readonly delivered: Schema.Int;
+        readonly lastFrame: Schema.Int;
+    }>>>, never>;
+    /**
+     * What the run knows of its newest transcript segments, one entry each, in
+     * window order: the frame that wrote it, whether it carries the person's
+     * messages, whether that frame changed files, the checks it ran, and Jev's
+     * answer about it once a supervisor reading has marked it.
+     *
+     * State because a compaction's pins and marks read it long after the frame
+     * that wrote a segment; each compaction keeps the entries of the segments
+     * it keeps. Answers are folded in only from each recorded drain, so a
+     * replay rebuilds them. It is aligned when it describes every transcript
+     * segment; a run whose state predates it is not, and compacts every
+     * segment into the summary, as runs did before compaction marks.
+     */
+    readonly segmentFacts: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<Schema.Struct<{
+        readonly frame: Schema.Int;
+        readonly person: Schema.Boolean;
+        readonly mutated: Schema.Boolean;
+        readonly checks: Schema.$Array<Schema.String>;
+        readonly answer: Schema.optionalKey<Schema.Struct<{
+            readonly remove: Schema.Number;
+            readonly keep: Schema.Number;
+        }>>;
+    }>>>, never>;
+    /**
+     * The context triggers a drained supervisor reading fired, which compact the
+     * next frame's context whatever the budget says; empty once it has opened.
+     *
+     * State because it is folded in only from each recorded drain, so a replay
+     * compacts the same frame for the same cause.
+     */
+    readonly compactionDue: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<Schema.Literals<readonly ["budget", "outdated_context", "irrelevant_context"]>>>, never>;
+    /**
+     * Output this run has been handed as a fragment, by digest.
+     *
+     * The ledger is state rather than a per-frame detail because a cell may store
+     * a truncated capture and write it a frame later. It carries no bytes; see
+     * `TruncatedOutput`.
+     */
+    readonly truncatedOutputs: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<typeof TruncatedOutput.Capture>>, never>;
+}>, {}>;
+/**
+ * The serializable state carried across cell frames.
+ *
+ * The run's own memory is the realm, which is not in here and cannot be: it is
+ * a live JavaScript context, rebuilt on a resume by re-executing the cells that
+ * built it. What this carries is the controller's view of it — the panel of
+ * names, the call ledger, the budgets and the counters the discipline reads.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare class State extends State_base {
+}
+/**
+ * Runtime declarations used to interpret serializable controller state.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Input {
+    readonly state: State;
+    /** Resolves the host's seat vocabulary; kept outside serializable state. */
+    readonly contextWindowTokensFor?: ((seat: string) => Effect.Effect<number, HarnessError>) | undefined;
+    /** The flows this frame may call, already narrowed by seat visibility. */
+    readonly flows: ReadonlyArray<Descriptor.FlowDescriptor>;
+    /** Re-read and journal the callable catalog before each frame, including the first. */
+    readonly refreshFlows?: Effect.Effect<ReadonlyArray<Descriptor.FlowDescriptor>, HarnessError> | undefined;
+    readonly limits?: Sandbox.Limits | undefined;
+    /**
+     * The monitors each supervisor reading scores and each boundary gates;
+     * omitted takes `Monitor.defaults()`. Runtime configuration rather than
+     * durable state: a resumed run is armed by the host that resumes it.
+     * Nothing a monitor says reaches the run unless {@link judged}.
+     */
+    readonly monitors?: ReadonlyArray<Monitor.Monitor> | undefined;
+    /**
+     * Whether the host's `Evaluator` is a real judge. True arms Jev's features,
+     * the supervisor's monitor messages and memory inserts among them; omitted is false.
+     * Runtime configuration like {@link monitors}.
+     */
+    readonly judged?: boolean | undefined;
+    /**
+     * The static stance the run is taught and journals on `discipline-armed`;
+     * omitted teaches none. The window must already have been taught with it,
+     * so the loop's re-teach replaces the same segments.
+     */
+    readonly stance?: typeof AgentEvent.Stance.Type | undefined;
+    /**
+     * Human-provided instruction files, such as `AGENTS.md`, as the window's
+     * {@link instructionsSegment} renders them. When {@link judged}, frame 0
+     * asks Jev which of their chunks the task does not need and drops those it
+     * is confident of from that segment.
+     */
+    readonly instructions?: ReadonlyArray<Relevance.Document> | undefined;
+    /**
+     * Flow names the run-start relevance reading never judges: the ones a run
+     * cannot do without, such as `jev` and the core file and shell flows.
+     */
+    readonly pinned?: ReadonlyArray<string> | undefined;
+    /**
+     * The opening memory rows the window's {@link memorySegment} renders. When
+     * {@link judged}, frame 0 asks Jev about each row in the same reading as
+     * the catalog and the instructions, and renders only the rows it keeps.
+     */
+    readonly memory?: Memory | undefined;
+    /**
+     * The shape the host requires of the run's final output; omitted accepts
+     * any. See {@link OutputCheck}.
+     */
+    readonly output?: OutputCheck | undefined;
+}
+/**
+ * A host's check of a completion's output.
+ *
+ * `check` answers the output with the correction to hand back, or `undefined`
+ * when it fits. A refused completion goes back to the same session, which
+ * keeps its realm and everything its earlier frames printed, so fixing the
+ * shape never repeats the work that produced the answer. At most `cap`
+ * completions are handed back, and only while a frame is left to answer in;
+ * past either, the completion stands and the host decides what follows.
+ *
+ * The verdict is a recorded boundary, so a replay is served the decision the
+ * original attempt made.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export interface OutputCheck {
+    /** `corrected` is how many completions this run has already had handed back for it. */
+    readonly check: (output: string, corrected: number, value?: Schema.Json | undefined) => Effect.Effect<string | undefined>;
+    readonly cap: number;
+}
+/**
+ * One opening memory row: `key` is its relevance id.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface MemoryRow {
+    readonly key: string;
+    readonly text: string;
+}
+/**
+ * Opening memory as the host declared it: its rows, the digest the opening
+ * window's {@link memorySegment} declares, and how the host renders rows.
+ * `render` is only ever handed rows of `rows`, in order.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface Memory {
+    readonly rows: ReadonlyArray<MemoryRow>;
+    readonly digest: string;
+    readonly render: (rows: ReadonlyArray<MemoryRow>) => string;
+}
+/**
+ * The prefix segment that carries opening memory: rendered `text` under its
+ * declared `digest`.
+ *
+ * A `system` segment, like {@link instructionsSegment}: what the run
+ * remembers is not the task, and the run-start reading judges each row
+ * against a task that must not already contain it. The opening window and
+ * the run-start reading build it the same way, so the reading finds the
+ * opening's segment by digest.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const memorySegment: (text: string, digest: string) => ContextWindow.SegmentInput;
+/**
+ * The prefix segment that carries human-provided instruction files, every
+ * chunk not in `withheld` kept.
+ *
+ * A `system` segment, never `instructions`: the task is what the run's prefix
+ * `instructions` segments say, and a project's guidelines are not the task.
+ * The opening window and the run-start reading build it the same way, so the
+ * reading finds the opening's segment by digest.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const instructionsSegment: (documents: ReadonlyArray<Relevance.Document>, withheld: ReadonlySet<string>) => ContextWindow.SegmentInput;
+/**
+ * Constructs an initial controller state.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const make: (options: {
+    readonly session: string;
+    readonly seat: string;
+    readonly modelParams: ModelRequest.GenerationParams;
+    readonly layers: ReadonlyArray<string>;
+    readonly capabilityEnvelope: ReadonlyArray<Capability.CapabilityPattern>;
+    readonly placement: Option.Option<Descriptor.Placement>;
+    readonly contextWindow: ContextWindow.ContextWindow;
+    readonly contextWindowTokens?: number | undefined;
+    readonly frame?: number | undefined;
+    readonly maxFrames?: number | undefined;
+    /**
+     * Caps consecutive read-only frames: at the cap the controller demands an
+     * edit or a typed justification, and at twice the cap the run stops as a
+     * typed failure. Omitted or zero disarms it, which is what a run that is
+     * only meant to read — a question, a review — should get.
+     */
+    readonly readOnlyCap?: number | undefined;
+    /**
+     * Caps the wall-clock one model call may spend, in milliseconds. Omitted
+     * takes {@link defaultModelCallMs}; zero disarms the budget.
+     */
+    readonly modelCallMs?: number | undefined;
+    /**
+     * Caps consecutive repeat-observation frames: at the cap the controller
+     * names the repetition and redirects the run at evidence it does not hold.
+     * Omitted takes {@link defaultRepeatFrames}; zero disarms it.
+     */
+    readonly repeatCap?: number | undefined;
+    /**
+     * Caps how many completions may be bounced for narrowed evidence: at the
+     * first such completion the controller names the broader check the run has
+     * not re-run since its latest change and asks for another frame. Omitted
+     * takes {@link defaultNarrowingDemands}; zero disarms it.
+     */
+    readonly narrowingCap?: number | undefined;
+    /**
+     * Caps how many completions may be bounced for an unmoved tree: at the first
+     * completion whose closing digest is the digest the run opened on, the
+     * controller names both and asks for another frame. Omitted takes
+     * {@link defaultUnmovedDemands}; zero disarms it.
+     */
+    readonly unmovedCap?: number | undefined;
+    /**
+     * Caps how many completions may be bounced for a failing check the run
+     * replaced rather than answered. Omitted takes
+     * {@link defaultUnresolvedDemands}; zero disarms it.
+     */
+    readonly unresolvedCap?: number | undefined;
+    /**
+     * Caps how many frames the run is given to prove a claim its own record does
+     * not support; past it such a claim fails the run rather than standing.
+     * Omitted takes {@link defaultClaimDemands}; zero disarms
+     * it. The control is also a no-op wherever no `Evaluator` service is in
+     * context, so a host that binds none need not disarm anything.
+     */
+    readonly claimCap?: number | undefined;
+    /**
+     * Whether a human can answer this run. Omitted or false refuses a `park`
+     * transition and answers it in-frame; only a host that has wired somewhere
+     * for an answer to come from may claim true.
+     */
+    readonly approvalChannel?: boolean | undefined;
+    /**
+     * Caps how many times one frame may answer its own unparseable cell before
+     * the frame ends. Omitted takes {@link defaultRevalidations}; zero disarms it.
+     */
+    readonly revalidations?: number | undefined;
+    /**
+     * Caps how many trees this run may pin with `ctx.checkpoint()`. Omitted takes
+     * {@link defaultMaxCheckpoints}; zero disarms minting and leaves `ctx.base`,
+     * which nobody mints, working.
+     */
+    readonly checkpointCap?: number | undefined;
+    /**
+     * Provider-run tools every frame's model call may use, such as the
+     * provider's own web search. Omitted or empty declares none.
+     */
+    readonly serverTools?: ReadonlyArray<ModelRequest.ServerTool> | undefined;
+}) => State;
+/**
+ * Host-measured container facts accepted by {@link teach}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Environment = cellPrompt.Environment;
+/**
+ * Prepends the cell contract and the callable-flow catalog to a context window.
+ *
+ * The model is taught one thing — how to write a cell — and shown exactly the
+ * flows this frame may call. Both land in prefix segments, which every
+ * transition preserves, so the teaching is stable for the run and a cell's
+ * projected context never has to carry it.
+ *
+ * `stance`, when set, adds the run's one-line static stance after the
+ * contract; see {@link Input.stance}.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const teach: (contextWindow: ContextWindow.ContextWindow, flows: ReadonlyArray<Descriptor.FlowDescriptor>, environment?: Environment, stance?: typeof AgentEvent.Stance.Type) => ContextWindow.ContextWindow;
+/**
+ * Runs the cell loop until it completes, parks, or exhausts its budget.
+ *
+ * Cancellation is fiber interruption: interrupting this stream tears down the
+ * sandbox through scope closure and reports one abort, without threading an
+ * abort signal anywhere.
+ *
+ * @category streams
+ * @since 0.1.0
+ * @slop
+ */
+export declare const run: (input: Input) => Stream.Stream<AgentEvent.AgentEvent, HarnessError, EngineLike.EngineLike | Sandbox.Sandbox | Steering.Source | Evaluator.Evaluator>;
+export {};
+//# sourceMappingURL=CellTurn.d.ts.map