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

package/dist/cjs/AgentEvent.js

@@ -0,0 +1,1116 @@
+"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 AgentEvent_exports = {};
+__export(AgentEvent_exports, {
+  Aborted: () => Aborted,
+  AgentEvent: () => AgentEvent,
+  CellCallSettled: () => CellCallSettled,
+  CellCallStarted: () => CellCallStarted,
+  CellPrinted: () => CellPrinted,
+  CellProduced: () => CellProduced,
+  CellRejectedInFrame: () => CellRejectedInFrame,
+  CellSettled: () => CellSettled,
+  CheckpointMinted: () => CheckpointMinted,
+  ClaimDemanded: () => ClaimDemanded,
+  CompactionCause: () => CompactionCause,
+  CompactionMark: () => CompactionMark,
+  CompactionPin: () => CompactionPin,
+  CompactionSettled: () => CompactionSettled,
+  DecisionAnswer: () => DecisionAnswer,
+  DecisionSettled: () => DecisionSettled,
+  DecisionUnjudged: () => DecisionUnjudged,
+  DisciplineArmed: () => DisciplineArmed,
+  FailedCallDemanded: () => FailedCallDemanded,
+  Journal: () => Journal,
+  ModelDelta: () => ModelDelta,
+  ModelParked: () => ModelParked,
+  ModelRequested: () => ModelRequested,
+  ModelRetried: () => ModelRetried,
+  ModelSelected: () => ModelSelected,
+  ModelSettled: () => ModelSettled,
+  ModelUnparked: () => ModelUnparked,
+  MonitorKind: () => MonitorKind,
+  MutationObserved: () => MutationObserved,
+  NarrowOnlyDemanded: () => NarrowOnlyDemanded,
+  NarrowedDemanded: () => NarrowedDemanded,
+  Observer: () => Observer,
+  OutputDemanded: () => OutputDemanded,
+  PermissionRequired: () => PermissionRequired,
+  ReadOnlyDemandIssued: () => ReadOnlyDemandIssued,
+  ReadOnlyDemanded: () => ReadOnlyDemanded,
+  RelevanceKind: () => RelevanceKind,
+  RelevanceRestored: () => RelevanceRestored,
+  RelevanceSettled: () => RelevanceSettled,
+  RepeatDemanded: () => RepeatDemanded,
+  Resolved: () => Resolved,
+  SeatFailedOver: () => SeatFailedOver,
+  SeatPanel: () => SeatPanel,
+  SeatRouted: () => SeatRouted,
+  Stance: () => Stance,
+  SteeringDrained: () => SteeringDrained,
+  SufficiencyObserved: () => SufficiencyObserved,
+  SupervisorMemoryFailed: () => SupervisorMemoryFailed,
+  SupervisorSettled: () => SupervisorSettled,
+  SupervisorUnjudged: () => SupervisorUnjudged,
+  Suppression: () => Suppression,
+  Suspended: () => Suspended,
+  TransitionApplied: () => TransitionApplied,
+  TurnClosed: () => TurnClosed,
+  TurnOpened: () => TurnOpened,
+  UnjudgedReason: () => UnjudgedReason,
+  UnmovedDemanded: () => UnmovedDemanded,
+  UnobservedDemanded: () => UnobservedDemanded,
+  UnresolvedDemanded: () => UnresolvedDemanded,
+  VacuousVerificationObserved: () => VacuousVerificationObserved,
+  decisionAnswers: () => decisionAnswers,
+  eventType: () => eventType
+});
+module.exports = __toCommonJS(AgentEvent_exports);
+var Permission = __toESM(require("@smthrs/capability/Permission"), 1);
+var Evaluator = __toESM(require("@smthrs/model/Evaluator"), 1);
+var ModelError = __toESM(require("@smthrs/model/ModelError"), 1);
+var ModelEvent = __toESM(require("@smthrs/model/ModelEvent"), 1);
+var ModelRequest = __toESM(require("@smthrs/model/ModelRequest"), 1);
+var Pricing = __toESM(require("@smthrs/model/Pricing"), 1);
+var import_effect = require("effect");
+var Cell = __toESM(require("./Cell.js"), 1);
+var EngineLike = __toESM(require("./EngineLike.js"), 1);
+var import_nonNegativeSafeInt = require("./internal/nonNegativeSafeInt.js");
+var Sandbox = __toESM(require("./Sandbox.js"), 1);
+const Observer = import_effect.Context.Reference(
+  "@smthrs/harness/AgentEvent/Observer",
+  { defaultValue: () => () => import_effect.Effect.void }
+);
+const Journal = import_effect.Context.Reference(
+  "@smthrs/harness/AgentEvent/Journal",
+  { defaultValue: () => () => import_effect.Effect.void }
+);
+const RelevanceKind = import_effect.Schema.Literals(["flow", "skill", "instruction", "memory"]);
+const CompactionMark = import_effect.Schema.Literals(["keep", "squash", "remove"]);
+const CompactionPin = import_effect.Schema.Literals(["summary", "person", "steering", "mutated", "failing", "pair", "budget"]);
+const CompactionCause = import_effect.Schema.Literals(["budget", "outdated_context", "irrelevant_context"]);
+const MonitorKind = import_effect.Schema.Literals(["mood", "skill", "lint"]);
+const Stance = import_effect.Schema.Literals(["careful", "paranoid"]);
+const Suppression = import_effect.Schema.Literals(["streak", "cooldown", "limit", "slot"]);
+const UnjudgedReason = import_effect.Schema.Literals(["interrupted", ...Evaluator.EvaluatorErrorCode.literals]);
+const Usage = import_effect.Schema.Struct({
+  inputTokens: import_effect.Schema.Number,
+  outputTokens: import_effect.Schema.Number,
+  modelId: import_effect.Schema.optional(import_effect.Schema.String)
+});
+class DisciplineArmed extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/DisciplineArmed"
+)("discipline-armed", {
+  eventType: import_effect.Schema.Literal("flows.harness.discipline-armed.v1"),
+  /** Consecutive read-only frames allowed; zero means the cap is disarmed. */
+  readOnlyCap: import_effect.Schema.Number,
+  /** The frame budget the run stops at. */
+  maxFrames: import_effect.Schema.Number,
+  /**
+   * Whether a human can answer this run.
+   *
+   * False says nothing is listening: a `park` transition is refused and
+   * answered in the frame that returned it, because a run that waits for an
+   * answer nobody will give has stopped working with its budget unspent.
+   */
+  approvalChannel: import_effect.Schema.Boolean,
+  /**
+   * Wall-clock milliseconds one model call may spend; zero means disarmed.
+   *
+   * Every other budget here caps the cell — the calls it makes, the memory and
+   * time its code spends, the run's frames. This one caps the step in between,
+   * which was the only unbounded thing the loop did.
+   */
+  modelCallMs: import_effect.Schema.Number,
+  /**
+   * Consecutive repeat-observation frames allowed; zero disarms the demand.
+   *
+   * Armed here for the same reason the read-only cap is: a run that never
+   * reaches a control proves nothing about whether the control was armed, and
+   * a grader must be able to tell "armed and never needed" from "never armed".
+   */
+  repeatCap: import_effect.Schema.Number,
+  /**
+   * Completions this run may have bounced for narrowed evidence; zero disarms.
+   *
+   * Journaled with the rest because the demand it governs fires at most once
+   * in a run and often not at all, so its absence from a wave says nothing on
+   * its own. One is the armed default: the loop names the missing check once,
+   * and the answer that comes back is the answer that stands.
+   */
+  narrowingCap: import_effect.Schema.Number,
+  /**
+   * Completions this run may have bounced for an unmoved tree; zero disarms.
+   *
+   * Journaled for the same reason as the other two completion caps: the demand
+   * fires at most once and usually not at all, so a wave that records none must
+   * be able to say whether the control was armed and never needed.
+   */
+  unmovedCap: import_effect.Schema.Number,
+  /**
+   * Times one frame may answer its own unparseable cell before ending; zero
+   * disarms the answer.
+   *
+   * Journaled with the rest because a wave that records no
+   * `cell-rejected-in-frame` must be able to say whether the answer was armed
+   * and never needed or never armed at all.
+   */
+  revalidations: import_effect.Schema.Number.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.
+   */
+  unresolvedCap: import_effect.Schema.Number,
+  /**
+   * Completions this run may have bounced for a claim its own record does not
+   * support; zero disarms.
+   *
+   * Journaled with the other completion caps, and it says less than they do on
+   * its own: the control it arms is also a no-op wherever no `Evaluator` is
+   * bound, so an armed cap and no `claim-demanded` event anywhere in a run
+   * means either that nothing was asked or that everything asked came back
+   * inside the thresholds. Defaulted so journals written before this control
+   * existed decode unchanged. See `CompletionClaim`.
+   */
+  claimCap: import_effect.Schema.Number.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  ),
+  /**
+   * Whether a supervisor reading could nudge the run, as journals written
+   * before {@link judged} said it. Later writers omit it: `judged` says the
+   * same.
+   */
+  supervisorSteer: import_effect.Schema.optional(import_effect.Schema.Boolean),
+  /** Maximum calls per cell, when this binding can enforce one. */
+  calls: import_effect.Schema.optional(import_effect.Schema.Number),
+  /** Maximum sandbox heap, when this binding can enforce one. */
+  memoryBytes: import_effect.Schema.optional(import_effect.Schema.Number),
+  /** Maximum interpreter steps, when this binding can enforce one. */
+  steps: import_effect.Schema.optional(import_effect.Schema.Number),
+  /** Maximum cell-compute time, when this binding can enforce one. */
+  timeMs: import_effect.Schema.optional(import_effect.Schema.Number),
+  /** Maximum whole-evaluation time, when this binding can enforce one. */
+  totalMs: import_effect.Schema.optional(import_effect.Schema.Number),
+  /** Maximum wall-clock time for one flow call. */
+  callMs: import_effect.Schema.optional(import_effect.Schema.Number),
+  /** Whether a judge was bound, so Jev's readings run. Absent before it existed. */
+  judged: import_effect.Schema.optional(import_effect.Schema.Boolean),
+  /** The relevance gate: the withhold threshold and the item ids never offered to it. */
+  relevance: import_effect.Schema.optional(import_effect.Schema.Struct({ withholdAt: import_effect.Schema.Number, pinned: import_effect.Schema.Array(import_effect.Schema.String) })),
+  /** The supervisor monitors armed, with their delivery gates. */
+  monitors: import_effect.Schema.optional(import_effect.Schema.Array(import_effect.Schema.Struct({
+    id: import_effect.Schema.String,
+    kind: MonitorKind,
+    /** The probability at or above which the monitor crosses. */
+    at: import_effect.Schema.Number,
+    /** Consecutive crossed readings required before a delivery. */
+    consecutive: import_nonNegativeSafeInt.NonNegativeSafeInt,
+    /** Frames after a delivery during which the monitor is not delivered again. */
+    cooldownFrames: import_nonNegativeSafeInt.NonNegativeSafeInt,
+    /** Deliveries allowed in one run. */
+    limit: import_nonNegativeSafeInt.NonNegativeSafeInt
+  }))),
+  /** The static stance the monitors deliver under. */
+  stance: import_effect.Schema.optional(Stance)
+}) {
+}
+class TurnOpened extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/TurnOpened"
+)("turn-opened", {
+  eventType: import_effect.Schema.Literal("flows.harness.turn-opened.v1"),
+  seat: import_effect.Schema.String,
+  modelParams: ModelRequest.GenerationParams,
+  /**
+   * The tool set the turn opened with, which the cell-first controller always
+   * opens empty: it declares no provider tools. The field stays on the event
+   * so journals written before the provider-tool loop was retired keep
+   * decoding, and so a foreign-adapter loop has somewhere to put one.
+   */
+  activeToolNames: import_effect.Schema.Array(import_effect.Schema.String),
+  contextDigest: import_effect.Schema.String
+}) {
+}
+class ModelRequested extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/ModelRequested"
+)("model-requested", {
+  eventType: import_effect.Schema.Literal("flows.harness.model-requested.v1"),
+  /** The run's session, which is the recorded scope of the step that made the call. */
+  scope: import_effect.Schema.String,
+  /** The controller's frame number for the turn this call belongs to. */
+  frame: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0)),
+  /** Which model call of that frame and purpose this is, counting from one. */
+  attempt: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(1)),
+  /** What the call is for: the frame's own turn, or the compaction ahead of it. */
+  purpose: import_effect.Schema.Literals(["frame", "compaction"]),
+  /** The seat the frame ran on, as `turn-opened` names it. */
+  seat: import_effect.Schema.String,
+  /** The route the host resolved, absent where the host names none. */
+  binding: import_effect.Schema.optional(EngineLike.Binding),
+  /** The request the provider is sent, whole: after any rewrite the host applies. */
+  request: ModelRequest.ModelRequest
+}) {
+}
+class ModelSelected extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/ModelSelected"
+)("model-selected", {
+  eventType: import_effect.Schema.Literal("flows.harness.model-selected.v1"),
+  seat: import_effect.Schema.String
+}) {
+}
+class SeatFailedOver extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/SeatFailedOver"
+)("seat-failed-over", {
+  eventType: import_effect.Schema.Literal("flows.harness.seat-failed-over.v1"),
+  from: import_effect.Schema.String,
+  to: import_effect.Schema.String,
+  code: ModelError.ModelErrorCode,
+  resetAtEpochMillis: import_effect.Schema.optional(import_effect.Schema.Number),
+  retryAfterMillis: import_effect.Schema.optional(import_effect.Schema.Number),
+  httpStatus: import_effect.Schema.optional(import_effect.Schema.Number),
+  quotaScope: import_effect.Schema.optional(import_effect.Schema.Literals(["account", "model"]))
+}) {
+}
+class ModelParked extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/ModelParked"
+)("model-parked", {
+  eventType: import_effect.Schema.Literal("flows.harness.model-parked.v1"),
+  seat: import_effect.Schema.String,
+  wakeAt: import_effect.Schema.Number,
+  source: import_effect.Schema.Literals(["reset", "retry-after", "default"]),
+  code: ModelError.ModelErrorCode
+}) {
+}
+class ModelUnparked extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/ModelUnparked"
+)("model-unparked", {
+  eventType: import_effect.Schema.Literal("flows.harness.model-unparked.v1"),
+  seat: import_effect.Schema.String,
+  at: import_effect.Schema.Number
+}) {
+}
+class ModelDelta extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/ModelDelta"
+)("model-delta", {
+  eventType: import_effect.Schema.Literal("flows.harness.model-delta.v1"),
+  delta: ModelEvent.ModelEvent
+}) {
+}
+class ModelRetried extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/ModelRetried"
+)("model-retried", {
+  eventType: import_effect.Schema.Literal("flows.harness.model-retried.v1"),
+  attempt: import_effect.Schema.Int,
+  code: import_effect.Schema.String,
+  /**
+   * Milliseconds the boundary waited before this attempt.
+   *
+   * Every retry of one sealed step is journaled at the moment the step
+   * settles, so the event timestamps cannot show the schedule. This carries
+   * it. Zero is what an unscheduled retry, or a record written before the
+   * field existed, reports.
+   */
+  delayMillis: import_effect.Schema.Number.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  )
+}) {
+}
+class ModelSettled extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/ModelSettled"
+)("model-settled", {
+  eventType: import_effect.Schema.Literal("flows.harness.model-settled.v1"),
+  message: ModelRequest.AssistantMessage,
+  usage: ModelEvent.Usage,
+  /**
+   * The call's USD cost: the provider's reported charge, or its usage priced
+   * under the model's rate card. Absent for an unpriced model.
+   */
+  costUsd: import_effect.Schema.optional(import_effect.Schema.Number),
+  /** Where {@link costUsd} came from. */
+  costSource: import_effect.Schema.optional(Pricing.CostSource),
+  /** The vendor session that answered, for a wrapped CLI seat: `claude --resume <sessionId>`. */
+  sessionId: import_effect.Schema.optional(import_effect.Schema.String),
+  /**
+   * Wall-clock milliseconds the sealed step took, measured on the injected
+   * clock.
+   *
+   * Usage alone answers what a call cost, never how long it took, so a
+   * benchmark could compare tokens per run but not seconds per call — and
+   * speed was the larger half of the gap the first head-to-head measured.
+   * Zero is what an event carries when nothing timed it.
+   */
+  durationMillis: import_effect.Schema.Number.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(0)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(0))
+  )
+}) {
+}
+class CellProduced extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/CellProduced"
+)("cell-produced", {
+  eventType: import_effect.Schema.Literal("flows.harness.cell-produced.v1"),
+  cell: Cell.Source,
+  /**
+   * How many fenced cell blocks the reply was written in.
+   *
+   * Journaled because it is the only record of how the model laid its frame
+   * out, and because the count above one is the shape whose whole program the
+   * harness used to discard. See `Cell.extract`.
+   */
+  blocks: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(1)).pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(1)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(1))
+  )
+}) {
+}
+class CellRejectedInFrame extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/CellRejectedInFrame"
+)("cell-rejected-in-frame", {
+  eventType: import_effect.Schema.Literal("flows.harness.cell-rejected-in-frame.v1"),
+  /** Which attempt of this frame was refused, counting from one. */
+  attempt: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(1)),
+  /** Why the parse refused it. */
+  code: Cell.RejectionCode,
+  /** What the frame told the model, verbatim. */
+  message: import_effect.Schema.String
+}) {
+}
+class CellCallStarted extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/CellCallStarted"
+)("cell-call-started", {
+  eventType: import_effect.Schema.Literal("flows.harness.cell-call-started.v1"),
+  call: Cell.Call
+}) {
+}
+class CellCallSettled extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/CellCallSettled"
+)("cell-call-settled", {
+  eventType: import_effect.Schema.Literal("flows.harness.cell-call-settled.v1"),
+  flowName: import_effect.Schema.String,
+  identity: Cell.CallIdentity,
+  result: Cell.CallResult
+}) {
+}
+class CellPrinted extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/CellPrinted"
+)("cell-printed", {
+  eventType: import_effect.Schema.Literal("flows.harness.cell-printed.v1"),
+  /** The digest of the cell whose prints these are. */
+  cell: import_effect.Schema.String,
+  /** The frame's whole print buffer, already bounded; empty when it printed nothing. */
+  text: import_effect.Schema.String
+}) {
+}
+class CellSettled extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/CellSettled"
+)("cell-settled", {
+  eventType: import_effect.Schema.Literal("flows.harness.cell-settled.v1"),
+  cell: import_effect.Schema.String,
+  outcome: Cell.Outcome,
+  /** Absent in journals written before execution frontiers were recorded. */
+  boundary: import_effect.Schema.optional(Sandbox.FrameBoundary)
+}) {
+}
+class TransitionApplied extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/TransitionApplied"
+)("transition-applied", {
+  eventType: import_effect.Schema.Literal("flows.harness.transition-applied.v1"),
+  transition: Cell.Transition
+}) {
+}
+class ReadOnlyDemandIssued extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/ReadOnlyDemandIssued"
+)("read-only-demand-issued", {
+  eventType: import_effect.Schema.Literal("flows.harness.read-only-demand-issued.v1"),
+  /** Consecutive read-only frames the run had spent. */
+  streak: import_effect.Schema.Int,
+  /** The armed threshold that streak reached. */
+  cap: import_effect.Schema.Int,
+  /** The frame the demand was attached to, which is the one that must answer it. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+class ReadOnlyDemanded extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/ReadOnlyDemanded"
+)("read-only-demanded", {
+  eventType: import_effect.Schema.Literal("flows.harness.read-only-demanded.v1"),
+  streak: import_effect.Schema.Int,
+  cap: import_effect.Schema.Int,
+  nextFrame: import_effect.Schema.Int,
+  nextAction: import_effect.Schema.Literals(["write", "justification", "read-only", "park"])
+}) {
+}
+class RepeatDemanded extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/RepeatDemanded"
+)("repeat-demanded", {
+  eventType: import_effect.Schema.Literal("flows.harness.repeat-demanded.v1"),
+  /** Consecutive repeat-observation frames the run had spent. */
+  frames: import_effect.Schema.Int,
+  /** The armed threshold that streak reached. */
+  cap: import_effect.Schema.Int,
+  /** The frame the demand was attached to, which is the one that must answer it. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+class NarrowedDemanded extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/NarrowedDemanded"
+)("narrowed-demanded", {
+  eventType: import_effect.Schema.Literal("flows.harness.narrowed-demanded.v1"),
+  /** The flow both checks named. */
+  flow: import_effect.Schema.String,
+  /** The broader check's input as the run wrote it, clipped. */
+  broader: import_effect.Schema.String,
+  /** The narrowing check's input as the run wrote it, clipped. */
+  narrower: import_effect.Schema.String,
+  /** Workspace digest the broader check was last run over. */
+  broaderDigest: import_effect.Schema.String,
+  /** Workspace digest the completing frame closed on. */
+  currentDigest: import_effect.Schema.String,
+  /** The frame the demand was attached to, which is the one that must answer it. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+class UnmovedDemanded extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/UnmovedDemanded"
+)("unmoved-demanded", {
+  eventType: import_effect.Schema.Literal("flows.harness.unmoved-demanded.v1"),
+  /** Workspace digest the run opened on. */
+  openedDigest: import_effect.Schema.String,
+  /** Workspace digest the completing frame closed on, equal to the first. */
+  currentDigest: import_effect.Schema.String,
+  /** The frame the demand was attached to, which is the one that must answer it. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+class UnresolvedDemanded extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/UnresolvedDemanded"
+)("unresolved-demanded", {
+  eventType: import_effect.Schema.Literal("flows.harness.unresolved-demanded.v1"),
+  /** The flow both checks named. */
+  flow: import_effect.Schema.String,
+  /** The failing check's input as the run wrote it, clipped. */
+  failed: import_effect.Schema.String,
+  /** The input of the reading the run took instead, clipped. */
+  instead: import_effect.Schema.String,
+  /** Workspace digest both checks were recorded over, and the frame closed on. */
+  currentDigest: import_effect.Schema.String,
+  /** The frame the demand was attached to, which is the one that must answer it. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+class FailedCallDemanded extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/FailedCallDemanded"
+)("failed-call-demanded", {
+  eventType: import_effect.Schema.Literal("flows.harness.failed-call-demanded.v1"),
+  /** The calls the completing frame settled as failures, oldest first. */
+  failures: import_effect.Schema.Array(import_effect.Schema.Struct({ flow: import_effect.Schema.String, message: import_effect.Schema.String })),
+  /** The frame the demand was attached to, which is the one that must answer it. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+class OutputDemanded extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/OutputDemanded"
+)("output-demanded", {
+  eventType: import_effect.Schema.Literal("flows.harness.output-demanded.v1"),
+  /** The correction handed back with the completion. */
+  note: import_effect.Schema.String,
+  /** The frame the demand was attached to, which is the one that must answer it. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+class UnobservedDemanded extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/UnobservedDemanded"
+)("unobserved-demanded", {
+  eventType: import_effect.Schema.Literal("flows.harness.unobserved-demanded.v1"),
+  /** The calls the completion was written without reading, oldest first. */
+  calls: import_effect.Schema.Array(
+    import_effect.Schema.Struct({ flow: import_effect.Schema.String, ordinal: import_effect.Schema.Int, ok: import_effect.Schema.Boolean, summary: import_effect.Schema.String })
+  ),
+  /** The frame the demand was attached to, which is the one that must answer it. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+class NarrowOnlyDemanded extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/NarrowOnlyDemanded"
+)("narrow-only-demanded", {
+  eventType: import_effect.Schema.Literal("flows.harness.narrow-only-demanded.v1"),
+  /** The flow the check named. */
+  flow: import_effect.Schema.String,
+  /** The check's input as the run wrote it, clipped. */
+  check: import_effect.Schema.String,
+  /** The subjects it names, sorted. */
+  targets: import_effect.Schema.Array(import_effect.Schema.String),
+  /** Workspace digest the completing frame closed on; empty when unmeasured. */
+  currentDigest: import_effect.Schema.String,
+  /** The frame the demand was attached to, which is the one that must answer it. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+class ClaimDemanded extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/ClaimDemanded"
+)("claim-demanded", {
+  eventType: import_effect.Schema.Literal("flows.harness.claim-demanded.v1"),
+  /** Probability the transport gave to "the task as stated is done"; journaled, decides nothing. */
+  complete: import_effect.Schema.Number,
+  /** Probability it gave to "the claim asserts what the evidence does not show"; journaled, decides nothing. */
+  overclaims: import_effect.Schema.Number,
+  /** Probability it gave to "the claim reports a command or a result the evidence does not record"; the one that decides. */
+  invented: import_effect.Schema.Number,
+  /** Wall-clock milliseconds the evaluation took. */
+  latencyMs: import_effect.Schema.Int,
+  /** Token usage reported by the evaluator, absent from older journal entries. */
+  usage: import_effect.Schema.optional(Usage),
+  /** Whether this reading handed the completion back. */
+  demanded: import_effect.Schema.Boolean,
+  /**
+   * Whether this reading ended the run instead of handing the completion back.
+   *
+   * The third of the three ways a reading comes out, and the one that had no
+   * field. `demanded` false meant both "the claim stands" and "the claim is
+   * refused and the run is over", which a projection cannot tell apart, so the
+   * refusal wrote no card and the sentence it refused was nowhere a person
+   * could read. Absent from older journal entries, where it decodes false: a
+   * journal written before this field carries its verdict in the run's
+   * failure, which is where it always was.
+   */
+  refused: import_effect.Schema.Boolean.pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(false)),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(false))
+  ),
+  /** Workspace digest the completing frame closed on; empty when unmeasured. */
+  currentDigest: import_effect.Schema.String,
+  /** The frame the demand was attached to, which is the one that must answer it. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+const Probability = import_effect.Schema.Number.check(import_effect.Schema.isBetween({ minimum: 0, maximum: 1 }));
+const DecisionAnswer = import_effect.Schema.Union([
+  import_effect.Schema.Struct({
+    kind: import_effect.Schema.Literal("boolean"),
+    /** The probability the transport gave to yes. */
+    p: Probability
+  }),
+  import_effect.Schema.Struct({
+    kind: import_effect.Schema.Literal("choice"),
+    /** The option chosen. */
+    value: import_effect.Schema.String,
+    probabilities: import_effect.Schema.Record(import_effect.Schema.String, Probability),
+    /** The provider's own number, unchecked: it is theirs to define, and a record must not fail a run. */
+    confidence: import_effect.Schema.optionalKey(import_effect.Schema.Number)
+  }),
+  import_effect.Schema.Struct({
+    kind: import_effect.Schema.Literal("score"),
+    /** The score as the transport gave it, interpolated over rung indexes. */
+    value: import_effect.Schema.Number,
+    /** The label of the nearest rung. */
+    label: import_effect.Schema.String,
+    probabilities: import_effect.Schema.Record(import_effect.Schema.String, Probability),
+    /** The provider's own number, unchecked: it is theirs to define, and a record must not fail a run. */
+    confidence: import_effect.Schema.optionalKey(import_effect.Schema.Number)
+  })
+]);
+const decisionAnswers = (answers, confidence) => Object.fromEntries(
+  Object.entries(answers).map(([id, answer]) => {
+    if ("probability" in answer) return [id, { kind: "boolean", p: answer.probability }];
+    const reported = confidence !== void 0 && Object.hasOwn(confidence, id) ? confidence[id] : void 0;
+    const provided = reported === void 0 ? {} : { confidence: reported };
+    return "label" in answer ? [id, {
+      kind: "score",
+      value: answer.value,
+      label: answer.label,
+      probabilities: answer.probabilities,
+      ...provided
+    }] : [id, { kind: "choice", value: answer.value, probabilities: answer.probabilities, ...provided }];
+  })
+);
+class DecisionSettled extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/DecisionSettled"
+)("decision-settled", {
+  eventType: import_effect.Schema.Literal("flows.harness.decision-settled.v1"),
+  /** The run's session, which is the recorded scope of the step that decided. */
+  scope: import_effect.Schema.String,
+  /** The controller's frame number for the turn the decision was made in. */
+  frame: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0)),
+  /** The classifier's stable id. */
+  classifier: import_effect.Schema.String,
+  /** `Classifier.digest`: the canonical hash of the id and the questions. */
+  digest: import_effect.Schema.String,
+  /** The encoded state the questions were asked about, as the transport was sent it. */
+  state: import_effect.Schema.Json,
+  /** The questions as they crossed the wire, keyed by question id. */
+  questions: import_effect.Schema.Record(import_effect.Schema.String, Evaluator.Question),
+  /** One answer per question id, tagged by kind. */
+  answers: import_effect.Schema.Record(import_effect.Schema.String, DecisionAnswer),
+  /** Wall-clock milliseconds the evaluation took. */
+  latencyMs: import_effect.Schema.Int,
+  /** Whether this decision changed what the run did next. */
+  acted: import_effect.Schema.Boolean,
+  /** Who answered. */
+  decidedBy: import_effect.Schema.Literals(["jev", "seat", "human"]),
+  /** Token usage reported by the evaluator, absent when it supplied none. */
+  usage: import_effect.Schema.optional(Usage)
+}) {
+}
+const Level = import_effect.Schema.Literals(["none", "mild", "strong"]);
+class SupervisorSettled extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/SupervisorSettled"
+)("supervisor-settled", {
+  eventType: import_effect.Schema.Literal("flows.harness.supervisor-settled.v1"),
+  /** The run's session. */
+  scope: import_effect.Schema.String,
+  /** The frame the snapshot was built from. */
+  frame: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0)),
+  /** Probability the run is repeating itself without converging. */
+  thrashing: import_effect.Schema.Number,
+  /** Probability the run is still working on the task as stated. */
+  onTarget: import_effect.Schema.Number,
+  /** Probability the run's evidence is suspect. */
+  suspect: import_effect.Schema.Number,
+  /** Probability visible earlier context is contradicted by later evidence. */
+  outdatedContext: import_effect.Schema.optional(import_effect.Schema.Number),
+  /** Probability visible earlier context is no longer useful for this task. */
+  irrelevantContext: import_effect.Schema.optional(import_effect.Schema.Number),
+  frustrated: Level,
+  anxious: Level,
+  scared: Level,
+  confused: Level,
+  confident: Level,
+  /** The one word a person is shown. */
+  needsHelp: import_effect.Schema.Literals(["none", "clarification", "permission", "stuck", "risky_action"]),
+  /** Whether the reading crossed a nudge threshold. */
+  crossed: import_effect.Schema.Boolean,
+  /** Whether a nudge was handed to the next boundary. */
+  nudged: import_effect.Schema.Boolean,
+  /**
+   * Whether steering was armed for this reading. `discipline-armed` states it
+   * once, at a run's first frame; a resumed run may be armed differently, and
+   * this is where the journal says what the reading actually ran under.
+   * Absent from readings journaled before it existed.
+   */
+  steer: import_effect.Schema.optional(import_effect.Schema.Boolean),
+  /**
+   * Whether the snapshot had more uncalled skills than `Supervisor.skillLimit`,
+   * so some were not scored. Absent when every one was.
+   */
+  skillsCapped: import_effect.Schema.optional(import_effect.Schema.Boolean),
+  /** Wall-clock milliseconds the evaluation took. */
+  latencyMs: import_effect.Schema.Int,
+  /** Token usage reported by the evaluator, absent when it supplied none. */
+  usage: import_effect.Schema.optional(Usage),
+  /** Each armed monitor's probability in this reading, and whether it crossed. */
+  monitors: import_effect.Schema.optional(import_effect.Schema.Array(import_effect.Schema.Struct({
+    id: import_effect.Schema.String,
+    kind: MonitorKind,
+    p: import_effect.Schema.Number,
+    crossed: import_effect.Schema.Boolean
+  })))
+}) {
+}
+class SupervisorUnjudged extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/SupervisorUnjudged"
+)("supervisor-unjudged", {
+  eventType: import_effect.Schema.Literal("flows.harness.supervisor-unjudged.v1"),
+  /** The run's session. */
+  scope: import_effect.Schema.String,
+  /** The frame the snapshot was built from. */
+  frame: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0)),
+  /** `unconfigured`, `interrupted`, or the transport's own error code. */
+  reason: UnjudgedReason,
+  /** What went wrong, safe to journal: see `Evaluator.publicMessage`. */
+  detail: import_effect.Schema.String,
+  /** What each request of the failed reading paid; absent when none was metered. */
+  usage: import_effect.Schema.optional(import_effect.Schema.Array(Usage))
+}) {
+}
+class DecisionUnjudged extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/DecisionUnjudged"
+)("decision-unjudged", {
+  eventType: import_effect.Schema.Literal("flows.harness.decision-unjudged.v1"),
+  /** The run's session. */
+  scope: import_effect.Schema.String,
+  /** The frame the reading was asked in. */
+  frame: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  /** The classifier's stable id. */
+  classifier: import_effect.Schema.String,
+  /** `unconfigured`, `interrupted`, or the transport's own error code. */
+  reason: UnjudgedReason,
+  /** What went wrong, safe to journal: see `Evaluator.publicMessage`. */
+  detail: import_effect.Schema.String,
+  /** Items the failed reading covered. */
+  items: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  /** What each request of the failed reading paid; absent when none was metered. */
+  usage: import_effect.Schema.optional(import_effect.Schema.Array(Usage))
+}) {
+}
+const RelevanceItem = import_effect.Schema.Struct({
+  kind: RelevanceKind,
+  id: import_effect.Schema.String,
+  /** Digest of the item's text; the text itself is never journaled. */
+  digest: import_effect.Schema.String,
+  /** Probability the item is unnecessary for the task as stated. */
+  p: import_effect.Schema.Number
+});
+class RelevanceSettled extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/RelevanceSettled"
+)("relevance-settled", {
+  eventType: import_effect.Schema.Literal("flows.harness.relevance-settled.v1"),
+  /** The run's session. */
+  scope: import_effect.Schema.String,
+  /** The frame the reading was asked in. */
+  frame: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  /**
+   * `run` for the gate at run start, `supervisor` for recalled memory,
+   * `recall` for a recall the model called.
+   */
+  source: import_effect.Schema.Literals(["run", "supervisor", "recall"]),
+  /** The probability at or above which an item is withheld. */
+  withholdAt: import_effect.Schema.Number,
+  kept: import_effect.Schema.Array(RelevanceItem),
+  withheld: import_effect.Schema.Array(RelevanceItem),
+  /** Wall-clock milliseconds the evaluation took. */
+  latencyMs: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  /** Token usage reported by the evaluator, absent when it supplied none. */
+  usage: import_effect.Schema.optional(Usage)
+}) {
+}
+class RelevanceRestored extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/RelevanceRestored"
+)("relevance-restored", {
+  eventType: import_effect.Schema.Literal("flows.harness.relevance-restored.v1"),
+  /** The run's session. */
+  scope: import_effect.Schema.String,
+  /** The frame whose call restored it. */
+  frame: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  /** The flow restored. */
+  flow: import_effect.Schema.String
+}) {
+}
+const SeatPanel = import_effect.Schema.Struct({
+  seats: import_effect.Schema.Array(import_effect.Schema.Struct({ seat: import_effect.Schema.String, backups: import_effect.Schema.Array(import_effect.Schema.String) })),
+  merger: import_effect.Schema.String
+});
+class SeatRouted extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/SeatRouted"
+)("seat-routed", {
+  eventType: import_effect.Schema.Literal("flows.harness.seat-routed.v1"),
+  /** The run's session. */
+  scope: import_effect.Schema.String,
+  /** What the flow declared, such as `auto`. */
+  declared: import_effect.Schema.String,
+  /** The seat chosen. */
+  seat: import_effect.Schema.String,
+  /** The chosen seat's model. */
+  modelId: import_effect.Schema.String,
+  /** The system-prompt variant chosen with it, when one was. */
+  variant: import_effect.Schema.NullOr(import_effect.Schema.String),
+  /** The seats offered. */
+  candidates: import_effect.Schema.Array(import_effect.Schema.String),
+  decidedBy: import_effect.Schema.Literals(["jev", "only"]),
+  /** The provider's own number, absent when it sent none. */
+  confidence: import_effect.Schema.optional(import_effect.Schema.Number),
+  /** Wall-clock milliseconds the routing took. */
+  latencyMs: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  /** The seats `seat` fails over to, in order; absent when there are none. */
+  backups: import_effect.Schema.optionalKey(import_effect.Schema.Array(import_effect.Schema.String)),
+  /** The panel the task was routed to, whose merger is `seat`; absent for one seat. */
+  panel: import_effect.Schema.optionalKey(SeatPanel)
+}) {
+}
+class SupervisorMemoryFailed extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/SupervisorMemoryFailed"
+)("supervisor-memory-failed", {
+  eventType: import_effect.Schema.Literal("flows.harness.supervisor-memory-failed.v1"),
+  /** The run's session. */
+  scope: import_effect.Schema.String,
+  /** The frame whose reading asked; for a `remember`, the run's last frame. */
+  frame: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0)),
+  /** `recall` for a read, `remember` for a write. */
+  operation: import_effect.Schema.Literals(["recall", "remember"]),
+  /** The store's own account of the failure. */
+  detail: import_effect.Schema.String
+}) {
+}
+class SufficiencyObserved extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/SufficiencyObserved"
+)("sufficiency-observed", {
+  eventType: import_effect.Schema.Literal("flows.harness.sufficiency-observed.v1"),
+  /** The flow that ran the failing check. */
+  flow: import_effect.Schema.String,
+  /** The failing check's input as the run wrote it, clipped. */
+  failed: import_effect.Schema.String,
+  /** The input of the passing check that answered it, clipped. */
+  passed: import_effect.Schema.String,
+  /** Mutating frames the run had spent when the failure was recorded. */
+  epoch: import_effect.Schema.Int,
+  /** The frame the observation was attached to. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+class VacuousVerificationObserved extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/VacuousVerificationObserved"
+)("vacuous-verification-observed", {
+  eventType: import_effect.Schema.Literal("flows.harness.vacuous-verification-observed.v1"),
+  /** The flow the stored check named. */
+  flow: import_effect.Schema.String,
+  /** The stored check's input as the run wrote it, clipped. */
+  check: import_effect.Schema.String,
+  /** The controller's identity for that call: the digest of its flow and input. */
+  callDigest: import_effect.Schema.String,
+  /** The frame the observation was attached to. */
+  nextFrame: import_effect.Schema.Int
+}) {
+}
+class MutationObserved extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/MutationObserved"
+)("mutation-observed", {
+  eventType: import_effect.Schema.Literal("flows.harness.mutation-observed.v1"),
+  /** What the frame had to decide with: a full measurement, a partial one, or paperwork. */
+  basis: import_effect.Schema.Literals(["observed", "partial", "declared"]),
+  /** Whether this frame changed anything: the tree said so, or a call declared it. */
+  mutated: import_effect.Schema.Boolean,
+  /** Content address of the workspace as the frame left it; empty when unobserved. */
+  digest: import_effect.Schema.String,
+  /** Paths the closing measurement covered; zero when unobserved. */
+  paths: import_effect.Schema.Int,
+  /**
+   * Calls this frame made that DECLARED a write, whether or not they landed.
+   *
+   * Journaled beside the observed answer rather than instead of it, because
+   * the gap between the two numbers is the accounting defect itself: a frame
+   * with `declaredWrites: 0` and `mutated: true` is a shell mutation nothing
+   * else in the run can see, and a frame with `declaredWrites: 1` and
+   * `mutated: false` under `observed` is a failed call whose declaration the
+   * measurement contradicted.
+   */
+  declaredWrites: import_effect.Schema.Int
+}) {
+}
+class CheckpointMinted extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/CheckpointMinted"
+)("checkpoint-minted", {
+  eventType: import_effect.Schema.Literal("flows.harness.checkpoint-minted.v1"),
+  /** The handle the cell holds, and what a later call names in its `at`. */
+  id: import_effect.Schema.String,
+  /** What the host recorded, in the host's own vocabulary. */
+  ref: import_effect.Schema.String,
+  /** The cell that minted it, and where in that cell. */
+  cell: import_effect.Schema.String,
+  ordinal: import_effect.Schema.Int
+}) {
+}
+class Suspended extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/Suspended"
+)("suspended", {
+  eventType: import_effect.Schema.Literal("flows.harness.suspended.v1"),
+  reason: EngineLike.SuspendReason
+}) {
+}
+class CompactionSettled extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/CompactionSettled"
+)("compaction-settled", {
+  eventType: import_effect.Schema.Literal("flows.harness.compaction-settled.v1"),
+  replacedPrefixDigest: import_effect.Schema.String,
+  // Counts messages, not segments: one live transcript segment can contain
+  // both an assistant turn and its observations. Absent in older journals.
+  retainedMessageCount: import_effect.Schema.optional(import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0))),
+  /** Absent when nothing replaced was squashed. */
+  summary: import_effect.Schema.optional(ModelRequest.Message),
+  /** Replaced messages carried over verbatim, after the summary. */
+  kept: import_effect.Schema.optional(import_effect.Schema.Array(ModelRequest.Message)),
+  /** What a reading marked each replaced segment, by segment digest. */
+  marks: import_effect.Schema.optional(import_effect.Schema.Array(import_effect.Schema.Struct({
+    digest: import_effect.Schema.String,
+    mark: CompactionMark,
+    /** The invariant that overrode a `remove`, when one did. */
+    pinned: import_effect.Schema.optional(CompactionPin)
+  }))),
+  /** Estimated tokens the removed messages held. */
+  removedTokens: import_effect.Schema.optional(import_nonNegativeSafeInt.NonNegativeSafeInt),
+  /**
+   * True when a judged run could not mark: its facts do not describe every
+   * transcript segment, as in state written before marks, so every replaced
+   * message was squashed.
+   */
+  unaligned: import_effect.Schema.optional(import_effect.Schema.Boolean),
+  /** Why the compaction ran, budget first. Absent in older journals, which compacted on the budget alone. */
+  causes: import_effect.Schema.optional(import_effect.Schema.Array(CompactionCause))
+}) {
+}
+class SteeringDrained extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/SteeringDrained"
+)("steering-drained", {
+  eventType: import_effect.Schema.Literal("flows.harness.steering-drained.v1"),
+  /** What the person sent, in admission order. */
+  messages: import_effect.Schema.Array(ModelRequest.Message),
+  /**
+   * What the run's supervisor delivered at the same boundary: a nudge or a
+   * recalled row. The model reads these above the person's messages; they
+   * never join the task the completion brake or the supervisor reads.
+   */
+  supervisor: import_effect.Schema.optional(import_effect.Schema.Array(ModelRequest.Message)),
+  /** The monitor whose delivery `supervisor` carries, when one's does. */
+  monitor: import_effect.Schema.optional(import_effect.Schema.String),
+  /** Crossed monitors not delivered at this boundary, and why. */
+  suppressed: import_effect.Schema.optional(import_effect.Schema.Array(import_effect.Schema.Struct({ id: import_effect.Schema.String, reason: Suppression }))),
+  /** Keys of the memory rows delivered at this boundary. */
+  memory: import_effect.Schema.optional(import_effect.Schema.Array(import_effect.Schema.String))
+}) {
+}
+class TurnClosed extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/TurnClosed"
+)("turn-closed", {
+  eventType: import_effect.Schema.Literal("flows.harness.turn-closed.v1"),
+  stopReason: ModelRequest.StopReason,
+  outcome: import_effect.Schema.Literals(["continue", "resolved", "aborted", "suspended"])
+}) {
+}
+class PermissionRequired extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/PermissionRequired"
+)("permission-required", {
+  eventType: import_effect.Schema.Literal("flows.harness.permission-required.v1"),
+  request: Permission.PermissionRequired
+}) {
+}
+class Aborted extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/Aborted"
+)("aborted", {
+  eventType: import_effect.Schema.Literal("flows.harness.aborted.v1"),
+  reason: import_effect.Schema.String
+}) {
+}
+class Resolved extends import_effect.Schema.TaggedClass(
+  "flows/harness/AgentEvent/Resolved"
+)("resolved", {
+  eventType: import_effect.Schema.Literal("flows.harness.resolved.v1"),
+  message: ModelRequest.AssistantMessage
+}) {
+}
+const AgentEvent = import_effect.Schema.Union([
+  DisciplineArmed,
+  TurnOpened,
+  ModelDelta,
+  ModelRequested,
+  ModelSelected,
+  SeatFailedOver,
+  ModelParked,
+  ModelUnparked,
+  ModelRetried,
+  ModelSettled,
+  CellProduced,
+  CellRejectedInFrame,
+  CellCallStarted,
+  CellCallSettled,
+  CellPrinted,
+  CellSettled,
+  TransitionApplied,
+  MutationObserved,
+  CheckpointMinted,
+  ReadOnlyDemandIssued,
+  ReadOnlyDemanded,
+  RepeatDemanded,
+  NarrowedDemanded,
+  NarrowOnlyDemanded,
+  UnmovedDemanded,
+  UnresolvedDemanded,
+  FailedCallDemanded,
+  UnobservedDemanded,
+  OutputDemanded,
+  ClaimDemanded,
+  DecisionSettled,
+  SupervisorSettled,
+  SupervisorUnjudged,
+  SupervisorMemoryFailed,
+  DecisionUnjudged,
+  RelevanceSettled,
+  RelevanceRestored,
+  SeatRouted,
+  SufficiencyObserved,
+  VacuousVerificationObserved,
+  Suspended,
+  CompactionSettled,
+  SteeringDrained,
+  TurnClosed,
+  PermissionRequired,
+  Aborted,
+  Resolved
+]).pipe(import_effect.Schema.toTaggedUnion("_tag"));
+const eventType = {
+  aborted: "flows.harness.aborted.v1",
+  cellCallSettled: "flows.harness.cell-call-settled.v1",
+  cellCallStarted: "flows.harness.cell-call-started.v1",
+  cellPrinted: "flows.harness.cell-printed.v1",
+  cellProduced: "flows.harness.cell-produced.v1",
+  cellRejectedInFrame: "flows.harness.cell-rejected-in-frame.v1",
+  cellSettled: "flows.harness.cell-settled.v1",
+  checkpointMinted: "flows.harness.checkpoint-minted.v1",
+  claimDemanded: "flows.harness.claim-demanded.v1",
+  compactionSettled: "flows.harness.compaction-settled.v1",
+  decisionSettled: "flows.harness.decision-settled.v1",
+  decisionUnjudged: "flows.harness.decision-unjudged.v1",
+  disciplineArmed: "flows.harness.discipline-armed.v1",
+  modelDelta: "flows.harness.model-delta.v1",
+  modelRequested: "flows.harness.model-requested.v1",
+  modelSelected: "flows.harness.model-selected.v1",
+  seatFailedOver: "flows.harness.seat-failed-over.v1",
+  modelParked: "flows.harness.model-parked.v1",
+  modelUnparked: "flows.harness.model-unparked.v1",
+  modelRetried: "flows.harness.model-retried.v1",
+  modelSettled: "flows.harness.model-settled.v1",
+  mutationObserved: "flows.harness.mutation-observed.v1",
+  narrowOnlyDemanded: "flows.harness.narrow-only-demanded.v1",
+  narrowedDemanded: "flows.harness.narrowed-demanded.v1",
+  permissionRequired: "flows.harness.permission-required.v1",
+  readOnlyDemandIssued: "flows.harness.read-only-demand-issued.v1",
+  readOnlyDemanded: "flows.harness.read-only-demanded.v1",
+  relevanceRestored: "flows.harness.relevance-restored.v1",
+  relevanceSettled: "flows.harness.relevance-settled.v1",
+  repeatDemanded: "flows.harness.repeat-demanded.v1",
+  resolved: "flows.harness.resolved.v1",
+  seatRouted: "flows.harness.seat-routed.v1",
+  steeringDrained: "flows.harness.steering-drained.v1",
+  sufficiencyObserved: "flows.harness.sufficiency-observed.v1",
+  supervisorSettled: "flows.harness.supervisor-settled.v1",
+  supervisorUnjudged: "flows.harness.supervisor-unjudged.v1",
+  supervisorMemoryFailed: "flows.harness.supervisor-memory-failed.v1",
+  suspended: "flows.harness.suspended.v1",
+  transitionApplied: "flows.harness.transition-applied.v1",
+  turnClosed: "flows.harness.turn-closed.v1",
+  turnOpened: "flows.harness.turn-opened.v1",
+  unmovedDemanded: "flows.harness.unmoved-demanded.v1",
+  unresolvedDemanded: "flows.harness.unresolved-demanded.v1",
+  failedCallDemanded: "flows.harness.failed-call-demanded.v1",
+  unobservedDemanded: "flows.harness.unobserved-demanded.v1",
+  outputDemanded: "flows.harness.output-demanded.v1",
+  vacuousVerificationObserved: "flows.harness.vacuous-verification-observed.v1"
+};
+//# sourceMappingURL=AgentEvent.js.map