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

package/dist/esm/Supervisor.d.ts

@@ -0,0 +1,719 @@
+/**
+ * The reading Jev takes of a run while it is still running.
+ *
+ * Every other control in this package reads a completion, or reads one fact
+ * the harness measured: a tree that never moved, a check that was narrowed, a
+ * frame that repeated itself. Each is exact, each fires late, and each is
+ * silent about the run between its brakes. A run that edits the wrong file
+ * for twenty frames, re-runs one failing check after every edit and never
+ * once claims to be done trips none of them until its budget is gone.
+ *
+ * So this module asks Jev about the run's *shape* rather than its sentence.
+ * One classifier, `supervisor/turn`, over a {@link Snapshot} the controller
+ * assembles from what it already holds: the task, the newest frames, and the
+ * counts the deterministic controls keep — read-only streak, repeat streak,
+ * mutations, checks run and failing, unanswered failures, demands spent. It
+ * re-derives none of them. Beside the run's state it carries the skills it has
+ * not called, the flows it has, and whether it can call `jev`. One Jev call per
+ * snapshot answers every question at once.
+ *
+ * Eleven questions are fixed. Five are about the run: whether it is
+ * thrashing, whether it is still on the task, whether its evidence is
+ * suspect, and whether it carries outdated or irrelevant context. Five are
+ * operational states a person would recognise in a colleague, each scored
+ * `none`, `mild` or `strong` against evidence the snapshot names, and
+ * `needs_help` is the one word a person is shown. The five about the run are
+ * the {@link triggers}: any one past its threshold crosses. Each monitor the
+ * host arms may add one boolean of its own, under {@link monitorPrefix}.
+ *
+ * Rows recalled from {@link Memory} are not asked about here. Beside each
+ * reading, the supervisor asks `Relevance` which of up to
+ * {@link recalledLimit} rows, none already shown to the run, are unnecessary
+ * for the task; the rest are shown at the next boundary as
+ * {@link recalledInsert} renders them, and a row is shown to a run once.
+ *
+ * It is a supervisor and not a brake: nothing here ends a run, refuses a
+ * completion, or decides anything on the cell loop's hot path. `CellTurn`
+ * offers each frame's snapshot to a one-slot sliding queue and continues; a
+ * forked fiber takes the newest snapshot, asks, journals what came back, and
+ * hands the monitors' values and any recalled rows to the *next* turn boundary,
+ * which decides there what the run is told. A reading that arrives after the boundary it was for is
+ * journaled and never delivered, and a snapshot the fiber never reached is
+ * dropped: the run is never told something about a frame two frames gone.
+ *
+ * It never falls back. A snapshot Jev could not read is journaled as
+ * {@link AgentEvent.SupervisorUnjudged} with the transport's own reason; it
+ * nudges nothing, and is never counted as a reading that
+ * found the run calm or on target. A host with no judge (`unconfigured`) is
+ * journaled once per streak rather than every frame; each reading still asks,
+ * so a judge connected mid-run is used at once. Nothing here is a default value: every
+ * level and every word on the settled event came back from the transport.
+ *
+ * What a reading says is delivered wherever the host holds a real judge
+ * (`CellTurn.Input.judged`), and only through a monitor that crossed and
+ * passed its gates; the text of the legacy nudge is {@link nudge}, which the
+ * `supervisor` lint monitor says. The offline replay of archived journals
+ * (`evals/swebench/lib/jev-replay.mjs`, which scores {@link triggers} itself
+ * rather than a copy of it) measures their precision. The verdict is
+ * journaled whenever an `Evaluator` is bound. The supervisor writes no
+ * memory: a run's transcript is mined once, at run end, by `@smthrs/agent`'s
+ * `MemoryMine`.
+ *
+ * @since 1.0.0-rc.0
+ */
+import * as Classifier from "@smthrs/model/Classifier";
+import type * as Evaluator from "@smthrs/model/Evaluator";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type * as AgentEvent from "./AgentEvent.ts";
+import * as Judgement from "./Judgement.ts";
+/**
+ * The most of one frame's cell, prose or prints the snapshot carries, in
+ * UTF-8 bytes. The head of a cell and the tail of its prints: a cell states
+ * its plan first and a runner states its verdict last.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const frameBytes = 1024;
+/**
+ * How many of the newest frames a snapshot carries.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const recentFrames = 3;
+/**
+ * The most rows one reading recalls from {@link Memory}.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const recalledLimit = 6;
+/**
+ * How long a run that ends with a reading in flight waits for it to settle
+ * and journal, in milliseconds. A reading still unanswered then is interrupted
+ * and journaled `supervisor-unjudged` with reason `interrupted`; the run never
+ * waits longer than this for its supervisor.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const closeGraceMs = 1500;
+/**
+ * At or above this probability of `thrashing`, the reading crosses.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const thrashingAt = 0.5;
+/**
+ * At or below this probability of `on_target`, the reading crosses.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const offTargetAt = 0.5;
+/**
+ * At or above this probability of `suspect`, the reading crosses.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const suspectAt = 0.5;
+/**
+ * At or above this probability of `outdated_context` or
+ * `irrelevant_context`, a judged run compacts at its next frame.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const contextAt = 0.5;
+/**
+ * The three rungs every operational-state question is scored on.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.0
+ */
+export declare const Level: Schema.Literals<readonly ["none", "mild", "strong"]>;
+/**
+ * The decoded form of {@link Level}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Level = typeof Level.Type;
+/**
+ * The rungs as the score question declares them, in order.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const levels: readonly ["none", "mild", "strong"];
+/**
+ * The one word a person is shown about a run.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.0
+ */
+export declare const Help: Schema.Literals<readonly ["none", "clarification", "permission", "stuck", "risky_action"]>;
+/**
+ * The decoded form of {@link Help}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Help = typeof Help.Type;
+/**
+ * The five operational states, in the order they are asked and journaled.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const emotions: readonly ["frustrated", "anxious", "scared", "confused", "confident"];
+/**
+ * One of {@link emotions}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Emotion = typeof emotions[number];
+/**
+ * One recent frame as the snapshot carries it: the cell the model wrote, the
+ * prose around it, what the cell printed, and how it ended.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.0
+ */
+export declare const Frame: Schema.Struct<{
+    readonly frame: Schema.Int;
+    readonly cell: Schema.String;
+    readonly prose: Schema.String;
+    readonly printed: Schema.String;
+    readonly transition: Schema.Literals<readonly ["continue", "complete", "park", "raised", "rejected"]>;
+    readonly mutated: Schema.Boolean;
+}>;
+/**
+ * The decoded form of {@link Frame}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Frame = typeof Frame.Type;
+/**
+ * The counts the deterministic controls keep, handed over as they stand.
+ *
+ * Every field is read off `CellTurn.State` or the frame's accounting and none
+ * is re-derived here: the supervisor is a reader of the harness's evidence,
+ * not a second measurer of it.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.0
+ */
+export declare const Signals: Schema.Struct<{
+    readonly frame: Schema.Int;
+    readonly maxFrames: Schema.Int;
+    readonly readOnlyFrames: Schema.Int;
+    readonly repeatFrames: Schema.Int;
+    readonly mutations: Schema.Int;
+    readonly remoteMutations: Schema.Int;
+    readonly treeMoved: Schema.Boolean;
+    readonly paths: Schema.Int;
+    readonly checksRun: Schema.Int;
+    readonly checksFailing: Schema.Int;
+    readonly failuresUnanswered: Schema.Int;
+    readonly callsFailed: Schema.Int;
+    readonly callsSettled: Schema.Int;
+    readonly narrowingDemands: Schema.Int;
+    readonly unmovedDemands: Schema.Int;
+    readonly unresolvedDemands: Schema.Int;
+    readonly claimDemands: Schema.Int;
+    readonly sufficiencyStated: Schema.Boolean;
+}>;
+/**
+ * The decoded form of {@link Signals}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Signals = typeof Signals.Type;
+/**
+ * One row recalled from memory.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.0
+ */
+export declare const Recalled: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly text: Schema.String;
+}>;
+/**
+ * The decoded form of {@link Recalled}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Recalled = typeof Recalled.Type;
+/**
+ * The most skills one snapshot offers.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const skillLimit = 12;
+/**
+ * The most of one skill's description a snapshot carries, in UTF-8 bytes.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const skillBytes = 256;
+/**
+ * The most distinct flow names {@link Snapshot} `called` carries.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const calledLimit = 64;
+/**
+ * One skill the run could read and has neither called nor read.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.0
+ */
+export declare const Skill: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.String;
+    readonly path: Schema.String;
+}>;
+/**
+ * The decoded form of {@link Skill}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Skill = typeof Skill.Type;
+/**
+ * One skill as a snapshot offers it: its description's head within
+ * {@link skillBytes}, wrapped as untrusted data.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const skill: (name: string, description: string, path: string) => Skill;
+/**
+ * Everything one supervisor reading is a reading of.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.0
+ */
+export declare const Snapshot: Schema.Struct<{
+    readonly task: Schema.String;
+    readonly frames: Schema.$Array<Schema.Struct<{
+        readonly frame: Schema.Int;
+        readonly cell: Schema.String;
+        readonly prose: Schema.String;
+        readonly printed: Schema.String;
+        readonly transition: Schema.Literals<readonly ["continue", "complete", "park", "raised", "rejected"]>;
+        readonly mutated: Schema.Boolean;
+    }>>;
+    readonly signals: Schema.Struct<{
+        readonly frame: Schema.Int;
+        readonly maxFrames: Schema.Int;
+        readonly readOnlyFrames: Schema.Int;
+        readonly repeatFrames: Schema.Int;
+        readonly mutations: Schema.Int;
+        readonly remoteMutations: Schema.Int;
+        readonly treeMoved: Schema.Boolean;
+        readonly paths: Schema.Int;
+        readonly checksRun: Schema.Int;
+        readonly checksFailing: Schema.Int;
+        readonly failuresUnanswered: Schema.Int;
+        readonly callsFailed: Schema.Int;
+        readonly callsSettled: Schema.Int;
+        readonly narrowingDemands: Schema.Int;
+        readonly unmovedDemands: Schema.Int;
+        readonly unresolvedDemands: Schema.Int;
+        readonly claimDemands: Schema.Int;
+        readonly sufficiencyStated: Schema.Boolean;
+    }>;
+    readonly skills: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.String;
+        readonly path: Schema.String;
+    }>>;
+    readonly called: Schema.$Array<Schema.String>;
+    readonly jevAvailable: Schema.Boolean;
+}>;
+/**
+ * The decoded form of {@link Snapshot}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Snapshot = typeof Snapshot.Type;
+/**
+ * The prefix of every question a monitor adds to a reading; the rest of the
+ * id is the monitor's own.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const monitorPrefix = "monitor_";
+/**
+ * The questions a snapshot's monitors add, by `monitor_<id>`.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type MonitorQuestions = Readonly<Record<`${typeof monitorPrefix}${string}`, Classifier.BooleanQuestion>>;
+declare const declare: (extra: MonitorQuestions) => Classifier.Classifier<"supervisor/turn", Schema.Struct<{
+    readonly task: Schema.String;
+    readonly frames: Schema.$Array<Schema.Struct<{
+        readonly frame: Schema.Int;
+        readonly cell: Schema.String;
+        readonly prose: Schema.String;
+        readonly printed: Schema.String;
+        readonly transition: Schema.Literals<readonly ["continue", "complete", "park", "raised", "rejected"]>;
+        readonly mutated: Schema.Boolean;
+    }>>;
+    readonly signals: Schema.Struct<{
+        readonly frame: Schema.Int;
+        readonly maxFrames: Schema.Int;
+        readonly readOnlyFrames: Schema.Int;
+        readonly repeatFrames: Schema.Int;
+        readonly mutations: Schema.Int;
+        readonly remoteMutations: Schema.Int;
+        readonly treeMoved: Schema.Boolean;
+        readonly paths: Schema.Int;
+        readonly checksRun: Schema.Int;
+        readonly checksFailing: Schema.Int;
+        readonly failuresUnanswered: Schema.Int;
+        readonly callsFailed: Schema.Int;
+        readonly callsSettled: Schema.Int;
+        readonly narrowingDemands: Schema.Int;
+        readonly unmovedDemands: Schema.Int;
+        readonly unresolvedDemands: Schema.Int;
+        readonly claimDemands: Schema.Int;
+        readonly sufficiencyStated: Schema.Boolean;
+    }>;
+    readonly skills: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.String;
+        readonly path: Schema.String;
+    }>>;
+    readonly called: Schema.$Array<Schema.String>;
+    readonly jevAvailable: Schema.Boolean;
+}>, {
+    readonly thrashing: Evaluator.BooleanQuestion;
+    readonly on_target: Evaluator.BooleanQuestion;
+    readonly suspect: Evaluator.BooleanQuestion;
+    readonly outdated_context: Evaluator.BooleanQuestion;
+    readonly irrelevant_context: Evaluator.BooleanQuestion;
+    readonly frustrated: Omit<Evaluator.ScoreQuestion, "criteria"> & {
+        readonly criteria: readonly ["none", "mild", "strong"];
+    };
+    readonly anxious: Omit<Evaluator.ScoreQuestion, "criteria"> & {
+        readonly criteria: readonly ["none", "mild", "strong"];
+    };
+    readonly scared: Omit<Evaluator.ScoreQuestion, "criteria"> & {
+        readonly criteria: readonly ["none", "mild", "strong"];
+    };
+    readonly confused: Omit<Evaluator.ScoreQuestion, "criteria"> & {
+        readonly criteria: readonly ["none", "mild", "strong"];
+    };
+    readonly confident: Omit<Evaluator.ScoreQuestion, "criteria"> & {
+        readonly criteria: readonly ["none", "mild", "strong"];
+    };
+    readonly needs_help: Omit<Evaluator.ChoiceQuestion, "criteria"> & {
+        readonly criteria: {
+            readonly none: "nothing; the run can carry on";
+            readonly clarification: "the task is ambiguous or contradicted and a person must say which reading is meant";
+            readonly permission: "the run is blocked on a permission or sandbox refusal a person can grant";
+            readonly stuck: "the run is not converging and a person should intervene";
+            readonly risky_action: "the run is about to do something destructive, irreversible or out of scope";
+        };
+    };
+}>;
+/**
+ * The classifier for a snapshot with these monitor questions.
+ *
+ * The fixed questions are the same for every snapshot and the monitors' follow
+ * them, so a snapshot with no monitor questions asks the eleven fixed
+ * questions and no others. Declared once per set of monitor ids, and again
+ * when a monitor id asks a different question, because the digest is the
+ * canonical hash of the questions and the journal names it.
+ *
+ * @category classifiers
+ * @since 1.0.0-rc.0
+ */
+export declare const classifierFor: (extra: MonitorQuestions) => ReturnType<typeof declare>;
+/**
+ * The classifier over a bare snapshot: the eleven fixed questions and no
+ * monitor booleans. Its id is the id every shape shares.
+ *
+ * @category classifiers
+ * @since 1.0.0-rc.0
+ */
+export declare const classifier: Classifier.Classifier<"supervisor/turn", Schema.Struct<{
+    readonly task: Schema.String;
+    readonly frames: Schema.$Array<Schema.Struct<{
+        readonly frame: Schema.Int;
+        readonly cell: Schema.String;
+        readonly prose: Schema.String;
+        readonly printed: Schema.String;
+        readonly transition: Schema.Literals<readonly ["continue", "complete", "park", "raised", "rejected"]>;
+        readonly mutated: Schema.Boolean;
+    }>>;
+    readonly signals: Schema.Struct<{
+        readonly frame: Schema.Int;
+        readonly maxFrames: Schema.Int;
+        readonly readOnlyFrames: Schema.Int;
+        readonly repeatFrames: Schema.Int;
+        readonly mutations: Schema.Int;
+        readonly remoteMutations: Schema.Int;
+        readonly treeMoved: Schema.Boolean;
+        readonly paths: Schema.Int;
+        readonly checksRun: Schema.Int;
+        readonly checksFailing: Schema.Int;
+        readonly failuresUnanswered: Schema.Int;
+        readonly callsFailed: Schema.Int;
+        readonly callsSettled: Schema.Int;
+        readonly narrowingDemands: Schema.Int;
+        readonly unmovedDemands: Schema.Int;
+        readonly unresolvedDemands: Schema.Int;
+        readonly claimDemands: Schema.Int;
+        readonly sufficiencyStated: Schema.Boolean;
+    }>;
+    readonly skills: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.String;
+        readonly path: Schema.String;
+    }>>;
+    readonly called: Schema.$Array<Schema.String>;
+    readonly jevAvailable: Schema.Boolean;
+}>, {
+    readonly thrashing: Evaluator.BooleanQuestion;
+    readonly on_target: Evaluator.BooleanQuestion;
+    readonly suspect: Evaluator.BooleanQuestion;
+    readonly outdated_context: Evaluator.BooleanQuestion;
+    readonly irrelevant_context: Evaluator.BooleanQuestion;
+    readonly frustrated: Omit<Evaluator.ScoreQuestion, "criteria"> & {
+        readonly criteria: readonly ["none", "mild", "strong"];
+    };
+    readonly anxious: Omit<Evaluator.ScoreQuestion, "criteria"> & {
+        readonly criteria: readonly ["none", "mild", "strong"];
+    };
+    readonly scared: Omit<Evaluator.ScoreQuestion, "criteria"> & {
+        readonly criteria: readonly ["none", "mild", "strong"];
+    };
+    readonly confused: Omit<Evaluator.ScoreQuestion, "criteria"> & {
+        readonly criteria: readonly ["none", "mild", "strong"];
+    };
+    readonly confident: Omit<Evaluator.ScoreQuestion, "criteria"> & {
+        readonly criteria: readonly ["none", "mild", "strong"];
+    };
+    readonly needs_help: Omit<Evaluator.ChoiceQuestion, "criteria"> & {
+        readonly criteria: {
+            readonly none: "nothing; the run can carry on";
+            readonly clarification: "the task is ambiguous or contradicted and a person must say which reading is meant";
+            readonly permission: "the run is blocked on a permission or sandbox refusal a person can grant";
+            readonly stuck: "the run is not converging and a person should intervene";
+            readonly risky_action: "the run is about to do something destructive, irreversible or out of scope";
+        };
+    };
+}>;
+/**
+ * What one evaluation came back with, decoded.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface Reading {
+    readonly thrashing: number;
+    readonly onTarget: number;
+    readonly suspect: number;
+    readonly outdatedContext: number;
+    readonly irrelevantContext: number;
+    readonly emotions: Readonly<Record<Emotion, Level>>;
+    readonly needsHelp: Help;
+    /** The probability of each monitor question asked, by monitor id. */
+    readonly monitors: Readonly<Record<string, number>>;
+    readonly latencyMs: number;
+    readonly usage?: Evaluator.Usage | undefined;
+    /** What was asked and what came back, for `decision-settled`. */
+    readonly asked: {
+        readonly digest: string;
+        readonly questions: Classifier.Questions;
+        readonly state: Schema.Json;
+        readonly answers: Readonly<Record<string, AgentEvent.DecisionAnswer>>;
+    };
+}
+/**
+ * Asks Jev about one snapshot, and the monitor questions `extra` adds.
+ *
+ * Fails, typed, whenever an answer could not be obtained: no evaluator bound,
+ * a transport refusal, a deadline, an answer that does not decode. There is
+ * no reading of a snapshot Jev did not read.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const read: (snapshot: Snapshot, extra: MonitorQuestions) => Effect.Effect<Reading, Judgement.Unjudged>;
+/**
+ * The memory a supervisor reads rows from, and the run-end transcript miner
+ * writes accepted facts to.
+ *
+ * A port, so this package needs no memory store: the production composition
+ * adapts `@smthrs/memory` to it, and a test binds a recording double. The
+ * default is {@link memoryNone}, which recalls nothing and writes nothing.
+ *
+ * @category services
+ * @since 1.0.0-rc.0
+ */
+export interface Memory {
+    /** Whether anything is behind this port; false is the default. */
+    readonly bound: boolean;
+    /** Rows relevant to the query, most relevant first, bounded by the caller. */
+    readonly recall: (query: string, limit: number) => Effect.Effect<ReadonlyArray<Recalled>, MemoryFailure>;
+    /**
+     * Writes one accepted fact. A store that refuses it fails typed, and the
+     * writer journals `supervisor-memory-failed` and carries on.
+     */
+    readonly remember: (text: string) => Effect.Effect<void, MemoryFailure>;
+}
+/**
+ * What a {@link Memory} fails with: the store's own account, safe to journal.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface MemoryFailure {
+    readonly detail: string;
+}
+/**
+ * A memory with nothing behind it.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const memoryNone: Memory;
+/**
+ * The {@link Memory} reference, defaulting to {@link memoryNone}.
+ *
+ * @category services
+ * @since 1.0.0-rc.0
+ */
+export declare const Memory: Context.Reference<Memory>;
+/**
+ * The five triggers a reading fires, by name, each with the inequality that
+ * fires it. The one rule: the `supervisor` lint monitor crosses on it,
+ * {@link nudge} names from it, {@link compacting} reads its context triggers,
+ * and the offline replay scores it, so they cannot drift apart.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const triggers: {
+    readonly thrashing: (reading: Triggerable) => boolean;
+    readonly off_target: (reading: Triggerable) => boolean;
+    readonly suspect: (reading: Triggerable) => boolean;
+    readonly outdated_context: (reading: Triggerable) => boolean;
+    readonly irrelevant_context: (reading: Triggerable) => boolean;
+};
+/**
+ * The fields of a {@link Reading} the triggers read.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Triggerable = Pick<Reading, "thrashing" | "onTarget" | "suspect" | "outdatedContext" | "irrelevantContext">;
+/**
+ * One of {@link triggers}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Trigger = keyof typeof triggers;
+/**
+ * The triggers one reading fires, in declaration order.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const triggered: (reading: Triggerable) => ReadonlyArray<Trigger>;
+/**
+ * The triggers that compact the run's context instead of nudging it.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const contextTriggers: readonly ["outdated_context", "irrelevant_context"];
+/**
+ * One of {@link contextTriggers}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type ContextTrigger = typeof contextTriggers[number];
+/**
+ * Whether one reading crosses: any trigger but a context one fires. A context
+ * trigger compacts the run's context at the next frame instead; see
+ * {@link compacting}.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const crosses: (reading: Triggerable) => boolean;
+/**
+ * The context triggers one reading fires, in declaration order: why a judged
+ * run that is sent this reading compacts at its next frame.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const compacting: (reading: Triggerable) => ReadonlyArray<ContextTrigger>;
+/**
+ * The nudge a crossed reading puts in front of the run, naming its evidence.
+ *
+ * Concise on purpose, and built from counts rather than from the model's
+ * prose: what the run is told is what the harness measured, and the reading's
+ * probabilities say only which measurements to name.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const nudge: (snapshot: Snapshot, reading: Reading) => string;
+/**
+ * Renders one recalled row as the run reads it.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const recalledInsert: (row: Recalled) => string;
+/**
+ * The head of a frame's cell or prose, bounded by {@link frameBytes}.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const head: (text: string) => string;
+/**
+ * The newest {@link frameBytes} of a frame's prints.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const tail: (text: string) => string;
+/**
+ * What the model wrote around its cell: the reply with every fenced cell
+ * removed. The anxiety question reads it, and so does the run-end
+ * transcript miner.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const prose: (text: string) => string;
+export {};
+//# sourceMappingURL=Supervisor.d.ts.map