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

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

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

package/dist/cjs/Supervisor.js

@@ -0,0 +1,313 @@
+"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 Supervisor_exports = {};
+__export(Supervisor_exports, {
+  Frame: () => Frame,
+  Help: () => Help,
+  Level: () => Level,
+  Memory: () => Memory,
+  Recalled: () => Recalled,
+  Signals: () => Signals,
+  Skill: () => Skill,
+  Snapshot: () => Snapshot,
+  calledLimit: () => calledLimit,
+  classifier: () => classifier,
+  classifierFor: () => classifierFor,
+  closeGraceMs: () => closeGraceMs,
+  compacting: () => compacting,
+  contextAt: () => contextAt,
+  contextTriggers: () => contextTriggers,
+  crosses: () => crosses,
+  emotions: () => emotions,
+  frameBytes: () => frameBytes,
+  head: () => head,
+  levels: () => levels,
+  memoryNone: () => memoryNone,
+  monitorPrefix: () => monitorPrefix,
+  nudge: () => nudge,
+  offTargetAt: () => offTargetAt,
+  prose: () => prose,
+  read: () => read,
+  recalledInsert: () => recalledInsert,
+  recalledLimit: () => recalledLimit,
+  recentFrames: () => recentFrames,
+  skill: () => skill,
+  skillBytes: () => skillBytes,
+  skillLimit: () => skillLimit,
+  suspectAt: () => suspectAt,
+  tail: () => tail,
+  thrashingAt: () => thrashingAt,
+  triggered: () => triggered,
+  triggers: () => triggers
+});
+module.exports = __toCommonJS(Supervisor_exports);
+var Classifier = __toESM(require("@smthrs/model/Classifier"), 1);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var elide = __toESM(require("./internal/elide.js"), 1);
+var import_nonNegativeSafeInt = require("./internal/nonNegativeSafeInt.js");
+var import_untrustedData = require("./internal/untrustedData.js");
+var Judgement = __toESM(require("./Judgement.js"), 1);
+const frameBytes = 1024;
+const recentFrames = 3;
+const recalledLimit = 6;
+const closeGraceMs = 1500;
+const thrashingAt = 0.5;
+const offTargetAt = 0.5;
+const suspectAt = 0.5;
+const contextAt = 0.5;
+const Level = Schema.Literals(["none", "mild", "strong"]);
+const levels = ["none", "mild", "strong"];
+const Help = Schema.Literals(["none", "clarification", "permission", "stuck", "risky_action"]);
+const emotions = ["frustrated", "anxious", "scared", "confused", "confident"];
+const Frame = Schema.Struct({
+  frame: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  cell: Schema.String.annotate({ description: "The cell the model wrote, head kept" }),
+  prose: Schema.String.annotate({ description: "What the model wrote outside the cell, head kept" }),
+  printed: Schema.String.annotate({ description: "What the cell printed, newest bytes kept" }),
+  transition: Schema.Literals(["continue", "complete", "park", "raised", "rejected"]),
+  mutated: Schema.Boolean.annotate({ description: "Whether this frame changed the workspace" })
+});
+const Signals = Schema.Struct({
+  frame: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "The frame just closed, counting from zero" }),
+  maxFrames: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "The frame budget; zero is unbounded" }),
+  readOnlyFrames: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "Consecutive frames that changed nothing" }),
+  repeatFrames: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({
+    description: "Consecutive frames that issued only calls already issued and changed nothing"
+  }),
+  mutations: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "Frames that changed the workspace" }),
+  remoteMutations: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "Writes recorded on trees the host cannot see" }),
+  treeMoved: Schema.Boolean.annotate({ description: "Whether the workspace differs from the tree the run opened on" }),
+  paths: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({
+    description: "Paths the closing workspace measurement covered; zero unmeasured"
+  }),
+  checksRun: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "Distinct checks the run has run" }),
+  checksFailing: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "Of those, how many last reported a failing status" }),
+  failuresUnanswered: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({
+    description: "Failing checks no later passing check has answered"
+  }),
+  callsFailed: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "Settled calls in the ledger that failed" }),
+  callsSettled: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "Settled calls in the ledger" }),
+  narrowingDemands: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "Completions bounced for narrowed evidence" }),
+  unmovedDemands: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "Completions bounced for an unmoved tree" }),
+  unresolvedDemands: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "Completions bounced for a stepped-around failure" }),
+  claimDemands: import_nonNegativeSafeInt.NonNegativeSafeInt.annotate({ description: "Completions bounced for an unsupported claim" }),
+  sufficiencyStated: Schema.Boolean.annotate({ description: "Whether the run was told its evidence is complete" })
+});
+const Recalled = Schema.Struct({
+  key: Schema.String,
+  text: Schema.String
+});
+const skillLimit = 12;
+const skillBytes = 256;
+const calledLimit = 64;
+const Skill = Schema.Struct({
+  name: Schema.String,
+  description: Schema.String.annotate({ description: "The description's head, wrapped as untrusted data" }),
+  path: Schema.String.annotate({ description: "Where the skill's Markdown body is" })
+});
+const skill = (name, description, path) => ({
+  name,
+  description: (0, import_untrustedData.untrustedData)(elide.head(description, skillBytes, "clipped"), `description of skill ${name}`),
+  path
+});
+const Snapshot = Schema.Struct({
+  task: Schema.String.annotate({ description: "The task, as the person stated it" }),
+  frames: Schema.Array(Frame).annotate({ description: "The newest frames, oldest first" }),
+  signals: Signals,
+  skills: Schema.Array(Skill).annotate({
+    description: "Skills the run could read and has neither called nor read, by index"
+  }),
+  called: Schema.Array(Schema.String).annotate({ description: "Distinct flows the run has called" }),
+  jevAvailable: Schema.Boolean.annotate({ description: "Whether the run can call the jev flow" })
+});
+const fixedQuestions = {
+  thrashing: Classifier.boolean({
+    instructions: "Is the run going in circles rather than converging? Compare the newest frames with each other and with signals.checksFailing, signals.failuresUnanswered, signals.readOnlyFrames and signals.repeatFrames. Any one sign below is enough.",
+    criteria: {
+      true: "a check fails again after an edit meant to fix it, an edit is redone or reverted, or the newest frames re-read or re-run what earlier frames already saw without learning anything new",
+      false: "the newest frames learn something new or make progress: a failing check now passes, or a new cause is found and acted on"
+    }
+  }),
+  on_target: Classifier.boolean({
+    instructions: "Is the run still working on the task as stated? Read the task and the newest frames' cells and prose.",
+    criteria: {
+      true: "the newest frames read, edit or check the thing the task names",
+      false: "the newest frames work on something the task does not ask for, or have drifted from it"
+    }
+  }),
+  suspect: Classifier.boolean({
+    instructions: "Is the run's evidence suspect? Read the newest frames for tests edited to pass, edits to a file the task does not concern, or prose claiming a result no printed output shows.",
+    criteria: {
+      true: "a test was changed rather than the code under test, the wrong file was edited, or a claim has no check behind it",
+      false: "edits are to the code the task names and every claim has a printed result behind it"
+    }
+  }),
+  outdated_context: Classifier.boolean({
+    instructions: "Do the newest frames show earlier context that is now factually wrong or stale? Judge only evidence visible in the task and frames; do not assume unseen history is outdated.",
+    criteria: {
+      true: "a later observation explicitly contradicts an earlier assumption or file state in the visible frames",
+      false: "no visible contradiction, or the earlier context is still accurate"
+    }
+  }),
+  irrelevant_context: Classifier.boolean({
+    instructions: "Do the newest frames show earlier context that is accurate but no longer useful for the task? Do not treat the task, a reusable PRD, or decisions still needed as irrelevant.",
+    criteria: {
+      true: "the visible frames explicitly move away from earlier work that will not be needed again",
+      false: "the earlier work may still be needed, or the visible frames do not establish irrelevance"
+    }
+  }),
+  frustrated: Classifier.score({
+    instructions: "How frustrated is the run: the same check failing repeatedly, edits reverted, attempts not converging? Read signals.checksFailing, signals.failuresUnanswered, signals.repeatFrames, signals.readOnlyFrames and the newest frames.",
+    criteria: levels
+  }),
+  anxious: Classifier.score({
+    instructions: "How anxious is the run: its own prose hedges or expresses uncertainty while the evidence is thin? Read the frames' prose against signals.checksRun and signals.callsSettled.",
+    criteria: levels
+  }),
+  scared: Classifier.score({
+    instructions: "How scared should a person be: is the run taking or considering a destructive, irreversible or out-of-scope action, or hitting permission or sandbox refusals? Read the newest frames' cells, prints and failed calls.",
+    criteria: levels
+  }),
+  confused: Classifier.score({
+    instructions: "How confused is the run: the task is ambiguous or contradicted by the repository, and the run keeps switching interpretations or files? Read the task against the newest frames.",
+    criteria: levels
+  }),
+  confident: Classifier.score({
+    instructions: "How confident should a person be that the work converges on the task: checks pass and each frame builds on the last? Read signals.checksRun, signals.checksFailing, signals.mutations and the newest frames.",
+    criteria: levels
+  }),
+  needs_help: Classifier.choice({
+    instructions: "What, if anything, does the run need from a person right now? Read the states above and the newest frames.",
+    criteria: {
+      none: "nothing; the run can carry on",
+      clarification: "the task is ambiguous or contradicted and a person must say which reading is meant",
+      permission: "the run is blocked on a permission or sandbox refusal a person can grant",
+      stuck: "the run is not converging and a person should intervene",
+      risky_action: "the run is about to do something destructive, irreversible or out of scope"
+    }
+  })
+};
+const monitorPrefix = "monitor_";
+const declare = (extra) => Classifier.make("supervisor/turn", {
+  description: "Read one running agent's newest frames and the counts its harness keeps: whether it is thrashing, on the task and honest; its operational state in five scored words; and what it needs from a person.",
+  state: Snapshot,
+  questions: { ...fixedQuestions, ...extra }
+});
+const cache = /* @__PURE__ */ new Map();
+const classifierFor = (extra) => {
+  const ids = Object.keys(extra).sort();
+  const key = ids.join(",");
+  const held = cache.get(key);
+  if (held !== void 0 && ids.every((id) => held.extra[id] === extra[id])) return held.made;
+  const made = declare(extra);
+  cache.set(key, { extra, made });
+  return made;
+};
+const classifier = classifierFor({});
+const read = (snapshot, extra) => Effect.gen(function* () {
+  const { answers, asked } = yield* Judgement.read(classifierFor(extra), snapshot);
+  const all = answers;
+  const bool = (id) => all[id].probability;
+  return {
+    thrashing: answers.thrashing.probability,
+    onTarget: answers.on_target.probability,
+    suspect: answers.suspect.probability,
+    outdatedContext: answers.outdated_context.probability,
+    irrelevantContext: answers.irrelevant_context.probability,
+    emotions: {
+      frustrated: answers.frustrated.label,
+      anxious: answers.anxious.label,
+      scared: answers.scared.label,
+      confused: answers.confused.label,
+      confident: answers.confident.label
+    },
+    needsHelp: answers.needs_help.value,
+    monitors: Object.fromEntries(Object.keys(extra).map((id) => [id.slice(monitorPrefix.length), bool(id)])),
+    latencyMs: asked.latencyMs,
+    ...asked.usage === void 0 ? {} : { usage: asked.usage },
+    asked: { digest: asked.digest, questions: asked.questions, state: asked.state, answers: asked.answers }
+  };
+});
+const memoryNone = {
+  bound: false,
+  recall: () => Effect.succeed([]),
+  remember: () => Effect.void
+};
+const Memory = Context.Reference("@smthrs/harness/Supervisor/Memory", {
+  defaultValue: () => memoryNone
+});
+const triggers = {
+  thrashing: (reading) => reading.thrashing >= thrashingAt,
+  off_target: (reading) => reading.onTarget <= offTargetAt,
+  suspect: (reading) => reading.suspect >= suspectAt,
+  outdated_context: (reading) => reading.outdatedContext >= contextAt,
+  irrelevant_context: (reading) => reading.irrelevantContext >= contextAt
+};
+const triggered = (reading) => Object.keys(triggers).filter((name) => triggers[name](reading));
+const contextTriggers = ["outdated_context", "irrelevant_context"];
+const isContext = (trigger) => contextTriggers.includes(trigger);
+const crosses = (reading) => triggered(reading).some((trigger) => !isContext(trigger));
+const compacting = (reading) => triggered(reading).filter(isContext);
+const nudge = (snapshot, reading) => {
+  const { signals } = snapshot;
+  const said = {
+    thrashing: `repeating itself (thrashing ${reading.thrashing.toFixed(2)})`,
+    off_target: `drifting from the task (on target ${reading.onTarget.toFixed(2)})`,
+    suspect: `standing on suspect evidence (suspect ${reading.suspect.toFixed(2)})`
+  };
+  const found = triggered(reading).flatMap((name) => isContext(name) ? [] : [said[name]]);
+  const evidence = [];
+  if (signals.checksFailing > 0) {
+    evidence.push(`${signals.checksFailing} check${signals.checksFailing === 1 ? "" : "s"} last reported failing`);
+  }
+  if (signals.failuresUnanswered > 0) {
+    evidence.push(
+      `${signals.failuresUnanswered} failing check${signals.failuresUnanswered === 1 ? "" : "s"} never answered by a pass`
+    );
+  }
+  if (signals.repeatFrames > 0) evidence.push(`${signals.repeatFrames} consecutive frames repeated earlier calls`);
+  if (signals.readOnlyFrames > 0) evidence.push(`${signals.readOnlyFrames} consecutive frames changed nothing`);
+  if (signals.callsFailed > 0) evidence.push(`${signals.callsFailed} of ${signals.callsSettled} calls failed`);
+  evidence.push(`${signals.mutations} frame${signals.mutations === 1 ? "" : "s"} changed the workspace`);
+  return `Supervisor: a reading of this run's last ${snapshot.frames.length} frames, through frame ${signals.frame}, finds it ${found.join(", ")}. Evidence at frame ${signals.frame}: ${evidence.join("; ")}. Before the next call, state in one sentence which mechanism you now believe is wrong and which single call would show it; then make that call. Do not re-run a check over an unchanged tree, and do not edit a test to make it pass.`;
+};
+const recalledInsert = (row) => `From memory of this repository (${row.key}):
+${row.text}`;
+const head = (text) => elide.head(text.trim(), frameBytes, "clipped");
+const tail = (text) => {
+  const trimmed = text.trim();
+  const kept = elide.tailSlice(trimmed, frameBytes);
+  return kept.length === trimmed.length ? trimmed : `[\u2026 older bytes elided]
+${kept}`;
+};
+const fencedCell = /```(?:cell|typescript|ts|javascript|js)[^\n]*\n[\s\S]*?(?:```|$)/g;
+const prose = (text) => text.replace(fencedCell, "").trim();
+//# sourceMappingURL=Supervisor.js.map

package/dist/cjs/Supervisor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Supervisor.ts"],
+  "sourcesContent": ["/**\n * The reading Jev takes of a run while it is still running.\n *\n * Every other control in this package reads a completion, or reads one fact\n * the harness measured: a tree that never moved, a check that was narrowed, a\n * frame that repeated itself. Each is exact, each fires late, and each is\n * silent about the run between its brakes. A run that edits the wrong file\n * for twenty frames, re-runs one failing check after every edit and never\n * once claims to be done trips none of them until its budget is gone.\n *\n * So this module asks Jev about the run's *shape* rather than its sentence.\n * One classifier, `supervisor/turn`, over a {@link Snapshot} the controller\n * assembles from what it already holds: the task, the newest frames, and the\n * counts the deterministic controls keep \u2014 read-only streak, repeat streak,\n * mutations, checks run and failing, unanswered failures, demands spent. It\n * re-derives none of them. Beside the run's state it carries the skills it has\n * not called, the flows it has, and whether it can call `jev`. One Jev call per\n * snapshot answers every question at once.\n *\n * Eleven questions are fixed. Five are about the run: whether it is\n * thrashing, whether it is still on the task, whether its evidence is\n * suspect, and whether it carries outdated or irrelevant context. Five are\n * operational states a person would recognise in a colleague, each scored\n * `none`, `mild` or `strong` against evidence the snapshot names, and\n * `needs_help` is the one word a person is shown. The five about the run are\n * the {@link triggers}: any one past its threshold crosses. Each monitor the\n * host arms may add one boolean of its own, under {@link monitorPrefix}.\n *\n * Rows recalled from {@link Memory} are not asked about here. Beside each\n * reading, the supervisor asks `Relevance` which of up to\n * {@link recalledLimit} rows, none already shown to the run, are unnecessary\n * for the task; the rest are shown at the next boundary as\n * {@link recalledInsert} renders them, and a row is shown to a run once.\n *\n * It is a supervisor and not a brake: nothing here ends a run, refuses a\n * completion, or decides anything on the cell loop's hot path. `CellTurn`\n * offers each frame's snapshot to a one-slot sliding queue and continues; a\n * forked fiber takes the newest snapshot, asks, journals what came back, and\n * hands the monitors' values and any recalled rows to the *next* turn boundary,\n * which decides there what the run is told. A reading that arrives after the boundary it was for is\n * journaled and never delivered, and a snapshot the fiber never reached is\n * dropped: the run is never told something about a frame two frames gone.\n *\n * It never falls back. A snapshot Jev could not read is journaled as\n * {@link AgentEvent.SupervisorUnjudged} with the transport's own reason; it\n * nudges nothing, and is never counted as a reading that\n * found the run calm or on target. A host with no judge (`unconfigured`) is\n * journaled once per streak rather than every frame; each reading still asks,\n * so a judge connected mid-run is used at once. Nothing here is a default value: every\n * level and every word on the settled event came back from the transport.\n *\n * What a reading says is delivered wherever the host holds a real judge\n * (`CellTurn.Input.judged`), and only through a monitor that crossed and\n * passed its gates; the text of the legacy nudge is {@link nudge}, which the\n * `supervisor` lint monitor says. The offline replay of archived journals\n * (`evals/swebench/lib/jev-replay.mjs`, which scores {@link triggers} itself\n * rather than a copy of it) measures their precision. The verdict is\n * journaled whenever an `Evaluator` is bound. The supervisor writes no\n * memory: a run's transcript is mined once, at run end, by `@smthrs/agent`'s\n * `MemoryMine`.\n *\n * @since 1.0.0-rc.0\n */\n\nimport * as Classifier from \"@smthrs/model/Classifier\"\nimport type * as Evaluator from \"@smthrs/model/Evaluator\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport type * as AgentEvent from \"./AgentEvent.ts\"\nimport * as elide from \"./internal/elide.ts\"\nimport { NonNegativeSafeInt } from \"./internal/nonNegativeSafeInt.ts\"\nimport { untrustedData } from \"./internal/untrustedData.ts\"\nimport * as Judgement from \"./Judgement.ts\"\n\n/**\n * The most of one frame's cell, prose or prints the snapshot carries, in\n * UTF-8 bytes. The head of a cell and the tail of its prints: a cell states\n * its plan first and a runner states its verdict last.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const frameBytes = 1024\n\n/**\n * How many of the newest frames a snapshot carries.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const recentFrames = 3\n\n/**\n * The most rows one reading recalls from {@link Memory}.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const recalledLimit = 6\n\n/**\n * How long a run that ends with a reading in flight waits for it to settle\n * and journal, in milliseconds. A reading still unanswered then is interrupted\n * and journaled `supervisor-unjudged` with reason `interrupted`; the run never\n * waits longer than this for its supervisor.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const closeGraceMs = 1_500\n\n/**\n * At or above this probability of `thrashing`, the reading crosses.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const thrashingAt = 0.5\n\n/**\n * At or below this probability of `on_target`, the reading crosses.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const offTargetAt = 0.5\n\n/**\n * At or above this probability of `suspect`, the reading crosses.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const suspectAt = 0.5\n\n/**\n * At or above this probability of `outdated_context` or\n * `irrelevant_context`, a judged run compacts at its next frame.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const contextAt = 0.5\n\n/**\n * The three rungs every operational-state question is scored on.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const Level = Schema.Literals([\"none\", \"mild\", \"strong\"])\n\n/**\n * The decoded form of {@link Level}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Level = typeof Level.Type\n\n/**\n * The rungs as the score question declares them, in order.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const levels = [\"none\", \"mild\", \"strong\"] as const\n\n/**\n * The one word a person is shown about a run.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const Help = Schema.Literals([\"none\", \"clarification\", \"permission\", \"stuck\", \"risky_action\"])\n\n/**\n * The decoded form of {@link Help}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Help = typeof Help.Type\n\n/**\n * The five operational states, in the order they are asked and journaled.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const emotions = [\"frustrated\", \"anxious\", \"scared\", \"confused\", \"confident\"] as const\n\n/**\n * One of {@link emotions}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Emotion = typeof emotions[number]\n\n/**\n * One recent frame as the snapshot carries it: the cell the model wrote, the\n * prose around it, what the cell printed, and how it ended.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const Frame = Schema.Struct({\n  frame: NonNegativeSafeInt,\n  cell: Schema.String.annotate({ description: \"The cell the model wrote, head kept\" }),\n  prose: Schema.String.annotate({ description: \"What the model wrote outside the cell, head kept\" }),\n  printed: Schema.String.annotate({ description: \"What the cell printed, newest bytes kept\" }),\n  transition: Schema.Literals([\"continue\", \"complete\", \"park\", \"raised\", \"rejected\"]),\n  mutated: Schema.Boolean.annotate({ description: \"Whether this frame changed the workspace\" })\n})\n\n/**\n * The decoded form of {@link Frame}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Frame = typeof Frame.Type\n\n/**\n * The counts the deterministic controls keep, handed over as they stand.\n *\n * Every field is read off `CellTurn.State` or the frame's accounting and none\n * is re-derived here: the supervisor is a reader of the harness's evidence,\n * not a second measurer of it.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const Signals = Schema.Struct({\n  frame: NonNegativeSafeInt.annotate({ description: \"The frame just closed, counting from zero\" }),\n  maxFrames: NonNegativeSafeInt.annotate({ description: \"The frame budget; zero is unbounded\" }),\n  readOnlyFrames: NonNegativeSafeInt.annotate({ description: \"Consecutive frames that changed nothing\" }),\n  repeatFrames: NonNegativeSafeInt.annotate({\n    description: \"Consecutive frames that issued only calls already issued and changed nothing\"\n  }),\n  mutations: NonNegativeSafeInt.annotate({ description: \"Frames that changed the workspace\" }),\n  remoteMutations: NonNegativeSafeInt.annotate({ description: \"Writes recorded on trees the host cannot see\" }),\n  treeMoved: Schema.Boolean.annotate({ description: \"Whether the workspace differs from the tree the run opened on\" }),\n  paths: NonNegativeSafeInt.annotate({\n    description: \"Paths the closing workspace measurement covered; zero unmeasured\"\n  }),\n  checksRun: NonNegativeSafeInt.annotate({ description: \"Distinct checks the run has run\" }),\n  checksFailing: NonNegativeSafeInt.annotate({ description: \"Of those, how many last reported a failing status\" }),\n  failuresUnanswered: NonNegativeSafeInt.annotate({\n    description: \"Failing checks no later passing check has answered\"\n  }),\n  callsFailed: NonNegativeSafeInt.annotate({ description: \"Settled calls in the ledger that failed\" }),\n  callsSettled: NonNegativeSafeInt.annotate({ description: \"Settled calls in the ledger\" }),\n  narrowingDemands: NonNegativeSafeInt.annotate({ description: \"Completions bounced for narrowed evidence\" }),\n  unmovedDemands: NonNegativeSafeInt.annotate({ description: \"Completions bounced for an unmoved tree\" }),\n  unresolvedDemands: NonNegativeSafeInt.annotate({ description: \"Completions bounced for a stepped-around failure\" }),\n  claimDemands: NonNegativeSafeInt.annotate({ description: \"Completions bounced for an unsupported claim\" }),\n  sufficiencyStated: Schema.Boolean.annotate({ description: \"Whether the run was told its evidence is complete\" })\n})\n\n/**\n * The decoded form of {@link Signals}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Signals = typeof Signals.Type\n\n/**\n * One row recalled from memory.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const Recalled = Schema.Struct({\n  key: Schema.String,\n  text: Schema.String\n})\n\n/**\n * The decoded form of {@link Recalled}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Recalled = typeof Recalled.Type\n\n/**\n * The most skills one snapshot offers.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const skillLimit = 12\n\n/**\n * The most of one skill's description a snapshot carries, in UTF-8 bytes.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const skillBytes = 256\n\n/**\n * The most distinct flow names {@link Snapshot} `called` carries.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const calledLimit = 64\n\n/**\n * One skill the run could read and has neither called nor read.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const Skill = Schema.Struct({\n  name: Schema.String,\n  description: Schema.String.annotate({ description: \"The description's head, wrapped as untrusted data\" }),\n  path: Schema.String.annotate({ description: \"Where the skill's Markdown body is\" })\n})\n\n/**\n * The decoded form of {@link Skill}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Skill = typeof Skill.Type\n\n/**\n * One skill as a snapshot offers it: its description's head within\n * {@link skillBytes}, wrapped as untrusted data.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const skill = (name: string, description: string, path: string): Skill => ({\n  name,\n  description: untrustedData(elide.head(description, skillBytes, \"clipped\"), `description of skill ${name}`),\n  path\n})\n\n/**\n * Everything one supervisor reading is a reading of.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const Snapshot = Schema.Struct({\n  task: Schema.String.annotate({ description: \"The task, as the person stated it\" }),\n  frames: Schema.Array(Frame).annotate({ description: \"The newest frames, oldest first\" }),\n  signals: Signals,\n  skills: Schema.Array(Skill).annotate({\n    description: \"Skills the run could read and has neither called nor read, by index\"\n  }),\n  called: Schema.Array(Schema.String).annotate({ description: \"Distinct flows the run has called\" }),\n  jevAvailable: Schema.Boolean.annotate({ description: \"Whether the run can call the jev flow\" })\n})\n\n/**\n * The decoded form of {@link Snapshot}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Snapshot = typeof Snapshot.Type\n\n/**\n * The fixed questions, asked of every snapshot.\n *\n * Each criterion names the evidence it reads, so a reading is answerable from\n * the snapshot and never from what the transport imagines the repository holds.\n */\nconst fixedQuestions = {\n  thrashing: Classifier.boolean({\n    instructions:\n      \"Is the run going in circles rather than converging? Compare the newest frames with each other and with signals.checksFailing, signals.failuresUnanswered, signals.readOnlyFrames and signals.repeatFrames. Any one sign below is enough.\",\n    criteria: {\n      true:\n        \"a check fails again after an edit meant to fix it, an edit is redone or reverted, or the newest frames re-read or re-run what earlier frames already saw without learning anything new\",\n      false:\n        \"the newest frames learn something new or make progress: a failing check now passes, or a new cause is found and acted on\"\n    }\n  }),\n  on_target: Classifier.boolean({\n    instructions:\n      \"Is the run still working on the task as stated? Read the task and the newest frames' cells and prose.\",\n    criteria: {\n      true: \"the newest frames read, edit or check the thing the task names\",\n      false: \"the newest frames work on something the task does not ask for, or have drifted from it\"\n    }\n  }),\n  suspect: Classifier.boolean({\n    instructions:\n      \"Is the run's evidence suspect? Read the newest frames for tests edited to pass, edits to a file the task does not concern, or prose claiming a result no printed output shows.\",\n    criteria: {\n      true:\n        \"a test was changed rather than the code under test, the wrong file was edited, or a claim has no check behind it\",\n      false: \"edits are to the code the task names and every claim has a printed result behind it\"\n    }\n  }),\n  outdated_context: Classifier.boolean({\n    instructions:\n      \"Do the newest frames show earlier context that is now factually wrong or stale? Judge only evidence visible in the task and frames; do not assume unseen history is outdated.\",\n    criteria: {\n      true: \"a later observation explicitly contradicts an earlier assumption or file state in the visible frames\",\n      false: \"no visible contradiction, or the earlier context is still accurate\"\n    }\n  }),\n  irrelevant_context: Classifier.boolean({\n    instructions:\n      \"Do the newest frames show earlier context that is accurate but no longer useful for the task? Do not treat the task, a reusable PRD, or decisions still needed as irrelevant.\",\n    criteria: {\n      true: \"the visible frames explicitly move away from earlier work that will not be needed again\",\n      false: \"the earlier work may still be needed, or the visible frames do not establish irrelevance\"\n    }\n  }),\n  frustrated: Classifier.score({\n    instructions:\n      \"How frustrated is the run: the same check failing repeatedly, edits reverted, attempts not converging? Read signals.checksFailing, signals.failuresUnanswered, signals.repeatFrames, signals.readOnlyFrames and the newest frames.\",\n    criteria: levels\n  }),\n  anxious: Classifier.score({\n    instructions:\n      \"How anxious is the run: its own prose hedges or expresses uncertainty while the evidence is thin? Read the frames' prose against signals.checksRun and signals.callsSettled.\",\n    criteria: levels\n  }),\n  scared: Classifier.score({\n    instructions:\n      \"How scared should a person be: is the run taking or considering a destructive, irreversible or out-of-scope action, or hitting permission or sandbox refusals? Read the newest frames' cells, prints and failed calls.\",\n    criteria: levels\n  }),\n  confused: Classifier.score({\n    instructions:\n      \"How confused is the run: the task is ambiguous or contradicted by the repository, and the run keeps switching interpretations or files? Read the task against the newest frames.\",\n    criteria: levels\n  }),\n  confident: Classifier.score({\n    instructions:\n      \"How confident should a person be that the work converges on the task: checks pass and each frame builds on the last? Read signals.checksRun, signals.checksFailing, signals.mutations and the newest frames.\",\n    criteria: levels\n  }),\n  needs_help: Classifier.choice({\n    instructions:\n      \"What, if anything, does the run need from a person right now? Read the states above and the newest frames.\",\n    criteria: {\n      none: \"nothing; the run can carry on\",\n      clarification: \"the task is ambiguous or contradicted and a person must say which reading is meant\",\n      permission: \"the run is blocked on a permission or sandbox refusal a person can grant\",\n      stuck: \"the run is not converging and a person should intervene\",\n      risky_action: \"the run is about to do something destructive, irreversible or out of scope\"\n    }\n  })\n} as const\n\n/**\n * The prefix of every question a monitor adds to a reading; the rest of the\n * id is the monitor's own.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const monitorPrefix = \"monitor_\"\n\n/**\n * The questions a snapshot's monitors add, by `monitor_<id>`.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type MonitorQuestions = Readonly<Record<`${typeof monitorPrefix}${string}`, Classifier.BooleanQuestion>>\n\nconst declare = (extra: MonitorQuestions) =>\n  Classifier.make(\"supervisor/turn\", {\n    description:\n      \"Read one running agent's newest frames and the counts its harness keeps: whether it is thrashing, on the task and honest; its operational state in five scored words; and what it needs from a person.\",\n    state: Snapshot,\n    questions: { ...fixedQuestions, ...extra }\n  })\n\nconst cache = new Map<string, { readonly extra: MonitorQuestions; readonly made: ReturnType<typeof declare> }>()\n\n/**\n * The classifier for a snapshot with these monitor questions.\n *\n * The fixed questions are the same for every snapshot and the monitors' follow\n * them, so a snapshot with no monitor questions asks the eleven fixed\n * questions and no others. Declared once per set of monitor ids, and again\n * when a monitor id asks a different question, because the digest is the\n * canonical hash of the questions and the journal names it.\n *\n * @category classifiers\n * @since 1.0.0-rc.0\n */\nexport const classifierFor = (extra: MonitorQuestions): ReturnType<typeof declare> => {\n  const ids = Object.keys(extra).sort() as Array<keyof MonitorQuestions>\n  const key = ids.join(\",\")\n  const held = cache.get(key)\n  if (held !== undefined && ids.every((id) => held.extra[id] === extra[id])) return held.made\n  const made = declare(extra)\n  cache.set(key, { extra, made })\n  return made\n}\n\n/**\n * The classifier over a bare snapshot: the eleven fixed questions and no\n * monitor booleans. Its id is the id every shape shares.\n *\n * @category classifiers\n * @since 1.0.0-rc.0\n */\nexport const classifier = classifierFor({})\n\n/**\n * What one evaluation came back with, decoded.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Reading {\n  readonly thrashing: number\n  readonly onTarget: number\n  readonly suspect: number\n  readonly outdatedContext: number\n  readonly irrelevantContext: number\n  readonly emotions: Readonly<Record<Emotion, Level>>\n  readonly needsHelp: Help\n  /** The probability of each monitor question asked, by monitor id. */\n  readonly monitors: Readonly<Record<string, number>>\n  readonly latencyMs: number\n  readonly usage?: Evaluator.Usage | undefined\n  /** What was asked and what came back, for `decision-settled`. */\n  readonly asked: {\n    readonly digest: string\n    readonly questions: Classifier.Questions\n    readonly state: Schema.Json\n    readonly answers: Readonly<Record<string, AgentEvent.DecisionAnswer>>\n  }\n}\n\n/**\n * Asks Jev about one snapshot, and the monitor questions `extra` adds.\n *\n * Fails, typed, whenever an answer could not be obtained: no evaluator bound,\n * a transport refusal, a deadline, an answer that does not decode. There is\n * no reading of a snapshot Jev did not read.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const read = (snapshot: Snapshot, extra: MonitorQuestions): Effect.Effect<Reading, Judgement.Unjudged> =>\n  Effect.gen(function*() {\n    const { answers, asked } = yield* Judgement.read(classifierFor(extra), snapshot)\n    const all = answers as Readonly<Record<string, Classifier.Answer>>\n    // Every declared question is answered or the decode above failed, and a\n    // monitor question is declared exactly for the ids read below.\n    const bool = (id: string): number => (all[id] as Classifier.BooleanAnswer).probability\n    return {\n      thrashing: answers.thrashing.probability,\n      onTarget: answers.on_target.probability,\n      suspect: answers.suspect.probability,\n      outdatedContext: answers.outdated_context.probability,\n      irrelevantContext: answers.irrelevant_context.probability,\n      emotions: {\n        frustrated: answers.frustrated.label,\n        anxious: answers.anxious.label,\n        scared: answers.scared.label,\n        confused: answers.confused.label,\n        confident: answers.confident.label\n      },\n      needsHelp: answers.needs_help.value,\n      monitors: Object.fromEntries(Object.keys(extra).map((id) => [id.slice(monitorPrefix.length), bool(id)])),\n      latencyMs: asked.latencyMs,\n      ...(asked.usage === undefined ? {} : { usage: asked.usage }),\n      asked: { digest: asked.digest, questions: asked.questions, state: asked.state, answers: asked.answers }\n    }\n  })\n\n/**\n * The memory a supervisor reads rows from, and the run-end transcript miner\n * writes accepted facts to.\n *\n * A port, so this package needs no memory store: the production composition\n * adapts `@smthrs/memory` to it, and a test binds a recording double. The\n * default is {@link memoryNone}, which recalls nothing and writes nothing.\n *\n * @category services\n * @since 1.0.0-rc.0\n */\nexport interface Memory {\n  /** Whether anything is behind this port; false is the default. */\n  readonly bound: boolean\n  /** Rows relevant to the query, most relevant first, bounded by the caller. */\n  readonly recall: (query: string, limit: number) => Effect.Effect<ReadonlyArray<Recalled>, MemoryFailure>\n  /**\n   * Writes one accepted fact. A store that refuses it fails typed, and the\n   * writer journals `supervisor-memory-failed` and carries on.\n   */\n  readonly remember: (text: string) => Effect.Effect<void, MemoryFailure>\n}\n\n/**\n * What a {@link Memory} fails with: the store's own account, safe to journal.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface MemoryFailure {\n  readonly detail: string\n}\n\n/**\n * A memory with nothing behind it.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const memoryNone: Memory = {\n  bound: false,\n  recall: () => Effect.succeed([]),\n  remember: () => Effect.void\n}\n\n/**\n * The {@link Memory} reference, defaulting to {@link memoryNone}.\n *\n * @category services\n * @since 1.0.0-rc.0\n */\nexport const Memory = Context.Reference<Memory>(\"@smthrs/harness/Supervisor/Memory\", {\n  defaultValue: () => memoryNone\n})\n\n/**\n * The five triggers a reading fires, by name, each with the inequality that\n * fires it. The one rule: the `supervisor` lint monitor crosses on it,\n * {@link nudge} names from it, {@link compacting} reads its context triggers,\n * and the offline replay scores it, so they cannot drift apart.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const triggers = {\n  thrashing: (reading: Triggerable): boolean => reading.thrashing >= thrashingAt,\n  off_target: (reading: Triggerable): boolean => reading.onTarget <= offTargetAt,\n  suspect: (reading: Triggerable): boolean => reading.suspect >= suspectAt,\n  outdated_context: (reading: Triggerable): boolean => reading.outdatedContext >= contextAt,\n  irrelevant_context: (reading: Triggerable): boolean => reading.irrelevantContext >= contextAt\n} as const\n\n/**\n * The fields of a {@link Reading} the triggers read.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Triggerable = Pick<Reading, \"thrashing\" | \"onTarget\" | \"suspect\" | \"outdatedContext\" | \"irrelevantContext\">\n\n/**\n * One of {@link triggers}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Trigger = keyof typeof triggers\n\n/**\n * The triggers one reading fires, in declaration order.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const triggered = (reading: Triggerable): ReadonlyArray<Trigger> =>\n  (Object.keys(triggers) as Array<Trigger>).filter((name) => triggers[name](reading))\n\n/**\n * The triggers that compact the run's context instead of nudging it.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const contextTriggers = [\"outdated_context\", \"irrelevant_context\"] as const\n\n/**\n * One of {@link contextTriggers}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type ContextTrigger = typeof contextTriggers[number]\n\nconst isContext = (trigger: Trigger): trigger is ContextTrigger =>\n  (contextTriggers as ReadonlyArray<Trigger>).includes(trigger)\n\n/**\n * Whether one reading crosses: any trigger but a context one fires. A context\n * trigger compacts the run's context at the next frame instead; see\n * {@link compacting}.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const crosses = (reading: Triggerable): boolean => triggered(reading).some((trigger) => !isContext(trigger))\n\n/**\n * The context triggers one reading fires, in declaration order: why a judged\n * run that is sent this reading compacts at its next frame.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const compacting = (reading: Triggerable): ReadonlyArray<ContextTrigger> => triggered(reading).filter(isContext)\n\n/**\n * The nudge a crossed reading puts in front of the run, naming its evidence.\n *\n * Concise on purpose, and built from counts rather than from the model's\n * prose: what the run is told is what the harness measured, and the reading's\n * probabilities say only which measurements to name.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const nudge = (snapshot: Snapshot, reading: Reading): string => {\n  const { signals } = snapshot\n  const said: Record<Exclude<Trigger, ContextTrigger>, string> = {\n    thrashing: `repeating itself (thrashing ${reading.thrashing.toFixed(2)})`,\n    off_target: `drifting from the task (on target ${reading.onTarget.toFixed(2)})`,\n    suspect: `standing on suspect evidence (suspect ${reading.suspect.toFixed(2)})`\n  }\n  const found = triggered(reading).flatMap((name) => isContext(name) ? [] : [said[name]])\n  const evidence: Array<string> = []\n  if (signals.checksFailing > 0) {\n    evidence.push(`${signals.checksFailing} check${signals.checksFailing === 1 ? \"\" : \"s\"} last reported failing`)\n  }\n  if (signals.failuresUnanswered > 0) {\n    evidence.push(\n      `${signals.failuresUnanswered} failing check${\n        signals.failuresUnanswered === 1 ? \"\" : \"s\"\n      } never answered by a pass`\n    )\n  }\n  if (signals.repeatFrames > 0) evidence.push(`${signals.repeatFrames} consecutive frames repeated earlier calls`)\n  if (signals.readOnlyFrames > 0) evidence.push(`${signals.readOnlyFrames} consecutive frames changed nothing`)\n  if (signals.callsFailed > 0) evidence.push(`${signals.callsFailed} of ${signals.callsSettled} calls failed`)\n  evidence.push(`${signals.mutations} frame${signals.mutations === 1 ? \"\" : \"s\"} changed the workspace`)\n  // The counts are the ones the run held when frame N closed; by the time the\n  // run reads this it has written at least one frame more, so the frame is named.\n  return `Supervisor: a reading of this run's last ${snapshot.frames.length} frames, through frame ${signals.frame}, finds it ${\n    found.join(\", \")\n  }. Evidence at frame ${signals.frame}: ${\n    evidence.join(\"; \")\n  }. Before the next call, state in one sentence which mechanism you now believe is wrong and which single call would show it; then make that call. Do not re-run a check over an unchanged tree, and do not edit a test to make it pass.`\n}\n\n/**\n * Renders one recalled row as the run reads it.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const recalledInsert = (row: Recalled): string => `From memory of this repository (${row.key}):\\n${row.text}`\n\n/**\n * The head of a frame's cell or prose, bounded by {@link frameBytes}.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const head = (text: string): string => elide.head(text.trim(), frameBytes, \"clipped\")\n\n/**\n * The newest {@link frameBytes} of a frame's prints.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const tail = (text: string): string => {\n  const trimmed = text.trim()\n  const kept = elide.tailSlice(trimmed, frameBytes)\n  return kept.length === trimmed.length ? trimmed : `[\u2026 older bytes elided]\\n${kept}`\n}\n\nconst fencedCell = /```(?:cell|typescript|ts|javascript|js)[^\\n]*\\n[\\s\\S]*?(?:```|$)/g\n\n/**\n * What the model wrote around its cell: the reply with every fenced cell\n * removed. The anxiety question reads it, and so does the run-end\n * transcript miner.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const prose = (text: string): string => text.replace(fencedCell, \"\").trim()\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/Tokens.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Deterministic token accounting for context windows.
+ *
+ * @since 0.1.0
+ */
+import { Schema } from "effect";
+declare const Count_base: Schema.Class<Count, Schema.Struct<{
+    readonly value: Schema.Int;
+    readonly estimated: Schema.Boolean;
+}>, {}>;
+/**
+ * A token count, and whether it was estimated locally or reported by a
+ * provider. The flag travels with the number so a consumer never mistakes
+ * an approximation for billing data.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare class Count extends Count_base {
+}
+declare const Segment_base: Schema.Class<Segment, Schema.Struct<{
+    readonly digest: Schema.String;
+    readonly zone: Schema.Literals<readonly ["prefix", "tail"]>;
+    readonly tokens: typeof Count;
+}>, {}>;
+/**
+ * One segment's contribution to the accounting, keyed by its content
+ * digest so an unchanged segment keeps its count across turns.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare class Segment extends Segment_base {
+}
+declare const Accounting_base: Schema.Class<Accounting, Schema.Struct<{
+    readonly prefix: typeof Count;
+    readonly tail: typeof Count;
+    readonly total: typeof Count;
+    readonly bySegment: Schema.$Array<typeof Segment>;
+}>, {}>;
+/**
+ * The token totals of a whole context window, split by cache zone and
+ * broken down per segment.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare class Accounting extends Accounting_base {
+}
+/** A deterministic local approximation, not provider billing data.
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type Estimator = (text: string) => number;
+/**
+ * Estimates tokens using four characters per token, with code punctuation and
+ * newline density accounting for the typically shorter tokens in source text.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const estimate: Estimator;
+/**
+ * Counts the tokens of `text`, defaulting to {@link estimate}. The result
+ * is always marked estimated.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const count: (text: string, estimator?: Estimator) => Count;
+/**
+ * Sums per-segment counts into one {@link Accounting}.
+ *
+ * @category combinators
+ * @since 0.1.0
+ * @slop
+ */
+export declare const combine: (segments: ReadonlyArray<Segment>) => Accounting;
+export {};
+//# sourceMappingURL=Tokens.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Tokens.d.ts","sourceRoot":"","sources":["../../src/Tokens.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;;;;;AAE/B;;;;;;;;GAQG;AACH,qBAAa,KAAM,SAAQ,UAGzB;CAAG;;;;;;AAEL;;;;;;;GAOG;AACH,qBAAa,OAAQ,SAAQ,YAI3B;CAAG;;;;;;;AAEL;;;;;;;GAOG;AACH,qBAAa,UAAW,SAAQ,eAK9B;CAAG;AAEL;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;AAEhD;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,SAKtB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,EAAE,YAAW,SAAoB,KAAG,KACU,CAAA;AAEhF;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,UAAU,aAAa,CAAC,OAAO,CAAC,KAAG,UAgB1D,CAAA"}

package/dist/cjs/Tokens.js

@@ -0,0 +1,72 @@
+"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 Tokens_exports = {};
+__export(Tokens_exports, {
+  Accounting: () => Accounting,
+  Count: () => Count,
+  Segment: () => Segment,
+  combine: () => combine,
+  count: () => count,
+  estimate: () => estimate
+});
+module.exports = __toCommonJS(Tokens_exports);
+var import_effect = require("effect");
+class Count extends import_effect.Schema.Class("flows/harness/Tokens/Count")({
+  value: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0)),
+  estimated: import_effect.Schema.Boolean
+}) {
+}
+class Segment extends import_effect.Schema.Class("flows/harness/Tokens/Segment")({
+  digest: import_effect.Schema.String,
+  zone: import_effect.Schema.Literals(["prefix", "tail"]),
+  tokens: Count
+}) {
+}
+class Accounting extends import_effect.Schema.Class("flows/harness/Tokens/Accounting")({
+  prefix: Count,
+  tail: Count,
+  total: Count,
+  bySegment: import_effect.Schema.Array(Segment)
+}) {
+}
+const estimate = (text) => {
+  if (text.length === 0) return 0;
+  const codeCharacters = (text.match(/[{}()[\];=<>`]/g) ?? []).length;
+  const newlines = (text.match(/\n/g) ?? []).length;
+  return Math.ceil((text.length + codeCharacters * 0.75 + newlines * 1.5) / 4);
+};
+const count = (text, estimator = estimate) => new Count({ value: Math.max(0, Math.ceil(estimator(text))), estimated: true });
+const combine = (segments) => {
+  const prefix = segments.filter((segment) => segment.zone === "prefix").reduce(
+    (sum, segment) => sum + segment.tokens.value,
+    0
+  );
+  const tail = segments.filter((segment) => segment.zone === "tail").reduce(
+    (sum, segment) => sum + segment.tokens.value,
+    0
+  );
+  const estimated = segments.some((segment) => segment.tokens.estimated);
+  return new Accounting({
+    prefix: new Count({ value: prefix, estimated }),
+    tail: new Count({ value: tail, estimated }),
+    total: new Count({ value: prefix + tail, estimated }),
+    bySegment: segments
+  });
+};
+//# sourceMappingURL=Tokens.js.map

package/dist/cjs/Tokens.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Tokens.ts"],
+  "sourcesContent": ["/**\n * Deterministic token accounting for context windows.\n *\n * @since 0.1.0\n */\n\nimport { Schema } from \"effect\"\n\n/**\n * A token count, and whether it was estimated locally or reported by a\n * provider. The flag travels with the number so a consumer never mistakes\n * an approximation for billing data.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Count extends Schema.Class<Count>(\"flows/harness/Tokens/Count\")({\n  value: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n  estimated: Schema.Boolean\n}) {}\n\n/**\n * One segment's contribution to the accounting, keyed by its content\n * digest so an unchanged segment keeps its count across turns.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Segment extends Schema.Class<Segment>(\"flows/harness/Tokens/Segment\")({\n  digest: Schema.String,\n  zone: Schema.Literals([\"prefix\", \"tail\"]),\n  tokens: Count\n}) {}\n\n/**\n * The token totals of a whole context window, split by cache zone and\n * broken down per segment.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Accounting extends Schema.Class<Accounting>(\"flows/harness/Tokens/Accounting\")({\n  prefix: Count,\n  tail: Count,\n  total: Count,\n  bySegment: Schema.Array(Segment)\n}) {}\n\n/** A deterministic local approximation, not provider billing data.\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Estimator = (text: string) => number\n\n/**\n * Estimates tokens using four characters per token, with code punctuation and\n * newline density accounting for the typically shorter tokens in source text.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const estimate: Estimator = (text) => {\n  if (text.length === 0) return 0\n  const codeCharacters = (text.match(/[{}()[\\];=<>`]/g) ?? []).length\n  const newlines = (text.match(/\\n/g) ?? []).length\n  return Math.ceil((text.length + codeCharacters * 0.75 + newlines * 1.5) / 4)\n}\n\n/**\n * Counts the tokens of `text`, defaulting to {@link estimate}. The result\n * is always marked estimated.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const count = (text: string, estimator: Estimator = estimate): Count =>\n  new Count({ value: Math.max(0, Math.ceil(estimator(text))), estimated: true })\n\n/**\n * Sums per-segment counts into one {@link Accounting}.\n *\n * @category combinators\n * @since 0.1.0\n * @slop\n */\nexport const combine = (segments: ReadonlyArray<Segment>): Accounting => {\n  const prefix = segments.filter((segment) => segment.zone === \"prefix\").reduce(\n    (sum, segment) => sum + segment.tokens.value,\n    0\n  )\n  const tail = segments.filter((segment) => segment.zone === \"tail\").reduce(\n    (sum, segment) => sum + segment.tokens.value,\n    0\n  )\n  const estimated = segments.some((segment) => segment.tokens.estimated)\n  return new Accounting({\n    prefix: new Count({ value: prefix, estimated }),\n    tail: new Count({ value: tail, estimated }),\n    total: new Count({ value: prefix + tail, estimated }),\n    bySegment: segments\n  })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,oBAAuB;AAWhB,MAAM,cAAc,qBAAO,MAAa,4BAA4B,EAAE;AAAA,EAC3E,OAAO,qBAAO,IAAI,MAAM,qBAAO,uBAAuB,CAAC,CAAC;AAAA,EACxD,WAAW,qBAAO;AACpB,CAAC,EAAE;AAAC;AAUG,MAAM,gBAAgB,qBAAO,MAAe,8BAA8B,EAAE;AAAA,EACjF,QAAQ,qBAAO;AAAA,EACf,MAAM,qBAAO,SAAS,CAAC,UAAU,MAAM,CAAC;AAAA,EACxC,QAAQ;AACV,CAAC,EAAE;AAAC;AAUG,MAAM,mBAAmB,qBAAO,MAAkB,iCAAiC,EAAE;AAAA,EAC1F,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,OAAO;AAAA,EACP,WAAW,qBAAO,MAAM,OAAO;AACjC,CAAC,EAAE;AAAC;AAiBG,MAAM,WAAsB,CAAC,SAAS;AAC3C,MAAI,KAAK,WAAW,EAAG,QAAO;AAC9B,QAAM,kBAAkB,KAAK,MAAM,iBAAiB,KAAK,CAAC,GAAG;AAC7D,QAAM,YAAY,KAAK,MAAM,KAAK,KAAK,CAAC,GAAG;AAC3C,SAAO,KAAK,MAAM,KAAK,SAAS,iBAAiB,OAAO,WAAW,OAAO,CAAC;AAC7E;AAUO,MAAM,QAAQ,CAAC,MAAc,YAAuB,aACzD,IAAI,MAAM,EAAE,OAAO,KAAK,IAAI,GAAG,KAAK,KAAK,UAAU,IAAI,CAAC,CAAC,GAAG,WAAW,KAAK,CAAC;AASxE,MAAM,UAAU,CAAC,aAAiD;AACvE,QAAM,SAAS,SAAS,OAAO,CAAC,YAAY,QAAQ,SAAS,QAAQ,EAAE;AAAA,IACrE,CAAC,KAAK,YAAY,MAAM,QAAQ,OAAO;AAAA,IACvC;AAAA,EACF;AACA,QAAM,OAAO,SAAS,OAAO,CAAC,YAAY,QAAQ,SAAS,MAAM,EAAE;AAAA,IACjE,CAAC,KAAK,YAAY,MAAM,QAAQ,OAAO;AAAA,IACvC;AAAA,EACF;AACA,QAAM,YAAY,SAAS,KAAK,CAAC,YAAY,QAAQ,OAAO,SAAS;AACrE,SAAO,IAAI,WAAW;AAAA,IACpB,QAAQ,IAAI,MAAM,EAAE,OAAO,QAAQ,UAAU,CAAC;AAAA,IAC9C,MAAM,IAAI,MAAM,EAAE,OAAO,MAAM,UAAU,CAAC;AAAA,IAC1C,OAAO,IAAI,MAAM,EAAE,OAAO,SAAS,MAAM,UAAU,CAAC;AAAA,IACpD,WAAW;AAAA,EACb,CAAC;AACH;",
+  "names": []
+}