agentfootprint 13.0.0 → 14.0.0

package/dist/core/agent/stages/toolCalls/helpers/periodWarnings.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._resetPeriodUnjudgedWarnings = exports.warnToolPeriodUnjudged = exports.warnPeriodUnjudged = void 0;
+const footprintjs_1 = require("footprintjs");
+/** Tools already told that their declared period has no judge — once per tool per process. */
+const periodUnjudgedWarned = new Set();
+/**
+ * A result declared a `period` on an agent whose results layer is NOT mounted
+ * (honesty step 7b): the period is recorded — it is the tool's declaration —
+ * but no verdict is filed, so the answer's standing cannot read it. Configured
+ * and inert must never look like configured and working, so dev mode says so,
+ * once per tool per process, naming the two arms.
+ */
+function warnPeriodUnjudged(toolName) {
+    if (periodUnjudgedWarned.has(toolName) || !(0, footprintjs_1.isDevMode)())
+        return;
+    if (periodUnjudgedWarned.size < 500)
+        periodUnjudgedWarned.add(toolName);
+    // eslint-disable-next-line no-console
+    console.warn(`agentfootprint results: tool '${toolName}' declared the period its read covered, and this ` +
+        `agent does not mount the results layer, so no period verdict is filed and the answer's ` +
+        `standing cannot read it (the period itself is recorded). Arm it with .resultsLayer() on ` +
+        `the builder, or declare a ToolPeriod on the tool. This warning fires once per tool per ` +
+        `process.`);
+}
+exports.warnPeriodUnjudged = warnPeriodUnjudged;
+/** Tools already told that their `ToolPeriod` has no judge — once per tool per process. */
+const toolPeriodUnjudgedWarned = new Set();
+/**
+ * A tool that declares a `ToolPeriod` was dispatched on an agent whose results
+ * layer is NOT mounted (honesty step 7b). Only a ToolProvider-served tool gets
+ * here — a registered one arms the layer at build — and its calls run, but no
+ * period verdict is filed for them, not even `undeclared`. The twin of
+ * {@link warnPeriodUnjudged} for the tool's declaration: dev mode says so,
+ * once per tool per process, naming the arm.
+ */
+function warnToolPeriodUnjudged(toolName) {
+    if (toolPeriodUnjudgedWarned.has(toolName) || !(0, footprintjs_1.isDevMode)())
+        return;
+    if (toolPeriodUnjudgedWarned.size < 500)
+        toolPeriodUnjudgedWarned.add(toolName);
+    // eslint-disable-next-line no-console
+    console.warn(`agentfootprint results: tool '${toolName}' declares which argument sets its period (a ` +
+        `ToolPeriod), and this agent does not mount the results layer, so no period verdict — not ` +
+        `even 'undeclared' — is filed for its calls and the answer's standing cannot read them. A ` +
+        `ToolProvider served the tool, so the build could not see it: arm the layer with ` +
+        `.resultsLayer() on the builder. This warning fires once per tool per process.`);
+}
+exports.warnToolPeriodUnjudged = warnToolPeriodUnjudged;
+/**
+ * Forget every "no judge for this period" warning issued so far — for a
+ * declared period and for a declared `ToolPeriod`.
+ * @internal test seam — the ledger is process-wide and warn-once.
+ */
+function _resetPeriodUnjudgedWarnings() {
+    periodUnjudgedWarned.clear();
+    toolPeriodUnjudgedWarned.clear();
+}
+exports._resetPeriodUnjudgedWarnings = _resetPeriodUnjudgedWarnings;
+//# sourceMappingURL=periodWarnings.js.map

package/dist/core/agent/stages/toolCalls/helpers/periodWarnings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"periodWarnings.js","sourceRoot":"","sources":["../../../../../../src/core/agent/stages/toolCalls/helpers/periodWarnings.ts"],"names":[],"mappings":";;;AAAA,6CAAwC;AAExC,8FAA8F;AAC9F,MAAM,oBAAoB,GAAG,IAAI,GAAG,EAAU,CAAC;AAE/C;;;;;;GAMG;AACH,SAAgB,kBAAkB,CAAC,QAAgB;IACjD,IAAI,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAA,uBAAS,GAAE;QAAE,OAAO;IAC/D,IAAI,oBAAoB,CAAC,IAAI,GAAG,GAAG;QAAE,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACxE,sCAAsC;IACtC,OAAO,CAAC,IAAI,CACV,iCAAiC,QAAQ,mDAAmD;QAC1F,yFAAyF;QACzF,0FAA0F;QAC1F,yFAAyF;QACzF,UAAU,CACb,CAAC;AACJ,CAAC;AAXD,gDAWC;AAED,2FAA2F;AAC3F,MAAM,wBAAwB,GAAG,IAAI,GAAG,EAAU,CAAC;AAEnD;;;;;;;GAOG;AACH,SAAgB,sBAAsB,CAAC,QAAgB;IACrD,IAAI,wBAAwB,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAA,uBAAS,GAAE;QAAE,OAAO;IACnE,IAAI,wBAAwB,CAAC,IAAI,GAAG,GAAG;QAAE,wBAAwB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAChF,sCAAsC;IACtC,OAAO,CAAC,IAAI,CACV,iCAAiC,QAAQ,+CAA+C;QACtF,2FAA2F;QAC3F,2FAA2F;QAC3F,kFAAkF;QAClF,+EAA+E,CAClF,CAAC;AACJ,CAAC;AAXD,wDAWC;AAED;;;;GAIG;AACH,SAAgB,4BAA4B;IAC1C,oBAAoB,CAAC,KAAK,EAAE,CAAC;IAC7B,wBAAwB,CAAC,KAAK,EAAE,CAAC;AACnC,CAAC;AAHD,oEAGC"}

package/dist/core/agent/stages/toolCalls/helpers/readSkillRefusal.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeReadSkillRefusal = void 0;
+// LENS · tool-result · persistent-history
+// reads: hops/open ← deps.allowedSkillIds + deps.openSkillIds, each through scope.hiddenSkillIds via spoken()
+//        target class ← skillGraph.ts · classifySkillTarget, carried in, not re-derived
+//        menu/turnStartedBy ← scope.turnRoute (the routing verdict, whole, not a boolean)
+// law: may omit, never deny; every clause anchored to the call it was composed on.
+/**
+ * THE ONE COMPOSER of every `read_skill` refusal (9.86.0) — reachability,
+ * posture and tree, from one set of inputs.
+ *
+ * ── WHY ONE ─────────────────────────────────────────────────────────────
+ *
+ * There were two, and they disagreed. `skillRefusal` named "Reachable skills:
+ * beta" from the graph's raw hop set; `postureRefusal`, forty lines below it in
+ * the same gate, answered a model that took that offer up with "read_skill here
+ * reaches only the open skills: gamma". Same call, same turn, opposite claims —
+ * and the second one cost a refusal from the escalation budget to discover.
+ * Neither had heard of the role filter, so both could name a skill the caller's
+ * policy hides. One composer, handed the FILTERED sets and the posture that
+ * will judge the next pick, cannot contradict itself that way.
+ *
+ * ── THE TENSE DISCIPLINE (the law `selfCallNotice` is written against) ──
+ *
+ * A tool result is composed on iteration N and re-read by the model on every
+ * later call of the turn, including the tool-less wrap-up. So every clause here
+ * is a PAST fact about ONE named call — the call the model made `read_skill`
+ * on — anchored by the phrase "that call", never by deixis ("this turn", "the
+ * call you just made") and never by a forecast ("you can call", "pick one of
+ * these"). What the model may do NEXT is owned by the `read_skill` DESCRIPTION,
+ * which is recomposed for every single request and may therefore speak in the
+ * present. Two owners, one tense each, and they can no longer disagree.
+ *
+ * ── AND WHY IT NEVER NAMES A HOP THE POSTURE WOULD DECLINE ──────────────
+ *
+ * Under `'rails'` the model does not route at all; under `'guard'` it routes
+ * only from an outstanding menu. Naming hops there is an offer the very next
+ * arm of this gate refuses. So those arms name no hop: they say who DID route,
+ * and (when there are any) which open skills were admitted anyway — open skills
+ * never reach the posture arm, so that clause cannot be contradicted.
+ *
+ * ── AND WHY AN EMPTY LIST IS NEVER A DENIAL ─────────────────────────────
+ *
+ * Every set arrives as {@link SpokenIds}, which carries whether the UNFILTERED
+ * set held anything. That is the difference between "nothing was reachable" and
+ * "nothing reachable may be named", and this composer used to say the first
+ * when the second was true — over a graph that was routing the cursor the whole
+ * time. Where the filter empties a set, the clause is omitted. A model told the
+ * map is a dead end stops asking for the door it may not be shown.
+ *
+ * Exported so a producer registry can list it beside the other model-facing
+ * composers rather than re-deriving what it says.
+ */
+function composeReadSkillRefusal(args) {
+    const { requestedId, targetClass, cursorId, hops, openIds, isTree, posture, menuOffered, turnStartedBy, cursorWithheld, } = args;
+    const head = `read_skill("${requestedId}") was not granted on that call: `;
+    // Open skills are the one list every arm may name: they are admitted from
+    // every cursor and no posture governs them (the posture arm below is reached
+    // only by hops), so naming them cannot be falsified by the next call. There is
+    // no negative arm here and there never was — an unnamed open set is simply
+    // omitted, which is the shape the two arms below now share.
+    const openClause = openIds.named.length > 0
+        ? ` Open skills were admitted on that call: ${openIds.named.join(', ')}.`
+        : '';
+    if (posture !== undefined) {
+        if (posture === 'rails') {
+            return (`${head}this graph's 'rails' posture reserves routing to the framework — turn ` +
+                `starts resolve by declared rule or scorer and transitions by declared routes — ` +
+                `so a model pick was not admitted on that call.${openClause}`);
+        }
+        if (menuOffered !== undefined && menuOffered.named.length > 0) {
+            return (`${head}this graph's 'guard' posture admits a routing pick only from the menu the ` +
+                `framework offered, and '${requestedId}' was not on it. The menu outstanding when ` +
+                `that call was made: ${menuOffered.named.join(', ')}.${openClause}`);
+        }
+        // A menu WAS outstanding and not one of its ids may be named to this
+        // caller. Neither of the other two sentences is available: naming the menu
+        // would leak it, and "no menu was outstanding" is false — as is the
+        // "declared routes moved the cursor instead" clause that rides with it,
+        // which is a second assertion about a turn that did not route that way. So
+        // this arm says the one thing that is true of that call and stops.
+        if (menuOffered !== undefined && menuOffered.held) {
+            return (`${head}this graph's 'guard' posture admits a routing pick only from the menu the ` +
+                `framework offered, and '${requestedId}' was not admitted on that call.${openClause}`);
+        }
+        // What the gate KNOWS about why no menu was outstanding is `TurnRoute.by`,
+        // and each value is a different finished fact. Nothing is asserted about
+        // how the cursor came to be where it was beyond that — the old tail,
+        // "Declared routes moved the cursor instead.", was composed for every
+        // value and was true of none of them in particular.
+        const startClause = turnStartedBy === 'entry' || turnStartedBy === 'intent'
+            ? " — the turn's start had already been resolved decisively"
+            : turnStartedBy === 'continuity'
+                ? ' — the cursor had been carried over from the previous turn'
+                : turnStartedBy === 'menu'
+                    ? ' — the menu had already been resolved by an earlier pick'
+                    : turnStartedBy === 'decider'
+                        ? " — the menu had been resolved by the configured decider before the turn's first call"
+                        : '';
+        return (`${head}this graph's 'guard' posture admits a routing pick only while the framework ` +
+            `has declared ambiguity, and no menu was outstanding when that call was made` +
+            `${startClause}.${openClause}`);
+    }
+    if (isTree === true) {
+        return (`${head}this map is a decision tree. A tree routes by predicate on every iteration ` +
+            `and keeps no cursor, so there was nothing for that pick to move and ` +
+            `'${requestedId}' was not activated by it.${openClause}`);
+    }
+    // Reachability. `targetClass` is 'unreachable' by the time the gate calls
+    // this arm — 'self' is answered by the notice, 'hop' and 'open' are admitted
+    // — and it is carried rather than re-derived so the sentence and the verdict
+    // read the same classification.
+    // Three anchors, not two: a named cursor, a cursor this caller may not be
+    // told the name of, and a genuine cold start. The middle one used to print
+    // the raw id — the one name the description's own law withholds.
+    const from = cursorId !== undefined
+        ? `'${cursorId}'`
+        : cursorWithheld === true
+            ? 'the skill the cursor stood in'
+            : "the turn's start";
+    // The gate reaches this arm only with `'unreachable'`; the weaker sentence is
+    // for a caller that refused an admissible class for a reason of its own, and
+    // it is deliberately not an invented explanation of one.
+    const reason = targetClass === 'unreachable'
+        ? `'${requestedId}' was not reachable from ${from}.`
+        : `'${requestedId}' was not admitted from ${from}.`;
+    // OMIT, NEVER DENY. Three cases, not two: hops to name, no hops at all, and
+    // hops the graph holds that this caller may not be told about. The third used
+    // to fall into the second and assert "No skill was reachable from 'alpha'"
+    // while the graph routed 'alpha' to a skill the role hides — a denial of what
+    // the run holds, and the one shape omission is always safe against.
+    const hopClause = hops.named.length > 0
+        ? ` Skills reachable from ${from} when that call was made: ${hops.named.join(', ')}.`
+        : hops.held
+            ? ''
+            : ` No skill was reachable from ${from} when that call was made.`;
+    return `${head}${reason}${hopClause}${openClause}`;
+}
+exports.composeReadSkillRefusal = composeReadSkillRefusal;
+//# sourceMappingURL=readSkillRefusal.js.map

package/dist/core/agent/stages/toolCalls/helpers/readSkillRefusal.js.map

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

package/dist/core/agent/stages/toolCalls/helpers/sourceNote.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOURCES_NOTE = void 0;
+/**
+ * The inputs layer's note options for a call whose tool's served schema
+ * carries `_findings.from` under declared sources (`arguments/serve.ts` ·
+ * `ServeOptions`) — one frozen value, handed per call.
+ */
+exports.SOURCES_NOTE = Object.freeze({ sources: true });
+//# sourceMappingURL=sourceNote.js.map

package/dist/core/agent/stages/toolCalls/helpers/sourceNote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sourceNote.js","sourceRoot":"","sources":["../../../../../../src/core/agent/stages/toolCalls/helpers/sourceNote.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACU,QAAA,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,IAAa,EAAE,CAAC,CAAC"}

package/dist/core/agent/stages/toolCalls/helpers/unscopedRun.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNSCOPED_RUN = void 0;
+/**
+ * The ledger key for a handler built with no `currentRun` accessor — a
+ * hand-composed dispatch loop in a test, never an Agent (which always wires
+ * it).
+ *
+ * One shared bucket, stated rather than hidden: without a run id there is
+ * nothing to tell two runs apart by, and the honest consequence is that such a
+ * loop counts across them. It cannot leak anything — the ledger holds
+ * fingerprints — and the only visible effect is a note arriving one call early.
+ */
+exports.UNSCOPED_RUN = '#no-run-id';
+//# sourceMappingURL=unscopedRun.js.map

package/dist/core/agent/stages/toolCalls/helpers/unscopedRun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unscopedRun.js","sourceRoot":"","sources":["../../../../../../src/core/agent/stages/toolCalls/helpers/unscopedRun.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;GASG;AACU,QAAA,YAAY,GAAG,YAAY,CAAC"}

package/dist/core/agent/stages/toolCalls/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildToolCallsHandler = exports.producerCorpusOf = exports.notDispatchedResult = exports._resetPeriodUnjudgedWarnings = exports.pausedBatchOf = exports.composeReadSkillRefusal = exports.unknownToolResult = exports.notServedResult = exports.atMountedCursor = void 0;
+const compose_js_1 = require("./compose.js");
+const dispatchCall_js_1 = require("./execution/dispatchCall.js");
+const execute_js_1 = require("./batch/execute.js");
+const handler_js_1 = require("./resume/handler.js");
+var mountedCursor_js_1 = require("./helpers/mountedCursor.js");
+Object.defineProperty(exports, "atMountedCursor", { enumerable: true, get: function () { return mountedCursor_js_1.atMountedCursor; } });
+var dispatchRefusals_js_1 = require("./helpers/dispatchRefusals.js");
+Object.defineProperty(exports, "notServedResult", { enumerable: true, get: function () { return dispatchRefusals_js_1.notServedResult; } });
+Object.defineProperty(exports, "unknownToolResult", { enumerable: true, get: function () { return dispatchRefusals_js_1.unknownToolResult; } });
+var readSkillRefusal_js_1 = require("./helpers/readSkillRefusal.js");
+Object.defineProperty(exports, "composeReadSkillRefusal", { enumerable: true, get: function () { return readSkillRefusal_js_1.composeReadSkillRefusal; } });
+var paused_js_1 = require("./batch/paused.js");
+Object.defineProperty(exports, "pausedBatchOf", { enumerable: true, get: function () { return paused_js_1.pausedBatchOf; } });
+var periodWarnings_js_1 = require("./helpers/periodWarnings.js");
+Object.defineProperty(exports, "_resetPeriodUnjudgedWarnings", { enumerable: true, get: function () { return periodWarnings_js_1._resetPeriodUnjudgedWarnings; } });
+var settle_js_1 = require("./batch/settle.js");
+Object.defineProperty(exports, "notDispatchedResult", { enumerable: true, get: function () { return settle_js_1.notDispatchedResult; } });
+var producerCorpus_js_1 = require("./evidence/producerCorpus.js");
+Object.defineProperty(exports, "producerCorpusOf", { enumerable: true, get: function () { return producerCorpus_js_1.producerCorpusOf; } });
+/** Compose one native tool-call handler; runtime call state remains invocation-local. */
+function buildToolCallsHandler(deps) {
+    const operations = (0, compose_js_1.composeToolCallOperations)(deps);
+    const dispatchCall = (0, dispatchCall_js_1.buildCallDispatch)(deps, operations);
+    return {
+        execute: (0, execute_js_1.buildToolBatchExecution)(deps, operations, dispatchCall),
+        resume: (0, handler_js_1.buildToolResume)(deps, operations),
+    };
+}
+exports.buildToolCallsHandler = buildToolCallsHandler;
+//# sourceMappingURL=index.js.map

package/dist/core/agent/stages/toolCalls/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/core/agent/stages/toolCalls/index.ts"],"names":[],"mappings":";;;AAGA,6CAAyD;AACzD,iEAAgE;AAChE,mDAA6D;AAC7D,oDAAsD;AAEtD,+DAA6D;AAApD,mHAAA,eAAe,OAAA;AACxB,qEAAmF;AAA1E,sHAAA,eAAe,OAAA;AAAE,wHAAA,iBAAiB,OAAA;AAC3C,qEAAwE;AAA/D,8HAAA,uBAAuB,OAAA;AAChC,+CAAkD;AAAzC,0GAAA,aAAa,OAAA;AAEtB,iEAA2E;AAAlE,iIAAA,4BAA4B,OAAA;AACrC,+CAAwD;AAA/C,gHAAA,mBAAmB,OAAA;AAC5B,kEAAgE;AAAvD,qHAAA,gBAAgB,OAAA;AAGzB,yFAAyF;AACzF,SAAgB,qBAAqB,CACnC,IAA0B;IAE1B,MAAM,UAAU,GAAG,IAAA,sCAAyB,EAAC,IAAI,CAAC,CAAC;IACnD,MAAM,YAAY,GAAG,IAAA,mCAAiB,EAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACzD,OAAO;QACL,OAAO,EAAE,IAAA,oCAAuB,EAAC,IAAI,EAAE,UAAU,EAAE,YAAY,CAAC;QAChE,MAAM,EAAE,IAAA,4BAAe,EAAC,IAAI,EAAE,UAAU,CAAC;KAC1C,CAAC;AACJ,CAAC;AATD,sDASC"}

package/dist/core/agent/stages/toolCalls/observation/callSettlement.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordCallSettlement = void 0;
+/** The existing synchronous callSettlement phase; no new await or checkpoint carrier. */
+function recordCallSettlement(scope, frame) {
+    // The call has settled: its script row, read from the runner's facts
+    // first, then from how the call settled — never from the delivery
+    // (`ceilingRefused` rides the row as `resultWithheld`).
+    frame.fileScript(scope, {
+        tool: frame.tool,
+        toolName: frame.tc.name,
+        toolCallId: frame.tc.id,
+        iteration: frame.iteration,
+        proposed: frame.proposedProgram,
+        submitted: frame.execution.executed
+            ? frame.execution.submittedProgram
+            : frame.programOfCall(frame.tool, frame.callArguments.callArgs),
+        settlement: !frame.execution.executed
+            ? 'not-entered'
+            : frame.execution.executeThrew
+                ? 'threw'
+                : 'returned',
+        ...(frame.execution.ranCode !== undefined && { facts: frame.execution.ranCode }),
+        withheld: frame.execution.withheldOverCeiling,
+    });
+    frame.emitToolEnd(scope, frame.tc.name, {
+        toolCallId: frame.tc.id,
+        result: frame.capped.result,
+        durationMs: frame.durationMs,
+        ...(frame.outcome.error === true && { error: true }),
+        // The tool's own declared outcome (9.19.0) — additive, envelope
+        // tools only.
+        ...(frame.outcome.toolStatus !== undefined && { status: frame.outcome.toolStatus }),
+        // Each only when a CONFIGURED RULE acted — an `onToolResult` link or
+        // the cap (`modelResult`), an `onToolCall` link or the tool's own
+        // redaction (`changedArgKeys`), a permission policy or a link that
+        // refused (`notExecuted`). With no rule, `tool_end` is the bytes it
+        // always was: a call that failed to run on its own (an unknown name,
+        // an args rejection, a credential block) keeps saying so with
+        // `error: true` alone.
+        ...(frame.modelResult !== frame.capped.result && { modelResult: frame.modelResult }),
+        ...(frame.execution.executed &&
+            frame.changedKeys.length > 0 && { changedArgKeys: frame.changedKeys }),
+        ...(frame.execution.denied && { notExecuted: true }),
+    }, frame.execution.executed, frame.outcome.toolEnvelope?.status, frame.execution.negativeDispatch?.resultId, frame.callArguments.callArgs);
+}
+exports.recordCallSettlement = recordCallSettlement;
+//# sourceMappingURL=callSettlement.js.map

package/dist/core/agent/stages/toolCalls/observation/callSettlement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"callSettlement.js","sourceRoot":"","sources":["../../../../../../src/core/agent/stages/toolCalls/observation/callSettlement.ts"],"names":[],"mappings":";;;AA6BA,yFAAyF;AACzF,SAAgB,oBAAoB,CAClC,KAA6B,EAC7B,KAAgC;IAEhC,qEAAqE;IACrE,kEAAkE;IAClE,wDAAwD;IACxD,KAAK,CAAC,UAAU,CAAC,KAAK,EAAE;QACtB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI;QACvB,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,EAAE;QACvB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,QAAQ,EAAE,KAAK,CAAC,eAAe;QAC/B,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,QAAQ;YACjC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,gBAAgB;YAClC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC;QACjE,UAAU,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ;YACnC,CAAC,CAAC,aAAa;YACf,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,YAAY;gBAC9B,CAAC,CAAC,OAAO;gBACT,CAAC,CAAC,UAAU;QACd,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;QAChF,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC,mBAAmB;KAC9C,CAAC,CAAC;IACH,KAAK,CAAC,WAAW,CACf,KAAK,EACL,KAAK,CAAC,EAAE,CAAC,IAAI,EACb;QACE,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,EAAE;QACvB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM;QAC3B,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,KAAK,IAAI,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACpD,gEAAgE;QAChE,cAAc;QACd,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;QACnF,qEAAqE;QACrE,kEAAkE;QAClE,mEAAmE;QACnE,oEAAoE;QACpE,qEAAqE;QACrE,8DAA8D;QAC9D,uBAAuB;QACvB,GAAG,CAAC,KAAK,CAAC,WAAW,KAAK,KAAK,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC;QACpF,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ;YAC1B,KAAK,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC;QACxE,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,IAAI,EAAE,WAAW,EAAE,IAAa,EAAE,CAAC;KAC9D,EACD,KAAK,CAAC,SAAS,CAAC,QAAQ,EACxB,KAAK,CAAC,OAAO,CAAC,YAAY,EAAE,MAAM,EAClC,KAAK,CAAC,SAAS,CAAC,gBAAgB,EAAE,QAAQ,EAC1C,KAAK,CAAC,aAAa,CAAC,QAAQ,CAC7B,CAAC;AACJ,CAAC;AApDD,oDAoDC"}

package/dist/core/agent/stages/toolCalls/observation/observationsOperations.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildToolObservationsOperations = void 0;
+const frozenCopy_js_1 = require("../../../../../lib/frozenCopy.js");
+const typedEmit_js_1 = require("../../../../../recorders/core/typedEmit.js");
+const toolLedger_js_1 = require("../../../../../answer-validation/toolLedger.js");
+const capture_js_1 = require("../../../negativeClaims/capture.js");
+/** Compose the existing observations callbacks once for this handler. */
+function buildToolObservationsOperations(deps) {
+    /** `emitToolEnd`'s twin: the call is open in the ledger until its `tool_end` lands. */
+    const emitToolStart = (scope, payload) => {
+        // A listener sees the call's frozen copy — the dispatch loop's shared one
+        // when it hands that over — never the arguments the tool runs with: one
+        // that set `amount = 9000` used to refund 9000. Arguments no copy can be
+        // made of are carried as a frozen, detached projection — what JSON writes
+        // of them — never as their live objects.
+        const args = (0, frozenCopy_js_1.frozenView)(payload.args) ?? (0, frozenCopy_js_1.frozenProjectionOf)(payload.args);
+        (0, typedEmit_js_1.typedEmit)(scope, 'agentfootprint.stream.tool_start', { ...payload, args });
+        const ledger = deps.toolCallLedger;
+        if (ledger === undefined)
+            return;
+        const prior = scope.toolCallLedger;
+        const next = (0, toolLedger_js_1.startToolCall)(prior, payload.toolCallId, ledger.maxCalls);
+        if (next !== prior)
+            scope.toolCallLedger = next;
+    };
+    /**
+     * THE one door for a `stream.tool_end` bracket in this handler. Every
+     * dispatch path here closes a call through it, so the run's tool-call ledger (when `answerValidation` keeps
+     * one) lists exactly the brackets the stream reported — never arguments,
+     * never results. `ran` is whether the tool's own code ran: a call a person
+     * declined or a rule refused without an `error` is listed `not-run`, never `ok`.
+     */
+    const emitToolEnd = (scope, toolName, payload, ran, declaredStatus = payload.status, negativeResultId, refusalArgs) => {
+        if (deps.negativeClaimsArmed === true) {
+            (0, capture_js_1.settleNegativeCall)(scope, negativeResultId, (0, toolLedger_js_1.toolOutcomeOf)(payload, ran));
+            if (!ran ||
+                payload.error ||
+                ['invalid', 'denied', 'failure'].includes(declaredStatus ?? '')) {
+                (0, capture_js_1.captureNegativeRefusal)(scope, toolName, payload.result, refusalArgs);
+                if (payload.modelResult !== undefined)
+                    (0, capture_js_1.captureNegativeRefusal)(scope, toolName, payload.modelResult, refusalArgs);
+            }
+        }
+        (0, typedEmit_js_1.typedEmit)(scope, 'agentfootprint.stream.tool_end', payload);
+        const ledger = deps.toolCallLedger;
+        if (ledger === undefined)
+            return;
+        const prior = scope.toolCallLedger;
+        const next = (0, toolLedger_js_1.appendToolCall)(prior, { name: toolName, callId: payload.toolCallId, outcome: (0, toolLedger_js_1.toolOutcomeOf)(payload, ran) }, ledger.maxCalls, 
+        // A tool that declared `pending` returned before its own work settled —
+        // read off what the TOOL declared, before a ceiling or contract refusal
+        // rewrote the bracket's status.
+        declaredStatus !== 'pending' && payload.status !== 'pending');
+        if (next !== prior)
+            scope.toolCallLedger = next;
+    };
+    return { emitToolStart, emitToolEnd };
+}
+exports.buildToolObservationsOperations = buildToolObservationsOperations;
+//# sourceMappingURL=observationsOperations.js.map

package/dist/core/agent/stages/toolCalls/observation/observationsOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observationsOperations.js","sourceRoot":"","sources":["../../../../../../src/core/agent/stages/toolCalls/observation/observationsOperations.ts"],"names":[],"mappings":";;;AAIA,oEAAkF;AAClF,6EAAuE;AACvE,kFAIwD;AACxD,mEAAgG;AAGhG,yEAAyE;AACzE,SAAgB,+BAA+B,CAC7C,IAA0E;IAE1E,uFAAuF;IACvF,MAAM,aAAa,GAAG,CACpB,KAA6B,EAC7B,OAA8E,EACxE,EAAE;QACR,0EAA0E;QAC1E,wEAAwE;QACxE,yEAAyE;QACzE,0EAA0E;QAC1E,yCAAyC;QACzC,MAAM,IAAI,GAAG,IAAA,0BAAU,EAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAA,kCAAkB,EAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC1E,IAAA,wBAAS,EAAC,KAAK,EAAE,kCAAkC,EAAE,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3E,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC;QACnC,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO;QACjC,MAAM,KAAK,GAAG,KAAK,CAAC,cAAc,CAAC;QACnC,MAAM,IAAI,GAAG,IAAA,6BAAa,EAAC,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;QACvE,IAAI,IAAI,KAAK,KAAK;YAAE,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC;IAClD,CAAC,CAAC;IAEF;;;;;;OAMG;IACH,MAAM,WAAW,GAAG,CAClB,KAA6B,EAC7B,QAAgB,EAChB,OAA4E,EAC5E,GAAY,EACZ,iBAAqC,OAAO,CAAC,MAAM,EACnD,gBAAyB,EACzB,WAA+C,EACzC,EAAE;QACR,IAAI,IAAI,CAAC,mBAAmB,KAAK,IAAI,EAAE,CAAC;YACtC,IAAA,+BAAkB,EAAC,KAAK,EAAE,gBAAgB,EAAE,IAAA,6BAAa,EAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;YACzE,IACE,CAAC,GAAG;gBACJ,OAAO,CAAC,KAAK;gBACb,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,cAAc,IAAI,EAAE,CAAC,EAC/D,CAAC;gBACD,IAAA,mCAAsB,EAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;gBACrE,IAAI,OAAO,CAAC,WAAW,KAAK,SAAS;oBACnC,IAAA,mCAAsB,EAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;YAC9E,CAAC;QACH,CAAC;QACD,IAAA,wBAAS,EAAC,KAAK,EAAE,gCAAgC,EAAE,OAAO,CAAC,CAAC;QAC5D,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC;QACnC,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO;QACjC,MAAM,KAAK,GAAG,KAAK,CAAC,cAAc,CAAC;QACnC,MAAM,IAAI,GAAG,IAAA,8BAAc,EACzB,KAAK,EACL,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE,OAAO,EAAE,IAAA,6BAAa,EAAC,OAAO,EAAE,GAAG,CAAC,EAAE,EACpF,MAAM,CAAC,QAAQ;QACf,wEAAwE;QACxE,wEAAwE;QACxE,gCAAgC;QAChC,cAAc,KAAK,SAAS,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,CAC7D,CAAC;QACF,IAAI,IAAI,KAAK,KAAK;YAAE,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC;IAClD,CAAC,CAAC;IAEF,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC;AACxC,CAAC;AAnED,0EAmEC"}

package/dist/core/agent/stages/toolCalls/observation/progressOperations.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildToolProgressOperations = void 0;
+const footprintjs_1 = require("footprintjs");
+const typedEmit_js_1 = require("../../../../../recorders/core/typedEmit.js");
+/** Compose the existing progress callbacks once for this handler. */
+function buildToolProgressOperations(links) {
+    const toolProgress = (scope, call) => ({
+        progress: (payload) => {
+            try {
+                (0, typedEmit_js_1.typedEmit)(scope, 'agentfootprint.stream.tool_progress', {
+                    toolCallId: call.toolCallId,
+                    toolName: call.toolName,
+                    iteration: call.iteration,
+                    payload,
+                });
+            }
+            catch (err) {
+                if ((0, footprintjs_1.isDevMode)() && !links.progressWarned.has(call.toolName)) {
+                    links.progressWarned.add(call.toolName);
+                    // eslint-disable-next-line no-console
+                    console.warn(`[agentfootprint] tool '${call.toolName}': ctx.progress could not file a report ` +
+                        `(${err instanceof Error ? err.message : String(err)}). The call itself is ` +
+                        'unaffected — progress is telemetry, and a dropped report never fails a tool.');
+                }
+            }
+        },
+    });
+    return { toolProgress };
+}
+exports.buildToolProgressOperations = buildToolProgressOperations;
+//# sourceMappingURL=progressOperations.js.map

package/dist/core/agent/stages/toolCalls/observation/progressOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progressOperations.js","sourceRoot":"","sources":["../../../../../../src/core/agent/stages/toolCalls/observation/progressOperations.ts"],"names":[],"mappings":";;;AAAA,6CAAyD;AAGzD,6EAAuE;AAOvE,qEAAqE;AACrE,SAAgB,2BAA2B,CACzC,KAAkC;IAElC,MAAM,YAAY,GAAG,CACnB,KAA6B,EAC7B,IAIC,EACuC,EAAE,CAAC,CAAC;QAC5C,QAAQ,EAAE,CAAC,OAAgB,EAAQ,EAAE;YACnC,IAAI,CAAC;gBACH,IAAA,wBAAS,EAAC,KAAK,EAAE,qCAAqC,EAAE;oBACtD,UAAU,EAAE,IAAI,CAAC,UAAU;oBAC3B,QAAQ,EAAE,IAAI,CAAC,QAAQ;oBACvB,SAAS,EAAE,IAAI,CAAC,SAAS;oBACzB,OAAO;iBACR,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,IAAA,uBAAS,GAAE,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC5D,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;oBACxC,sCAAsC;oBACtC,OAAO,CAAC,IAAI,CACV,0BAA0B,IAAI,CAAC,QAAQ,0CAA0C;wBAC/E,IAAI,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,wBAAwB;wBAC5E,8EAA8E,CACjF,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;KACF,CAAC,CAAC;IAEH,OAAO,EAAE,YAAY,EAAE,CAAC;AAC1B,CAAC;AAlCD,kEAkCC"}