agentfootprint 9.40.0 → 9.43.0

package/dist/core/agent/coverage/ledger.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * ledger — what a clean result does NOT rule out.
+ *
+ * Pattern: a wrapper the framework recognizes, minted by a helper (the
+ *          `absent()` shape one level up: same vocabulary, different claim).
+ * Role:    core/ layer, pure. `coverage()` is what a tool author writes;
+ *          `readCoverageLedger` is what the dispatch loop calls.
+ * Emits:   N/A (the caller emits `agentfootprint.tools.coverage_declared`).
+ *
+ * ## The problem, stated as narrowly as it deserves
+ *
+ * An agent answers confidently from partial coverage. "Everything looks fine"
+ * is produced from four checks that passed, and arrives with no way to tell
+ * whether *fine* means **verified** or **unexamined** — whether the fifth
+ * thing was healthy or was never looked at. The evidence gate (9.35.0) is the
+ * sibling of this: the gate catches invented VALUES, this catches unstated
+ * LIMITS. Both are ways an answer can be false while every token in it is
+ * real.
+ *
+ * A ledger is not a caveat and not a disclaimer. It is three lists the TOOL
+ * knows and the model does not: what it checked, what it did not check, and
+ * what it can never cover. Only the tool knows the third one, which is why
+ * this cannot be prompt engineering.
+ *
+ * ## Why the wrapper, and not a field on the result
+ *
+ * The alternative — teaching the framework to read a `coverage` key off any
+ * returned object — would make every domain object that happens to have one
+ * change behavior. The wrapper is opt-in by construction: `coverage(x, …)`
+ * produces a shape that did not exist before, so nothing that ever ran can
+ * become a ledger by accident. Same argument as the effects envelope's strict
+ * recognizer, same guarantee.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coverageOfLedger = exports.readCoverageLedger = exports.coverage = exports.COVERAGE_NOTE = exports.COVERAGE_MARKER = void 0;
+const items_js_1 = require("./items.js");
+/** The reserved key that makes a ledger recognizable. */
+exports.COVERAGE_MARKER = 'af_coverage';
+/**
+ * The static sentence every ledger carries. The last clause is the OFFER half
+ * of survival — the model is told to carry the limits into its answer. The
+ * ENFORCEMENT half (`.limitsTravelWithTheAnswer()`) does not depend on the
+ * model obeying it; see `answer.ts` for why both exist.
+ */
+exports.COVERAGE_NOTE = 'This result covers only what `checked` lists. `not_checked` is ground this call did not ' +
+    'look at, and `cannot_cover` is ground this tool can never see — a clean result here is ' +
+    'NOT evidence about either, and no retry changes `cannot_cover`. Carry these limits into ' +
+    'any answer you build on this result.';
+/**
+ * Return a verdict with its own boundary attached.
+ *
+ * The model reads `{ af_coverage: {…}, result: <your value> }` — boundary
+ * first, deliberately: a limit placed after a long result is a limit that gets
+ * skimmed past. The framework records the ledger and, with
+ * `.limitsTravelWithTheAnswer()` configured, appends it to the run's final
+ * answer where the model cannot drop it.
+ *
+ * @example the highest-stakes tool in a triage agent
+ *   defineTool({
+ *     name: 'replication_health',
+ *     description: 'Replication health across the estate',
+ *     inputSchema: { type: 'object', properties: {} },
+ *     execute: async () => {
+ *       const { verdict, ndmTimedOut } = await checkReplication();
+ *       return coverage(verdict, {
+ *         checked: ['SRDF pair state on all 4 arrays (live query)'],
+ *         notChecked: ndmTimedOut
+ *           ? [{ what: 'NDM migration sessions', why: 'the API timed out — ask again' }]
+ *           : [],
+ *         cannotCover: [
+ *           { what: 'host-side multipathing', why: 'no collector runs on the ESX hosts' },
+ *         ],
+ *       });
+ *     },
+ *   });
+ */
+function coverage(content, decl) {
+    const fn = 'coverage';
+    if (typeof decl !== 'object' || decl === null) {
+        throw new Error(`${fn}: takes the result and its boundary — coverage(result, { checked?, notChecked?, ` +
+            `cannotCover? }). To return a result with no declared boundary, return it bare.`);
+    }
+    const checked = (0, items_js_1.normalizeCoverageList)(fn, 'checked', decl.checked, false);
+    const notChecked = (0, items_js_1.normalizeCoverageList)(fn, 'notChecked', decl.notChecked, false);
+    const cannotCover = (0, items_js_1.normalizeCoverageList)(fn, 'cannotCover', decl.cannotCover, true);
+    if (checked.length === 0 && notChecked.length === 0 && cannotCover.length === 0) {
+        throw new Error(`${fn}: all three lists are empty, so this ledger declares no boundary at all — it ` +
+            `would tell a reader nothing while looking like it did, which is worse than saying ` +
+            `nothing. Name what you checked, what you skipped, or what you can never see; or ` +
+            `return the result bare.`);
+    }
+    return {
+        af_coverage: {
+            ...(checked.length > 0 && { checked }),
+            ...(notChecked.length > 0 && { not_checked: notChecked }),
+            ...(cannotCover.length > 0 && { cannot_cover: cannotCover }),
+            note: exports.COVERAGE_NOTE,
+        },
+        result: content,
+    };
+}
+exports.coverage = coverage;
+/**
+ * Recognize (or decline to recognize) a value as a covered result. STRICT for
+ * the same reason `readAbsence` is: only a plain object carrying a plain
+ * `af_coverage` object AND a `result` key qualifies.
+ */
+function readCoverageLedger(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return undefined;
+    const rec = value;
+    const marker = rec[exports.COVERAGE_MARKER];
+    if (typeof marker !== 'object' || marker === null || Array.isArray(marker))
+        return undefined;
+    if (!('result' in rec))
+        return undefined;
+    return value;
+}
+exports.readCoverageLedger = readCoverageLedger;
+/** The ledger's coverage, in the normalized three-list shape. */
+function coverageOfLedger(covered) {
+    const m = covered.af_coverage;
+    return {
+        checked: m.checked ?? [],
+        notChecked: m.not_checked ?? [],
+        cannotCover: m.cannot_cover ?? [],
+    };
+}
+exports.coverageOfLedger = coverageOfLedger;
+//# sourceMappingURL=ledger.js.map

package/dist/core/agent/coverage/ledger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger.js","sourceRoot":"","sources":["../../../../src/core/agent/coverage/ledger.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;;;AAEH,yCAAmD;AAGnD,yDAAyD;AAC5C,QAAA,eAAe,GAAG,aAAa,CAAC;AAE7C;;;;;GAKG;AACU,QAAA,aAAa,GACxB,0FAA0F;IAC1F,yFAAyF;IACzF,0FAA0F;IAC1F,sCAAsC,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,SAAgB,QAAQ,CAAI,OAAU,EAAE,IAAyB;IAC/D,MAAM,EAAE,GAAG,UAAU,CAAC;IACtB,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CACb,GAAG,EAAE,kFAAkF;YACrF,gFAAgF,CACnF,CAAC;IACJ,CAAC;IACD,MAAM,OAAO,GAAG,IAAA,gCAAqB,EAAC,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC1E,MAAM,UAAU,GAAG,IAAA,gCAAqB,EAAC,EAAE,EAAE,YAAY,EAAE,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IACnF,MAAM,WAAW,GAAG,IAAA,gCAAqB,EAAC,EAAE,EAAE,aAAa,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;IACrF,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChF,MAAM,IAAI,KAAK,CACb,GAAG,EAAE,+EAA+E;YAClF,oFAAoF;YACpF,kFAAkF;YAClF,yBAAyB,CAC5B,CAAC;IACJ,CAAC;IACD,OAAO;QACL,WAAW,EAAE;YACX,GAAG,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC;YACtC,GAAG,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC;YACzD,GAAG,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,WAAW,EAAE,CAAC;YAC5D,IAAI,EAAE,qBAAa;SACpB;QACD,MAAM,EAAE,OAAO;KAChB,CAAC;AACJ,CAAC;AA5BD,4BA4BC;AAED;;;;GAIG;AACH,SAAgB,kBAAkB,CAAC,KAAc;IAC/C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC1F,MAAM,GAAG,GAAG,KAAgC,CAAC;IAC7C,MAAM,MAAM,GAAG,GAAG,CAAC,uBAAe,CAAC,CAAC;IACpC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;QAAE,OAAO,SAAS,CAAC;IAC7F,IAAI,CAAC,CAAC,QAAQ,IAAI,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IACzC,OAAO,KAAsB,CAAC;AAChC,CAAC;AAPD,gDAOC;AAED,iEAAiE;AACjE,SAAgB,gBAAgB,CAAC,OAAsB;IACrD,MAAM,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC;IAC9B,OAAO;QACL,OAAO,EAAE,CAAC,CAAC,OAAO,IAAI,EAAE;QACxB,UAAU,EAAE,CAAC,CAAC,WAAW,IAAI,EAAE;QAC/B,WAAW,EAAE,CAAC,CAAC,YAAY,IAAI,EAAE;KAClC,CAAC;AACJ,CAAC;AAPD,4CAOC"}

package/dist/core/agent/coverage/read.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * read — the ONE recognizer the tool-dispatch loop calls.
+ *
+ * Pattern: one reader, every dispatch door (the `applyResultCeiling`
+ *          precedent). The batch loop and the credential/resume execute
+ *          boundary both call this at the moment a handler's return lands, so
+ *          a resumed call declares its coverage exactly as an inline one.
+ * Role:    core/ layer, pure. Recognition and normalization only — the caller
+ *          owns the events, the scope write and the delivered status.
+ * Emits:   N/A.
+ *
+ * Zero-cost when unused: two `typeof` checks and a key lookup for every
+ * result that is neither shape, and `undefined` back. Nothing is emitted,
+ * nothing is written, and the value the model reads is the value the tool
+ * returned — byte for byte.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCoverageResult = void 0;
+const absent_js_1 = require("./absent.js");
+const ledger_js_1 = require("./ledger.js");
+const ABSENT_STATUS = 'absent';
+/**
+ * Read one finalized tool result for coverage declarations.
+ *
+ * The two shapes compose: `coverage(absent({…}), {…})` is a search that found
+ * nothing AND a boundary around the search, so both are declared and the
+ * delivered status is still `'absent'` — the ledger bounds the answer, it
+ * does not change what the answer was.
+ */
+function readCoverageResult(value) {
+    const absence = (0, absent_js_1.readAbsence)(value);
+    if (absence !== undefined) {
+        return {
+            status: ABSENT_STATUS,
+            declared: [
+                { kind: 'absence', coverage: (0, absent_js_1.coverageOfAbsence)(absence), lookedFor: absence.looked_for },
+            ],
+        };
+    }
+    const covered = (0, ledger_js_1.readCoverageLedger)(value);
+    if (covered === undefined)
+        return undefined;
+    const declared = [{ kind: 'ledger', coverage: (0, ledger_js_1.coverageOfLedger)(covered) }];
+    const inner = (0, absent_js_1.readAbsence)(covered.result);
+    if (inner === undefined)
+        return { declared };
+    declared.push({
+        kind: 'absence',
+        coverage: (0, absent_js_1.coverageOfAbsence)(inner),
+        lookedFor: inner.looked_for,
+    });
+    return { status: ABSENT_STATUS, declared };
+}
+exports.readCoverageResult = readCoverageResult;
+//# sourceMappingURL=read.js.map

package/dist/core/agent/coverage/read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.js","sourceRoot":"","sources":["../../../../src/core/agent/coverage/read.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAGH,2CAA6D;AAC7D,2CAAmE;AA6BnE,MAAM,aAAa,GAAqB,QAAQ,CAAC;AAEjD;;;;;;;GAOG;AACH,SAAgB,kBAAkB,CAAC,KAAc;IAC/C,MAAM,OAAO,GAAG,IAAA,uBAAW,EAAC,KAAK,CAAC,CAAC;IACnC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO;YACL,MAAM,EAAE,aAAa;YACrB,QAAQ,EAAE;gBACR,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAA,6BAAiB,EAAC,OAAO,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,UAAU,EAAE;aACzF;SACF,CAAC;IACJ,CAAC;IACD,MAAM,OAAO,GAAG,IAAA,8BAAkB,EAAC,KAAK,CAAC,CAAC;IAC1C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC5C,MAAM,QAAQ,GAAoB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAA,4BAAgB,EAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC5F,MAAM,KAAK,GAAG,IAAA,uBAAW,EAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;IAC7C,QAAQ,CAAC,IAAI,CAAC;QACZ,IAAI,EAAE,SAAS;QACf,QAAQ,EAAE,IAAA,6BAAiB,EAAC,KAAK,CAAC;QAClC,SAAS,EAAE,KAAK,CAAC,UAAU;KAC5B,CAAC,CAAC;IACH,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC;AAC7C,CAAC;AArBD,gDAqBC"}

package/dist/core/agent/coverage/types.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * coverage/types — the shared vocabulary of the two coverage primitives.
+ *
+ * Pattern: one value type, two consumers — `absent()` says "I looked HERE and
+ *          found nothing", `coverage()` says "my answer covers THIS and not
+ *          THAT". Both are statements about the same thing: the ground a
+ *          result stands on. Spelling them with one vocabulary is what lets
+ *          the answer-level block merge an absence's boundary with a
+ *          verdict's without translating between two grammars.
+ * Role:    core/ layer, pure data. No imports, no behavior.
+ * Emits:   N/A.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/core/agent/coverage/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/core/agent/coverage/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG"}

package/dist/core/agent/evidence/evidenceIndex.js

@@ -27,6 +27,13 @@
  *     value because the model passed it to a tool would let any invention
  *     launder itself through one failed lookup.
  *   • **The model's own earlier answers do not count**, for the same reason.
+ *   • **An `absent(…)` result grounds its COVERAGE only.** An absence names
+ *     what was looked FOR, which in practice quotes the arguments the model
+ *     passed — so indexing the whole frame would ground an invented
+ *     identifier through the one operation that proves nothing about it: a
+ *     lookup that found nothing. `checked` / `not_checked` / `cannot_cover`
+ *     are the tool's own words about the world and do count. See
+ *     `../coverage/evidence.ts`.
  *
  * The EXEMPT index is built from a different corpus with the same machinery:
  * the user's own message, the conversation's user/system turns, and the
@@ -36,6 +43,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exemptFromRun = exports.evidenceFromHistory = void 0;
+const index_js_1 = require("../coverage/index.js");
 const frames_js_1 = require("./frames.js");
 const normalize_js_1 = require("./normalize.js");
 /**
@@ -96,7 +104,16 @@ function indexResult(content, sink) {
     const trimmed = content.trim();
     if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
         try {
-            walk(JSON.parse(trimmed), sink);
+            const parsed = JSON.parse(trimmed);
+            // An `absent(…)` frame grounds its COVERAGE and nothing else: the rest
+            // of it is prose about the REQUEST, which usually quotes the model's own
+            // arguments, and indexing that would ground every identifier a model
+            // invented as long as it handed the invention to one tool that found
+            // nothing. See `../coverage/evidence.ts` — it is the frames.ts argument
+            // on the tool side of the conversation. `undefined` (every other result
+            // ever returned) keeps the walk it always had.
+            const projection = (0, index_js_1.absenceEvidenceProjection)(parsed);
+            walk(projection ?? parsed, sink);
             return;
         }
         catch {

package/dist/core/agent/evidence/evidenceIndex.js.map

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

package/dist/core/agent/runManifest.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * runManifest — the run-configuration manifest, composed.
+ *
+ * Pattern: Pure builder over already-resolved configuration.
+ * Role:    Turn what an Agent HOLDS into what `agentfootprint.agent.run_configured`
+ *          SAYS. Kept out of Agent.ts so the rule that governs it — names only,
+ *          absence never guessed — is testable without building an agent, and
+ *          so the one place that decides what may leave the process is one
+ *          small file rather than a paragraph inside a 3,000-line class.
+ * Emits:   N/A — the Agent dispatches what this returns.
+ *
+ * ## The rule this file exists to keep
+ *
+ * The manifest carries NAMES AND IDS ONLY. Not endpoints, not directories, not
+ * connection strings, not keys, not tenants, not principals — and not a config
+ * VALUE that could be any of those. It rides into every recording, every vendor
+ * sink and every shared trace, which is exactly where a secret must not go.
+ *
+ * That rule is why this file takes an already-narrowed input rather than the
+ * Agent: nothing here can reach a store's options bag even by accident, because
+ * a store is never passed in. Where the only handle on a component is a value
+ * (a directory, a URL, a table name), the component is reported as PRESENT and
+ * left unnamed — {@link RunManifestSources.artifacts} is the shape of that
+ * answer. A field the configuration did not declare is ABSENT: "the strategy
+ * did not say" and "the default" are different facts, and only the first one is
+ * true here.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRunManifest = void 0;
+/**
+ * Compose the manifest. Pure: same input, same payload, no clock, no ids
+ * minted here (the runId the arms are grouped by is already on `meta`).
+ */
+function buildRunManifest(sources) {
+    // Who may replace the model mid-run. Built as a list of NAMES rather than a
+    // boolean so a reader knows which mechanism to go look at, and left absent
+    // when nobody can — that absence is the strong statement: `model` is then
+    // what every call of this run used, and an arm can be grouped on it alone.
+    const modelOverrides = [];
+    if (sources.hasRunConfig)
+        modelOverrides.push('configure');
+    if (sources.hasSkillBrains)
+        modelOverrides.push('skill-brains');
+    const artifacts = sources.artifacts;
+    return {
+        agentId: sources.agentId,
+        llm: {
+            provider: sources.providerName,
+            model: sources.model,
+            ...(modelOverrides.length > 0 && { modelOverrides }),
+        },
+        reactMode: sources.reactMode,
+        // `[]` rather than an omitted field: "no memory is mounted" is an arm, and
+        // a consumer grouping on retrieval strategy must be able to tell it from a
+        // manifest that forgot to look.
+        memories: sources.memories.map(describeMemory),
+        ...(sources.windowStrategyName !== undefined && { window: sources.windowStrategyName }),
+        ...(sources.skillGraph !== undefined && {
+            skillGraph: {
+                ...(sources.skillGraph.routing !== undefined && { routing: sources.skillGraph.routing }),
+                ...(sources.skillGraph.continuity !== undefined && {
+                    continuity: sources.skillGraph.continuity,
+                }),
+                ...(sources.skillGraph.scorerName !== undefined && {
+                    scorer: sources.skillGraph.scorerName,
+                }),
+            },
+        }),
+        ...(sources.evidenceGatePosture !== undefined && {
+            evidenceGate: sources.evidenceGatePosture,
+        }),
+        // Only the TRUE dials are written. `placement: false` would be noise on
+        // every artifact-configured agent; the object's presence already says a
+        // store is wired.
+        ...(artifacts !== undefined && {
+            artifacts: {
+                ...(artifacts.placement && { placement: true }),
+                ...(artifacts.recordings && { recordings: true }),
+            },
+        }),
+    };
+}
+exports.buildRunManifest = buildRunManifest;
+/**
+ * One memory row — only the names the definition DECLARED.
+ *
+ * `store` is never described: `MemoryStore` has no id and no kind, and a class
+ * name is a label no bundler promises to keep. An arm grouped on an invented
+ * label is an arm that silently regroups itself on the next build.
+ */
+function describeMemory(def) {
+    return {
+        id: def.id,
+        type: def.type,
+        ...(def.strategy !== undefined && { strategy: def.strategy }),
+        ...(def.retrieval !== undefined && { retrieval: def.retrieval }),
+        ...(def.embedderId !== undefined && { embedderId: def.embedderId }),
+        ...(def.flavor !== undefined && { flavor: def.flavor }),
+    };
+}
+//# sourceMappingURL=runManifest.js.map

package/dist/core/agent/runManifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runManifest.js","sourceRoot":"","sources":["../../../src/core/agent/runManifest.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;;AAuDH;;;GAGG;AACH,SAAgB,gBAAgB,CAAC,OAA2B;IAC1D,4EAA4E;IAC5E,2EAA2E;IAC3E,0EAA0E;IAC1E,2EAA2E;IAC3E,MAAM,cAAc,GAAqC,EAAE,CAAC;IAC5D,IAAI,OAAO,CAAC,YAAY;QAAE,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC3D,IAAI,OAAO,CAAC,cAAc;QAAE,cAAc,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IAEhE,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IAEpC,OAAO;QACL,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,GAAG,EAAE;YACH,QAAQ,EAAE,OAAO,CAAC,YAAY;YAC9B,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,GAAG,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,cAAc,EAAE,CAAC;SACrD;QACD,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,2EAA2E;QAC3E,2EAA2E;QAC3E,gCAAgC;QAChC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC;QAC9C,GAAG,CAAC,OAAO,CAAC,kBAAkB,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,kBAAkB,EAAE,CAAC;QACvF,GAAG,CAAC,OAAO,CAAC,UAAU,KAAK,SAAS,IAAI;YACtC,UAAU,EAAE;gBACV,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;gBACxF,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,KAAK,SAAS,IAAI;oBACjD,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,UAAU;iBAC1C,CAAC;gBACF,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,KAAK,SAAS,IAAI;oBACjD,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,UAAU;iBACtC,CAAC;aACH;SACF,CAAC;QACF,GAAG,CAAC,OAAO,CAAC,mBAAmB,KAAK,SAAS,IAAI;YAC/C,YAAY,EAAE,OAAO,CAAC,mBAAmB;SAC1C,CAAC;QACF,wEAAwE;QACxE,wEAAwE;QACxE,kBAAkB;QAClB,GAAG,CAAC,SAAS,KAAK,SAAS,IAAI;YAC7B,SAAS,EAAE;gBACT,GAAG,CAAC,SAAS,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,IAAa,EAAE,CAAC;gBACxD,GAAG,CAAC,SAAS,CAAC,UAAU,IAAI,EAAE,UAAU,EAAE,IAAa,EAAE,CAAC;aAC3D;SACF,CAAC;KACH,CAAC;AACJ,CAAC;AAhDD,4CAgDC;AAED;;;;;;GAMG;AACH,SAAS,cAAc,CAAC,GAAqB;IAC3C,OAAO;QACL,EAAE,EAAE,GAAG,CAAC,EAAE;QACV,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,GAAG,CAAC,GAAG,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,CAAC;QAC7D,GAAG,CAAC,GAAG,CAAC,SAAS,KAAK,SAAS,IAAI,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;QAChE,GAAG,CAAC,GAAG,CAAC,UAAU,KAAK,SAAS,IAAI,EAAE,UAAU,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC;QACnE,GAAG,CAAC,GAAG,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC;KACxD,CAAC;AACJ,CAAC"}

package/dist/core/agent/stages/prepareFinal.js

@@ -26,11 +26,24 @@
  * `stages/route.ts`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareFinalStage = void 0;
+exports.prepareFinalWithLimitsStage = exports.prepareFinalStage = void 0;
 const typedEmit_js_1 = require("../../../recorders/core/typedEmit.js");
-const prepareFinalStage = (scope) => {
+const index_js_1 = require("../coverage/index.js");
+/**
+ * The stage body, with the answer passed IN.
+ *
+ * One body, two entry points. The answer is a parameter rather than a read of
+ * `scope.llmLatestContent` because `.limitsTravelWithTheAnswer()` composes a
+ * different one — and everything filed here (`finalContent`, `newMessages`,
+ * which memory persists, and `turn_end.finalContent`) must agree about what
+ * the answer WAS. Note that `llmLatestContent` itself is a READ-ONLY input to
+ * this branch subflow, so there is no version of this where the composed
+ * answer is written back over it: the capture is the only place all four
+ * readers meet.
+ */
+const captureTurnPayload = (scope, answer) => {
     const iteration = scope.iteration;
-    scope.finalContent = scope.llmLatestContent;
+    scope.finalContent = answer;
     // v2.14 — attach thinking blocks to the assistant final message
     // (if any). For non-Anthropic providers this is informational; for
     // Anthropic + extended-thinking-with-tool-use, signature round-trip
@@ -62,5 +75,33 @@ const prepareFinalStage = (scope) => {
         durationMs: Date.now() - scope.turnStartMs,
     });
 };
+const prepareFinalStage = (scope) => {
+    captureTurnPayload(scope, scope.llmLatestContent);
+};
 exports.prepareFinalStage = prepareFinalStage;
+/**
+ * `.limitsTravelWithTheAnswer()`'s half of prepare-final — the SAME stage,
+ * with the run's declared coverage folded into the answer first.
+ *
+ * Mounted in place of `prepareFinalStage` by both chart builders when the
+ * option is configured, and nowhere else: an agent that did not ask for it
+ * runs the function above, byte for byte. Written as one stage rather than a
+ * second one because everything the capture files must agree about what the
+ * answer WAS — a second stage afterwards would leave `turn_end` reporting an
+ * answer the caller never saw.
+ *
+ * It runs AFTER the evidence gate has judged (the gate is in the Route
+ * decider, one stage earlier). That ordering is deliberate: the block is
+ * composed by the framework out of what the TOOLS declared, so subjecting it
+ * to a check for values the MODEL could not support would be asking whether
+ * the library grounded itself.
+ */
+const prepareFinalWithLimitsStage = (scope) => {
+    const declared = scope.coverageDeclared;
+    const answer = declared !== undefined && declared.length > 0
+        ? (0, index_js_1.composeAnswerWithCoverage)(scope.llmLatestContent, declared)
+        : scope.llmLatestContent;
+    captureTurnPayload(scope, answer);
+};
+exports.prepareFinalWithLimitsStage = prepareFinalWithLimitsStage;
 //# sourceMappingURL=prepareFinal.js.map

package/dist/core/agent/stages/prepareFinal.js.map

@@ -1 +1 @@
-{"version":3,"file":"prepareFinal.js","sourceRoot":"","sources":["../../../../src/core/agent/stages/prepareFinal.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;;;AAGH,uEAAiE;AAG1D,MAAM,iBAAiB,GAAG,CAAC,KAA6B,EAAQ,EAAE;IACvE,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;IAClC,KAAK,CAAC,YAAY,GAAG,KAAK,CAAC,gBAAgB,CAAC;IAC5C,gEAAgE;IAChE,mEAAmE;IACnE,oEAAoE;IACpE,iEAAiE;IACjE,+DAA+D;IAC/D,MAAM,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC;IAC5C,MAAM,WAAW,GAAG,cAAc,KAAK,SAAS,IAAI,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC;IAC9E,6DAA6D;IAC7D,wCAAwC;IACxC,KAAK,CAAC,WAAW,GAAG;QAClB,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,WAAW,EAAE;QAC5C;YACE,IAAI,EAAE,WAAW;YACjB,OAAO,EAAE,KAAK,CAAC,YAAY;YAC3B,GAAG,CAAC,WAAW,IAAI,EAAE,cAAc,EAAE,CAAC;SACvC;KACF,CAAC;IAEF,IAAA,wBAAS,EAAC,KAAK,EAAE,oCAAoC,EAAE;QACrD,SAAS,EAAE,CAAC;QACZ,SAAS,EAAE,SAAS;QACpB,aAAa,EAAE,CAAC;KACjB,CAAC,CAAC;IACH,IAAA,wBAAS,EAAC,KAAK,EAAE,+BAA+B,EAAE;QAChD,SAAS,EAAE,CAAC;QACZ,YAAY,EAAE,KAAK,CAAC,YAAY;QAChC,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;QACxC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;QAC1C,cAAc,EAAE,SAAS;QACzB,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,WAAW;KAC3C,CAAC,CAAC;AACL,CAAC,CAAC;AAlCW,QAAA,iBAAiB,qBAkC5B"}
+{"version":3,"file":"prepareFinal.js","sourceRoot":"","sources":["../../../../src/core/agent/stages/prepareFinal.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;;;AAGH,uEAAiE;AACjE,mDAAiE;AAGjE;;;;;;;;;;;GAWG;AACH,MAAM,kBAAkB,GAAG,CAAC,KAA6B,EAAE,MAAc,EAAQ,EAAE;IACjF,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;IAClC,KAAK,CAAC,YAAY,GAAG,MAAM,CAAC;IAC5B,gEAAgE;IAChE,mEAAmE;IACnE,oEAAoE;IACpE,iEAAiE;IACjE,+DAA+D;IAC/D,MAAM,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC;IAC5C,MAAM,WAAW,GAAG,cAAc,KAAK,SAAS,IAAI,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC;IAC9E,6DAA6D;IAC7D,wCAAwC;IACxC,KAAK,CAAC,WAAW,GAAG;QAClB,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,WAAW,EAAE;QAC5C;YACE,IAAI,EAAE,WAAW;YACjB,OAAO,EAAE,KAAK,CAAC,YAAY;YAC3B,GAAG,CAAC,WAAW,IAAI,EAAE,cAAc,EAAE,CAAC;SACvC;KACF,CAAC;IAEF,IAAA,wBAAS,EAAC,KAAK,EAAE,oCAAoC,EAAE;QACrD,SAAS,EAAE,CAAC;QACZ,SAAS,EAAE,SAAS;QACpB,aAAa,EAAE,CAAC;KACjB,CAAC,CAAC;IACH,IAAA,wBAAS,EAAC,KAAK,EAAE,+BAA+B,EAAE;QAChD,SAAS,EAAE,CAAC;QACZ,YAAY,EAAE,KAAK,CAAC,YAAY;QAChC,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;QACxC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;QAC1C,cAAc,EAAE,SAAS;QACzB,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,WAAW;KAC3C,CAAC,CAAC;AACL,CAAC,CAAC;AAEK,MAAM,iBAAiB,GAAG,CAAC,KAA6B,EAAQ,EAAE;IACvE,kBAAkB,CAAC,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;AACpD,CAAC,CAAC;AAFW,QAAA,iBAAiB,qBAE5B;AAEF;;;;;;;;;;;;;;;;GAgBG;AACI,MAAM,2BAA2B,GAAG,CAAC,KAA6B,EAAQ,EAAE;IACjF,MAAM,QAAQ,GAAG,KAAK,CAAC,gBAAgB,CAAC;IACxC,MAAM,MAAM,GACV,QAAQ,KAAK,SAAS,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC;QAC3C,CAAC,CAAC,IAAA,oCAAyB,EAAC,KAAK,CAAC,gBAAgB,EAAE,QAAQ,CAAC;QAC7D,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC;IAC7B,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AACpC,CAAC,CAAC;AAPW,QAAA,2BAA2B,+BAOtC"}

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

@@ -68,6 +68,7 @@ const validators_js_1 = require("../validators.js");
 const toolResultCap_js_1 = require("../toolResultCap.js");
 const resultCeiling_js_1 = require("../resultCeiling.js");
 const skillSteps_js_1 = require("../../../lib/injection-engine/skillSteps.js");
+const index_js_1 = require("../coverage/index.js");
 const toolEffects_js_1 = require("../toolEffects.js");
 /** Declaration order preserved, ids de-duplicated — the shape the gate's re-prompt
  *  and the `skill.rejected` payload both report as "what this gate accepts". */
@@ -309,6 +310,76 @@ function buildToolCallsHandler(deps) {
         });
         return verdict.refusal;
     };
+    /**
+     * 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 `../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) => {
+        const reading = (0, index_js_1.readCoverageResult)(value);
+        if (reading === undefined)
+            return undefined;
+        const rows = [];
+        for (const facts of reading.declared) {
+            // Copied item by item — event payloads are detached plain data, never
+            // a shared reference into a value the tool still holds.
+            const copy = (list) => list.map((i) => ({ what: i.what, ...(i.why !== undefined && { why: i.why }) }));
+            const checked = copy(facts.coverage.checked);
+            const notChecked = copy(facts.coverage.notChecked);
+            const cannotCover = copy(facts.coverage.cannotCover);
+            if (facts.kind === 'absence') {
+                (0, typedEmit_js_1.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 }),
+                });
+            }
+            else {
+                (0, typedEmit_js_1.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 }),
+                });
+            }
+            rows.push({
+                kind: facts.kind,
+                toolName: call.toolName,
+                toolCallId: call.toolCallId,
+                iteration: call.iteration,
+                ...(facts.lookedFor !== undefined && { lookedFor: facts.lookedFor }),
+                checked,
+                notChecked,
+                cannotCover,
+            });
+        }
+        scope.coverageDeclared = [...(scope.coverageDeclared ?? []), ...rows];
+        return reading.status;
+    };
     // ── Step-procedure boundary (9.18.0) — ONE implementation, five sites ──
     // The batch loop and the four resume paths all finalize results; each
     // calls these where its result becomes final, so a pointer can never miss
@@ -1185,6 +1256,14 @@ function buildToolCallsHandler(deps) {
             // judged exactly as an inline one's.
             const envelope = (0, toolEffects_js_1.readToolResultEnvelope)(result);
             if (envelope !== undefined) {
+                // Coverage (this release) before the ceiling, for the same reason the
+                // effects are judged even when the payload is refused: the boundary a
+                // tool declared is not the channel that can overflow, and a limit
+                // that died with an oversized result would be the silence this
+                // primitive exists to break. An absence's status is the tool's own
+                // and wins over the envelope's only when the envelope declared none.
+                const coverageStatus = declareCoverage(scope, { toolName, toolCallId, iteration }, envelope.content);
+                const declaredStatus = envelope.status ?? coverageStatus;
                 // The tool's own ceiling (9.20.0) measures the CONTENT — the channel
                 // that can overflow a context window. The DECLARED effects are small
                 // validated data and are still judged by the caller: a tool that
@@ -1192,7 +1271,7 @@ function buildToolCallsHandler(deps) {
                 // transition. The delivered status becomes 'invalid' (the declared
                 // status described a result the model never received — the
                 // `result_refused` event keeps what was declared).
-                const refusal = refuseOverCeiling(scope, { toolName, toolCallId, iteration }, tool, envelope.content, envelope.status);
+                const refusal = refuseOverCeiling(scope, { toolName, toolCallId, iteration }, tool, envelope.content, declaredStatus);
                 if (refusal !== undefined) {
                     return {
                         result: refusal,
@@ -1201,9 +1280,14 @@ function buildToolCallsHandler(deps) {
                         envelope: { ...envelope, content: refusal, status: 'invalid' },
                     };
                 }
-                return { result: envelope.content, executed: true, envelope };
+                return {
+                    result: envelope.content,
+                    executed: true,
+                    envelope: declaredStatus === envelope.status ? envelope : { ...envelope, status: declaredStatus },
+                };
             }
-            const refusal = refuseOverCeiling(scope, { toolName, toolCallId, iteration }, tool, result);
+            const coverageStatus = declareCoverage(scope, { toolName, toolCallId, iteration }, result);
+            const refusal = refuseOverCeiling(scope, { toolName, toolCallId, iteration }, tool, result, coverageStatus);
             if (refusal !== undefined) {
                 // Synthesized empty-effects envelope: the resume paths read the
                 // routing status off `envelope.status`, and this is how a refused
@@ -1221,6 +1305,19 @@ function buildToolCallsHandler(deps) {
             const nearMiss = (0, toolEffects_js_1.explainStatusOnlyNearMiss)(result);
             if (nearMiss !== undefined)
                 warnEffect(toolName, nearMiss);
+            if (coverageStatus !== undefined) {
+                // The ceiling path's synthesized envelope, for the same reason: the
+                // resume paths read the routing status off `envelope.status`, and an
+                // absence that lost its status here would route down whichever edge a
+                // statusless result routes down — the confusion the word exists to
+                // end. Empty effects/malformed judge to nothing, so the only thing
+                // this carries is the status.
+                return {
+                    result,
+                    executed: true,
+                    envelope: { content: result, effects: [], status: coverageStatus, malformed: [] },
+                };
+            }
             return { result, executed: true };
         }
         catch (err) {
@@ -1879,6 +1976,15 @@ function buildToolCallsHandler(deps) {
                                 if (nearMiss !== undefined)
                                     warnEffect(tc.name, nearMiss);
                             }
+                            // Coverage (this release), on the UNWRAPPED content and before
+                            // the ceiling — the boundary a tool declared is not the channel
+                            // that can overflow. A tool that spelled its own status keeps
+                            // it; otherwise an absence names the delivered outcome, so an
+                            // `onToolStatus` edge can route "we looked and there was
+                            // nothing" somewhere other than "the call broke".
+                            const coverageStatus = declareCoverage(scope, { toolName: tc.name, toolCallId: tc.id, iteration }, result);
+                            if (toolStatus === undefined)
+                                toolStatus = coverageStatus;
                             // The tool's own refusing ceiling (9.20.0) — at the execute
                             // boundary, BEFORE the gates and the after-tool chain, so
                             // governance and the agent-level cap compose over what the