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

package/dist/esm/Sufficiency.d.ts

@@ -0,0 +1,195 @@
+/**
+ * The evidence that is already complete.
+ *
+ * Every armed control in this package pushes a run to do more. The read-only
+ * cap says nothing has been written. The repeat demand says nothing new has
+ * been learned. `UnmovedTree` says there is no change behind the completion,
+ * `UnresolvedFailure` says a failing check was stepped around, `NarrowedCheck`
+ * says the evidence is narrower than it looks. Five brakes and no accelerator,
+ * and the asymmetry is not free: on a graded benchmark the best rounds pay one
+ * frame re-checking work they had already proved and one more frame doing
+ * nothing but writing the completion, because nothing ever tells a careful run
+ * that it is finished. Two of the seventeen strokes those rounds spent over par
+ * are that, measured.
+ *
+ * Pure braking also produces compliance rather than work. The wave that armed
+ * the completion demands answered the read-only demand with a paragraph and no
+ * write, and answered the unmoved-tree demand with "no change is needed" and an
+ * empty patch. A control set that only ever says *not yet* teaches a run to
+ * write the sentence that makes the notice go away.
+ *
+ * This is the counterweight, and it is built out of what the controller already
+ * records. Three facts, in this order:
+ *
+ * 1. a check reported a failing exit status over a tree the run had not yet
+ *    changed;
+ * 2. the run changed the workspace after that;
+ * 3. the same check, or a broader one, reported a passing exit status after the
+ *    change.
+ *
+ * That is failing-before and passing-after over one subject, which is the whole
+ * of what the contract asks a run to hold before it completes. So the harness
+ * says so, once, in one sentence, and asks for nothing: the run may complete
+ * citing it or name what is still missing. It is an observation and not a
+ * demand — nothing is bounced, nothing is refused, no cap is spent — because a
+ * harness that decided a run was finished would be grading the agent's work
+ * with its own, which is the line every other control in this package holds.
+ *
+ * It reads no output and parses no runner. `exitCode` is the one wire key the
+ * controller already reads, `UnresolvedFailure` owns what it means, and the
+ * ordering comes from the run's own count of frames that changed the workspace.
+ *
+ * @since 0.1.0
+ */
+import { Schema } from "effect";
+import * as NarrowedCheck from "./NarrowedCheck.ts";
+/**
+ * How many distinct failing checks one run carries forward.
+ *
+ * The ledger is durable controller state, so it is bounded, and it holds only
+ * the checks that reported a failure — a small fraction of what a run runs. The
+ * longest graded run recorded nine of them across 42 frames, so sixteen covers
+ * a whole run with room to spare. A run that outlives the bound forgets its
+ * oldest failures first, which can cost the observation and can never invent
+ * one.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const retained = 16;
+declare const Failure_base: Schema.Class<Failure, 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 distinct terms of the call's input, sorted; see `NarrowedCheck` `terms`. */
+    readonly terms: Schema.$Array<Schema.String>;
+    /** The call's input as it was written, clipped, for the observation to quote. */
+    readonly label: Schema.String;
+    /**
+     * How many frames had changed the workspace when this check failed.
+     *
+     * The run's own count of mutating frames is the clock here, rather than a
+     * workspace digest, because the fact being established is an ordering — this
+     * failed, then something changed, then that passed — and a count is an
+     * ordering on any host, including one that measures nothing and knows only
+     * what its calls declared.
+     */
+    readonly epoch: Schema.Int;
+}>, {}>;
+/**
+ * One check that reported a failure, and where the run was when it did.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare class Failure extends Failure_base {
+}
+/**
+ * The failing checks this run carries, oldest first and bounded.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Ledger: Schema.withDecodingDefaultKey<Schema.withConstructorDefault<Schema.$Array<typeof Failure>>, never>;
+/**
+ * The failing checks this run carries, oldest first and bounded.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Ledger = typeof Ledger.Type;
+/**
+ * Records one frame's failing checks against the epoch it ran in.
+ *
+ * A check from a frame that also changed the workspace is dropped rather than
+ * recorded. A frame's calls are not ordered against its edits in anything the
+ * harness records, so such a check might have failed before the change or after
+ * it, and a failure stamped on the wrong side of an edit is exactly the false
+ * before-and-after this module must never manufacture. `UnresolvedFailure`
+ * refuses the same stamp for the same reason; see `NarrowedCheck` `Check`
+ * `stable`.
+ *
+ * A repeated signature moves to the newest position and restamps, so a check
+ * that failed again over a later tree is remembered where it last failed.
+ *
+ * @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;
+}) => Ledger;
+/**
+ * A failure this run has answered, and the check that answered it.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Sufficient {
+    /** The check that reported a failure before the run changed anything. */
+    readonly failed: Failure;
+    /** The check that reported a pass after it, over the changed tree. */
+    readonly passed: NarrowedCheck.Check;
+}
+/**
+ * Finds a failing-before, passing-after pair this frame has completed.
+ *
+ * Four conditions, each read off the run's own record:
+ *
+ * 0. no check of this frame reported a *failing* exit status. The sentence says
+ *    the evidence the contract asks for exists, and a frame that is looking at
+ *    a red check right now is a frame for which that reading is at best half
+ *    the record — a narrow probe going green while the broad check beside it
+ *    stays red is the exact shape that has lost one graded instance for six
+ *    consecutive waves. The harness will not pick the good half out of a frame
+ *    that holds both; it says nothing and lets the run finish reading. This
+ *    only ever suppresses the observation and can never manufacture one, and it
+ *    changes neither of the two frames that fire across the ten journals two
+ *    graded waves recorded;
+ * 1. some stable check of this frame reported a *passing* exit status — silence
+ *    is not a pass, and an unstable reading may precede this frame's edits.
+ *    Checkpoint-attributed readings are already stamped stable by `CellTurn`;
+ * 2. some remembered failure names the same flow and is the same call, or one
+ *    that check is broader than, as `NarrowedCheck` `narrows` reads "broader":
+ *    every term of the passing check is carried by the failing one, which added
+ *    conditions to it.
+ *    A broader reading passing is stronger evidence than the narrow one
+ *    passing, never weaker, so it is admitted;
+ * 3. the run changed the workspace between the two — the failure's epoch is
+ *    below the epoch this frame closes at.
+ *
+ * The broadest qualifying passing check wins — fewest terms, the least
+ * constrained question — so the sentence quotes the strongest evidence the run
+ * holds rather than the first one found. Ties go to the earliest-settled check.
+ * Among the failures that check answers, the most recent one wins, because it
+ * is the reading the run was working against most lately.
+ *
+ * @category conversions
+ * @since 0.1.0
+ */
+export declare const find: (options: {
+    /** Failing checks this run has remembered, oldest first. */
+    readonly ledger: Ledger;
+    /** The checks this frame ran, in the order they settled. */
+    readonly frame: ReadonlyArray<NarrowedCheck.Check>;
+    /** Frames that have changed the workspace, this one included. */
+    readonly epoch: number;
+}) => Sufficient | undefined;
+/**
+ * States that the run holds both halves of its own evidence.
+ *
+ * It quotes both readings and says what they establish, then names the two
+ * things the run may do with that — complete citing it, or say what is still
+ * missing — as equals. It asks for nothing and refuses nothing: the harness
+ * does not know whether the change is right, only that the evidence the
+ * contract asks for exists, and the sentence claims exactly that much.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const observation: (found: Sufficient) => string;
+export {};
+//# sourceMappingURL=Sufficiency.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Sufficiency.d.ts","sourceRoot":"","sources":["../../src/Sufficiency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEvC,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;;IASxB,+BAA+B;;IAE/B,uEAAuE;;IAEvE,mFAAmF;;IAEnF,iFAAiF;;IAEjF;;;;;;;;OAQG;;;AAvBL;;;;;GAKG;AACH,qBAAa,OAAQ,SAAQ,YAmB3B;CAAG;AAEL;;;;;GAKG;AACH,eAAO,MAAM,MAAM,oGAGlB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;;;;;;;;;;;;GAgBG;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;CACvB,KACA,MAkBF,CAAA;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAA;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS;IAC5B,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;IAClD,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB,KAAG,UAAU,GAAG,SAgBhB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,UAAU,KAAG,MAMqZ,CAAA"}

package/dist/esm/Sufficiency.js

@@ -0,0 +1,207 @@
+/**
+ * The evidence that is already complete.
+ *
+ * Every armed control in this package pushes a run to do more. The read-only
+ * cap says nothing has been written. The repeat demand says nothing new has
+ * been learned. `UnmovedTree` says there is no change behind the completion,
+ * `UnresolvedFailure` says a failing check was stepped around, `NarrowedCheck`
+ * says the evidence is narrower than it looks. Five brakes and no accelerator,
+ * and the asymmetry is not free: on a graded benchmark the best rounds pay one
+ * frame re-checking work they had already proved and one more frame doing
+ * nothing but writing the completion, because nothing ever tells a careful run
+ * that it is finished. Two of the seventeen strokes those rounds spent over par
+ * are that, measured.
+ *
+ * Pure braking also produces compliance rather than work. The wave that armed
+ * the completion demands answered the read-only demand with a paragraph and no
+ * write, and answered the unmoved-tree demand with "no change is needed" and an
+ * empty patch. A control set that only ever says *not yet* teaches a run to
+ * write the sentence that makes the notice go away.
+ *
+ * This is the counterweight, and it is built out of what the controller already
+ * records. Three facts, in this order:
+ *
+ * 1. a check reported a failing exit status over a tree the run had not yet
+ *    changed;
+ * 2. the run changed the workspace after that;
+ * 3. the same check, or a broader one, reported a passing exit status after the
+ *    change.
+ *
+ * That is failing-before and passing-after over one subject, which is the whole
+ * of what the contract asks a run to hold before it completes. So the harness
+ * says so, once, in one sentence, and asks for nothing: the run may complete
+ * citing it or name what is still missing. It is an observation and not a
+ * demand — nothing is bounced, nothing is refused, no cap is spent — because a
+ * harness that decided a run was finished would be grading the agent's work
+ * with its own, which is the line every other control in this package holds.
+ *
+ * It reads no output and parses no runner. `exitCode` is the one wire key the
+ * controller already reads, `UnresolvedFailure` owns what it means, and the
+ * ordering comes from the run's own count of frames that changed the workspace.
+ *
+ * @since 0.1.0
+ */
+import { Effect, Schema } from "effect";
+import { NonNegativeSafeInt } from "./internal/nonNegativeSafeInt.js";
+import * as NarrowedCheck from "./NarrowedCheck.js";
+/**
+ * How many distinct failing checks one run carries forward.
+ *
+ * The ledger is durable controller state, so it is bounded, and it holds only
+ * the checks that reported a failure — a small fraction of what a run runs. The
+ * longest graded run recorded nine of them across 42 frames, so sixteen covers
+ * a whole run with room to spare. A run that outlives the bound forgets its
+ * oldest failures first, which can cost the observation and can never invent
+ * one.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export const retained = 16;
+/**
+ * One check that reported a failure, and where the run was when it did.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export class Failure extends Schema.Class("flows/harness/Sufficiency/Failure")({
+    /** The flow the call named. */
+    flow: Schema.String,
+    /** The call's identity, as the controller's own signature names it. */
+    signature: Schema.String,
+    /** The distinct terms of the call's input, sorted; see `NarrowedCheck` `terms`. */
+    terms: Schema.Array(Schema.String),
+    /** The call's input as it was written, clipped, for the observation to quote. */
+    label: Schema.String,
+    /**
+     * How many frames had changed the workspace when this check failed.
+     *
+     * The run's own count of mutating frames is the clock here, rather than a
+     * workspace digest, because the fact being established is an ordering — this
+     * failed, then something changed, then that passed — and a count is an
+     * ordering on any host, including one that measures nothing and knows only
+     * what its calls declared.
+     */
+    epoch: NonNegativeSafeInt
+}) {
+}
+/**
+ * The failing checks this run carries, oldest first and bounded.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const Ledger = Schema.Array(Failure).pipe(Schema.withConstructorDefault(Effect.succeed([])), Schema.withDecodingDefaultKey(Effect.succeed([])));
+/**
+ * Records one frame's failing checks against the epoch it ran in.
+ *
+ * A check from a frame that also changed the workspace is dropped rather than
+ * recorded. A frame's calls are not ordered against its edits in anything the
+ * harness records, so such a check might have failed before the change or after
+ * it, and a failure stamped on the wrong side of an edit is exactly the false
+ * before-and-after this module must never manufacture. `UnresolvedFailure`
+ * refuses the same stamp for the same reason; see `NarrowedCheck` `Check`
+ * `stable`.
+ *
+ * A repeated signature moves to the newest position and restamps, so a check
+ * that failed again over a later tree is remembered where it last failed.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export const remember = (ledger, options) => {
+    const newest = new Map(ledger.map((entry) => [entry.signature, entry]));
+    for (const check of options.frame) {
+        if (!check.failing || !check.stable)
+            continue;
+        newest.delete(check.signature);
+        newest.set(check.signature, new Failure({
+            flow: check.flow,
+            signature: check.signature,
+            terms: check.terms,
+            label: check.label,
+            epoch: options.epoch
+        }));
+    }
+    const distinct = [...newest.values()];
+    return distinct.slice(Math.max(0, distinct.length - retained));
+};
+/**
+ * Finds a failing-before, passing-after pair this frame has completed.
+ *
+ * Four conditions, each read off the run's own record:
+ *
+ * 0. no check of this frame reported a *failing* exit status. The sentence says
+ *    the evidence the contract asks for exists, and a frame that is looking at
+ *    a red check right now is a frame for which that reading is at best half
+ *    the record — a narrow probe going green while the broad check beside it
+ *    stays red is the exact shape that has lost one graded instance for six
+ *    consecutive waves. The harness will not pick the good half out of a frame
+ *    that holds both; it says nothing and lets the run finish reading. This
+ *    only ever suppresses the observation and can never manufacture one, and it
+ *    changes neither of the two frames that fire across the ten journals two
+ *    graded waves recorded;
+ * 1. some stable check of this frame reported a *passing* exit status — silence
+ *    is not a pass, and an unstable reading may precede this frame's edits.
+ *    Checkpoint-attributed readings are already stamped stable by `CellTurn`;
+ * 2. some remembered failure names the same flow and is the same call, or one
+ *    that check is broader than, as `NarrowedCheck` `narrows` reads "broader":
+ *    every term of the passing check is carried by the failing one, which added
+ *    conditions to it.
+ *    A broader reading passing is stronger evidence than the narrow one
+ *    passing, never weaker, so it is admitted;
+ * 3. the run changed the workspace between the two — the failure's epoch is
+ *    below the epoch this frame closes at.
+ *
+ * The broadest qualifying passing check wins — fewest terms, the least
+ * constrained question — so the sentence quotes the strongest evidence the run
+ * holds rather than the first one found. Ties go to the earliest-settled check.
+ * Among the failures that check answers, the most recent one wins, because it
+ * is the reading the run was working against most lately.
+ *
+ * @category conversions
+ * @since 0.1.0
+ */
+export const find = (options) => {
+    if (options.frame.some((check) => check.failing))
+        return undefined;
+    let found = undefined;
+    for (const passed of options.frame) {
+        if (!passed.passing || !passed.stable)
+            continue;
+        if (found !== undefined && found.passed.terms.length <= passed.terms.length)
+            continue;
+        let answered = undefined;
+        for (const failed of options.ledger) {
+            if (failed.epoch >= options.epoch)
+                continue;
+            if (failed.flow !== passed.flow)
+                continue;
+            if (failed.signature !== passed.signature && !NarrowedCheck.narrows(failed.terms, passed.terms))
+                continue;
+            answered = failed;
+        }
+        if (answered !== undefined)
+            found = { failed: answered, passed };
+    }
+    return found;
+};
+/**
+ * States that the run holds both halves of its own evidence.
+ *
+ * It quotes both readings and says what they establish, then names the two
+ * things the run may do with that — complete citing it, or say what is still
+ * missing — as equals. It asks for nothing and refuses nothing: the harness
+ * does not know whether the change is right, only that the evidence the
+ * contract asks for exists, and the sentence claims exactly that much.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export const observation = (found) => `Evidence held — you have watched a check fail before your change and pass after it, which is the evidence this contract asks for.
+
+- failed, before the workspace changed: ${found.failed.flow} ${found.failed.label}
+- passed, after it changed: ${found.passed.flow} ${found.passed.label}
+
+Nothing is being asked of you and nothing has been refused; this is the record read back. If that pair is the proof of the change you set out to make, complete now and name both commands and what they printed in your output. If it is not — the pair covers less than you changed, or a check you have not run yet is the one that would tell you — say in your next context which reading is still missing and go take it. This notice is written once per run.`;
+//# sourceMappingURL=Sufficiency.js.map

package/dist/esm/Sufficiency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sufficiency.js","sourceRoot":"","sources":["../../src/Sufficiency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AACrE,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,CAAA;AAE1B;;;;;GAKG;AACH,MAAM,OAAO,OAAQ,SAAQ,MAAM,CAAC,KAAK,CAAU,mCAAmC,CAAC,CAAC;IACtF,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC,MAAM;IACnB,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC,MAAM;IACxB,mFAAmF;IACnF,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC;IAClC,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAC,MAAM;IACpB;;;;;;;;OAQG;IACH,KAAK,EAAE,kBAAkB;CAC1B,CAAC;CAAG;AAEL;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAC9C,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAyB,EAAE,CAAC,CAAC,EACzE,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAyB,EAAE,CAAC,CAAC,CAC1E,CAAA;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,MAAc,EACd,OAKC,EACO,EAAE;IACV,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;IACvE,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QAClC,IAAI,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM;YAAE,SAAQ;QAC7C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;QAC9B,MAAM,CAAC,GAAG,CACR,KAAK,CAAC,SAAS,EACf,IAAI,OAAO,CAAC;YACV,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,KAAK,EAAE,OAAO,CAAC,KAAK;SACrB,CAAC,CACH,CAAA;IACH,CAAC;IACD,MAAM,QAAQ,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAA;IACrC,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAA;AAChE,CAAC,CAAA;AAeD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,OAOpB,EAA0B,EAAE;IAC3B,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC;QAAE,OAAO,SAAS,CAAA;IAClE,IAAI,KAAK,GAA2B,SAAS,CAAA;IAC7C,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QACnC,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM;YAAE,SAAQ;QAC/C,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM;YAAE,SAAQ;QACrF,IAAI,QAAQ,GAAwB,SAAS,CAAA;QAC7C,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACpC,IAAI,MAAM,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK;gBAAE,SAAQ;YAC3C,IAAI,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI;gBAAE,SAAQ;YACzC,IAAI,MAAM,CAAC,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC;gBAAE,SAAQ;YACzG,QAAQ,GAAG,MAAM,CAAA;QACnB,CAAC;QACD,IAAI,QAAQ,KAAK,SAAS;YAAE,KAAK,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClE,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAiB,EAAU,EAAE,CACvD;;0CAEwC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK;8BACnD,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK;;qcAEgY,CAAA","sourcesContent":["/**\n * The evidence that is already complete.\n *\n * Every armed control in this package pushes a run to do more. The read-only\n * cap says nothing has been written. The repeat demand says nothing new has\n * been learned. `UnmovedTree` says there is no change behind the completion,\n * `UnresolvedFailure` says a failing check was stepped around, `NarrowedCheck`\n * says the evidence is narrower than it looks. Five brakes and no accelerator,\n * and the asymmetry is not free: on a graded benchmark the best rounds pay one\n * frame re-checking work they had already proved and one more frame doing\n * nothing but writing the completion, because nothing ever tells a careful run\n * that it is finished. Two of the seventeen strokes those rounds spent over par\n * are that, measured.\n *\n * Pure braking also produces compliance rather than work. The wave that armed\n * the completion demands answered the read-only demand with a paragraph and no\n * write, and answered the unmoved-tree demand with \"no change is needed\" and an\n * empty patch. A control set that only ever says *not yet* teaches a run to\n * write the sentence that makes the notice go away.\n *\n * This is the counterweight, and it is built out of what the controller already\n * records. Three facts, in this order:\n *\n * 1. a check reported a failing exit status over a tree the run had not yet\n *    changed;\n * 2. the run changed the workspace after that;\n * 3. the same check, or a broader one, reported a passing exit status after the\n *    change.\n *\n * That is failing-before and passing-after over one subject, which is the whole\n * of what the contract asks a run to hold before it completes. So the harness\n * says so, once, in one sentence, and asks for nothing: the run may complete\n * citing it or name what is still missing. It is an observation and not a\n * demand — nothing is bounced, nothing is refused, no cap is spent — because a\n * harness that decided a run was finished would be grading the agent's work\n * with its own, which is the line every other control in this package holds.\n *\n * It reads no output and parses no runner. `exitCode` is the one wire key the\n * controller already reads, `UnresolvedFailure` owns what it means, and the\n * ordering comes from the run's own count of frames that changed the workspace.\n *\n * @since 0.1.0\n */\n\nimport { Effect, Schema } from \"effect\"\nimport { NonNegativeSafeInt } from \"./internal/nonNegativeSafeInt.ts\"\nimport * as NarrowedCheck from \"./NarrowedCheck.ts\"\n\n/**\n * How many distinct failing checks one run carries forward.\n *\n * The ledger is durable controller state, so it is bounded, and it holds only\n * the checks that reported a failure — a small fraction of what a run runs. The\n * longest graded run recorded nine of them across 42 frames, so sixteen covers\n * a whole run with room to spare. A run that outlives the bound forgets its\n * oldest failures first, which can cost the observation and can never invent\n * one.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const retained = 16\n\n/**\n * One check that reported a failure, and where the run was when it did.\n *\n * @category models\n * @since 0.1.0\n */\nexport class Failure extends Schema.Class<Failure>(\"flows/harness/Sufficiency/Failure\")({\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 distinct terms of the call's input, sorted; see `NarrowedCheck` `terms`. */\n  terms: Schema.Array(Schema.String),\n  /** The call's input as it was written, clipped, for the observation to quote. */\n  label: Schema.String,\n  /**\n   * How many frames had changed the workspace when this check failed.\n   *\n   * The run's own count of mutating frames is the clock here, rather than a\n   * workspace digest, because the fact being established is an ordering — this\n   * failed, then something changed, then that passed — and a count is an\n   * ordering on any host, including one that measures nothing and knows only\n   * what its calls declared.\n   */\n  epoch: NonNegativeSafeInt\n}) {}\n\n/**\n * The failing checks this run carries, oldest first and bounded.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Ledger = Schema.Array(Failure).pipe(\n  Schema.withConstructorDefault(Effect.succeed<ReadonlyArray<Failure>>([])),\n  Schema.withDecodingDefaultKey(Effect.succeed<ReadonlyArray<Failure>>([]))\n)\n\n/**\n * The failing checks 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 failing checks against the epoch it ran in.\n *\n * A check from a frame that also changed the workspace is dropped rather than\n * recorded. A frame's calls are not ordered against its edits in anything the\n * harness records, so such a check might have failed before the change or after\n * it, and a failure stamped on the wrong side of an edit is exactly the false\n * before-and-after this module must never manufacture. `UnresolvedFailure`\n * refuses the same stamp for the same reason; see `NarrowedCheck` `Check`\n * `stable`.\n *\n * A repeated signature moves to the newest position and restamps, so a check\n * that failed again over a later tree is remembered where it last failed.\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  }\n): Ledger => {\n  const newest = new Map(ledger.map((entry) => [entry.signature, entry]))\n  for (const check of options.frame) {\n    if (!check.failing || !check.stable) continue\n    newest.delete(check.signature)\n    newest.set(\n      check.signature,\n      new Failure({\n        flow: check.flow,\n        signature: check.signature,\n        terms: check.terms,\n        label: check.label,\n        epoch: options.epoch\n      })\n    )\n  }\n  const distinct = [...newest.values()]\n  return distinct.slice(Math.max(0, distinct.length - retained))\n}\n\n/**\n * A failure this run has answered, and the check that answered it.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Sufficient {\n  /** The check that reported a failure before the run changed anything. */\n  readonly failed: Failure\n  /** The check that reported a pass after it, over the changed tree. */\n  readonly passed: NarrowedCheck.Check\n}\n\n/**\n * Finds a failing-before, passing-after pair this frame has completed.\n *\n * Four conditions, each read off the run's own record:\n *\n * 0. no check of this frame reported a *failing* exit status. The sentence says\n *    the evidence the contract asks for exists, and a frame that is looking at\n *    a red check right now is a frame for which that reading is at best half\n *    the record — a narrow probe going green while the broad check beside it\n *    stays red is the exact shape that has lost one graded instance for six\n *    consecutive waves. The harness will not pick the good half out of a frame\n *    that holds both; it says nothing and lets the run finish reading. This\n *    only ever suppresses the observation and can never manufacture one, and it\n *    changes neither of the two frames that fire across the ten journals two\n *    graded waves recorded;\n * 1. some stable check of this frame reported a *passing* exit status — silence\n *    is not a pass, and an unstable reading may precede this frame's edits.\n *    Checkpoint-attributed readings are already stamped stable by `CellTurn`;\n * 2. some remembered failure names the same flow and is the same call, or one\n *    that check is broader than, as `NarrowedCheck` `narrows` reads \"broader\":\n *    every term of the passing check is carried by the failing one, which added\n *    conditions to it.\n *    A broader reading passing is stronger evidence than the narrow one\n *    passing, never weaker, so it is admitted;\n * 3. the run changed the workspace between the two — the failure's epoch is\n *    below the epoch this frame closes at.\n *\n * The broadest qualifying passing check wins — fewest terms, the least\n * constrained question — so the sentence quotes the strongest evidence the run\n * holds rather than the first one found. Ties go to the earliest-settled check.\n * Among the failures that check answers, the most recent one wins, because it\n * is the reading the run was working against most lately.\n *\n * @category conversions\n * @since 0.1.0\n */\nexport const find = (options: {\n  /** Failing checks this run has remembered, oldest first. */\n  readonly ledger: Ledger\n  /** The checks this frame ran, in the order they settled. */\n  readonly frame: ReadonlyArray<NarrowedCheck.Check>\n  /** Frames that have changed the workspace, this one included. */\n  readonly epoch: number\n}): Sufficient | undefined => {\n  if (options.frame.some((check) => check.failing)) return undefined\n  let found: Sufficient | undefined = undefined\n  for (const passed of options.frame) {\n    if (!passed.passing || !passed.stable) continue\n    if (found !== undefined && found.passed.terms.length <= passed.terms.length) continue\n    let answered: Failure | undefined = undefined\n    for (const failed of options.ledger) {\n      if (failed.epoch >= options.epoch) continue\n      if (failed.flow !== passed.flow) continue\n      if (failed.signature !== passed.signature && !NarrowedCheck.narrows(failed.terms, passed.terms)) continue\n      answered = failed\n    }\n    if (answered !== undefined) found = { failed: answered, passed }\n  }\n  return found\n}\n\n/**\n * States that the run holds both halves of its own evidence.\n *\n * It quotes both readings and says what they establish, then names the two\n * things the run may do with that — complete citing it, or say what is still\n * missing — as equals. It asks for nothing and refuses nothing: the harness\n * does not know whether the change is right, only that the evidence the\n * contract asks for exists, and the sentence claims exactly that much.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const observation = (found: Sufficient): string =>\n  `Evidence held — you have watched a check fail before your change and pass after it, which is the evidence this contract asks for.\n\n- failed, before the workspace changed: ${found.failed.flow} ${found.failed.label}\n- passed, after it changed: ${found.passed.flow} ${found.passed.label}\n\nNothing is being asked of you and nothing has been refused; this is the record read back. If that pair is the proof of the change you set out to make, complete now and name both commands and what they printed in your output. If it is not — the pair covers less than you changed, or a check you have not run yet is the one that would tell you — say in your next context which reading is still missing and go take it. This notice is written once per run.`\n"]}