agentfootprint 13.0.0 → 14.0.0

package/dist/esm/core/agent/stages/toolCalls/evidence/coverageOperations.js

@@ -0,0 +1,232 @@
+import { readCoverageResult, } from '../../../../../semantics/coverage/index.js';
+import { copyPeriod } from '../../../../../semantics/coverage/period.js';
+import { warnPeriodUnjudged } from '../helpers/periodWarnings.js';
+import { readItemExtras } from '../../../../../semantics/coverage/items.js';
+import { copyInProgressItem } from '../../../../../semantics/coverage/inProgress.js';
+import { typedEmit } from '../../../../../recorders/core/typedEmit.js';
+import { composedEventFields } from '../../../../../semantics/coverage/search/events.js';
+import { captureNegativeCoverage } from '../../../negativeClaims/capture.js';
+/** Compose the existing coverage callbacks once for this handler. */
+export function buildToolCoverageOperations(deps, links) {
+    /**
+     * Coverage declarations — `absent(…)` and `coverage(…)`, recognized at the
+     * SAME execute boundaries the ceiling is measured at (one implementation,
+     * every door: a resumed call declares its coverage exactly as an inline
+     * one).
+     *
+     * Returns the DELIVERED status: `'absent'` when an absence is in play,
+     * `undefined` otherwise. That single line is the whole downstream
+     * behavioural change, and it is deliberately narrow — an absence is not an
+     * error, so nothing here sets `error: true`, nothing refuses, nothing
+     * retries, and the value the model reads is the value the tool minted. The
+     * direction-of-error argument (see `../../../../../semantics/coverage/absent.ts`) is that a
+     * *nothing-found* routed as a *failure* sends someone to investigate a
+     * healthy collector, while a *failure* routed as *nothing-found* declares a
+     * system fine that was never checked; giving the outcome its own word is
+     * how `onToolStatus` edges stop having to guess.
+     *
+     * The RECORD keeps the coverage twice over: on the emit channel (per-call
+     * facts belong there) and, because a limit is a fact about the ANSWER
+     * rather than about an attempt, in tracked state — where the final-answer
+     * block reads it. Written only when a tool declares one, so an agent that
+     * returns neither shape commits exactly what it always did.
+     */
+    const declareCoverage = (scope, call, value, 
+    /** What the search funnel composed (`../../searchCoverage.ts`) — read in place of the value. */
+    composed) => {
+        const reading = composed ?? readCoverageResult(value, call.toolName);
+        if (reading === undefined)
+            return undefined;
+        const rows = [];
+        for (const facts of reading.declared) {
+            // A statement the LIBRARY composed from the tool's `search`: the row
+            // carries the typed items and gaps, the events carry no composed value.
+            if (facts.composed !== undefined) {
+                rows.push(declareComposed(scope, call, facts));
+                continue;
+            }
+            // Honesty step 7b: a declared period rides the event and the tracked row
+            // (read by the ONE period rule — a malformed one never reaches here), as
+            // a copy. Filed whatever the agent armed: it is the tool's declaration.
+            // Its VERDICT is the results layer's — say so when that layer is not
+            // mounted, so a period nobody judges is never silently inert.
+            const period = facts.period !== undefined ? copyPeriod(facts.period) : undefined;
+            if (period !== undefined && deps.resultsLayer !== true) {
+                warnPeriodUnjudged(call.toolName);
+            }
+            // Copied item by item — event payloads are detached plain data, never
+            // a shared reference into a value the tool still holds. The
+            // record-only extras (`short`, `kind`) ride along when valid, read by
+            // the ONE non-throwing reader (`coverage/items.ts` · `readItemExtras`),
+            // so the event and the tracked row carry the same fields; the model is
+            // served the envelope without them (`afterMoment`, below).
+            const copy = (list, section) => list.map((i) => ({
+                what: i.what,
+                ...(i.why !== undefined && { why: i.why }),
+                ...readItemExtras(i, section, call.toolName),
+            }));
+            const checked = copy(facts.coverage.checked, 'checked');
+            const notChecked = copy(facts.coverage.notChecked, 'notChecked');
+            const cannotCover = copy(facts.coverage.cannotCover, 'cannotCover');
+            // What a ledger's read found still running (`coverage/inProgress.ts`) —
+            // read by its ONE rule set, so every item here is well-formed; copied.
+            const inProgress = facts.inProgress?.map(copyInProgressItem);
+            if (facts.kind === 'absence') {
+                typedEmit(scope, 'agentfootprint.tools.absent', {
+                    toolName: call.toolName,
+                    toolCallId: call.toolCallId,
+                    iteration: call.iteration,
+                    ...(facts.lookedFor !== undefined && { lookedFor: facts.lookedFor }),
+                    checked,
+                    ...(notChecked.length > 0 && { notChecked }),
+                    ...(cannotCover.length > 0 && { cannotCover }),
+                    // The suggestion, as declared (9.113.0): the sentence, and the
+                    // typed tool as a copy (`tryInsteadToolOfAbsence`). The EVENT only:
+                    // it is advice about a call not yet made, not ground the answer
+                    // stands on, so the tracked row below and the block composed from
+                    // it never carry it.
+                    ...(facts.tryInstead !== undefined && { tryInstead: facts.tryInstead }),
+                    ...(facts.tryInsteadTool !== undefined && { tryInsteadTool: facts.tryInsteadTool }),
+                    // Honesty step 7b — where the search looked and when (the event only:
+                    // the limits block prints coverage, never a source), and the period.
+                    ...(facts.provenance !== undefined && { provenance: { ...facts.provenance } }),
+                    ...(period !== undefined && { period: copyPeriod(period) }),
+                });
+            }
+            else {
+                typedEmit(scope, 'agentfootprint.tools.coverage_declared', {
+                    toolName: call.toolName,
+                    toolCallId: call.toolCallId,
+                    iteration: call.iteration,
+                    ...(checked.length > 0 && { checked }),
+                    ...(notChecked.length > 0 && { notChecked }),
+                    ...(cannotCover.length > 0 && { cannotCover }),
+                    ...(inProgress !== undefined && { inProgress: inProgress.map(copyInProgressItem) }),
+                    ...(period !== undefined && { period: copyPeriod(period) }),
+                });
+            }
+            rows.push({
+                kind: facts.kind,
+                toolName: call.toolName,
+                toolCallId: call.toolCallId,
+                iteration: call.iteration,
+                ...(facts.lookedFor !== undefined && { lookedFor: facts.lookedFor }),
+                checked,
+                notChecked,
+                cannotCover,
+                ...(period !== undefined && { period }),
+                ...(inProgress !== undefined && { inProgress }),
+            });
+        }
+        scope.coverageDeclared = [...(scope.coverageDeclared ?? []), ...rows];
+        return reading.status;
+    };
+    /**
+     * One COMPOSED statement (`Tool.search`) — its event and its row. The row is
+     * the committed record: every value, under the run's redaction policy, at
+     * the address the funnel reserved (`resultId`). The event carries the
+     * declaration's constants, the gaps and each other facet as a reference —
+     * never a composed value, armed or not (`search/events.ts`).
+     */
+    const declareComposed = (scope, call, facts) => {
+        const composed = facts.composed;
+        const period = facts.period !== undefined ? copyPeriod(facts.period) : undefined;
+        if (period !== undefined && deps.resultsLayer !== true)
+            warnPeriodUnjudged(call.toolName);
+        const event = composedEventFields(facts, { armed: deps.negativeClaimsArmed === true });
+        const base = {
+            toolName: call.toolName,
+            toolCallId: call.toolCallId,
+            iteration: call.iteration,
+        };
+        if (facts.kind === 'absence') {
+            typedEmit(scope, 'agentfootprint.tools.absent', {
+                ...base,
+                ...(event.lookedFor !== undefined && { lookedFor: event.lookedFor }),
+                ...(event.lookedForRef !== undefined && { lookedForRef: event.lookedForRef }),
+                checked: event.checked,
+                ...(event.notChecked.length > 0 && { notChecked: event.notChecked }),
+                ...(event.cannotCover.length > 0 && { cannotCover: event.cannotCover }),
+                ...(facts.tryInstead !== undefined && { tryInstead: facts.tryInstead }),
+                ...(facts.tryInsteadTool !== undefined && { tryInsteadTool: facts.tryInsteadTool }),
+                ...(facts.provenance !== undefined && { provenance: { ...facts.provenance } }),
+                ...(period !== undefined && { period: copyPeriod(period) }),
+                composition: event.composition,
+            });
+        }
+        else {
+            typedEmit(scope, 'agentfootprint.tools.coverage_declared', {
+                ...base,
+                ...(event.checked.length > 0 && { checked: event.checked }),
+                ...(event.notChecked.length > 0 && { notChecked: event.notChecked }),
+                ...(event.cannotCover.length > 0 && { cannotCover: event.cannotCover }),
+                ...(facts.inProgress !== undefined && {
+                    inProgress: facts.inProgress.map(copyInProgressItem),
+                }),
+                ...(period !== undefined && { period: copyPeriod(period) }),
+                composition: event.composition,
+            });
+        }
+        // Detached plain data: the row must not share a reference with a value
+        // the tool still holds (a sent argument object, the declaration's lists).
+        const row = structuredClone({
+            kind: facts.kind,
+            ...base,
+            composed: composed.origin,
+            resultId: composed.resultId,
+            handle: composed.handle,
+            ...(facts.lookedFor !== undefined && { lookedFor: facts.lookedFor }),
+            checked: facts.coverage.checked,
+            notChecked: facts.coverage.notChecked,
+            cannotCover: facts.coverage.cannotCover,
+            complete: composed.complete,
+            gaps: composed.gaps,
+            ...(period !== undefined && { period }),
+            ...(facts.inProgress !== undefined && { inProgress: facts.inProgress }),
+        });
+        if (deps.negativeClaimsArmed === true)
+            captureNegativeCoverage(scope, row);
+        return row;
+    };
+    /**
+     * A lookup that pauses still declares what it looked at (9.114.0) — the
+     * RAISE-SITE reader of `InputRequestDeclaration.absence`.
+     *
+     * A tool that found nothing and raised `requestInput` about the miss used
+     * to leave no record of it: `declareCoverage` reads a RETURNED value, and
+     * the pause branch returns the checkpoint before any of its call sites.
+     * The app could not file it either — the declaration's `context` rides to
+     * the model on resume, never to the record. So the raise site files it,
+     * through the same two readers a returned absence meets: `declareCoverage`
+     * (the one recognizer, `tools.absent`, the `coverageDeclared` row — the
+     * bytes a returned `absent(…)` files) and the empty-lookup write seam, with
+     * the envelope as the tool's own answer — it ran, nothing errored, nothing
+     * denied it, and no ceiling judged a result the model was never served.
+     *
+     * The delivered status `declareCoverage` returns is dropped on purpose: a
+     * paused call is not settled, so there is no `tool_end` for it to ride.
+     * Nothing on resume reads the field (the served result there is the
+     * person's `InputResponseResult`), so the rows are filed once, here.
+     *
+     * CONTAINED the way the returned path contains it. The recognizer reads an
+     * envelope minted elsewhere without repairing it, so its lists can be
+     * something `declareCoverage` cannot copy (`checked: [null]`,
+     * `not_checked: 5`). Returned, that throw lands in the dispatch `try` and
+     * errors the call; here it would land in the `catch` and fail the run. So
+     * the copy is caught here instead, and the error text comes back: the
+     * caller errors the call with it and does not pause. That is what the same
+     * value returned would do. `undefined` means filed.
+     */
+    const declareRaisedAbsence = (scope, call, args, absence, history) => {
+        try {
+            declareCoverage(scope, call, absence);
+        }
+        catch (err) {
+            return err instanceof Error ? err.message : String(err);
+        }
+        links.noticeEmptyLookup(scope, call, args, absence, history, true);
+        return undefined;
+    };
+    return { declareCoverage, declareComposed, declareRaisedAbsence };
+}
+//# sourceMappingURL=coverageOperations.js.map

package/dist/esm/core/agent/stages/toolCalls/evidence/coverageOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverageOperations.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/coverageOperations.ts"],"names":[],"mappings":"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"}

package/dist/esm/core/agent/stages/toolCalls/evidence/integrityOperations.d.ts

@@ -0,0 +1,4 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolIntegrityOperations } from '../contracts/operations/integrity.js';
+/** Compose the existing integrity callbacks once for this handler. */
+export declare function buildToolIntegrityOperations(deps: Pick<ToolCallsHandlerDeps, 'columnDeclarations' | 'columnCheckMode' | 'integrityLedger' | 'emptyLookupGrounding'>): ToolIntegrityOperations;

package/dist/esm/core/agent/stages/toolCalls/evidence/integrityOperations.js

@@ -0,0 +1,137 @@
+import { columnTypesOf, readRowset } from '../../../../../integrity/column-types/check.js';
+import { servedToModel } from '../../../../../semantics/coverage/read.js';
+import { fileIntegrityFindings } from '../../../integrityFindings.js';
+import { producerCorpusOf } from './producerCorpus.js';
+import { emptyLookupOf, readLookupResult } from '../../../../../integrity/empty-lookup/check.js';
+import { readAbsence } from '../../../../../semantics/coverage/index.js';
+/** Compose the existing integrity callbacks once for this handler. */
+export function buildToolIntegrityOperations(deps) {
+    /**
+     * THE COLUMN-TYPE CONTRACT (9.78.0) — the tool declared what its rows
+     * contain, and this is where the rows are.
+     *
+     * Placed at the SAME execute boundaries as `refuseOverCeiling` and for the
+     * same reason: `resultColumns` is the TOOL AUTHOR's contract on the tool's
+     * OWN return, so it is judged the moment the handler's value lands, before
+     * governance, before placement, before the cap — and a resumed call is
+     * judged exactly as an inline one.
+     *
+     * AFTER the ceiling, deliberately. A payload the model will never read has
+     * no columns worth arguing about, and judging one that was already refused
+     * would file findings about rows nobody was ever served.
+     *
+     * `undefined` = nothing declared, nothing to refuse, or `'warn'` — the
+     * caller keeps today's path byte for byte. A string is the teaching
+     * refusal, which under `'enforce'` replaces the payload on every channel,
+     * exactly as the ceiling's does.
+     *
+     * The three field failures this exists for: LUN 0 stored as an empty string
+     * on 2,094 mappings; an 8 MiB disk rendered `0.0 GB`; a whole tool family
+     * returning its numbers as quoted strings. This catches the first and the
+     * third. It cannot catch the second — that is MEANING, and the ceiling
+     * sentence in every finding says so.
+     */
+    const judgeColumns = (scope, call, value) => {
+        const declarations = deps.columnDeclarations;
+        if (declarations === undefined)
+            return undefined;
+        const columns = declarations.get(call.toolName);
+        if (columns === undefined)
+            return undefined;
+        const { findings, disposition, refusal } = columnTypesOf({
+            toolName: call.toolName,
+            toolCallId: call.toolCallId,
+            columns,
+            // What the model will read (the ceiling's reasoning, above).
+            reading: readRowset(servedToModel(value)),
+            mode: deps.columnCheckMode ?? 'warn',
+        }, call.iteration);
+        // ONE encounter, TWO rows. The declaration arms both checks and a call
+        // meets both at once, so both must answer for it — a shape that is not a
+        // rowset is `not-applicable` to each, and a clean rowset is a
+        // `checked-pass` for each. Filing one row would leave the other check
+        // looking untouched, which is the rot signal, not the truth.
+        const ledger = deps.integrityLedger?.current;
+        for (const kind of ['column-type-mismatch', 'missing-column']) {
+            const kindFired = findings.some((f) => f.kind === kind);
+            // A rowset this check could read, where THIS kind found nothing, is a
+            // pass for THIS kind even when its sibling failed: the columns really
+            // were all present, or really did all hold their declared type.
+            const row = disposition === 'not-applicable'
+                ? 'not-applicable'
+                : kindFired
+                    ? 'checked-fail'
+                    : 'checked-pass';
+            ledger?.note(kind, 'write', row, kindFired ? Date.now() : undefined);
+        }
+        // The findings ARE the record of a refusal: each one names what was
+        // refused, which column, how many rows, and — through `outcomeClause` —
+        // that the model read a sentence instead of the rows. Deliberately NOT
+        // `tools.result_refused`: that event's whole vocabulary is a SIZE
+        // (`sizeChars`, `maxChars`), and reusing it here would put a fabricated
+        // ceiling on the record to describe a refusal that had nothing to do
+        // with size.
+        fileIntegrityFindings(scope, findings, call.iteration);
+        return refusal;
+    };
+    /**
+     * THE WRITE SEAM (9.77.0) — `empty-lookup`, at the one moment a lookup's
+     * answer becomes a fact in the conversation.
+     *
+     * The recorded failure this exists for: a reverse-lookup tool filtered a
+     * column before a pivot, so EVERY lookup returned an empty result, for
+     * every identifier, always — and the agent reported, with confidence and in
+     * a table, that the device was logged in nowhere. It was logged in the
+     * whole time. An empty result from a broken filter is byte-identical to an
+     * empty result from a genuine absence, so nothing anywhere could notice.
+     *
+     * What CAN be noticed is the pair: the run itself produced this identifier
+     * (it came out of a result from a tool this one's author named in
+     * `argumentsFrom`), and the lookup keyed on it came back empty. The finding
+     * is an ADVISORY and says so — an empty answer can be perfectly true, and
+     * this cannot tell which one it is looking at.
+     *
+     * Judged on the TOOL'S OWN answer, before the after-tool chain rewrites it
+     * for the model: whether the lookup found anything is a fact about the
+     * tool, not about what a governance rule then did with it. A refused,
+     * placed or capped result reads as bespoke anyway — a claim ticket has no
+     * rows to count.
+     */
+    const noticeEmptyLookup = (scope, call, args, result, history, 
+    /** The call produced a real result to read (ran, no error, nothing refused it). */
+    answered) => {
+        const grounding = deps.emptyLookupGrounding;
+        if (grounding === undefined)
+            return;
+        const argumentsFrom = grounding.get(call.toolName);
+        if (argumentsFrom === undefined)
+            return;
+        const ledger = deps.integrityLedger?.current;
+        // A call that never ran, was denied, errored or had its payload refused
+        // produced no lookup result to read. Not a pass, not a fail — the check
+        // met its subject and the subject is out of scope BY RULE, which is what
+        // `not-applicable` is for. Stated, never silence.
+        if (!answered) {
+            ledger?.note('empty-lookup', 'write', 'not-applicable');
+            return;
+        }
+        // The producer corpus: the earlier RESULTS from a tool THIS tool declares
+        // as one of its grounds — never a settled message (`producerCorpusOf`).
+        const produced = producerCorpusOf(history, argumentsFrom);
+        const { findings, disposition } = emptyLookupOf({
+            toolName: call.toolName,
+            toolCallId: call.toolCallId,
+            args,
+            argumentsFrom,
+            // `readAbsence` is the ONE owner of the `af_absent` marker; the pure
+            // check is handed its verdict rather than re-deriving it, so
+            // `src/integrity/` stays a leaf and the reserved word keeps one
+            // spelling.
+            reading: readLookupResult(result, readAbsence(result) !== undefined),
+        }, produced, call.iteration);
+        ledger?.note('empty-lookup', 'write', disposition, disposition === 'checked-fail' ? Date.now() : undefined);
+        fileIntegrityFindings(scope, findings, call.iteration);
+    };
+    return { judgeColumns, noticeEmptyLookup };
+}
+//# sourceMappingURL=integrityOperations.js.map

package/dist/esm/core/agent/stages/toolCalls/evidence/integrityOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrityOperations.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/integrityOperations.ts"],"names":[],"mappings":"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"}

package/dist/esm/core/agent/stages/toolCalls/evidence/judgeLanded.d.ts

@@ -0,0 +1,29 @@
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { Classifier } from '../../../../../classify/types.js';
+import type { TurnStamp } from '../../../findings/ledger.js';
+/**
+ * The judge's turn on ONE landed result (9.104.0) — called at the five
+ * places a result joins the batch (the execute loop and the four resume
+ * doors), right after the `toolResults` entry exists and before the next
+ * model call. Value-gated on `deps.findingsJudge`: unarmed, or armed with
+ * no judge, this is a no-op that awaits nothing. `judgeResult` never
+ * throws — a failed call is an error row and the run continues.
+ *
+ * `ran` is the caller's word that the TOOL produced this text: a permission
+ * denial, a halt, a fail-closed refusal, a declined check-in, a chain deny
+ * are sentences the library wrote about a call that never ran, and a
+ * denial text is not a tool result — asking a judge what it is worth for
+ * the proposition would file a standing for evidence nobody collected. The
+ * execute loop passes the nudge's own predicate (`executed && !denied &&
+ * !skillRejected`); the resume doors pass `dispatched.executed === true`;
+ * the `pauseHere` / `askHuman` door passes `true` because the person's
+ * answer IS that tool's result by the handler's contract.
+ */
+export declare function judgeLanded(scope: TypedScope<AgentState>, judge: Classifier | undefined, ran: boolean, entry: {
+    toolName: string;
+    result: string;
+    toolCallId: string;
+}, iteration: number, 
+/** The honesty layers' turn stamp — passed only while an honesty layer is armed. */
+stamp?: TurnStamp): Promise<void>;

package/dist/esm/core/agent/stages/toolCalls/evidence/judgeLanded.js

@@ -0,0 +1,32 @@
+/**
+ * The judge's turn on ONE landed result (9.104.0) — called at the five
+ * places a result joins the batch (the execute loop and the four resume
+ * doors), right after the `toolResults` entry exists and before the next
+ * model call. Value-gated on `deps.findingsJudge`: unarmed, or armed with
+ * no judge, this is a no-op that awaits nothing. `judgeResult` never
+ * throws — a failed call is an error row and the run continues.
+ *
+ * `ran` is the caller's word that the TOOL produced this text: a permission
+ * denial, a halt, a fail-closed refusal, a declined check-in, a chain deny
+ * are sentences the library wrote about a call that never ran, and a
+ * denial text is not a tool result — asking a judge what it is worth for
+ * the proposition would file a standing for evidence nobody collected. The
+ * execute loop passes the nudge's own predicate (`executed && !denied &&
+ * !skillRejected`); the resume doors pass `dispatched.executed === true`;
+ * the `pauseHere` / `askHuman` door passes `true` because the person's
+ * answer IS that tool's result by the handler's contract.
+ */
+export async function judgeLanded(scope, judge, ran, entry, iteration, 
+/** The honesty layers' turn stamp — passed only while an honesty layer is armed. */
+stamp) {
+    if (judge === undefined || !ran)
+        return;
+    // Dynamic import — the optional-family law of docs-next's site budget: a
+    // family that exists only behind a builder option reaches the bundle
+    // through `import()` at the point the option is enabled, and dispatch is
+    // already async. An agent without a judge never loads `findings/judge.ts`
+    // (the `selfExplain.ts · lazilyMountedTraceTools` precedent).
+    const { judgeResult } = await import('../../../findings/judge.js');
+    await judgeResult(scope, judge, entry, iteration, scope.$getEnv().signal, stamp);
+}
+//# sourceMappingURL=judgeLanded.js.map

package/dist/esm/core/agent/stages/toolCalls/evidence/judgeLanded.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"judgeLanded.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/judgeLanded.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,KAA6B,EAC7B,KAA6B,EAC7B,GAAY,EACZ,KAA+D,EAC/D,SAAiB;AACjB,oFAAoF;AACpF,KAAiB;IAEjB,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,GAAG;QAAE,OAAO;IACxC,yEAAyE;IACzE,qEAAqE;IACrE,yEAAyE;IACzE,0EAA0E;IAC1E,8DAA8D;IAC9D,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,MAAM,CAAC,4BAA4B,CAAC,CAAC;IACnE,MAAM,WAAW,CACf,KAAqD,EACrD,KAAK,EACL,KAAK,EACL,SAAS,EACT,KAAK,CAAC,OAAO,EAAE,CAAC,MAAM,EACtB,KAAK,CACN,CAAC;AACJ,CAAC"}

package/dist/esm/core/agent/stages/toolCalls/evidence/madeInRun.d.ts

@@ -0,0 +1,6 @@
+/** The run a capability binding was made in — `undefined` when there is no binding. */
+export declare const madeInRun: (bindRun: {
+    readonly runContext?: {
+        readonly runId: string;
+    };
+} | undefined) => string | undefined;

package/dist/esm/core/agent/stages/toolCalls/evidence/madeInRun.js

@@ -0,0 +1,3 @@
+/** The run a capability binding was made in — `undefined` when there is no binding. */
+export const madeInRun = (bindRun) => bindRun?.runContext?.runId;
+//# sourceMappingURL=madeInRun.js.map

package/dist/esm/core/agent/stages/toolCalls/evidence/madeInRun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"madeInRun.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/madeInRun.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,OAAyE,EACzE,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,CAAC"}

package/dist/esm/core/agent/stages/toolCalls/evidence/producerCorpus.d.ts

@@ -0,0 +1,22 @@
+import type { LLMMessage } from '../../../../../provider-contract/types.js';
+import type { ProducedResult } from '../../../../../integrity/empty-lookup/check.js';
+/**
+ * The empty-lookup check's PRODUCER CORPUS (9.77.0) — every `role: 'tool'`
+ * RESULT in `history` from a tool the judged one names in `argumentsFrom`,
+ * as the run served it. The caller hands the history the judged call was
+ * served (the call itself is pushed after it), so a producer called earlier in
+ * the same batch is already in it — which is right: the model can only have
+ * taken a value from a result it had already been served.
+ *
+ * A message the batch settlement wrote (9.113.0) is no result: its ground
+ * never ran, so it produced nothing to take a value from. Read off the marker
+ * (`../../../findings/offer.ts` · `isResultMessage`), never the sentence.
+ *
+ * Each result is read as the TOOL's own bytes (`lib/toolBytes.ts` ·
+ * `toolBytesOf`): the note the inputs layer appends after a filled call's
+ * result carries the value the library filled, and a value only that note
+ * carries is not one the run's producer served.
+ *
+ * Exported for its unit test (`test/integrity/emptyLookup.test.ts`).
+ */
+export declare function producerCorpusOf(history: readonly LLMMessage[], argumentsFrom: readonly string[]): ProducedResult[];

package/dist/esm/core/agent/stages/toolCalls/evidence/producerCorpus.js

@@ -0,0 +1,34 @@
+import { isResultMessage } from '../../../findings/offer.js';
+import { toolBytesOf } from '../../../../../lib/toolBytes.js';
+/**
+ * The empty-lookup check's PRODUCER CORPUS (9.77.0) — every `role: 'tool'`
+ * RESULT in `history` from a tool the judged one names in `argumentsFrom`,
+ * as the run served it. The caller hands the history the judged call was
+ * served (the call itself is pushed after it), so a producer called earlier in
+ * the same batch is already in it — which is right: the model can only have
+ * taken a value from a result it had already been served.
+ *
+ * A message the batch settlement wrote (9.113.0) is no result: its ground
+ * never ran, so it produced nothing to take a value from. Read off the marker
+ * (`../../../findings/offer.ts` · `isResultMessage`), never the sentence.
+ *
+ * Each result is read as the TOOL's own bytes (`lib/toolBytes.ts` ·
+ * `toolBytesOf`): the note the inputs layer appends after a filled call's
+ * result carries the value the library filled, and a value only that note
+ * carries is not one the run's producer served.
+ *
+ * Exported for its unit test (`test/integrity/emptyLookup.test.ts`).
+ */
+export function producerCorpusOf(history, argumentsFrom) {
+    const produced = [];
+    for (const message of history) {
+        if (!isResultMessage(message))
+            continue;
+        const name = message.toolName;
+        if (typeof name !== 'string' || !argumentsFrom.includes(name))
+            continue;
+        produced.push({ toolName: name, text: toolBytesOf(message) });
+    }
+    return produced;
+}
+//# sourceMappingURL=producerCorpus.js.map

package/dist/esm/core/agent/stages/toolCalls/evidence/producerCorpus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"producerCorpus.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/producerCorpus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAI9D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAA8B,EAC9B,aAAgC;IAEhC,MAAM,QAAQ,GAAqB,EAAE,CAAC;IACtC,KAAK,MAAM,OAAO,IAAI,OAAO,EAAE,CAAC;QAC9B,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;YAAE,SAAS;QACxC,MAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC;QAC9B,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC;YAAE,SAAS;QACxE,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/esm/core/agent/stages/toolCalls/evidence/scriptsOperations.d.ts

@@ -0,0 +1,11 @@
+import type { buildToolResolver } from '../../toolResolver.js';
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolScriptsOperations } from '../contracts/operations/scripts.js';
+import type { ToolCatalogOperations } from '../contracts/operations/catalog.js';
+interface ToolScriptsOperationsLinks {
+    readonly peelCall: ToolCatalogOperations['peelCall'];
+    readonly resolveTool: ReturnType<typeof buildToolResolver>;
+}
+/** Compose the existing scripts callbacks once for this handler. */
+export declare function buildToolScriptsOperations(deps: Pick<ToolCallsHandlerDeps, 'scriptRecord'>, links: ToolScriptsOperationsLinks): ToolScriptsOperations;
+export {};