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

package/dist/esm/VacuousVerification.d.ts

@@ -0,0 +1,237 @@
+/**
+ * The proof that was already true before anything changed.
+ *
+ * **This control is not wired into `CellTurn`. Nothing in a production run
+ * reads it, and no run is told anything by it.** The module, this suite and
+ * `AgentEvent.VacuousVerificationObserved` are kept intact so it can be
+ * measured on its own, in its own wave, against the contract text r92
+ * measured. Everything below describes what it does when an arm turns it on.
+ *
+ * **Its input no longer exists.** {@link stored} reads the reserved
+ * `verification` key out of the durable state a cell filed by hand, and the
+ * filing surface was deleted on 2026-08-24: `Cell.Continue.state` decodes and
+ * is populated by nothing. An arm that re-wires this module reads nothing until
+ * it first decides where a realm run declares its verification — a name bound
+ * in the realm, a print, or a new field — so the wave that turns this back on
+ * carries that decision with it. {@link stored} is left reading `Schema.Json`
+ * because that decision has not been made and the r90–r96 journals it can be
+ * replayed against are still filing journals.
+ *
+ * It was live for exactly one wave. the r93 wave report reads
+ * the result off the 45 journals, and the reason it is off is that the wave
+ * cannot price it:
+ *
+ * - It fired **twice in 45 journals**, and on neither of the instances the
+ *   diagnosis or the replay predicted. `django__django-14351`, the run it was
+ *   written for, resolved that wave with **no observation on its journal at
+ *   all** — so the row it was built to close was closed by something else, and
+ *   two prompt rules landed in the same round.
+ * - `sympy__sympy-13878` is the firing that worked: told at frame 1 that its
+ *   stored check was already green, the run replaced it, spent seventeen more
+ *   frames on a different proof, and resolved — cheaper and in fewer frames
+ *   than any earlier wave.
+ * - `django__django-15732` is the firing that did not. The observation landed
+ *   on frame 7, which is the frame that made the correct edit. On frame 8 the
+ *   run made a second edit that rewrote the enclosing block and restored the
+ *   first edit's text **byte for byte**. Both edits reported `mutated: true`
+ *   on an `observed` basis, the final tree equalled the base, and the captured
+ *   diff was zero bytes. The instance had resolved in r90, r91 and r92; it is
+ *   the wave's only empty patch.
+ *
+ * Nothing in this module's contract asks a run to revert, and one instance is
+ * not a mechanism. But it is the first evidence that a fact delivered on the
+ * `invalidProbe` channel can be read by a run as an instruction to retreat,
+ * and the one consequential firing in the wave preceded the wave's only
+ * revert-to-empty-patch. Two firings is not a rate. Turning this back on is a
+ * wave of its own — this control alone, on r92's contract text, with
+ * `django__django-15732` and `sympy__sympy-13878` as the rows to read — and
+ * not a change that rides along with another.
+ *
+ * A run is asked to store the check it verified with as
+ * `state.verification: { flow, input }` and to re-run that exact check after
+ * its edit. Nothing in that rule says the check ever failed. A run may pick a
+ * command that was green on the tree it was handed, watch it stay green after
+ * the edit, and complete citing a before-and-after that never moved.
+ *
+ * That is not a hypothetical either. `django__django-14351` lost a baseline
+ * verdict across two waves, and its journal says why in two rows: the same
+ * verification script — one content digest — ran at sequence 260, before any
+ * frame of the run had changed a byte, and exited 0; then again at sequence
+ * 582, after the edit, and exited 0. Both readings are true and the pair
+ * establishes nothing. The contract already says the words — *a command
+ * becomes evidence only once you have SEEN it fail on the unmodified tree* —
+ * and the run stored a check it had watched pass there instead.
+ *
+ * The harness can see this without re-running anything. It already records
+ * every check a frame ran, whether that check reported a passing exit status,
+ * and how many frames of the run had changed the workspace when it ran. A
+ * check that passed while that count was zero, in a frame that itself changed
+ * nothing, is a check that passed on the tree the run was handed. If a later
+ * cell stores that exact call as its verification, the run is standing on a
+ * proof that cannot distinguish its own change from no change at all.
+ *
+ * One reading takes it back: the same call reported *failing* over that same
+ * untouched tree. Then the run has watched the red the contract asks for, and a
+ * second, green reading of it before any edit says the command is unsteady
+ * rather than that the run never saw it fail. Such a signature is never
+ * admitted, so the observation can only ever be made about a check this run has
+ * no pre-edit failure for.
+ *
+ * So the harness says so, and does nothing else. It is delivered on the
+ * `invalidProbe` channel — the one place the loop already contradicts a
+ * reading of a result the flow itself could see through — because it is the
+ * same class of fact: a result that reads identically on a broken tree and on
+ * a fixed one. No bounce, no demand, no cap: the run continues on the
+ * transition it wrote. A harness that refused the completion would be grading
+ * the agent's work with its own, which is the line every control in this
+ * package holds, and it would be refusing on a *guess* — a check that was
+ * green before an edit is the right check for a task whose bug is a crash the
+ * command never reached, and only the run knows which it has.
+ *
+ * It fires at most once per distinct verification input. The fact is about a
+ * call, the record only grows, and a run that has been told and stored the
+ * same check again has decided, which is its decision to make.
+ *
+ * @since 0.1.0
+ */
+import { Schema } from "effect";
+import type * as NarrowedCheck from "./NarrowedCheck.ts";
+/**
+ * How many pristine-tree passes one run carries forward.
+ *
+ * The ledger is durable controller state, so it is bounded, and it only ever
+ * grows while the run has changed nothing: the moment a frame edits, nothing
+ * new is admitted. The longest graded run made 43 calls across 24 frames with
+ * its first edit at frame 3, so sixteen covers every check a run takes before
+ * it commits to a change. A run that outlives the bound forgets its oldest
+ * passes first, which can cost the observation and can never invent one.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const retained = 16;
+declare const Pass_base: Schema.Class<Pass, Schema.Struct<{
+    /** The flow the call named. */
+    readonly flow: Schema.String;
+    /** The call's identity, as the controller's own signature names it. */
+    readonly signature: Schema.String;
+    /** The call's input as it was written, clipped, for the observation to quote. */
+    readonly label: Schema.String;
+}>, {}>;
+/**
+ * One check that passed over the tree the run was handed.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare class Pass extends Pass_base {
+}
+/**
+ * The pristine-tree passes this run carries, oldest first and bounded.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Ledger: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<typeof Pass>>, never>;
+/**
+ * The pristine-tree passes this run carries, oldest first and bounded.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Ledger = typeof Ledger.Type;
+/**
+ * Records one frame's passing checks, but only while the tree is untouched.
+ *
+ * Three conditions, and all of them are refusals rather than readings. `epoch`
+ * is the run's own count of frames that changed the workspace *before* this
+ * one, so a non-zero epoch means some earlier frame already edited and a pass
+ * taken now says nothing about the tree the run was handed. `stable` is the
+ * same question inside one frame: a frame's calls are not ordered against its
+ * edits in anything the harness records, so a check from a frame that also
+ * edited might have run on either side of it. `Sufficiency` refuses the same
+ * stamp for the same reason; see `NarrowedCheck` `Check` `stable`.
+ *
+ * `failed` is the third, and it is the one that keeps the observation from
+ * contradicting the record it is read off. A check the run has already watched
+ * *fail* over the tree it was handed is a check the run has done the contract's
+ * work on, whatever it printed the second time: it is red on the unmodified
+ * tree, and a later green reading of it at the same epoch says the command is
+ * unsteady, not that the run never saw it fail. Telling such a run its proof
+ * was "already green" would be a sentence its own journal refutes, so the
+ * signature is refused on the way in and evicted if an earlier pass already put
+ * it there. The list is the run's failing-check ledger read at epoch zero —
+ * `Sufficiency` already keeps it, stamped with the epoch each failure was
+ * watched in — so nothing new is measured or stored for this. That ledger is
+ * bounded, so a run with more distinct pre-edit failures than `Sufficiency`
+ * retains can forget one; forgetting can cost the refusal and can never invent
+ * a pass.
+ *
+ * A repeated signature keeps its first entry rather than taking a second slot:
+ * the entries are all the same tree, so re-running one adds no information and
+ * re-stamping it would only cost the ledger its oldest genuinely distinct pass.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export declare const remember: (ledger: Ledger, options: {
+    /** The checks this frame ran. */
+    readonly frame: ReadonlyArray<NarrowedCheck.Check>;
+    /** Frames that had changed the workspace before this one. */
+    readonly epoch: number;
+    /** Signatures this run has watched fail over the tree it was handed. */
+    readonly failed: ReadonlyArray<string>;
+}) => Ledger;
+/**
+ * The `{ flow, input }` pair a cell stored as its verification, if it stored
+ * one this module can read.
+ *
+ * The reserved key and its two fields are the contract's own words, and this
+ * is the only thing the controller ever reads out of `agentState`. Anything
+ * else under `verification` — a string, a bare command, a shape the contract
+ * does not describe — reads as absent, because a state key the harness cannot
+ * parse is the cell's own memory and not a claim about evidence.
+ *
+ * @category conversions
+ * @since 0.1.0
+ */
+export declare const stored: (agentState: Schema.Json) => {
+    readonly flow: string;
+    readonly input: Schema.Json;
+} | undefined;
+/**
+ * Finds the pristine-tree pass a stored verification is standing on.
+ *
+ * The match is on the controller's own call signature, so it is the *exact*
+ * `{ flow, input }` the contract asks a run to reuse — a broadened or narrowed
+ * command is a different call and is not this failure.
+ *
+ * `stated` is the run's record of what it has already been told, which is what
+ * keeps this to one sentence per distinct input.
+ *
+ * @category conversions
+ * @since 0.1.0
+ */
+export declare const find: (options: {
+    /** Checks that passed over the tree the run was handed, oldest first. */
+    readonly ledger: Ledger;
+    /** The signature of the `{ flow, input }` the cell stored. */
+    readonly signature: string;
+    /** Verification signatures this run has already been told about. */
+    readonly stated: ReadonlyArray<string>;
+}) => Pass | undefined;
+/**
+ * States that the stored proof was already green before anything changed.
+ *
+ * It quotes the call, says what the record establishes about it, and names the
+ * two things the run may do — keep it, having a reason, or go find a reading
+ * that can move. Neither is refused and neither is graded: a check that was
+ * green before the edit is the right check for a task whose bug is a crash the
+ * command never reached, and only the run knows whether that is this task.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const observation: (found: Pass) => string;
+export {};
+//# sourceMappingURL=VacuousVerification.d.ts.map

package/dist/esm/VacuousVerification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VacuousVerification.d.ts","sourceRoot":"","sources":["../../src/VacuousVerification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,OAAO,KAAK,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAExD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;;IASxB,+BAA+B;;IAE/B,uEAAuE;;IAEvE,iFAAiF;;;AAXnF;;;;;GAKG;AACH,qBAAa,IAAK,SAAQ,SAOxB;CAAG;AAEL;;;;;GAKG;AACH,eAAO,MAAM,MAAM,iGAGlB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,QAAQ,GACnB,QAAQ,MAAM,EACd,SAAS;IACP,iCAAiC;IACjC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;IAClD,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACvC,KACA,MAeF,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,GACjB,YAAY,MAAM,CAAC,IAAI,KACtB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAA;CAAE,GAAG,SAQ3D,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS;IAC5B,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,8DAA8D;IAC9D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACvC,KAAG,IAAI,GAAG,SAGV,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,IAAI,KAAG,MAM+gB,CAAA"}

package/dist/esm/VacuousVerification.js

@@ -0,0 +1,245 @@
+/**
+ * The proof that was already true before anything changed.
+ *
+ * **This control is not wired into `CellTurn`. Nothing in a production run
+ * reads it, and no run is told anything by it.** The module, this suite and
+ * `AgentEvent.VacuousVerificationObserved` are kept intact so it can be
+ * measured on its own, in its own wave, against the contract text r92
+ * measured. Everything below describes what it does when an arm turns it on.
+ *
+ * **Its input no longer exists.** {@link stored} reads the reserved
+ * `verification` key out of the durable state a cell filed by hand, and the
+ * filing surface was deleted on 2026-08-24: `Cell.Continue.state` decodes and
+ * is populated by nothing. An arm that re-wires this module reads nothing until
+ * it first decides where a realm run declares its verification — a name bound
+ * in the realm, a print, or a new field — so the wave that turns this back on
+ * carries that decision with it. {@link stored} is left reading `Schema.Json`
+ * because that decision has not been made and the r90–r96 journals it can be
+ * replayed against are still filing journals.
+ *
+ * It was live for exactly one wave. the r93 wave report reads
+ * the result off the 45 journals, and the reason it is off is that the wave
+ * cannot price it:
+ *
+ * - It fired **twice in 45 journals**, and on neither of the instances the
+ *   diagnosis or the replay predicted. `django__django-14351`, the run it was
+ *   written for, resolved that wave with **no observation on its journal at
+ *   all** — so the row it was built to close was closed by something else, and
+ *   two prompt rules landed in the same round.
+ * - `sympy__sympy-13878` is the firing that worked: told at frame 1 that its
+ *   stored check was already green, the run replaced it, spent seventeen more
+ *   frames on a different proof, and resolved — cheaper and in fewer frames
+ *   than any earlier wave.
+ * - `django__django-15732` is the firing that did not. The observation landed
+ *   on frame 7, which is the frame that made the correct edit. On frame 8 the
+ *   run made a second edit that rewrote the enclosing block and restored the
+ *   first edit's text **byte for byte**. Both edits reported `mutated: true`
+ *   on an `observed` basis, the final tree equalled the base, and the captured
+ *   diff was zero bytes. The instance had resolved in r90, r91 and r92; it is
+ *   the wave's only empty patch.
+ *
+ * Nothing in this module's contract asks a run to revert, and one instance is
+ * not a mechanism. But it is the first evidence that a fact delivered on the
+ * `invalidProbe` channel can be read by a run as an instruction to retreat,
+ * and the one consequential firing in the wave preceded the wave's only
+ * revert-to-empty-patch. Two firings is not a rate. Turning this back on is a
+ * wave of its own — this control alone, on r92's contract text, with
+ * `django__django-15732` and `sympy__sympy-13878` as the rows to read — and
+ * not a change that rides along with another.
+ *
+ * A run is asked to store the check it verified with as
+ * `state.verification: { flow, input }` and to re-run that exact check after
+ * its edit. Nothing in that rule says the check ever failed. A run may pick a
+ * command that was green on the tree it was handed, watch it stay green after
+ * the edit, and complete citing a before-and-after that never moved.
+ *
+ * That is not a hypothetical either. `django__django-14351` lost a baseline
+ * verdict across two waves, and its journal says why in two rows: the same
+ * verification script — one content digest — ran at sequence 260, before any
+ * frame of the run had changed a byte, and exited 0; then again at sequence
+ * 582, after the edit, and exited 0. Both readings are true and the pair
+ * establishes nothing. The contract already says the words — *a command
+ * becomes evidence only once you have SEEN it fail on the unmodified tree* —
+ * and the run stored a check it had watched pass there instead.
+ *
+ * The harness can see this without re-running anything. It already records
+ * every check a frame ran, whether that check reported a passing exit status,
+ * and how many frames of the run had changed the workspace when it ran. A
+ * check that passed while that count was zero, in a frame that itself changed
+ * nothing, is a check that passed on the tree the run was handed. If a later
+ * cell stores that exact call as its verification, the run is standing on a
+ * proof that cannot distinguish its own change from no change at all.
+ *
+ * One reading takes it back: the same call reported *failing* over that same
+ * untouched tree. Then the run has watched the red the contract asks for, and a
+ * second, green reading of it before any edit says the command is unsteady
+ * rather than that the run never saw it fail. Such a signature is never
+ * admitted, so the observation can only ever be made about a check this run has
+ * no pre-edit failure for.
+ *
+ * So the harness says so, and does nothing else. It is delivered on the
+ * `invalidProbe` channel — the one place the loop already contradicts a
+ * reading of a result the flow itself could see through — because it is the
+ * same class of fact: a result that reads identically on a broken tree and on
+ * a fixed one. No bounce, no demand, no cap: the run continues on the
+ * transition it wrote. A harness that refused the completion would be grading
+ * the agent's work with its own, which is the line every control in this
+ * package holds, and it would be refusing on a *guess* — a check that was
+ * green before an edit is the right check for a task whose bug is a crash the
+ * command never reached, and only the run knows which it has.
+ *
+ * It fires at most once per distinct verification input. The fact is about a
+ * call, the record only grows, and a run that has been told and stored the
+ * same check again has decided, which is its decision to make.
+ *
+ * @since 0.1.0
+ */
+import { Schema } from "effect";
+import * as Effect from "effect/Effect";
+/**
+ * How many pristine-tree passes one run carries forward.
+ *
+ * The ledger is durable controller state, so it is bounded, and it only ever
+ * grows while the run has changed nothing: the moment a frame edits, nothing
+ * new is admitted. The longest graded run made 43 calls across 24 frames with
+ * its first edit at frame 3, so sixteen covers every check a run takes before
+ * it commits to a change. A run that outlives the bound forgets its oldest
+ * passes first, which can cost the observation and can never invent one.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export const retained = 16;
+/**
+ * One check that passed over the tree the run was handed.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export class Pass extends Schema.Class("flows/harness/VacuousVerification/Pass")({
+    /** The flow the call named. */
+    flow: Schema.String,
+    /** The call's identity, as the controller's own signature names it. */
+    signature: Schema.String,
+    /** The call's input as it was written, clipped, for the observation to quote. */
+    label: Schema.String
+}) {
+}
+/**
+ * The pristine-tree passes this run carries, oldest first and bounded.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const Ledger = Schema.Array(Pass).pipe(Schema.withConstructorDefault(Effect.succeed([])), Schema.withDecodingDefaultKey(Effect.succeed([])));
+/**
+ * Records one frame's passing checks, but only while the tree is untouched.
+ *
+ * Three conditions, and all of them are refusals rather than readings. `epoch`
+ * is the run's own count of frames that changed the workspace *before* this
+ * one, so a non-zero epoch means some earlier frame already edited and a pass
+ * taken now says nothing about the tree the run was handed. `stable` is the
+ * same question inside one frame: a frame's calls are not ordered against its
+ * edits in anything the harness records, so a check from a frame that also
+ * edited might have run on either side of it. `Sufficiency` refuses the same
+ * stamp for the same reason; see `NarrowedCheck` `Check` `stable`.
+ *
+ * `failed` is the third, and it is the one that keeps the observation from
+ * contradicting the record it is read off. A check the run has already watched
+ * *fail* over the tree it was handed is a check the run has done the contract's
+ * work on, whatever it printed the second time: it is red on the unmodified
+ * tree, and a later green reading of it at the same epoch says the command is
+ * unsteady, not that the run never saw it fail. Telling such a run its proof
+ * was "already green" would be a sentence its own journal refutes, so the
+ * signature is refused on the way in and evicted if an earlier pass already put
+ * it there. The list is the run's failing-check ledger read at epoch zero —
+ * `Sufficiency` already keeps it, stamped with the epoch each failure was
+ * watched in — so nothing new is measured or stored for this. That ledger is
+ * bounded, so a run with more distinct pre-edit failures than `Sufficiency`
+ * retains can forget one; forgetting can cost the refusal and can never invent
+ * a pass.
+ *
+ * A repeated signature keeps its first entry rather than taking a second slot:
+ * the entries are all the same tree, so re-running one adds no information and
+ * re-stamping it would only cost the ledger its oldest genuinely distinct pass.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export const remember = (ledger, options) => {
+    const refused = new Set(options.failed);
+    const kept = new Map(ledger.filter((entry) => !refused.has(entry.signature)).map((entry) => [entry.signature, entry]));
+    if (options.epoch === 0) {
+        for (const check of options.frame) {
+            if (!check.passing || !check.stable)
+                continue;
+            if (refused.has(check.signature))
+                continue;
+            if (kept.has(check.signature))
+                continue;
+            kept.set(check.signature, new Pass({ flow: check.flow, signature: check.signature, label: check.label }));
+        }
+    }
+    const distinct = [...kept.values()];
+    return distinct.slice(Math.max(0, distinct.length - retained));
+};
+/**
+ * The `{ flow, input }` pair a cell stored as its verification, if it stored
+ * one this module can read.
+ *
+ * The reserved key and its two fields are the contract's own words, and this
+ * is the only thing the controller ever reads out of `agentState`. Anything
+ * else under `verification` — a string, a bare command, a shape the contract
+ * does not describe — reads as absent, because a state key the harness cannot
+ * parse is the cell's own memory and not a claim about evidence.
+ *
+ * @category conversions
+ * @since 0.1.0
+ */
+export const stored = (agentState) => {
+    if (agentState === null || typeof agentState !== "object" || Array.isArray(agentState))
+        return undefined;
+    const declared = agentState["verification"];
+    if (declared === null || declared === undefined || typeof declared !== "object" || Array.isArray(declared)) {
+        return undefined;
+    }
+    const { flow, input } = declared;
+    return typeof flow === "string" && input !== undefined ? { flow, input } : undefined;
+};
+/**
+ * Finds the pristine-tree pass a stored verification is standing on.
+ *
+ * The match is on the controller's own call signature, so it is the *exact*
+ * `{ flow, input }` the contract asks a run to reuse — a broadened or narrowed
+ * command is a different call and is not this failure.
+ *
+ * `stated` is the run's record of what it has already been told, which is what
+ * keeps this to one sentence per distinct input.
+ *
+ * @category conversions
+ * @since 0.1.0
+ */
+export const find = (options) => {
+    if (options.stated.includes(options.signature))
+        return undefined;
+    return options.ledger.find((entry) => entry.signature === options.signature);
+};
+/**
+ * States that the stored proof was already green before anything changed.
+ *
+ * It quotes the call, says what the record establishes about it, and names the
+ * two things the run may do — keep it, having a reason, or go find a reading
+ * that can move. Neither is refused and neither is graded: a check that was
+ * green before the edit is the right check for a task whose bug is a crash the
+ * command never reached, and only the run knows whether that is this task.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export const observation = (found) => `Vacuous verification — the check you stored as \`state.verification\` is a check this run already watched PASS on the unmodified tree, before any frame of it changed a byte.
+
+- the stored check: ${found.flow} ${found.label}
+- what this run saw it do on the tree it was handed: exit 0
+
+Re-running it after your edit cannot show your change did anything: it reads identically on a broken tree and on a fixed one, so a green result after the edit is the same green result as before it. A proof is a check you have watched FAIL and then watched pass. Nothing is being asked of you and nothing has been refused — if this command is genuinely the only observable the task has, keep it and say in your output that it never failed and why. Otherwise the reading you still need is one that is red right now. This notice is written once per distinct verification.`;
+//# sourceMappingURL=VacuousVerification.js.map

package/dist/esm/VacuousVerification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VacuousVerification.js","sourceRoot":"","sources":["../../src/VacuousVerification.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The proof that was already true before anything changed.\n *\n * **This control is not wired into `CellTurn`. Nothing in a production run\n * reads it, and no run is told anything by it.** The module, this suite and\n * `AgentEvent.VacuousVerificationObserved` are kept intact so it can be\n * measured on its own, in its own wave, against the contract text r92\n * measured. Everything below describes what it does when an arm turns it on.\n *\n * **Its input no longer exists.** {@link stored} reads the reserved\n * `verification` key out of the durable state a cell filed by hand, and the\n * filing surface was deleted on 2026-08-24: `Cell.Continue.state` decodes and\n * is populated by nothing. An arm that re-wires this module reads nothing until\n * it first decides where a realm run declares its verification — a name bound\n * in the realm, a print, or a new field — so the wave that turns this back on\n * carries that decision with it. {@link stored} is left reading `Schema.Json`\n * because that decision has not been made and the r90–r96 journals it can be\n * replayed against are still filing journals.\n *\n * It was live for exactly one wave. the r93 wave report reads\n * the result off the 45 journals, and the reason it is off is that the wave\n * cannot price it:\n *\n * - It fired **twice in 45 journals**, and on neither of the instances the\n *   diagnosis or the replay predicted. `django__django-14351`, the run it was\n *   written for, resolved that wave with **no observation on its journal at\n *   all** — so the row it was built to close was closed by something else, and\n *   two prompt rules landed in the same round.\n * - `sympy__sympy-13878` is the firing that worked: told at frame 1 that its\n *   stored check was already green, the run replaced it, spent seventeen more\n *   frames on a different proof, and resolved — cheaper and in fewer frames\n *   than any earlier wave.\n * - `django__django-15732` is the firing that did not. The observation landed\n *   on frame 7, which is the frame that made the correct edit. On frame 8 the\n *   run made a second edit that rewrote the enclosing block and restored the\n *   first edit's text **byte for byte**. Both edits reported `mutated: true`\n *   on an `observed` basis, the final tree equalled the base, and the captured\n *   diff was zero bytes. The instance had resolved in r90, r91 and r92; it is\n *   the wave's only empty patch.\n *\n * Nothing in this module's contract asks a run to revert, and one instance is\n * not a mechanism. But it is the first evidence that a fact delivered on the\n * `invalidProbe` channel can be read by a run as an instruction to retreat,\n * and the one consequential firing in the wave preceded the wave's only\n * revert-to-empty-patch. Two firings is not a rate. Turning this back on is a\n * wave of its own — this control alone, on r92's contract text, with\n * `django__django-15732` and `sympy__sympy-13878` as the rows to read — and\n * not a change that rides along with another.\n *\n * A run is asked to store the check it verified with as\n * `state.verification: { flow, input }` and to re-run that exact check after\n * its edit. Nothing in that rule says the check ever failed. A run may pick a\n * command that was green on the tree it was handed, watch it stay green after\n * the edit, and complete citing a before-and-after that never moved.\n *\n * That is not a hypothetical either. `django__django-14351` lost a baseline\n * verdict across two waves, and its journal says why in two rows: the same\n * verification script — one content digest — ran at sequence 260, before any\n * frame of the run had changed a byte, and exited 0; then again at sequence\n * 582, after the edit, and exited 0. Both readings are true and the pair\n * establishes nothing. The contract already says the words — *a command\n * becomes evidence only once you have SEEN it fail on the unmodified tree* —\n * and the run stored a check it had watched pass there instead.\n *\n * The harness can see this without re-running anything. It already records\n * every check a frame ran, whether that check reported a passing exit status,\n * and how many frames of the run had changed the workspace when it ran. A\n * check that passed while that count was zero, in a frame that itself changed\n * nothing, is a check that passed on the tree the run was handed. If a later\n * cell stores that exact call as its verification, the run is standing on a\n * proof that cannot distinguish its own change from no change at all.\n *\n * One reading takes it back: the same call reported *failing* over that same\n * untouched tree. Then the run has watched the red the contract asks for, and a\n * second, green reading of it before any edit says the command is unsteady\n * rather than that the run never saw it fail. Such a signature is never\n * admitted, so the observation can only ever be made about a check this run has\n * no pre-edit failure for.\n *\n * So the harness says so, and does nothing else. It is delivered on the\n * `invalidProbe` channel — the one place the loop already contradicts a\n * reading of a result the flow itself could see through — because it is the\n * same class of fact: a result that reads identically on a broken tree and on\n * a fixed one. No bounce, no demand, no cap: the run continues on the\n * transition it wrote. A harness that refused the completion would be grading\n * the agent's work with its own, which is the line every control in this\n * package holds, and it would be refusing on a *guess* — a check that was\n * green before an edit is the right check for a task whose bug is a crash the\n * command never reached, and only the run knows which it has.\n *\n * It fires at most once per distinct verification input. The fact is about a\n * call, the record only grows, and a run that has been told and stored the\n * same check again has decided, which is its decision to make.\n *\n * @since 0.1.0\n */\n\nimport { Schema } from \"effect\"\nimport * as Effect from \"effect/Effect\"\nimport type * as NarrowedCheck from \"./NarrowedCheck.ts\"\n\n/**\n * How many pristine-tree passes one run carries forward.\n *\n * The ledger is durable controller state, so it is bounded, and it only ever\n * grows while the run has changed nothing: the moment a frame edits, nothing\n * new is admitted. The longest graded run made 43 calls across 24 frames with\n * its first edit at frame 3, so sixteen covers every check a run takes before\n * it commits to a change. A run that outlives the bound forgets its oldest\n * passes first, which can cost the observation and can never invent one.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const retained = 16\n\n/**\n * One check that passed over the tree the run was handed.\n *\n * @category models\n * @since 0.1.0\n */\nexport class Pass extends Schema.Class<Pass>(\"flows/harness/VacuousVerification/Pass\")({\n  /** The flow the call named. */\n  flow: Schema.String,\n  /** The call's identity, as the controller's own signature names it. */\n  signature: Schema.String,\n  /** The call's input as it was written, clipped, for the observation to quote. */\n  label: Schema.String\n}) {}\n\n/**\n * The pristine-tree passes this run carries, oldest first and bounded.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Ledger = Schema.Array(Pass).pipe(\n  Schema.withConstructorDefault(Effect.succeed<ReadonlyArray<Pass>>([])),\n  Schema.withDecodingDefaultKey(Effect.succeed<ReadonlyArray<Pass>>([]))\n)\n\n/**\n * The pristine-tree passes this run carries, oldest first and bounded.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Ledger = typeof Ledger.Type\n\n/**\n * Records one frame's passing checks, but only while the tree is untouched.\n *\n * Three conditions, and all of them are refusals rather than readings. `epoch`\n * is the run's own count of frames that changed the workspace *before* this\n * one, so a non-zero epoch means some earlier frame already edited and a pass\n * taken now says nothing about the tree the run was handed. `stable` is the\n * same question inside one frame: a frame's calls are not ordered against its\n * edits in anything the harness records, so a check from a frame that also\n * edited might have run on either side of it. `Sufficiency` refuses the same\n * stamp for the same reason; see `NarrowedCheck` `Check` `stable`.\n *\n * `failed` is the third, and it is the one that keeps the observation from\n * contradicting the record it is read off. A check the run has already watched\n * *fail* over the tree it was handed is a check the run has done the contract's\n * work on, whatever it printed the second time: it is red on the unmodified\n * tree, and a later green reading of it at the same epoch says the command is\n * unsteady, not that the run never saw it fail. Telling such a run its proof\n * was \"already green\" would be a sentence its own journal refutes, so the\n * signature is refused on the way in and evicted if an earlier pass already put\n * it there. The list is the run's failing-check ledger read at epoch zero —\n * `Sufficiency` already keeps it, stamped with the epoch each failure was\n * watched in — so nothing new is measured or stored for this. That ledger is\n * bounded, so a run with more distinct pre-edit failures than `Sufficiency`\n * retains can forget one; forgetting can cost the refusal and can never invent\n * a pass.\n *\n * A repeated signature keeps its first entry rather than taking a second slot:\n * the entries are all the same tree, so re-running one adds no information and\n * re-stamping it would only cost the ledger its oldest genuinely distinct pass.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const remember = (\n  ledger: Ledger,\n  options: {\n    /** The checks this frame ran. */\n    readonly frame: ReadonlyArray<NarrowedCheck.Check>\n    /** Frames that had changed the workspace before this one. */\n    readonly epoch: number\n    /** Signatures this run has watched fail over the tree it was handed. */\n    readonly failed: ReadonlyArray<string>\n  }\n): Ledger => {\n  const refused = new Set(options.failed)\n  const kept = new Map(\n    ledger.filter((entry) => !refused.has(entry.signature)).map((entry) => [entry.signature, entry])\n  )\n  if (options.epoch === 0) {\n    for (const check of options.frame) {\n      if (!check.passing || !check.stable) continue\n      if (refused.has(check.signature)) continue\n      if (kept.has(check.signature)) continue\n      kept.set(check.signature, new Pass({ flow: check.flow, signature: check.signature, label: check.label }))\n    }\n  }\n  const distinct = [...kept.values()]\n  return distinct.slice(Math.max(0, distinct.length - retained))\n}\n\n/**\n * The `{ flow, input }` pair a cell stored as its verification, if it stored\n * one this module can read.\n *\n * The reserved key and its two fields are the contract's own words, and this\n * is the only thing the controller ever reads out of `agentState`. Anything\n * else under `verification` — a string, a bare command, a shape the contract\n * does not describe — reads as absent, because a state key the harness cannot\n * parse is the cell's own memory and not a claim about evidence.\n *\n * @category conversions\n * @since 0.1.0\n */\nexport const stored = (\n  agentState: Schema.Json\n): { readonly flow: string; readonly input: Schema.Json } | undefined => {\n  if (agentState === null || typeof agentState !== \"object\" || Array.isArray(agentState)) return undefined\n  const declared = (agentState as Record<string, Schema.Json>)[\"verification\"]\n  if (declared === null || declared === undefined || typeof declared !== \"object\" || Array.isArray(declared)) {\n    return undefined\n  }\n  const { flow, input } = declared as Record<string, Schema.Json>\n  return typeof flow === \"string\" && input !== undefined ? { flow, input } : undefined\n}\n\n/**\n * Finds the pristine-tree pass a stored verification is standing on.\n *\n * The match is on the controller's own call signature, so it is the *exact*\n * `{ flow, input }` the contract asks a run to reuse — a broadened or narrowed\n * command is a different call and is not this failure.\n *\n * `stated` is the run's record of what it has already been told, which is what\n * keeps this to one sentence per distinct input.\n *\n * @category conversions\n * @since 0.1.0\n */\nexport const find = (options: {\n  /** Checks that passed over the tree the run was handed, oldest first. */\n  readonly ledger: Ledger\n  /** The signature of the `{ flow, input }` the cell stored. */\n  readonly signature: string\n  /** Verification signatures this run has already been told about. */\n  readonly stated: ReadonlyArray<string>\n}): Pass | undefined => {\n  if (options.stated.includes(options.signature)) return undefined\n  return options.ledger.find((entry) => entry.signature === options.signature)\n}\n\n/**\n * States that the stored proof was already green before anything changed.\n *\n * It quotes the call, says what the record establishes about it, and names the\n * two things the run may do — keep it, having a reason, or go find a reading\n * that can move. Neither is refused and neither is graded: a check that was\n * green before the edit is the right check for a task whose bug is a crash the\n * command never reached, and only the run knows whether that is this task.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const observation = (found: Pass): string =>\n  `Vacuous verification — the check you stored as \\`state.verification\\` is a check this run already watched PASS on the unmodified tree, before any frame of it changed a byte.\n\n- the stored check: ${found.flow} ${found.label}\n- what this run saw it do on the tree it was handed: exit 0\n\nRe-running it after your edit cannot show your change did anything: it reads identically on a broken tree and on a fixed one, so a green result after the edit is the same green result as before it. A proof is a check you have watched FAIL and then watched pass. Nothing is being asked of you and nothing has been refused — if this command is genuinely the only observable the task has, keep it and say in your output that it never failed and why. Otherwise the reading you still need is one that is red right now. This notice is written once per distinct verification.`\n"]}

package/dist/esm/VariablesPanel.d.ts

@@ -0,0 +1,117 @@
+/**
+ * The variables panel: what the realm holds, stated every frame.
+ *
+ * A run's memory is not a JSON document the cell filed — it is the set of names
+ * the realm is holding, and the model can only act on what the prompt says about
+ * them. This is what the prompt says.
+ *
+ * Every line is a name, its type, one *cheap* size, and when it was last bound.
+ * Nothing here is serialized whole: a panel that stringified every global would
+ * pay the heap for it every frame, and the value the model wants is already
+ * under the name the panel prints.
+ *
+ * Freshness is derived from the cheap size, which is what makes the panel cost
+ * nothing. A binding rewritten to a value of the same type and the same size —
+ * a 40-character string replaced by a different 40-character string — reads as
+ * unchanged and keeps its stamp. That bound is stated rather than hidden: the
+ * panel is a roster, and the run's own prints are what say a value moved.
+ *
+ * @since 0.1.0
+ */
+import { Schema } from "effect";
+/**
+ * How many names the panel prints before it starts counting instead.
+ *
+ * Sixty-four is the same order as `CallLedger` `bound` and well above what a
+ * round near par binds: the five golfed instances hold between 6 and 21 names
+ * at their last frame. A run past the bound is shown its most recently bound
+ * names and told how many older ones it still holds.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const bound = 64;
+declare const Binding_base: Schema.Class<Binding, Schema.Struct<{
+    readonly name: Schema.String;
+    /**
+     * The name's JavaScript type, `unset` for a name a throw left unassigned, or
+     * `unreadable` for one whose value the probe could not even read — a throwing
+     * accessor, a proxy that refuses its own keys. The two are named apart because
+     * they say different things: one name holds nothing, the other holds something
+     * that will not be looked at.
+     */
+    readonly type: Schema.String;
+    /** One cheap measure of the value, already rendered; empty when there is none. */
+    readonly size: Schema.String;
+}>, {}>;
+/**
+ * One name the realm holds, with the cheap facts a probe can read off it.
+ *
+ * `size` is already rendered by the probe — a string's length, an array's
+ * length, an object's key count, a function's arity, a number or boolean by
+ * value — because the value itself never crosses the realm boundary.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare class Binding extends Binding_base {
+}
+declare const Stamp_base: Schema.Class<Stamp, Schema.Struct<{
+    readonly name: Schema.String;
+    readonly type: Schema.String;
+    readonly size: Schema.String;
+    /** The frame whose cell last changed the binding's cheap shape. */
+    readonly frame: Schema.Int;
+    /** The frame whose cell first bound the name. */
+    readonly since: Schema.Int;
+}>, {}>;
+/**
+ * One name the realm holds, with the frames that first and last bound it.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare class Stamp extends Stamp_base {
+}
+/**
+ * Every name the realm holds, with the frames that bound it.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const Ledger: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<typeof Stamp>>, never>;
+/**
+ * Every name the realm holds, with the frames that bound it.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Ledger = typeof Ledger.Type;
+/**
+ * Re-stamps the panel against the bindings a frame closed on.
+ *
+ * A name whose type and size are unchanged keeps both of its frames, so the
+ * panel says when a binding last moved rather than that every name was touched
+ * again. A name the realm no longer reports is dropped: a `var` global cannot
+ * be deleted, so the only way a name leaves the probe's answer is the realm
+ * being rebuilt, and a roster that outlived its realm would be a lie.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export declare const stamp: (known: Ledger, bindings: ReadonlyArray<Binding>, frame: number) => Ledger;
+/**
+ * Renders the panel for one frame's prompt.
+ *
+ * `frame` is the frame whose cell just ran, which is what `new` and `changed`
+ * are relative to.
+ *
+ * @category conversions
+ * @since 0.1.0
+ */
+export declare const render: (options: {
+    readonly ledger: Ledger;
+    readonly frame: number;
+}) => string;
+export {};
+//# sourceMappingURL=VariablesPanel.d.ts.map

package/dist/esm/VariablesPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VariablesPanel.d.ts","sourceRoot":"","sources":["../../src/VariablesPanel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAKvC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,KAAK,KAAK,CAAA;;;IAcrB;;;;;;OAMG;;IAEH,kFAAkF;;;AApBpF;;;;;;;;;GASG;AACH,qBAAa,OAAQ,SAAQ,YAY3B;CAAG;;;;;IAYH,mEAAmE;;IAEnE,iDAAiD;;;AAZnD;;;;;GAKG;AACH,qBAAa,KAAM,SAAQ,UAQzB;CAAG;AAEL;;;;;GAKG;AACH,eAAO,MAAM,MAAM,kGAGlB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,EAAE,UAAU,aAAa,CAAC,OAAO,CAAC,EAAE,OAAO,MAAM,KAAG,MAWtF,CAAA;AAUD;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB,KAAG,MAqBH,CAAA"}