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

package/dist/cjs/internal/frame.d.ts

@@ -0,0 +1,463 @@
+/**
+ * The decisions one controller frame takes from what it measured.
+ *
+ * `CellTurn` seals a model step and runs a cell, and both need a model, a
+ * sandbox and an engine. What the frame decides from the result needs none of
+ * them: what it did to the run's ledgers, whether a completion is handed back,
+ * and which interventions the next frame is handed are functions of the state
+ * the frame opened on and the facts it measured. Each phase here returns a
+ * value, events included, instead of writing a variable a later exit reads, so
+ * each one is read and tested without running a frame.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+import { ModelRequest } from "@smthrs/model";
+import type * as Evaluator from "@smthrs/model/Evaluator";
+import { Effect, Option, type Schema } from "effect";
+import * as AgentEvent from "../AgentEvent.ts";
+import type { State } from "../CellTurn.ts";
+import * as CompletionClaim from "../CompletionClaim.ts";
+import type * as ContextWindow from "../ContextWindow.ts";
+import type * as EngineLike from "../EngineLike.ts";
+import type * as HarnessError from "../HarnessError.ts";
+import * as NarrowedCheck from "../NarrowedCheck.ts";
+import * as TruncatedOutput from "../TruncatedOutput.ts";
+import * as VariablesPanel from "../VariablesPanel.ts";
+/**
+ * The fields of controller state one step changes; everything else is carried.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type StateChanges = Partial<ConstructorParameters<typeof State>[0]>;
+/**
+ * Whether the frame budget leaves a frame after this one.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const hasNextFrame: (state: State) => boolean;
+/**
+ * Whether a completion can be handed back: a frame is left to answer in, and
+ * spending it cannot end the run at the read-only cap. See `judgeCompletion`.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const handBackRoom: (state: State, readOnlyFrames: number) => boolean;
+/**
+ * One call a cell made this frame, as the frame's accounting reads it.
+ *
+ * Every call the frame settles is remembered so a raise can hand the model its
+ * partial work. Without this, one uncaught throw discarded the frame's reads
+ * and the next cell re-did them — often raising the same way again. Prime
+ * Agent's tool errors return stdout-so-far plus the traceback for exactly this
+ * reason.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export interface ObservedCall {
+    readonly flow: string;
+    readonly ok: boolean;
+    readonly summary: string;
+    /** Where this call lands in the run's ledger, so a salvage line can name it. */
+    readonly ordinal: number;
+    /**
+     * Whether the call reached the engine declaring a write, which is what
+     * breaks a read-only run. A call the boundary refused is not one: it
+     * declared a write and performed none.
+     */
+    readonly mutates: boolean;
+    /**
+     * Whether the write behind `mutates` was measured on a tree the host's
+     * workspace walk does not cover: the result carried the reserved `mutated`
+     * key, which `bash` sets by fingerprinting a container's working directory
+     * either side of the command. The read-only cap counts such a write like
+     * any other; the unmoved-tree demand and the claim judge need to know that
+     * the host digests holding still says nothing about it.
+     */
+    readonly remote: boolean;
+    /**
+     * What this invocation asked for, as `CellTurn`'s `signatureOf` names it,
+     * with the tree it asked about folded in.
+     *
+     * The repeat ledger reads this one, because the identical command against
+     * a pinned tree and against the live tree are two different questions and
+     * a run that asks both has learned twice.
+     */
+    readonly signature: string;
+    /**
+     * The same, with the tree left out: what the call asked, of whatever
+     * tree.
+     *
+     * The check ledgers read this one, because `Sufficiency` matches a
+     * failing reading against the passing reading that answered it, and the
+     * whole shape this surface exists for takes those two readings of one
+     * command over two different trees. Keyed on the tree they would never
+     * meet. For a call on the live tree the two are the same string, so
+     * nothing that existed before checkpoints re-keys.
+     */
+    readonly subject: string;
+    /** The checkpoint this call ran against, when it named one. */
+    readonly at: string | undefined;
+    /** What this invocation asked for, verbatim, for the narrowing ledger. */
+    readonly input: Schema.Json;
+    /** What the call resolved with, verbatim, for the call ledger's digest. */
+    readonly value: Schema.Json;
+    /** What the flow said about a failure, for the call ledger's digest. */
+    readonly message: string | undefined;
+    /** What the flow said about its own failure, when it said it ran nothing. */
+    readonly invalidProbe: {
+        readonly reason: string;
+        readonly message: string;
+    } | undefined;
+    /**
+     * Whether the result reported a failing exit status about its subject.
+     *
+     * A call that declared an invalid probe is never failing here, whatever
+     * its exit status: the flow itself said the failure was about the command
+     * and not about the code, so the result is not a statement about the tree
+     * at all. See `UnresolvedFailure` `failed`.
+     */
+    readonly failing: boolean;
+    /**
+     * Whether the result reported a passing exit status about its subject.
+     *
+     * Not the negation of `failing`: a flow that reports no exit status is
+     * neither, and `Sufficiency` needs the difference between a check that
+     * passed and a call that never checked anything. An invalid probe is
+     * neither either, for the same reason it is never failing — the flow
+     * itself said the result is not a statement about the tree.
+     */
+    readonly passing: boolean;
+}
+/**
+ * The frame's own record of what it did to the world, computed once and
+ * carried out through every exit that continues the run.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export interface Accounting {
+    /** Whether the frame changed the workspace, by declaration or by measurement. */
+    readonly mutated: boolean;
+    /** The journal's record of how that answer was reached. */
+    readonly observed: AgentEvent.MutationObserved;
+    /**
+     * The digest the frame closed on, when its closing measurement covered the
+     * tree; empty otherwise, which makes every demand that reads it inert.
+     */
+    readonly workspaceDigest: string;
+    /** This frame's readings of the live tree, in the order they settled. */
+    readonly frameChecks: ReadonlyArray<NarrowedCheck.Check>;
+    /**
+     * Every call the frame settled, verbatim, in the order they settled.
+     *
+     * The ledgers above are what a run carries forward, and they are bounded
+     * and lossy on purpose: a durable check entry keeps a clipped label and two
+     * exit-status flags, never a result. This is the one place the whole result
+     * of a call still exists, and it exists for one frame. `CompletionClaim`
+     * quotes the last check out of it; nothing else reads it.
+     */
+    readonly calls: ReadonlyArray<ObservedCall>;
+    /** The cell the frame ran, verbatim, for `FailedCall`. */
+    readonly source: string;
+    /** The frame's own broken probes, stated once for whichever exit it takes. */
+    readonly probeNotice: string | undefined;
+    /**
+     * Every state field the frame's measurements settle.
+     *
+     * A continuing exit states only what it changes on top of these, so a field
+     * measured here is carried whichever exit the frame leaves by. The read-only
+     * streak is one of them: when each exit passed it by hand, the frame's
+     * accounting was only as complete as the exit that remembered to.
+     */
+    readonly facts: StateChanges & Required<Pick<StateChanges, "readOnlyFrames" | "repeatFrames" | "checks" | "failures" | "mutations" | "remoteMutations">> & Required<Pick<StateChanges, "openingDigest" | "callLedger" | "reported">>;
+}
+/**
+ * What one frame that ran a cell did to the run's ledgers.
+ *
+ * Read off the calls the cell made and the two workspace measurements either
+ * side of them, and nothing else: no model, sandbox or engine is consulted, so
+ * a replayed frame accounts exactly as its original attempt did.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const account: (options: {
+    /** The state the frame opened on. */
+    readonly state: State;
+    /** Every call the cell made, in the order they settled. */
+    readonly calls: ReadonlyArray<ObservedCall>;
+    /** The workspace before the frame's calls. */
+    readonly opened: Option.Option<EngineLike.Observation>;
+    /** The workspace after them. */
+    readonly closed: Option.Option<EngineLike.Observation>;
+    /** Ids of the trees the frame pinned, oldest first. */
+    readonly minted: ReadonlyArray<string>;
+    /** What the realm holds after the frame, for the variables panel. */
+    readonly bindings: ReadonlyArray<VariablesPanel.Binding>;
+    /** Output the run has been handed as a fragment, this frame's included. */
+    readonly captures: ReadonlyArray<TruncatedOutput.Capture>;
+    /** The cell the frame ran, verbatim; omitted reads as a cell that inspects nothing. */
+    readonly source?: string | undefined;
+}) => Accounting;
+/**
+ * One completion handed back, and what handing it back costs.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export interface CompletionDemand {
+    /** The control event that names the demand in the journal. */
+    readonly event: AgentEvent.UnmovedDemanded | AgentEvent.UnresolvedDemanded | AgentEvent.FailedCallDemanded | AgentEvent.UnobservedDemanded | AgentEvent.NarrowedDemanded | AgentEvent.NarrowOnlyDemanded | AgentEvent.ClaimDemanded;
+    /** The in-frame observation the next frame answers. */
+    readonly note: string;
+    /**
+     * Whether the answer this demand takes away may come back as the run's
+     * answer when the frame budget runs out; see `CellTurn.budgetMessage`.
+     *
+     * True for the measured demands except `FailedCall`, whose answer was
+     * written over a call that failed. `UnobservedCall` keeps its answer: the
+     * brake reads the source, not the sentence, so an answer it refused may be
+     * right, and a run that ends on the budget should end on it rather than on
+     * a bare notice. Each of the others says the record is
+     * missing a fact, not that the sentence is wrong, so a run that spends its
+     * last frame and never completes again is better served by the answer it
+     * wrote than by a bare budget notice.
+     *
+     * For the claim brake it depends on which of its two heights fired, because
+     * they mean different things. A reading between `CompletionClaim.unsupportedAt`
+     * and `CompletionClaim.inventedAt` is a bounce that would let the same
+     * sentence stand if the run re-stated it, so discarding it against an
+     * exhausted budget would throw away an answer the brake was never going to
+     * refuse. A reading at or above `inventedAt` is one the brake *would* refuse:
+     * restoring that sentence on the budget notice is how one measured run turned
+     * a bounced "the tests pass" into its final answer with a `stop` finish over a
+     * repository whose test exits 1. A bounce that cannot be re-judged must not be
+     * undone by the budget. See `CompletionClaim.unrecorded`.
+     */
+    readonly keeps: boolean;
+    /** The cap the demand spends. */
+    readonly spent: StateChanges;
+}
+/**
+ * What judging one completion produced: at most one demand, and at most one
+ * reading to journal whichever way it went.
+ *
+ * `observed` exists for the sixth brake alone. The five before it are derived
+ * from measurements the journal already carries, so a grader recomputes them
+ * and there is nothing to write when they stay silent; the claim brake asks a
+ * model, and a reading nobody records is a reading nobody can grade. It is set
+ * only where that brake ran and issued no demand — when it does demand, the
+ * same event travels on `demand.event`, so exactly one `claim-demanded` is
+ * written per evaluation.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export interface CompletionJudgement {
+    /** The claim brake's reading, when it ran and issued no demand. */
+    readonly observed: AgentEvent.ClaimDemanded | undefined;
+    /** The demand that hands the completion back, when one of the six issued. */
+    readonly demand: CompletionDemand | undefined;
+    /**
+     * The failure the run ends with when the claim brake read a claim the
+     * evidence does not support and no bounce was left to spend. It travels on
+     * the judgement rather than as the effect's own failure so the caller
+     * journals `observed` first: a reading that ends a run is the one a grader
+     * most needs, and an effect that failed would take it with it.
+     */
+    readonly unproven: HarnessError.HarnessError | undefined;
+    /**
+     * The claim brake's whole decision, whenever it read one: the evidence, the
+     * questions and the answers behind the three numbers `observed` or the
+     * demand carries. Set on every way a reading comes out, because the record a
+     * reader reopens a decision from is needed most for the one that acted.
+     */
+    readonly decision: AgentEvent.DecisionSettled | undefined;
+    /** The per-sentence decision, when the brake asked for one. */
+    readonly sentenceDecision?: AgentEvent.DecisionSettled | undefined;
+    /**
+     * Whether the completion reported its own work unfinished, when the verdict
+     * asked. See `UnfinishedWork`.
+     */
+    readonly unfinishedDecision?: AgentEvent.DecisionSettled | undefined;
+}
+/**
+ * The prose the harness itself put in front of the run as its task.
+ *
+ * The `instructions` segments of the prefix zone and nothing else: `Agent`
+ * writes the task there, while the cell contract, the flow catalog, the
+ * project's instructions and the host's memory go in as `system` and the
+ * transcript goes in the tail. So this is the closest thing the controller holds to the task as
+ * the person stated it, and it cannot pick up a sentence the model wrote.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const taskText: (window: ContextWindow.ContextWindow) => string;
+/**
+ * Whether a `complete` transition stands, or which demand hands it back.
+ *
+ * The completion's own evidence, judged once per demand. A run gets exactly
+ * one frame wrong for free — the last one — and five things can be wrong with
+ * it, four of them read off measurements the controller already took, under
+ * four caps:
+ *
+ * 1. `UnmovedTree`: the tree it is completing on is the tree it opened on, so
+ *    there is no change for any evidence to be about. This one is not read
+ *    alone: a question is answered on the tree it was asked on, so it is
+ *    issued only where the claim brake (5) found the completion unsupported,
+ *    and then in the brake's place;
+ * 2. `UnresolvedFailure`: a check over this exact tree reported a failing exit
+ *    status and the run answered it with a different reading of the same
+ *    subject rather than with the check itself;
+ * 3. `NarrowedCheck.find`: this frame's check repeats an earlier, broader one
+ *    and adds conditions to it, run after a change the broader one never saw;
+ * 4. `NarrowedCheck.findOnly`: the check this frame ended on is the run's only
+ *    reading of what it names — nothing broader was ever taken, so there was
+ *    no broader check for (3) to find — and it carries a condition the run
+ *    itself added, one taught neither by the prefix this harness wrote nor by
+ *    the run's own other checks.
+ *
+ * Demands 3 and 4 share one cap. They are two readings of one question —
+ * whether the evidence covers what it looks like it covers — and a run that
+ * answers either has answered the question; a second bounce would be the loop
+ * asking it twice in different words.
+ *
+ * 5. `CompletionClaim`: the last brake and the only one that is not a
+ *    measurement. The four above have said nothing, which means the tree
+ *    moved, no check was stepped around, and whatever the run checked it
+ *    checked whole — and none of that reads the sentence the run wrote. So
+ *    the claim, the task, the tree fact, every check the run took over this
+ *    tree and the verbatim result of the last one go to Jev, and a claim that
+ *    reports a command or a result none of that records hands the frame back
+ *    from a cap of its own. It is last because it is the only one
+ *    that costs a request, and because a run one of the four already named
+ *    has a demand to answer: asking a model to add a second one would hand
+ *    the frame two questions. It never falls back: a completion Jev could
+ *    not judge — no evaluator on the host, a refusal, a deadline, an answer
+ *    that does not decode — fails the turn as `completion_unjudged` carrying
+ *    the reason, the way `read_only_cap` ends a run, rather than standing.
+ *    `Evaluator` is therefore a required service of this function and of
+ *    every turn above it.
+ *
+ * The fifth is the one that is read on *every* completion, and the three
+ * things below that take a demand away do not take the reading away. The
+ * others are recomputable from the journal, so skipping them costs a grader
+ * nothing and a skipped one lets a completion stand that the truth bar still
+ * judges. This one is a sentence being checked against the record, it is what
+ * the server banner and the operator docs promise happens to every completion,
+ * and the run's answer is the product. So when there is no bounce left to
+ * spend — the cap is used up, or none of the room below exists — a claim that
+ * reports work the record does not record ends the run as `claim_unproven`
+ * instead of standing. That is the shape `read_only_cap` already uses, and it
+ * is the only shape that keeps the promise: a cap that stops at the bounce
+ * means the second identical claim is accepted unread, which is what a live
+ * run did.
+ *
+ * The verdict is narrower than the bounce, and that is the whole of what this
+ * lane changed. A completion the brake merely finds thin is handed back once
+ * and then stands; only a completion at `CompletionClaim.inventedAt` — a
+ * sentence reporting a command or a result nothing in the run produced — is
+ * refused. Arming the verdict on "is the task done" instead killed roughly one
+ * honest run in four, including five question-shaped turns in a row and one
+ * live CI dispatch whose planted bug was fixed. `CompletionClaim`'s header
+ * carries the eighteen-state corpus that measured it.
+ *
+ * A thin completion that stands is still not a success when it says so
+ * itself. Where the verdict is reached on a completion read as not done, one
+ * more question asks whether the completion reports its own work unfinished,
+ * and one that does ends the run as `completion_incomplete` quoting that
+ * report, so a host never settles "I could not finish" as a completed run.
+ * See `UnfinishedWork`.
+ *
+ * At most one is named, in that order, because they are in descending order of
+ * how fundamental the missing thing is: there is nothing to check, then the
+ * check said no, then the check said less than it looks like it said, then
+ * nothing in the record matches what the run said it did. Naming two at once
+ * would ask the run to answer a question it has not been given a frame for.
+ *
+ * The loop names what is missing and hands the frame back; it does not re-run
+ * anything, and it does not judge the answer that comes back.
+ *
+ * Asking costs the run a frame it can answer in, so a demand is issued only
+ * where that frame exists, and three separate things take it away (and leave
+ * the claim brake reading anyway, as above):
+ *
+ * - the frame budget, which has no frame left to spend, and turning a
+ *   completion into an exhausted budget would lose the run's answer to make a
+ *   point about it;
+ * - the read-only cap, which is the other budget that ends a run and ends it as
+ *   a typed failure carrying nothing. A run that changed nothing is exactly the
+ *   run `UnmovedTree` fires on, so a completion one frame short of twice the
+ *   cap would be bounced, spend that frame reading, and die as `read_only_cap`
+ *   with the answer it had already written discarded — a demand turning a
+ *   finished run into a failure, which is the one outcome none of these may
+ *   produce;
+ * - a demand this run has already answered. Each demand ends by promising that
+ *   what comes back next is the answer that stands, and three of them fire on
+ *   one transition, so the frame written to answer one is never judged by the
+ *   next. See `State.demandedFrame`.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const judgeCompletion: (state: State, accounting: Accounting, contextWindow: ContextWindow.ContextWindow, claim: string, read?: typeof CompletionClaim.read) => Effect.Effect<CompletionJudgement, HarnessError.HarnessError, Evaluator.Evaluator>;
+/**
+ * The interventions one ordinary continuing frame hands to the next.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export interface Discipline {
+    /** The control events that issue them, in journal order. */
+    readonly events: ReadonlyArray<AgentEvent.AgentEvent>;
+    /** The messages the next frame reads after the steering it was sent. */
+    readonly messages: ReadonlyArray<ModelRequest.Message>;
+    /** What issuing them changes on top of the frame's facts. */
+    readonly changes: StateChanges;
+}
+/**
+ * The read-only, repeat and sufficiency interventions for a frame that settled
+ * a `continue` transition and has a frame after it.
+ *
+ * The read-only intervention. At the cap the next frame is told, structurally,
+ * that it must write something or say why it cannot; a justification is typed
+ * data on the transition, is recorded, and buys a bounded quiet spell without
+ * resetting the counter that ends the run at twice the cap.
+ *
+ * A justification buys that spell only when it *answers* a demand this frame
+ * was handed. A justification volunteered by a frame nobody asked is recorded —
+ * it is a field on the transition and the journal writes the whole transition —
+ * and buys nothing. The two cannot be the same price, because the counter runs
+ * regardless of which one is written: a run that volunteers one every few
+ * frames used to renew the quiet spell before the streak could ever hand the
+ * demand out, so the demand was never issued, never journaled, and never got
+ * its one chance to redirect the run, while the hard stop at twice the cap —
+ * which no grace touches — killed the run anyway. Two SWE-bench waves lost
+ * `pydata__xarray-7393` exactly so: ten volunteered justifications, zero
+ * `read-only-demanded` events, and death at 24 frames against a cap of 12
+ * without the control ever speaking.
+ *
+ * The convergence intervention. It is journaled when it is *issued* rather than
+ * when the next frame answers it, because what answers it is the shape of that
+ * frame's calls — which the journal already writes one by one — and not a
+ * field on a transition the controller has to wait for. Issuing it restarts the
+ * count, so a run that keeps repeating is told once every `repeatCap` frames
+ * instead of every frame.
+ *
+ * The counterweight, and the only notice here that asks for nothing. It is
+ * written on the frame that completes the pair rather than at a completion,
+ * because its whole purpose is to reach a run that is still deciding whether to
+ * keep working — a run at its `complete` transition has already decided. See
+ * `Sufficiency`.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const discipline: (state: State, accounting: Accounting, justification: string | undefined) => Discipline;
+//# sourceMappingURL=frame.d.ts.map

package/dist/cjs/internal/frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.d.ts","sourceRoot":"","sources":["../../../src/internal/frame.ts"],"names":[],"mappings":"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"}