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

package/dist/cjs/UnresolvedFailure.d.ts

@@ -0,0 +1,196 @@
+/**
+ * The failing check a completion stepped around.
+ *
+ * `NarrowedCheck` names a completion whose last check is a *narrower* version
+ * of one the run already ran, taken after the workspace moved. This module
+ * names the case one step further along: the run's reading of some subject
+ * reported a failure, over the very tree the run is now completing on, and the
+ * run neither re-ran it nor left it alone — it took a *different* reading of the
+ * same subject and completed on that one instead.
+ *
+ * It is not hypothetical. On a graded benchmark, one run edited a source file at
+ * frame 11, ran `pytest -rA testing/python/collect.py` at frame 12 — the whole
+ * file, unfiltered, over the tree it would go on to finish with — and was told
+ * "2 failed, 72 passed". At frame 13 it ran a command naming four cases out of
+ * that same file, was told "4 passed", and at frame 14 it completed. The broad
+ * result was never re-run, never retracted, and never mentioned. Its graded
+ * patch passed both target tests and 144 of 145 neighbours.
+ *
+ * ## Why a failing check alone is not the trigger
+ *
+ * "Some check failed and the run finished anyway" is not a defect, and reading
+ * it as one would be the harness deciding whose failures matter. The same wave
+ * contains the counter-example: an instance that **resolved** ran
+ * `pytest -rA astropy/io/fits/tests/test_header.py` after its edit, was told "2
+ * failed, 148 passed", and completed — correctly, because those two failures
+ * were nothing to do with its change. Nothing in the record distinguishes those
+ * two failure counts, and nothing may: counting failures means parsing a
+ * runner's output, which makes this a rule about pytest instead of a rule about
+ * evidence.
+ *
+ * What separates the two runs is what happened *after* the failing check. The
+ * resolved run walked away from that subject entirely: no later call it made
+ * names `astropy/io/fits/tests/test_header.py` at all. The unresolved run went
+ * back to exactly the subject that had failed, asked a smaller question about
+ * it, and reported the smaller answer. That is the shape this module names, and
+ * it is one the run's own record establishes: the run itself demonstrated the
+ * subject was still live by returning to it.
+ *
+ * So the demand is not "you have a failing test". It is: *the reading you
+ * replaced reported a failure, and you replaced it rather than answering it.*
+ * The run may answer either way — fix what the check reported, or complete again
+ * saying why those failures are expected. The loop asks once and accepts what
+ * comes back, because a harness that decided which failures counted would be
+ * grading the agent's work with its own.
+ *
+ * @since 0.1.0
+ */
+import type { Schema } from "effect";
+import type * as NarrowedCheck from "./NarrowedCheck.ts";
+/**
+ * The reserved key a flow reports its subject's exit status under.
+ *
+ * The second of the two conventions the loop reads off an otherwise opaque call
+ * result, alongside `invalidProbe`. It is not a shared type — the controller
+ * must not depend on the tool library — so it is a documented wire key.
+ * `@smthrs/std` `Bash` and `ShellCommand` are the producing half and own what
+ * the number means; the controller only has to know that a result carrying a
+ * non-zero number under this key is a result whose subject reported failure.
+ *
+ * @category identifiers
+ * @since 0.1.0
+ */
+export declare const exitStatusKey = "exitCode";
+/**
+ * Whether a settled call's result reports a failing exit status.
+ *
+ * A result that declares no exit status is not a failure and not a success: it
+ * is a call whose flow does not report one, and reading its absence either way
+ * would be an assumption. `false` is the answer that costs a demand rather than
+ * inventing one.
+ *
+ * @category predicates
+ * @since 0.1.0
+ */
+export declare const failed: (value: Schema.Json) => boolean;
+/**
+ * The exit status a settled call's result reports about its subject, or
+ * nothing where it reports none.
+ *
+ * The one reader of {@link exitStatusKey}, so the two predicates below and
+ * every caller that wants the number itself agree by construction rather than
+ * by three copies of the same shape test.
+ *
+ * @category getters
+ * @since 1.0.0-rc.0
+ */
+export declare const exitStatus: (value: Schema.Json) => number | undefined;
+/**
+ * Whether a settled call's result reports a passing exit status.
+ *
+ * The mirror of {@link failed}, and not its negation. A result that declares no
+ * exit status is neither: `false` from both predicates is a call whose flow
+ * does not report one, which is what a read and a search are. `Sufficiency`
+ * builds a completion signal out of this answer, so silence has to read as
+ * silence — a file read that "did not fail" is not a check that passed.
+ *
+ * @category predicates
+ * @since 0.1.0
+ */
+export declare const passed: (value: Schema.Json) => boolean;
+/**
+ * A failing check, paired with the reading the run took in its place.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Displaced {
+    /** The check that reported a failure and was never re-run. */
+    readonly failed: NarrowedCheck.Check;
+    /** A later check over the same tree that revisits its subject. */
+    readonly instead: NarrowedCheck.Check;
+}
+/**
+ * Whether a later check asks about the same subject as an earlier one.
+ *
+ * The relation is: same flow, a different call, and every *target* the earlier
+ * check named is named again. Targets — the terms carrying a separator, as
+ * `NarrowedCheck` `targeting` reads them — are the paths, files, modules and
+ * node ids a call is about; everything else is a condition on them. So "same
+ * subject" means the later call went back to all of the places the earlier one
+ * looked, whether it asked a narrower question there, a broader one, or looked
+ * somewhere else as well.
+ *
+ * It is deliberately weaker than `NarrowedCheck` `narrows`, which additionally
+ * requires every *condition* to be carried and forbids adding a target. That
+ * relation misses a compound command — a `git diff` of two source files joined
+ * onto a test run — because the diff's own paths read as added targets. This one
+ * does not, because the question it answers is not "is this the same question
+ * again" but "did you come back to this".
+ *
+ * An earlier check that names no target at all is never revisited. Such a call
+ * has no subject to return to, and treating it as revisited by any later call of
+ * the same flow would make the relation vacuous.
+ *
+ * @category predicates
+ * @since 0.1.0
+ */
+export declare const revisits: (later: NarrowedCheck.Check, earlier: NarrowedCheck.Check) => boolean;
+/**
+ * Finds the failing check a completion replaced rather than answered.
+ *
+ * Every condition is read off something the harness already records:
+ *
+ * 1. the frame closed on a complete measurement, so a digest means something;
+ * 2. some check in the ledger reported a failing exit status;
+ * 3. that check was recorded over the tree this frame is completing on, so its
+ *    result is a statement about the tree the completion stands on;
+ * 4. it was recorded by a frame that changed nothing, so the digest stamped on
+ *    it is the tree it actually ran over rather than a conservative guess;
+ * 5. some *later* check {@link revisits} it.
+ *
+ * Condition 4 is the one that cannot be dropped. A frame's calls are not ordered
+ * against its edits in anything the harness records, so a check taken in a frame
+ * that also edited is stamped with that frame's closing digest — which reads a
+ * check taken *before* the edit as though it ran after. `NarrowedCheck` accepts
+ * that in the direction that suppresses demands; here the same stamp would
+ * attribute a pre-edit failure to a tree the check never ran over, and invent
+ * one. The same wave carries an instance where it would have: a reproduction run
+ * in the same frame as the edit that fixed it, still reporting the bug.
+ *
+ * The ledger holds one entry per call signature, carrying that call's most
+ * recent run, so "never re-ran it" needs no separate test: a check re-run and
+ * passed is no longer failing, and a check re-run and failed again is still
+ * unanswered. Ledger order is recency of last run, which is what makes
+ * condition 5 a statement about time.
+ *
+ * The most recent such failing check wins, because it is the reading the
+ * completion is standing closest to.
+ *
+ * @category conversions
+ * @since 0.1.0
+ */
+export declare const find: (options: {
+    /** Every check this run has run, oldest first, this frame's included. */
+    readonly ledger: ReadonlyArray<NarrowedCheck.Check>;
+    /** The workspace digest the completing frame closed on; empty when unmeasured. */
+    readonly digest: string;
+}) => Displaced | undefined;
+/**
+ * States which reading failed, which one replaced it, and what ends it.
+ *
+ * The text quotes both calls as the run wrote them and asserts only what the
+ * record says: the first reported a failing exit status over this exact tree,
+ * the second asked about the same subject, and the first was never run again.
+ * It does not say the failures are the run's fault, because it does not know —
+ * a pre-existing failure is a real answer and the demand names it as one of the
+ * two ways out.
+ *
+ * It also says plainly that nothing re-runs anything for the run, and that the
+ * next answer stands.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const demand: (found: Displaced) => string;
+//# sourceMappingURL=UnresolvedFailure.d.ts.map

package/dist/cjs/UnresolvedFailure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnresolvedFailure.d.ts","sourceRoot":"","sources":["../../src/UnresolvedFailure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEpC,OAAO,KAAK,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAGxD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,aAAa,CAAA;AAEvC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,MAAM,CAAC,IAAI,KAAG,OAG3C,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,CAAC,IAAI,KAAG,MAAM,GAAG,SAIxD,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,MAAM,CAAC,IAAI,KAAG,OAAkC,CAAA;AAE9E;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAA;IACpC,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAA;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,QAAQ,GACnB,OAAO,aAAa,CAAC,KAAK,EAC1B,SAAS,aAAa,CAAC,KAAK,KAC3B,OAWF,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS;IAC5B,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;IACnD,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,KAAG,SAAS,GAAG,SAYf,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,SAAS,KAAG,MACyC,CAAA"}

package/dist/cjs/UnresolvedFailure.js

@@ -0,0 +1,77 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var UnresolvedFailure_exports = {};
+__export(UnresolvedFailure_exports, {
+  demand: () => demand,
+  exitStatus: () => exitStatus,
+  exitStatusKey: () => exitStatusKey,
+  failed: () => failed,
+  find: () => find,
+  passed: () => passed,
+  revisits: () => revisits
+});
+module.exports = __toCommonJS(UnresolvedFailure_exports);
+var DemandText = __toESM(require("./internal/demandText.js"), 1);
+var import_NarrowedCheck = require("./NarrowedCheck.js");
+const exitStatusKey = "exitCode";
+const failed = (value) => {
+  const status = exitStatus(value);
+  return status !== void 0 && status !== 0;
+};
+const exitStatus = (value) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const status = value[exitStatusKey];
+  return typeof status === "number" ? status : void 0;
+};
+const passed = (value) => exitStatus(value) === 0;
+const revisits = (later, earlier) => {
+  if (later.flow !== earlier.flow) return false;
+  if (later.signature === earlier.signature) return false;
+  const carried = new Set(later.terms);
+  let named = false;
+  for (const term of earlier.terms) {
+    if (!(0, import_NarrowedCheck.targeting)(term)) continue;
+    named = true;
+    if (!carried.has(term)) return false;
+  }
+  return named;
+};
+const find = (options) => {
+  if (options.digest === "") return void 0;
+  let found = void 0;
+  for (const [index, earlier] of options.ledger.entries()) {
+    if (!earlier.failing || !earlier.stable) continue;
+    if (earlier.digest !== options.digest) continue;
+    const instead = options.ledger.slice(index + 1).find((candidate) => revisits(candidate, earlier));
+    if (instead !== void 0) found = { failed: earlier, instead };
+  }
+  return found;
+};
+const demand = (found) => DemandText.unresolved(found.failed.flow, found.failed.label, found.instead.label);
+//# sourceMappingURL=UnresolvedFailure.js.map

package/dist/cjs/UnresolvedFailure.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/UnresolvedFailure.ts"],
+  "sourcesContent": ["/**\n * The failing check a completion stepped around.\n *\n * `NarrowedCheck` names a completion whose last check is a *narrower* version\n * of one the run already ran, taken after the workspace moved. This module\n * names the case one step further along: the run's reading of some subject\n * reported a failure, over the very tree the run is now completing on, and the\n * run neither re-ran it nor left it alone \u2014 it took a *different* reading of the\n * same subject and completed on that one instead.\n *\n * It is not hypothetical. On a graded benchmark, one run edited a source file at\n * frame 11, ran `pytest -rA testing/python/collect.py` at frame 12 \u2014 the whole\n * file, unfiltered, over the tree it would go on to finish with \u2014 and was told\n * \"2 failed, 72 passed\". At frame 13 it ran a command naming four cases out of\n * that same file, was told \"4 passed\", and at frame 14 it completed. The broad\n * result was never re-run, never retracted, and never mentioned. Its graded\n * patch passed both target tests and 144 of 145 neighbours.\n *\n * ## Why a failing check alone is not the trigger\n *\n * \"Some check failed and the run finished anyway\" is not a defect, and reading\n * it as one would be the harness deciding whose failures matter. The same wave\n * contains the counter-example: an instance that **resolved** ran\n * `pytest -rA astropy/io/fits/tests/test_header.py` after its edit, was told \"2\n * failed, 148 passed\", and completed \u2014 correctly, because those two failures\n * were nothing to do with its change. Nothing in the record distinguishes those\n * two failure counts, and nothing may: counting failures means parsing a\n * runner's output, which makes this a rule about pytest instead of a rule about\n * evidence.\n *\n * What separates the two runs is what happened *after* the failing check. The\n * resolved run walked away from that subject entirely: no later call it made\n * names `astropy/io/fits/tests/test_header.py` at all. The unresolved run went\n * back to exactly the subject that had failed, asked a smaller question about\n * it, and reported the smaller answer. That is the shape this module names, and\n * it is one the run's own record establishes: the run itself demonstrated the\n * subject was still live by returning to it.\n *\n * So the demand is not \"you have a failing test\". It is: *the reading you\n * replaced reported a failure, and you replaced it rather than answering it.*\n * The run may answer either way \u2014 fix what the check reported, or complete again\n * saying why those failures are expected. The loop asks once and accepts what\n * comes back, because a harness that decided which failures counted would be\n * grading the agent's work with its own.\n *\n * @since 0.1.0\n */\n\nimport type { Schema } from \"effect\"\nimport * as DemandText from \"./internal/demandText.ts\"\nimport type * as NarrowedCheck from \"./NarrowedCheck.ts\"\nimport { targeting } from \"./NarrowedCheck.ts\"\n\n/**\n * The reserved key a flow reports its subject's exit status under.\n *\n * The second of the two conventions the loop reads off an otherwise opaque call\n * result, alongside `invalidProbe`. It is not a shared type \u2014 the controller\n * must not depend on the tool library \u2014 so it is a documented wire key.\n * `@smthrs/std` `Bash` and `ShellCommand` are the producing half and own what\n * the number means; the controller only has to know that a result carrying a\n * non-zero number under this key is a result whose subject reported failure.\n *\n * @category identifiers\n * @since 0.1.0\n */\nexport const exitStatusKey = \"exitCode\"\n\n/**\n * Whether a settled call's result reports a failing exit status.\n *\n * A result that declares no exit status is not a failure and not a success: it\n * is a call whose flow does not report one, and reading its absence either way\n * would be an assumption. `false` is the answer that costs a demand rather than\n * inventing one.\n *\n * @category predicates\n * @since 0.1.0\n */\nexport const failed = (value: Schema.Json): boolean => {\n  const status = exitStatus(value)\n  return status !== undefined && status !== 0\n}\n\n/**\n * The exit status a settled call's result reports about its subject, or\n * nothing where it reports none.\n *\n * The one reader of {@link exitStatusKey}, so the two predicates below and\n * every caller that wants the number itself agree by construction rather than\n * by three copies of the same shape test.\n *\n * @category getters\n * @since 1.0.0-rc.0\n */\nexport const exitStatus = (value: Schema.Json): number | undefined => {\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) return undefined\n  const status = (value as Record<string, unknown>)[exitStatusKey]\n  return typeof status === \"number\" ? status : undefined\n}\n\n/**\n * Whether a settled call's result reports a passing exit status.\n *\n * The mirror of {@link failed}, and not its negation. A result that declares no\n * exit status is neither: `false` from both predicates is a call whose flow\n * does not report one, which is what a read and a search are. `Sufficiency`\n * builds a completion signal out of this answer, so silence has to read as\n * silence \u2014 a file read that \"did not fail\" is not a check that passed.\n *\n * @category predicates\n * @since 0.1.0\n */\nexport const passed = (value: Schema.Json): boolean => exitStatus(value) === 0\n\n/**\n * A failing check, paired with the reading the run took in its place.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Displaced {\n  /** The check that reported a failure and was never re-run. */\n  readonly failed: NarrowedCheck.Check\n  /** A later check over the same tree that revisits its subject. */\n  readonly instead: NarrowedCheck.Check\n}\n\n/**\n * Whether a later check asks about the same subject as an earlier one.\n *\n * The relation is: same flow, a different call, and every *target* the earlier\n * check named is named again. Targets \u2014 the terms carrying a separator, as\n * `NarrowedCheck` `targeting` reads them \u2014 are the paths, files, modules and\n * node ids a call is about; everything else is a condition on them. So \"same\n * subject\" means the later call went back to all of the places the earlier one\n * looked, whether it asked a narrower question there, a broader one, or looked\n * somewhere else as well.\n *\n * It is deliberately weaker than `NarrowedCheck` `narrows`, which additionally\n * requires every *condition* to be carried and forbids adding a target. That\n * relation misses a compound command \u2014 a `git diff` of two source files joined\n * onto a test run \u2014 because the diff's own paths read as added targets. This one\n * does not, because the question it answers is not \"is this the same question\n * again\" but \"did you come back to this\".\n *\n * An earlier check that names no target at all is never revisited. Such a call\n * has no subject to return to, and treating it as revisited by any later call of\n * the same flow would make the relation vacuous.\n *\n * @category predicates\n * @since 0.1.0\n */\nexport const revisits = (\n  later: NarrowedCheck.Check,\n  earlier: NarrowedCheck.Check\n): boolean => {\n  if (later.flow !== earlier.flow) return false\n  if (later.signature === earlier.signature) return false\n  const carried = new Set(later.terms)\n  let named = false\n  for (const term of earlier.terms) {\n    if (!targeting(term)) continue\n    named = true\n    if (!carried.has(term)) return false\n  }\n  return named\n}\n\n/**\n * Finds the failing check a completion replaced rather than answered.\n *\n * Every condition is read off something the harness already records:\n *\n * 1. the frame closed on a complete measurement, so a digest means something;\n * 2. some check in the ledger reported a failing exit status;\n * 3. that check was recorded over the tree this frame is completing on, so its\n *    result is a statement about the tree the completion stands on;\n * 4. it was recorded by a frame that changed nothing, so the digest stamped on\n *    it is the tree it actually ran over rather than a conservative guess;\n * 5. some *later* check {@link revisits} it.\n *\n * Condition 4 is the one that cannot be dropped. A frame's calls are not ordered\n * against its edits in anything the harness records, so a check taken in a frame\n * that also edited is stamped with that frame's closing digest \u2014 which reads a\n * check taken *before* the edit as though it ran after. `NarrowedCheck` accepts\n * that in the direction that suppresses demands; here the same stamp would\n * attribute a pre-edit failure to a tree the check never ran over, and invent\n * one. The same wave carries an instance where it would have: a reproduction run\n * in the same frame as the edit that fixed it, still reporting the bug.\n *\n * The ledger holds one entry per call signature, carrying that call's most\n * recent run, so \"never re-ran it\" needs no separate test: a check re-run and\n * passed is no longer failing, and a check re-run and failed again is still\n * unanswered. Ledger order is recency of last run, which is what makes\n * condition 5 a statement about time.\n *\n * The most recent such failing check wins, because it is the reading the\n * completion is standing closest to.\n *\n * @category conversions\n * @since 0.1.0\n */\nexport const find = (options: {\n  /** Every check this run has run, oldest first, this frame's included. */\n  readonly ledger: ReadonlyArray<NarrowedCheck.Check>\n  /** The workspace digest the completing frame closed on; empty when unmeasured. */\n  readonly digest: string\n}): Displaced | undefined => {\n  if (options.digest === \"\") return undefined\n  let found: Displaced | undefined = undefined\n  for (const [index, earlier] of options.ledger.entries()) {\n    if (!earlier.failing || !earlier.stable) continue\n    if (earlier.digest !== options.digest) continue\n    const instead = options.ledger.slice(index + 1).find((candidate) => revisits(candidate, earlier))\n    // Oldest first, keeping the last match: the ledger is ordered by when each\n    // check last ran, so the surviving pair names the most recent failure.\n    if (instead !== undefined) found = { failed: earlier, instead }\n  }\n  return found\n}\n\n/**\n * States which reading failed, which one replaced it, and what ends it.\n *\n * The text quotes both calls as the run wrote them and asserts only what the\n * record says: the first reported a failing exit status over this exact tree,\n * the second asked about the same subject, and the first was never run again.\n * It does not say the failures are the run's fault, because it does not know \u2014\n * a pre-existing failure is a real answer and the demand names it as one of the\n * two ways out.\n *\n * It also says plainly that nothing re-runs anything for the run, and that the\n * next answer stands.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const demand = (found: Displaced): string =>\n  DemandText.unresolved(found.failed.flow, found.failed.label, found.instead.label)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiDA,iBAA4B;AAE5B,2BAA0B;AAenB,MAAM,gBAAgB;AAatB,MAAM,SAAS,CAAC,UAAgC;AACrD,QAAM,SAAS,WAAW,KAAK;AAC/B,SAAO,WAAW,UAAa,WAAW;AAC5C;AAaO,MAAM,aAAa,CAAC,UAA2C;AACpE,MAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,EAAG,QAAO;AAChF,QAAM,SAAU,MAAkC,aAAa;AAC/D,SAAO,OAAO,WAAW,WAAW,SAAS;AAC/C;AAcO,MAAM,SAAS,CAAC,UAAgC,WAAW,KAAK,MAAM;AAwCtE,MAAM,WAAW,CACtB,OACA,YACY;AACZ,MAAI,MAAM,SAAS,QAAQ,KAAM,QAAO;AACxC,MAAI,MAAM,cAAc,QAAQ,UAAW,QAAO;AAClD,QAAM,UAAU,IAAI,IAAI,MAAM,KAAK;AACnC,MAAI,QAAQ;AACZ,aAAW,QAAQ,QAAQ,OAAO;AAChC,QAAI,KAAC,gCAAU,IAAI,EAAG;AACtB,YAAQ;AACR,QAAI,CAAC,QAAQ,IAAI,IAAI,EAAG,QAAO;AAAA,EACjC;AACA,SAAO;AACT;AAoCO,MAAM,OAAO,CAAC,YAKQ;AAC3B,MAAI,QAAQ,WAAW,GAAI,QAAO;AAClC,MAAI,QAA+B;AACnC,aAAW,CAAC,OAAO,OAAO,KAAK,QAAQ,OAAO,QAAQ,GAAG;AACvD,QAAI,CAAC,QAAQ,WAAW,CAAC,QAAQ,OAAQ;AACzC,QAAI,QAAQ,WAAW,QAAQ,OAAQ;AACvC,UAAM,UAAU,QAAQ,OAAO,MAAM,QAAQ,CAAC,EAAE,KAAK,CAAC,cAAc,SAAS,WAAW,OAAO,CAAC;AAGhG,QAAI,YAAY,OAAW,SAAQ,EAAE,QAAQ,SAAS,QAAQ;AAAA,EAChE;AACA,SAAO;AACT;AAkBO,MAAM,SAAS,CAAC,UACrB,WAAW,WAAW,MAAM,OAAO,MAAM,MAAM,OAAO,OAAO,MAAM,QAAQ,KAAK;",
+  "names": []
+}

package/dist/cjs/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/cjs/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/cjs/VacuousVerification.js

@@ -0,0 +1,91 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var VacuousVerification_exports = {};
+__export(VacuousVerification_exports, {
+  Ledger: () => Ledger,
+  Pass: () => Pass,
+  find: () => find,
+  observation: () => observation,
+  remember: () => remember,
+  retained: () => retained,
+  stored: () => stored
+});
+module.exports = __toCommonJS(VacuousVerification_exports);
+var import_effect = require("effect");
+var Effect = __toESM(require("effect/Effect"), 1);
+const retained = 16;
+class Pass extends import_effect.Schema.Class("flows/harness/VacuousVerification/Pass")({
+  /** The flow the call named. */
+  flow: import_effect.Schema.String,
+  /** The call's identity, as the controller's own signature names it. */
+  signature: import_effect.Schema.String,
+  /** The call's input as it was written, clipped, for the observation to quote. */
+  label: import_effect.Schema.String
+}) {
+}
+const Ledger = import_effect.Schema.Array(Pass).pipe(
+  import_effect.Schema.withConstructorDefault(Effect.succeed([])),
+  import_effect.Schema.withDecodingDefaultKey(Effect.succeed([]))
+);
+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));
+};
+const stored = (agentState) => {
+  if (agentState === null || typeof agentState !== "object" || Array.isArray(agentState)) return void 0;
+  const declared = agentState["verification"];
+  if (declared === null || declared === void 0 || typeof declared !== "object" || Array.isArray(declared)) {
+    return void 0;
+  }
+  const { flow, input } = declared;
+  return typeof flow === "string" && input !== void 0 ? { flow, input } : void 0;
+};
+const find = (options) => {
+  if (options.stated.includes(options.signature)) return void 0;
+  return options.ledger.find((entry) => entry.signature === options.signature);
+};
+const observation = (found) => `Vacuous verification \u2014 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 \u2014 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