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

package/dist/cjs/internal/bytes.js

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bytes_exports = {};
+__export(bytes_exports, {
+  headSlice: () => headSlice,
+  size: () => size,
+  tailSlice: () => tailSlice
+});
+module.exports = __toCommonJS(bytes_exports);
+const encoder = new TextEncoder();
+const size = (text) => encoder.encode(text).byteLength;
+const headSlice = (text, limit) => {
+  let end = 0;
+  let used = 0;
+  for (const character of text) {
+    const next = used + size(character);
+    if (next > limit) break;
+    used = next;
+    end = end + character.length;
+  }
+  return text.slice(0, end);
+};
+const tailSlice = (text, limit) => {
+  let start = text.length;
+  let used = 0;
+  while (start > 0) {
+    const last = text.charCodeAt(start - 1);
+    let units = 1;
+    if (last >= 56320 && last <= 57343 && start > 1) {
+      const previous = text.charCodeAt(start - 2);
+      if (previous >= 55296 && previous <= 56319) units = 2;
+    }
+    const width = units === 2 ? 4 : last < 128 ? 1 : last < 2048 ? 2 : 3;
+    const next = used + width;
+    if (next > limit) break;
+    used = next;
+    start = start - units;
+  }
+  return text.slice(start);
+};
+//# sourceMappingURL=bytes.js.map

package/dist/cjs/internal/bytes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/bytes.ts"],
+  "sourcesContent": ["/**\n * UTF-8 byte measurement and boundary-safe slicing.\n *\n * JavaScript indexes strings in UTF-16 code units, while every bound this\n * harness presents to a model and records in a journal is stated in UTF-8\n * bytes. These helpers keep that unit honest without ever cutting a code point\n * into an invalid string.\n *\n * @since 0.1.0\n * @private\n */\n\nconst encoder = new TextEncoder()\n\n/**\n * Measures a string in UTF-8 bytes.\n *\n * @category conversions\n * @since 0.1.0\n * @private\n */\nexport const size = (text: string): number => encoder.encode(text).byteLength\n\n/**\n * Returns the longest code-point-aligned prefix no wider than `limit` UTF-8 bytes.\n *\n * @category conversions\n * @since 0.1.0\n * @private\n */\nexport const headSlice = (text: string, limit: number): string => {\n  let end = 0\n  let used = 0\n  for (const character of text) {\n    const next = used + size(character)\n    if (next > limit) break\n    used = next\n    end = end + character.length\n  }\n  return text.slice(0, end)\n}\n\n/**\n * Returns the longest code-point-aligned suffix no wider than `limit` UTF-8 bytes.\n *\n * @category conversions\n * @since 0.1.0\n * @private\n */\nexport const tailSlice = (text: string, limit: number): string => {\n  let start = text.length\n  let used = 0\n  // Inspect only the suffix: a large print must not allocate an array for\n  // the discarded prefix or a TextEncoder buffer for each retained character.\n  while (start > 0) {\n    const last = text.charCodeAt(start - 1)\n    let units = 1\n    if (last >= 0xdc00 && last <= 0xdfff && start > 1) {\n      const previous = text.charCodeAt(start - 2)\n      if (previous >= 0xd800 && previous <= 0xdbff) units = 2\n    }\n    // Lone surrogates use three UTF-8 bytes, like TextEncoder's replacement.\n    const width = units === 2 ? 4 : last < 0x80 ? 1 : last < 0x800 ? 2 : 3\n    const next = used + width\n    if (next > limit) break\n    used = next\n    start = start - units\n  }\n  return text.slice(start)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,MAAM,UAAU,IAAI,YAAY;AASzB,MAAM,OAAO,CAAC,SAAyB,QAAQ,OAAO,IAAI,EAAE;AAS5D,MAAM,YAAY,CAAC,MAAc,UAA0B;AAChE,MAAI,MAAM;AACV,MAAI,OAAO;AACX,aAAW,aAAa,MAAM;AAC5B,UAAM,OAAO,OAAO,KAAK,SAAS;AAClC,QAAI,OAAO,MAAO;AAClB,WAAO;AACP,UAAM,MAAM,UAAU;AAAA,EACxB;AACA,SAAO,KAAK,MAAM,GAAG,GAAG;AAC1B;AASO,MAAM,YAAY,CAAC,MAAc,UAA0B;AAChE,MAAI,QAAQ,KAAK;AACjB,MAAI,OAAO;AAGX,SAAO,QAAQ,GAAG;AAChB,UAAM,OAAO,KAAK,WAAW,QAAQ,CAAC;AACtC,QAAI,QAAQ;AACZ,QAAI,QAAQ,SAAU,QAAQ,SAAU,QAAQ,GAAG;AACjD,YAAM,WAAW,KAAK,WAAW,QAAQ,CAAC;AAC1C,UAAI,YAAY,SAAU,YAAY,MAAQ,SAAQ;AAAA,IACxD;AAEA,UAAM,QAAQ,UAAU,IAAI,IAAI,OAAO,MAAO,IAAI,OAAO,OAAQ,IAAI;AACrE,UAAM,OAAO,OAAO;AACpB,QAAI,OAAO,MAAO;AAClB,WAAO;AACP,YAAQ,QAAQ;AAAA,EAClB;AACA,SAAO,KAAK,MAAM,KAAK;AACzB;",
+  "names": []
+}

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

@@ -0,0 +1,122 @@
+/**
+ * The one contract the cell-first harness teaches a model.
+ *
+ * This contract is plain JavaScript over `ctx.call`, shaped to look like the
+ * Claude Code workflow API, and that is a ruling rather than an accident: will
+ * ruled on 2026-08-20 that the model authoring surface stays this shape,
+ * because agents perform better on the shape they are trained on. Effect.ts is
+ * the language of the code we maintain, not the language the model writes. Do
+ * not port this contract onto `Flow`/`Action`/`Node`; that was built out under
+ * a 2026-08-12 ruling and reversed. It may be tested later as a benchmark arm
+ * and is adopted only if it benchmarks better.
+ *
+ * There is one contract, and it is the REPL's. The surface it replaced — a cell
+ * as the body of its own async function, filing JSON into `state` and choosing
+ * its successor's `context` by hand — is recorded as a design error rather than
+ * as an arm that lost: it made the model do the realm's job, which is why it
+ * never worked like a REPL. will ruled it out on 2026-08-24. The evidence and
+ * the ruling are in `../../docs/concepts.md#repl-realm`.
+ *
+ * The teaching here is measured, not preferred, and the measurement has now run
+ * both ways. The merged optimal-trace program
+ * predicted that more teaching
+ * would buy verdicts, and grew the contract it replaced from 8,197 to 11,312
+ * characters across changes 2, 9 and 10. The re-run that settles those
+ * predictions says it did not:
+ * resolved fell 35/45 to 30/45, cost rose 59 %, and five instances spent a whole
+ * 1,200 s budget without editing one byte, held there by an unconditional
+ * pre-edit reproduction rule. The same wave shows every *tool* change paying.
+ * That is why the rules below carry their traces and why a teaching change is
+ * made one at a time.
+ *
+ * The exception rule 8 used to state — "when the command will not bootstrap,
+ * edit on the diagnosis you have and establish the proof afterwards" — is gone,
+ * and it is gone because the thing it was managing no longer exists. It existed
+ * to relieve an *ordering*: a baseline had to be taken before the edit, so a
+ * baseline that could not be taken yet blocked the edit. Checkpoints remove the
+ * ordering outright (will, 2026-08-24). The baseline is now taken after the
+ * edit, against `ctx.base`, so there is nothing left to make conditional and a
+ * sentence offering relief from a constraint the contract no longer imposes is
+ * teaching a shape that is not the shape.
+ *
+ * The same ruling is why the worked examples put the edit first and the
+ * baseline second. That ordering is the whole of the failure it kills: on
+ * `sympy__sympy-13878` the r95repl lane applied one byte-identical
+ * 4,789-character patch five times, four of those applications preceded by
+ * `git checkout -- sympy/stats/crv_types.py`, because a clean fails-before
+ * proof required reverting the very work it was meant to prove. Models imitate
+ * the example, and the example now shows a run that never gives its work back.
+ *
+ * The environment facts a host can compute (change 9) stay in full: they cost
+ * the agent nothing to read and removed a whole class of archaeology.
+ *
+ * Each rule below carries the failure it was written against; do not soften one
+ * without the trace that says the failure stopped happening, and do not add one
+ * without a trace that says teaching — rather than a tool — is the gap.
+ *
+ * Governing design: `../../docs/concepts.md#model-authoring-surface` (the
+ * ruling) and `../../docs/concepts.md#agent-cell-context` (the surface).
+ *
+ * @since 0.1.0
+ */
+import type * as Descriptor from "@smthrs/registry/Descriptor";
+import type * as AgentEvent from "../AgentEvent.ts";
+import type * as Cell from "../Cell.ts";
+/**
+ * One rendered prompt section, with the digest that identifies its
+ * content.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface Section {
+    readonly id: "cell-contract" | "cell-stance" | "cell-environment" | "cell-jev" | "cell-catalog";
+    readonly text: string;
+    readonly digest: string;
+}
+/**
+ * Facts about the container a run executes in, computed by the harness.
+ *
+ * Every field is something the host can read off the environment without
+ * knowing anything about the task, which is the whole admission rule: the
+ * program that motivated this section rejects instance-specific teaching
+ * outright, so the shape is a closed set of typed fields rather than free
+ * prose a caller could smuggle an answer into. Facts that are absent are not
+ * rendered; the run discovers them the ordinary way.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Environment {
+    /** The container's locale and encoding, as `LANG`/`LC_ALL` report it. */
+    readonly locale?: string;
+    /** Tools a run will reach for that this image does not install. */
+    readonly absentTools?: ReadonlyArray<string>;
+}
+type CatalogProjection = Cell.FlowProjection & Partial<Pick<Descriptor.FlowDescriptor, "provenance" | "path">>;
+/**
+ * Builds the cell-contract teaching sections for one frame.
+ *
+ * The order is by how often each section changes, because every one of them is
+ * a prefix segment and a prefix is only cached up to its first edit: the
+ * contract is constant for the life of the binary, the environment and the
+ * `jev` teaching for the life of a run, and the catalog can differ frame to
+ * frame. The `jev` teaching is rendered only when `flows` binds `jev`.
+ *
+ * `stance` renders a one-line `cell-stance` section between the contract and
+ * the environment. It is constant for the run, so the cached prefix holds;
+ * with no stance nothing is rendered and the prompt is unchanged.
+ *
+ * `environment` carries what the host measured about the container. It is
+ * optional because the epoch fact — a checkout has no future in it — holds
+ * everywhere and is stated with or without a host that measures anything else.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const make: (flows: Readonly<Record<string, CatalogProjection>>, environment?: Environment, stance?: typeof AgentEvent.Stance.Type) => ReadonlyArray<Section>;
+export {};
+//# sourceMappingURL=cellPrompt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cellPrompt.d.ts","sourceRoot":"","sources":["../../../src/internal/cellPrompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAIH,OAAO,KAAK,KAAK,UAAU,MAAM,6BAA6B,CAAA;AAE9D,OAAO,KAAK,KAAK,UAAU,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,YAAY,CAAA;AAIvC;;;;;;;GAOG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,EAAE,EAAE,eAAe,GAAG,aAAa,GAAG,kBAAkB,GAAG,UAAU,GAAG,cAAc,CAAA;IAC/F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,WAAW;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAC7C;AAgKD,KAAK,iBAAiB,GAAG,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,YAAY,GAAG,MAAM,CAAC,CAAC,CAAA;AA+B9G;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,IAAI,GACf,OAAO,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,EAClD,cAAa,WAAgB,EAC7B,SAAS,OAAO,UAAU,CAAC,MAAM,CAAC,IAAI,KACrC,aAAa,CAAC,OAAO,CAgBvB,CAAA"}

package/dist/cjs/internal/cellPrompt.js

@@ -0,0 +1,146 @@
+"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 cellPrompt_exports = {};
+__export(cellPrompt_exports, {
+  make: () => make
+});
+module.exports = __toCommonJS(cellPrompt_exports);
+var Digest = __toESM(require("@smthrs/core/Digest"), 1);
+var CanonicalJson = __toESM(require("@smthrs/model/CanonicalJson"), 1);
+var import_effect = require("effect");
+var Monitor = __toESM(require("../Monitor.js"), 1);
+var import_untrustedData = require("./untrustedData.js");
+const replContract = `JavaScript REPL, one cell per turn, alive for the whole run.
+
+Every reply MUST contain a fenced \`cell\` block, JavaScript only. Several blocks in one reply run as ONE program.
+
+Top-level bindings persist across cells, as in any REPL. \`console.log\` output opens your next turn and stays in context; unprinted values stay in their variables.
+
+Example bug fix, two cells. Names illustrative; call what \`ctx.flows\` lists.
+
+\`\`\`cell
+const found = await ctx.call("grep", { pattern: "return value", root: "src/units", limit: 5 })
+const hit = found.ok === false ? undefined : found.matches[0]   // failed calls resolve, never throw
+const region = await ctx.call("read", { path: hit.file, offset: Math.max(1, hit.line - 20), limit: 40 })
+console.log(region.content)
+\`\`\`
+
+\`\`\`cell
+const verification = { flow: "bash", input: { command: "run-tests tests/test_widen.py::test_keeps_unit" } }
+const anchor = hit.text                                         // text a call returned, never typed from memory
+const applied = await ctx.call("edit", { path: hit.file, oldString: anchor, newString: anchor.replace("return value", "return widen(value)") })
+const before = await ctx.call(verification.flow, verification.input, { at: ctx.base })  // opening tree; edit stays
+const after = await ctx.call(verification.flow, verification.input)
+console.log(applied.ok === false ? applied.error.message : applied.hunk, before.exitCode, after.exitCode, after.stdout)
+if (before.exitCode !== 0 && after.exitCode === 0) ctx.done(verification.input.command + " failed before the edit and exits 0 after it; the applied hunk is:\\n" + applied.hunk)
+\`\`\`
+
+Many calls per cell; one call per frame wastes turns.
+
+Rules:
+
+1. Bindings: \`ctx\`, \`console\`, earlier cells' names. \`ctx.call(name, input)\` runs a flow; \`ctx.flows\` lists them. No imports, require, fetch, filesystem, process, Date, Math.random; anything else throws. Strings passed to flows are data (a Python heredoc is fine).
+2. Every effect is a flow: files, commands, memory, questions, subagents.
+3. A failed call does not throw: resolves \`{ ok: false, error: { code, message, hint } }\`; test \`.ok === false\` where you are unsure. Success resolves the result unwrapped. A throwing cell keeps names already assigned. Long calls spend the flow's budget, not the cell's. Output is capped: a result flagged truncated is a fragment. Restore files with git checkout or git restore; never route file content through captured stdout (a write of bytes a call returned truncated is refused).
+4. Print only what you must read; keep the rest in variables. Each turn opens with your last print, bound names, and one line per settled call (tree writes and repeats flagged). Prints are re-paid every turn: \u226440 lines a cell; never whole listings, search results, files or intermediates. Counts and paths first (\`console.log(hits.matches.length, files.slice(0, 15))\`, not \`console.log(hits)\`), then read only the chosen region. Structures print as JSON; record lists as tables.
+5. Finish by calling. \`ctx.done(output)\` ends the run; \`output\` is the answer. \`ctx.park(reason, message)\` waits durably for a human; reason "waiting-input" | "waiting-event" | "waiting-quota"; refused when nobody listens. Both take effect at that line; later calls in the cell resolve \`{ ok: false, error: { code: "run_completed" } }\`. Conversational or read-only request: \`ctx.done(answer)\` directly; no edit, command, baseline or tree review. \`console.log\` alone does not finish. Workspace change: finish behind the deciding check, \`if (after.exitCode === 0) ctx.done(...)\`. Let the guard read the tree too: \`git status --porcelain\` and \`git diff\` in the completing cell; finish silently only when the check passes AND the diff holds exactly the files you meant to change, else \`console.log\` that diff. A bare \`ctx.done\` is allowed but is a claim nobody checked: say what is unverified. Name each claimed check's exact command and output. A cell calling neither ends the turn.
+6. Resume re-executes cells from the top; settled calls replay recorded results.
+7. Bug-fix evidence: a command counts only after you SEE it fail on the unmodified tree FOR THE RIGHT REASON (the bug). A probe naming a test, file, module or program that does not exist reproduces nothing; \`invalidProbe\` flags some. Fix such a probe before you rely on it. Keep the check as \`verification = { flow, input }\`; reuse it unchanged after edits.
+8. Workspace change: read broadly in ONE cell, then edit. Too many frames without a write stop the run; near the limit, edit or \`ctx.justify("<missing evidence, the call that gets it, what changes next>")\`. An edit answers with the hunk it applied: print it in the same cell (a bad edit costs one glance there). Then run whatever language-aware checker \`ctx.flows\` and this image actually offer (compiler, ruff, eslint/tsc) through the shell flow. Fix undefined names before broad suites. No checker: say so; never regex-guess.
+9. Bug-fix proof, fewest frames: ONE cell edits, runs the baseline at \`{ at: ctx.base }\` (opening tree), reruns the identical check. NEVER undo your own edit to re-prove a baseline. \`ctx.checkpoint()\` pins the current tree for your own baseline; a checkpoint is read-only, so a flow that writes is refused at one. Let code decide: \`if (before.exitCode !== 0 && after.exitCode === 0) ctx.done(...)\`. An already-green suite or a probe that misses its target proves nothing.
+
+Cell throws: you are told, next turn. If a cell does not PARSE nothing ran at all; you are asked again inside the SAME frame with the error and line.`;
+const jevText = `1. Use \`jev\` for any judgment over >3 items and any yes/no, pick-one or score you would otherwise make by printing and reading (relevant files, related failures, rankings, which subtask needs a worker). ONE call: items in \`state:\`, one question per item keyed by your id. Hundreds take ~300 ms.
+2. Never make one call per item; never ask \`jev\` for text, code or quotes.
+3. Failure resolves \`{ ok: false }\`: print \`error.message\`; do not decide in its place.
+4. Act on booleans when \`answers[id].probability >= 0.8\`; on choice or score when \`judged.confidence?.[id] >= 0.7\` (provider confidence; absent = uncertain). Never use a choice's own \`.confidence\` (reads 1 without a distribution). Print uncertain items; don't decide them.
+
+\`\`\`cell
+const found = await ctx.call("grep", { pattern: "timeout", root: "src", limit: 200 })
+const files = found.ok === false ? [] : [...new Set(found.matches.map((m) => m.file))]
+const judged = await ctx.call("jev", { state: { task: "the timeout ignores its setting", files }, questions: Object.fromEntries(files.map((f) => [f, { type: "boolean", instructions: "Must " + f + " change?" }])) })
+const p = (f) => judged.answers[f].probability
+const kept = judged.ok === false ? [] : files.filter((f) => p(f) >= 0.8)
+const uncertain = judged.ok === false ? [] : files.filter((f) => p(f) > 0.2 && p(f) < 0.8)
+console.log(found.ok === false ? found.error.message : judged.ok === false ? judged.error.message : { count: files.length, kept, uncertain })
+\`\`\``;
+const stanceText = (stance) => stance === "paranoid" ? Monitor.paranoidText : Monitor.carefulText;
+const historyFact = `the checkout ends at the commit you were given; no branch, tag, stash or reflog here holds a later fix, so \`git log --all\` or \`-S\` hunting costs a frame and returns nothing. The harness keeps its own attempt and durability snapshots in a repository of its own. A dangling commit is this harness pinning your own tree for a checkpoint: \`git fsck\` reports your edit and never a fix. Backwards history pays: \`git blame\` or \`git log -S\` on a line says what an assertion was written for; given a last-known-good release, \`git log <tag>..HEAD -- <paths>\`.`;
+const environmentText = (environment) => {
+  const lines = [`- History: ${historyFact}`];
+  if (environment.locale !== void 0) {
+    lines.push(
+      `- Locale: ${environment.locale}; output and files decode as that.`
+    );
+  }
+  const absent = environment.absentTools === void 0 ? [] : [...environment.absentTools].sort();
+  if (absent.length > 0) {
+    lines.push(
+      `- Not installed: ${absent.join(", ")}. Calls to them fail; use \`ctx.flows\`.`
+    );
+  }
+  return `Harness-computed facts about the checkout and container, not the task.
+${lines.join("\n")}`;
+};
+const digest = (id, text) => Digest.digest(CanonicalJson.stringify({ id, text }));
+const catalogText = (flows) => {
+  const names = Object.keys(flows).sort();
+  if (names.length === 0) {
+    return "No flows are callable in this run. Complete or park; ctx.call has nothing to reach.";
+  }
+  const lines = names.map((name) => {
+    const projection = flows[name];
+    const capabilities = projection.capabilities.length === 0 ? "" : ` capabilities=${[...projection.capabilities].sort().join(",")}`;
+    const origin = JSON.stringify({
+      source: projection.provenance?.source ?? "unknown",
+      root: projection.provenance?.root,
+      path: projection.path
+    });
+    const heading = `- ${name} (${projection.tier})${capabilities}: ${projection.description}
+  provenance: ${origin}`;
+    return import_effect.Option.isNone(projection.input) ? heading : `${heading}
+  input: ${JSON.stringify(projection.input.value)}`;
+  });
+  return `Flows callable with ctx.call in this frame:
+${(0, import_untrustedData.untrustedData)(lines.join("\n"), "flow catalog (descriptor provenance follows)")}`;
+};
+const make = (flows, environment = {}, stance) => {
+  const facts = environmentText(environment);
+  const catalog = catalogText(flows);
+  const taught = replContract;
+  const stanced = stance === void 0 ? void 0 : stanceText(stance);
+  return [
+    { id: "cell-contract", text: taught, digest: digest("cell-contract", taught) },
+    ...stanced === void 0 ? [] : [{ id: "cell-stance", text: stanced, digest: digest("cell-stance", stanced) }],
+    { id: "cell-environment", text: facts, digest: digest("cell-environment", facts) },
+    ...flows.jev === void 0 ? [] : [{ id: "cell-jev", text: jevText, digest: digest("cell-jev", jevText) }],
+    { id: "cell-catalog", text: catalog, digest: digest("cell-catalog", catalog) }
+  ];
+};
+//# sourceMappingURL=cellPrompt.js.map

package/dist/cjs/internal/cellPrompt.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/cellPrompt.ts"],
+  "sourcesContent": ["/**\n * The one contract the cell-first harness teaches a model.\n *\n * This contract is plain JavaScript over `ctx.call`, shaped to look like the\n * Claude Code workflow API, and that is a ruling rather than an accident: will\n * ruled on 2026-08-20 that the model authoring surface stays this shape,\n * because agents perform better on the shape they are trained on. Effect.ts is\n * the language of the code we maintain, not the language the model writes. Do\n * not port this contract onto `Flow`/`Action`/`Node`; that was built out under\n * a 2026-08-12 ruling and reversed. It may be tested later as a benchmark arm\n * and is adopted only if it benchmarks better.\n *\n * There is one contract, and it is the REPL's. The surface it replaced \u2014 a cell\n * as the body of its own async function, filing JSON into `state` and choosing\n * its successor's `context` by hand \u2014 is recorded as a design error rather than\n * as an arm that lost: it made the model do the realm's job, which is why it\n * never worked like a REPL. will ruled it out on 2026-08-24. The evidence and\n * the ruling are in `../../docs/concepts.md#repl-realm`.\n *\n * The teaching here is measured, not preferred, and the measurement has now run\n * both ways. The merged optimal-trace program\n * predicted that more teaching\n * would buy verdicts, and grew the contract it replaced from 8,197 to 11,312\n * characters across changes 2, 9 and 10. The re-run that settles those\n * predictions says it did not:\n * resolved fell 35/45 to 30/45, cost rose 59 %, and five instances spent a whole\n * 1,200 s budget without editing one byte, held there by an unconditional\n * pre-edit reproduction rule. The same wave shows every *tool* change paying.\n * That is why the rules below carry their traces and why a teaching change is\n * made one at a time.\n *\n * The exception rule 8 used to state \u2014 \"when the command will not bootstrap,\n * edit on the diagnosis you have and establish the proof afterwards\" \u2014 is gone,\n * and it is gone because the thing it was managing no longer exists. It existed\n * to relieve an *ordering*: a baseline had to be taken before the edit, so a\n * baseline that could not be taken yet blocked the edit. Checkpoints remove the\n * ordering outright (will, 2026-08-24). The baseline is now taken after the\n * edit, against `ctx.base`, so there is nothing left to make conditional and a\n * sentence offering relief from a constraint the contract no longer imposes is\n * teaching a shape that is not the shape.\n *\n * The same ruling is why the worked examples put the edit first and the\n * baseline second. That ordering is the whole of the failure it kills: on\n * `sympy__sympy-13878` the r95repl lane applied one byte-identical\n * 4,789-character patch five times, four of those applications preceded by\n * `git checkout -- sympy/stats/crv_types.py`, because a clean fails-before\n * proof required reverting the very work it was meant to prove. Models imitate\n * the example, and the example now shows a run that never gives its work back.\n *\n * The environment facts a host can compute (change 9) stay in full: they cost\n * the agent nothing to read and removed a whole class of archaeology.\n *\n * Each rule below carries the failure it was written against; do not soften one\n * without the trace that says the failure stopped happening, and do not add one\n * without a trace that says teaching \u2014 rather than a tool \u2014 is the gap.\n *\n * Governing design: `../../docs/concepts.md#model-authoring-surface` (the\n * ruling) and `../../docs/concepts.md#agent-cell-context` (the surface).\n *\n * @since 0.1.0\n */\n\nimport * as Digest from \"@smthrs/core/Digest\"\nimport * as CanonicalJson from \"@smthrs/model/CanonicalJson\"\nimport type * as Descriptor from \"@smthrs/registry/Descriptor\"\nimport { Option } from \"effect\"\nimport type * as AgentEvent from \"../AgentEvent.ts\"\nimport type * as Cell from \"../Cell.ts\"\nimport * as Monitor from \"../Monitor.ts\"\nimport { untrustedData } from \"./untrustedData.ts\"\n\n/**\n * One rendered prompt section, with the digest that identifies its\n * content.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface Section {\n  readonly id: \"cell-contract\" | \"cell-stance\" | \"cell-environment\" | \"cell-jev\" | \"cell-catalog\"\n  readonly text: string\n  readonly digest: string\n}\n\n/**\n * Facts about the container a run executes in, computed by the harness.\n *\n * Every field is something the host can read off the environment without\n * knowing anything about the task, which is the whole admission rule: the\n * program that motivated this section rejects instance-specific teaching\n * outright, so the shape is a closed set of typed fields rather than free\n * prose a caller could smuggle an answer into. Facts that are absent are not\n * rendered; the run discovers them the ordinary way.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Environment {\n  /** The container's locale and encoding, as `LANG`/`LC_ALL` report it. */\n  readonly locale?: string\n  /** Tools a run will reach for that this image does not install. */\n  readonly absentTools?: ReadonlyArray<string>\n}\n\n/**\n * The contract every run is taught.\n *\n * It is the contract that replaced the filing one, and the difference is exactly\n * the difference in the surface: there is no returned object to describe, no\n * `state` to file, no manifest to read, and no `render`/`recall` to name,\n * because the variable is the memory and the print is the summary.\n *\n * Every rule with a trace behind it was carried across byte-similar when the\n * surface changed, and that was deliberate: the r91 rerun grew the old contract\n * from 8,197 to 11,312 characters and dropped resolved from 35/45 to 30/45 at\n * 59 % more cost, which says teaching changes are expensive and must be measured\n * one at a time. A wave that changed the realm *and* re-cut the doctrine could\n * not attribute its own result. Cutting further is its own arm, with its own\n * wave.\n *\n * The second worked example is the golf report's own prescription \u2014 its\n * class-(a) finding is that the contract's only worked example is a three-line\n * toy, and models imitate the example.\n *\n * It moved a second time on 2026-08-24, when checkpoints landed: the baseline\n * moved after the edit in the example and rule 9 names `ctx.base`. Both pinned\n * numbers moved with it.\n *\n * The completion teaching first moved after the first REPL wave, and the change\n * is stated rather than smuggled. What died is the see-then-attest rule\n * (\"complete only once you have SEEN that identical command pass\"): it asked for\n * a memory of a result and got one, and `sympy__sympy-13878` ended by claiming\n * in `output` that a suite \"exited 0 and printed its passing test summary\" one\n * frame after its own guarded `ctx.done` had declined to fire because that suite\n * exited 1. What replaces it is the shape the model had already written and\n * abandoned: complete behind a check of the result, `if (after.exitCode === 0)\n * ctx.done(...)`, so the verdict is read from the call rather than remembered\n * across a turn. An unguarded completion stays legal \u2014 sometimes nothing in the\n * image can be made to flip \u2014 and is named for what it is, a claim nobody\n * checked. That is will's ruling of 2026-08-23, and it is why the pinned length\n * in `test/CellPrompt.test.ts` moved.\n *\n * Task scoping moved on 2026-09-19 after a chat request to answer only A spent\n * twelve frames printing and then looking for an unrelated failing test.\n * The host already taught same-cell completion, but these rules required an\n * edit and a proving command unconditionally. The scoped contract completed\n * the retained natural-language opening in six of six probes, against four\n * of six for the old contract. A seeded six-print loop still did not recover\n * the exact answer; the unchanged read-only cap remains necessary. The edit,\n * baseline and tree-review requirements remain for requested workspace work.\n *\n * Rule 10 and rule 4's `jev` clause moved to the `cell-jev` section on\n * 2026-09-25 (#1929), so a run with no `jev` bound is not taught it.\n *\n * On 2026-09-30 will ruled for token economy: every rule stays, prose becomes\n * fragments, 9,715 \u2192 5,553 characters. No wave has measured this wording yet.\n *\n * Governing design: `../../docs/concepts.md#repl-realm`.\n */\nconst replContract = `JavaScript REPL, one cell per turn, alive for the whole run.\n\nEvery reply MUST contain a fenced \\`cell\\` block, JavaScript only. Several blocks in one reply run as ONE program.\n\nTop-level bindings persist across cells, as in any REPL. \\`console.log\\` output opens your next turn and stays in context; unprinted values stay in their variables.\n\nExample bug fix, two cells. Names illustrative; call what \\`ctx.flows\\` lists.\n\n\\`\\`\\`cell\nconst found = await ctx.call(\"grep\", { pattern: \"return value\", root: \"src/units\", limit: 5 })\nconst hit = found.ok === false ? undefined : found.matches[0]   // failed calls resolve, never throw\nconst region = await ctx.call(\"read\", { path: hit.file, offset: Math.max(1, hit.line - 20), limit: 40 })\nconsole.log(region.content)\n\\`\\`\\`\n\n\\`\\`\\`cell\nconst verification = { flow: \"bash\", input: { command: \"run-tests tests/test_widen.py::test_keeps_unit\" } }\nconst anchor = hit.text                                         // text a call returned, never typed from memory\nconst applied = await ctx.call(\"edit\", { path: hit.file, oldString: anchor, newString: anchor.replace(\"return value\", \"return widen(value)\") })\nconst before = await ctx.call(verification.flow, verification.input, { at: ctx.base })  // opening tree; edit stays\nconst after = await ctx.call(verification.flow, verification.input)\nconsole.log(applied.ok === false ? applied.error.message : applied.hunk, before.exitCode, after.exitCode, after.stdout)\nif (before.exitCode !== 0 && after.exitCode === 0) ctx.done(verification.input.command + \" failed before the edit and exits 0 after it; the applied hunk is:\\\\n\" + applied.hunk)\n\\`\\`\\`\n\nMany calls per cell; one call per frame wastes turns.\n\nRules:\n\n1. Bindings: \\`ctx\\`, \\`console\\`, earlier cells' names. \\`ctx.call(name, input)\\` runs a flow; \\`ctx.flows\\` lists them. No imports, require, fetch, filesystem, process, Date, Math.random; anything else throws. Strings passed to flows are data (a Python heredoc is fine).\n2. Every effect is a flow: files, commands, memory, questions, subagents.\n3. A failed call does not throw: resolves \\`{ ok: false, error: { code, message, hint } }\\`; test \\`.ok === false\\` where you are unsure. Success resolves the result unwrapped. A throwing cell keeps names already assigned. Long calls spend the flow's budget, not the cell's. Output is capped: a result flagged truncated is a fragment. Restore files with git checkout or git restore; never route file content through captured stdout (a write of bytes a call returned truncated is refused).\n4. Print only what you must read; keep the rest in variables. Each turn opens with your last print, bound names, and one line per settled call (tree writes and repeats flagged). Prints are re-paid every turn: \u226440 lines a cell; never whole listings, search results, files or intermediates. Counts and paths first (\\`console.log(hits.matches.length, files.slice(0, 15))\\`, not \\`console.log(hits)\\`), then read only the chosen region. Structures print as JSON; record lists as tables.\n5. Finish by calling. \\`ctx.done(output)\\` ends the run; \\`output\\` is the answer. \\`ctx.park(reason, message)\\` waits durably for a human; reason \"waiting-input\" | \"waiting-event\" | \"waiting-quota\"; refused when nobody listens. Both take effect at that line; later calls in the cell resolve \\`{ ok: false, error: { code: \"run_completed\" } }\\`. Conversational or read-only request: \\`ctx.done(answer)\\` directly; no edit, command, baseline or tree review. \\`console.log\\` alone does not finish. Workspace change: finish behind the deciding check, \\`if (after.exitCode === 0) ctx.done(...)\\`. Let the guard read the tree too: \\`git status --porcelain\\` and \\`git diff\\` in the completing cell; finish silently only when the check passes AND the diff holds exactly the files you meant to change, else \\`console.log\\` that diff. A bare \\`ctx.done\\` is allowed but is a claim nobody checked: say what is unverified. Name each claimed check's exact command and output. A cell calling neither ends the turn.\n6. Resume re-executes cells from the top; settled calls replay recorded results.\n7. Bug-fix evidence: a command counts only after you SEE it fail on the unmodified tree FOR THE RIGHT REASON (the bug). A probe naming a test, file, module or program that does not exist reproduces nothing; \\`invalidProbe\\` flags some. Fix such a probe before you rely on it. Keep the check as \\`verification = { flow, input }\\`; reuse it unchanged after edits.\n8. Workspace change: read broadly in ONE cell, then edit. Too many frames without a write stop the run; near the limit, edit or \\`ctx.justify(\"<missing evidence, the call that gets it, what changes next>\")\\`. An edit answers with the hunk it applied: print it in the same cell (a bad edit costs one glance there). Then run whatever language-aware checker \\`ctx.flows\\` and this image actually offer (compiler, ruff, eslint/tsc) through the shell flow. Fix undefined names before broad suites. No checker: say so; never regex-guess.\n9. Bug-fix proof, fewest frames: ONE cell edits, runs the baseline at \\`{ at: ctx.base }\\` (opening tree), reruns the identical check. NEVER undo your own edit to re-prove a baseline. \\`ctx.checkpoint()\\` pins the current tree for your own baseline; a checkpoint is read-only, so a flow that writes is refused at one. Let code decide: \\`if (before.exitCode !== 0 && after.exitCode === 0) ctx.done(...)\\`. An already-green suite or a probe that misses its target proves nothing.\n\nCell throws: you are told, next turn. If a cell does not PARSE nothing ran at all; you are asked again inside the SAME frame with the error and line.`\n\n/**\n * How a cell uses the `jev` flow, taught only when the catalog binds it.\n *\n * It was rule 10 of the contract and a clause of rule 4 until 2026-09-25, when\n * will asked for Jev to be used strongly in the cells a model writes (#1929).\n * A rule that names a flow the catalog may not hold teaches a call that\n * resolves `unknown_flow`, so the teaching moved into a section of its own\n * that exists exactly when the flow does. It is constant for a run, so it sits\n * between the environment and the catalog without breaking the cached prefix.\n *\n * The floors are the owner's: act on a boolean at probability 0.8, and on a\n * choice or score at the provider's confidence 0.7. A choice's own\n * `.confidence` is the largest probability in its distribution and reads 1\n * when none was sent, so the teaching names the provider's number instead.\n *\n * The one worked example is run verbatim by `test/CellFlows.test.ts` against\n * the real `grep` and `jev` bindings, because a model copies the example.\n */\nconst jevText =\n  `1. Use \\`jev\\` for any judgment over >3 items and any yes/no, pick-one or score you would otherwise make by printing and reading (relevant files, related failures, rankings, which subtask needs a worker). ONE call: items in \\`state:\\`, one question per item keyed by your id. Hundreds take ~300 ms.\n2. Never make one call per item; never ask \\`jev\\` for text, code or quotes.\n3. Failure resolves \\`{ ok: false }\\`: print \\`error.message\\`; do not decide in its place.\n4. Act on booleans when \\`answers[id].probability >= 0.8\\`; on choice or score when \\`judged.confidence?.[id] >= 0.7\\` (provider confidence; absent = uncertain). Never use a choice's own \\`.confidence\\` (reads 1 without a distribution). Print uncertain items; don't decide them.\n\n\\`\\`\\`cell\nconst found = await ctx.call(\"grep\", { pattern: \"timeout\", root: \"src\", limit: 200 })\nconst files = found.ok === false ? [] : [...new Set(found.matches.map((m) => m.file))]\nconst judged = await ctx.call(\"jev\", { state: { task: \"the timeout ignores its setting\", files }, questions: Object.fromEntries(files.map((f) => [f, { type: \"boolean\", instructions: \"Must \" + f + \" change?\" }])) })\nconst p = (f) => judged.answers[f].probability\nconst kept = judged.ok === false ? [] : files.filter((f) => p(f) >= 0.8)\nconst uncertain = judged.ok === false ? [] : files.filter((f) => p(f) > 0.2 && p(f) < 0.8)\nconsole.log(found.ok === false ? found.error.message : judged.ok === false ? judged.error.message : { count: files.length, kept, uncertain })\n\\`\\`\\``\n\n/**\n * The one line a judged run is taught about its stance: the Monitor mood text,\n * verbatim, so the static stance and the delivered mood never disagree.\n */\nconst stanceText = (stance: typeof AgentEvent.Stance.Type): string =>\n  stance === \"paranoid\" ? Monitor.paranoidText : Monitor.carefulText\n\nconst historyFact =\n  `the checkout ends at the commit you were given; no branch, tag, stash or reflog here holds a later fix, so \\`git log --all\\` or \\`-S\\` hunting costs a frame and returns nothing. The harness keeps its own attempt and durability snapshots in a repository of its own. A dangling commit is this harness pinning your own tree for a checkpoint: \\`git fsck\\` reports your edit and never a fix. Backwards history pays: \\`git blame\\` or \\`git log -S\\` on a line says what an assertion was written for; given a last-known-good release, \\`git log <tag>..HEAD -- <paths>\\`.`\n\nconst environmentText = (environment: Environment): string => {\n  const lines = [`- History: ${historyFact}`]\n  if (environment.locale !== undefined) {\n    lines.push(\n      `- Locale: ${environment.locale}; output and files decode as that.`\n    )\n  }\n  const absent = environment.absentTools === undefined ? [] : [...environment.absentTools].sort()\n  if (absent.length > 0) {\n    lines.push(\n      `- Not installed: ${absent.join(\", \")}. Calls to them fail; use \\`ctx.flows\\`.`\n    )\n  }\n  return `Harness-computed facts about the checkout and container, not the task.\\n${lines.join(\"\\n\")}`\n}\n\nconst digest = (id: Section[\"id\"], text: string): string => Digest.digest(CanonicalJson.stringify({ id, text }))\n\ntype CatalogProjection = Cell.FlowProjection & Partial<Pick<Descriptor.FlowDescriptor, \"provenance\" | \"path\">>\n\nconst catalogText = (flows: Readonly<Record<string, CatalogProjection>>): string => {\n  const names = Object.keys(flows).sort()\n  if (names.length === 0) {\n    return \"No flows are callable in this run. Complete or park; ctx.call has nothing to reach.\"\n  }\n  const lines = names.map((name) => {\n    const projection = flows[name]!\n    const capabilities = projection.capabilities.length === 0\n      ? \"\"\n      : ` capabilities=${[...projection.capabilities].sort().join(\",\")}`\n    const origin = JSON.stringify({\n      source: projection.provenance?.source ?? \"unknown\",\n      root: projection.provenance?.root,\n      path: projection.path\n    })\n    const heading = `- ${name} (${projection.tier})${capabilities}: ${projection.description}\\n  provenance: ${origin}`\n    // The input schema is the difference between choosing a call and guessing\n    // one. A rejected input costs a whole frame, so a catalog that names a\n    // flow without saying what it takes spends the run's frame budget on\n    // trial and error.\n    return Option.isNone(projection.input)\n      ? heading\n      : `${heading}\\n  input: ${JSON.stringify(projection.input.value)}`\n  })\n  return `Flows callable with ctx.call in this frame:\\n${\n    untrustedData(lines.join(\"\\n\"), \"flow catalog (descriptor provenance follows)\")\n  }`\n}\n\n/**\n * Builds the cell-contract teaching sections for one frame.\n *\n * The order is by how often each section changes, because every one of them is\n * a prefix segment and a prefix is only cached up to its first edit: the\n * contract is constant for the life of the binary, the environment and the\n * `jev` teaching for the life of a run, and the catalog can differ frame to\n * frame. The `jev` teaching is rendered only when `flows` binds `jev`.\n *\n * `stance` renders a one-line `cell-stance` section between the contract and\n * the environment. It is constant for the run, so the cached prefix holds;\n * with no stance nothing is rendered and the prompt is unchanged.\n *\n * `environment` carries what the host measured about the container. It is\n * optional because the epoch fact \u2014 a checkout has no future in it \u2014 holds\n * everywhere and is stated with or without a host that measures anything else.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const make = (\n  flows: Readonly<Record<string, CatalogProjection>>,\n  environment: Environment = {},\n  stance?: typeof AgentEvent.Stance.Type\n): ReadonlyArray<Section> => {\n  const facts = environmentText(environment)\n  const catalog = catalogText(flows)\n  const taught = replContract\n  const stanced = stance === undefined ? undefined : stanceText(stance)\n  return [\n    { id: \"cell-contract\", text: taught, digest: digest(\"cell-contract\", taught) },\n    ...(stanced === undefined\n      ? []\n      : [{ id: \"cell-stance\" as const, text: stanced, digest: digest(\"cell-stance\", stanced) }]),\n    { id: \"cell-environment\", text: facts, digest: digest(\"cell-environment\", facts) },\n    ...(flows.jev === undefined\n      ? []\n      : [{ id: \"cell-jev\" as const, text: jevText, digest: digest(\"cell-jev\", jevText) }]),\n    { id: \"cell-catalog\", text: catalog, digest: digest(\"cell-catalog\", catalog) }\n  ]\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA8DA,aAAwB;AACxB,oBAA+B;AAE/B,oBAAuB;AAGvB,cAAyB;AACzB,2BAA8B;AA4F9B,MAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2DrB,MAAM,UACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBF,MAAM,aAAa,CAAC,WAClB,WAAW,aAAa,QAAQ,eAAe,QAAQ;AAEzD,MAAM,cACJ;AAEF,MAAM,kBAAkB,CAAC,gBAAqC;AAC5D,QAAM,QAAQ,CAAC,cAAc,WAAW,EAAE;AAC1C,MAAI,YAAY,WAAW,QAAW;AACpC,UAAM;AAAA,MACJ,aAAa,YAAY,MAAM;AAAA,IACjC;AAAA,EACF;AACA,QAAM,SAAS,YAAY,gBAAgB,SAAY,CAAC,IAAI,CAAC,GAAG,YAAY,WAAW,EAAE,KAAK;AAC9F,MAAI,OAAO,SAAS,GAAG;AACrB,UAAM;AAAA,MACJ,oBAAoB,OAAO,KAAK,IAAI,CAAC;AAAA,IACvC;AAAA,EACF;AACA,SAAO;AAAA,EAA2E,MAAM,KAAK,IAAI,CAAC;AACpG;AAEA,MAAM,SAAS,CAAC,IAAmB,SAAyB,OAAO,OAAO,cAAc,UAAU,EAAE,IAAI,KAAK,CAAC,CAAC;AAI/G,MAAM,cAAc,CAAC,UAA+D;AAClF,QAAM,QAAQ,OAAO,KAAK,KAAK,EAAE,KAAK;AACtC,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO;AAAA,EACT;AACA,QAAM,QAAQ,MAAM,IAAI,CAAC,SAAS;AAChC,UAAM,aAAa,MAAM,IAAI;AAC7B,UAAM,eAAe,WAAW,aAAa,WAAW,IACpD,KACA,iBAAiB,CAAC,GAAG,WAAW,YAAY,EAAE,KAAK,EAAE,KAAK,GAAG,CAAC;AAClE,UAAM,SAAS,KAAK,UAAU;AAAA,MAC5B,QAAQ,WAAW,YAAY,UAAU;AAAA,MACzC,MAAM,WAAW,YAAY;AAAA,MAC7B,MAAM,WAAW;AAAA,IACnB,CAAC;AACD,UAAM,UAAU,KAAK,IAAI,KAAK,WAAW,IAAI,IAAI,YAAY,KAAK,WAAW,WAAW;AAAA,gBAAmB,MAAM;AAKjH,WAAO,qBAAO,OAAO,WAAW,KAAK,IACjC,UACA,GAAG,OAAO;AAAA,WAAc,KAAK,UAAU,WAAW,MAAM,KAAK,CAAC;AAAA,EACpE,CAAC;AACD,SAAO;AAAA,MACL,oCAAc,MAAM,KAAK,IAAI,GAAG,8CAA8C,CAChF;AACF;AAuBO,MAAM,OAAO,CAClB,OACA,cAA2B,CAAC,GAC5B,WAC2B;AAC3B,QAAM,QAAQ,gBAAgB,WAAW;AACzC,QAAM,UAAU,YAAY,KAAK;AACjC,QAAM,SAAS;AACf,QAAM,UAAU,WAAW,SAAY,SAAY,WAAW,MAAM;AACpE,SAAO;AAAA,IACL,EAAE,IAAI,iBAAiB,MAAM,QAAQ,QAAQ,OAAO,iBAAiB,MAAM,EAAE;AAAA,IAC7E,GAAI,YAAY,SACZ,CAAC,IACD,CAAC,EAAE,IAAI,eAAwB,MAAM,SAAS,QAAQ,OAAO,eAAe,OAAO,EAAE,CAAC;AAAA,IAC1F,EAAE,IAAI,oBAAoB,MAAM,OAAO,QAAQ,OAAO,oBAAoB,KAAK,EAAE;AAAA,IACjF,GAAI,MAAM,QAAQ,SACd,CAAC,IACD,CAAC,EAAE,IAAI,YAAqB,MAAM,SAAS,QAAQ,OAAO,YAAY,OAAO,EAAE,CAAC;AAAA,IACpF,EAAE,IAAI,gBAAgB,MAAM,SAAS,QAAQ,OAAO,gBAAgB,OAAO,EAAE;AAAA,EAC/E;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,44 @@
+/**
+ * The segments a compaction may replace.
+ *
+ * A window's system and instruction segments are what the next turn is still
+ * addressed to, so only the conversational kinds are eligible. `ContextWindow`
+ * selects the prefix and `Compaction` declares one against the same selection;
+ * two spellings of this filter that drifted would let a declared prefix name
+ * segments the window would never replace.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+import type * as ContextWindow from "../ContextWindow.ts";
+/**
+ * The tokens the compaction trigger leaves free below the context window.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const defaultReserve = 16000;
+/**
+ * The tokens of recent segments a compaction keeps whole.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const defaultKeepRecent = 20000;
+/**
+ * The transcript, summary and steering segments of a window, in order.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const compactable: (segments: ReadonlyArray<ContextWindow.Segment>) => ReadonlyArray<ContextWindow.Segment>;
+/**
+ * The boundaries a cut may not fall on: every boundary between a tool call
+ * and its result, when the two sit in different segments of `segments`.
+ * Boundary `b` lies between `segments[b - 1]` and `segments[b]`.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const pairBoundaries: (segments: ReadonlyArray<ContextWindow.Segment>) => ReadonlySet<number>;
+//# sourceMappingURL=compactable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compactable.d.ts","sourceRoot":"","sources":["../../../src/internal/compactable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,KAAK,aAAa,MAAM,qBAAqB,CAAA;AAEzD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,QAAS,CAAA;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,QAAS,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GACtB,UAAU,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,KAC7C,aAAa,CAAC,aAAa,CAAC,OAAO,CAGnC,CAAA;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,KAAG,WAAW,CAAC,MAAM,CAuBjG,CAAA"}

package/dist/cjs/internal/compactable.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compactable_exports = {};
+__export(compactable_exports, {
+  compactable: () => compactable,
+  defaultKeepRecent: () => defaultKeepRecent,
+  defaultReserve: () => defaultReserve,
+  pairBoundaries: () => pairBoundaries
+});
+module.exports = __toCommonJS(compactable_exports);
+const defaultReserve = 16e3;
+const defaultKeepRecent = 2e4;
+const compactable = (segments) => segments.filter(
+  (segment) => segment.kind === "transcript" || segment.kind === "summary" || segment.kind === "steering"
+);
+const pairBoundaries = (segments) => {
+  const calls = /* @__PURE__ */ new Map();
+  const results = /* @__PURE__ */ new Map();
+  for (const [index, segment] of segments.entries()) {
+    for (const item of segment.content) {
+      if ("role" in item && item.role === "assistant") {
+        for (const part of item.content) {
+          if (part.type === "tool-call") calls.set(part.id, index);
+        }
+      } else if ("role" in item && item.role === "tool") {
+        for (const part of item.content) results.set(part.toolCallId, index);
+      }
+    }
+  }
+  const unsafe = /* @__PURE__ */ new Set();
+  for (const [callId, callIndex] of calls) {
+    const resultIndex = results.get(callId);
+    if (resultIndex === void 0) continue;
+    const first = Math.min(callIndex, resultIndex);
+    const last = Math.max(callIndex, resultIndex);
+    for (let boundary = first + 1; boundary <= last; boundary++) unsafe.add(boundary);
+  }
+  return unsafe;
+};
+//# sourceMappingURL=compactable.js.map

package/dist/cjs/internal/compactable.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/compactable.ts"],
+  "sourcesContent": ["/**\n * The segments a compaction may replace.\n *\n * A window's system and instruction segments are what the next turn is still\n * addressed to, so only the conversational kinds are eligible. `ContextWindow`\n * selects the prefix and `Compaction` declares one against the same selection;\n * two spellings of this filter that drifted would let a declared prefix name\n * segments the window would never replace.\n *\n * @since 1.0.0-rc.0\n * @private\n */\n\nimport type * as ContextWindow from \"../ContextWindow.ts\"\n\n/**\n * The tokens the compaction trigger leaves free below the context window.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const defaultReserve = 16_000\n\n/**\n * The tokens of recent segments a compaction keeps whole.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const defaultKeepRecent = 20_000\n\n/**\n * The transcript, summary and steering segments of a window, in order.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const compactable = (\n  segments: ReadonlyArray<ContextWindow.Segment>\n): ReadonlyArray<ContextWindow.Segment> =>\n  segments.filter((segment) =>\n    segment.kind === \"transcript\" || segment.kind === \"summary\" || segment.kind === \"steering\"\n  )\n\n/**\n * The boundaries a cut may not fall on: every boundary between a tool call\n * and its result, when the two sit in different segments of `segments`.\n * Boundary `b` lies between `segments[b - 1]` and `segments[b]`.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const pairBoundaries = (segments: ReadonlyArray<ContextWindow.Segment>): ReadonlySet<number> => {\n  const calls = new Map<string, number>()\n  const results = new Map<string, number>()\n  for (const [index, segment] of segments.entries()) {\n    for (const item of segment.content) {\n      if (\"role\" in item && item.role === \"assistant\") {\n        for (const part of item.content) {\n          if (part.type === \"tool-call\") calls.set(part.id, index)\n        }\n      } else if (\"role\" in item && item.role === \"tool\") {\n        for (const part of item.content) results.set(part.toolCallId, index)\n      }\n    }\n  }\n  const unsafe = new Set<number>()\n  for (const [callId, callIndex] of calls) {\n    const resultIndex = results.get(callId)\n    if (resultIndex === undefined) continue\n    const first = Math.min(callIndex, resultIndex)\n    const last = Math.max(callIndex, resultIndex)\n    for (let boundary = first + 1; boundary <= last; boundary++) unsafe.add(boundary)\n  }\n  return unsafe\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,MAAM,iBAAiB;AAQvB,MAAM,oBAAoB;AAQ1B,MAAM,cAAc,CACzB,aAEA,SAAS;AAAA,EAAO,CAAC,YACf,QAAQ,SAAS,gBAAgB,QAAQ,SAAS,aAAa,QAAQ,SAAS;AAClF;AAUK,MAAM,iBAAiB,CAAC,aAAwE;AACrG,QAAM,QAAQ,oBAAI,IAAoB;AACtC,QAAM,UAAU,oBAAI,IAAoB;AACxC,aAAW,CAAC,OAAO,OAAO,KAAK,SAAS,QAAQ,GAAG;AACjD,eAAW,QAAQ,QAAQ,SAAS;AAClC,UAAI,UAAU,QAAQ,KAAK,SAAS,aAAa;AAC/C,mBAAW,QAAQ,KAAK,SAAS;AAC/B,cAAI,KAAK,SAAS,YAAa,OAAM,IAAI,KAAK,IAAI,KAAK;AAAA,QACzD;AAAA,MACF,WAAW,UAAU,QAAQ,KAAK,SAAS,QAAQ;AACjD,mBAAW,QAAQ,KAAK,QAAS,SAAQ,IAAI,KAAK,YAAY,KAAK;AAAA,MACrE;AAAA,IACF;AAAA,EACF;AACA,QAAM,SAAS,oBAAI,IAAY;AAC/B,aAAW,CAAC,QAAQ,SAAS,KAAK,OAAO;AACvC,UAAM,cAAc,QAAQ,IAAI,MAAM;AACtC,QAAI,gBAAgB,OAAW;AAC/B,UAAM,QAAQ,KAAK,IAAI,WAAW,WAAW;AAC7C,UAAM,OAAO,KAAK,IAAI,WAAW,WAAW;AAC5C,aAAS,WAAW,QAAQ,GAAG,YAAY,MAAM,WAAY,QAAO,IAAI,QAAQ;AAAA,EAClF;AACA,SAAO;AACT;",
+  "names": []
+}