agentfootprint 12.2.0 → 13.0.0

package/dist/esm/core/agent/scripts/inert.js

@@ -0,0 +1,84 @@
+/**
+ * scripts/inert — a dynamic value (a tool's name, a provider's call id) written
+ * into a library line as an inline code span that cannot leave its line.
+ *
+ * Pattern: pure leaf.
+ * Role:    core/ layer leaf, asked by the attachment's lines (`attachment.ts`)
+ *          for every name and id they print.
+ * Emits:   N/A.
+ *
+ * THE RULE. A provider may hand the library any string as a call id: line
+ * breaks, a sentence, a fence. Interpolated as it is, a blank line in an id ends
+ * the library's label paragraph, and the rest of the id renders as a paragraph
+ * of its own — text nobody checked, under the answer, in the library's voice.
+ * So a value is written as inline code:
+ *
+ * - every character that can end a line, turn the line's direction or hide
+ *   (C0 and C1 controls, DEL, U+2028 and U+2029, format characters such as a
+ *   bidi override or a zero-width joiner, a lone surrogate) is written as
+ *   `\u{…}`, its code point in hex;
+ * - at most {@link MAX_INERT_POINTS} code points are written, then `…`;
+ * - the delimiter is one backtick longer than the longest run inside, with a
+ *   space at either end when the value begins or ends with a backtick or a
+ *   space (CommonMark's code-span rule), so nothing inside can close it.
+ *
+ * Inside a code span nothing is Markdown: no emphasis, no link, no HTML, no
+ * line ending. The value is shown, never interpreted.
+ *
+ * @example
+ * ```ts
+ * inertCode('c1');                         // '`c1`'
+ * inertCode('c1\n\nRevenue was 98765.');   // '`c1\u{a}\u{a}Revenue was 98765.`'
+ * inertCode('a`b');                        // '``a`b``'
+ * ```
+ */
+/** Code points of a value written; the rest is `…`. */
+export const MAX_INERT_POINTS = 64;
+const FORMAT = /\p{Cf}/u;
+/** Whether one code point must be written as `\u{…}`. */
+function escapes(point, char) {
+    if (point < 0x20 || point === 0x7f || (point >= 0x80 && point <= 0x9f))
+        return true;
+    if (point === 0x2028 || point === 0x2029)
+        return true;
+    if (point >= 0xd800 && point <= 0xdfff)
+        return true;
+    return FORMAT.test(char);
+}
+/** The longest run of backticks in `text`. */
+function longestBacktickRun(text) {
+    let longest = 0;
+    let run = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text.charCodeAt(i) === 0x60) {
+            run += 1;
+            if (run > longest)
+                longest = run;
+        }
+        else {
+            run = 0;
+        }
+    }
+    return longest;
+}
+/** `value` as an inline code span that stays on its line. */
+export function inertCode(value) {
+    let shown = '';
+    let points = 0;
+    for (const char of value) {
+        if (points === MAX_INERT_POINTS) {
+            shown += '…';
+            break;
+        }
+        points += 1;
+        const point = char.codePointAt(0);
+        shown += escapes(point, char) ? `\\u{${point.toString(16)}}` : char;
+    }
+    if (shown.length === 0)
+        return '`(empty)`';
+    const fence = '`'.repeat(longestBacktickRun(shown) + 1);
+    const edge = (c) => c === '`' || c === ' ';
+    const pad = edge(shown[0]) || edge(shown[shown.length - 1]) ? ' ' : '';
+    return `${fence}${pad}${shown}${pad}${fence}`;
+}
+//# sourceMappingURL=inert.js.map

package/dist/esm/core/agent/scripts/inert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inert.js","sourceRoot":"","sources":["../../../../../src/core/agent/scripts/inert.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,uDAAuD;AACvD,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAEnC,MAAM,MAAM,GAAG,SAAS,CAAC;AAEzB,yDAAyD;AACzD,SAAS,OAAO,CAAC,KAAa,EAAE,IAAY;IAC1C,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACpF,IAAI,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,MAAM;QAAE,OAAO,IAAI,CAAC;IACtD,IAAI,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,MAAM;QAAE,OAAO,IAAI,CAAC;IACpD,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC3B,CAAC;AAED,8CAA8C;AAC9C,SAAS,kBAAkB,CAAC,IAAY;IACtC,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YAChC,GAAG,IAAI,CAAC,CAAC;YACT,IAAI,GAAG,GAAG,OAAO;gBAAE,OAAO,GAAG,GAAG,CAAC;QACnC,CAAC;aAAM,CAAC;YACN,GAAG,GAAG,CAAC,CAAC;QACV,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,6DAA6D;AAC7D,MAAM,UAAU,SAAS,CAAC,KAAa;IACrC,IAAI,KAAK,GAAG,EAAE,CAAC;IACf,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,MAAM,KAAK,gBAAgB,EAAE,CAAC;YAChC,KAAK,IAAI,GAAG,CAAC;YACb,MAAM;QACR,CAAC;QACD,MAAM,IAAI,CAAC,CAAC;QACZ,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAW,CAAC;QAC5C,KAAK,IAAI,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;IACtE,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,WAAW,CAAC;IAC3C,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,kBAAkB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;IACxD,MAAM,IAAI,GAAG,CAAC,CAAqB,EAAW,EAAE,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC;IACxE,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IACvE,OAAO,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,EAAE,CAAC;AAChD,CAAC"}

package/dist/esm/core/agent/scripts/judge.d.ts

@@ -0,0 +1,36 @@
+/**
+ * scripts/judge — the evidence gate's ONE judge, with the script match in
+ * front of it.
+ *
+ * Pattern: Decorator over the judge closure `stages/route.ts` ·
+ *          `judgeEvidence` builds (the gate bound to this run's evidence).
+ * Role:    core/ layer. Built only under `.namesAndNumbersFromEvidence({
+ *          code: 'match' })`, on a prose answer (a typed answer is read as
+ *          today — design § 12). The same decorated closure judges the draft
+ *          and, for `.answerValidation()`, the delivered candidate.
+ * Emits:   N/A — the Route decider emits `evidence_checked`, now carrying
+ *          `scripts` and each unsupported value's `region`.
+ *
+ * What it adds, and nothing else: the matched blocks are cut out of the text
+ * the gate reads (`match.ts`), the verdict carries `scripts`, and each
+ * unsupported value says where it sat — `'code'` when every occurrence of it
+ * is inside an unmatched block, `'prose'` otherwise. The corpus and the
+ * exempt corpus are untouched: a matched script grounds nothing.
+ */
+import type { EvidenceVerdict } from '../evidence/types.js';
+import type { TurnScripts } from './rows.js';
+/** The gate's judge with the script match in front of it. */
+export declare function scriptJudge(input: {
+    /** The gate's judge — `checkAnswer` bound to this run's evidence. */
+    readonly judgeProse: (text: string) => EvidenceVerdict;
+    /**
+     * The values the gate's extractor reads in a text, spelled as a verdict
+     * reports them (normalized, clipped) — asked of the answer with every block
+     * cut out, to place each unsupported value.
+     */
+    readonly valuesIn: (text: string) => ReadonlySet<string>;
+    /** This turn's script rows (`rows.ts` · `scriptRowsOfTurn`). */
+    readonly turn: TurnScripts;
+    /** `AgentState.scriptsDropped`, when calls past the per-turn cap were dropped. */
+    readonly scriptsDropped?: number;
+}): (text: string) => EvidenceVerdict;

package/dist/esm/core/agent/scripts/judge.js

@@ -0,0 +1,37 @@
+/**
+ * scripts/judge — the evidence gate's ONE judge, with the script match in
+ * front of it.
+ *
+ * Pattern: Decorator over the judge closure `stages/route.ts` ·
+ *          `judgeEvidence` builds (the gate bound to this run's evidence).
+ * Role:    core/ layer. Built only under `.namesAndNumbersFromEvidence({
+ *          code: 'match' })`, on a prose answer (a typed answer is read as
+ *          today — design § 12). The same decorated closure judges the draft
+ *          and, for `.answerValidation()`, the delivered candidate.
+ * Emits:   N/A — the Route decider emits `evidence_checked`, now carrying
+ *          `scripts` and each unsupported value's `region`.
+ *
+ * What it adds, and nothing else: the matched blocks are cut out of the text
+ * the gate reads (`match.ts`), the verdict carries `scripts`, and each
+ * unsupported value says where it sat — `'code'` when every occurrence of it
+ * is inside an unmatched block, `'prose'` otherwise. The corpus and the
+ * exempt corpus are untouched: a matched script grounds nothing.
+ */
+import { readShownScripts } from './match.js';
+/** The gate's judge with the script match in front of it. */
+export function scriptJudge(input) {
+    return (text) => {
+        const shown = readShownScripts(text, input.turn, input.scriptsDropped);
+        const verdict = input.judgeProse(shown.prose);
+        const inProse = verdict.unsupported.length > 0 ? input.valuesIn(shown.outsideCode) : new Set();
+        return {
+            ...verdict,
+            unsupported: verdict.unsupported.map((value) => ({
+                ...value,
+                region: inProse.has(value.value) ? 'prose' : 'code',
+            })),
+            scripts: shown.verdict,
+        };
+    };
+}
+//# sourceMappingURL=judge.js.map

package/dist/esm/core/agent/scripts/judge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"judge.js","sourceRoot":"","sources":["../../../../../src/core/agent/scripts/judge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG9C,6DAA6D;AAC7D,MAAM,UAAU,WAAW,CAAC,KAa3B;IACC,OAAO,CAAC,IAAI,EAAE,EAAE;QACd,MAAM,KAAK,GAAG,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;QACvE,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC9C,MAAM,OAAO,GACX,OAAO,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,EAAU,CAAC;QACzF,OAAO;YACL,GAAG,OAAO;YACV,WAAW,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;gBAC/C,GAAG,KAAK;gBACR,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE,OAAiB,CAAC,CAAC,CAAE,MAAgB;aAC1E,CAAC,CAAC;YACH,OAAO,EAAE,KAAK,CAAC,OAAO;SACvB,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}

package/dist/esm/core/agent/scripts/label.d.ts

@@ -0,0 +1,103 @@
+/**
+ * scripts/label — the ONE rule that turns a code call's record into a label,
+ * and the label's words.
+ *
+ * Pattern: pure function over two separate facts (design § 4.3).
+ * Role:    core/ layer leaf. Asked by the dispatch loop when it files a call's
+ *          `script` row (`rows.ts` · `scriptRowFor`); every sentence that names
+ *          an outcome — the attachment's label line, the recovery clause, the
+ *          answer account — reads the row's label through {@link labelWords}.
+ * Emits:   N/A.
+ *
+ * ## Three facts, read in one order
+ *
+ * The record holds three facts about a code call, written by three mechanisms:
+ * EXECUTION evidence (the runner's facts — `codeRunnerTool.ts` ·
+ * `CodeRunFacts`, taken right after `tool.execute` returns), call SETTLEMENT
+ * (did the call return, throw, or never enter `execute`) and result DELIVERY
+ * (the tool's ceiling replaced the payload). A label is read from execution
+ * evidence first, then settlement, and NEVER from delivery: a withheld result
+ * does not undo a completed execution (it rides the row as `resultWithheld`).
+ *
+ * | the record says | label |
+ * |---|---|
+ * | an explicit `exitCode: 0` | `completed` |
+ * | an explicit non-zero `exitCode` (a whole number — {@link isExitCode}) | `completed-with-failure` |
+ * | `serviceError` and no exit code | `outcome-unknown` |
+ * | `ok: true`, no exit code | `reported-success` |
+ * | `ok: false`, no exit code, no service error (a stopped process included) | `reported-failure` |
+ * | facts that report no outcome (`ok` absent, no exit code) | — no execution evidence: the settlement decides |
+ * | no facts, the call returned | `returned` |
+ * | no facts, the call threw (a timeout, a cancellation, a staging refusal) | `outcome-unknown` |
+ * | the call never entered `execute` (or has not settled) | `submitted` |
+ *
+ * Only an explicit exit code proves the program reached an exit. `ok` is a
+ * VERDICT: it never yields `completed`, and no word here prints an exit number
+ * the record does not hold.
+ *
+ * @example
+ * ```ts
+ * scriptLabelOf({ settlement: 'returned', facts: { exitCode: 0 } });          // { label: 'completed', exitCode: 0 }
+ * scriptLabelOf({ settlement: 'returned', facts: { ok: false, serviceError: true } }); // { label: 'outcome-unknown', serviceError: true }
+ * scriptLabelOf({ settlement: 'threw' });                                      // { label: 'outcome-unknown' }
+ * labelWords('completed-with-failure', 7);                                     // 'completed with failure, exit 7'
+ * ```
+ */
+import type { ScriptLabel } from './types.js';
+/** How a call settled, as the dispatch loop knows it. */
+export type CallSettlement = 
+/** Never entered `execute`: not dispatched, refused before it, or still open. */
+'not-entered'
+/** `execute` returned a result. */
+ | 'returned'
+/** `execute` was entered and threw (a timeout, a cancellation, any error). */
+ | 'threw';
+/** The runner facts a label reads — `CodeRunFacts`' outcome half. */
+export interface RunnerOutcome {
+    readonly ok?: boolean;
+    readonly exitCode?: number;
+    readonly serviceError?: true;
+    readonly terminatedBy?: string;
+}
+/** A label, with the facts it may print. */
+export interface ScriptOutcome {
+    readonly label: ScriptLabel;
+    /** Exactly the runner's, only when it supplied one. */
+    readonly exitCode?: number;
+    /** The failure verdict was the service's, with no exit code. */
+    readonly serviceError?: true;
+}
+/**
+ * Whether `value` is an exit code: a whole number, as a process reports one
+ * (a negative one included — a signal, on some runtimes). THE rule for every
+ * writer and reader of a script's exit code — the label below, and the
+ * readers of a saved record (`rows.ts` · `scriptRowIsWellFormed`,
+ * `attachment.ts` · `recordedScripts`, `match.ts` · `recordedBlocks`), so the
+ * writer never files a row the checkpoint door refuses. A runner that reports
+ * anything else (`1.5`, `NaN`) reported no exit code.
+ */
+export declare const isExitCode: (value: unknown) => value is number;
+/**
+ * Whether a recorded label and exit code agree, as {@link scriptLabelOf}
+ * writes them: an exit code rides exactly the two labels one proves — `0` on
+ * `completed`, any other on `completed-with-failure` — and no other label.
+ * A record where they disagree holds a value no writer of this library files.
+ */
+export declare function exitCodeFits(label: unknown, exitCode: unknown): boolean;
+/**
+ * The label of one call — execution evidence first, then settlement. `facts`
+ * is ABSENT when the tool filed none (a declared tool that is not
+ * `codeRunnerTool`, or a call that never reached its runner).
+ */
+export declare function scriptLabelOf(input: {
+    readonly settlement: CallSettlement;
+    readonly facts?: RunnerOutcome;
+}): ScriptOutcome;
+/**
+ * The label's own words — the one phrase every library sentence about a call's
+ * outcome uses (design § 4.3). `exitCode` is printed only for
+ * `completed-with-failure`, and only the number the record holds.
+ */
+export declare function labelWords(label: ScriptLabel, exitCode?: number): string;
+/** Every label, in the design's order — for a reader that validates one. */
+export declare const SCRIPT_LABELS: readonly ScriptLabel[];

package/dist/esm/core/agent/scripts/label.js

@@ -0,0 +1,136 @@
+/**
+ * scripts/label — the ONE rule that turns a code call's record into a label,
+ * and the label's words.
+ *
+ * Pattern: pure function over two separate facts (design § 4.3).
+ * Role:    core/ layer leaf. Asked by the dispatch loop when it files a call's
+ *          `script` row (`rows.ts` · `scriptRowFor`); every sentence that names
+ *          an outcome — the attachment's label line, the recovery clause, the
+ *          answer account — reads the row's label through {@link labelWords}.
+ * Emits:   N/A.
+ *
+ * ## Three facts, read in one order
+ *
+ * The record holds three facts about a code call, written by three mechanisms:
+ * EXECUTION evidence (the runner's facts — `codeRunnerTool.ts` ·
+ * `CodeRunFacts`, taken right after `tool.execute` returns), call SETTLEMENT
+ * (did the call return, throw, or never enter `execute`) and result DELIVERY
+ * (the tool's ceiling replaced the payload). A label is read from execution
+ * evidence first, then settlement, and NEVER from delivery: a withheld result
+ * does not undo a completed execution (it rides the row as `resultWithheld`).
+ *
+ * | the record says | label |
+ * |---|---|
+ * | an explicit `exitCode: 0` | `completed` |
+ * | an explicit non-zero `exitCode` (a whole number — {@link isExitCode}) | `completed-with-failure` |
+ * | `serviceError` and no exit code | `outcome-unknown` |
+ * | `ok: true`, no exit code | `reported-success` |
+ * | `ok: false`, no exit code, no service error (a stopped process included) | `reported-failure` |
+ * | facts that report no outcome (`ok` absent, no exit code) | — no execution evidence: the settlement decides |
+ * | no facts, the call returned | `returned` |
+ * | no facts, the call threw (a timeout, a cancellation, a staging refusal) | `outcome-unknown` |
+ * | the call never entered `execute` (or has not settled) | `submitted` |
+ *
+ * Only an explicit exit code proves the program reached an exit. `ok` is a
+ * VERDICT: it never yields `completed`, and no word here prints an exit number
+ * the record does not hold.
+ *
+ * @example
+ * ```ts
+ * scriptLabelOf({ settlement: 'returned', facts: { exitCode: 0 } });          // { label: 'completed', exitCode: 0 }
+ * scriptLabelOf({ settlement: 'returned', facts: { ok: false, serviceError: true } }); // { label: 'outcome-unknown', serviceError: true }
+ * scriptLabelOf({ settlement: 'threw' });                                      // { label: 'outcome-unknown' }
+ * labelWords('completed-with-failure', 7);                                     // 'completed with failure, exit 7'
+ * ```
+ */
+/**
+ * Whether `value` is an exit code: a whole number, as a process reports one
+ * (a negative one included — a signal, on some runtimes). THE rule for every
+ * writer and reader of a script's exit code — the label below, and the
+ * readers of a saved record (`rows.ts` · `scriptRowIsWellFormed`,
+ * `attachment.ts` · `recordedScripts`, `match.ts` · `recordedBlocks`), so the
+ * writer never files a row the checkpoint door refuses. A runner that reports
+ * anything else (`1.5`, `NaN`) reported no exit code.
+ */
+export const isExitCode = (value) => Number.isInteger(value);
+/**
+ * Whether a recorded label and exit code agree, as {@link scriptLabelOf}
+ * writes them: an exit code rides exactly the two labels one proves — `0` on
+ * `completed`, any other on `completed-with-failure` — and no other label.
+ * A record where they disagree holds a value no writer of this library files.
+ */
+export function exitCodeFits(label, exitCode) {
+    if (label === 'completed')
+        return exitCode === 0;
+    if (label === 'completed-with-failure')
+        return isExitCode(exitCode) && exitCode !== 0;
+    return exitCode === undefined;
+}
+/**
+ * The label of one call — execution evidence first, then settlement. `facts`
+ * is ABSENT when the tool filed none (a declared tool that is not
+ * `codeRunnerTool`, or a call that never reached its runner).
+ */
+export function scriptLabelOf(input) {
+    const facts = input.facts;
+    if (facts !== undefined) {
+        if (isExitCode(facts.exitCode)) {
+            return {
+                label: facts.exitCode === 0 ? 'completed' : 'completed-with-failure',
+                exitCode: facts.exitCode,
+            };
+        }
+        if (facts.serviceError === true)
+            return { label: 'outcome-unknown', serviceError: true };
+        if (facts.ok === true)
+            return { label: 'reported-success' };
+        if (facts.ok === false)
+            return { label: 'reported-failure' };
+        // Facts with no outcome in them — the runner reported neither an exit code
+        // nor a verdict — are no execution evidence: the settlement decides below.
+    }
+    switch (input.settlement) {
+        case 'not-entered':
+            return { label: 'submitted' };
+        case 'returned':
+            return { label: 'returned' };
+        case 'threw':
+            return { label: 'outcome-unknown' };
+    }
+}
+/**
+ * The label's own words — the one phrase every library sentence about a call's
+ * outcome uses (design § 4.3). `exitCode` is printed only for
+ * `completed-with-failure`, and only the number the record holds.
+ */
+export function labelWords(label, exitCode) {
+    switch (label) {
+        case 'submitted':
+            return 'submitted';
+        case 'returned':
+            return 'tool call returned; execution not confirmed';
+        case 'reported-success':
+            return 'runner reported success; no exit code';
+        case 'reported-failure':
+            return 'runner reported failure; no exit code';
+        case 'completed':
+            return 'completed, exit 0';
+        case 'completed-with-failure':
+            return exitCode === undefined
+                ? 'completed with failure'
+                : `completed with failure, exit ${exitCode}`;
+        case 'outcome-unknown':
+            return 'outcome unknown';
+    }
+}
+/** Every label, in the design's order — for a reader that validates one. */
+export const SCRIPT_LABELS = Object.freeze([
+    'submitted',
+    'returned',
+    'reported-success',
+    'reported-failure',
+    'completed',
+    'completed-with-failure',
+    'outcome-unknown',
+]);
+//# sourceMappingURL=label.js.map

package/dist/esm/core/agent/scripts/label.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"label.js","sourceRoot":"","sources":["../../../../../src/core/agent/scripts/label.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AA8BH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAc,EAAmB,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AAEvF;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc,EAAE,QAAiB;IAC5D,IAAI,KAAK,KAAK,WAAW;QAAE,OAAO,QAAQ,KAAK,CAAC,CAAC;IACjD,IAAI,KAAK,KAAK,wBAAwB;QAAE,OAAO,UAAU,CAAC,QAAQ,CAAC,IAAI,QAAQ,KAAK,CAAC,CAAC;IACtF,OAAO,QAAQ,KAAK,SAAS,CAAC;AAChC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,KAG7B;IACC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAC1B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,IAAI,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC/B,OAAO;gBACL,KAAK,EAAE,KAAK,CAAC,QAAQ,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,wBAAwB;gBACpE,QAAQ,EAAE,KAAK,CAAC,QAAQ;aACzB,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,KAAK,IAAI;YAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;QACzF,IAAI,KAAK,CAAC,EAAE,KAAK,IAAI;YAAE,OAAO,EAAE,KAAK,EAAE,kBAAkB,EAAE,CAAC;QAC5D,IAAI,KAAK,CAAC,EAAE,KAAK,KAAK;YAAE,OAAO,EAAE,KAAK,EAAE,kBAAkB,EAAE,CAAC;QAC7D,2EAA2E;QAC3E,2EAA2E;IAC7E,CAAC;IACD,QAAQ,KAAK,CAAC,UAAU,EAAE,CAAC;QACzB,KAAK,aAAa;YAChB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;QAChC,KAAK,UAAU;YACb,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;QAC/B,KAAK,OAAO;YACV,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC;IACxC,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,KAAkB,EAAE,QAAiB;IAC9D,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,WAAW;YACd,OAAO,WAAW,CAAC;QACrB,KAAK,UAAU;YACb,OAAO,6CAA6C,CAAC;QACvD,KAAK,kBAAkB;YACrB,OAAO,uCAAuC,CAAC;QACjD,KAAK,kBAAkB;YACrB,OAAO,uCAAuC,CAAC;QACjD,KAAK,WAAW;YACd,OAAO,mBAAmB,CAAC;QAC7B,KAAK,wBAAwB;YAC3B,OAAO,QAAQ,KAAK,SAAS;gBAC3B,CAAC,CAAC,wBAAwB;gBAC1B,CAAC,CAAC,gCAAgC,QAAQ,EAAE,CAAC;QACjD,KAAK,iBAAiB;YACpB,OAAO,iBAAiB,CAAC;IAC7B,CAAC;AACH,CAAC;AAED,4EAA4E;AAC5E,MAAM,CAAC,MAAM,aAAa,GAA2B,MAAM,CAAC,MAAM,CAAC;IACjE,WAAW;IACX,UAAU;IACV,kBAAkB;IAClB,kBAAkB;IAClB,WAAW;IACX,wBAAwB;IACxB,iBAAiB;CAClB,CAAC,CAAC"}

package/dist/esm/core/agent/scripts/match.d.ts

@@ -0,0 +1,99 @@
+/**
+ * scripts/match — is a fenced block the program ONE call of this turn
+ * submitted? Identity against the record, never evidence for a value.
+ *
+ * Pattern: pure function over the answer and this turn's rows.
+ * Role:    core/ layer. Asked inside the ONE judge closure the Route decider
+ *          builds (`stages/route.ts` · `judgeEvidence`, through `judge.ts`),
+ *          before the names-and-numbers extractor reads the text — so the
+ *          draft and the delivered candidate are read alike. Only under
+ *          `.namesAndNumbersFromEvidence({ code: 'match' })`.
+ * Emits:   N/A.
+ *
+ * ## The match rule: exact, after removing only the wrapper (design § 5.2)
+ *
+ * A block matches a call only when its content (`../evidence/codeRegions.ts`)
+ * equals the program the call SUBMITTED to the tool, byte for byte. Nothing is
+ * transformed: no trailing-space strip, no line-ending rewrite, no Unicode
+ * normalization, no shape, no edit distance — each can change a literal and so
+ * the program (`print(len("""A  \nB"""))` prints 5, its copy without the two
+ * spaces 3; `"é"` written with a combining mark is one more character than its
+ * NFC form). The strings are compared as they hold the text (UTF-16 code
+ * units): for well-formed text that is UTF-8 byte equality, and for a lone
+ * surrogate it is stricter, the safe direction.
+ *
+ * - Against the rows of the CURRENT TURN only; earlier turns are counted
+ *   (`earlierTurnRows`), never compared, and a miss says "no submission of
+ *   this turn", never "no submission".
+ * - A block over `MAX_SCRIPT_BYTES` is `over-size`: no row keeps a program
+ *   that long, so it is never compared.
+ * - Two calls that submitted byte-identical programs: the block names the
+ *   LATEST, counts the rest (`alsoMatches`) and carries its label.
+ * - No nearest submission is ever named: a near match is a different program.
+ *
+ * WHAT A MATCH YIELDS. The block is script content: it is cut out of the text
+ * the extractor reads, so it yields no value candidates — and it grounds
+ * nothing: the evidence corpus is untouched, so a value in the prose that also
+ * sits in the script still needs a result. A MISS stays in the text and is
+ * checked as prose, exactly as today.
+ *
+ * COST. One linear scan of the answer (`codeRegionsOf`); each of at most
+ * `MAX_CODE_REGIONS` blocks is looked up once among at most `MAX_SCRIPT_ROWS`
+ * programs of at most `MAX_SCRIPT_BYTES` — within the 512 comparisons per
+ * judged answer of design § 4.4. Earlier turns add nothing.
+ */
+import { type TurnScripts } from './rows.js';
+import type { ScriptBlockVerdict, ScriptsVerdict, UnmatchedReason } from './types.js';
+/** One answer, read for its scripts. */
+export interface ShownScripts {
+    /** The answer with every MATCHED block cut out — what the extractor reads. */
+    readonly prose: string;
+    /** The answer with EVERY block cut out — "the prose", for `unsupported[].region`. */
+    readonly outsideCode: string;
+    readonly verdict: ScriptsVerdict;
+}
+/**
+ * Read `answer`'s fenced blocks against this turn's submissions. Pure; the
+ * rows are `rows.ts` · `scriptRowsOfTurn`'s reading (last row per call).
+ */
+export declare function readShownScripts(answer: string, turn: TurnScripts, scriptsDropped?: number): ShownScripts;
+/**
+ * A verdict as detached plain data — field by field, never a reference into
+ * state (a value read back through a TypedScope is a live view, and an event
+ * payload must be plain data).
+ */
+export declare function copyScriptsVerdict(verdict: ScriptsVerdict): ScriptsVerdict;
+/** Every reason a block can be unmatched for. */
+export declare const UNMATCHED_REASONS: readonly UnmatchedReason[];
+/**
+ * One block verdict's fields, checked as {@link readShownScripts} writes them
+ * — a fresh copy, or `undefined` when any field is one no writer of this
+ * library files: a position or a dispatch that is not a whole number from 1,
+ * a label outside the vocabulary, an exit code its label does not carry
+ * (`label.ts` · `exitCodeFits`), an unmatched block that names a call, a
+ * matched one without its call. Fields beside these (a witness row's `kind`,
+ * `turn`, `iteration`) are not read.
+ */
+export declare function blockVerdictOf(value: unknown): ScriptBlockVerdict | undefined;
+/** One block verdict read back, at its position in the record's `blocks`. */
+export interface RecordedBlock {
+    readonly index: number;
+    readonly verdict: ScriptBlockVerdict;
+}
+/** A saved `evidence_checked.scripts`, read back. */
+export interface RecordedBlocks {
+    /** The verdicts a writer of this library files, at their record position. */
+    readonly blocks: readonly RecordedBlock[];
+    /**
+     * What no writer files, counted once each: a verdict that does not read
+     * back, every verdict past `MAX_CODE_REGIONS` (the writer reads no more
+     * blocks), or a `scripts` value that is not `{ blocks: [...] }`.
+     */
+    readonly unread: number;
+}
+/**
+ * A saved `evidence_checked.scripts` — THE reader of the shape for a reader
+ * of a record. `undefined` when the event carries no scripts arm. Bounded by
+ * the writer's cap: no reader iterates more verdicts than a writer files.
+ */
+export declare function recordedBlocks(value: unknown): RecordedBlocks | undefined;