agentfootprint 13.0.0 → 14.0.0

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

@@ -0,0 +1,156 @@
+import { codeRunsOf } from '../../../../codeRunnerTool.js';
+import { scriptOf } from '../../../../../tools/script.js';
+import { scriptRowFor, recordScriptRow, programIn } from '../../../scripts/rows.js';
+import { typedEmit } from '../../../../../recorders/core/typedEmit.js';
+/** Compose the existing scripts callbacks once for this handler. */
+export function buildToolScriptsOperations(deps, links) {
+    /**
+     * THE ONE DOOR for a call's `script` row (`deps.scriptRecord`) — asked
+     * where each call of a declared code-running tool settles or pauses. A tool
+     * that declares no `script` (or one the dispatch door refuses,
+     * `tools/script.ts` · `scriptOf`) files nothing; an unarmed agent never
+     * reaches the declaration at all.
+     */
+    const fileScript = (scope, call) => {
+        if (deps.scriptRecord !== true)
+            return undefined;
+        const script = scriptOf(call.tool);
+        if (script === undefined)
+            return undefined;
+        const row = scriptRowFor({
+            script,
+            tool: call.toolName,
+            toolCallId: call.toolCallId,
+            iteration: call.iteration,
+            turn: scope.turnNumber,
+            proposed: call.proposed,
+            ...(call.submitted !== undefined && { submitted: call.submitted }),
+            settlement: call.settlement,
+            ...(call.facts !== undefined && { facts: call.facts }),
+            ...(call.withheld === true && { withheld: true }),
+            ...(call.paused === true && { paused: true }),
+        });
+        if (row === undefined)
+            return undefined;
+        const dispatch = recordScriptRow(scope, row, {
+            paused: call.paused === true,
+            ...(call.dispatch !== undefined && { dispatch: call.dispatch }),
+        });
+        // A paused call keeps its dispatch across the checkpoint: the row that
+        // settles it on resume joins the same dispatch, never a new one.
+        if (call.paused === true && dispatch !== undefined) {
+            scope.pausedScriptDispatch = { dispatch, toolCallId: call.toolCallId, turn: row.turn };
+        }
+        return dispatch;
+    };
+    /**
+     * The declared argument's VALUE in `args`, read now — `undefined` when the
+     * agent is unarmed or the tool declares no `script`. Asked at the boundary
+     * each value belongs to (as the call arrives; just before `execute`) and
+     * kept: a string cannot be edited afterwards, the arguments object can.
+     */
+    const programOfCall = (tool, args) => {
+        if (deps.scriptRecord !== true)
+            return undefined;
+        const script = scriptOf(tool);
+        return script === undefined ? undefined : programIn(script, args);
+    };
+    /**
+     * The arguments the model PROPOSED for a call, read back from the assistant
+     * turn that carried it (`_findings` peeled) — what a resumed call's script
+     * row compares the program it ran with. `undefined` when the turn is gone.
+     */
+    const proposedArgsOf = (scope, toolCallId) => {
+        const history = scope.history;
+        for (let i = history.length - 1; i >= 0; i--) {
+            const call = history[i]?.toolCalls?.find((c) => c.id === toolCallId);
+            if (call !== undefined)
+                return links.peelCall(call).args;
+        }
+        return undefined;
+    };
+    /**
+     * A RESUMED call's script row — the four resume doors settle the paused call
+     * here. `carried` is the pause carrier (the arguments the person approved,
+     * or the call was paused with); `seen` is what `resolveCredentialAndExecute`
+     * saw when the call ran. The tool is resolved as the resume resolved it.
+     */
+    const fileResumedScript = (scope, call) => {
+        if (deps.scriptRecord !== true)
+            return;
+        const tool = links.resolveTool(call.toolName, scope.pausedToolParty).tool;
+        // The dispatch the pause filed this call under — when it is THIS call's.
+        const held = scope.pausedScriptDispatch;
+        const dispatch = held !== undefined &&
+            held.toolCallId === call.toolCallId &&
+            held.turn === scope.turnNumber
+            ? held.dispatch
+            : undefined;
+        if (held !== undefined)
+            scope.pausedScriptDispatch = undefined;
+        // A call that paused from inside `execute` carried the values read before
+        // it ran (`pausedScriptPrograms`) — this call's, when the dispatch is.
+        const carried = scope.pausedScriptPrograms;
+        if (carried !== undefined)
+            scope.pausedScriptPrograms = undefined;
+        const own = dispatch !== undefined ? carried : undefined;
+        // Read before `execute` ran (`seen`), or carried from before it ran; a
+        // call that never got there reads its carrier now — no tool code ran on it.
+        const proposed = call.seen.entered === true
+            ? call.seen.proposed
+            : own?.proposed ??
+                programOfCall(tool, proposedArgsOf(scope, call.toolCallId) ?? call.carried);
+        const submitted = call.seen.entered === true
+            ? call.seen.submitted
+            : own?.submitted ?? programOfCall(tool, call.carried);
+        fileScript(scope, {
+            tool,
+            toolName: call.toolName,
+            toolCallId: call.toolCallId,
+            iteration: call.iteration,
+            proposed,
+            ...(submitted !== undefined && { submitted }),
+            settlement: !call.entered ? 'not-entered' : call.seen.threw === true ? 'threw' : 'returned',
+            ...(call.seen.codeRun !== undefined && { facts: call.seen.codeRun }),
+            withheld: call.seen.overCeiling === true,
+            ...(dispatch !== undefined && { dispatch }),
+        });
+    };
+    /**
+     * THIS dispatch's code-run facts, taken from its own slot (`CODE_RUN_SLOT`)
+     * — what the script row attests, whichever runner filed them (a wrapper that
+     * hands its context to a code runner included). Asked at BOTH execute
+     * boundaries — the batch loop and `resolveCredentialAndExecute` — right
+     * after `tool.execute` returns. Only the slot is ever attested from.
+     *
+     * The published surfaces are kept exactly as they were. The map
+     * (`codeRunsOf`): at the batch boundary (`takeListed`) the dispatched tool's
+     * entry for this call id is taken off it; the resume boundary leaves it.
+     * The event fires when the dispatched tool is itself a code runner, as it
+     * always did, carrying the dispatch's own facts. When the slot is empty
+     * there — a decorator kept the runner's map but handed the runner a context
+     * of its own, so the runner filed by the call id alone — it fires as it
+     * always did, from the map's entry: the one case the slot cannot reach, and
+     * the facts it carries are the map's, never attested. The code itself is
+     * never on this channel: generated code quotes the data it was handed.
+     */
+    const takeCodeRun = (scope, tool, slot, call) => {
+        const facts = slot.facts;
+        slot.facts = undefined;
+        const listed = codeRunsOf(tool);
+        const filed = call.takeListed ? listed?.get(call.toolCallId) : undefined;
+        if (filed !== undefined)
+            listed?.delete(call.toolCallId);
+        const told = facts ?? filed;
+        if (told !== undefined && listed !== undefined) {
+            // `tool` is the name the model CALLED, not the one the runner's closure
+            // was built with: a runner re-exposed under another schema name must be
+            // recognizable by the name its calls carry (a content exporter withholds
+            // that tool's arguments — the program). Same bytes whenever they agree.
+            typedEmit(scope, 'agentfootprint.tools.code_run', { ...told, tool: call.toolName });
+        }
+        return facts;
+    };
+    return { fileScript, programOfCall, proposedArgsOf, fileResumedScript, takeCodeRun };
+}
+//# sourceMappingURL=scriptsOperations.js.map

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

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

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

@@ -0,0 +1,4 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolSemanticsOperations } from '../contracts/operations/semantics.js';
+/** Compose the existing semantics callbacks once for this handler. */
+export declare function buildToolSemanticsOperations(deps: Pick<ToolCallsHandlerDeps, 'collectClaimFacts'>): ToolSemanticsOperations;

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

@@ -0,0 +1,90 @@
+import { isDevMode } from 'footprintjs';
+import { readSemantics, explainSemantics, semanticsForModel, } from '../../../../../semantics/envelope.js';
+import { typedEmit } from '../../../../../recorders/core/typedEmit.js';
+import { claimRowsOf } from '../../../../../integrity/unsupported-claim/ledger.js';
+/** Compose the existing semantics callbacks once for this handler. */
+export function buildToolSemanticsOperations(deps) {
+    /**
+     * The semantic envelope (9.53.0) — recognized at the SAME execute
+     * boundaries as coverage and the ceiling (one implementation, every door),
+     * AFTER `declareCoverage` (which absorbs the envelope's `coverage` field
+     * through the one coverage funnel) and BEFORE `refuseOverCeiling` (so the
+     * FULL envelope — grain, provenance, render, coverage — is on the record
+     * even when the content is refused as oversized: a caveat that died with
+     * an oversized result would be the silence the envelope exists to break).
+     *
+     * Returns the MODEL's view — the compact rendering-free projection
+     * (`semanticsForModel`: data + grain + provenance + composed `not_covered`
+     * + non-null clarify + the static note; never the marker, `render`, or the
+     * three-list coverage detail) — or `undefined` for every non-envelope
+     * value, which keeps today's path byte for byte. The full envelope rides
+     * the typed `tools.semantics_declared` event, so recordings and UIs get
+     * everything the model was spared.
+     *
+     * A value CARRYING the marker that this library cannot honor stays DATA
+     * (never half-applied — the recognition strictness law) and is dev-warned
+     * here naming its first fault; `check:semantics` names them all at build
+     * time.
+     */
+    const declareSemantics = (scope, call, value) => {
+        const sem = readSemantics(value);
+        if (sem === undefined) {
+            const faults = explainSemantics(value);
+            if (faults !== undefined && faults.length > 0 && isDevMode()) {
+                // eslint-disable-next-line no-console
+                console.warn(`agentfootprint semantics: tool '${call.toolName}' returned a value carrying ` +
+                    `af_semantics that was NOT recognized (treated as plain data): ` +
+                    `${faults[0].message} (field: ${faults[0].field})` +
+                    (faults.length > 1 ? ` — and ${faults.length - 1} more; run check:semantics.` : ''));
+            }
+            return undefined;
+        }
+        // Detached plain data for the record — the event must not hold a live
+        // reference into a value the tool still owns. An envelope that cannot
+        // survive structuredClone cannot ride the record (or a checkpoint), so
+        // it is declined here — data path, dev-warned — rather than half-filed.
+        let detached;
+        try {
+            detached = structuredClone(sem);
+        }
+        catch {
+            if (isDevMode()) {
+                // eslint-disable-next-line no-console
+                console.warn(`agentfootprint semantics: tool '${call.toolName}' returned a semantic envelope ` +
+                    `that does not survive structuredClone (a function or live handle in a fact row?) ` +
+                    `— treated as plain data. Envelope values must be plain data.`);
+            }
+            return undefined;
+        }
+        typedEmit(scope, 'agentfootprint.tools.semantics_declared', {
+            toolName: call.toolName,
+            toolCallId: call.toolCallId,
+            iteration: call.iteration,
+            semantics: detached,
+        });
+        // THE CLAIM LEDGER (9.61.0). The envelope's typed readings are absorbed
+        // into tracked state here — the `coverageDeclared` shape one function
+        // up — because the projection returned below REPLACES the envelope on
+        // the wire, and after that the typed object exists nowhere a check
+        // could read it. Written only when a tool actually declares readings,
+        // so an agent whose tools return none commits exactly what it did
+        // before. Rows carry the DETACHED values: a ledger holding live
+        // references into a value the tool still owns would compare against
+        // whatever that value became later.
+        // GATED on a declared contract: with nothing to read these rows, they
+        // would be committed state and checkpoint weight bought for nobody.
+        if (deps.collectClaimFacts === true) {
+            const rows = claimRowsOf(detached, call);
+            if (rows.length > 0) {
+                // `concat` over spread: one copy of the existing rows instead of
+                // re-spreading element by element. The write itself is still a
+                // fresh array — committed state is immutable-after-swap, so the
+                // prior value must never be mutated in place.
+                scope.claimFacts = (scope.claimFacts ?? []).concat(rows);
+            }
+        }
+        return semanticsForModel(sem);
+    };
+    return { declareSemantics };
+}
+//# sourceMappingURL=semanticsOperations.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semanticsOperations.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/semanticsOperations.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,SAAS,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,4CAA4C,CAAC;AAEvE,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAInF,sEAAsE;AACtE,MAAM,UAAU,4BAA4B,CAC1C,IAAqD;IAErD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,gBAAgB,GAAG,CACvB,KAA6B,EAC7B,IAA4F,EAC5F,KAAc,EACO,EAAE;QACvB,MAAM,GAAG,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,MAAM,MAAM,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;YACvC,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,SAAS,EAAE,EAAE,CAAC;gBAC7D,sCAAsC;gBACtC,OAAO,CAAC,IAAI,CACV,mCAAmC,IAAI,CAAC,QAAQ,8BAA8B;oBAC5E,gEAAgE;oBAChE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,YAAY,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG;oBAClD,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,MAAM,CAAC,MAAM,GAAG,CAAC,6BAA6B,CAAC,CAAC,CAAC,EAAE,CAAC,CACtF,CAAC;YACJ,CAAC;YACD,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,sEAAsE;QACtE,sEAAsE;QACtE,uEAAuE;QACvE,wEAAwE;QACxE,IAAI,QAAiB,CAAC;QACtB,IAAI,CAAC;YACH,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;QAClC,CAAC;QAAC,MAAM,CAAC;YACP,IAAI,SAAS,EAAE,EAAE,CAAC;gBAChB,sCAAsC;gBACtC,OAAO,CAAC,IAAI,CACV,mCAAmC,IAAI,CAAC,QAAQ,iCAAiC;oBAC/E,mFAAmF;oBACnF,8DAA8D,CACjE,CAAC;YACJ,CAAC;YACD,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,SAAS,CAAC,KAAK,EAAE,yCAAyC,EAAE;YAC1D,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,SAAS,EAAE,QAAyB;SACrC,CAAC,CAAC;QACH,wEAAwE;QACxE,sEAAsE;QACtE,sEAAsE;QACtE,mEAAmE;QACnE,sEAAsE;QACtE,kEAAkE;QAClE,gEAAgE;QAChE,oEAAoE;QACpE,oCAAoC;QACpC,sEAAsE;QACtE,oEAAoE;QACpE,IAAI,IAAI,CAAC,iBAAiB,KAAK,IAAI,EAAE,CAAC;YACpC,MAAM,IAAI,GAAG,WAAW,CAAC,QAAyB,EAAE,IAAI,CAAC,CAAC;YAC1D,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpB,iEAAiE;gBACjE,+DAA+D;gBAC/D,gEAAgE;gBAChE,8CAA8C;gBAC9C,KAAK,CAAC,UAAU,GAAI,CAAC,KAAK,CAAC,UAAU,IAAI,EAAE,CAAsB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACjF,CAAC;QACH,CAAC;QACD,OAAO,iBAAiB,CAAC,GAAG,CAAC,CAAC;IAChC,CAAC,CAAC;IAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAC9B,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+/**
+ * File the `source-clock` row for one call's dataset whose declared time axis
+ * names `zone` (step T8) — once per call and zone this turn, through the one
+ * writer; no event (the row is the record).
+ */
+export declare function recordSourceClock(scope: TypedScope<AgentState>, call: {
+    readonly toolCallId: string;
+    readonly toolName: string;
+}, zone: string): void;

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

@@ -0,0 +1,18 @@
+import { sourceClocksOf, sourceClockRow } from '../../../../../time/rows.js';
+import { recordFindings } from '../../../findings/ledger.js';
+/**
+ * File the `source-clock` row for one call's dataset whose declared time axis
+ * names `zone` (step T8) — once per call and zone this turn, through the one
+ * writer; no event (the row is the record).
+ */
+export function recordSourceClock(scope, call, zone) {
+    const ledger = scope.findingsLedger;
+    const turn = scope.turnNumber;
+    const filed = sourceClocksOf(ledger, turn).some((r) => r.toolCallId === call.toolCallId && r.zone === zone);
+    if (filed)
+        return;
+    recordFindings(scope, [
+        sourceClockRow(call, { turn, iteration: scope.iteration }, zone),
+    ]);
+}
+//# sourceMappingURL=sourceClock.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sourceClock.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/sourceClock.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC/B,KAA6B,EAC7B,IAAgE,EAChE,IAAY;IAEZ,MAAM,MAAM,GAAG,KAAK,CAAC,cAA4C,CAAC;IAClE,MAAM,IAAI,GAAG,KAAK,CAAC,UAAoB,CAAC;IACxC,MAAM,KAAK,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,IAAI,CAC7C,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,IAAI,CAAC,UAAU,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI,CAC3D,CAAC;IACF,IAAI,KAAK;QAAE,OAAO;IAClB,cAAc,CAAC,KAAK,EAAE;QACpB,cAAc,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,SAAmB,EAAE,EAAE,IAAI,CAAC;KAC3E,CAAC,CAAC;AACL,CAAC"}

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

@@ -0,0 +1,18 @@
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { ResolvedEvidenceGate } from '../../../evidence/types.js';
+import { type EvidenceCorpus } from '../../../evidence/evidenceIndex.js';
+import type { StandingRow } from '../../../findings/types.js';
+/**
+ * What the dispatch moment of the contingent check needs for one batch
+ * (9.110.0), or `undefined` when nothing can be filed: one of the two doors
+ * is closed, the ledger is absent, or no result holds a set-aside standing.
+ * The corpus and the exempt set are built once per batch — every call of the
+ * batch was served the same history.
+ */
+export declare function towersFor(scope: TypedScope<AgentState>, findings: true | undefined, gate: ResolvedEvidenceGate | undefined): {
+    readonly gate: ResolvedEvidenceGate;
+    readonly corpus: EvidenceCorpus;
+    readonly exempt: ReadonlySet<string>;
+    readonly standingOf: ReadonlyMap<string, StandingRow>;
+} | undefined;

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

@@ -0,0 +1,38 @@
+import { evidenceFromHistory, exemptFromRun, } from '../../../evidence/evidenceIndex.js';
+import { foldLedger } from '../../../findings/ledger.js';
+import { hasSetAsideStanding } from '../../../findings/contingent.js';
+/**
+ * What the dispatch moment of the contingent check needs for one batch
+ * (9.110.0), or `undefined` when nothing can be filed: one of the two doors
+ * is closed, the ledger is absent, or no result holds a set-aside standing.
+ * The corpus and the exempt set are built once per batch — every call of the
+ * batch was served the same history.
+ */
+export function towersFor(scope, findings, gate) {
+    if (findings !== true || gate === undefined)
+        return undefined;
+    const rows = [...(scope.findingsLedger ?? [])];
+    const { standingOf } = foldLedger(rows);
+    if (!hasSetAsideStanding(standingOf))
+        return undefined;
+    const history = [...(scope.history ?? [])];
+    // The same corpus the answer moment builds: one gate, one fold.
+    const corpus = evidenceFromHistory(history, gate);
+    // The index hit its ceiling: a result past the cut carried nothing into
+    // it, so a fact carrier there is invisible and a row read off the prefix
+    // would be false. The gate downgrades itself under the same flag; the
+    // dispatch moment files nothing (`findings/contingent.ts`, the header).
+    if (corpus.truncated)
+        return undefined;
+    return {
+        gate,
+        corpus,
+        exempt: exemptFromRun({
+            userMessage: scope.userMessage,
+            history,
+            systemPromptInjections: scope.systemPromptInjections,
+        }),
+        standingOf,
+    };
+}
+//# sourceMappingURL=towers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"towers.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/towers.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,mBAAmB,EACnB,aAAa,GACd,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAItE;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CACvB,KAA6B,EAC7B,QAA0B,EAC1B,IAAsC;IAStC,IAAI,QAAQ,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC9D,MAAM,IAAI,GAAG,CAAC,GAAG,CAAE,KAAK,CAAC,cAA6C,IAAI,EAAE,CAAC,CAAC,CAAC;IAC/E,MAAM,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IACxC,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC;QAAE,OAAO,SAAS,CAAC;IACvD,MAAM,OAAO,GAAG,CAAC,GAAG,CAAE,KAAK,CAAC,OAA6C,IAAI,EAAE,CAAC,CAAC,CAAC;IAClF,gEAAgE;IAChE,MAAM,MAAM,GAAG,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAClD,wEAAwE;IACxE,yEAAyE;IACzE,sEAAsE;IACtE,wEAAwE;IACxE,IAAI,MAAM,CAAC,SAAS;QAAE,OAAO,SAAS,CAAC;IACvC,OAAO;QACL,IAAI;QACJ,MAAM;QACN,MAAM,EAAE,aAAa,CAAC;YACpB,WAAW,EAAE,KAAK,CAAC,WAAiC;YACpD,OAAO;YACP,sBAAsB,EAAE,KAAK,CAAC,sBAEjB;SACd,CAAC;QACF,UAAU;KACX,CAAC;AACJ,CAAC"}

package/dist/esm/core/agent/stages/toolCalls/execution/artifactsOperations.d.ts

@@ -0,0 +1,12 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolArtifactsOperations } from '../contracts/operations/artifacts.js';
+import type { ToolContextOperations } from '../contracts/operations/context.js';
+import type { ToolCatalogOperations } from '../contracts/operations/catalog.js';
+interface ToolArtifactsOperationsLinks {
+    readonly runScopeOf: ToolContextOperations['runScopeOf'];
+    readonly toolArtifacts: ToolContextOperations['toolArtifacts'];
+    readonly lookupTool: ToolCatalogOperations['lookupTool'];
+}
+/** Compose the existing artifacts callbacks once for this handler. */
+export declare function buildToolArtifactsOperations(deps: Pick<ToolCallsHandlerDeps, 'artifactStore' | 'placement'>, links: ToolArtifactsOperationsLinks): ToolArtifactsOperations;
+export {};

package/dist/esm/core/agent/stages/toolCalls/execution/artifactsOperations.js

@@ -0,0 +1,261 @@
+import { isDevMode } from 'footprintjs';
+import { typedEmit } from '../../../../../recorders/core/typedEmit.js';
+import { wantsNeedsStoreRefusal, resolveToolWants } from '../../../../../artifacts/wants.js';
+import { assertAskComponent, InvalidAskComponentError, } from '../../../../../tools/askComponent.js';
+import { presentArtifact, PRESENT_TOOL_NAME } from '../../../../../artifacts/present.js';
+import { safeStringify } from '../../../validators.js';
+import { placedResultKind, placedToolResult } from '../../../../../artifacts/placement.js';
+import { strippedOnly } from '../../../../../semantics/coverage/read.js';
+/** Compose the existing artifacts callbacks once for this handler. */
+export function buildToolArtifactsOperations(deps, links) {
+    // ── Ref ARGUMENTS at dispatch (9.22.0, Leg 1) — ONE resolver, every door ──
+    // The batch loop and `resolveCredentialAndExecute` (the resume paths) both
+    // dispatch tools; each calls this BEFORE credential resolution — never
+    // acquire credentials for a call that won't run — so a declared ref is
+    // judged identically whichever door the call came through. Success rides
+    // the existing `artifacts.resolved` (one event per resolved argument);
+    // refusals ride `artifacts.refused` with `op: 'dispatch'`, and the tool is
+    // NOT executed — the model reads the teaching refusal instead.
+    const resolveWantsAtDispatch = async (scope, toolName, wants, args, 
+    /** The tool's OWN schema — the other half of the declaration. `required`
+     *  there is what makes an omitted ref a hole rather than a choice, and it
+     *  is read HERE, not left to `toolArgValidation`: that dial is agent-wide
+     *  and can be turned off, while `wants` is a promise about delivered data
+     *  (the same reason the non-string belt already runs behind a disabled
+     *  gate). */
+    inputSchema) => {
+        const store = deps.artifactStore;
+        if (store === undefined) {
+            // Statically registered tools are refused at BUILD; this serves the
+            // doors that only meet the tool at dispatch (provider-served tools).
+            typedEmit(scope, 'agentfootprint.artifacts.refused', {
+                op: 'dispatch',
+                reason: 'no-store',
+                detail: `tool '${toolName}' declares wants but no artifact store is attached`,
+                tool: toolName,
+            });
+            return { ok: false, refusal: wantsNeedsStoreRefusal(toolName, wants) };
+        }
+        const verdict = await resolveToolWants(store, links.runScopeOf(scope), toolName, wants, args, inputSchema);
+        if (!verdict.ok) {
+            for (const refusal of verdict.refusals) {
+                typedEmit(scope, 'agentfootprint.artifacts.refused', {
+                    op: 'dispatch',
+                    reason: refusal.reason,
+                    ...(refusal.ref !== undefined && { ref: refusal.ref }),
+                    detail: refusal.detail,
+                    tool: toolName,
+                });
+            }
+            return { ok: false, refusal: verdict.refusal };
+        }
+        for (const { meta } of verdict.resolved) {
+            typedEmit(scope, 'agentfootprint.artifacts.resolved', {
+                ref: meta.ref,
+                via: 'get',
+                kind: meta.kind,
+                bytes: meta.bytes,
+                tool: toolName,
+            });
+        }
+        return {
+            ok: true,
+            args: verdict.args,
+            // Absent when nothing resolved (no declared arg was passed): absent
+            // and empty are different facts, and `ctx.wanted` keeps them apart.
+            ...(verdict.resolved.length > 0 && { wanted: verdict.wanted }),
+        };
+    };
+    // ── Typed-HITL ask components at raise time (9.24.0) ───────────────────
+    // The ONE gatekeeper every component-carrying ask passes through before it
+    // is allowed to pause: `askHuman({ component })`, a middleware `ask`, and a
+    // tool's `checkInComponent` all land here. Shape first (the door the value
+    // arrived through is named in the refusal), then the `propsRef` questions
+    // only a raise site can answer — is there a store, and does the ref resolve
+    // in THIS run's scope. A dangling ref is refused at its source, loudly (the
+    // run fails with the teaching error), never handed to a screen to discover:
+    // a pause whose component cannot render is a question a person
+    // half-receives, and silently downgrading a consent gate to prose would be
+    // accepted-and-silently-wrong. Refusals + resolutions land on the record as
+    // `artifacts.refused { op: 'dispatch' }` / `artifacts.resolved` — the same
+    // facts a `wants` resolution files. Asks WITHOUT a component never reach
+    // this function: zero reads, zero events, byte-identical.
+    const assertComponentDeliverable = async (scope, toolName, component, door) => {
+        assertAskComponent(component, door);
+        const ref = component.propsRef;
+        if (ref === undefined)
+            return component;
+        const store = deps.artifactStore;
+        if (store === undefined) {
+            typedEmit(scope, 'agentfootprint.artifacts.refused', {
+                op: 'dispatch',
+                reason: 'no-store',
+                ref,
+                detail: `${door}: component.propsRef set but no artifact store is attached`,
+                tool: toolName,
+            });
+            throw new InvalidAskComponentError('no-store', door, `component.propsRef ('${ref}') is set but no artifact store is attached, so the ` +
+                `screen could never redeem it. Pass \`artifacts\` to Agent.create({ ..., artifacts }) ` +
+                `— inMemoryArtifacts(), fileArtifacts({ directory }) or sqliteArtifacts({ file }) — ` +
+                `or carry the payload inline as component.props.`, ref);
+        }
+        const meta = await store.head(links.runScopeOf(scope), ref);
+        if (meta === null) {
+            typedEmit(scope, 'agentfootprint.artifacts.refused', {
+                op: 'dispatch',
+                reason: 'missing-or-expired',
+                ref,
+                detail: `${door}: component.propsRef does not resolve in this run's scope`,
+                tool: toolName,
+            });
+            throw new InvalidAskComponentError('unresolved-ref', door, `component.propsRef ('${ref}') does not resolve in this run's artifact scope — ` +
+                `missing, expired, or minted under a different scope. Mint the props BEFORE raising ` +
+                `the ask (ctx.artifacts.put(...) in the same run) and pass the ref it returns; a ` +
+                `ref the screen cannot redeem must be refused here, at the source, not discovered ` +
+                `by the person answering.`, ref);
+        }
+        typedEmit(scope, 'agentfootprint.artifacts.resolved', {
+            ref: meta.ref,
+            via: 'head',
+            kind: meta.kind,
+            bytes: meta.bytes,
+            tool: toolName,
+        });
+        return component;
+    };
+    // ── The `present` tool's authoritative result (9.22.0, Leg 2) ──────────
+    // The skip_step pattern: the auto-attached placeholder ran; the stage —
+    // which owns the scope, the store and the emit channel — OVERWRITES its
+    // result with the description snapshot (or the teaching refusal), so
+    // governance rules and the caps compose over what the model will read.
+    // LENS · tool-result · persistent-history
+    // reads: the artifact's description snapshot ← the ArtifactStore port (src/artifacts/present.ts, the owner of head/list)
+    // law: may omit, never deny; every clause anchored to the call it was composed on.
+    const applyPresent = async (scope, call) => {
+        const store = deps.artifactStore;
+        if (store === undefined) {
+            // Unreachable through the Agent (the tool is only attached beside a
+            // store) — kept for the same reason the placeholder text exists.
+            return {
+                ok: false,
+                text: 'present has no artifact store behind it here; nothing was presented.',
+            };
+        }
+        const outcome = await presentArtifact(store, links.runScopeOf(scope), call.args);
+        if (!outcome.ok) {
+            typedEmit(scope, 'agentfootprint.artifacts.refused', {
+                op: 'dispatch',
+                reason: outcome.missedRef !== undefined ? 'missing-or-expired' : 'invalid-input',
+                ...(outcome.missedRef !== undefined && { ref: outcome.missedRef }),
+                detail: outcome.refusal,
+                tool: PRESENT_TOOL_NAME,
+            });
+            return { ok: false, text: outcome.refusal };
+        }
+        const { ref, as, snapshot } = outcome.result;
+        typedEmit(scope, 'agentfootprint.artifacts.resolved', {
+            ref,
+            via: 'head',
+            kind: snapshot.kind,
+            bytes: snapshot.bytes,
+            tool: PRESENT_TOOL_NAME,
+        });
+        typedEmit(scope, 'agentfootprint.artifacts.presented', {
+            ref,
+            as,
+            snapshot: { ...snapshot },
+            toolCallId: call.toolCallId,
+            iteration: call.iteration,
+        });
+        // The snapshot lives INSIDE the tool result — the one thing provider
+        // history keeps typed and durable — so a reloaded conversation can
+        // re-draw the pane, or state honestly why it can't.
+        return { ok: true, text: safeStringify(outcome.result) };
+    };
+    // ── The placement threshold (9.22.0, Leg 3) — ONE judge, every door ────
+    // Called beside every `capResults` site, on the FINALIZED values (after
+    // the tool's own resultCeiling, after the after-tool chain) and before the
+    // truncation net — the stated precedence: author's refusal first, then the
+    // operator's ref-ing, then the last-resort net (which then measures the
+    // ticket). A placed result is a TICKET, not a refusal: the caller's
+    // effects/step bookkeeping proceeds exactly as if the payload had landed.
+    //
+    // ── WHAT ROUTING SEES AFTERWARDS (the coupling, stated at both ends) ───
+    // The substitute returned here becomes `resultStr` below, which is the ONE
+    // string every downstream reader gets: the `role: 'tool'` history message,
+    // `scope.lastToolResult.result`, and each `scope.toolResults[]` entry. Route
+    // `when` predicates and `rule` triggers read exactly that string
+    // (`InjectionContext.lastToolResult` / `toolResults` — the other end of this
+    // comment lives on those fields), so raising or lowering `maxInlineChars`
+    // CAN change which edge fires: a predicate matching on payload text stops
+    // matching once the payload becomes a ticket, and one matching on
+    // `"kind":"tool-result/<tool>"` only ever matches after placement.
+    //
+    // That is the layering, not an accident. The alternative — predicates
+    // reading the pre-placement text while the model reads the ticket — would
+    // route on a string that is not in the conversation, and the whole point of
+    // reading `lastToolResult` is to react to what the MODEL was told. Keep the
+    // two identical: whatever the model reads is what routing judges. (Tool NAME
+    // edges — `onToolReturn` — and `onToolStatus` are unaffected either way;
+    // neither reads the result text.)
+    const placeResults = async (scope, call, values, eligible) => {
+        const placement = deps.placement;
+        if (placement === undefined || deps.artifactStore === undefined || !eligible)
+            return values;
+        const text = typeof values.modelResult === 'string'
+            ? values.modelResult
+            : safeStringify(values.modelResult);
+        if (text.length <= placement.maxInlineChars)
+            return values;
+        const bound = links.toolArtifacts(scope, call.toolName, call.toolCallId);
+        let meta;
+        try {
+            // The payload stored is the EXACT text the model would have read —
+            // byte-faithful, so a consumer redeems precisely what was displaced.
+            // `mediaType` states what that text is: a JSON serialization when the
+            // tool returned a value, plain text when it returned a string.
+            meta = await bound.artifacts.put({
+                // The tool's own `resultKind` when it declared one (9.70.0), the
+                // framework's `tool-result/<name>` when it did not. Resolved HERE
+                // rather than threaded through the five dispatch doors: `lookupTool`
+                // is the closure's one resolver (registry + this iteration's cached
+                // provider list), so a sixth door added later cannot forget to carry
+                // the declaration — the `capResults` landmine, avoided by shape.
+                kind: placedResultKind(call.toolName, links.lookupTool(call.toolName)?.resultKind),
+                mediaType: typeof values.modelResult === 'string' ? 'text/plain' : 'application/json',
+                data: text,
+                label: `${call.toolName} result`,
+            });
+        }
+        catch (err) {
+            // The store could not take it (a payload over the whole scope budget,
+            // say). The refusal is already on the record via the capability sink;
+            // the honest fallback is today's path — the truncation net still
+            // measures what placement could not lift. Named in dev mode.
+            if (isDevMode()) {
+                // eslint-disable-next-line no-console
+                console.warn(`agentfootprint placement: tool '${call.toolName}' result (${text.length} chars) ` +
+                    `exceeded the ${placement.maxInlineChars}-char threshold but could not be ` +
+                    `stored: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return values;
+        }
+        const substitute = placedToolResult(call.toolName, meta, text.length, placement.maxInlineChars);
+        return {
+            // One ticket when the two channels carry one value — the capResults
+            // law. A value that differs from what the model reads ONLY by the
+            // record-only coverage fields (`coverage/read.ts` · `strippedOnly`) is
+            // one value too: the fields still ride `tools.absent` /
+            // `tools.coverage_declared`, and `tool_end.result` must not keep a
+            // payload placement exists to keep off the record. A chain-transformed
+            // `result` keeps its own truth and meets the truncation net below,
+            // exactly as before.
+            result: values.result === values.modelResult || strippedOnly(values.result, values.modelResult)
+                ? substitute
+                : values.result,
+            modelResult: substitute,
+        };
+    };
+    return { resolveWantsAtDispatch, assertComponentDeliverable, applyPresent, placeResults };
+}
+//# sourceMappingURL=artifactsOperations.js.map