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

package/dist/esm/CallLedger.js

@@ -0,0 +1,506 @@
+/**
+ * The call ledger: what this run has already asked, rendered every frame.
+ *
+ * A cell's results are durable, but they are invisible to the next model turn
+ * unless the cell that made them happened to copy them into `context`. A cell
+ * is authored blind — the model writes the whole program before it sees any of
+ * its results — so copying is a guess made before the answer exists, and the
+ * rational response is to split one logical step across two frames: one frame
+ * to fetch, one to look. Thirty-one percent of the frames in one graded wave
+ * made no flow call at all, and the justifications they volunteered name the
+ * cause outright: "loaded the durable investigation results so the next frame
+ * can edit without repeating repository reads".
+ *
+ * This ledger removes the guess. Every settled call of the run contributes one
+ * line the harness derives on its own — ordinal, flow, what the call was about,
+ * whether it settled ok, and a structural digest of what came back — so a model
+ * can see what it has already asked without asking again. It carries no
+ * payloads: a line says `stdout=4096b`, never the four kilobytes.
+ *
+ * A call that *writes* gets two things more, because a repeated write is a
+ * different failure from a repeated read. The line says so and says how many
+ * bytes the call carried, and a write whose flow and input an earlier write
+ * already settled names that earlier one. The r95repl lane is why:
+ * `sympy__sympy-13878` applied one 4,789-byte patch five times across five
+ * frames, reverting the file between each, and nothing in the run's own record
+ * of itself said that the second application was the first one again. It spent
+ * 649 seconds and $1.20, the slowest instance in an arm whose median was 121 s.
+ * This is visibility and not a gate: re-applying is sometimes exactly right —
+ * the run had genuinely reverted the tree — and the exact-match refusal the
+ * truncated-write guard already carries is what stands between a run and a
+ * destructive repeat.
+ *
+ * It is a sibling of `NarrowedCheck` and `TruncatedOutput`: run-scoped
+ * controller state, bounded, journal-derivable, and interpreting nothing about
+ * any flow, tool, or repository.
+ *
+ * @since 0.1.0
+ */
+import * as Digest from "@smthrs/core/Digest";
+import * as CanonicalJson from "@smthrs/model/CanonicalJson";
+import { Effect, Schema } from "effect";
+import * as elide from "./internal/elide.js";
+import { NonNegativeSafeInt } from "./internal/nonNegativeSafeInt.js";
+import * as NarrowedCheck from "./NarrowedCheck.js";
+/**
+ * How many settled calls the rendered ledger carries, newest last.
+ *
+ * Thirty is above the whole call count of every round this harness has ever
+ * completed at or near par — the five golfed instances settle 7 to 25 calls —
+ * and it is a third of the call count of the worst recorded round, so a run
+ * that has genuinely lost the thread is shown its recent history rather than
+ * its whole one. Each line is bounded, so the section is bounded.
+ *
+ * @category constants
+ * @since 0.1.0
+ * @slop
+ */
+export const bound = 30;
+/**
+ * How much of one call's subject or result digest a line may quote.
+ *
+ * @category constants
+ * @since 0.1.0
+ * @slop
+ */
+export const width = 120;
+/**
+ * How many leaves of a result the digest may name.
+ *
+ * @category constants
+ * @since 0.1.0
+ * @slop
+ */
+export const members = 6;
+/**
+ * How many levels below a result's own the digest descends.
+ *
+ * Five, because that is where a batched judgement keeps its answers. A
+ * `classify` batch answers under `results[].answers.<question>.value`, which
+ * is five levels down, and a digest that stopped above it reported
+ * `results=[4]` about a call that had answered four questions. Measured on the
+ * live seat over the three refused completions this bound was raised for:
+ * with `results=[4]` the narrow question read `invented` 0.86, 0.87 and 0.86;
+ * with the leaves named it read 0.11, 0.11 and 0.10. Below five the same
+ * states read 0.24 to 0.49, because naming the first member of a batch says
+ * what one state answered and the claim is about all of them.
+ *
+ * It is a depth and not a size: {@link resultWidth} is what keeps the line
+ * bounded, and {@link members} is what keeps a wide result from taking it
+ * over.
+ *
+ * @category constants
+ * @since 0.1.0
+ * @slop
+ */
+export const depth = 5;
+/**
+ * How many distinct values one leaf may report before the rest are counted.
+ *
+ * A leaf folded across a batch takes one value per member, and what a reader
+ * needs from it is the spread: four states that all answered `true`, or three
+ * that answered `true` and one that did not. Three distinct values say that;
+ * a fourth says only that the leaf varies, which the count already said.
+ *
+ * @category constants
+ * @since 0.1.0
+ * @slop
+ */
+export const distinct = 3;
+/**
+ * How much of one call's result digest a line may quote.
+ *
+ * Wider than {@link width} because a digest is a list of leaves and a name is
+ * one term. It is the bound the brake's receipt is held to as well: the
+ * digest travels twice, once in the state section this module renders and
+ * once as `CompletionClaim.Evidence.callsRun`'s `resultSummary`, and both are
+ * the same string. Three hundred and twenty bytes holds the six leaves
+ * {@link members} allows at the path lengths {@link depth} produces, and caps
+ * the ledger's whole contribution to a frame at thirty lines of it.
+ *
+ * @category constants
+ * @since 0.1.0
+ * @slop
+ */
+export const resultWidth = 320;
+const clip = (text, limit) => elide.head(text, limit, "clipped");
+/**
+ * One settled call, as one line of the run's history.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export class Entry extends Schema.Class("flows/harness/CallLedger/Entry")({
+    /** The call's one-based position in the run's whole settled sequence. */
+    ordinal: NonNegativeSafeInt,
+    /** The flow the call named. */
+    flow: Schema.String,
+    /** What the call was about; see {@link subject}. */
+    subject: Schema.String,
+    /** Whether the call settled successfully. This is not the exit status. */
+    ok: Schema.Boolean,
+    /** The structural digest of what came back; see {@link digest}. */
+    digest: Schema.String,
+    /**
+     * The whole of what came back, in bytes of canonical JSON.
+     *
+     * Stated on every line, because a line is an index entry and the size is what
+     * says how much the name it points at is holding.
+     */
+    bytes: NonNegativeSafeInt.pipe(Schema.withConstructorDefault(Effect.succeed(0)), Schema.withDecodingDefaultKey(Effect.succeed(0))),
+    /**
+     * Whether this call reached the engine declaring that it changes the tree.
+     *
+     * A mutation is the one kind of call whose repetition is never compliance.
+     * Re-issuing a read costs bytes; re-issuing the check that failed is what rule
+     * 7 asks for; re-applying a hunk means the run either lost its own edit or
+     * undid it, and either way it is about to make a change it has already made.
+     * So the line says which calls wrote, and {@link render} points a repeated
+     * write back at the write it repeats.
+     */
+    mutates: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false)), Schema.withDecodingDefaultKey(Effect.succeed(false))),
+    /**
+     * The bytes this call carried into the tree, for a call that declares a write.
+     *
+     * It is the longest string in the call's input — a `write`'s content, an
+     * `edit`'s replacement, a patch — measured the same flow-agnostic way
+     * `TruncatedOutput` measures a payload, and it is **not** a measured delta of
+     * the workspace. The harness has no per-call delta to report: its one honest
+     * measurement is `EngineLike.observe`, which covers a whole frame and counts
+     * paths rather than bytes. Stating the payload says what the call was, which
+     * is what makes two applications of one 4,789-byte patch legible as the same
+     * act; claiming a delta would say what the tree did, which this number does
+     * not know.
+     *
+     * The number is the payload and not the call: `sympy__sympy-13878` sent a
+     * 4,789-byte patch inside a 4,965-byte input, and it is the patch this reports,
+     * because the patch is the part two calls have in common.
+     */
+    payloadBytes: NonNegativeSafeInt.pipe(Schema.withConstructorDefault(Effect.succeed(0)), Schema.withDecodingDefaultKey(Effect.succeed(0))),
+    /**
+     * The digest of this call's flow and input together.
+     *
+     * Held rather than rendered: it is what lets a later identical write name the
+     * earlier one, and it is a digest so the ledger stays small enough to live in
+     * journaled controller state.
+     */
+    signature: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed("")), Schema.withDecodingDefaultKey(Effect.succeed("")))
+}) {
+}
+/**
+ * The run's settled calls, oldest first and bounded to {@link bound}.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export const Ledger = Schema.Array(Entry).pipe(Schema.withConstructorDefault(Effect.succeed([])), Schema.withDecodingDefaultKey(Effect.succeed([])));
+/**
+ * What one call was about: the first term of its input that names a target.
+ *
+ * `NarrowedCheck` already owns the lexer and the target/condition split, so a
+ * path, a test id, a dotted module name, or the file inside a shell command is
+ * picked out without this module knowing what any of those are. `names` is its
+ * stricter reading of a target, because a subject nobody can recognize is worse
+ * than no subject at all. An input with no such term is quoted whole instead,
+ * clipped — a grep that targets only a glob is named by its own pattern and
+ * root, which is what makes the line recognizable at all.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export const subject = (input) => clip(sole(input) ?? CanonicalJson.stringify(input), width);
+/**
+ * The one target an input names, or nothing when it names none or several.
+ *
+ * {@link target} takes the first, which is the right reading of a call about
+ * one thing and the wrong reading of a call about many. A `classify` batch
+ * over four files lexes four paths and was named by the first of them, so its
+ * line read `classify notes/n1.txt`: a call about four states, named after
+ * one of them, with the question it asked nowhere on the line. An input that
+ * names several targets is quoted whole instead, clipped, which is where the
+ * question is. Measured with the leaves of the result named either way, on
+ * the live seat over three refused completions: named after one state the
+ * narrow question read `invented` 0.73, 0.64 and 0.70; quoted whole it read
+ * 0.11, 0.11 and 0.10.
+ *
+ * Distinct, not total: a patch that names one path on every hunk header names
+ * one target, and it is the target.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export const sole = (value) => {
+    const named = new Set(NarrowedCheck.lex(value).filter(NarrowedCheck.names));
+    const [only] = named;
+    return named.size === 1 ? only : undefined;
+};
+/**
+ * The first term of a value that names a target, or nothing.
+ *
+ * Split out of {@link subject} because a write's target is not always in its
+ * input. Usually it is, even inside a blob: the lexer reads a patch's own text,
+ * so `sympy__sympy-13878`'s five applications each named
+ * `sympy/stats/crv_types.py` off the `*** Update File:` line. The split is for
+ * the write whose input names nothing a lexer can find — a patch that only adds
+ * a file, an input that carries bytes and a handle — where the result is the one
+ * place a path appears at all: `modified: ["sympy/stats/crv_types.py"]`. A line
+ * that named such a write by its payload's first hundred bytes said nothing a
+ * reader could match against the next one.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export const target = (value) => NarrowedCheck.lex(value).find(NarrowedCheck.names);
+const encoder = new TextEncoder();
+const scalar = (value) => {
+    if (typeof value === "string")
+        return `${encoder.encode(value).byteLength}b`;
+    if (Array.isArray(value))
+        return `[${value.length}]`;
+    if (value !== null && typeof value === "object")
+        return "{…}";
+    return String(value);
+};
+const leafly = (value) => value === null || typeof value !== "object";
+/** Whether a value reports itself whole: a scalar, or an array of them. */
+const counted = (value) => leafly(value) || (Array.isArray(value) && (value.length === 0 || value.every(leafly)));
+/**
+ * Folds one result's leaves into the path each sits at and the values that
+ * path took, in the order the walk met them.
+ *
+ * An array is walked into one path rather than one path per index: the members
+ * of a batch answer the same question, so `results[].ok` is one leaf that took
+ * four values and not four leaves that took one each. That is what makes a
+ * four-state judgement fit a line.
+ */
+const leaves = (value, path, into, left) => {
+    const took = (rendered) => {
+        const seen = into.get(path);
+        if (seen === undefined)
+            into.set(path, [rendered]);
+        else
+            seen.push(rendered);
+    };
+    if (counted(value) || left === 0)
+        return took(scalar(value));
+    if (Array.isArray(value)) {
+        for (const item of value)
+            leaves(item, `${path}[]`, into, left - 1);
+        return;
+    }
+    const record = value;
+    const keys = Object.keys(record).sort();
+    // `{}` and not `{…}`: nothing was elided, the record is empty, and a reader
+    // that cannot tell those apart reads an empty result as a hidden one.
+    if (keys.length === 0)
+        return took("{}");
+    for (const key of keys)
+        leaves(record[key], path === "" ? key : `${path}.${key}`, into, left - 1);
+};
+/**
+ * What one leaf reported, across however many members it was folded over.
+ *
+ * Distinct values, each with how many members took it, capped at
+ * {@link distinct}. A leaf one member deep reports its value alone, which is
+ * what every unbatched result in this ledger reported before folding existed.
+ */
+const spread = (values) => {
+    const tally = new Map();
+    for (const value of values)
+        tally.set(value, (tally.get(value) ?? 0) + 1);
+    const all = [...tally.entries()];
+    const named = all.slice(0, distinct).map(([value, count]) => count === 1 ? value : `${value}×${count}`);
+    const rest = all.length - named.length;
+    return [...named, ...(rest > 0 ? [`+${rest} more`] : [])].join(" ");
+};
+/**
+ * The one-line structural digest of what a call returned.
+ *
+ * Counts and statuses, never payloads: a leaf that is a string reports its
+ * byte length, an array of scalars reports its length, and a number or boolean
+ * (an exit code, a truncation flag, a judgement) reports itself. Leaves are
+ * named by their path in canonical key order and capped at {@link members}, so
+ * the same result always renders the same line and a result with fifty leaves
+ * cannot take the frame over.
+ *
+ * It descends {@link depth} levels, and an array of records folds into one
+ * path per leaf with the values its members took, because the alternative was
+ * measured and it was the defect. A `classify` batch returns its judgements
+ * under `results[].answers.<question>.value`; a digest that named only the
+ * result's own keys reported `results=[4]`, which records that four answers
+ * arrived and not one of them. The completion brake reads this string as its
+ * receipt for work that reports no exit status, so a run that judged four
+ * files and said so was refused for reporting a result nothing recorded. See
+ * {@link depth} for the readings either way.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export const digest = (value) => {
+    if (counted(value))
+        return clip(scalar(value), resultWidth);
+    const found = new Map();
+    leaves(value, "", found, depth);
+    const paths = [...found.keys()];
+    // The root has no name, so a result with nothing under it reports its own
+    // shape rather than an empty name bound to it.
+    const named = paths.slice(0, members).map((path) => path === "" ? spread(found.get(path)) : `${path}=${spread(found.get(path))}`);
+    const rest = paths.length - named.length;
+    return clip([...named, ...(rest > 0 ? [`+${rest} more`] : [])].join(" "), resultWidth);
+};
+/**
+ * The bytes one call carried into the tree: the longest string in its input.
+ *
+ * Flow-agnostic on purpose, and the same walk `TruncatedOutput` uses to find the
+ * payload of a call it has never heard of. A `write` carries its content, an
+ * `edit` its replacement, `apply_patch` its patch, and every one of them is the
+ * longest string the input holds. A mutating call with no string at all — a
+ * revert that names only a path — carries nothing and says zero.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export const payload = (input) => {
+    if (typeof input === "string")
+        return encoder.encode(input).byteLength;
+    if (Array.isArray(input))
+        return input.reduce((widest, item) => Math.max(widest, payload(item)), 0);
+    if (input === null || typeof input !== "object")
+        return 0;
+    return Object.values(input).reduce((widest, item) => Math.max(widest, payload(item)), 0);
+};
+/**
+ * Records one settled call.
+ *
+ * A call that failed carries what the flow said about the failure, because that
+ * text — an anchor near-miss, a missing path — is the whole content of the
+ * result and is otherwise seen only by a cell that thought to catch it.
+ *
+ * Every one of the four rendered fields is bounded, the flow name included. A
+ * name that matches no descriptor still settles — as a failure saying so — and
+ * the name is whatever the cell passed to `ctx.call`, which is a value the model
+ * writes. `ctx.call("Z".repeat(50000), {})` is one short line of JavaScript, and
+ * without this bound it put fifty kilobytes into durable controller state and
+ * into every remaining frame's prompt, thirty times over at the ledger's bound.
+ * A real flow name is far under {@link width}, so the clip is invisible to every
+ * call that names something callable.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export const entry = (ordinal, call) => {
+    // `?? null` because a host can settle a call with no value at all: the
+    // contract says `Json`, an implementation that returns nothing says
+    // `undefined`, and canonical JSON refuses it. The ledger reports what the
+    // cell saw, which for such a call is `null`.
+    const whole = CanonicalJson.stringify(call.ok ? call.value ?? null : { failed: call.message ?? "failed" });
+    const mutates = call.mutates === true;
+    return new Entry({
+        ordinal,
+        flow: clip(call.flow, width),
+        // A write whose input names nothing is named by what came back, because a
+        // patch carries its paths in its own text and hands them back as a list.
+        // A write is named by the first target it holds, wherever it holds it: a
+        // patch names one file per hunk header and every one of them is a target
+        // this write has, so {@link sole} would refuse a two-file patch a name.
+        subject: mutates
+            ? clip(target(call.input) ?? target(call.value) ?? CanonicalJson.stringify(call.input), width)
+            : subject(call.input),
+        ok: call.ok,
+        digest: call.ok ? digest(call.value) : clip(call.message ?? "failed", width),
+        bytes: encoder.encode(whole).byteLength,
+        mutates,
+        payloadBytes: mutates ? payload(call.input) : 0,
+        signature: mutates ? Digest.digest(CanonicalJson.stringify([call.flow, call.input])) : ""
+    });
+};
+/**
+ * How many calls this run has settled, given a ledger some of whose lines have
+ * aged out.
+ *
+ * The ledger holds at most {@link bound} lines, so its length stops being the
+ * run's call count as soon as it fills. The newest entry's ordinal is the count
+ * and does not, which is why ordinals are stored rather than rendered from an
+ * index.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export const settled = (ledger) => ledger.length === 0 ? 0 : ledger[ledger.length - 1].ordinal;
+/**
+ * Folds one frame's settled calls into the run's ledger, newest last.
+ *
+ * Ordinals continue the run's own sequence, so the numbers a model reads stay
+ * the numbers the journal would give the same calls after older lines have aged
+ * out of the bound.
+ *
+ * The ledger is an index, not a store: what a call returned is under the name
+ * the cell bound it to, and it is that index the golf report credits with
+ * deleting a whole frame class.
+ *
+ * @category combinators
+ * @since 0.1.0
+ * @slop
+ */
+export const remember = (known, made) => {
+    const before = settled(known);
+    const all = [...known, ...made.map((call, index) => entry(before + index + 1, call))];
+    return all.length <= bound ? all : all.slice(all.length - bound);
+};
+/**
+ * Renders the ledger for the state section, or nothing when there is no call
+ * to list.
+ *
+ * `since` is the newest ordinal an earlier section in the window already
+ * listed. The window keeps every frame's section (see `CellTurn`), so a later
+ * section lists only the calls settled after it; zero lists the whole ledger.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export const render = (ledger, since = 0) => {
+    const listed = ledger.filter((line) => line.ordinal > since);
+    if (listed.length === 0)
+        return undefined;
+    const total = settled(ledger);
+    const elided = total - ledger.length;
+    const heading = since > 0
+        ? `Calls this run has settled since the last list (${listed.length} of ${total}), oldest first. You have already asked these — read them here instead of asking again:`
+        : elided === 0
+            ? `Calls this run has settled (${total}), oldest first. You have already asked these — read them here instead of asking again:`
+            : `Calls this run has settled (${total}), oldest first; the ${elided} oldest are not listed. You have already asked these — read them here instead of asking again:`;
+    // Where each write's signature was first settled, so a repeat can name it.
+    // First rather than most recent: the run wants the call it has already made,
+    // and the earliest one is the one every later copy repeats.
+    const first = new Map();
+    for (const line of ledger) {
+        if (line.mutates && !first.has(line.signature))
+            first.set(line.signature, line);
+    }
+    const lines = listed.map((line) => {
+        const repeated = line.mutates ? first.get(line.signature) : undefined;
+        const again = repeated === undefined || repeated.ordinal === line.ordinal
+            ? ""
+            : ` — the same write as ${repeated.ordinal}, which ${repeated.ok ? "succeeded" : "failed"}`;
+        const wrote = line.mutates ? `WROTE ${line.payloadBytes}b, ` : "";
+        return `${line.ordinal}. ${line.flow} ${line.subject} — ${wrote}${line.ok ? "ok" : "FAILED"}${again}: ${line.digest} (${line.bytes}b)`;
+    });
+    // Only where the run has actually written something: teaching about a marker
+    // nothing on the page carries costs a frame's worth of reading for nothing.
+    const writes = first.size === 0
+        ? ""
+        : "\nA line marked `WROTE` changed the tree, with the bytes it carried. One that names an earlier write made a change this run had already made: read what happened after the first one before making it a third time.";
+    const trailer = "\nThese are an index, not the results: what each call returned is still under the name your cell bound it to. Read the name; do not issue the call again.";
+    return `${heading}\n${lines.join("\n")}${trailer}${writes}`;
+};
+//# sourceMappingURL=CallLedger.js.map

package/dist/esm/CallLedger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CallLedger.js","sourceRoot":"","sources":["../../src/CallLedger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The call ledger: what this run has already asked, rendered every frame.\n *\n * A cell's results are durable, but they are invisible to the next model turn\n * unless the cell that made them happened to copy them into `context`. A cell\n * is authored blind — the model writes the whole program before it sees any of\n * its results — so copying is a guess made before the answer exists, and the\n * rational response is to split one logical step across two frames: one frame\n * to fetch, one to look. Thirty-one percent of the frames in one graded wave\n * made no flow call at all, and the justifications they volunteered name the\n * cause outright: \"loaded the durable investigation results so the next frame\n * can edit without repeating repository reads\".\n *\n * This ledger removes the guess. Every settled call of the run contributes one\n * line the harness derives on its own — ordinal, flow, what the call was about,\n * whether it settled ok, and a structural digest of what came back — so a model\n * can see what it has already asked without asking again. It carries no\n * payloads: a line says `stdout=4096b`, never the four kilobytes.\n *\n * A call that *writes* gets two things more, because a repeated write is a\n * different failure from a repeated read. The line says so and says how many\n * bytes the call carried, and a write whose flow and input an earlier write\n * already settled names that earlier one. The r95repl lane is why:\n * `sympy__sympy-13878` applied one 4,789-byte patch five times across five\n * frames, reverting the file between each, and nothing in the run's own record\n * of itself said that the second application was the first one again. It spent\n * 649 seconds and $1.20, the slowest instance in an arm whose median was 121 s.\n * This is visibility and not a gate: re-applying is sometimes exactly right —\n * the run had genuinely reverted the tree — and the exact-match refusal the\n * truncated-write guard already carries is what stands between a run and a\n * destructive repeat.\n *\n * It is a sibling of `NarrowedCheck` and `TruncatedOutput`: run-scoped\n * controller state, bounded, journal-derivable, and interpreting nothing about\n * any flow, tool, or repository.\n *\n * @since 0.1.0\n */\n\nimport * as Digest from \"@smthrs/core/Digest\"\nimport * as CanonicalJson from \"@smthrs/model/CanonicalJson\"\nimport { Effect, Schema } from \"effect\"\nimport * as elide from \"./internal/elide.ts\"\nimport { NonNegativeSafeInt } from \"./internal/nonNegativeSafeInt.ts\"\nimport * as NarrowedCheck from \"./NarrowedCheck.ts\"\n\n/**\n * How many settled calls the rendered ledger carries, newest last.\n *\n * Thirty is above the whole call count of every round this harness has ever\n * completed at or near par — the five golfed instances settle 7 to 25 calls —\n * and it is a third of the call count of the worst recorded round, so a run\n * that has genuinely lost the thread is shown its recent history rather than\n * its whole one. Each line is bounded, so the section is bounded.\n *\n * @category constants\n * @since 0.1.0\n * @slop\n */\nexport const bound = 30\n\n/**\n * How much of one call's subject or result digest a line may quote.\n *\n * @category constants\n * @since 0.1.0\n * @slop\n */\nexport const width = 120\n\n/**\n * How many leaves of a result the digest may name.\n *\n * @category constants\n * @since 0.1.0\n * @slop\n */\nexport const members = 6\n\n/**\n * How many levels below a result's own the digest descends.\n *\n * Five, because that is where a batched judgement keeps its answers. A\n * `classify` batch answers under `results[].answers.<question>.value`, which\n * is five levels down, and a digest that stopped above it reported\n * `results=[4]` about a call that had answered four questions. Measured on the\n * live seat over the three refused completions this bound was raised for:\n * with `results=[4]` the narrow question read `invented` 0.86, 0.87 and 0.86;\n * with the leaves named it read 0.11, 0.11 and 0.10. Below five the same\n * states read 0.24 to 0.49, because naming the first member of a batch says\n * what one state answered and the claim is about all of them.\n *\n * It is a depth and not a size: {@link resultWidth} is what keeps the line\n * bounded, and {@link members} is what keeps a wide result from taking it\n * over.\n *\n * @category constants\n * @since 0.1.0\n * @slop\n */\nexport const depth = 5\n\n/**\n * How many distinct values one leaf may report before the rest are counted.\n *\n * A leaf folded across a batch takes one value per member, and what a reader\n * needs from it is the spread: four states that all answered `true`, or three\n * that answered `true` and one that did not. Three distinct values say that;\n * a fourth says only that the leaf varies, which the count already said.\n *\n * @category constants\n * @since 0.1.0\n * @slop\n */\nexport const distinct = 3\n\n/**\n * How much of one call's result digest a line may quote.\n *\n * Wider than {@link width} because a digest is a list of leaves and a name is\n * one term. It is the bound the brake's receipt is held to as well: the\n * digest travels twice, once in the state section this module renders and\n * once as `CompletionClaim.Evidence.callsRun`'s `resultSummary`, and both are\n * the same string. Three hundred and twenty bytes holds the six leaves\n * {@link members} allows at the path lengths {@link depth} produces, and caps\n * the ledger's whole contribution to a frame at thirty lines of it.\n *\n * @category constants\n * @since 0.1.0\n * @slop\n */\nexport const resultWidth = 320\n\nconst clip = (text: string, limit: number): string => elide.head(text, limit, \"clipped\")\n\n/**\n * One settled call, as one line of the run's history.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Entry extends Schema.Class<Entry>(\"flows/harness/CallLedger/Entry\")({\n  /** The call's one-based position in the run's whole settled sequence. */\n  ordinal: NonNegativeSafeInt,\n  /** The flow the call named. */\n  flow: Schema.String,\n  /** What the call was about; see {@link subject}. */\n  subject: Schema.String,\n  /** Whether the call settled successfully. This is not the exit status. */\n  ok: Schema.Boolean,\n  /** The structural digest of what came back; see {@link digest}. */\n  digest: Schema.String,\n  /**\n   * The whole of what came back, in bytes of canonical JSON.\n   *\n   * Stated on every line, because a line is an index entry and the size is what\n   * says how much the name it points at is holding.\n   */\n  bytes: NonNegativeSafeInt.pipe(\n    Schema.withConstructorDefault(Effect.succeed(0)),\n    Schema.withDecodingDefaultKey(Effect.succeed(0))\n  ),\n  /**\n   * Whether this call reached the engine declaring that it changes the tree.\n   *\n   * A mutation is the one kind of call whose repetition is never compliance.\n   * Re-issuing a read costs bytes; re-issuing the check that failed is what rule\n   * 7 asks for; re-applying a hunk means the run either lost its own edit or\n   * undid it, and either way it is about to make a change it has already made.\n   * So the line says which calls wrote, and {@link render} points a repeated\n   * write back at the write it repeats.\n   */\n  mutates: Schema.Boolean.pipe(\n    Schema.withConstructorDefault(Effect.succeed(false)),\n    Schema.withDecodingDefaultKey(Effect.succeed(false))\n  ),\n  /**\n   * The bytes this call carried into the tree, for a call that declares a write.\n   *\n   * It is the longest string in the call's input — a `write`'s content, an\n   * `edit`'s replacement, a patch — measured the same flow-agnostic way\n   * `TruncatedOutput` measures a payload, and it is **not** a measured delta of\n   * the workspace. The harness has no per-call delta to report: its one honest\n   * measurement is `EngineLike.observe`, which covers a whole frame and counts\n   * paths rather than bytes. Stating the payload says what the call was, which\n   * is what makes two applications of one 4,789-byte patch legible as the same\n   * act; claiming a delta would say what the tree did, which this number does\n   * not know.\n   *\n   * The number is the payload and not the call: `sympy__sympy-13878` sent a\n   * 4,789-byte patch inside a 4,965-byte input, and it is the patch this reports,\n   * because the patch is the part two calls have in common.\n   */\n  payloadBytes: NonNegativeSafeInt.pipe(\n    Schema.withConstructorDefault(Effect.succeed(0)),\n    Schema.withDecodingDefaultKey(Effect.succeed(0))\n  ),\n  /**\n   * The digest of this call's flow and input together.\n   *\n   * Held rather than rendered: it is what lets a later identical write name the\n   * earlier one, and it is a digest so the ledger stays small enough to live in\n   * journaled controller state.\n   */\n  signature: Schema.String.pipe(\n    Schema.withConstructorDefault(Effect.succeed(\"\")),\n    Schema.withDecodingDefaultKey(Effect.succeed(\"\"))\n  )\n}) {}\n\n/**\n * The run's settled calls, oldest first and bounded to {@link bound}.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport const Ledger = Schema.Array(Entry).pipe(\n  Schema.withConstructorDefault(Effect.succeed<ReadonlyArray<Entry>>([])),\n  Schema.withDecodingDefaultKey(Effect.succeed<ReadonlyArray<Entry>>([]))\n)\n\n/**\n * The run's settled calls, oldest first and bounded to {@link bound}.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Ledger = typeof Ledger.Type\n\n/**\n * What one call was about: the first term of its input that names a target.\n *\n * `NarrowedCheck` already owns the lexer and the target/condition split, so a\n * path, a test id, a dotted module name, or the file inside a shell command is\n * picked out without this module knowing what any of those are. `names` is its\n * stricter reading of a target, because a subject nobody can recognize is worse\n * than no subject at all. An input with no such term is quoted whole instead,\n * clipped — a grep that targets only a glob is named by its own pattern and\n * root, which is what makes the line recognizable at all.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const subject = (input: Schema.Json): string => clip(sole(input) ?? CanonicalJson.stringify(input), width)\n\n/**\n * The one target an input names, or nothing when it names none or several.\n *\n * {@link target} takes the first, which is the right reading of a call about\n * one thing and the wrong reading of a call about many. A `classify` batch\n * over four files lexes four paths and was named by the first of them, so its\n * line read `classify notes/n1.txt`: a call about four states, named after\n * one of them, with the question it asked nowhere on the line. An input that\n * names several targets is quoted whole instead, clipped, which is where the\n * question is. Measured with the leaves of the result named either way, on\n * the live seat over three refused completions: named after one state the\n * narrow question read `invented` 0.73, 0.64 and 0.70; quoted whole it read\n * 0.11, 0.11 and 0.10.\n *\n * Distinct, not total: a patch that names one path on every hunk header names\n * one target, and it is the target.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const sole = (value: Schema.Json): string | undefined => {\n  const named = new Set(NarrowedCheck.lex(value).filter(NarrowedCheck.names))\n  const [only] = named\n  return named.size === 1 ? only : undefined\n}\n\n/**\n * The first term of a value that names a target, or nothing.\n *\n * Split out of {@link subject} because a write's target is not always in its\n * input. Usually it is, even inside a blob: the lexer reads a patch's own text,\n * so `sympy__sympy-13878`'s five applications each named\n * `sympy/stats/crv_types.py` off the `*** Update File:` line. The split is for\n * the write whose input names nothing a lexer can find — a patch that only adds\n * a file, an input that carries bytes and a handle — where the result is the one\n * place a path appears at all: `modified: [\"sympy/stats/crv_types.py\"]`. A line\n * that named such a write by its payload's first hundred bytes said nothing a\n * reader could match against the next one.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const target = (value: Schema.Json): string | undefined => NarrowedCheck.lex(value).find(NarrowedCheck.names)\n\nconst encoder = new TextEncoder()\n\nconst scalar = (value: unknown): string => {\n  if (typeof value === \"string\") return `${encoder.encode(value).byteLength}b`\n  if (Array.isArray(value)) return `[${value.length}]`\n  if (value !== null && typeof value === \"object\") return \"{…}\"\n  return String(value)\n}\n\nconst leafly = (value: unknown): boolean => value === null || typeof value !== \"object\"\n\n/** Whether a value reports itself whole: a scalar, or an array of them. */\nconst counted = (value: unknown): boolean =>\n  leafly(value) || (Array.isArray(value) && (value.length === 0 || value.every(leafly)))\n\n/**\n * Folds one result's leaves into the path each sits at and the values that\n * path took, in the order the walk met them.\n *\n * An array is walked into one path rather than one path per index: the members\n * of a batch answer the same question, so `results[].ok` is one leaf that took\n * four values and not four leaves that took one each. That is what makes a\n * four-state judgement fit a line.\n */\nconst leaves = (value: Schema.Json, path: string, into: Map<string, Array<string>>, left: number): void => {\n  const took = (rendered: string) => {\n    const seen = into.get(path)\n    if (seen === undefined) into.set(path, [rendered])\n    else seen.push(rendered)\n  }\n  if (counted(value) || left === 0) return took(scalar(value))\n  if (Array.isArray(value)) {\n    for (const item of value) leaves(item, `${path}[]`, into, left - 1)\n    return\n  }\n  const record = value as Readonly<Record<string, Schema.Json>>\n  const keys = Object.keys(record).sort()\n  // `{}` and not `{…}`: nothing was elided, the record is empty, and a reader\n  // that cannot tell those apart reads an empty result as a hidden one.\n  if (keys.length === 0) return took(\"{}\")\n  for (const key of keys) leaves(record[key]!, path === \"\" ? key : `${path}.${key}`, into, left - 1)\n}\n\n/**\n * What one leaf reported, across however many members it was folded over.\n *\n * Distinct values, each with how many members took it, capped at\n * {@link distinct}. A leaf one member deep reports its value alone, which is\n * what every unbatched result in this ledger reported before folding existed.\n */\nconst spread = (values: ReadonlyArray<string>): string => {\n  const tally = new Map<string, number>()\n  for (const value of values) tally.set(value, (tally.get(value) ?? 0) + 1)\n  const all = [...tally.entries()]\n  const named = all.slice(0, distinct).map(([value, count]) => count === 1 ? value : `${value}×${count}`)\n  const rest = all.length - named.length\n  return [...named, ...(rest > 0 ? [`+${rest} more`] : [])].join(\" \")\n}\n\n/**\n * The one-line structural digest of what a call returned.\n *\n * Counts and statuses, never payloads: a leaf that is a string reports its\n * byte length, an array of scalars reports its length, and a number or boolean\n * (an exit code, a truncation flag, a judgement) reports itself. Leaves are\n * named by their path in canonical key order and capped at {@link members}, so\n * the same result always renders the same line and a result with fifty leaves\n * cannot take the frame over.\n *\n * It descends {@link depth} levels, and an array of records folds into one\n * path per leaf with the values its members took, because the alternative was\n * measured and it was the defect. A `classify` batch returns its judgements\n * under `results[].answers.<question>.value`; a digest that named only the\n * result's own keys reported `results=[4]`, which records that four answers\n * arrived and not one of them. The completion brake reads this string as its\n * receipt for work that reports no exit status, so a run that judged four\n * files and said so was refused for reporting a result nothing recorded. See\n * {@link depth} for the readings either way.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const digest = (value: Schema.Json): string => {\n  if (counted(value)) return clip(scalar(value), resultWidth)\n  const found = new Map<string, Array<string>>()\n  leaves(value, \"\", found, depth)\n  const paths = [...found.keys()]\n  // The root has no name, so a result with nothing under it reports its own\n  // shape rather than an empty name bound to it.\n  const named = paths.slice(0, members).map((path) =>\n    path === \"\" ? spread(found.get(path)!) : `${path}=${spread(found.get(path)!)}`\n  )\n  const rest = paths.length - named.length\n  return clip([...named, ...(rest > 0 ? [`+${rest} more`] : [])].join(\" \"), resultWidth)\n}\n\n/**\n * The bytes one call carried into the tree: the longest string in its input.\n *\n * Flow-agnostic on purpose, and the same walk `TruncatedOutput` uses to find the\n * payload of a call it has never heard of. A `write` carries its content, an\n * `edit` its replacement, `apply_patch` its patch, and every one of them is the\n * longest string the input holds. A mutating call with no string at all — a\n * revert that names only a path — carries nothing and says zero.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const payload = (input: Schema.Json): number => {\n  if (typeof input === \"string\") return encoder.encode(input).byteLength\n  if (Array.isArray(input)) return input.reduce<number>((widest, item) => Math.max(widest, payload(item)), 0)\n  if (input === null || typeof input !== \"object\") return 0\n  return Object.values(input).reduce<number>((widest, item) => Math.max(widest, payload(item)), 0)\n}\n\n/**\n * One settled call, as the controller observed it.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Settlement {\n  readonly flow: string\n  readonly input: Schema.Json\n  readonly ok: boolean\n  readonly value: Schema.Json\n  readonly message?: string | undefined\n  /** Whether the call reached the engine declaring a write; see {@link Entry.mutates}. */\n  readonly mutates?: boolean | undefined\n}\n\n/**\n * Records one settled call.\n *\n * A call that failed carries what the flow said about the failure, because that\n * text — an anchor near-miss, a missing path — is the whole content of the\n * result and is otherwise seen only by a cell that thought to catch it.\n *\n * Every one of the four rendered fields is bounded, the flow name included. A\n * name that matches no descriptor still settles — as a failure saying so — and\n * the name is whatever the cell passed to `ctx.call`, which is a value the model\n * writes. `ctx.call(\"Z\".repeat(50000), {})` is one short line of JavaScript, and\n * without this bound it put fifty kilobytes into durable controller state and\n * into every remaining frame's prompt, thirty times over at the ledger's bound.\n * A real flow name is far under {@link width}, so the clip is invisible to every\n * call that names something callable.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const entry = (ordinal: number, call: Settlement): Entry => {\n  // `?? null` because a host can settle a call with no value at all: the\n  // contract says `Json`, an implementation that returns nothing says\n  // `undefined`, and canonical JSON refuses it. The ledger reports what the\n  // cell saw, which for such a call is `null`.\n  const whole = CanonicalJson.stringify(call.ok ? call.value ?? null : { failed: call.message ?? \"failed\" })\n  const mutates = call.mutates === true\n  return new Entry({\n    ordinal,\n    flow: clip(call.flow, width),\n    // A write whose input names nothing is named by what came back, because a\n    // patch carries its paths in its own text and hands them back as a list.\n    // A write is named by the first target it holds, wherever it holds it: a\n    // patch names one file per hunk header and every one of them is a target\n    // this write has, so {@link sole} would refuse a two-file patch a name.\n    subject: mutates\n      ? clip(target(call.input) ?? target(call.value) ?? CanonicalJson.stringify(call.input), width)\n      : subject(call.input),\n    ok: call.ok,\n    digest: call.ok ? digest(call.value) : clip(call.message ?? \"failed\", width),\n    bytes: encoder.encode(whole).byteLength,\n    mutates,\n    payloadBytes: mutates ? payload(call.input) : 0,\n    signature: mutates ? Digest.digest(CanonicalJson.stringify([call.flow, call.input])) : \"\"\n  })\n}\n\n/**\n * How many calls this run has settled, given a ledger some of whose lines have\n * aged out.\n *\n * The ledger holds at most {@link bound} lines, so its length stops being the\n * run's call count as soon as it fills. The newest entry's ordinal is the count\n * and does not, which is why ordinals are stored rather than rendered from an\n * index.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const settled = (ledger: Ledger): number => ledger.length === 0 ? 0 : ledger[ledger.length - 1]!.ordinal\n\n/**\n * Folds one frame's settled calls into the run's ledger, newest last.\n *\n * Ordinals continue the run's own sequence, so the numbers a model reads stay\n * the numbers the journal would give the same calls after older lines have aged\n * out of the bound.\n *\n * The ledger is an index, not a store: what a call returned is under the name\n * the cell bound it to, and it is that index the golf report credits with\n * deleting a whole frame class.\n *\n * @category combinators\n * @since 0.1.0\n * @slop\n */\nexport const remember = (known: Ledger, made: ReadonlyArray<Settlement>): Ledger => {\n  const before = settled(known)\n  const all = [...known, ...made.map((call, index) => entry(before + index + 1, call))]\n  return all.length <= bound ? all : all.slice(all.length - bound)\n}\n\n/**\n * Renders the ledger for the state section, or nothing when there is no call\n * to list.\n *\n * `since` is the newest ordinal an earlier section in the window already\n * listed. The window keeps every frame's section (see `CellTurn`), so a later\n * section lists only the calls settled after it; zero lists the whole ledger.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const render = (ledger: Ledger, since = 0): string | undefined => {\n  const listed = ledger.filter((line) => line.ordinal > since)\n  if (listed.length === 0) return undefined\n  const total = settled(ledger)\n  const elided = total - ledger.length\n  const heading = since > 0\n    ? `Calls this run has settled since the last list (${listed.length} of ${total}), oldest first. You have already asked these — read them here instead of asking again:`\n    : elided === 0\n    ? `Calls this run has settled (${total}), oldest first. You have already asked these — read them here instead of asking again:`\n    : `Calls this run has settled (${total}), oldest first; the ${elided} oldest are not listed. You have already asked these — read them here instead of asking again:`\n  // Where each write's signature was first settled, so a repeat can name it.\n  // First rather than most recent: the run wants the call it has already made,\n  // and the earliest one is the one every later copy repeats.\n  const first = new Map<string, Entry>()\n  for (const line of ledger) {\n    if (line.mutates && !first.has(line.signature)) first.set(line.signature, line)\n  }\n  const lines = listed.map((line) => {\n    const repeated = line.mutates ? first.get(line.signature) : undefined\n    const again = repeated === undefined || repeated.ordinal === line.ordinal\n      ? \"\"\n      : ` — the same write as ${repeated.ordinal}, which ${repeated.ok ? \"succeeded\" : \"failed\"}`\n    const wrote = line.mutates ? `WROTE ${line.payloadBytes}b, ` : \"\"\n    return `${line.ordinal}. ${line.flow} ${line.subject} — ${wrote}${\n      line.ok ? \"ok\" : \"FAILED\"\n    }${again}: ${line.digest} (${line.bytes}b)`\n  })\n  // Only where the run has actually written something: teaching about a marker\n  // nothing on the page carries costs a frame's worth of reading for nothing.\n  const writes = first.size === 0\n    ? \"\"\n    : \"\\nA line marked `WROTE` changed the tree, with the bytes it carried. One that names an earlier write made a change this run had already made: read what happened after the first one before making it a third time.\"\n  const trailer =\n    \"\\nThese are an index, not the results: what each call returned is still under the name your cell bound it to. Read the name; do not issue the call again.\"\n  return `${heading}\\n${lines.join(\"\\n\")}${trailer}${writes}`\n}\n"]}