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

package/dist/cjs/CellTurn.js

@@ -0,0 +1,2618 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CellTurn_exports = {};
+__export(CellTurn_exports, {
+  State: () => State,
+  defaultClaimDemands: () => defaultClaimDemands,
+  defaultMaxCheckpoints: () => defaultMaxCheckpoints,
+  defaultMaxFrames: () => defaultMaxFrames,
+  defaultModelCallMs: () => defaultModelCallMs,
+  defaultNarrowingDemands: () => defaultNarrowingDemands,
+  defaultReadOnlyFrames: () => defaultReadOnlyFrames,
+  defaultRepeatFrames: () => defaultRepeatFrames,
+  defaultRevalidations: () => defaultRevalidations,
+  defaultUnmovedDemands: () => defaultUnmovedDemands,
+  defaultUnresolvedDemands: () => defaultUnresolvedDemands,
+  instructionsSegment: () => instructionsSegment,
+  make: () => make,
+  memorySegment: () => memorySegment,
+  modelCallMsFor: () => modelCallMsFor,
+  run: () => run,
+  teach: () => teach
+});
+module.exports = __toCommonJS(CellTurn_exports);
+var import_core = require("@smthrs/core");
+var Digest = __toESM(require("@smthrs/core/Digest"), 1);
+var Fault = __toESM(require("@smthrs/flow/Fault"), 1);
+var import_kernel = require("@smthrs/kernel");
+var import_model = require("@smthrs/model");
+var Pricing = __toESM(require("@smthrs/model/Pricing"), 1);
+var import_registry = require("@smthrs/registry");
+var import_effect = require("effect");
+var AgentEvent = __toESM(require("./AgentEvent.js"), 1);
+var CallLedger = __toESM(require("./CallLedger.js"), 1);
+var Cell = __toESM(require("./Cell.js"), 1);
+var CellHistory = __toESM(require("./CellHistory.js"), 1);
+var CellValidation = __toESM(require("./CellValidation.js"), 1);
+var Compaction = __toESM(require("./Compaction.js"), 1);
+var CompletionClaim = __toESM(require("./CompletionClaim.js"), 1);
+var ContextWindow = __toESM(require("./ContextWindow.js"), 1);
+var EngineLike = __toESM(require("./EngineLike.js"), 1);
+var FailedCall = __toESM(require("./FailedCall.js"), 1);
+var import_HarnessError = require("./HarnessError.js");
+var cellPrompt = __toESM(require("./internal/cellPrompt.js"), 1);
+var import_compactable = require("./internal/compactable.js");
+var compactionMarks = __toESM(require("./internal/compactionMarks.js"), 1);
+var elide = __toESM(require("./internal/elide.js"), 1);
+var Frame = __toESM(require("./internal/frame.js"), 1);
+var import_nonNegativeSafeInt = require("./internal/nonNegativeSafeInt.js");
+var import_paidUsage = require("./internal/paidUsage.js");
+var import_printsObservation = require("./internal/printsObservation.js");
+var import_refusal = require("./internal/refusal.js");
+var Supervision = __toESM(require("./internal/supervision.js"), 1);
+var import_untrustedData = require("./internal/untrustedData.js");
+var Judgement = __toESM(require("./Judgement.js"), 1);
+var Monitor = __toESM(require("./Monitor.js"), 1);
+var NarrowedCheck = __toESM(require("./NarrowedCheck.js"), 1);
+var Relevance = __toESM(require("./Relevance.js"), 1);
+var Sandbox = __toESM(require("./Sandbox.js"), 1);
+var Steering = __toESM(require("./Steering.js"), 1);
+var Sufficiency = __toESM(require("./Sufficiency.js"), 1);
+var Supervisor = __toESM(require("./Supervisor.js"), 1);
+var import_Transcript = require("./Transcript.js");
+var TruncatedOutput = __toESM(require("./TruncatedOutput.js"), 1);
+var UnresolvedFailure = __toESM(require("./UnresolvedFailure.js"), 1);
+var VariablesPanel = __toESM(require("./VariablesPanel.js"), 1);
+const repeatedFailureTag = "/harness/CellTurn/RepeatedFailure";
+Fault.register(repeatedFailureTag, "factory");
+const defaultMaxFrames = 100;
+const defaultReadOnlyFrames = 12;
+const defaultModelCallMs = 3e5;
+const modelCallMsFor = (effort) => {
+  switch (effort) {
+    case "xhigh":
+    case "max":
+      return 18e5;
+    case "high":
+      return 9e5;
+    default:
+      return defaultModelCallMs;
+  }
+};
+const defaultRepeatFrames = 4;
+const defaultNarrowingDemands = 1;
+const defaultUnmovedDemands = 1;
+const defaultUnresolvedDemands = 1;
+const defaultClaimDemands = 3;
+const defaultRevalidations = 1;
+const defaultMaxCheckpoints = 8;
+const MaxFrames = import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+  import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(defaultMaxFrames)),
+  import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(defaultMaxFrames))
+);
+const ContextWindowTokens = import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+  import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+  import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+);
+const eventType = AgentEvent.eventType;
+class State extends import_effect.Schema.Class("flows/harness/CellTurn/State")({
+  session: import_effect.Schema.String,
+  /** Missing versions decode as legacy so resume refuses before any model call. */
+  journalVersion: import_effect.Schema.Number.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(import_Transcript.journalVersion)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(1))
+  ),
+  frame: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  maxFrames: MaxFrames,
+  /**
+   * 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`.
+   */
+  panel: VariablesPanel.Ledger,
+  seat: import_effect.Schema.String,
+  modelParams: import_model.ModelRequest.GenerationParams,
+  layers: import_effect.Schema.Array(import_effect.Schema.String),
+  capabilityEnvelope: import_effect.Schema.Array(import_kernel.Capability.CapabilityPattern),
+  placement: import_effect.Schema.Option(import_registry.Descriptor.Placement),
+  contextWindow: ContextWindow.ContextWindow,
+  contextWindowTokens: ContextWindowTokens,
+  /**
+   * Consecutive read-only frames this run may spend before the controller
+   * intervenes. Zero disarms the cap, which is what a conversational run gets.
+   */
+  readOnlyCap: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * 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.
+   */
+  modelCallMs: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(defaultModelCallMs)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(defaultModelCallMs))
+  ),
+  /**
+   * 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.
+   */
+  modelCallMsFollowsEffort: import_effect.Schema.Boolean.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(false)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(false))
+  ),
+  /**
+   * 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.
+   */
+  readOnlyFrames: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * 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`.
+   */
+  readOnlyGrace: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /** Intervention waiting to be resolved by the next frame. */
+  pendingReadOnlyDemand: import_effect.Schema.optional(import_effect.Schema.Struct({
+    streak: import_nonNegativeSafeInt.NonNegativeSafeInt,
+    cap: import_nonNegativeSafeInt.NonNegativeSafeInt
+  })),
+  /**
+   * 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.
+   */
+  ledgerShown: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * 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.
+   */
+  sectioned: import_effect.Schema.Boolean.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(false)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(false))
+  ),
+  /**
+   * 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.
+   */
+  interventions: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * 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.
+   */
+  repeatCap: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(defaultRepeatFrames)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(defaultRepeatFrames))
+  ),
+  /** Consecutive frames with the same uncorrected cell or call failure. */
+  failureFrames: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /** Bounded identity of the failure being retried. */
+  failureKey: import_effect.Schema.String.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed("")),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(""))
+  ),
+  /**
+   * 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.
+   */
+  repeatFrames: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * 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}.
+   */
+  callSignatures: import_effect.Schema.Array(import_effect.Schema.String).pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed([])),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed([]))
+  ),
+  /**
+   * 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}.
+   */
+  narrowingCap: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(defaultNarrowingDemands)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(defaultNarrowingDemands))
+  ),
+  /**
+   * 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.
+   */
+  narrowingDemands: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * 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`.
+   */
+  unmovedCap: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(defaultUnmovedDemands)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(defaultUnmovedDemands))
+  ),
+  /** Completions this run has already had bounced for an unmoved tree. */
+  unmovedDemands: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * Completions this run may have bounced for a failing check it replaced
+   * rather than answered. Zero disarms the demand. See
+   * {@link defaultUnresolvedDemands} and `UnresolvedFailure`.
+   */
+  unresolvedCap: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(defaultUnresolvedDemands)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(defaultUnresolvedDemands))
+  ),
+  /** Completions this run has already had bounced for such a check. */
+  unresolvedDemands: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * Completions this run has already had bounced for a call their own cell
+   * failed before they were written. Capped at `FailedCall.cap`.
+   */
+  failedCallDemands: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * Completions this run has already had bounced for calls their own cell
+   * made and never read before completing. Capped at `UnobservedCall.cap`.
+   */
+  unobservedDemands: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * Completions this run has already had handed back for an output that did
+   * not fit the host's declared shape. Capped by `Input.output`.
+   */
+  outputDemands: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * 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`.
+   */
+  claimCap: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(defaultClaimDemands)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(defaultClaimDemands))
+  ),
+  /** Completions this run has already had bounced for such a claim. */
+  claimDemands: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * Trees this run may pin with `ctx.checkpoint()`. Zero disarms minting.
+   *
+   * See {@link defaultMaxCheckpoints}. `ctx.base` is not minted and is
+   * unaffected by this.
+   */
+  checkpointCap: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(defaultMaxCheckpoints)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(defaultMaxCheckpoints))
+  ),
+  /**
+   * 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.
+   */
+  checkpointIds: import_effect.Schema.Array(import_effect.Schema.String).pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed([])),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed([]))
+  ),
+  /**
+   * Provider-run tools every frame's model call may use (see
+   * `ModelRequest.serverTools`). Absent means none.
+   */
+  serverTools: import_effect.Schema.optionalKey(import_effect.Schema.Array(import_model.ModelRequest.ServerTool)),
+  /**
+   * 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.
+   */
+  openingDigest: import_effect.Schema.String.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed("")),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(""))
+  ),
+  /**
+   * 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`.
+   */
+  checks: NarrowedCheck.Ledger,
+  /**
+   * 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`.
+   */
+  callLedger: CallLedger.Ledger,
+  /**
+   * Every command this run ran that reported an exit status, as the claim
+   * brake lists it. See `CompletionClaim.record`.
+   */
+  reported: CompletionClaim.Reported,
+  /**
+   * 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`.
+   */
+  failures: Sufficiency.Ledger,
+  /**
+   * 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.
+   */
+  mutations: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * 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.
+   */
+  remoteMutations: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * 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.
+   */
+  sufficiencyStated: import_effect.Schema.Boolean.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(false)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(false))
+  ),
+  /**
+   * 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.
+   */
+  revalidations: import_nonNegativeSafeInt.NonNegativeSafeInt.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(defaultRevalidations)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(defaultRevalidations))
+  ),
+  /**
+   * 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`.
+   */
+  bouncedCompletion: import_effect.Schema.optional(import_effect.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`.
+   */
+  demandedFrame: import_effect.Schema.optional(import_nonNegativeSafeInt.NonNegativeSafeInt),
+  /**
+   * 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.
+   */
+  approvalChannel: import_effect.Schema.Boolean.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(false)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(false))
+  ),
+  /**
+   * 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.
+   */
+  workspace: import_effect.Schema.optional(import_effect.Schema.Option(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}.
+   */
+  withheldFlows: import_effect.Schema.Array(import_effect.Schema.String).pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed([])),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed([]))
+  ),
+  /**
+   * 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`.
+   */
+  memoryShown: import_effect.Schema.Array(import_effect.Schema.String).pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed([])),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed([]))
+  ),
+  /**
+   * 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`.
+   */
+  monitorLedger: Monitor.Ledger.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed({})),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed({}))
+  ),
+  /**
+   * 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.
+   */
+  segmentFacts: import_effect.Schema.Array(compactionMarks.Facts).pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed([])),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed([]))
+  ),
+  /**
+   * 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.
+   */
+  compactionDue: import_effect.Schema.Array(AgentEvent.CompactionCause).pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed([])),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed([]))
+  ),
+  /**
+   * 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`.
+   */
+  truncatedOutputs: TruncatedOutput.Ledger
+}) {
+}
+const advance = (state, changes) => new State({ ...state, ...changes });
+const memorySegment = (text, digest) => ({
+  kind: "system",
+  zone: "prefix",
+  declaredDigest: digest,
+  content: [import_model.ModelRequest.SystemPart.make({ text })]
+});
+const instructionsSegment = (documents, withheld2) => ({
+  kind: "system",
+  zone: "prefix",
+  content: [import_model.ModelRequest.SystemPart.make({ text: Relevance.render(documents, withheld2) })]
+});
+const make = (options) => new State({
+  session: options.session,
+  frame: options.frame ?? 0,
+  maxFrames: options.maxFrames ?? defaultMaxFrames,
+  panel: [],
+  seat: options.seat,
+  modelParams: options.modelParams,
+  layers: options.layers,
+  capabilityEnvelope: options.capabilityEnvelope,
+  placement: options.placement,
+  contextWindow: options.contextWindow,
+  // The opening transcript is the host's, written before any frame: no
+  // person's message, no change and no check.
+  segmentFacts: options.contextWindow.segments.flatMap(
+    (segment) => segment.kind === "transcript" ? [{ frame: options.frame ?? 0, person: false, mutated: false, checks: [] }] : []
+  ),
+  contextWindowTokens: options.contextWindowTokens ?? 0,
+  readOnlyCap: options.readOnlyCap ?? 0,
+  modelCallMs: options.modelCallMs ?? modelCallMsFor(options.modelParams.reasoningEffort),
+  modelCallMsFollowsEffort: options.modelCallMs === void 0,
+  readOnlyFrames: 0,
+  readOnlyGrace: 0,
+  pendingReadOnlyDemand: void 0,
+  interventions: 0,
+  repeatCap: options.repeatCap ?? defaultRepeatFrames,
+  repeatFrames: 0,
+  failureFrames: 0,
+  failureKey: "",
+  callSignatures: [],
+  narrowingCap: options.narrowingCap ?? defaultNarrowingDemands,
+  narrowingDemands: 0,
+  unmovedCap: options.unmovedCap ?? defaultUnmovedDemands,
+  unmovedDemands: 0,
+  unresolvedCap: options.unresolvedCap ?? defaultUnresolvedDemands,
+  unresolvedDemands: 0,
+  failedCallDemands: 0,
+  unobservedDemands: 0,
+  outputDemands: 0,
+  claimCap: options.claimCap ?? defaultClaimDemands,
+  claimDemands: 0,
+  openingDigest: "",
+  checks: [],
+  callLedger: [],
+  reported: [],
+  failures: [],
+  mutations: 0,
+  remoteMutations: 0,
+  sufficiencyStated: false,
+  revalidations: options.revalidations ?? defaultRevalidations,
+  approvalChannel: options.approvalChannel ?? false,
+  workspace: void 0,
+  truncatedOutputs: [],
+  checkpointCap: options.checkpointCap ?? defaultMaxCheckpoints,
+  checkpointIds: [],
+  ...options.serverTools === void 0 || options.serverTools.length === 0 ? {} : {
+    serverTools: [
+      ...new Map(options.serverTools.map((tool) => [import_model.CanonicalJson.stringify(tool), tool])).values()
+    ]
+  }
+});
+const teach = (contextWindow, flows, environment, stance) => {
+  const projections = {};
+  for (const descriptor of flows) {
+    projections[descriptor.name] = {
+      ...Cell.project(descriptor),
+      provenance: descriptor.provenance,
+      path: descriptor.path
+    };
+  }
+  const taught = cellPrompt.make(projections, environment, stance).map(
+    (section) => ContextWindow.makeSegment({
+      kind: "system",
+      zone: "prefix",
+      declaredDigest: section.digest,
+      content: [import_model.ModelRequest.SystemPart.make({ text: section.text })]
+    })
+  );
+  return ContextWindow.make({
+    modelId: contextWindow.modelId,
+    segments: [...taught, ...contextWindow.segments],
+    activeTools: contextWindow.activeTools,
+    replaced: contextWindow.replaced
+  });
+};
+const modelIdFromSeat = (seat) => {
+  const separator = seat.indexOf(":");
+  return separator < 0 ? seat : seat.slice(separator + 1);
+};
+const placementFrom = (state) => import_effect.Option.match(state.placement, {
+  onNone: () => void 0,
+  onSome: (value) => {
+    switch (value) {
+      case "client":
+        return import_core.Placement.client();
+      case "local":
+        return import_core.Placement.local();
+      case "remote":
+        return import_core.Placement.remote();
+      case "sandbox":
+        return import_core.Placement.sandbox();
+    }
+  }
+});
+const keyMaterialFrom = (state, contextWindow, request) => ({
+  version: "flows/key-material/v2",
+  kind: "sealed",
+  body: { _tag: "ModelCall", request },
+  inputs: [{ _tag: "Literal", value: { contextDigest: contextWindow.digest, journalVersion: import_Transcript.journalVersion } }],
+  layers: [...new Set(state.layers)].sort(),
+  capabilities: [...new Set(state.capabilityEnvelope.map(import_kernel.Capability.format))].sort(),
+  effects: import_core.Effects.make({
+    reads: [],
+    writes: [],
+    mode: "hermetic",
+    onConflict: "serialize",
+    tier: "sealed"
+  }),
+  placement: placementFrom(state)
+});
+const stateSection = (state) => {
+  const settled = CallLedger.render(state.callLedger, state.ledgerShown);
+  return [
+    VariablesPanel.render({ ledger: state.panel, frame: state.frame - 1 }),
+    ...settled === void 0 ? [] : [settled]
+  ].join("\n\n");
+};
+const frozen = (contextWindow, state) => {
+  try {
+    ContextWindow.render(contextWindow);
+    return import_effect.Result.succeed(withSection(contextWindow, state));
+  } catch (cause) {
+    return import_effect.Result.fail(
+      new import_HarnessError.HarnessError({ code: "render_failed", message: "Unable to render the context window", cause })
+    );
+  }
+};
+const withSection = (contextWindow, state) => {
+  const section = import_model.ModelRequest.Message.user(stateSection(state));
+  const segments = [...contextWindow.segments];
+  let asks = state.interventions;
+  let index = segments.length - 1;
+  let position = index < 0 ? 0 : segments[index].content.length;
+  while (index >= 0 && asks > 0) {
+    const content = segments[index].content;
+    position = content.length;
+    for (let item = content.length - 1; item >= 0 && asks > 0; item--) {
+      if ("role" in content[item]) {
+        asks--;
+        position = item;
+      }
+    }
+    if (asks > 0 && index > 0) {
+      index--;
+    } else break;
+  }
+  const holder = index < 0 ? void 0 : segments[index];
+  if (holder === void 0 || holder.zone !== "tail") {
+    segments.push(ContextWindow.makeSegment({ kind: "transcript", zone: "tail", content: [section] }));
+  } else {
+    segments[index] = ContextWindow.makeSegment({
+      kind: holder.kind,
+      zone: holder.zone,
+      content: [...holder.content.slice(0, position), section, ...holder.content.slice(position)]
+    });
+  }
+  return ContextWindow.make({
+    modelId: contextWindow.modelId,
+    segments,
+    activeTools: contextWindow.activeTools,
+    replaced: contextWindow.replaced
+  });
+};
+const requestFrom = (state, contextWindow) => {
+  let rendered;
+  try {
+    rendered = ContextWindow.render(contextWindow);
+  } catch (cause) {
+    return import_effect.Result.fail(
+      new import_HarnessError.HarnessError({
+        code: "render_failed",
+        message: "Unable to render the context window",
+        cause
+      })
+    );
+  }
+  return import_effect.Result.succeed(
+    import_model.ModelRequest.ModelRequest.make({
+      modelId: contextWindow.modelId,
+      system: rendered.system,
+      messages: rendered.messages,
+      // A cell-first frame never declares provider tools: the cell is the plan
+      // and `ctx.call` is the only invocation path.
+      tools: [],
+      toolChoice: "none",
+      params: state.modelParams,
+      // The window only grows between frames (see `frozen`), so the whole
+      // request is the next one's prefix and Anthropic's moving breakpoint
+      // sits at its end.
+      cacheKey: cacheKey(state, rendered.system),
+      // Provider-run tools are not declared tools: the model may search
+      // inside the call while `ctx.call` stays the only invocation path.
+      ...state.serverTools === void 0 ? {} : { serverTools: state.serverTools }
+    })
+  );
+};
+const cacheKey = (state, system) => {
+  const task = system.findIndex((part) => part.text.startsWith("The task for this run:\n\n"));
+  const prefix = task < 0 ? system : system.slice(0, task);
+  return `smithers-${import_model.CanonicalJson.shortHash(`${state.session}
+${prefix.map((part) => part.text).join("\n")}`)}`;
+};
+const assistantText = (message) => message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+const encodePermissionRequired = import_effect.Schema.encodeSync(import_kernel.Permission.PermissionRequired);
+const permissionRequired = (error) => {
+  if (error instanceof import_kernel.Permission.PermissionRequired) return error;
+  if (error instanceof import_HarnessError.HarnessError && error.cause instanceof import_kernel.Permission.PermissionRequired) return error.cause;
+  return import_effect.Option.getOrUndefined(
+    import_effect.Schema.decodeUnknownOption(import_kernel.Permission.PermissionRequired)(
+      error instanceof import_HarnessError.HarnessError ? error.cause : error
+    )
+  );
+};
+const liveCellEcho = 8192;
+const deadCellEcho = 1024;
+const appended = (contextWindow, assistant, messages, echo) => ContextWindow.make({
+  modelId: contextWindow.modelId,
+  segments: [
+    ...contextWindow.segments,
+    ContextWindow.makeSegment({
+      kind: "transcript",
+      zone: "tail",
+      content: [bounded(assistant, echo), ...messages]
+    })
+  ],
+  activeTools: contextWindow.activeTools,
+  replaced: contextWindow.replaced
+});
+const observedOn = (contextWindow, assistant, observation, echo) => appended(contextWindow, assistant, [import_model.ModelRequest.Message.user(observation)], echo);
+const memoryShownLimit = 256;
+const shownAfter = (state, drained) => drained.memory === void 0 ? {} : { memoryShown: [...state.memoryShown, ...drained.memory].slice(-memoryShownLimit) };
+const ledgerAfter = (drained) => drained.monitorLedger === void 0 ? {} : { monitorLedger: drained.monitorLedger };
+const marksAfter = (state, drained) => {
+  const due = drained.compact === void 0 ? {} : { compactionDue: drained.compact };
+  if (drained.marks === void 0) return due;
+  const answers = new Map(drained.marks.map(({ digest, ...answer }) => [digest, answer]));
+  const transcripts = (0, import_compactable.compactable)(state.contextWindow.segments).filter((segment) => segment.kind === "transcript");
+  const missing = transcripts.length - state.segmentFacts.length;
+  return {
+    segmentFacts: state.segmentFacts.map((facts, at) => {
+      const answer = answers.get(transcripts[at + missing].digest);
+      return facts.answer !== void 0 || answer === void 0 ? facts : { ...facts, answer };
+    }),
+    ...due
+  };
+};
+const carries = (drained) => drained.inserts.length > 0 || drained.seatChanges.length > 0;
+const steered = (state, changes, resolve) => import_effect.Effect.gen(function* () {
+  let seat = state.seat;
+  let modelParams = state.modelParams;
+  for (const change of changes) {
+    if (change._tag === "SeatChange") seat = change.seat;
+    else {
+      modelParams = import_model.ModelRequest.GenerationParams.make({
+        maxTokens: modelParams.maxTokens,
+        temperature: modelParams.temperature,
+        topP: modelParams.topP,
+        topK: modelParams.topK,
+        stopSequences: modelParams.stopSequences,
+        thinkingBudget: modelParams.thinkingBudget,
+        reasoningEffort: change.thinking
+      });
+    }
+  }
+  return {
+    seat,
+    modelParams,
+    modelCallMs: state.modelCallMsFollowsEffort ? modelCallMsFor(modelParams.reasoningEffort) : state.modelCallMs,
+    contextWindowTokens: seat === state.seat ? state.contextWindowTokens : resolve === void 0 ? import_model.ModelCatalog.contextWindowTokensFor(modelIdFromSeat(seat)) : yield* resolve(seat)
+  };
+});
+const windowOn = (state, seat, context) => seat === state.seat ? context : ContextWindow.make({
+  modelId: modelIdFromSeat(seat),
+  segments: context.segments,
+  activeTools: context.activeTools,
+  replaced: context.replaced
+});
+const missedProperty = (message) => {
+  const match = /reading '([^']+)'|read property '([^']+)'/i.exec(message);
+  return match === null ? void 0 : match[1] ?? match[2];
+};
+const bindingPathMiss = (message, bindings) => {
+  const property = missedProperty(message);
+  if (property === void 0) return void 0;
+  return bindings.length === 0 ? `If \`${property}\` was meant to come from a name an earlier cell bound: your realm holds no names yet.` : `If \`${property}\` was meant to come from a name an earlier cell bound, these are the names your realm holds: ${elide.head(
+    bindings.map((binding) => binding.name).join(", "),
+    CallLedger.width * 4,
+    "the panel in the frame block lists them all"
+  )}. The panel gives each one's type and size.`;
+};
+const revalidationNote = (rejection) => `${rejection.message}
+
+This reply is not a frame. Nothing ran, nothing changed, and no call was made, so you are being asked again inside the same frame instead of losing it: everything above this line is already in the provider's cache, and only what you write next is paid for. Emit the corrected cell and nothing else.`;
+const bounded = (assistant, echo) => {
+  const text = assistantText(assistant);
+  const shortened = elide.middle(
+    text,
+    echo,
+    "the reply is not re-read in full; the observation below names what went wrong"
+  );
+  if (shortened === text) return assistant;
+  return import_model.ModelRequest.Message.assistant(shortened, { stopReason: assistant.stopReason });
+};
+const clip = (text, width) => elide.head(text, width, "clipped");
+const salvageSummary = 400;
+const salvageRecall = "the whole result is still under the name your cell bound it to";
+const signatureOf = (flow, input, at) => Digest.digest(import_model.CanonicalJson.stringify(at === void 0 ? [flow, input] : [flow, input, at]));
+const readOnlyCapFailure = (cap, frames) => new import_HarnessError.HarnessError({
+  code: "read_only_cap",
+  message: `The run spent ${frames} consecutive frames without one call that declares a write, twice its read-only budget of ${cap}. It is stopped here rather than allowed to report work it never did.`
+});
+const mutating = (descriptor, input) => {
+  if (descriptor.effects.writes.length > 0) return true;
+  const declared = input !== null && typeof input === "object" && !Array.isArray(input) ? input.writes : void 0;
+  return Array.isArray(declared) && declared.length > 0;
+};
+const RecordedObservation = import_effect.Schema.Option(EngineLike.Observation);
+const RecordedCompletion = import_effect.Schema.Struct({
+  observed: import_effect.Schema.NullOr(AgentEvent.ClaimDemanded),
+  demand: import_effect.Schema.NullOr(import_effect.Schema.Struct({
+    event: import_effect.Schema.Union([
+      AgentEvent.UnmovedDemanded,
+      AgentEvent.UnresolvedDemanded,
+      AgentEvent.FailedCallDemanded,
+      AgentEvent.UnobservedDemanded,
+      AgentEvent.NarrowedDemanded,
+      AgentEvent.NarrowOnlyDemanded,
+      AgentEvent.ClaimDemanded
+    ]),
+    note: import_effect.Schema.String,
+    keeps: import_effect.Schema.Boolean,
+    spent: import_effect.Schema.Struct({
+      unmovedDemands: import_effect.Schema.optionalKey(import_nonNegativeSafeInt.NonNegativeSafeInt),
+      unresolvedDemands: import_effect.Schema.optionalKey(import_nonNegativeSafeInt.NonNegativeSafeInt),
+      failedCallDemands: import_effect.Schema.optionalKey(import_nonNegativeSafeInt.NonNegativeSafeInt),
+      unobservedDemands: import_effect.Schema.optionalKey(import_nonNegativeSafeInt.NonNegativeSafeInt),
+      narrowingDemands: import_effect.Schema.optionalKey(import_nonNegativeSafeInt.NonNegativeSafeInt),
+      claimDemands: import_effect.Schema.optionalKey(import_nonNegativeSafeInt.NonNegativeSafeInt)
+    })
+  })),
+  unproven: import_effect.Schema.NullOr(import_HarnessError.HarnessError),
+  // An optional key, not a nullable one: a judgement recorded before decisions
+  // existed has no such member, and it must replay as a judgement with no
+  // decision to report rather than fail to decode.
+  decision: import_effect.Schema.optionalKey(import_effect.Schema.NullOr(AgentEvent.DecisionSettled)),
+  sentenceDecision: import_effect.Schema.optionalKey(import_effect.Schema.NullOr(AgentEvent.DecisionSettled)),
+  unfinishedDecision: import_effect.Schema.optionalKey(import_effect.Schema.NullOr(AgentEvent.DecisionSettled))
+});
+const witness = (engine, state, boundary, phase) => engine.record({
+  name: `workspace-${phase}`,
+  // The purpose is folded into the boundary as well as carried in `name`.
+  // `EngineLike.record` keys on `(name, identity)` together, and the
+  // production engine does; an engine that read the contract as keying on
+  // identity alone would replay this frame's opening measurement as its
+  // closing one, and its cell outcome as its steering drain. Folding the
+  // purpose in makes the controller correct under either reading. No released
+  // run database exists at 1.0.0-rc.0, so the labels are free to change now
+  // and will not be again.
+  identity: { session: state.session, frame: state.frame, boundary: `workspace-${phase}:${boundary}` },
+  success: RecordedObservation,
+  execute: engine.observe
+});
+const RecordedSnapshot = import_effect.Schema.Option(EngineLike.Snapshot);
+const pin = (engine, state, cell, ordinal, id, callMs) => engine.record({
+  name: "checkpoint",
+  identity: { session: state.session, frame: state.frame, boundary: `checkpoint:${cell}:${ordinal}` },
+  success: RecordedSnapshot,
+  // The per-call ceiling, applied INSIDE the record for the reason
+  // {@link settled} applies it inside its own: a store that hung past the
+  // budget left the cell told nothing was pinned while the pin itself was
+  // still in flight, so the resumed frame could be handed a snapshot the
+  // original attempt was told it never got. Cut off here, "nothing was
+  // pinned" is what the journal holds and what every later attempt reads.
+  execute: engine.capture({
+    id,
+    identity: { session: state.session, frame: state.frame, boundary: `checkpoint-capture:${cell}` }
+  }).pipe(
+    import_effect.Effect.timeoutOrElse({ duration: callMs, orElse: () => import_effect.Effect.succeed(import_effect.Option.none()) })
+  )
+});
+const issued = (engine, state, cell, ordinal, callMs, flow, issue, replaying, call) => import_effect.Effect.gen(function* () {
+  if (replaying) {
+    return yield* engine.record({
+      name: "cell-call",
+      call,
+      identity: { session: state.session, frame: state.frame, boundary: `cell-call:${cell}:${ordinal}` },
+      success: Cell.CallResultVariant,
+      execute: import_effect.Effect.fail(
+        new import_HarnessError.HarnessError({
+          code: "incompatible_journal",
+          message: `The timed-out frame is missing settlement ${ordinal}`
+        })
+      )
+    }).pipe(import_effect.Effect.flatMap(Cell.decodeCallResult));
+  }
+  const refused = engine.admit === void 0 ? void 0 : yield* engine.admit(call);
+  const identity = { session: state.session, frame: state.frame, boundary: `cell-call:${cell}:${ordinal}` };
+  const subject = EngineLike.callSubject(call.identity);
+  const guarded = refused === void 0 ? engine.guard : void 0;
+  if (guarded !== void 0) yield* guarded.admit(subject);
+  const settlement = refused ?? (yield* issue.pipe(
+    import_effect.Effect.timeoutOrElse({ duration: callMs, orElse: () => import_effect.Effect.succeed(Sandbox.callTimedOut(flow, callMs)) }),
+    import_effect.Effect.flatMap(Cell.decodeCallResult)
+  ));
+  if (guarded !== void 0 && settlement.outcome === "failure" && settlement.code === "timeout") {
+    yield* guarded.trip({
+      source: "tool-call",
+      subject,
+      limitMillis: (0, import_refusal.limitOf)(settlement),
+      message: settlement.message ?? `Flow ${flow} timed out.`
+    });
+  }
+  return yield* engine.record({
+    name: "cell-call",
+    call,
+    identity,
+    success: Cell.CallResultVariant,
+    execute: import_effect.Effect.succeed(settlement)
+  }).pipe(import_effect.Effect.flatMap(Cell.decodeCallResult));
+});
+const RecordedFrame = import_effect.Schema.Struct({
+  boundary: import_effect.Schema.optional(Sandbox.FrameBoundary),
+  outcome: Cell.Outcome,
+  prints: import_effect.Schema.String,
+  bindings: import_effect.Schema.Array(VariablesPanel.Binding)
+});
+const minter = (state, cell, engine, minted, callMs, emit) => (mint) => import_effect.Effect.gen(function* () {
+  const held = state.checkpointIds.length + minted.length;
+  if (held >= state.checkpointCap) {
+    return (0, import_refusal.refusal)(
+      "checkpoint_exhausted",
+      `This run has pinned its ${state.checkpointCap} checkpoints and nothing was pinned here. ${held === 0 ? "" : `The ones you hold are ${[...state.checkpointIds, ...minted].join(", ")}, and `}ctx.base is always the tree this run opened on.`
+    );
+  }
+  const id = `cp-${state.frame}-${mint.ordinal}`;
+  const snapshot = yield* pin(engine, state, cell.digest, mint.ordinal, id, callMs);
+  if (import_effect.Option.isNone(snapshot)) {
+    return (0, import_refusal.refusal)(
+      "checkpoint_unavailable",
+      "This host pins no trees, so nothing was checkpointed. For a baseline, run the check before your edit, then again after it."
+    );
+  }
+  minted.push(id);
+  yield* emit(
+    new AgentEvent.CheckpointMinted({
+      eventType: eventType.checkpointMinted,
+      id: snapshot.value.id,
+      ref: snapshot.value.ref,
+      cell: cell.digest,
+      ordinal: mint.ordinal
+    })
+  );
+  return new Cell.CallResult({ outcome: "success", value: Cell.checkpoint(snapshot.value.id) });
+});
+const emitModelProgress = (event, emit) => event.type === "retry" ? emit(
+  new AgentEvent.ModelRetried({
+    eventType: eventType.modelRetried,
+    attempt: event.attempt,
+    code: event.code,
+    delayMillis: event.delayMillis
+  })
+) : event.type === "settle" ? import_effect.Effect.void : emit(new AgentEvent.ModelDelta({ eventType: eventType.modelDelta, delta: event }));
+const invalidProbeKey = "invalidProbe";
+const invalidProbeOf = (value) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const declared = value[invalidProbeKey];
+  if (declared === null || typeof declared !== "object" || Array.isArray(declared)) return void 0;
+  const { message, reason } = declared;
+  return typeof reason === "string" && typeof message === "string" ? { reason, message } : void 0;
+};
+const mutatedKey = "mutated";
+const mutatedOf = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && value[mutatedKey] === true;
+const frameFailureMessage = (error) => {
+  const row = typeof error === "object" && error !== null ? error : {};
+  const said = typeof row["message"] === "string" ? row["message"].replace(/\s+/g, " ").trim() : "";
+  if (said === "") return "The cell frame failed";
+  const code = typeof row["code"] === "string" && row["code"] !== "" ? `${row["code"].slice(0, 64)}: ` : "";
+  return `The cell frame failed: ${code}${said.slice(0, 1e3)}`;
+};
+const budgetMessage = (state) => state.bouncedCompletion === void 0 ? `The frame budget of ${state.maxFrames} is exhausted. The run stops here; the last transition was a request to continue.` : `The frame budget of ${state.maxFrames} is exhausted. This run completed once and had that completion handed back for another frame, so what it reported then stands here rather than being lost:
+
+${state.bouncedCompletion}`;
+const callHandler = (state, cell, descriptors, engine, ledger, performed, restored, tree, live, callMs, replaying, emit) => (invocation) => import_effect.Effect.gen(function* () {
+  if (state.withheldFlows.includes(invocation.flow)) {
+    restored.add(invocation.flow);
+    return (0, import_refusal.refusal)(
+      "flow_withheld",
+      `Flow ${invocation.flow} was withheld for this task. It is in ctx.flows from the next frame; reissue the call.`
+    );
+  }
+  const descriptor = descriptors.get(invocation.flow);
+  if (descriptor === void 0) {
+    return (0, import_refusal.refusal)("unknown_flow", `Unknown flow ${invocation.flow}. Only the flows in ctx.flows are callable.`);
+  }
+  if (!descriptor.modelInvocable) {
+    return (0, import_refusal.refusal)("capability_refused", `Flow ${invocation.flow} is not model-invocable.`);
+  }
+  const envelope = import_kernel.CapabilitySet.fromPatterns(state.capabilityEnvelope);
+  const refused = descriptor.capabilities.filter(
+    (declared) => import_effect.Option.match(import_kernel.Capability.parse(declared), {
+      onNone: () => true,
+      onSome: (capability) => !import_kernel.CapabilitySet.allows(envelope, capability)
+    })
+  );
+  if (refused.length > 0) {
+    return (0, import_refusal.refusal)(
+      "capability_refused",
+      `Flow ${invocation.flow} needs ${refused.join(", ")}, which is outside this run's capability envelope.`
+    );
+  }
+  const changes = mutating(descriptor, invocation.input);
+  if (changes) {
+    const found = TruncatedOutput.reuse(invocation.input, ledger);
+    if (found !== void 0) {
+      return (0, import_refusal.refusal)("truncated_write", TruncatedOutput.refusal(invocation.flow, found));
+    }
+  }
+  let at;
+  if (invocation.at !== void 0) {
+    at = Cell.checkpointOf(invocation.at);
+    if (at === void 0) {
+      return (0, import_refusal.refusal)(
+        "invalid_input",
+        `The at option takes a checkpoint, which is what ctx.checkpoint() resolves with and what ctx.base is. It was given ${elide.head(import_model.CanonicalJson.stringify(invocation.at), 120, "the rest is the same shape")}.`
+      );
+    }
+    if (changes) {
+      return (0, import_refusal.refusal)(
+        "checkpoint_readonly",
+        `Flow ${invocation.flow} declares a write, and a checkpoint is a read-only view of a tree that has already been. Nothing was run. Make the change on the live tree, and keep at for the readings you take against ${at}.`
+      );
+    }
+  }
+  const sealed = descriptor.effects.tier === "sealed";
+  const epoch = sealed && at === void 0 ? {
+    frames: state.mutations,
+    calls: tree.writes,
+    ...tree.chain === void 0 ? {} : { writes: tree.chain },
+    ...live
+  } : void 0;
+  const call = Cell.callOf(descriptor, {
+    input: invocation.input,
+    identity: new Cell.CallIdentity({
+      session: state.session,
+      frame: state.frame,
+      cell: cell.digest,
+      ordinal: invocation.ordinal,
+      declaration: Cell.declarationDigest(descriptor),
+      layers: [...new Set(state.layers)].sort()
+    }),
+    ...at === void 0 ? {} : { at },
+    ...epoch === void 0 ? {} : { epoch }
+  });
+  performed.add(invocation.ordinal);
+  if (!sealed) {
+    tree.writes++;
+    tree.chain = Digest.digest(
+      import_model.CanonicalJson.stringify([tree.chain ?? null, signatureOf(invocation.flow, invocation.input, at)])
+    );
+  }
+  yield* emit(new AgentEvent.CellCallStarted({ eventType: eventType.cellCallStarted, call }));
+  const result = yield* issued(
+    engine,
+    state,
+    cell.digest,
+    invocation.ordinal,
+    callMs,
+    invocation.flow,
+    // A flow that asks Jev journals its receipts into this run.
+    import_effect.Effect.suspend(() => engine.call(call)).pipe(import_effect.Effect.provideService(AgentEvent.Journal, emit)),
+    replaying,
+    call
+  );
+  if (result.outcome === "success") ledger.push(...TruncatedOutput.captures(call.flowName, result.value));
+  yield* emit(
+    new AgentEvent.CellCallSettled({
+      eventType: eventType.cellCallSettled,
+      flowName: call.flowName,
+      identity: call.identity,
+      result
+    })
+  );
+  return result;
+});
+const requested = (state, engine, request, purpose, attempt, emit) => import_effect.Effect.gen(function* () {
+  const resolved = yield* EngineLike.resolve(engine, request);
+  if (import_effect.Option.isNone(resolved)) return;
+  yield* emit(
+    new AgentEvent.ModelRequested({
+      eventType: eventType.modelRequested,
+      scope: state.session,
+      frame: state.frame,
+      attempt,
+      purpose,
+      seat: state.seat,
+      binding: import_effect.Option.getOrUndefined(resolved.value.binding),
+      request: resolved.value.request
+    })
+  );
+});
+const summarized = (state, engine, emit, step) => import_effect.Effect.gen(function* () {
+  const summaryRequest = yield* Compaction.summaryRequest(state.contextWindow, step).pipe(import_effect.Effect.orDie);
+  const request = import_model.ModelRequest.ModelRequest.make({
+    modelId: summaryRequest.modelId,
+    system: summaryRequest.system,
+    messages: summaryRequest.messages,
+    tools: [],
+    toolChoice: "none",
+    params: summaryRequest.params
+  });
+  yield* requested(state, engine, request, "compaction", 1, emit);
+  const events = yield* import_effect.Stream.runCollect(
+    (engine.sealStepWithEvents?.({
+      request,
+      keyMaterial: keyMaterialFrom(state, state.contextWindow, request),
+      modelCallMs: state.modelCallMs
+    }, emit) ?? engine.sealStep({
+      request,
+      keyMaterial: keyMaterialFrom(state, state.contextWindow, request),
+      modelCallMs: state.modelCallMs
+    })).pipe(
+      import_effect.Stream.tap((event) => emitModelProgress(event, emit))
+    )
+  ).pipe(import_effect.Effect.map((collected) => Array.from(collected)));
+  if (!events.some((event) => event.type === "settle")) {
+    return yield* new import_HarnessError.HarnessError({
+      code: "model_failed",
+      message: "The sealed compaction step ended without a recorded settlement"
+    });
+  }
+  const settled = import_model.ModelEvent.ModelEvent.settledMessage(events);
+  const text = settled.message.content.filter(
+    (part) => part.type === "text"
+  );
+  if (text.length === 0) {
+    return yield* new import_HarnessError.HarnessError({
+      code: "model_failed",
+      message: "The sealed compaction step returned no text summary"
+    });
+  }
+  return import_model.ModelRequest.Message.user(
+    (0, import_untrustedData.untrustedData)(text.map((part) => part.text).join("\n"), "compaction summary of conversation and tool output")
+  );
+});
+const messageText = (message) => message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+const markItem = (segment) => {
+  const messages = segment.content.filter((item) => "role" in item);
+  const said = messages.filter((message) => message.role === "assistant").map(messageText).join("\n");
+  const extracted = Cell.extract(said);
+  return {
+    tokens: segment.tokens.value,
+    cell: extracted._tag === "Success" ? extracted.success.source.text : "",
+    prose: Supervisor.prose(said),
+    observed: messages.filter((message) => message.role !== "assistant").map(messageText).join("\n\n")
+  };
+};
+const alignedFacts = (state, segments) => {
+  const transcripts = segments.filter((segment) => segment.kind === "transcript").length;
+  if (transcripts !== state.segmentFacts.length) return void 0;
+  let next = 0;
+  return segments.map((segment) => segment.kind === "transcript" ? state.segmentFacts[next++] : void 0);
+};
+const unmarked = (state) => {
+  const segments = (0, import_compactable.compactable)(state.contextWindow.segments);
+  const facts = alignedFacts(state, segments);
+  if (facts === void 0) return [];
+  const open = segments.flatMap((segment, index) => {
+    const known = facts[index];
+    return known === void 0 || known.person || known.answer !== void 0 ? [] : [segment];
+  });
+  return [...new Map(open.map((segment) => [segment.digest, segment])).values()].map((segment) => ({
+    digest: segment.digest,
+    item: markItem(segment)
+  }));
+};
+const factsAfter = (state, prefixLength, marks) => {
+  const transcripts = (0, import_compactable.compactable)(state.contextWindow.segments).flatMap(
+    (segment, index) => segment.kind === "transcript" ? [index] : []
+  );
+  const missing = transcripts.length - state.segmentFacts.length;
+  return transcripts.flatMap((index, at) => {
+    const facts = state.segmentFacts[at - missing];
+    return facts !== void 0 && (index >= prefixLength || marks?.[index] === "keep") ? [facts] : [];
+  });
+};
+const MarksRecord = import_effect.Schema.Array(compactionMarks.Marked);
+const marked = (state, facts, prefixLength, engine, emit, taskOf) => import_effect.Effect.gen(function* () {
+  const segments = (0, import_compactable.compactable)(state.contextWindow.segments);
+  const failing = state.checks.filter((check) => check.failing).map((check) => check.label);
+  const pinned = compactionMarks.pins(segments, prefixLength, facts, failing);
+  const open = compactionMarks.unpinned(pinned);
+  const missing = open.filter((index) => facts[index]?.answer === void 0);
+  const budget = {
+    contextWindow: state.contextWindowTokens,
+    reserve: import_compactable.defaultReserve,
+    keepRecent: import_compactable.defaultKeepRecent,
+    suffix: segments.slice(prefixLength).reduce((sum, segment) => sum + segment.tokens.value, 0),
+    tokens: segments.slice(0, prefixLength).map((segment) => segment.tokens.value)
+  };
+  const resolved = (answered) => import_effect.Effect.fromResult(compactionMarks.resolve(open.map((index) => answered.get(index)), pinned, budget)).pipe(
+    import_effect.Effect.orDie
+  );
+  const stored = new Map(open.flatMap((index) => {
+    const answer = facts[index]?.answer;
+    return answer === void 0 ? [] : [[index, answer]];
+  }));
+  if (missing.length === 0) return yield* resolved(stored);
+  const prefix = yield* import_effect.Effect.fromResult(ContextWindow.prefixDigest(state.contextWindow, prefixLength)).pipe(
+    import_effect.Effect.orDie
+  );
+  const record = yield* Judgement.recorded(
+    engine,
+    {
+      name: "compaction-marks",
+      identity: { session: state.session, frame: state.frame, boundary: `compaction-marks:${prefix}` },
+      classifier: "compaction/marks",
+      value: MarksRecord,
+      items: missing.length
+    },
+    compactionMarks.read(
+      { task: Judgement.task(taskOf(state.contextWindow)), failing },
+      missing.map((index) => markItem(segments[index]))
+    ).pipe(import_effect.Effect.flatMap(
+      (reading) => resolved(new Map([...stored, ...missing.map((index, at) => [index, reading.answers[at]])])).pipe(
+        import_effect.Effect.map((value) => ({
+          value,
+          asked: reading.asked,
+          acted: value.some((mark) => mark.mark !== "squash")
+        }))
+      )
+    ))
+  );
+  yield* Judgement.emitRecorded(emit, record);
+  return record.value ?? void 0;
+});
+const compacted = (state, engine, emit, judged, taskOf) => import_effect.Effect.gen(function* () {
+  const over = Compaction.shouldCompact({
+    total: state.contextWindow.tokens.total,
+    contextWindow: state.contextWindowTokens
+  });
+  const due = state.compactionDue;
+  const opened = due.length === 0 ? state : advance(state, { compactionDue: [] });
+  if (!over && due.length === 0) return opened;
+  const prefixLength = Compaction.selectPrefix(state.contextWindow);
+  if (prefixLength === 0) return opened;
+  const causes = [...over ? ["budget"] : [], ...due];
+  const facts = judged ? alignedFacts(state, (0, import_compactable.compactable)(state.contextWindow.segments)) : void 0;
+  const unaligned = judged && facts === void 0;
+  const marks = facts === void 0 ? void 0 : yield* marked(state, facts, prefixLength, engine, emit, taskOf);
+  if (!over && marks !== void 0 && marks.every((mark) => mark.mark === "keep")) return opened;
+  const step = yield* Compaction.declare(
+    state.contextWindow,
+    prefixLength,
+    {
+      identity: "flows/harness/CellTurn.compaction",
+      modelId: state.contextWindow.modelId,
+      params: state.modelParams
+    },
+    marks?.map((mark) => mark.mark)
+  ).pipe(import_effect.Effect.orDie);
+  const summary = marks === void 0 || marks.some((mark) => mark.mark === "squash") ? yield* summarized(state, engine, emit, step) : void 0;
+  const contextWindow = yield* Compaction.apply(state.contextWindow, step, summary).pipe(import_effect.Effect.orDie);
+  const segments = (0, import_compactable.compactable)(state.contextWindow.segments);
+  const replaced = segments.slice(0, prefixLength);
+  yield* emit(
+    new AgentEvent.CompactionSettled({
+      eventType: eventType.compactionSettled,
+      replacedPrefixDigest: step.replacedPrefixDigest,
+      retainedMessageCount: segments.slice(prefixLength).flatMap((segment) => segment.content).filter((item) => "role" in item).length,
+      ...summary === void 0 ? {} : { summary },
+      ...unaligned ? { unaligned } : {},
+      causes,
+      ...marks === void 0 ? {} : {
+        kept: replaced.filter((_, index) => marks[index].mark === "keep").flatMap((segment) => segment.content.filter((item) => "role" in item)),
+        marks: replaced.map((segment, index) => ({ digest: segment.digest, ...marks[index] })),
+        removedTokens: replaced.filter((_, index) => marks[index].mark === "remove").reduce((sum, segment) => sum + segment.tokens.value, 0)
+      }
+    })
+  );
+  return advance(opened, {
+    contextWindow,
+    segmentFacts: factsAfter(state, prefixLength, marks?.map((mark) => mark.mark)),
+    // The sections that listed earlier calls may be among what was replaced.
+    ledgerShown: 0
+  });
+});
+const parsed = (message) => {
+  if (message.stopReason === "length") {
+    return import_effect.Result.fail(
+      new Cell.Rejected({
+        code: "output_truncated",
+        message: "The model reached its output limit (length) before finishing the response. No blocks ran. Emit a shorter, complete cell."
+      })
+    );
+  }
+  const extracted = Cell.extract(assistantText(message));
+  if (extracted._tag === "Failure") return import_effect.Result.fail(extracted.failure);
+  const validation = CellValidation.validate(extracted.success.source);
+  return validation.rejected === void 0 ? import_effect.Result.succeed({
+    source: extracted.success.source,
+    blocks: extracted.success.blocks,
+    program: validation.compiled
+  }) : import_effect.Result.fail(validation.rejected);
+};
+const seal = (state, engine, emit) => import_effect.Effect.gen(function* () {
+  let contextWindow = state.contextWindow;
+  for (let attempt = 0; ; attempt++) {
+    const request = yield* import_effect.Effect.fromResult(requestFrom(state, contextWindow));
+    yield* requested(state, engine, request, "frame", attempt + 1, emit);
+    const startedAt = yield* import_effect.Clock.currentTimeMillis;
+    const events = yield* import_effect.Stream.runCollect(
+      (engine.sealStepWithEvents?.({
+        request,
+        keyMaterial: keyMaterialFrom(state, contextWindow, request),
+        modelCallMs: state.modelCallMs
+      }, emit) ?? engine.sealStep({
+        request,
+        keyMaterial: keyMaterialFrom(state, contextWindow, request),
+        modelCallMs: state.modelCallMs
+      })).pipe(
+        import_effect.Stream.tap((event) => emitModelProgress(event, emit))
+      )
+    ).pipe(import_effect.Effect.map((collected) => Array.from(collected)));
+    const settledAt = yield* import_effect.Clock.currentTimeMillis;
+    if (!events.some((event) => event.type === "settle")) {
+      return yield* new import_HarnessError.HarnessError({
+        code: "model_failed",
+        message: "The sealed model step ended without a recorded settlement"
+      });
+    }
+    const settled = import_model.ModelEvent.ModelEvent.settledMessage(events);
+    const sessionId = events.find((event) => event.type === "settle")?.sessionId;
+    const cost = Pricing.cost(settled.usage, request.modelId, { at: settledAt });
+    yield* emit(
+      new AgentEvent.ModelSettled({
+        eventType: eventType.modelSettled,
+        message: settled.message,
+        usage: settled.usage,
+        ...cost,
+        ...sessionId === void 0 ? {} : { sessionId },
+        durationMillis: settledAt - startedAt
+      })
+    );
+    const cell = parsed(settled.message);
+    if (cell._tag === "Success" || attempt >= state.revalidations) {
+      return { contextWindow, answer: settled.message, cell };
+    }
+    yield* emit(
+      new AgentEvent.CellRejectedInFrame({
+        eventType: eventType.cellRejectedInFrame,
+        attempt: attempt + 1,
+        code: cell.failure.code,
+        message: cell.failure.message
+      })
+    );
+    contextWindow = observedOn(
+      contextWindow,
+      settled.message,
+      revalidationNote(cell.failure),
+      deadCellEcho
+    );
+  }
+});
+const evaluate = (input, state, produced, engine, sandbox, realm, opened, steering, emit) => import_effect.Effect.gen(function* () {
+  const cell = produced.source;
+  const descriptors = new Map(input.flows.map((descriptor) => [descriptor.name, descriptor]));
+  const projections = {};
+  for (const descriptor of input.flows) projections[descriptor.name] = Cell.project(descriptor);
+  const captures = [...state.truncatedOutputs];
+  const calls = [];
+  const performed = /* @__PURE__ */ new Set();
+  const restored = /* @__PURE__ */ new Set();
+  const tree = { writes: 0, chain: void 0 };
+  const live = import_effect.Option.isSome(opened) && opened.value.complete ? { tree: opened.value.digest } : { session: state.session, frame: state.frame };
+  const callMs = Sandbox.withDefaults(sandbox.capabilities, input.limits).callMs ?? Sandbox.defaultLimits.callMs;
+  const totalMs = Sandbox.withDefaults(sandbox.capabilities, input.limits).totalMs;
+  let replaying = false;
+  const observing = (invocation) => {
+    const handle = callHandler(
+      state,
+      cell,
+      descriptors,
+      engine,
+      captures,
+      performed,
+      restored,
+      tree,
+      live,
+      callMs,
+      replaying,
+      emit
+    );
+    const pending = engine.record({
+      name: "steering-before-call",
+      identity: {
+        session: state.session,
+        frame: state.frame,
+        boundary: `steering-before-call:${cell.digest}:${invocation.ordinal}`
+      },
+      success: import_effect.Schema.Boolean,
+      execute: steering.read().pipe(import_effect.Effect.map((queue) => queue.items.some((item) => item.delivery === "steer")))
+    });
+    return pending.pipe(
+      import_effect.Effect.flatMap(
+        (blocked) => blocked ? import_effect.Effect.succeed(
+          (0, import_refusal.refusal)(
+            void 0,
+            "Outside changes are pending; finish this cell and re-read the changed files in the next turn."
+          )
+        ) : handle(invocation)
+      ),
+      import_effect.Effect.tap(
+        (result) => import_effect.Effect.sync(() => {
+          const rendered = result.outcome === "success" ? JSON.stringify(result.value) : result.message ?? "failed";
+          const ordinal = CallLedger.settled(state.callLedger) + calls.length + 1;
+          const descriptor = descriptors.get(invocation.flow);
+          const probe = result.outcome === "success" ? invalidProbeOf(result.value) : void 0;
+          const measured = performed.has(invocation.ordinal) && result.outcome === "success" && mutatedOf(result.value);
+          const ranAt = performed.has(invocation.ordinal) && invocation.at !== void 0 ? Cell.checkpointOf(invocation.at) : void 0;
+          calls.push({
+            flow: invocation.flow,
+            ok: result.outcome === "success",
+            summary: elide.head(rendered, salvageSummary, salvageRecall),
+            ordinal,
+            mutates: performed.has(invocation.ordinal) && descriptor !== void 0 && mutating(descriptor, invocation.input) || measured,
+            remote: measured,
+            // Every invocation the cell issued, refused ones included: a
+            // refusal is still a question the run has already asked, and
+            // asking it again learns nothing either.
+            signature: signatureOf(invocation.flow, invocation.input, ranAt),
+            subject: signatureOf(invocation.flow, invocation.input),
+            at: ranAt,
+            input: invocation.input,
+            value: result.value,
+            message: result.message,
+            invalidProbe: probe,
+            failing: result.outcome === "success" && probe === void 0 && UnresolvedFailure.failed(result.value),
+            passing: result.outcome === "success" && probe === void 0 && UnresolvedFailure.passed(result.value)
+          });
+        })
+      )
+    );
+  };
+  const minted = [];
+  const mint = minter(state, cell, engine, minted, callMs, emit);
+  const history = yield* import_effect.Effect.serviceOption(CellHistory.CellHistory);
+  yield* import_effect.Option.match(history, {
+    onNone: () => import_effect.Effect.void,
+    onSome: (recorder) => recorder.record(cell.text)
+  });
+  const settled = yield* import_effect.Effect.gen(function* () {
+    for (let attempt = 0; ; attempt++) {
+      const identity = (slot) => ({
+        session: state.session,
+        frame: state.frame,
+        boundary: `cell-frame:${cell.digest}${slot === 0 ? "" : `:attempt:${slot}`}`
+      });
+      let fresh = false;
+      const recorded = yield* engine.record({
+        name: "cell-frame",
+        identity: identity(attempt),
+        success: import_effect.Schema.NullOr(RecordedFrame),
+        execute: import_effect.Effect.sync(() => {
+          fresh = true;
+          return null;
+        })
+      });
+      if (recorded === null && !fresh) continue;
+      if (recorded !== null && recorded.boundary === void 0 && recorded.outcome._tag === "rejected" && recorded.outcome.code === "limit_exceeded") {
+        return yield* import_effect.Effect.fail(
+          new import_HarnessError.HarnessError({
+            code: "incompatible_journal",
+            message: "Cannot reconstruct a limited frame without its recorded execution frontier"
+          })
+        );
+      }
+      const replay = recorded !== null && recorded.boundary?.terminal === "timeout" ? { boundary: recorded.boundary, outcome: yield* Cell.decodeOutcome(recorded.outcome) } : void 0;
+      replaying = replay !== void 0;
+      const guarded = recorded === null && engine.guard !== void 0 ? engine.guard : void 0;
+      const subject = JSON.stringify({
+        session: state.session,
+        frame: state.frame,
+        boundary: `cell-frame:${cell.digest}`
+      });
+      if (guarded !== void 0) yield* guarded.admit(subject);
+      const frame2 = yield* realm.evaluate({
+        cell,
+        // The boundary parse is the only one this cell gets: the realm runs
+        // what it compiled rather than parsing the same text again.
+        program: produced.program,
+        frame: state.frame,
+        // A judged run's catalog can change without a refresh: the run-start
+        // relevance reading withholds flows and a call restores them.
+        flows: input.refreshFlows === void 0 && input.judged !== true ? void 0 : projections,
+        call: observing,
+        mint,
+        replay,
+        // Settlements are bounded inside their recorded boundaries.
+        bounded: true
+      });
+      if (recorded !== null) return recorded;
+      const outcome = yield* Cell.decodeOutcome(frame2.outcome);
+      if (guarded !== void 0 && frame2.boundary?.terminal === "timeout" && outcome._tag === "rejected" && outcome.code === "limit_exceeded") {
+        yield* guarded.trip({ source: "cell", subject, limitMillis: totalMs, message: outcome.message });
+      }
+      return yield* engine.record({
+        name: "cell-frame",
+        identity: identity(attempt + 1),
+        success: RecordedFrame,
+        execute: import_effect.Effect.succeed({ ...frame2, outcome })
+      });
+    }
+  });
+  return { frame: settled, calls, minted, captures, restored };
+});
+const completionTask = (task, instructions) => instructions === "" ? task : `${elide.middle(task, 3584, "the run record has the whole task")}
+
+The person now says:
+
+Later instructions accepted during this run, oldest first. Apply these changes to the task above; later changes take precedence:
+
+${instructions}`;
+const drain = (settling, wouldIdle) => import_effect.Effect.gen(function* () {
+  const { boundary, state } = settling;
+  const drained = yield* settling.engine.record({
+    name: "steering-drain",
+    identity: { session: state.session, frame: state.frame, boundary: `steering-drain:${boundary}` },
+    success: Steering.DrainRecord,
+    execute: Frame.hasNextFrame(state) ? settling.steering.drain({ boundary: `${state.frame}:${boundary}`, wouldIdle }).pipe(
+      import_effect.Effect.map(Steering.drainRecord),
+      // The supervisor's nudge rides the same recorded drain, in a field
+      // of its own and only at a boundary the run continues through: a
+      // boundary that would idle is a completion or the last frame, and a
+      // nudge there would turn a finished answer into a follow-up. Inside
+      // the record, so a replayed boundary delivers what it delivered the
+      // first time. Apart from `inserts`, because those are the person's
+      // words and the completion brake reads them as the task; a nudge is
+      // not. See `internal/supervision`.
+      import_effect.Effect.flatMap(
+        (record) => wouldIdle ? import_effect.Effect.succeed(record) : settling.supervision.take(state.frame, {
+          ledger: state.monitorLedger,
+          shown: state.memoryShown,
+          deliver: settling.input.judged ?? false
+        }).pipe(
+          import_effect.Effect.map((taken) => ({
+            ...record,
+            ...taken.messages.length === 0 ? {} : { supervisor: taken.messages },
+            ...taken.memory.length === 0 ? {} : { memory: taken.memory },
+            ...taken.monitor === void 0 ? {} : { monitor: taken.monitor },
+            ...taken.suppressed.length === 0 ? {} : { suppressed: taken.suppressed },
+            ...taken.ledger === void 0 ? {} : { monitorLedger: taken.ledger },
+            ...taken.marks.length === 0 ? {} : { marks: taken.marks },
+            ...taken.compact.length === 0 ? {} : { compact: taken.compact }
+          }))
+        )
+      ),
+      // Executed, not replayed: the one fact that says this frame is the
+      // run's present rather than its past.
+      import_effect.Effect.tap(() => import_effect.Effect.sync(() => void (settling.live.value = true)))
+    ) : import_effect.Effect.succeed({ inserts: [], seatChanges: [], queued: false })
+  });
+  yield* settling.emit(
+    new AgentEvent.SteeringDrained({
+      eventType: eventType.steeringDrained,
+      messages: drained.inserts,
+      ...drained.supervisor === void 0 || drained.supervisor.length === 0 ? {} : { supervisor: drained.supervisor },
+      ...drained.monitor === void 0 ? {} : { monitor: drained.monitor },
+      ...drained.suppressed === void 0 ? {} : { suppressed: drained.suppressed },
+      ...drained.memory === void 0 ? {} : { memory: drained.memory }
+    })
+  );
+  if (settling.live.value && !wouldIdle) yield* settling.offer;
+  return drained;
+});
+const close = (settling, outcome, output = budgetMessage(settling.state)) => import_effect.Effect.gen(function* () {
+  yield* settling.emit(
+    new AgentEvent.TurnClosed({
+      eventType: eventType.turnClosed,
+      stopReason: settling.answer.stopReason,
+      outcome
+    })
+  );
+  if (outcome === "resolved") {
+    yield* settling.emit(
+      new AgentEvent.Resolved({
+        eventType: eventType.resolved,
+        message: import_model.ModelRequest.Message.assistant(output, { stopReason: "stop" })
+      })
+    );
+  }
+});
+const finish = (settling, step) => close(settling, step._tag === "Done" ? "resolved" : step._tag === "Suspend" ? "suspended" : "continue").pipe(
+  import_effect.Effect.as(step)
+);
+const continuing = (settling, contextWindow, person, changes) => {
+  const transcripts = (window) => window.segments.filter((segment) => segment.kind === "transcript").length;
+  const frame2 = settling.state.frame;
+  const reasks = transcripts(contextWindow) - transcripts(settling.state.contextWindow) - 1;
+  const { segmentFacts = settling.state.segmentFacts, ...rest } = changes;
+  const next = advance(settling.state, {
+    frame: frame2 + 1,
+    interventions: 0,
+    // What this frame's section listed; see `frozen`.
+    ledgerShown: CallLedger.settled(settling.state.callLedger),
+    ...settling.facts,
+    contextWindow,
+    segmentFacts: [
+      ...segmentFacts,
+      ...new Array(reasks).fill({ frame: frame2, person: false, mutated: false, checks: [] }),
+      { frame: frame2, person, ...settling.written }
+    ],
+    ...rest
+  });
+  return {
+    _tag: "Continue",
+    state: advance(next, { contextWindow: withSection(next.contextWindow, next), sectioned: true })
+  };
+};
+const delivered = (drained) => [
+  ...drained.supervisor ?? [],
+  ...drained.inserts
+];
+const resumed = (settling, drained, changes = {}, text = settling.printed, echo = liveCellEcho, ask) => import_effect.Effect.gen(function* () {
+  const { state } = settling;
+  const settings = yield* steered(state, drained.seatChanges, settling.input.contextWindowTokensFor);
+  const inserts = delivered(drained);
+  const messages = ask === void 0 ? [import_model.ModelRequest.Message.user(text), ...inserts] : inserts.length === 0 ? [import_model.ModelRequest.Message.user(text === "" ? ask : `${text}
+
+${ask}`)] : [...text === "" ? [] : [import_model.ModelRequest.Message.user(text)], ...inserts, import_model.ModelRequest.Message.user(ask)];
+  const context = appended(settling.contextWindow, settling.answer, messages, echo);
+  return continuing(settling, windowOn(state, settings.seat, context), drained.inserts.length > 0, {
+    ...settings,
+    ...shownAfter(state, drained),
+    ...ledgerAfter(drained),
+    ...marksAfter(state, drained),
+    ...changes
+  });
+});
+const observe = (settling, note, changes = {}, echo = liveCellEcho) => import_effect.Effect.gen(function* () {
+  const next = Frame.hasNextFrame(settling.state);
+  const drained = yield* drain(settling, !next);
+  return next ? yield* resumed(settling, drained, changes, settling.printed, echo, note) : { _tag: "Done" };
+});
+const frame = (input, engine, sandbox, realm, steering, emit, readCompletion, supervision, taskOf) => import_effect.Effect.gen(function* () {
+  const compactedState = yield* compacted(input.state, engine, emit, input.judged ?? false, taskOf);
+  const sectioned = compactedState.sectioned ? import_effect.Result.succeed(compactedState.contextWindow) : frozen(compactedState.contextWindow, compactedState);
+  const state = sectioned._tag === "Success" ? advance(compactedState, { contextWindow: sectioned.success, sectioned: true }) : compactedState;
+  yield* emit(
+    new AgentEvent.TurnOpened({
+      eventType: eventType.turnOpened,
+      seat: state.seat,
+      modelParams: state.modelParams,
+      activeToolNames: [],
+      contextDigest: state.contextWindow.digest
+    })
+  );
+  if (sectioned._tag === "Failure") return yield* import_effect.Effect.fail(sectioned.failure);
+  const { answer, cell: sealed, contextWindow } = yield* seal(state, engine, emit);
+  const settling = (boundary, printed2, facts2, written2, offer = import_effect.Effect.void) => ({
+    input,
+    state,
+    engine,
+    steering,
+    supervision,
+    offer,
+    live: { value: false },
+    emit,
+    contextWindow,
+    answer,
+    boundary,
+    printed: printed2,
+    facts: facts2,
+    written: written2
+  });
+  if (sealed._tag === "Failure") {
+    const rejection = sealed.failure;
+    yield* emit(
+      new AgentEvent.CellSettled({
+        eventType: eventType.cellSettled,
+        cell: "",
+        outcome: rejection
+      })
+    );
+    const rejectedFrames = state.readOnlyFrames + 1;
+    if (state.readOnlyCap > 0 && rejectedFrames >= state.readOnlyCap * 2) {
+      return yield* readOnlyCapFailure(state.readOnlyCap, rejectedFrames);
+    }
+    const rejected = settling(contextWindow.digest, "", {
+      truncatedOutputs: TruncatedOutput.retain(state.truncatedOutputs),
+      readOnlyFrames: rejectedFrames
+    }, { mutated: false, checks: [] });
+    const step = yield* observe(rejected, rejection.message, {}, deadCellEcho);
+    return yield* finish(rejected, step);
+  }
+  const cell = sealed.success.source;
+  yield* emit(
+    new AgentEvent.CellProduced({
+      eventType: eventType.cellProduced,
+      cell,
+      blocks: sealed.success.blocks
+    })
+  );
+  const pendingBeforeTool = yield* engine.record({
+    name: "steering-before-tool",
+    identity: { session: state.session, frame: state.frame, boundary: `steering-before-tool:${cell.digest}` },
+    success: import_effect.Schema.Boolean,
+    execute: steering.read().pipe(import_effect.Effect.map((queue) => queue.items.some((item) => item.delivery === "steer")))
+  });
+  if (pendingBeforeTool) {
+    if (!Frame.hasNextFrame(state)) {
+      return yield* new import_HarnessError.HarnessError({
+        code: "engine_failed",
+        message: "Outside changes require another model turn before tools can run"
+      });
+    }
+    const beforeTool = settling(`before-tool:${cell.digest}`, "", {}, { mutated: false, checks: [] });
+    const drained2 = yield* drain(beforeTool, false);
+    if (carries(drained2)) {
+      const step = yield* resumed(beforeTool, drained2, {}, "", deadCellEcho);
+      return yield* finish(beforeTool, step);
+    }
+  }
+  const opened = state.workspace !== void 0 && (import_effect.Option.isNone(state.workspace) || !state.workspace.value.complete) ? state.workspace : yield* witness(engine, state, cell.digest, "open");
+  const ran = yield* evaluate(
+    input,
+    state,
+    sealed.success,
+    engine,
+    sandbox,
+    realm,
+    opened,
+    steering,
+    emit
+  );
+  const outcome = yield* Cell.decodeOutcome(ran.frame.outcome);
+  const printed = (0, import_printsObservation.printsObservation)(ran.frame.prints);
+  yield* emit(
+    new AgentEvent.CellPrinted({
+      eventType: eventType.cellPrinted,
+      cell: cell.digest,
+      text: ran.frame.prints
+    })
+  );
+  const closed = import_effect.Option.isSome(opened) && !opened.value.complete ? opened : yield* witness(engine, state, cell.digest, "close");
+  yield* emit(
+    new AgentEvent.CellSettled({
+      eventType: eventType.cellSettled,
+      cell: cell.digest,
+      outcome,
+      ...ran.frame.boundary === void 0 ? {} : { boundary: ran.frame.boundary }
+    })
+  );
+  const accounting = Frame.account({
+    state,
+    calls: ran.calls,
+    opened,
+    closed,
+    minted: ran.minted,
+    bindings: ran.frame.bindings,
+    captures: ran.captures,
+    source: cell.text
+  });
+  yield* emit(accounting.observed);
+  const written = Supervisor.prose(assistantText(answer));
+  const { mutated } = accounting;
+  const { readOnlyFrames } = accounting.facts;
+  const failed = ran.calls.length > 0 && ran.calls.every((call) => !call.ok || call.failing);
+  const failure = ran.calls.some((call) => call.ok && !call.failing) ? "" : outcome._tag === "raised" ? `cell threw ${outcome.name}: ${outcome.message}` : failed ? ran.calls.map((call) => `${call.flow}: ${call.summary}`).join("; ") : "";
+  const failureKey = failure.slice(0, 1e3);
+  const failureFrames = failureKey === "" ? 0 : failureKey === state.failureKey ? state.failureFrames + 1 : 1;
+  const facts = ran.restored.size === 0 ? accounting.facts : {
+    ...accounting.facts,
+    withheldFlows: state.withheldFlows.filter((name) => !ran.restored.has(name))
+  };
+  const { capped: skillsCapped, ...offered } = Supervision.catalog(input.flows, accounting.facts.callLedger);
+  const exit = settling(
+    cell.digest,
+    printed,
+    { ...facts, failureFrames, failureKey },
+    { mutated, checks: accounting.frameChecks.map((check) => check.label) },
+    supervision.offer({
+      frame: state.frame,
+      digest: cell.digest,
+      current: {
+        frame: state.frame,
+        cell: Supervisor.head(cell.text),
+        prose: Supervisor.head(written),
+        printed: Supervisor.tail(ran.frame.prints),
+        transition: outcome._tag === "settled" ? outcome.transition._tag : outcome._tag,
+        mutated
+      },
+      snapshot: {
+        task: Judgement.task(taskOf(contextWindow)),
+        signals: Supervision.signals(state, accounting.facts, accounting.workspaceDigest, accounting.observed.paths),
+        ...offered
+      },
+      shown: state.memoryShown,
+      recent: Supervisor.head(written),
+      skillsCapped,
+      unmarked: input.judged === true ? unmarked(state) : [],
+      failing: accounting.facts.checks.filter((check) => check.failing).map((check) => check.label)
+    })
+  );
+  const cap = state.readOnlyCap;
+  if (outcome._tag !== "settled") {
+    if (state.pendingReadOnlyDemand !== void 0 && mutated) {
+      yield* emit(
+        new AgentEvent.ReadOnlyDemanded({
+          eventType: eventType.readOnlyDemanded,
+          streak: state.pendingReadOnlyDemand.streak,
+          cap: state.pendingReadOnlyDemand.cap,
+          nextFrame: state.frame,
+          nextAction: "write"
+        })
+      );
+    }
+    if (cap > 0 && readOnlyFrames >= cap * 2) {
+      return yield* readOnlyCapFailure(cap, readOnlyFrames);
+    }
+    const salvage = ran.calls.length === 0 ? "" : `
+Calls this cell already completed (their results are durable, and each one is still under the name your cell bound it to \u2014 read the name instead of redoing the work):
+${ran.calls.map(
+      (call) => `- ${call.ordinal}. ${clip(call.flow, CallLedger.width)} -> ${call.ok ? "ok" : "FAILED"}: ${call.summary}`
+    ).join("\n")}`;
+    const alert = accounting.probeNotice === void 0 ? "" : `
+
+${accounting.probeNotice}`;
+    const missed = outcome._tag === "raised" ? bindingPathMiss(outcome.message, ran.frame.bindings) : void 0;
+    const note = outcome._tag === "raised" ? `The cell threw ${outcome.name}: ${outcome.message}. Emit a corrected cell.${missed === void 0 ? "" : `
+${missed}`}${salvage}${alert}` : `${outcome.message}${salvage}${alert}`;
+    const step = yield* observe(exit, note);
+    return yield* finish(exit, step);
+  }
+  const transition = outcome.transition;
+  yield* emit(
+    new AgentEvent.TransitionApplied({
+      eventType: eventType.transitionApplied,
+      transition
+    })
+  );
+  if (transition._tag === "park") {
+    if (state.pendingReadOnlyDemand !== void 0) {
+      yield* emit(
+        new AgentEvent.ReadOnlyDemanded({
+          eventType: eventType.readOnlyDemanded,
+          streak: state.pendingReadOnlyDemand.streak,
+          cap: state.pendingReadOnlyDemand.cap,
+          nextFrame: state.frame,
+          nextAction: mutated ? "write" : "park"
+        })
+      );
+    }
+    if (!state.approvalChannel) {
+      return yield* new import_HarnessError.HarnessError({
+        code: "approval_unavailable",
+        message: `The run requires an answer but has no approval channel: ${transition.message}`
+      });
+    }
+    if (!Frame.hasNextFrame(state)) {
+      return yield* finish(exit, {
+        _tag: "Suspend",
+        reason: new EngineLike.SuspendReason({
+          code: transition.reason,
+          message: transition.message
+        })
+      });
+    }
+    const answered = yield* import_effect.Effect.gen(function* () {
+      for (let rung = 0; ; rung++) {
+        const drained2 = yield* steering.drain({
+          boundary: `${state.frame}:${cell.digest}:park:${rung}`,
+          // A park IS the run going idle, which is the condition a queued
+          // follow-up was admitted to wait for. The continue path passes
+          // false because a continuing run is not idle; this is the boundary
+          // that owes those messages their delivery.
+          wouldIdle: true,
+          // What the park asks, so a source with a person on the other end
+          // can put the question to them and answer this drain.
+          park: { reason: transition.reason, message: transition.message }
+        });
+        const record = Steering.drainRecord(drained2);
+        if (carries(record) || !drained2.duplicate) return record;
+      }
+    });
+    if (carries(answered)) {
+      yield* emit(
+        new AgentEvent.SteeringDrained({
+          eventType: eventType.steeringDrained,
+          messages: answered.inserts
+        })
+      );
+      const step = yield* resumed(exit, answered, {
+        pendingReadOnlyDemand: void 0,
+        readOnlyFrames: state.readOnlyFrames
+      });
+      return yield* finish(exit, step);
+    }
+    return yield* finish(exit, {
+      _tag: "Suspend",
+      reason: new EngineLike.SuspendReason({
+        code: transition.reason,
+        message: transition.message
+      })
+    });
+  }
+  if (state.pendingReadOnlyDemand !== void 0) {
+    yield* emit(
+      new AgentEvent.ReadOnlyDemanded({
+        eventType: eventType.readOnlyDemanded,
+        streak: state.pendingReadOnlyDemand.streak,
+        cap: state.pendingReadOnlyDemand.cap,
+        nextFrame: state.frame,
+        nextAction: mutated ? "write" : transition._tag === "continue" && (transition.justification ?? "").trim().length > 0 ? "justification" : "read-only"
+      })
+    );
+  }
+  if (cap > 0 && readOnlyFrames >= cap * 2) {
+    return yield* readOnlyCapFailure(cap, readOnlyFrames);
+  }
+  const drained = yield* drain(exit, transition._tag === "complete" || !Frame.hasNextFrame(state));
+  if (transition._tag === "complete" && carries(drained)) {
+    const step = yield* resumed(
+      exit,
+      drained,
+      { bouncedCompletion: transition.output },
+      `${printed}
+
+The completed answer before this follow-up:
+${transition.output}`
+    );
+    return yield* finish(exit, step);
+  }
+  if (transition._tag === "complete" && input.output !== void 0 && state.outputDemands < input.output.cap && Frame.handBackRoom(state, readOnlyFrames)) {
+    const check = input.output.check;
+    const note = yield* engine.record({
+      name: "output-judgement",
+      identity: {
+        session: state.session,
+        frame: state.frame,
+        boundary: `output-judgement:${cell.digest}`
+      },
+      success: import_effect.Schema.NullOr(import_effect.Schema.String),
+      execute: import_effect.Effect.map(
+        import_effect.Effect.suspend(() => check(transition.output, state.outputDemands, transition.value)),
+        (refused) => refused ?? null
+      )
+    });
+    if (note !== null) {
+      if (exit.live.value) yield* exit.offer;
+      yield* emit(
+        new AgentEvent.OutputDemanded({
+          eventType: eventType.outputDemanded,
+          note,
+          nextFrame: state.frame + 1
+        })
+      );
+      yield* close(exit, "continue");
+      return continuing(
+        exit,
+        appended(
+          contextWindow,
+          answer,
+          [import_model.ModelRequest.Message.user(printed), import_model.ModelRequest.Message.user(note)],
+          liveCellEcho
+        ),
+        false,
+        {
+          interventions: 1,
+          pendingReadOnlyDemand: void 0,
+          outputDemands: state.outputDemands + 1,
+          // An answer the host could not read is not worth restoring.
+          bouncedCompletion: void 0
+        }
+      );
+    }
+  }
+  if (transition._tag === "complete") {
+    const services = yield* import_effect.Effect.context();
+    const judged = yield* engine.record({
+      name: "completion-judgement",
+      identity: {
+        session: state.session,
+        frame: state.frame,
+        boundary: `completion-judgement:${cell.digest}`
+      },
+      success: RecordedCompletion,
+      // The claim brake's reading, whole and by sentence, is paid model
+      // work: the run's budget accounts it like any sealed step (#2681). A
+      // bounce carries the reading as its demand and leaves `observed` empty.
+      usage: (judgement) => (0, import_paidUsage.paidUsage)([
+        (judgement.observed ?? (judgement.demand?.event._tag === "claim-demanded" ? judgement.demand.event : null))?.usage
+      ]),
+      // A replay uses the entire original decision. Re-evaluating even an
+      // accepted claim can invent a demand and execute additional work.
+      execute: Frame.judgeCompletion(
+        state,
+        accounting,
+        contextWindow,
+        transition.output,
+        readCompletion
+      ).pipe(
+        import_effect.Effect.provideContext(services),
+        import_effect.Effect.map((judgement) => ({
+          observed: judgement.observed ?? null,
+          demand: judgement.demand ?? null,
+          unproven: judgement.unproven ?? null,
+          decision: judgement.decision ?? null,
+          sentenceDecision: judgement.sentenceDecision ?? null,
+          unfinishedDecision: judgement.unfinishedDecision ?? null
+        }))
+      )
+    }).pipe(import_effect.Effect.map((judgement) => ({
+      observed: judgement.observed ?? void 0,
+      demand: judgement.demand ?? void 0,
+      unproven: judgement.unproven ?? void 0,
+      decision: judgement.decision ?? void 0,
+      sentenceDecision: judgement.sentenceDecision ?? void 0,
+      unfinishedDecision: judgement.unfinishedDecision ?? void 0
+    })));
+    if (judged.observed !== void 0) yield* emit(judged.observed);
+    if (judged.decision !== void 0) yield* emit(judged.decision);
+    if (judged.sentenceDecision !== void 0) yield* emit(judged.sentenceDecision);
+    if (judged.unfinishedDecision !== void 0) yield* emit(judged.unfinishedDecision);
+    if (judged.unproven !== void 0) return yield* import_effect.Effect.fail(judged.unproven);
+    const demanded = judged.demand;
+    if (demanded !== void 0) {
+      if (exit.live.value) yield* exit.offer;
+      yield* emit(demanded.event);
+      yield* close(exit, "continue");
+      const demandedWindow = demanded.event._tag === "unobserved-demanded" ? appended(
+        contextWindow,
+        answer,
+        [import_model.ModelRequest.Message.user(printed), import_model.ModelRequest.Message.user(demanded.note)],
+        liveCellEcho
+      ) : observedOn(contextWindow, answer, demanded.note, liveCellEcho);
+      return continuing(exit, demandedWindow, false, {
+        // The note is the ask this frame appended; the run's memory goes
+        // above it. See `frozen`.
+        interventions: 1,
+        pendingReadOnlyDemand: void 0,
+        ...demanded.spent,
+        // The answer the demand is taking away, kept so it cannot be lost.
+        // A frame was reserved for the run to answer in, but nothing makes
+        // that frame end in a completion, and a run that spends it and
+        // then runs out of budget would end on the budget notice with its
+        // own answer discarded. See {@link budgetMessage}.
+        //
+        // A claim the brake read and found unsupported is not kept: the
+        // budget notice would hand back the very sentence the brake
+        // refused. See `Frame.CompletionDemand.keeps`.
+        bouncedCompletion: demanded.keeps ? transition.output : void 0,
+        // The frame this demand was handed to, which is the frame that
+        // gets to answer it without being judged again. See
+        // {@link State.demandedFrame}.
+        demandedFrame: state.frame + 1
+      });
+    }
+    yield* close(
+      exit,
+      "resolved",
+      FailedCall.state(
+        transition.output,
+        FailedCall.find(accounting.calls, transition.output, accounting.source)
+      )
+    );
+    return { _tag: "Done" };
+  }
+  if (!Frame.hasNextFrame(state)) {
+    yield* close(exit, "resolved");
+    return { _tag: "Done" };
+  }
+  yield* close(exit, "continue");
+  const { contextWindowTokens, modelCallMs, modelParams, seat } = yield* steered(
+    state,
+    drained.seatChanges,
+    input.contextWindowTokensFor
+  );
+  const disciplined = Frame.discipline(state, accounting, transition.justification);
+  for (const event of disciplined.events) yield* emit(event);
+  const context = appended(
+    contextWindow,
+    answer,
+    [import_model.ModelRequest.Message.user(printed), ...delivered(drained), ...disciplined.messages],
+    liveCellEcho
+  );
+  return continuing(exit, windowOn(state, seat, context), drained.inserts.length > 0, {
+    seat,
+    modelParams,
+    modelCallMs,
+    contextWindowTokens,
+    ...shownAfter(state, drained),
+    ...ledgerAfter(drained),
+    ...marksAfter(state, drained),
+    // Whatever this frame earned is what the next one answers, so the run's
+    // memory goes above it. See `frozen`.
+    interventions: disciplined.messages.length,
+    ...disciplined.changes
+  });
+});
+const RelevanceRecord = import_effect.Schema.Struct({ settled: AgentEvent.RelevanceSettled });
+const withheld = (state, catalog, input, engine, emit, taskOf) => import_effect.Effect.gen(function* () {
+  const pinned = input.pinned ?? [];
+  const documents = input.instructions ?? [];
+  const rows = input.memory?.rows ?? [];
+  const items = [
+    ...catalog.filter((descriptor) => descriptor.modelInvocable && !pinned.includes(descriptor.name)).map(Relevance.flowItem).sort((left, right) => left.id < right.id ? -1 : 1),
+    ...Relevance.chunks(documents).map((chunk) => ({
+      kind: "instruction",
+      id: chunk.id,
+      text: chunk.text
+    })),
+    ...rows.map((row) => ({ kind: "memory", id: row.key, text: row.text }))
+  ];
+  if (items.length === 0) return state;
+  const record = yield* Judgement.recorded(
+    engine,
+    {
+      name: "relevance",
+      identity: { session: state.session, frame: 0, boundary: "relevance" },
+      classifier: "relevance/unnecessary",
+      value: RelevanceRecord,
+      items: items.length
+    },
+    import_effect.Effect.map(Relevance.judge({ task: Judgement.task(taskOf(state.contextWindow)) }, items), (reading) => ({
+      value: { settled: Relevance.settled(reading, { scope: state.session, frame: 0, source: "run" }) },
+      asked: reading.asked,
+      acted: reading.verdicts.some((verdict) => verdict.withheld)
+    }))
+  );
+  yield* Judgement.emitRecorded(emit, record);
+  if (record.value === null) return state;
+  const { settled } = record.value;
+  yield* emit(settled);
+  const judgedChunks = new Set(
+    settled.withheld.filter((item) => item.kind === "instruction").map((item) => `${item.id}\0${item.digest}`)
+  );
+  const chunks = new Set(
+    Relevance.chunks(documents).flatMap(
+      (chunk) => judgedChunks.has(`${chunk.id}\0${Digest.digest(chunk.text)}`) ? [chunk.id] : []
+    )
+  );
+  const dropped = new Set(
+    settled.withheld.filter((item) => item.kind === "memory").map((item) => `${item.id}\0${item.digest}`)
+  );
+  const replaced = /* @__PURE__ */ new Map();
+  if (chunks.size > 0) {
+    const text = Relevance.render(documents, chunks);
+    replaced.set(
+      ContextWindow.makeSegment(instructionsSegment(documents, /* @__PURE__ */ new Set())).digest,
+      text === "" ? [] : [ContextWindow.makeSegment(instructionsSegment(documents, chunks))]
+    );
+  }
+  if (input.memory !== void 0 && dropped.size > 0) {
+    const { digest, render } = input.memory;
+    const text = render(rows.filter((row) => !dropped.has(`${row.key}\0${Digest.digest(row.text)}`)));
+    replaced.set(
+      ContextWindow.makeSegment(memorySegment(render(rows), digest)).digest,
+      text === "" ? [] : [ContextWindow.makeSegment(memorySegment(text, Digest.digest(text)))]
+    );
+  }
+  return advance(state, {
+    withheldFlows: settled.withheld.filter((item) => item.kind === "flow" || item.kind === "skill").map(
+      (item) => item.id
+    ),
+    ...replaced.size === 0 ? {} : {
+      contextWindow: ContextWindow.make({
+        ...state.contextWindow,
+        segments: state.contextWindow.segments.flatMap((segment) => replaced.get(segment.digest) ?? [segment])
+      })
+    }
+  });
+});
+const run = (input) => import_effect.Stream.callback((queue) => {
+  let instructions = "";
+  const emit = (event) => import_effect.Effect.flatMap(AgentEvent.Observer, (observe2) => observe2(event)).pipe(
+    import_effect.Effect.andThen(import_effect.Effect.sync(() => {
+      if (event._tag !== "steering-drained") return;
+      const text = event.messages.flatMap((message) => message.content).filter((part) => part.type === "text").map((part) => part.text).join("\n\n");
+      if (text !== "") instructions = CompletionClaim.newest(`${instructions}
+
+${text}`.trim());
+    })),
+    import_effect.Effect.andThen(import_effect.Queue.offer(queue, event)),
+    import_effect.Effect.asVoid
+  );
+  const readCompletion = (evidence) => CompletionClaim.read({ ...evidence, task: completionTask(evidence.task, instructions) });
+  const taskOf = (window) => completionTask(Frame.taskText(window), instructions);
+  const monitors = input.monitors ?? Monitor.defaults();
+  const judged = input.judged ?? false;
+  const pinned = input.pinned ?? [];
+  const loop = import_effect.Effect.gen(function* () {
+    const engine = yield* EngineLike.EngineLike;
+    const sandbox = yield* Sandbox.Sandbox;
+    const steering = yield* Steering.Source;
+    let current = input.state;
+    let flows = input.flows.filter((descriptor) => !current.withheldFlows.includes(descriptor.name));
+    if (current.journalVersion !== import_Transcript.journalVersion) {
+      return yield* new import_HarnessError.HarnessError({
+        code: "incompatible_journal",
+        message: `Controller state predates harness journal format ${import_Transcript.journalVersion}; start a new run.`
+      });
+    }
+    if (current.frame === 0) {
+      const limits = Sandbox.withDefaults(sandbox.capabilities, input.limits);
+      yield* emit(
+        new AgentEvent.DisciplineArmed({
+          eventType: eventType.disciplineArmed,
+          readOnlyCap: current.readOnlyCap,
+          maxFrames: current.maxFrames,
+          approvalChannel: current.approvalChannel,
+          modelCallMs: current.modelCallMs,
+          repeatCap: current.repeatCap,
+          narrowingCap: current.narrowingCap,
+          unmovedCap: current.unmovedCap,
+          unresolvedCap: current.unresolvedCap,
+          claimCap: current.claimCap,
+          revalidations: current.revalidations,
+          // Written only when armed, so an unjudged journal keeps the bytes
+          // it had before the switch existed.
+          ...judged ? {
+            judged,
+            relevance: { withholdAt: Relevance.withholdAt, pinned: [...pinned] },
+            monitors: monitors.map(({ at, consecutive, cooldownFrames, id, kind, limit }) => ({
+              id,
+              kind,
+              at,
+              consecutive,
+              cooldownFrames,
+              limit
+            }))
+          } : {},
+          ...input.stance === void 0 ? {} : { stance: input.stance },
+          ...limits
+        })
+      );
+    }
+    const supervision = yield* Supervision.open({
+      session: current.session,
+      engine,
+      emit,
+      monitors,
+      deliver: judged
+    });
+    const realm = yield* import_effect.Effect.suspend(() => {
+      const projections = {};
+      for (const descriptor of input.flows) {
+        projections[descriptor.name] = Cell.project(descriptor);
+      }
+      return sandbox.openRealm === void 0 ? import_effect.Effect.fail(Sandbox.realmUnsupported) : sandbox.openRealm({ flows: projections, limits: input.limits });
+    }).pipe(
+      import_effect.Effect.mapError(
+        (cause) => new import_HarnessError.HarnessError({
+          code: "engine_failed",
+          message: "The run's persistent realm could not be opened",
+          cause
+        })
+      )
+    );
+    for (; ; ) {
+      if (current.failureFrames >= 5) {
+        return yield* new import_HarnessError.HarnessError({
+          code: "model_failed",
+          message: `Runaway guard: ${current.failureFrames} consecutive frames repeated the same failure: ${current.failureKey}`,
+          cause: { _tag: repeatedFailureTag, frames: current.failureFrames }
+        });
+      }
+      if (current.maxFrames > 0 && current.frame >= current.maxFrames) {
+        yield* emit(
+          new AgentEvent.Resolved({
+            eventType: eventType.resolved,
+            message: import_model.ModelRequest.Message.assistant(budgetMessage(current), { stopReason: "stop" })
+          })
+        );
+        return;
+      }
+      const catalog = input.refreshFlows === void 0 ? input.flows : yield* engine.record({
+        name: "flow-catalog",
+        identity: { session: current.session, frame: current.frame, boundary: "flow-catalog" },
+        success: import_effect.Schema.Array(import_registry.Descriptor.FlowDescriptor),
+        execute: input.refreshFlows
+      });
+      current = judged && current.frame === 0 ? yield* withheld(current, catalog, input, engine, emit, taskOf) : current;
+      const shown = catalog.filter((descriptor) => !current.withheldFlows.includes(descriptor.name));
+      if (input.refreshFlows !== void 0 || shown.length !== flows.length) {
+        const previous = teach(ContextWindow.empty(current.contextWindow.modelId), flows, void 0, input.stance);
+        const digests = new Set(previous.segments.map((segment) => segment.digest));
+        current = advance(current, {
+          contextWindow: teach(
+            ContextWindow.make({
+              ...current.contextWindow,
+              segments: current.contextWindow.segments.filter((segment) => !digests.has(segment.digest))
+            }),
+            shown,
+            void 0,
+            input.stance
+          )
+        });
+        flows = shown;
+      }
+      const step = yield* frame(
+        { ...input, state: current, flows },
+        engine,
+        sandbox,
+        realm,
+        steering,
+        emit,
+        readCompletion,
+        supervision,
+        taskOf
+      ).pipe(
+        import_effect.Effect.catch((error) => {
+          const request = permissionRequired(error);
+          if (request === void 0) {
+            return import_effect.Effect.fail(
+              error instanceof import_HarnessError.HarnessError ? error : new import_HarnessError.HarnessError({
+                code: error instanceof Sandbox.SandboxError ? "engine_failed" : "model_failed",
+                message: frameFailureMessage(error),
+                cause: error
+              })
+            );
+          }
+          return import_effect.Effect.gen(function* () {
+            yield* emit(
+              new AgentEvent.PermissionRequired({
+                eventType: eventType.permissionRequired,
+                request
+              })
+            );
+            yield* emit(
+              new AgentEvent.TurnClosed({
+                eventType: eventType.turnClosed,
+                stopReason: "error",
+                outcome: "suspended"
+              })
+            );
+            return {
+              _tag: "Suspend",
+              reason: new EngineLike.SuspendReason({
+                code: "permission-required",
+                message: `Permission ${request.requestId} is required`,
+                // Encoded, not attached: `request` is a class that extends
+                // `Error`, and this reason is journaled inside
+                // `AgentEvent.Suspended`. A live Error there has no JSON form,
+                // so encoding it dies with a schema failure that replaces the
+                // park it was carrying.
+                details: encodePermissionRequired(request)
+              })
+            };
+          });
+        }),
+        import_effect.Effect.onInterrupt(
+          () => import_effect.Effect.gen(function* () {
+            yield* emit(new AgentEvent.Aborted({ eventType: eventType.aborted, reason: "Cell frame interrupted" }));
+            yield* emit(
+              new AgentEvent.TurnClosed({
+                eventType: eventType.turnClosed,
+                stopReason: "aborted",
+                outcome: "aborted"
+              })
+            );
+          })
+        )
+      );
+      if (step._tag === "Done") return;
+      if (step._tag === "Suspend") {
+        yield* emit(new AgentEvent.Suspended({ eventType: eventType.suspended, reason: step.reason }));
+        return yield* engine.suspend(step.reason);
+      }
+      for (const flow of current.withheldFlows) {
+        if (step.state.withheldFlows.includes(flow)) continue;
+        yield* emit(
+          new AgentEvent.RelevanceRestored({
+            eventType: eventType.relevanceRestored,
+            scope: current.session,
+            frame: current.frame,
+            flow
+          })
+        );
+      }
+      current = step.state;
+    }
+  });
+  return import_effect.Effect.onExit(import_effect.Effect.scoped(loop), (exit) => import_effect.Effect.asVoid(
+    exit._tag === "Success" ? import_effect.Queue.end(queue) : import_effect.Queue.failCause(queue, exit.cause)
+  ));
+});
+//# sourceMappingURL=CellTurn.js.map