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

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

@@ -0,0 +1,278 @@
+/**
+ * What a compaction does with each old frame: keep it, squash it into the
+ * summary, or remove it.
+ *
+ * {@link pins} fixes what must survive whatever Jev says: a summary is always
+ * squashed, so a later summary extends it; steering and the person's messages
+ * are kept, and so is the newest frame that ran each check still failing; a
+ * frame that changed files is never removed; and the two halves of a tool
+ * call and its result share one mark. {@link read} asks Jev two questions
+ * about each segment, and {@link resolve} turns the answers into marks,
+ * demoting the least-needed keeps until the kept frames fit the window.
+ *
+ * Marking is not compacting. The supervisor asks about each settled segment
+ * off the loop's hot path, and the run stores each {@link Answer} in the
+ * segment's {@link Facts}; nothing the model is sent changes. Only when the
+ * budget forces a compaction are the pins taken and the stored answers
+ * resolved, and a segment still unmarked then is asked about in that one
+ * reading.
+ *
+ * Nothing here journals or compacts; the caller records the reading, and
+ * journals `decision-unjudged` and squashes every frame when it fails.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { InvalidStep } from "../Compaction.ts";
+import * as ContextWindow from "../ContextWindow.ts";
+import * as Judgement from "../Judgement.ts";
+/**
+ * One frame as Jev reads it: its size, the cell it ran, what the model said
+ * beside it, and what it observed.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const Item: Schema.Struct<{
+    readonly tokens: Schema.Int;
+    readonly cell: Schema.String;
+    readonly prose: Schema.String;
+    readonly observed: Schema.String;
+}>;
+/**
+ * The decoded form of {@link Item}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Item = typeof Item.Type;
+/**
+ * What every reading is told beside its items: the task and the labels of
+ * the checks still failing.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const Context: Schema.Struct<{
+    readonly task: Schema.String;
+    readonly failing: Schema.$Array<Schema.String>;
+}>;
+/**
+ * The decoded form of {@link Context}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Context = typeof Context.Type;
+/**
+ * Jev's answer about one item: the probabilities that it can be removed and
+ * that its exact text must be kept.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const Answer: Schema.Struct<{
+    readonly remove: Schema.Number;
+    readonly keep: Schema.Number;
+}>;
+/**
+ * The decoded form of {@link Answer}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Answer = typeof Answer.Type;
+/**
+ * Jev's {@link Answer} about one transcript segment, named by the segment's
+ * digest: what a supervisor reading marks and the next boundary stores.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const Marking: Schema.Struct<{
+    readonly remove: Schema.Number;
+    readonly keep: Schema.Number;
+    readonly digest: Schema.String;
+}>;
+/**
+ * The decoded form of {@link Marking}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Marking = typeof Marking.Type;
+/**
+ * What the run knows of one transcript segment: the frame that wrote it,
+ * whether it carries the person's messages, whether it changed files, the
+ * labels of the checks it ran, and Jev's answer about it once a reading has
+ * marked it.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const Facts: Schema.Struct<{
+    readonly frame: Schema.Int;
+    readonly person: Schema.Boolean;
+    readonly mutated: Schema.Boolean;
+    readonly checks: Schema.$Array<Schema.String>;
+    readonly answer: Schema.optionalKey<Schema.Struct<{
+        readonly remove: Schema.Number;
+        readonly keep: Schema.Number;
+    }>>;
+}>;
+/**
+ * The decoded form of {@link Facts}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Facts = typeof Facts.Type;
+/**
+ * Why a mark was not Jev's own.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const Pinned: Schema.Literals<readonly ["summary", "steering", "person", "failing", "mutated", "pair", "budget"]>;
+/**
+ * The decoded form of {@link Pinned}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Pinned = typeof Pinned.Type;
+/**
+ * One segment's resolved mark, and why it was fixed when Jev did not choose
+ * it.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const Marked: Schema.Struct<{
+    readonly mark: Schema.Literals<readonly ["keep", "squash", "remove"]>;
+    readonly pinned: Schema.optionalKey<Schema.Literals<readonly ["summary", "steering", "person", "failing", "mutated", "pair", "budget"]>>;
+}>;
+/**
+ * The decoded form of {@link Marked}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Marked = typeof Marked.Type;
+/**
+ * What {@link pins} fixes for one segment. `mark` is fixed and not asked;
+ * `floor` is the weakest mark allowed; `pair` is the index of the first
+ * segment of the tool-call span the segment shares a mark with.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export interface Pin {
+    readonly pin: Exclude<Pinned, "budget">;
+    readonly mark?: ContextWindow.Mark | undefined;
+    readonly floor?: ContextWindow.Mark | undefined;
+    readonly pair?: number | undefined;
+}
+/**
+ * What must survive of the first `prefixLength` of `segments`, the window's
+ * compactable segments in order. `facts[i]` describes `segments[i]`, and is
+ * absent for a segment no frame recorded; it is aligned by position, not by
+ * digest, because two frames can be byte-identical.
+ *
+ * Of the segments that ran a check still failing, only the newest is kept: a
+ * check that fails frame after frame would otherwise pin every run of it, and
+ * no compaction could shrink the window. When that newest run is past the
+ * prefix, no prefix segment is kept for it.
+ *
+ * A tool call and its result in different segments share the strongest
+ * retention either holds: kept together when one is pinned keep, and never
+ * below the other's floor.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const pins: (segments: ReadonlyArray<ContextWindow.Segment>, prefixLength: number, facts: ReadonlyArray<Facts | undefined>, failing: ReadonlyArray<string>) => ReadonlyArray<Pin | undefined>;
+/**
+ * The prefix indexes whose mark Jev is asked: those no pin fixes, in order.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const unpinned: (pinned: ReadonlyArray<Pin | undefined>) => ReadonlyArray<number>;
+/**
+ * The most of an item's cell and prose a reading carries, head kept, and of
+ * what it observed, tail kept; in UTF-8 bytes.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const fieldBytes = 1024;
+/**
+ * The reading: `remove_${i}` and `keep_${i}` per item, in as many requests as
+ * the items need, asked together.
+ *
+ * Two booleans rather than one choice: a boolean always carries its
+ * probability, and a choice without a distribution reads one-hot, so a floor
+ * on it would guard nothing.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const reader: Judgement.PerItem<{
+    readonly task: string;
+    readonly failing: readonly string[];
+}, {
+    readonly tokens: number;
+    readonly cell: string;
+    readonly prose: string;
+    readonly observed: string;
+}, {
+    readonly remove: (i: number) => import("@smthrs/model/Evaluator").BooleanQuestion;
+    readonly keep: (i: number) => import("@smthrs/model/Evaluator").BooleanQuestion;
+}>;
+/**
+ * Asks Jev about `items`, in order. Cell and prose are sent head-kept and what was observed tail-kept,
+ * each to {@link fieldBytes}. A reading is whole or it fails.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const read: (context: Context, items: ReadonlyArray<Item>) => Effect.Effect<{
+    readonly answers: ReadonlyArray<Answer>;
+    readonly asked: ReadonlyArray<Judgement.Asked>;
+}, Judgement.Unjudged>;
+/**
+ * The window a compaction must leave room in. Kept prefix tokens, `suffix`
+ * and a summary allowance must fit under
+ * `contextWindow - reserve - keepRecent / 2`. `tokens[i]` is prefix segment
+ * `i`'s size.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export interface Budget {
+    readonly contextWindow: number;
+    readonly reserve: number;
+    readonly keepRecent: number;
+    readonly suffix: number;
+    readonly tokens: ReadonlyArray<number>;
+}
+/**
+ * The mark of every prefix segment. `answers` are {@link read}'s, for the
+ * indexes {@link unpinned} names.
+ *
+ * A segment is removed only when Jev is sure it is not needed and would not
+ * keep it, kept when Jev would keep it, and squashed otherwise; pins and
+ * floors override Jev, and a tool-call span takes its strongest mark. Then,
+ * while the kept segments do not fit the {@link Budget}, the unpinned keep
+ * Jev was least sure of, the older on a tie, is squashed. Pins alone may
+ * exceed the budget; the next frame's trigger compacts again.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const resolve: (answers: ReadonlyArray<Answer>, pinned: ReadonlyArray<Pin | undefined>, budget: Budget) => Result.Result<ReadonlyArray<Marked>, InvalidStep>;
+//# sourceMappingURL=compactionMarks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compactionMarks.d.ts","sourceRoot":"","sources":["../../../src/internal/compactionMarks.ts"],"names":[],"mappings":"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"}

package/dist/cjs/internal/compactionMarks.js

@@ -0,0 +1,212 @@
+"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 compactionMarks_exports = {};
+__export(compactionMarks_exports, {
+  Answer: () => Answer,
+  Context: () => Context,
+  Facts: () => Facts,
+  Item: () => Item,
+  Marked: () => Marked,
+  Marking: () => Marking,
+  Pinned: () => Pinned,
+  fieldBytes: () => fieldBytes,
+  pins: () => pins,
+  read: () => read,
+  reader: () => reader,
+  resolve: () => resolve,
+  unpinned: () => unpinned
+});
+module.exports = __toCommonJS(compactionMarks_exports);
+var Classifier = __toESM(require("@smthrs/model/Classifier"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Result = __toESM(require("effect/Result"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_Compaction = require("../Compaction.js");
+var ContextWindow = __toESM(require("../ContextWindow.js"), 1);
+var Judgement = __toESM(require("../Judgement.js"), 1);
+var bytes = __toESM(require("./bytes.js"), 1);
+var import_compactable = require("./compactable.js");
+var elide = __toESM(require("./elide.js"), 1);
+var import_nonNegativeSafeInt = require("./nonNegativeSafeInt.js");
+const Item = Schema.Struct({
+  tokens: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  cell: Schema.String,
+  prose: Schema.String,
+  observed: Schema.String
+});
+const Context = Schema.Struct({ task: Schema.String, failing: Schema.Array(Schema.String) });
+const Answer = Schema.Struct({ remove: Schema.Number, keep: Schema.Number });
+const Marking = Schema.Struct({ digest: Schema.String, ...Answer.fields });
+const Facts = Schema.Struct({
+  frame: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  person: Schema.Boolean,
+  mutated: Schema.Boolean,
+  checks: Schema.Array(Schema.String),
+  answer: Schema.optionalKey(Answer)
+});
+const Pinned = Schema.Literals(["summary", "steering", "person", "failing", "mutated", "pair", "budget"]);
+const Marked = Schema.Struct({ mark: ContextWindow.Mark, pinned: Schema.optionalKey(Pinned) });
+const rank = { remove: 0, squash: 1, keep: 2 };
+const stronger = (a, b) => rank[a] >= rank[b] ? a : b;
+const spans = (prefix) => {
+  const unsafe = (0, import_compactable.pairBoundaries)(prefix);
+  const starts = [];
+  for (let index = 0; index < prefix.length; index++) {
+    starts.push(unsafe.has(index) ? starts[index - 1] : index);
+  }
+  return starts;
+};
+const own = (segment, facts, newest) => {
+  if (segment.kind === "summary") return { mark: "squash", pin: "summary" };
+  if (segment.kind === "steering") return { mark: "keep", pin: "steering" };
+  if (facts === void 0) return void 0;
+  if (facts.person) return { mark: "keep", pin: "person" };
+  if (newest) return { mark: "keep", pin: "failing" };
+  if (facts.mutated) return { floor: "squash", pin: "mutated" };
+  return void 0;
+};
+const pins = (segments, prefixLength, facts, failing) => {
+  const prefix = segments.slice(0, prefixLength);
+  const newest = new Set(
+    failing.map(
+      (label) => facts.reduce((last, entry, index) => entry?.checks.includes(label) === true ? index : last, -1)
+    )
+  );
+  const owned = prefix.map((segment, index) => own(segment, facts[index], newest.has(index)));
+  const starts = spans(prefix);
+  return owned.map((pin, index) => {
+    const start = starts[index];
+    const members = owned.filter((_, other) => starts[other] === start);
+    if (members.length === 1) return pin;
+    if (members.some((member) => member?.mark === "keep")) {
+      return { mark: "keep", pin: pin?.mark === "keep" ? pin.pin : "pair", pair: start };
+    }
+    if (pin?.mark !== void 0) return { ...pin, pair: start };
+    const floors = members.flatMap((member) => member?.floor ?? member?.mark ?? []);
+    if (floors.length === 0) return { pin: "pair", pair: start };
+    const floor = floors.reduce(stronger);
+    return { floor, pin: pin?.floor === floor ? pin.pin : "pair", pair: start };
+  });
+};
+const unpinned = (pinned) => pinned.flatMap((pin, index) => pin?.mark === void 0 ? [index] : []);
+const fieldBytes = 1024;
+const recall = "the run record has the whole frame";
+const headKept = (text) => {
+  const whole = bytes.size(text);
+  if (whole <= fieldBytes) return text;
+  return elide.head(text, fieldBytes - bytes.size(`\u2026 [+${whole}b, ${recall}]`), recall);
+};
+const tailKept = (text) => {
+  const whole = bytes.size(text);
+  if (whole <= fieldBytes) return text;
+  const kept = elide.tailSlice(text, fieldBytes - bytes.size(`[+${whole}b, ${recall}] \u2026`));
+  return `[+${whole - bytes.size(kept)}b, ${recall}] \u2026${kept}`;
+};
+const reader = Judgement.perItem({
+  id: "compaction/marks",
+  description: "Decide which old frames of an agent run to keep, squash into a summary, or remove",
+  context: Context,
+  item: Item,
+  questions: {
+    remove: (i) => Classifier.boolean({
+      instructions: `Is items[${i}], an old frame of this run, no longer needed at all now that the context must shrink? The task, the person's messages and the latest frames stay regardless.`,
+      criteria: {
+        true: "it contributed nothing still needed: a superseded read, a repeated command, a dead end later frames abandoned",
+        false: "something it established may still matter"
+      }
+    }),
+    keep: (i) => Classifier.boolean({
+      instructions: `Will the exact text of items[${i}] be needed again?`,
+      criteria: {
+        true: "a file's current content, an exact error still unresolved, a decision or constraint the run still acts on",
+        false: "a summary sentence is enough"
+      }
+    })
+  }
+});
+const read = (context, items) => reader.read(
+  context,
+  items.map((item) => ({
+    tokens: item.tokens,
+    cell: headKept(item.cell),
+    prose: headKept(item.prose),
+    observed: tailKept(item.observed)
+  }))
+).pipe(Effect.map((reading) => ({
+  answers: reading.answers.map((answer) => ({
+    remove: answer.remove.probability,
+    keep: answer.keep.probability
+  })),
+  asked: reading.asked
+})));
+const summaryAllowance = 4e3;
+const removeAt = 0.8;
+const keepAt = 0.5;
+const resolve = (answers, pinned, budget) => {
+  const asked = unpinned(pinned);
+  if (answers.length !== asked.length || budget.tokens.length !== pinned.length) {
+    return Result.fail(
+      new import_Compaction.InvalidStep({ message: "The compaction answers and budget must describe every unpinned prefix segment" })
+    );
+  }
+  const answered = new Map(asked.map((index, at) => [index, answers[at]]));
+  const marks = pinned.map((pin, index) => {
+    if (pin?.mark !== void 0) return { mark: pin.mark, pinned: pin.pin };
+    const { keep, remove } = answered.get(index);
+    const mark = keep >= keepAt ? "keep" : remove >= removeAt ? "remove" : "squash";
+    return pin?.floor !== void 0 && rank[pin.floor] > rank[mark] ? { mark: pin.floor, pinned: pin.pin } : { mark };
+  });
+  const unit = (index) => pinned[index]?.pair ?? index;
+  for (const [index, marked] of marks.entries()) {
+    const strongest = marks.filter((_, other) => unit(other) === unit(index)).map((other) => other.mark).reduce(
+      stronger
+    );
+    if (pinned[index]?.mark === void 0 && rank[strongest] > rank[marked.mark]) {
+      marks[index] = { mark: strongest, pinned: "pair" };
+    }
+  }
+  const limit = budget.contextWindow - budget.reserve - budget.keepRecent / 2;
+  let kept = marks.reduce((sum, marked, index) => marked.mark === "keep" ? sum + budget.tokens[index] : sum, 0);
+  const units = [...new Set(marks.map((_, index) => unit(index)))].map((start) => ({ start, members: marks.flatMap((_, index) => unit(index) === start ? [index] : []) })).filter(
+    ({ members }) => members.some((index) => marks[index].mark === "keep") && members.every((index) => pinned[index]?.mark === void 0)
+  ).map(({ members, start }) => ({
+    start,
+    members,
+    p: Math.max(...members.map((index) => answered.get(index).keep))
+  })).sort((a, b) => a.p - b.p || a.start - b.start);
+  for (const { members } of units) {
+    if (kept + budget.suffix + summaryAllowance <= limit) break;
+    for (const index of members) {
+      marks[index] = { mark: "squash", pinned: "budget" };
+      kept -= budget.tokens[index];
+    }
+  }
+  return Result.succeed(marks);
+};
+//# sourceMappingURL=compactionMarks.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/compactionMarks.ts"],
+  "sourcesContent": ["/**\n * What a compaction does with each old frame: keep it, squash it into the\n * summary, or remove it.\n *\n * {@link pins} fixes what must survive whatever Jev says: a summary is always\n * squashed, so a later summary extends it; steering and the person's messages\n * are kept, and so is the newest frame that ran each check still failing; a\n * frame that changed files is never removed; and the two halves of a tool\n * call and its result share one mark. {@link read} asks Jev two questions\n * about each segment, and {@link resolve} turns the answers into marks,\n * demoting the least-needed keeps until the kept frames fit the window.\n *\n * Marking is not compacting. The supervisor asks about each settled segment\n * off the loop's hot path, and the run stores each {@link Answer} in the\n * segment's {@link Facts}; nothing the model is sent changes. Only when the\n * budget forces a compaction are the pins taken and the stored answers\n * resolved, and a segment still unmarked then is asked about in that one\n * reading.\n *\n * Nothing here journals or compacts; the caller records the reading, and\n * journals `decision-unjudged` and squashes every frame when it fails.\n *\n * @since 1.0.0-rc.0\n * @private\n */\n\nimport * as Classifier from \"@smthrs/model/Classifier\"\nimport * as Effect from \"effect/Effect\"\nimport * as Result from \"effect/Result\"\nimport * as Schema from \"effect/Schema\"\nimport { InvalidStep } from \"../Compaction.ts\"\nimport * as ContextWindow from \"../ContextWindow.ts\"\nimport * as Judgement from \"../Judgement.ts\"\nimport * as bytes from \"./bytes.ts\"\nimport { pairBoundaries } from \"./compactable.ts\"\nimport * as elide from \"./elide.ts\"\nimport { NonNegativeSafeInt } from \"./nonNegativeSafeInt.ts\"\n\n/**\n * One frame as Jev reads it: its size, the cell it ran, what the model said\n * beside it, and what it observed.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const Item = Schema.Struct({\n  tokens: NonNegativeSafeInt,\n  cell: Schema.String,\n  prose: Schema.String,\n  observed: Schema.String\n})\n\n/**\n * The decoded form of {@link Item}.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport type Item = typeof Item.Type\n\n/**\n * What every reading is told beside its items: the task and the labels of\n * the checks still failing.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const Context = Schema.Struct({ task: Schema.String, failing: Schema.Array(Schema.String) })\n\n/**\n * The decoded form of {@link Context}.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport type Context = typeof Context.Type\n\n/**\n * Jev's answer about one item: the probabilities that it can be removed and\n * that its exact text must be kept.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const Answer = Schema.Struct({ remove: Schema.Number, keep: Schema.Number })\n\n/**\n * The decoded form of {@link Answer}.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport type Answer = typeof Answer.Type\n\n/**\n * Jev's {@link Answer} about one transcript segment, named by the segment's\n * digest: what a supervisor reading marks and the next boundary stores.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const Marking = Schema.Struct({ digest: Schema.String, ...Answer.fields })\n\n/**\n * The decoded form of {@link Marking}.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport type Marking = typeof Marking.Type\n\n/**\n * What the run knows of one transcript segment: the frame that wrote it,\n * whether it carries the person's messages, whether it changed files, the\n * labels of the checks it ran, and Jev's answer about it once a reading has\n * marked it.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const Facts = Schema.Struct({\n  frame: NonNegativeSafeInt,\n  person: Schema.Boolean,\n  mutated: Schema.Boolean,\n  checks: Schema.Array(Schema.String),\n  answer: Schema.optionalKey(Answer)\n})\n\n/**\n * The decoded form of {@link Facts}.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport type Facts = typeof Facts.Type\n\n/**\n * Why a mark was not Jev's own.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const Pinned = Schema.Literals([\"summary\", \"steering\", \"person\", \"failing\", \"mutated\", \"pair\", \"budget\"])\n\n/**\n * The decoded form of {@link Pinned}.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport type Pinned = typeof Pinned.Type\n\n/**\n * One segment's resolved mark, and why it was fixed when Jev did not choose\n * it.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const Marked = Schema.Struct({ mark: ContextWindow.Mark, pinned: Schema.optionalKey(Pinned) })\n\n/**\n * The decoded form of {@link Marked}.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport type Marked = typeof Marked.Type\n\n/**\n * What {@link pins} fixes for one segment. `mark` is fixed and not asked;\n * `floor` is the weakest mark allowed; `pair` is the index of the first\n * segment of the tool-call span the segment shares a mark with.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport interface Pin {\n  readonly pin: Exclude<Pinned, \"budget\">\n  readonly mark?: ContextWindow.Mark | undefined\n  readonly floor?: ContextWindow.Mark | undefined\n  readonly pair?: number | undefined\n}\n\nconst rank: Readonly<Record<ContextWindow.Mark, number>> = { remove: 0, squash: 1, keep: 2 }\n\nconst stronger = (a: ContextWindow.Mark, b: ContextWindow.Mark): ContextWindow.Mark => rank[a] >= rank[b] ? a : b\n\n/** Each prefix index's span: the index of the first segment of its tool-call span. */\nconst spans = (prefix: ReadonlyArray<ContextWindow.Segment>): ReadonlyArray<number> => {\n  const unsafe = pairBoundaries(prefix)\n  const starts: Array<number> = []\n  for (let index = 0; index < prefix.length; index++) {\n    starts.push(unsafe.has(index) ? starts[index - 1]! : index)\n  }\n  return starts\n}\n\nconst own = (\n  segment: ContextWindow.Segment,\n  facts: Facts | undefined,\n  newest: boolean\n): Pin | undefined => {\n  if (segment.kind === \"summary\") return { mark: \"squash\", pin: \"summary\" }\n  if (segment.kind === \"steering\") return { mark: \"keep\", pin: \"steering\" }\n  if (facts === undefined) return undefined\n  if (facts.person) return { mark: \"keep\", pin: \"person\" }\n  if (newest) return { mark: \"keep\", pin: \"failing\" }\n  if (facts.mutated) return { floor: \"squash\", pin: \"mutated\" }\n  return undefined\n}\n\n/**\n * What must survive of the first `prefixLength` of `segments`, the window's\n * compactable segments in order. `facts[i]` describes `segments[i]`, and is\n * absent for a segment no frame recorded; it is aligned by position, not by\n * digest, because two frames can be byte-identical.\n *\n * Of the segments that ran a check still failing, only the newest is kept: a\n * check that fails frame after frame would otherwise pin every run of it, and\n * no compaction could shrink the window. When that newest run is past the\n * prefix, no prefix segment is kept for it.\n *\n * A tool call and its result in different segments share the strongest\n * retention either holds: kept together when one is pinned keep, and never\n * below the other's floor.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const pins = (\n  segments: ReadonlyArray<ContextWindow.Segment>,\n  prefixLength: number,\n  facts: ReadonlyArray<Facts | undefined>,\n  failing: ReadonlyArray<string>\n): ReadonlyArray<Pin | undefined> => {\n  const prefix = segments.slice(0, prefixLength)\n  const newest = new Set(\n    failing.map((label) =>\n      facts.reduce((last, entry, index) => entry?.checks.includes(label) === true ? index : last, -1)\n    )\n  )\n  const owned = prefix.map((segment, index) => own(segment, facts[index], newest.has(index)))\n  const starts = spans(prefix)\n  return owned.map((pin, index) => {\n    const start = starts[index]!\n    const members = owned.filter((_, other) => starts[other] === start)\n    if (members.length === 1) return pin\n    if (members.some((member) => member?.mark === \"keep\")) {\n      return { mark: \"keep\", pin: pin?.mark === \"keep\" ? pin.pin : \"pair\", pair: start }\n    }\n    if (pin?.mark !== undefined) return { ...pin, pair: start }\n    const floors = members.flatMap((member) => member?.floor ?? member?.mark ?? [])\n    if (floors.length === 0) return { pin: \"pair\", pair: start }\n    const floor = floors.reduce(stronger)\n    return { floor, pin: pin?.floor === floor ? pin.pin : \"pair\", pair: start }\n  })\n}\n\n/**\n * The prefix indexes whose mark Jev is asked: those no pin fixes, in order.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const unpinned = (pinned: ReadonlyArray<Pin | undefined>): ReadonlyArray<number> =>\n  pinned.flatMap((pin, index) => pin?.mark === undefined ? [index] : [])\n\n/**\n * The most of an item's cell and prose a reading carries, head kept, and of\n * what it observed, tail kept; in UTF-8 bytes.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const fieldBytes = 1024\n\nconst recall = \"the run record has the whole frame\"\n\nconst headKept = (text: string): string => {\n  const whole = bytes.size(text)\n  if (whole <= fieldBytes) return text\n  return elide.head(text, fieldBytes - bytes.size(`\u2026 [+${whole}b, ${recall}]`), recall)\n}\n\nconst tailKept = (text: string): string => {\n  const whole = bytes.size(text)\n  if (whole <= fieldBytes) return text\n  const kept = elide.tailSlice(text, fieldBytes - bytes.size(`[+${whole}b, ${recall}] \u2026`))\n  return `[+${whole - bytes.size(kept)}b, ${recall}] \u2026${kept}`\n}\n\n/**\n * The reading: `remove_${i}` and `keep_${i}` per item, in as many requests as\n * the items need, asked together.\n *\n * Two booleans rather than one choice: a boolean always carries its\n * probability, and a choice without a distribution reads one-hot, so a floor\n * on it would guard nothing.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const reader = Judgement.perItem({\n  id: \"compaction/marks\",\n  description: \"Decide which old frames of an agent run to keep, squash into a summary, or remove\",\n  context: Context,\n  item: Item,\n  questions: {\n    remove: (i) =>\n      Classifier.boolean({\n        instructions:\n          `Is items[${i}], an old frame of this run, no longer needed at all now that the context must shrink? The task, the person's messages and the latest frames stay regardless.`,\n        criteria: {\n          true:\n            \"it contributed nothing still needed: a superseded read, a repeated command, a dead end later frames abandoned\",\n          false: \"something it established may still matter\"\n        }\n      }),\n    keep: (i) =>\n      Classifier.boolean({\n        instructions: `Will the exact text of items[${i}] be needed again?`,\n        criteria: {\n          true:\n            \"a file's current content, an exact error still unresolved, a decision or constraint the run still acts on\",\n          false: \"a summary sentence is enough\"\n        }\n      })\n  }\n})\n\n/**\n * Asks Jev about `items`, in order. Cell and prose are sent head-kept and what was observed tail-kept,\n * each to {@link fieldBytes}. A reading is whole or it fails.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const read = (\n  context: Context,\n  items: ReadonlyArray<Item>\n): Effect.Effect<\n  { readonly answers: ReadonlyArray<Answer>; readonly asked: ReadonlyArray<Judgement.Asked> },\n  Judgement.Unjudged\n> =>\n  reader.read(\n    context,\n    items.map((item) => ({\n      tokens: item.tokens,\n      cell: headKept(item.cell),\n      prose: headKept(item.prose),\n      observed: tailKept(item.observed)\n    }))\n  ).pipe(Effect.map((reading) => ({\n    answers: reading.answers.map((answer) => ({\n      remove: answer.remove.probability,\n      keep: answer.keep.probability\n    })),\n    asked: reading.asked\n  })))\n\n/**\n * The window a compaction must leave room in. Kept prefix tokens, `suffix`\n * and a summary allowance must fit under\n * `contextWindow - reserve - keepRecent / 2`. `tokens[i]` is prefix segment\n * `i`'s size.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport interface Budget {\n  readonly contextWindow: number\n  readonly reserve: number\n  readonly keepRecent: number\n  readonly suffix: number\n  readonly tokens: ReadonlyArray<number>\n}\n\n/** Room left for the summary a squash produces. */\nconst summaryAllowance = 4000\n\n/** Jev removes a frame at or above this probability, when it would not keep it. */\nconst removeAt = 0.8\n\n/** Jev keeps a frame's exact text at or above this probability. */\nconst keepAt = 0.5\n\n/**\n * The mark of every prefix segment. `answers` are {@link read}'s, for the\n * indexes {@link unpinned} names.\n *\n * A segment is removed only when Jev is sure it is not needed and would not\n * keep it, kept when Jev would keep it, and squashed otherwise; pins and\n * floors override Jev, and a tool-call span takes its strongest mark. Then,\n * while the kept segments do not fit the {@link Budget}, the unpinned keep\n * Jev was least sure of, the older on a tie, is squashed. Pins alone may\n * exceed the budget; the next frame's trigger compacts again.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const resolve = (\n  answers: ReadonlyArray<Answer>,\n  pinned: ReadonlyArray<Pin | undefined>,\n  budget: Budget\n): Result.Result<ReadonlyArray<Marked>, InvalidStep> => {\n  const asked = unpinned(pinned)\n  if (answers.length !== asked.length || budget.tokens.length !== pinned.length) {\n    return Result.fail(\n      new InvalidStep({ message: \"The compaction answers and budget must describe every unpinned prefix segment\" })\n    )\n  }\n  const answered = new Map(asked.map((index, at) => [index, answers[at]!]))\n  const marks: Array<Marked> = pinned.map((pin, index) => {\n    if (pin?.mark !== undefined) return { mark: pin.mark, pinned: pin.pin }\n    const { keep, remove } = answered.get(index)!\n    const mark = keep >= keepAt ? \"keep\" : remove >= removeAt ? \"remove\" : \"squash\"\n    return pin?.floor !== undefined && rank[pin.floor] > rank[mark]\n      ? { mark: pin.floor, pinned: pin.pin }\n      : { mark }\n  })\n  const unit = (index: number): number => pinned[index]?.pair ?? index\n  for (const [index, marked] of marks.entries()) {\n    const strongest = marks.filter((_, other) => unit(other) === unit(index)).map((other) => other.mark).reduce(\n      stronger\n    )\n    if (pinned[index]?.mark === undefined && rank[strongest] > rank[marked.mark]) {\n      marks[index] = { mark: strongest, pinned: \"pair\" }\n    }\n  }\n  const limit = budget.contextWindow - budget.reserve - budget.keepRecent / 2\n  let kept = marks.reduce((sum, marked, index) => marked.mark === \"keep\" ? sum + budget.tokens[index]! : sum, 0)\n  const units = [...new Set(marks.map((_, index) => unit(index)))]\n    .map((start) => ({ start, members: marks.flatMap((_, index) => unit(index) === start ? [index] : []) }))\n    .filter(({ members }) =>\n      members.some((index) => marks[index]!.mark === \"keep\") &&\n      members.every((index) => pinned[index]?.mark === undefined)\n    )\n    .map(({ members, start }) => ({\n      start,\n      members,\n      p: Math.max(...members.map((index) => answered.get(index)!.keep))\n    }))\n    .sort((a, b) => a.p - b.p || a.start - b.start)\n  for (const { members } of units) {\n    if (kept + budget.suffix + summaryAllowance <= limit) break\n    // A span takes its strongest mark, so every member of a demotable one is kept.\n    for (const index of members) {\n      marks[index] = { mark: \"squash\", pinned: \"budget\" }\n      kept -= budget.tokens[index]!\n    }\n  }\n  return Result.succeed(marks)\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,95 @@
+/**
+ * Canonical renderings of controller interventions recorded in the journal.
+ *
+ * `CellTurn` uses these strings when it builds the live model window and
+ * `Transcript` uses the same functions when it rebuilds that window. Keeping
+ * the rendering here makes an intervention event sufficient to reproduce the
+ * exact user message it represented.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+/**
+ * Renders the read-only-discipline intervention.
+ *
+ * It asks for a decision rather than a token write. An answerable request can
+ * complete without inventing work. An unfinished workspace change still needs
+ * evidence or a justification for more observation, and destructive
+ * writes made only to satisfy the notice are explicitly refused. A
+ * justification must name how later frames differ from the quiet ones so the
+ * run cannot buy a repeat by restating its plan.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const readOnly: (cap: number, frames: number) => string;
+/**
+ * Renders the repeated-observation intervention.
+ *
+ * This is separate from the read-only demand because a repeating run has
+ * often already edited. It redirects the run from re-reading that edit toward
+ * mechanism evidence: the failing check, symbol history, or another caller.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const repeat: (frames: number, cap: number) => string;
+/**
+ * Renders the unchanged-workspace completion intervention.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const unmoved: (opened: string, closed: string) => string;
+/**
+ * Renders the unresolved-failure completion intervention.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const unresolved: (flow: string, failed: string, instead: string) => string;
+/**
+ * Renders the narrowed-check completion intervention.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const narrowed: (flow: string, broader: string, narrower: string) => string;
+/**
+ * Renders the only-reading completion intervention.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const narrowOnly: (flow: string, check: string, targets: ReadonlyArray<string>) => string;
+/**
+ * Renders the completion-review intervention.
+ *
+ * Any of the three completion questions can ask for another frame. A low
+ * completeness reading does not establish that the run invented work, so the
+ * notice asks for a direct answer and makes evidence conditional on the
+ * actions or results that answer actually claims. A conversational answer
+ * needs no work report and must retain the person's requested format.
+ *
+ * The task is not quoted back. It is in the run's prefix on every frame, so a
+ * quote would buy nothing and cost the window the run has to answer in, and
+ * leaving it out is also what lets this text be rebuilt from the event alone.
+ * No probability is quoted either: a number is journal material for a grader,
+ * and in front of a model it is a score to negotiate.
+ *
+ * The text still warns about the narrower refusal: repeated claims of work
+ * the record does not carry can end the run. Honest reports of work left
+ * undone remain valid answers when that is what the run can report.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const claim: () => string;
+//# sourceMappingURL=demandText.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"demandText.d.ts","sourceRoot":"","sources":["../../../src/internal/demandText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,KAAG,MAKc,CAAA;AAErE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,MAAM,GAAI,QAAQ,MAAM,EAAE,KAAK,MAAM,KAAG,MAQqJ,CAAA;AAE1M;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,QAAQ,MAAM,EAAE,QAAQ,MAAM,KAAG,MAMinB,CAAA;AAE1qB;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,EAAE,SAAS,MAAM,KAAG,MAMwY,CAAA;AAEnd;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,EAAE,SAAS,MAAM,EAAE,UAAU,MAAM,KAAG,MAM8a,CAAA;AAEzf;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,EAAE,SAAS,aAAa,CAAC,MAAM,CAAC,KAAG,MAM0lB,CAAA;AAEnrB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,KAAK,QAAO,MAO6F,CAAA"}