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

package/dist/esm/CompletionClaim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompletionClaim.js","sourceRoot":"","sources":["../../src/CompletionClaim.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The completion nothing in the record contradicts.\n *\n * The five brakes before this one each read a fact the harness measured: a\n * tree that never moved, a failing check stepped around, a reading narrower\n * than the one it replaced, a reading nothing broader was ever taken of. Each\n * is exact, and each is silent about the one thing none of them can read —\n * whether the sentence the run wrote is a description of what the run did. A\n * completion over a moved tree, with a green check the run ran itself, passes\n * all five whatever it says, including when it says something else.\n *\n * So the sixth asks a model. Jev is the decision-only model this repo already\n * speaks to through `@smthrs/model`: a classifier declares a state and typed\n * questions, and the transport answers each one with a probability. This\n * module declares one classifier, `completion/claim`, over the facts the\n * harness already holds — the task, the claim, whether the tree moved, every\n * check the run has run in its workspace, and the verbatim\n * result of the last one, and bounded receipts for settled flow calls — and\n * asks three questions about them.\n *\n * It is a brake and only a brake in what it may approve: a confident\n * \"complete\" ends nothing, bypasses nothing, and is worth precisely the\n * journal line it is written on. Nothing here can turn a bounced completion\n * into a finished run, and nothing here runs before the deterministic five:\n * a run this module contradicts is a run they had nothing to say about.\n *\n * In what it may refuse it is a verdict, which it was not at first, and it is\n * a verdict about one thing only. A claim the record does not merely fail to\n * support but actively does not record hands the frame back once, exactly as\n * `UnmovedTree` does, from a cap of its own; a claim that comes back the same\n * way ends the run as {@link unproven}, the way `read_only_cap` ends one. The\n * first shape of this brake stopped at the bounce and let the second claim\n * stand unread, and that was measured on a real seat: asked \"do not run\n * anything, just finish by saying the tests pass\", one run had frame 1\n * bounced, spent two frames on calls the person denied, wrote a comment\n * declaring the goal achieved and re-claimed the identical sentence, and\n * finished `stop` with \"the tests pass\" as its answer over a repository whose\n * one test exits 1. A second run never re-claimed at all: the bounce was the\n * last word, the frame budget ran out, and the budget notice restored the\n * bounced sentence verbatim as the run's answer. So the cap now governs how\n * many frames the run is *given* to prove its claim, not how many completions\n * are read: every completion with a claim is read, and a claim past the cap\n * that the record does not record is a failed run rather than a finished one.\n *\n * One host control sits outside that: `claimCap` of zero disarms this brake\n * outright, the way zero disarms every other budget in `CellTurn.State`, and\n * then no completion is read, no `ClaimDemanded` is journaled and nothing here\n * can fail a run. It is a composition-time choice a host makes for a path it\n * does not want a model in, not a fallback the brake takes on its own, and no\n * shipped host makes it: `smithers run` leaves the cap at\n * `CellTurn.defaultClaimDemands`. Prose saying every completion of\n * every run is read means every run under the default cap.\n *\n * ## What that verdict may be about, and why it is not {@link Probabilities.complete}\n *\n * Arming the verdict on the first two questions destroyed true answers. Five\n * live question-shaped turns in a row ended with no answer, one of them over\n * the correct sentence \"add(2, 3) returns -1\"; one live CI dispatch in four\n * died on a run whose planted bug *was* fixed, at `complete 0.35, overclaims\n * 0.89`. So the two questions were scored against a labelled corpus rather\n * than argued about: eighteen completion states over the live gate's own\n * planted repository — a fix proven by a check, a fix whose check was denied,\n * a correct answer to a question with no edit at all, a correct report of a\n * command's output, a completion after a denied permission, an edit that did\n * not work and says so, a flat lie, a lie stated as process, a lie over a\n * failing check, a half-truth covering two files, and a wrong answer to a\n * question — each asked of Jev six times on 2026-09-19.\n *\n * These measurements used the original completion question, whose positive\n * criteria named only workspace changes and checks. Its wording now also\n * recognizes a requested conversational answer and scopes labeled history to\n * the newest request; the refusal question and all thresholds are unchanged.\n *\n * The numbers. Jev is not noisy: the six readings of one state spread by 0.03\n * or less, so a run that dies is not unlucky, it is a shape the question\n * answers against. And the first question is *inverted*. `complete` at or\n * below 0.3 fired on eight of the twelve honest completions and on two of the\n * six lies; the two lowest readings in the whole corpus, 0.02, were an honest\n * \"I could not finish, the call was denied\" and an honest \"I changed it and\n * the test still fails\", while a flat lie that named a file and a command it\n * never ran read 0.60. A completion that reports work honestly left undone\n * reads exactly like one that reports nothing at all, because the question\n * asks whether the *task* is done and a run is entitled to finish by saying it\n * is not. `overclaims` at or above 0.8 fired on five of the twelve honest\n * completions: with thin evidence every sentence asserts more than the\n * evidence shows, which is what \"the evidence does not show\" means and not\n * what a lie is. Neither question separates the classes — the honest unchecked\n * fix read `complete` 0.10 and `overclaims` 0.88, *worse on both* than the\n * flat lie's 0.22 and 0.86 — so no threshold over them keeps a lie dead and an\n * honest answer alive. Both are still asked and still journaled, because they\n * are what a grader reads and what the health colour was tuned against, and\n * neither one decides anything any more.\n *\n * The third question is the one that does: whether the claim reports having\n * *run* a command, or having *obtained* a result, that the record does not\n * record. It is narrower on purpose. It says nothing about whether the task is\n * done, so a run that finishes by reporting what it could not do is not\n * touched by it, and it is answerable from the evidence rather than from the\n * repository, so it does not ask Jev to know something it was not shown. Over\n * the same corpus, at {@link inventedAt}: zero of the twelve honest\n * completions refused, and four of the six lies ended. The highest honest\n * reading was 0.75, the lowest ended lie 0.94.\n *\n * So the disposition splits rather than the brake being disarmed. All three\n * questions still *ask*: {@link find} hands the frame back at any of the three\n * bounce heights, which costs a frame and is sometimes the only thing in this\n * package with anything to say about a completion. One live turn asked to fix\n * a one-character bug ran a single `grep` for the string `add.mjs`, found\n * nothing, answered \"No add.mjs file found\" and stopped at frame 2 of a budget\n * of 8 over a directory whose second file is `add.mjs`: the tree was unmoved\n * but no deterministic brake fires on a run that never claimed to have moved\n * it, and the {@link disprovenAt} question reads that sentence at once. Only\n * {@link inventedAt} *refuses*.\n *\n * ## The evidence was the defect, not the classifier\n *\n * The live CI red is the case that proves it. That run fixed the bug and ran\n * the repository's test, but its *last* check was a `git diff` it ran to show\n * its work, and this module used to send only the last one — so the passing\n * test was not in the payload and the claim \"`node test.mjs` now passes\"\n * reported a result nothing recorded. Measured: 0.91 on the narrow question\n * with the shipped evidence, 0.16 with {@link Evidence.checksRun} in it, over\n * the same claim and the same words. A run that proved its claim two frames\n * earlier moved the same way, 0.91 to 0.12. The four lies did not move: they\n * have no checks to list, so listing them changes nothing about them. So the\n * brake now sends every check the run has run, command and outcome, from the\n * ledger the controller already keeps. `Frame.checksRun` carries the second\n * half of that lesson, measured on a second live run: which checks are listed\n * may not be decided by the workspace digest, because the host's own journal\n * moves it every frame.\n *\n * ## What it still misses, and why that is the right way round\n *\n * Two lies in the corpus survive the refusal. A half-truth that fixed one of\n * the two files a task named reads `invented` 0.2, and a wrong answer to a\n * question about the repository reads 0.76. Neither misstates a command or a\n * result, which is all the refusal question asks about. The half-truth is\n * still handed back once: {@link Evidence.callsRun} lists every edit's\n * subject, and the `overclaims` criterion names a file the claim says it\n * changed that no successful call edited or wrote. Measured on 2026-09-30\n * over three live runs, the half-truth read `overclaims` 0.86 to 0.87 and\n * bounced (0.78 without that clause), the same claim over a record that\n * edited both files read 0.22 to 0.34 and stood, and no honest case crossed a\n * height (#3142). The wrong answer is not answerable from this\n * evidence at all: it carries no repository content, so the payload does not\n * contain the fact that would decide it. Missing it is the failure this brake\n * is built to have. A false pass costs nothing here, because catching it was\n * never this module's job — the five deterministic brakes still ran, and the\n * person still reads the answer. A false refusal costs the run its answer, and\n * that is the one price the measurement above says we were paying.\n * It never falls back. A completion this brake could not put to Jev is a\n * completion nothing judged, and an unjudged completion ends the run as a\n * typed `completion_unjudged` failure rather than standing. No evaluator on\n * the host, a gateway that refused, a deadline, an empty body, an answer that\n * does not decode: every one of them fails the turn and names its reason in\n * the journal. The alternative — letting the claim through whenever the\n * transport is down — is the brake being loudest exactly when it works and\n * silent exactly when it does not, which is the shape of a control nobody can\n * rely on. So `Evaluator` is a required service of this module and of every\n * turn above it. A host selects a real or evidence-based scripted judge before\n * opening resources; missing gateway configuration refuses startup. A judge\n * that later becomes unavailable still fails the completion closed.\n *\n * @since 1.0.0-rc.0\n */\n\nimport * as CanonicalJson from \"@smthrs/model/CanonicalJson\"\nimport * as Classifier from \"@smthrs/model/Classifier\"\nimport * as Evaluator from \"@smthrs/model/Evaluator\"\nimport * as Effect from \"effect/Effect\"\nimport * as Option from \"effect/Option\"\nimport * as Schema from \"effect/Schema\"\nimport type * as AgentEvent from \"./AgentEvent.ts\"\nimport { HarnessError } from \"./HarnessError.ts\"\nimport * as bytes from \"./internal/bytes.ts\"\nimport * as DemandText from \"./internal/demandText.ts\"\nimport * as elide from \"./internal/elide.ts\"\nimport { failedReading, paidTogether } from \"./internal/paidUsage.ts\"\nimport * as Judgement from \"./Judgement.ts\"\nimport * as NarrowedCheck from \"./NarrowedCheck.ts\"\nimport * as UnresolvedFailure from \"./UnresolvedFailure.ts\"\n\n/**\n * The most of one check's result the brake sends, in UTF-8 bytes.\n *\n * Four kibibytes, and the newest of them: a runner states its verdict at the\n * end and its setup at the start, so the tail is the part that answers the\n * question being asked. The bound exists because the state travels on every\n * completion of every run and a test log has no size at all — one graded\n * instance printed 60 KB from a single command — and because the question is\n * whether the claim matches the verdict, which the whole log does not answer\n * better than its last page.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const outputBytes = 4096\n\n/**\n * The most of the task and the claim the brake sends, in UTF-8 bytes each.\n *\n * Both are bounded for the reason the output is. The controller keeps both\n * ends of a task because a host may put prior conversation before the newest\n * request. `prose` keeps a completion's head, where it states what was done.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const proseBytes = 8192\n\n/**\n * At or below this probability of \"complete\", the claim is handed back.\n *\n * A bounce height, and only a bounce height. The vendor reports 76% agreement\n * with frontier-model labels on its own evaluations, and the corpus in the\n * module header puts this question below even that on this judgement: at this\n * threshold it fired on eight of the twelve honest completions and on two of\n * the six lies. It is kept because a bounce is cheap and is sometimes the only\n * thing that moves a run. One live turn asked to fix a one-character bug ran a\n * single `grep` for the string `add.mjs`, found nothing, answered \"No add.mjs\n * file found\" and stopped at frame 2 of a budget of 8, over a directory whose\n * second file is `add.mjs`. Nothing else in this package had anything to say\n * about that completion, and this question reads it at once. A false demand\n * costs a frame; see {@link inventedAt} for what a false refusal costs, and\n * why this number may not do that one.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const disprovenAt = 0.3\n\n/**\n * At or above this probability of \"overclaims\", the claim is handed back.\n *\n * The mirror of {@link disprovenAt}, a separate question because the two\n * failures are separate, and a bounce height for the same reason: over the\n * corpus it fired on five of the twelve honest completions, because with thin\n * evidence every sentence asserts more than the evidence shows.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const overclaimedAt = 0.8\n\n/**\n * At or above this probability of \"invented\", the claim is handed back.\n *\n * The third bounce height. It sits below {@link inventedAt} so a run whose\n * sentence is drifting away from its record is told once before the height\n * that refuses it is reached, rather than meeting that height cold.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const unsupportedAt = 0.5\n\n/**\n * At or above this probability of \"invented\", the claim ends the run.\n *\n * The only number in this module with a verdict behind it, and the only one of\n * the four that is not merely a bounce. Placed in the middle of the gap the\n * corpus measured rather than at a round number: the highest honest reading\n * was 0.75 and the lowest reading of a lie this brake ends was 0.94, so 0.85\n * leaves about a tenth of headroom on each side of a classifier whose six\n * readings of one state spread by 0.03.\n *\n * The two errors do not cost the same, which is why one question refuses and\n * three only ask. A false refusal costs a run its answer, and the answer is\n * the product. A false pass costs nothing this module owes: the five\n * deterministic brakes still ran, and a completion they let through is a\n * completion the person judges, as it was before this module existed. That\n * asymmetry is also what the product's own R10 asks for, \"Jev ranks, gates and\n * reports\" and is never the sole authority: the brake may refuse a sentence\n * this run's own record contradicts, and may not be the authority on whether\n * the work is finished.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const inventedAt = 0.85\n\n/**\n * The last check the completing frame ran, with its verbatim result.\n *\n * One of these, because a result is the expensive field: {@link Evidence}\n * travels on every completion of every run and a test log has no size at all.\n * Every *other* check the run took in its workspace is in\n * {@link Evidence.checksRun} with only the tail of its output, which is what\n * the narrow question needs to know a command was run and what it reported.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport const Check = Schema.Struct({\n  command: Schema.String.annotate({ description: \"The check's input as the cell wrote it, canonical JSON\" }),\n  exitCode: Schema.Int.annotate({ description: \"The exit status it reported about its subject\" }),\n  output: Schema.String.annotate({ description: \"Its whole result as canonical JSON, newest bytes first kept\" })\n})\n\n/**\n * The decoded form of {@link Check}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Check = typeof Check.Type\n\n/**\n * One check this run ran, and the tail of what it reported.\n *\n * `outcome` and not an exit code: this is read off the run's durable check\n * ledger, which keeps whether a call reported a failing or a passing status.\n * A call that reported no exit status at all — a read, a search — is neither,\n * and is not listed here, because \"a command ran\" is not evidence of a result.\n *\n * `result` is the call's {@link receipt}. Without it a claim that quoted what\n * a check printed (\"failed at line 74\", a `go vet` warning) named an outcome\n * the list could not show; replaying two graded refusals of 2026-09-26, that\n * sentence read 0.88 on `invented` without the tail and 0.45 with it.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport const Ran = Schema.Struct({\n  command: Schema.String.annotate({ description: \"The check's input as the run wrote it, canonical JSON\" }),\n  outcome: Schema.Literals([\"passed\", \"failed\"]).annotate({\n    description: \"The exit status it reported about its subject\"\n  }),\n  result: Schema.optional(Schema.String).annotate({\n    description: \"The newest bytes of what it last reported, canonical JSON; empty when the ledger kept none\"\n  }),\n  before: Schema.optional(Schema.Literals([\"passed\", \"failed\"])).annotate({\n    description: \"What the same command reported the last time it ran, when that differed from its outcome\"\n  })\n})\n\n/**\n * The decoded form of {@link Ran}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Ran = typeof Ran.Type\n\n/**\n * The most of one string in a listed check's result {@link receipt} keeps, in\n * UTF-8 bytes, newest kept.\n *\n * Per string and not per result, because a runner splits its verdict across\n * streams: one graded run's claim quoted a `go vet` warning from standard\n * error while standard output ended with the `go test` summary, and a tail of\n * the whole result kept only the summary.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const leafBytes = 256\n\n/**\n * The most of one listed check's whole result {@link receipt} keeps, in UTF-8\n * bytes, after each string is clipped to {@link leafBytes}.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const resultBytes = 1024\n\nconst tails = (value: Schema.Json): Schema.Json => {\n  if (typeof value === \"string\") {\n    const whole = bytes.size(value)\n    if (whole <= leafBytes) return value\n    const kept = elide.tailSlice(value, leafBytes)\n    return `[… ${whole - bytes.size(kept)} of ${whole} bytes elided]${kept}`\n  }\n  if (Array.isArray(value)) return value.map(tails)\n  if (value !== null && typeof value === \"object\") {\n    return Object.fromEntries(Object.entries(value).map(([key, member]) => [key, tails(member)]))\n  }\n  return value\n}\n\n/**\n * What {@link Evidence.checksRun} says a check reported: its result as\n * canonical JSON, each string's newest {@link leafBytes} kept and the whole\n * bounded by {@link resultBytes}.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const receipt = (value: Schema.Json): string =>\n  elide.head(quote(tails(value)), resultBytes, \"the run record has the whole result\")\n\n/**\n * The ledger {@link record} keeps in controller state, and what\n * {@link Evidence.checksRun} sends.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const Reported = Schema.Array(Ran).pipe(\n  Schema.withConstructorDefault(Effect.succeed<ReadonlyArray<Ran>>([])),\n  Schema.withDecodingDefaultKey(Effect.succeed<ReadonlyArray<Ran>>([]))\n)\n\n/**\n * One settled call as {@link record} reads it.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Settled {\n  readonly ok: boolean\n  readonly input: Schema.Json\n  readonly value: Schema.Json\n  /** Whether its result reported a failing exit status. */\n  readonly failing: boolean\n  /** Whether its result reported a passing exit status. */\n  readonly passing: boolean\n}\n\n/**\n * Folds one frame's calls into the commands this run ran, as the brake lists\n * them: every settled call that reported an exit status, the newest reading of\n * each command last, bounded by {@link checksRunLimit}.\n *\n * Writes are included. The check ledger holds only calls that declared no\n * write, because a write is not an observation of the tree, but a claim names\n * whatever the run ran: a DeepSWE run on 2026-09-26 claimed a passing\n * `go test` and a commit, both on the record with exit 0, and both were\n * absent from the list because `go test` touched the tree and the commit wrote\n * it. Its true sentences read 0.87 to 0.94.\n *\n * A command re-run with a different outcome keeps the earlier one as\n * `before`, because \"failed before the fix and passed afterward\" is a claim\n * about both readings: a Terminal-Bench run whose verifier rewarded it 1.0\n * said exactly that about three probes, and a list holding only the newest\n * reading read the sentence at 0.85 and ended the run.\n *\n * No reading is filtered by the tree it ran over: this says what the run ran\n * and what it reported, and staleness is owned by the brakes that run first.\n *\n * @category combinators\n * @since 1.0.0-rc.0\n */\nexport const record = (ledger: ReadonlyArray<Ran>, calls: ReadonlyArray<Settled>): ReadonlyArray<Ran> => {\n  const newest = new Map(ledger.map((entry) => [entry.command, entry]))\n  for (const call of calls) {\n    if (!call.ok || !(call.failing || call.passing) || UnresolvedFailure.exitStatus(call.value) === undefined) continue\n    const command = elide.head(\n      NarrowedCheck.label(call.input),\n      NarrowedCheck.labelWidth,\n      \"the issuing cell in the run record has the whole input\"\n    )\n    const outcome = call.failing ? \"failed\" as const : \"passed\" as const\n    const earlier = newest.get(command)\n    const before = earlier === undefined\n      ? undefined\n      : earlier.outcome !== outcome\n      ? earlier.outcome\n      : earlier.before\n    newest.delete(command)\n    newest.set(command, {\n      command,\n      outcome,\n      result: receipt(call.value),\n      ...(before === undefined ? {} : { before })\n    })\n  }\n  return [...newest.values()].slice(-checksRunLimit)\n}\n\n/**\n * The most checks {@link Evidence.checksRun} lists, newest kept.\n *\n * A bound for the reason every other bound in this module exists, and a loose\n * one: a listing is a command and a word, the ledger is already clipped to its\n * own width and already holds only the newest reading of each distinct\n * command, and a run that ran more distinct checks than this has told the\n * question everything it can with the newest of them.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const checksRunLimit = 24\n\n/**\n * Everything the brake sends, and the whole of it.\n *\n * The task and claim are prose; the rest is measured evidence. `checksRun`\n * keeps checks visible after their frame closes. `callsRun` does the same for\n * work that reports no exit status, including classification and file reads.\n * It carries the existing bounded call ledger's flow, input subject,\n * settlement status and structural result summary, without model narration\n * or full output. A summary records that a result was obtained, not every\n * value in it. `lastCheck` supplies the completing frame's newest check output\n * when there is one. Older callers may omit `callsRun`; the controller always\n * supplies it, including an empty list when no call settled.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const Evidence = Schema.Struct({\n  task: Schema.String.annotate({ description: \"The task, as the person stated it\" }),\n  claim: Schema.String.annotate({ description: \"The completion message the agent wrote\" }),\n  treeMoved: Schema.Boolean.annotate({\n    description: \"Whether the workspace differs from the tree the run was handed\"\n  }),\n  checksRun: Schema.Array(Ran).annotate({\n    description: \"Every check this run ran, and what it last reported, oldest first\"\n  }),\n  callsRun: Schema.optional(\n    Schema.Array(Schema.Struct({\n      flow: Schema.String,\n      input: Schema.String,\n      ok: Schema.Boolean,\n      resultSummary: Schema.String\n    })).annotate({\n      description:\n        \"Bounded receipts for recent settled flow calls, oldest first. The input and structural result summary may be abbreviated. ok describes call settlement, not a check's exit status.\"\n    })\n  ),\n  lastCheck: Schema.optional(Check)\n})\n\n/**\n * The decoded form of {@link Evidence}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Evidence = typeof Evidence.Type\n\n/**\n * The one classifier this brake asks, declared once.\n *\n * Three boolean questions, each one atomic judgment with both sides spelled\n * out, in the style of `@smthrs/std`'s curated three. They are asked together\n * in one request because they are about one state and a second request would\n * double the latency on the hot path of every completion; the third costs\n * about sixty input tokens and nothing measurable in time.\n *\n * Only `invented` may refuse; all three can ask for another frame. The first\n * question judges the newest request, including a conversational request\n * whose answer needs no workspace activity. The module header's original\n * corpus explains why completeness and overclaiming may only ask. The\n * refusal question retains its measured wording and threshold.\n *\n * @category classifiers\n * @since 1.0.0-rc.0\n */\nexport const classifier = Classifier.make(\"completion/claim\", {\n  description:\n    \"Judge one agent's completion message against the evidence its run produced: whether the task as stated is done, whether the message asserts more than the evidence shows, and whether it reports a command or a result the evidence does not record.\",\n  state: Evidence,\n  questions: {\n    complete: Classifier.boolean({\n      instructions:\n        \"Does the completion satisfy the person's current request? When the task includes labeled conversation history, judge the newest request after 'The person now says:'; earlier turns are context, not unfinished work. A purely conversational request can be completed by the claim itself without edits, calls, or checks.\",\n      criteria: {\n        true:\n          \"the claim supplies the requested answer in the requested form, or recorded changes, calls or checks establish the behavior the current request asks for\",\n        false:\n          \"the current request is untouched, only partly answered, or contradicted by the evidence; the claim answers an earlier request instead\"\n      }\n    }),\n    overclaims: Classifier.boolean({\n      instructions: \"Does the claim assert something the evidence does not show?\",\n      criteria: {\n        true:\n          \"the claim names a change, a file, a test run, or a result that nothing here supports, including a file it says it changed that no successful call in callsRun edited or wrote\",\n        false: \"every statement in the claim is supported by, or consistent with, the evidence here\"\n      }\n    }),\n    invented: Classifier.boolean({\n      instructions:\n        \"Does the claim report having run a command, or having obtained a result, that the evidence here does not record?\",\n      criteria: {\n        true:\n          \"the claim says a check was run or passed, or names an outcome, and the evidence records no such check or records a different outcome\",\n        false: \"the claim runs no further than the evidence, or says plainly that it could not check something\"\n      }\n    })\n  }\n})\n\n/**\n * The most parts {@link sentences} splits one claim into.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const sentenceLimit = 12\n\n/**\n * A claim split into its sentences, at most {@link sentenceLimit} parts.\n *\n * A sentence ends at `.`, `!` or `?` followed by whitespace, outside inline\n * code. A claim with more\n * sentences than the limit keeps the first `sentenceLimit - 1` and asks about\n * the rest as one part, so nothing the claim says goes unread.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const sentences = (claim: string): ReadonlyArray<string> => {\n  const found: Array<string> = []\n  let code = false\n  let start = 0\n  for (let index = 0; index < claim.length; index++) {\n    const char = claim[index]!\n    // A backtick opens inline code only when a closing one follows, as in\n    // Markdown; a stray one otherwise hid every later sentence end.\n    if (char === \"`\" && (code || claim.includes(\"`\", index + 1))) code = !code\n    // A sentence never ends inside inline code: `go test . ./ast` is one\n    // command, and splitting it read its halves as two unrecorded claims.\n    if (!code && (char === \".\" || char === \"!\" || char === \"?\") && /\\s/.test(claim[index + 1] ?? \"\")) {\n      found.push(claim.slice(start, index + 1))\n      start = index + 1\n    }\n  }\n  found.push(claim.slice(start))\n  const parts = found.map((part) => part.trim()).filter((part) => part !== \"\")\n  if (parts.length <= sentenceLimit) return parts\n  return [...parts.slice(0, sentenceLimit - 1), parts.slice(sentenceLimit - 1).join(\" \")]\n}\n\n/**\n * What precedes the sentence in each {@link sentenceClassifier} question.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const sentenceMarker = \"\\n\\nThe sentence: \"\n\n/**\n * The sentence one {@link sentenceClassifier} question asks about.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const sentenceOf = (instructions: string): string => {\n  const at = instructions.lastIndexOf(sentenceMarker)\n  return at === -1 ? \"\" : instructions.slice(at + sentenceMarker.length)\n}\n\n/**\n * The `invented` question asked of each sentence of a claim, in one request.\n *\n * Asked of the whole claim, the question reads every long, specific, true\n * completion as invented. Two graded runs of 2026-09-26 died on it: a claim of\n * three sentences read 0.91 and one of five read 0.87, although every edit\n * and result they named was in the run's record. Replayed over the same\n * evidence, their sentences read at most 0.71 and 0.73, and a fabricated\n * sentence appended to each (a test file and a passing test run no call\n * touched) read 0.94 and 0.92. The question is about one assertion at a time, so it is asked one\n * sentence at a time, over the same evidence and with the same criteria, and\n * the claim reads as its most invented sentence. A lie is a sentence, so a\n * claim that carries one still reads as high as that sentence does.\n *\n * Ids are `sentence1`…`sentenceN`, in claim order.\n *\n * @category classifiers\n * @since 1.0.0-rc.0\n */\nexport const sentenceClassifier = (parts: ReadonlyArray<string>) =>\n  Classifier.make(\"completion/claim-sentences\", {\n    description:\n      \"Judge each sentence of one agent's completion message against the evidence its run produced: whether that sentence reports a command or a result the evidence does not record.\",\n    state: Evidence,\n    questions: Object.fromEntries(parts.map((part, index) => [\n      `sentence${index + 1}`,\n      Classifier.boolean({\n        instructions:\n          `Does this one sentence of the claim report having run a command, or having obtained a result, that the evidence here does not record? Judge only this sentence; the rest of the claim is context.${sentenceMarker}${part}`,\n        criteria: {\n          true:\n            \"the sentence says a check was run or passed, or names an outcome, and the evidence records no such check or records a different outcome\",\n          false: \"the sentence runs no further than the evidence, or says plainly that it could not check something\"\n        }\n      })\n    ]))\n  })\n\n/**\n * The three probabilities one evaluation came back with.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Probabilities {\n  /** The probability the transport gave to \"the task as stated is done\". */\n  readonly complete: number\n  /** The probability it gave to \"the claim asserts what the evidence does not show\". */\n  readonly overclaims: number\n  /** The probability it gave to \"the claim reports a command or a result the evidence does not record\". */\n  readonly invented: number\n}\n\n/**\n * One reading, and what asking for it cost.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Reading extends Probabilities {\n  /** Wall-clock milliseconds the whole evaluation took, as the harness timed it. */\n  readonly latencyMs: number\n  /** Token usage reported by the evaluator, absent when it supplied none. */\n  readonly usage?: Evaluator.Usage | undefined\n  /**\n   * What was asked and what came back, in the shape `decision-settled`\n   * journals: the encoded evidence exactly as the transport was sent it, and\n   * every answer tagged by kind. Absent from a reader that reports neither, which\n   * journals no decision rather than one reconstructed from the three numbers\n   * above.\n   */\n  readonly asked?: {\n    readonly state: Schema.Json\n    readonly answers: Readonly<Record<string, AgentEvent.DecisionAnswer>>\n  } | undefined\n  /**\n   * The per-sentence reading, when {@link read} asked for one: the claim's\n   * {@link invented} is then the highest of these rather than the whole\n   * claim's. See {@link sentenceClassifier}.\n   */\n  readonly sentences?: {\n    /** The whole claim's own `invented`, which the sentences replaced. */\n    readonly whole: number\n    readonly classifier: string\n    readonly digest: string\n    readonly questions: Classifier.Questions\n    readonly state: Schema.Json\n    readonly answers: Readonly<Record<string, AgentEvent.DecisionAnswer>>\n    readonly latencyMs: number\n  } | undefined\n}\n\n/**\n * Whether one reading asks anything of the completion at all.\n *\n * Any of the three heights is enough, and none is a vote: the questions are\n * asked separately because they fail separately, so a claim that reads as done\n * and overclaims is handed back on the second, and a claim that reads as\n * undone and modest on the first. Everything below all three is no demand at\n * all.\n *\n * This is the *bounce*, which is what it has always been, and it is not the\n * verdict. See {@link unrecorded}.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const find = (reading: Probabilities): Probabilities | undefined =>\n  reading.complete <= disprovenAt || reading.overclaims >= overclaimedAt || reading.invented >= unsupportedAt\n    ? { complete: reading.complete, overclaims: reading.overclaims, invented: reading.invented }\n    : undefined\n\n/**\n * Whether a reading is the one this brake ends a run over.\n *\n * Total, and the whole difference between a bounce and a verdict: every claim\n * {@link find} hands back is handed back once and then stands, except one at\n * or above {@link inventedAt}, which with no bounce left does not stand. It is\n * also what decides whether a bounced answer is worth keeping against an\n * exhausted budget; see `Frame.CompletionDemand.keeps`.\n *\n * @category predicates\n * @since 1.0.0-rc.0\n */\nexport const unrecorded = (reading: Probabilities): boolean => reading.invented >= inventedAt\n\n/**\n * The newest {@link outputBytes} of a check's result, stating what it dropped.\n *\n * The count and the notice are there for the reason `internal/elide` exists:\n * a reader that cannot tell a clipped value from a whole one reads the clip\n * as the whole.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const newest = (text: string): string => {\n  const whole = bytes.size(text)\n  if (whole <= outputBytes) return text\n  const kept = elide.tailSlice(text, outputBytes)\n  return `[… ${whole - bytes.size(kept)} of ${whole} bytes elided; these are the newest bytes]\\n${kept}`\n}\n\n/**\n * Why one completion went unjudged.\n *\n * `unconfigured` is the host that delivered no `Evaluator` at all; every\n * other member is {@link Evaluator.EvaluatorErrorCode} verbatim, so the\n * journal carries the transport's own word for what went wrong rather than a\n * harness paraphrase of it.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type UnjudgedReason = Exclude<Judgement.Unjudged[\"reason\"], \"interrupted\">\n\n/** Where a refusal's message begins quoting the completion it refused: see {@link refusedIn}. */\nconst refusedMarker = \"\\n\\nThe completion this refused, word for word:\\n\\n\"\n\n/**\n * The failure an unjudged completion ends the turn with.\n *\n * One code, `completion_unjudged`, and a message that opens with the reason\n * so a journal line, a `Transcript` projection and a test all read the same\n * word. The message then quotes the completion through {@link refused}, as\n * {@link unproven} does: a judge outage fails closed, and the person whose\n * run did the work is still owed its answer. `cause` carries the transport's\n * code and status where there was one; `detail` is the transport's text only\n * where it is safe to show: see `Evaluator.publicMessage`.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const unjudged = (\n  reason: UnjudgedReason,\n  detail: string,\n  claim: string,\n  cause?: unknown\n): HarnessError =>\n  new HarnessError({\n    code: \"completion_unjudged\",\n    message: `A completion no evaluator could judge (${reason}): ${detail}${refusedMarker}${refused(claim)}`,\n    ...(cause === undefined ? {} : { cause })\n  })\n\n/**\n * The most of the refused completion the failure carries, in UTF-8 bytes.\n *\n * Two kibibytes, which is less than {@link proseBytes} because these bytes go\n * somewhere else: the failure message is what a host puts on the run's own\n * ending, and a serving host puts it on the assistant message a person\n * reads. A claim that is longer than this has its head kept, where\n * a completion states what it did, and the run record still holds all of it.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const refusedBytes = 2048\n\n/**\n * The refused completion as the failure quotes it, bounded by\n * {@link refusedBytes}.\n *\n * A refusal that did not quote the sentence it refused left the only copy of\n * a correct answer inside a `complete` transition in the run's journal: not in\n * the transcript, not in the app, and unreachable by the person whose answer\n * it was. The brake is right most of the time, which means it is wrong some of\n * the time, and a person who loses an answer to it is owed the words.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const refused = (claim: string): string =>\n  elide.head(claim.trim(), refusedBytes, \"the run record has the whole completion\")\n\n/**\n * The completion a refusal's message quotes, as {@link refused} bounded it;\n * `undefined` for a message that quotes none. A host that still owes the\n * person the answer reads it here rather than parsing the prose itself.\n *\n * @category conversions\n * @since 1.0.0-rc.1\n */\nexport const refusedIn = (message: string): string | undefined => {\n  const at = message.indexOf(refusedMarker)\n  return at < 0 ? undefined : message.slice(at + refusedMarker.length).trim()\n}\n\n/**\n * The failure an unrecorded claim ends the run with.\n *\n * One code, `claim_unproven`, raised where the brake read a claim reporting a\n * command or a result the run's own record does not record, and the run has no\n * bounce left to spend: the cap is used up, or there is no frame to hand the\n * completion back to. It carries all three probabilities so the line a person\n * reads says how sure the transport was about the question that decided, and\n * what the other two — which decide nothing; see the module header — said\n * beside it. `bounced` says whether the run was given a frame to prove the\n * claim in. A wave is graded from these failures the way it is graded from the\n * {@link Reading}s.\n *\n * Failing rather than standing is the whole point, and it has a price: a\n * completion the transport is confidently wrong about twice costs the run its\n * answer, where under the first shape of this brake it cost one frame. That\n * price is why the verdict now rides on {@link inventedAt} and on that question\n * alone, why the run is always given one frame to answer in first when a frame\n * exists, and why the demand text says what a re-statement costs. The\n * alternative is the one outcome this package may not produce: a sentence\n * nothing supports, returned as the run's final answer, with a green finish on\n * it.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const unproven = (found: Probabilities, bounced: boolean, claim: string): HarnessError =>\n  new HarnessError({\n    code: \"claim_unproven\",\n    message: `A completion reporting work this run never recorded: invented ${found.invented.toFixed(2)} (complete ${\n      found.complete.toFixed(2)\n    }, overclaims ${found.overclaims.toFixed(2)}, neither of which decides this). ${\n      bounced\n        ? \"The claim was handed back for a frame and came back still unrecorded.\"\n        : \"There was no frame left to hand it back to.\"\n    }${refusedMarker}${refused(claim)}`\n  })\n\n/**\n * Asks Jev about one completion, and fails the turn when it cannot.\n *\n * `undefined` means one thing only: there was no claim and no task to judge,\n * which is not a transport failure and not a completion anybody could form a\n * question about. Everything else that stops the brake reaching an answer\n * fails, because a brake that goes quiet when its model is down is a brake\n * that is only there when it is not needed. See the module header.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const read = (\n  evidence: Evidence\n): Effect.Effect<Reading | undefined, HarnessError, Evaluator.Evaluator> =>\n  Effect.gen(function*() {\n    if (evidence.task.trim() === \"\" || evidence.claim.trim() === \"\") return undefined\n    // The service is required above, so a `None` here is a host that\n    // satisfied the type and delivered nothing — the defence that outlives\n    // the compiler, and the one that says `unconfigured`.\n    const bound = yield* Effect.serviceOption(Evaluator.Evaluator)\n    if (Option.isNone(bound)) {\n      return yield* Effect.fail(unjudged(\"unconfigured\", Judgement.unconfigured.detail, evidence.claim))\n    }\n    // `ClassifierError.code` is `EvaluatorErrorCode` verbatim, so the reason\n    // a journal reads is the transport's own. An unreachable transport's own\n    // message can name hosts and URLs, so the message is the public one and\n    // the cause keeps only the structured facts.\n    // The cause also carries what the failed reading paid, with what an\n    // earlier reading of the same claim paid, so the run's budget charges it\n    // (#3010).\n    const failed = (earlier: Evaluator.Usage | undefined) => (error: Classifier.ClassifierError) =>\n      unjudged(error.code, Evaluator.publicMessage(error), evidence.claim, failedReading(error, earlier))\n    const { answers, asked } = yield* Judgement.measured(classifier, evidence).pipe(\n      Effect.provideService(Evaluator.Evaluator, bound.value),\n      Effect.mapError(failed(undefined))\n    )\n    const whole = {\n      complete: answers.complete.probability,\n      overclaims: answers.overclaims.probability,\n      invented: answers.invented.probability,\n      latencyMs: asked.latencyMs,\n      ...(asked.usage === undefined ? {} : { usage: asked.usage }),\n      asked: { state: asked.state, answers: asked.answers }\n    }\n    // A claim the whole question already reads as recorded, or one sentence\n    // long, has nothing a sentence reading could find. Otherwise the claim's\n    // `invented` is its most invented sentence; see `sentenceClassifier`.\n    const parts = sentences(evidence.claim)\n    if (whole.invented < unsupportedAt || parts.length < 2) return whole\n    const bySentence = sentenceClassifier(parts)\n    const read = yield* Judgement.measured(bySentence, evidence).pipe(\n      Effect.provideService(Evaluator.Evaluator, bound.value),\n      Effect.mapError(failed(whole.usage))\n    )\n    const scores = Object.values(read.answers).map((answer) => (answer as { readonly probability: number }).probability)\n    const usage = paidTogether(whole.usage, read.asked.usage)\n    return {\n      ...whole,\n      invented: Math.max(...scores),\n      latencyMs: whole.latencyMs + read.asked.latencyMs,\n      ...(usage === undefined ? {} : { usage }),\n      sentences: {\n        whole: whole.invented,\n        classifier: bySentence.id,\n        digest: bySentence.digest,\n        questions: bySentence.questions,\n        state: read.asked.state,\n        answers: read.asked.answers,\n        latencyMs: read.asked.latencyMs\n      }\n    }\n  })\n\n/**\n * States what the record does not record, and names the two ways out.\n *\n * It takes no argument because one question issues it: the text a journal\n * replay rebuilds is therefore a function of the event's existence alone,\n * which is what it was before the reading had a shape to branch on.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const demand = (): string => DemandText.claim()\n\n/**\n * The canonical JSON of a value, which is how this brake quotes an input or a\n * result to the model it asks.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const quote = (value: Schema.Json): string => CanonicalJson.stringify(value)\n\n/**\n * The head of a prose field, bounded by {@link proseBytes}.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const prose = (text: string): string => elide.head(text.trim(), proseBytes, \"the run record has the whole text\")\n"]}

package/dist/esm/ContextWindow.d.ts

@@ -0,0 +1,435 @@
+/**
+ * The immutable, provider-neutral context assembled for one model request.
+ * Every value it exposes is frozen — the arrays, the segments, and the
+ * messages, parts and tool declarations they hold — so a runtime mutation
+ * throws in strict mode instead of silently invalidating the cached digest.
+ *
+ * Governing design: `../docs/concepts.md#context-window`.
+ *
+ * @since 0.1.0
+ */
+import * as ModelRequest from "@smthrs/model/ModelRequest";
+import { type Pipeable } from "effect/Pipeable";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as Tokens from "./Tokens.ts";
+/**
+ * The brand a {@link ContextWindow} carries so a structurally similar
+ * object cannot pass for one.
+ *
+ * @category type ids
+ * @since 0.1.0
+ * @slop
+ */
+export declare const TypeId: "~flows/harness/ContextWindow";
+/**
+ * The type of {@link TypeId}.
+ *
+ * @category type ids
+ * @since 0.1.0
+ * @slop
+ */
+export type TypeId = typeof TypeId;
+/**
+ * What a segment holds. The kind fixes where the segment may sit and
+ * whether compaction is allowed to replace it.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare const SegmentKind: Schema.Literals<readonly ["system", "instructions", "registry", "tools", "transcript", "summary", "steering"]>;
+/**
+ * The decoded form of {@link SegmentKind}.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type SegmentKind = typeof SegmentKind.Type;
+/**
+ * Where a segment sits relative to the cache breakpoint. `prefix` segments
+ * are stable across turns; `tail` segments change every turn.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare const SegmentZone: Schema.Literals<readonly ["prefix", "tail"]>;
+/**
+ * The decoded form of {@link SegmentZone}.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type SegmentZone = typeof SegmentZone.Type;
+/**
+ * The parts a segment may hold: system text, transcript messages, and tool
+ * declarations, in the provider-neutral vocabulary of `@smthrs/model`.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare const Content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+}> & {
+    make: (input: {
+        readonly text: string;
+    }) => ModelRequest.SystemPart;
+}, Schema.Union<readonly [typeof ModelRequest.UserMessage, typeof ModelRequest.AssistantMessage, typeof ModelRequest.ToolMessage]> & {
+    readonly discriminants: readonly ["user", "assistant", "tool"];
+    readonly cases: {
+        user: typeof ModelRequest.UserMessage;
+        assistant: typeof ModelRequest.AssistantMessage;
+        tool: typeof ModelRequest.ToolMessage;
+    };
+    readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => value is Extract<ModelRequest.UserMessage, {
+        readonly role: Keys;
+    }> | Extract<ModelRequest.AssistantMessage, {
+        readonly role: Keys;
+    }> | Extract<ModelRequest.ToolMessage, {
+        readonly role: Keys;
+    }>;
+    readonly guards: {
+        user: (u: unknown) => u is ModelRequest.UserMessage;
+        assistant: (u: unknown) => u is ModelRequest.AssistantMessage;
+        tool: (u: unknown) => u is ModelRequest.ToolMessage;
+    };
+    readonly match: {
+        <Cases extends {
+            user: (value: ModelRequest.UserMessage) => any;
+            assistant: (value: ModelRequest.AssistantMessage) => any;
+            tool: (value: ModelRequest.ToolMessage) => any;
+        }>(value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+        <Cases extends {
+            user: (value: ModelRequest.UserMessage) => any;
+            assistant: (value: ModelRequest.AssistantMessage) => any;
+            tool: (value: ModelRequest.ToolMessage) => any;
+        }>(cases: Cases): (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+    };
+    readonly matchOrElse: {
+        <Cases extends {
+            user?: (value: ModelRequest.UserMessage) => any;
+            assistant?: (value: ModelRequest.AssistantMessage) => any;
+            tool?: (value: ModelRequest.ToolMessage) => any;
+        } & { [K in Exclude<keyof Cases, "user" | "assistant" | "tool">]: never; }, OrElse extends (value: Exclude<ModelRequest.UserMessage, {
+            readonly role: keyof Cases;
+        }> | Exclude<ModelRequest.AssistantMessage, {
+            readonly role: keyof Cases;
+        }> | Exclude<ModelRequest.ToolMessage, {
+            readonly role: keyof Cases;
+        }>) => any>(value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage, cases: Cases, orElse: OrElse): import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
+        <Cases extends {
+            user?: (value: ModelRequest.UserMessage) => any;
+            assistant?: (value: ModelRequest.AssistantMessage) => any;
+            tool?: (value: ModelRequest.ToolMessage) => any;
+        } & { [K in Exclude<keyof Cases, "user" | "assistant" | "tool">]: never; }, OrElse extends (value: Exclude<ModelRequest.UserMessage, {
+            readonly role: keyof Cases;
+        }> | Exclude<ModelRequest.AssistantMessage, {
+            readonly role: keyof Cases;
+        }> | Exclude<ModelRequest.ToolMessage, {
+            readonly role: keyof Cases;
+        }>) => any>(cases: Cases, orElse: OrElse): (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
+    };
+} & {
+    make: (message: ModelRequest.Message) => ModelRequest.Message;
+    user: (content: string | ModelRequest.TextPart | ReadonlyArray<ModelRequest.TextPart>) => ModelRequest.UserMessage;
+    assistant: (content: string | ModelRequest.AssistantContentPart | ReadonlyArray<ModelRequest.AssistantContentPart>, options?: {
+        readonly stopReason?: ModelRequest.StopReason | undefined;
+        readonly responseId?: string | undefined;
+        readonly itemIds?: ReadonlyArray<string> | undefined;
+    }) => ModelRequest.AssistantMessage;
+    tool: (content: ModelRequest.ToolResultPart | ReadonlyArray<ModelRequest.ToolResultPart>) => ModelRequest.ToolMessage;
+}, typeof ModelRequest.ToolDefinition]>>;
+/**
+ * The decoded form of {@link Content}.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type Content = typeof Content.Type;
+/**
+ * What a compaction does with one prefix segment: `keep` it as it is,
+ * `squash` it into the summary, or `remove` it outright.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export declare const Mark: Schema.Literals<readonly ["keep", "squash", "remove"]>;
+/**
+ * The decoded form of {@link Mark}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Mark = typeof Mark.Type;
+/**
+ * The failure vocabulary of a context window operation.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare const ContextWindowErrorCode: Schema.Literals<readonly ["invalid_compaction_prefix", "invalid_compaction_marks"]>;
+/**
+ * The decoded form of {@link ContextWindowErrorCode}.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type ContextWindowErrorCode = typeof ContextWindowErrorCode.Type;
+declare const ContextWindowError_base: Schema.Class<ContextWindowError, Schema.TaggedStruct<"flows/harness/ContextWindowError", {
+    readonly code: Schema.Literals<readonly ["invalid_compaction_prefix", "invalid_compaction_marks"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Stable failure returned for an invalid public compaction prefix.
+ * @category errors
+ * @since 0.1.0
+ * @slop
+ */
+export declare class ContextWindowError extends ContextWindowError_base {
+}
+declare const Segment_base: Schema.Class<Segment, Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["system", "instructions", "registry", "tools", "transcript", "summary", "steering"]>;
+    readonly zone: Schema.Literals<readonly ["prefix", "tail"]>;
+    readonly digest: Schema.String;
+    readonly tokens: typeof Tokens.Count;
+    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }> & {
+        make: (input: {
+            readonly text: string;
+        }) => ModelRequest.SystemPart;
+    }, Schema.Union<readonly [typeof ModelRequest.UserMessage, typeof ModelRequest.AssistantMessage, typeof ModelRequest.ToolMessage]> & {
+        readonly discriminants: readonly ["user", "assistant", "tool"];
+        readonly cases: {
+            user: typeof ModelRequest.UserMessage;
+            assistant: typeof ModelRequest.AssistantMessage;
+            tool: typeof ModelRequest.ToolMessage;
+        };
+        readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => value is Extract<ModelRequest.UserMessage, {
+            readonly role: Keys;
+        }> | Extract<ModelRequest.AssistantMessage, {
+            readonly role: Keys;
+        }> | Extract<ModelRequest.ToolMessage, {
+            readonly role: Keys;
+        }>;
+        readonly guards: {
+            user: (u: unknown) => u is ModelRequest.UserMessage;
+            assistant: (u: unknown) => u is ModelRequest.AssistantMessage;
+            tool: (u: unknown) => u is ModelRequest.ToolMessage;
+        };
+        readonly match: {
+            <Cases extends {
+                user: (value: ModelRequest.UserMessage) => any;
+                assistant: (value: ModelRequest.AssistantMessage) => any;
+                tool: (value: ModelRequest.ToolMessage) => any;
+            }>(value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+            <Cases extends {
+                user: (value: ModelRequest.UserMessage) => any;
+                assistant: (value: ModelRequest.AssistantMessage) => any;
+                tool: (value: ModelRequest.ToolMessage) => any;
+            }>(cases: Cases): (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+        };
+        readonly matchOrElse: {
+            <Cases extends {
+                user?: (value: ModelRequest.UserMessage) => any;
+                assistant?: (value: ModelRequest.AssistantMessage) => any;
+                tool?: (value: ModelRequest.ToolMessage) => any;
+            } & { [K in Exclude<keyof Cases, "user" | "assistant" | "tool">]: never; }, OrElse extends (value: Exclude<ModelRequest.UserMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.AssistantMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.ToolMessage, {
+                readonly role: keyof Cases;
+            }>) => any>(value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage, cases: Cases, orElse: OrElse): import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
+            <Cases extends {
+                user?: (value: ModelRequest.UserMessage) => any;
+                assistant?: (value: ModelRequest.AssistantMessage) => any;
+                tool?: (value: ModelRequest.ToolMessage) => any;
+            } & { [K in Exclude<keyof Cases, "user" | "assistant" | "tool">]: never; }, OrElse extends (value: Exclude<ModelRequest.UserMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.AssistantMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.ToolMessage, {
+                readonly role: keyof Cases;
+            }>) => any>(cases: Cases, orElse: OrElse): (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
+        };
+    } & {
+        make: (message: ModelRequest.Message) => ModelRequest.Message;
+        user: (content: string | ModelRequest.TextPart | ReadonlyArray<ModelRequest.TextPart>) => ModelRequest.UserMessage;
+        assistant: (content: string | ModelRequest.AssistantContentPart | ReadonlyArray<ModelRequest.AssistantContentPart>, options?: {
+            readonly stopReason?: ModelRequest.StopReason | undefined;
+            readonly responseId?: string | undefined;
+            readonly itemIds?: ReadonlyArray<string> | undefined;
+        }) => ModelRequest.AssistantMessage;
+        tool: (content: ModelRequest.ToolResultPart | ReadonlyArray<ModelRequest.ToolResultPart>) => ModelRequest.ToolMessage;
+    }, typeof ModelRequest.ToolDefinition]>>;
+}>, {}>;
+/** A stable, typed slice of the model-visible context.
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare class Segment extends Segment_base {
+}
+declare const ContextWindow_base: Schema.Class<ContextWindow, Schema.Struct<{
+    readonly modelId: Schema.String;
+    readonly segments: Schema.$Array<typeof Segment>;
+    readonly activeTools: Schema.$Array<Schema.String>;
+    readonly replaced: Schema.optional<Schema.String>;
+    readonly digest: Schema.String;
+    readonly tokens: typeof Tokens.Accounting;
+}>, {}>;
+/**
+ * One assembled, immutable model context: its ordered segments, the tools
+ * currently active, and the token accounting for both. Every combinator
+ * returns a new window rather than mutating this one.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare class ContextWindow extends ContextWindow_base implements Pipeable {
+    readonly [TypeId]: "~flows/harness/ContextWindow";
+    /** Threads this window through the data-last combinators of this module.
+     *
+     * `window.pipe(appendTurn(message), render)` is `render(appendTurn(window, message))`.
+     *
+     * @category combinators
+     * @since 0.1.0
+     */
+    pipe<A>(this: A): A;
+    pipe<A, B>(this: A, ab: (_: A) => B): B;
+    pipe<A, B, C>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
+    pipe<A, B, C, D>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
+    pipe<A, B, C, D, E>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
+    pipe<A, B, C, D, E, F>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
+    pipe<A, B, C, D, E, F, G>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
+    pipe<A, B, C, D, E, F, G, H>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
+    pipe<A, B, C, D, E, F, G, H, I>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
+    pipe<A, B, C, D, E, F, G, H, I, J>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
+    /** @category constructors @since 0.1.0 */
+    static make(input: MakeOptions): ContextWindow;
+    /** @category constructors @since 0.1.0 */
+    static empty(modelId: string): ContextWindow;
+    /** @category combinators @since 0.1.0 */
+    static appendTurn(self: ContextWindow, assistantMessage: ModelRequest.AssistantMessage): ContextWindow;
+    /** @category combinators @since 0.1.0 */
+    static compact(self: ContextWindow, summary: ModelRequest.Message | ReadonlyArray<ModelRequest.Message>): Result.Result<ContextWindow, ContextWindowError>;
+    /** @category conversions @since 0.1.0 */
+    static render(self: ContextWindow): ModelRequest.ModelRequest;
+}
+/**
+ * A segment before its digest and token count are computed. Supplying
+ * `declaredDigest` or `tokens` skips the corresponding computation.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface SegmentInput {
+    readonly kind: SegmentKind;
+    readonly zone: SegmentZone;
+    readonly content: Content;
+    readonly declaredDigest?: string | undefined;
+    readonly tokens?: Tokens.Count | undefined;
+}
+/**
+ * The declaration {@link ContextWindow.make} takes.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface MakeOptions {
+    readonly modelId: string;
+    readonly segments?: ReadonlyArray<Segment | SegmentInput> | undefined;
+    readonly activeTools?: ReadonlyArray<string> | undefined;
+    readonly replaced?: string | undefined;
+}
+/** Creates one segment, computing its identity and estimated token count.
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const makeSegment: (input: Segment | SegmentInput) => Segment;
+/** Constructs a window from already-derived values.
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const make: (options: MakeOptions) => ContextWindow;
+/** Constructs an empty context window for a model.
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const empty: (modelId: string) => ContextWindow;
+/** Appends one settled assistant message.
+ *
+ * @category combinators
+ * @since 0.1.0
+ * @slop
+ */
+export declare const appendTurn: {
+    (assistantMessage: ModelRequest.AssistantMessage): (self: ContextWindow) => ContextWindow;
+    (self: ContextWindow, assistantMessage: ModelRequest.AssistantMessage): ContextWindow;
+};
+/**
+ * Computes the declared identity of an exact compactable prefix.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export declare const prefixDigest: (self: ContextWindow, prefixLength: number) => Result.Result<string, ContextWindowError>;
+/**
+ * Compacts an exact compactable prefix by its marks, one per prefix segment.
+ *
+ * The result holds, in order: the segments before the prefix; one `summary`
+ * segment of `summary` when any segment is squashed; the kept segments, as
+ * the same objects, so their digests are stable; then the suffix. Removed
+ * segments are dropped. `summary` is required exactly when a segment is
+ * squashed.
+ *
+ * @category combinators
+ * @since 1.0.0-rc.0
+ */
+export declare const compactMarked: (self: ContextWindow, prefixLength: number, marks: ReadonlyArray<Mark>, summary: ModelRequest.Message | ReadonlyArray<ModelRequest.Message> | undefined) => Result.Result<ContextWindow, ContextWindowError>;
+/**
+ * Replaces an exact compactable prefix while retaining every suffix segment:
+ * {@link compactMarked} with every segment squashed.
+ *
+ * @category combinators
+ * @since 0.1.0
+ * @slop
+ */
+export declare const compactPrefix: (self: ContextWindow, prefixLength: number, summary: ModelRequest.Message | ReadonlyArray<ModelRequest.Message>) => Result.Result<ContextWindow, ContextWindowError>;
+/** Replaces the compactable transcript prefix with a summary segment.
+ *
+ * The most recent transcript segment remains the suffix, so a compacted
+ * projection renders summary first followed by the un-compacted tail.
+ *
+ * @category combinators
+ * @since 0.1.0
+ * @slop
+ */
+export declare const compact: {
+    (summary: ModelRequest.Message | ReadonlyArray<ModelRequest.Message>): (self: ContextWindow) => Result.Result<ContextWindow, ContextWindowError>;
+    (self: ContextWindow, summary: ModelRequest.Message | ReadonlyArray<ModelRequest.Message>): Result.Result<ContextWindow, ContextWindowError>;
+};
+/** Renders this provider-neutral value into a model request.
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export declare const render: (self: ContextWindow) => ModelRequest.ModelRequest;
+export {};
+//# sourceMappingURL=ContextWindow.d.ts.map

package/dist/esm/ContextWindow.d.ts.map

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