agentfootprint 13.0.0 → 14.0.0

package/dist/esm/time-travel/servedView/recordReads.d.ts

@@ -0,0 +1,44 @@
+import { type EpochLocation } from '../epochs.js';
+import type { StoredReceipt } from '../../core/agent/receipt/receipt.js';
+import type { ServedGapCause } from '../servedView.js';
+/** {@link https://github.com/footprintjs/agentfootprint/blob/main/src/time-travel/epochs.ts | epochs.readAtCall}, with the placeholder read as absent on a `served` record. */
+export declare function readAtCall(location: EpochLocation, key: string, served: boolean): unknown;
+/** {@link https://github.com/footprintjs/agentfootprint/blob/main/src/time-travel/epochs.ts | epochs.readRunConstant}, with the placeholder read as absent on a `served` record. */
+export declare function readRunConstant(location: EpochLocation, key: string, served: boolean): unknown;
+/** The receipt, or the reason there is none — the shape `readReceipt` answers
+ *  in. */
+type ReceiptRead = {
+    readonly receipt: StoredReceipt;
+    readonly cause?: undefined;
+} | {
+    readonly receipt?: undefined;
+    readonly cause: ServedGapCause;
+};
+/**
+ * The receipt this epoch's call committed, or WHY there is none. Shared by
+ * `receiptAt` and by the rebuild, which reads exactly TWO things off a receipt
+ * — the model/provider/runId basis, and whether a cache strategy stood between
+ * assembly and the port — and nothing else.
+ *
+ * THE ONE PLACE THAT KNOWS. This function is where the difference between
+ * "nothing was committed" and "something was committed and it is not a
+ * receipt" exists at all: everywhere else the two are one `undefined`. It used
+ * to be spent here, and the gap's printed sentence tried to make it up
+ * afterwards from a list of causes — which is how a shape refusal added in this
+ * release became a cause that sentence had already ruled out. So the answer
+ * carries the reason out, and {@link https://github.com/footprintjs/agentfootprint/blob/main/src/time-travel/servedView.ts | ServedGap.cause} is where it lands.
+ *
+ * THE ONE PLACE THAT NARROWS, too — and what it admits is what it says it
+ * admits. The check is the basis and nothing past it, so the value it hands
+ * back is a {@link StoredReceipt}: every container past the basis is what the
+ * MINTING release wrote, and a reader behind this narrowing reads them as
+ * optional, because the type says so and the compiler holds it to that.
+ * 9.93.0 read `receipt.cache.strategy` off a `Receipt` here — the minted
+ * shape, which promises `cache` — and a stored receipt with a basis and no
+ * `cache` made `servedAt` throw where 9.92 built a view. A reader reads the
+ * receipt it is handed; a missing container is a fact about the vintage,
+ * never a throw. It is also never repaired: nothing here fabricates a
+ * `cache: {}` or writes to the record.
+ */
+export declare function readReceipt(location: EpochLocation): ReceiptRead;
+export {};

package/dist/esm/time-travel/servedView/recordReads.js

@@ -0,0 +1,73 @@
+import { readAfterCall, readAtCall as foldAtCall, readRunConstant as foldRunConstant, } from '../epochs.js';
+import { RECEIPT_KEY } from '../../lib/conventions.js';
+/**
+ * The commit log's redaction placeholder (footprintjs writes it where a run's
+ * policy selected a key — `Agent.create({ redact })`). To this rebuild it is NO
+ * value: never a system piece, a tool list or a tool name the view could print
+ * as if the request had carried it. Read as absent, which is what the record
+ * can show. The view states the cost through the gap a redacted snapshot always
+ * carries: it travels without its fold base (footprintjs omits `initialState`
+ * from the served view), so `no-fold-base` — "unproven and may be SHORT … reads
+ * as empty rather than as unknown" — is on every view of it.
+ *
+ * Read so only when the record says a policy covered the run — the snapshot's
+ * marker (`redaction/marker.ts` · `servedUnderPolicy`), asked once per call of
+ * `servedAt` / `servedViews` — so a value that merely spells the word (a tool
+ * NAMED `REDACTED`) is a value on a run no policy covered, as the answer
+ * account and `assessAnswer` read it.
+ */
+const LOG_PLACEHOLDER = 'REDACTED';
+/** {@link https://github.com/footprintjs/agentfootprint/blob/main/src/time-travel/epochs.ts | epochs.readAtCall}, with the placeholder read as absent on a `served` record. */
+export function readAtCall(location, key, served) {
+    const value = foldAtCall(location, key);
+    return served && value === LOG_PLACEHOLDER ? undefined : value;
+}
+/** {@link https://github.com/footprintjs/agentfootprint/blob/main/src/time-travel/epochs.ts | epochs.readRunConstant}, with the placeholder read as absent on a `served` record. */
+export function readRunConstant(location, key, served) {
+    const value = foldRunConstant(location, key);
+    return served && value === LOG_PLACEHOLDER ? undefined : value;
+}
+/**
+ * The receipt this epoch's call committed, or WHY there is none. Shared by
+ * `receiptAt` and by the rebuild, which reads exactly TWO things off a receipt
+ * — the model/provider/runId basis, and whether a cache strategy stood between
+ * assembly and the port — and nothing else.
+ *
+ * THE ONE PLACE THAT KNOWS. This function is where the difference between
+ * "nothing was committed" and "something was committed and it is not a
+ * receipt" exists at all: everywhere else the two are one `undefined`. It used
+ * to be spent here, and the gap's printed sentence tried to make it up
+ * afterwards from a list of causes — which is how a shape refusal added in this
+ * release became a cause that sentence had already ruled out. So the answer
+ * carries the reason out, and {@link https://github.com/footprintjs/agentfootprint/blob/main/src/time-travel/servedView.ts | ServedGap.cause} is where it lands.
+ *
+ * THE ONE PLACE THAT NARROWS, too — and what it admits is what it says it
+ * admits. The check is the basis and nothing past it, so the value it hands
+ * back is a {@link StoredReceipt}: every container past the basis is what the
+ * MINTING release wrote, and a reader behind this narrowing reads them as
+ * optional, because the type says so and the compiler holds it to that.
+ * 9.93.0 read `receipt.cache.strategy` off a `Receipt` here — the minted
+ * shape, which promises `cache` — and a stored receipt with a basis and no
+ * `cache` made `servedAt` throw where 9.92 built a view. A reader reads the
+ * receipt it is handed; a missing container is a fact about the vintage,
+ * never a throw. It is also never repaired: nothing here fabricates a
+ * `cache: {}` or writes to the record.
+ */
+export function readReceipt(location) {
+    const value = readAfterCall(location, RECEIPT_KEY);
+    // Nothing under the key: the run never minted one here. The record does not
+    // say which of the ways that happens applied, and neither does this.
+    if (value === undefined)
+        return { cause: 'no-receipt-committed' };
+    // Something IS under the key. A value without a basis is not a receipt —
+    // refuse it rather than hand back a half-shape a caller would read
+    // `.basis.runId` off — and REPORT the refusal, because a log that holds a
+    // non-receipt under the receipt key is damaged, which is a different fact
+    // about the recording from a run that never minted.
+    const candidate = value;
+    if (value === null || typeof value !== 'object' || typeof candidate.basis?.epoch !== 'number') {
+        return { cause: 'receipt-shape-rejected' };
+    }
+    return { receipt: value };
+}
+//# sourceMappingURL=recordReads.js.map

package/dist/esm/time-travel/servedView/recordReads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordReads.js","sourceRoot":"","sources":["../../../../src/time-travel/servedView/recordReads.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,UAAU,IAAI,UAAU,EACxB,eAAe,IAAI,eAAe,GAEnC,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAGvD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,eAAe,GAAG,UAAU,CAAC;AAEnC,+KAA+K;AAC/K,MAAM,UAAU,UAAU,CAAC,QAAuB,EAAE,GAAW,EAAE,MAAe;IAC9E,MAAM,KAAK,GAAG,UAAU,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IACxC,OAAO,MAAM,IAAI,KAAK,KAAK,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC;AACjE,CAAC;AAED,oLAAoL;AACpL,MAAM,UAAU,eAAe,CAAC,QAAuB,EAAE,GAAW,EAAE,MAAe;IACnF,MAAM,KAAK,GAAG,eAAe,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IAC7C,OAAO,MAAM,IAAI,KAAK,KAAK,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC;AACjE,CAAC;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,WAAW,CAAC,QAAuB;IACjD,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IACnD,4EAA4E;IAC5E,qEAAqE;IACrE,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,EAAE,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAClE,yEAAyE;IACzE,mEAAmE;IACnE,0EAA0E;IAC1E,0EAA0E;IAC1E,oDAAoD;IACpD,MAAM,SAAS,GAAG,KAA+B,CAAC;IAClD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,SAAS,CAAC,KAAK,EAAE,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9F,OAAO,EAAE,KAAK,EAAE,wBAAwB,EAAE,CAAC;IAC7C,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,KAAsB,EAAE,CAAC;AAC7C,CAAC"}

package/dist/esm/time-travel/servedView/requestOnly.d.ts

@@ -0,0 +1,6 @@
+import type { LLMMessage, LLMToolSchema } from '../../provider-contract/types.js';
+import type { toolsWithheld } from '../../core/agent/composeRequest.js';
+import { type EpochLocation } from '../epochs.js';
+import type { ServedRequestOnly } from '../servedView.js';
+/** Rebuild request-only lines in wire order and retain late-layout uncertainty. */
+export declare function requestOnlyAt(location: EpochLocation, served: boolean, asSent: readonly LLMMessage[], registered: readonly LLMToolSchema[], withheld: ReturnType<typeof toolsWithheld>, iteration: number, committed: readonly LLMMessage[], lateLayout: boolean, recordedBound: unknown, layoutUnknown: boolean): readonly [requestOnly: ServedRequestOnly[], layoutUnknown: boolean];

package/dist/esm/time-travel/servedView/requestOnly.js

@@ -0,0 +1,67 @@
+import { findingsContext } from '../../core/agent/findings/context.js';
+import { findStagedRefs, stagedRefsNudgeLine } from '../../core/agent/stagedRefs.js';
+import { evidenceConclusionLine } from '../../core/agent/evidence/recovery.js';
+import { readAtCall as foldAtCall } from '../epochs.js';
+import { readAtCall, readRunConstant } from './recordReads.js';
+/** `toolWantsByName` back as the map `findStagedRefs` takes. It is committed
+ *  as a plain record because a `Map` does not survive the scope's write path
+ *  (an object write is JSON-round-tripped, and a `Map` round-trips to `{}`). */
+function wantsMapOf(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const map = new Map();
+    for (const [name, kinds] of Object.entries(value)) {
+        if (Array.isArray(kinds) && kinds.every((k) => typeof k === 'string')) {
+            map.set(name, kinds);
+        }
+    }
+    return map.size > 0 ? map : undefined;
+}
+/** Rebuild request-only lines in wire order and retain late-layout uncertainty. */
+export function requestOnlyAt(location, served, asSent, registered, withheld, iteration, committed, lateLayout, recordedBound, layoutUnknown) {
+    // ── the request-only lines ─────────────────────────────────────────────
+    // The staged-refs nudge is a pure function of committed state: the
+    // conversation, the tools really served this call, and the `wants`
+    // declarations `seed` put on the record for exactly this reason.
+    const requestOnly = [];
+    const wants = wantsMapOf(readRunConstant(location, 'toolWantsByName', served));
+    if (wants !== undefined) {
+        const match = findStagedRefs(asSent, wants, new Set(registered.map((t) => t.name)));
+        if (match !== undefined) {
+            requestOnly.push({
+                role: 'user',
+                text: stagedRefsNudgeLine(match),
+                reason: 'staged-refs-nudge',
+            });
+        }
+    }
+    // The time line (step T6b) — the tools slot's committed composition, served only on the
+    // iteration that composed it and never on the wrap-up call (`callLLM` · the same three tests).
+    const timeLine = readAtCall(location, 'timeLine', served);
+    if (withheld === null &&
+        typeof timeLine?.text === 'string' &&
+        timeLine.text.length > 0 &&
+        timeLine.iteration === readAtCall(location, 'iteration', served)) {
+        requestOnly.push({ role: 'user', text: timeLine.text, reason: 'time-window-line' });
+    }
+    // The evidence conclusion (the figures dial) — the committed carrier's late
+    // line, on the iteration its instruction is served (`callLLM` · the same test).
+    const conclusion = evidenceConclusionLine(readAtCall(location, 'evidenceRecovery', served), readAtCall(location, 'evidenceRecoveryUsed', served), iteration);
+    if (conclusion !== undefined) {
+        requestOnly.push({ role: 'user', text: conclusion, reason: 'evidence-conclusion' });
+    }
+    if (lateLayout) {
+        try {
+            requestOnly.push({
+                role: 'user',
+                text: findingsContext(committed, foldAtCall(location, 'findingsLedger'), recordedBound),
+                reason: 'findings-data',
+            });
+        }
+        catch {
+            layoutUnknown = true;
+        }
+    }
+    return [requestOnly, layoutUnknown];
+}
+//# sourceMappingURL=requestOnly.js.map

package/dist/esm/time-travel/servedView/requestOnly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestOnly.js","sourceRoot":"","sources":["../../../../src/time-travel/servedView/requestOnly.ts"],"names":[],"mappings":"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"}

package/dist/esm/time-travel/servedView/system.d.ts

@@ -0,0 +1,15 @@
+import type { InjectionRecord } from '../../recorders/core/types.js';
+import type { findingsLedgerPiece } from '../../core/agent/findings/serve.js';
+import type { ontologyPiece } from '../../ontology/serve.js';
+import { evidenceRecoveryPiece } from '../../core/agent/evidence/recovery.js';
+import type { EpochLocation } from '../epochs.js';
+import type { ServedPiece } from '../servedView.js';
+type RecoveryPiece = ReturnType<typeof evidenceRecoveryPiece>;
+type OntologyPiece = ReturnType<typeof ontologyPiece>;
+type FindingsPiece = ReturnType<typeof findingsLedgerPiece>;
+type ComposedPiece = InjectionRecord | Exclude<RecoveryPiece | OntologyPiece | FindingsPiece, undefined>;
+/** Read the initial system pieces before the conversation and findings. */
+export declare function systemInputs(location: EpochLocation, served: boolean): readonly [injections: InjectionRecord[], iteration: number, recovery: RecoveryPiece];
+/** Project the ordered system pieces; text is joined only at final assembly. */
+export declare function systemPieces(injections: InjectionRecord[], recovery: RecoveryPiece, ontology: OntologyPiece | undefined, findings: FindingsPiece): readonly [composedPieces: ComposedPiece[], pieces: ServedPiece[]];
+export {};

package/dist/esm/time-travel/servedView/system.js

@@ -0,0 +1,36 @@
+import { contributingPieces } from '../../core/agent/composeRequest.js';
+import { evidenceRecoveryPiece } from '../../core/agent/evidence/recovery.js';
+import { readAtCall } from './recordReads.js';
+/** Read the initial system pieces before the conversation and findings. */
+export function systemInputs(location, served) {
+    // ── the system prompt ──────────────────────────────────────────────────
+    // The pieces are committed; the joined string never is. Same function the
+    // stage used, over the records as the stage read them.
+    const injections = (readAtCall(location, 'systemPromptInjections', served) ??
+        []);
+    const iteration = readAtCall(location, 'iteration', served);
+    const recovery = evidenceRecoveryPiece(readAtCall(location, 'evidenceRecovery', served), readAtCall(location, 'evidenceRecoveryUsed', served), iteration);
+    return [injections, iteration, recovery];
+}
+/** Project the ordered system pieces; text is joined only at final assembly. */
+export function systemPieces(injections, recovery, ontology, findings) {
+    // ── the system prompt, joined ──────────────────────────────────────────
+    // Injections, then the recovery piece, then the ontology piece, then the
+    // findings piece — the fixed order the stage joins in. Every request-only
+    // piece is joined, never committed as an injection.
+    const composedPieces = recovery === undefined && ontology === undefined && findings === undefined
+        ? injections
+        : [
+            ...injections,
+            ...(recovery === undefined ? [] : [recovery]),
+            ...(ontology === undefined ? [] : [ontology]),
+            ...(findings === undefined ? [] : [findings]),
+        ];
+    const pieces = contributingPieces(composedPieces).map((record) => ({
+        text: record.rawContent,
+        slot: record.slot,
+        source: record.source,
+    }));
+    return [composedPieces, pieces];
+}
+//# sourceMappingURL=system.js.map

package/dist/esm/time-travel/servedView/system.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.js","sourceRoot":"","sources":["../../../../src/time-travel/servedView/system.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAG9E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAS9C,2EAA2E;AAC3E,MAAM,UAAU,YAAY,CAC1B,QAAuB,EACvB,MAAe;IAEf,0EAA0E;IAC1E,0EAA0E;IAC1E,uDAAuD;IACvD,MAAM,UAAU,GAAG,CAAC,UAAU,CAAC,QAAQ,EAAE,wBAAwB,EAAE,MAAM,CAAC;QACxE,EAAE,CAAsB,CAAC;IAC3B,MAAM,SAAS,GAAG,UAAU,CAAC,QAAQ,EAAE,WAAW,EAAE,MAAM,CAAW,CAAC;IACtE,MAAM,QAAQ,GAAG,qBAAqB,CACpC,UAAU,CAAC,QAAQ,EAAE,kBAAkB,EAAE,MAAM,CAAgD,EAC/F,UAAU,CAAC,QAAQ,EAAE,sBAAsB,EAAE,MAAM,CAAwB,EAC3E,SAAS,CACV,CAAC;IACF,OAAO,CAAC,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;AAC3C,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,YAAY,CAC1B,UAA6B,EAC7B,QAAuB,EACvB,QAAmC,EACnC,QAAuB;IAEvB,0EAA0E;IAC1E,yEAAyE;IACzE,0EAA0E;IAC1E,oDAAoD;IACpD,MAAM,cAAc,GAClB,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,SAAS;QACxE,CAAC,CAAC,UAAU;QACZ,CAAC,CAAC;YACE,GAAG,UAAU;YACb,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YAC7C,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YAC7C,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;SAC9C,CAAC;IACR,MAAM,MAAM,GAAkB,kBAAkB,CAAC,cAAc,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAChF,IAAI,EAAE,MAAM,CAAC,UAAU;QACvB,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,MAAM,EAAE,MAAM,CAAC,MAAM;KACtB,CAAC,CAAC,CAAC;IACJ,OAAO,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;AAClC,CAAC"}

package/dist/esm/time-travel/servedView/tools.d.ts

@@ -0,0 +1,9 @@
+import type { LLMToolSchema } from '../../provider-contract/types.js';
+import { toolsWithheld } from '../../core/agent/composeRequest.js';
+import type { EpochLocation } from '../epochs.js';
+/** Select the lazy schema fallback, then the recorded forced-tool name. */
+export declare function toolsAt(location: EpochLocation, served: boolean): readonly [
+    registered: LLMToolSchema[],
+    withheld: ReturnType<typeof toolsWithheld>,
+    forced: string | undefined
+];

package/dist/esm/time-travel/servedView/tools.js

@@ -0,0 +1,36 @@
+import { toolsWithheld } from '../../core/agent/composeRequest.js';
+import { FORCED_OUTPUT_TOOL_KEY } from '../../core/agent/receipt/receipt.js';
+import { readAtCall, readRunConstant } from './recordReads.js';
+/** A committed tool list, or `undefined` when the key held no array — which is
+ *  what makes it a FALLBACK CHAIN and not a merge: the first key that holds a
+ *  list is the list this call served, and an empty array is an answer. */
+function toolListOf(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+/** Select the lazy schema fallback, then the recorded forced-tool name. */
+export function toolsAt(location, served) {
+    // ── the tools ──────────────────────────────────────────────────────────
+    // `dynamicToolSchemas` is the PRE-assembly list. Two rules run after it and
+    // both are on the record: a withheld call (the wrap-up, or any call after
+    // the evidence revision under an enforcing answer validation —
+    // `composeRequest.ts` · `toolsWithheld`) is served no tool, and a
+    // 'tool-forced' strategy adds one.
+    //
+    // TWO committed sources, for the same reason the conversation above has two
+    // and with the same ordering rule (9.91.0). The agent charts map the tools
+    // slot's output onto `dynamicToolSchemas` at the mount boundary; the
+    // message-API charts carry it out under the slot's own name. Reading only
+    // the first reported an EMPTY tool list on a chart that served three — a
+    // Lens DENYING, about a fact the log holds perfectly well. The agent key is
+    // read first and the fallback is reached only when it holds no array, so no
+    // agent recording changes.
+    const withheld = toolsWithheld(readAtCall(location, 'wrapUpAsked', served), readAtCall(location, 'toolsOffAfterRevision', served));
+    const dynamic = toolListOf(readAtCall(location, 'dynamicToolSchemas', served)) ??
+        toolListOf(readAtCall(location, 'toolSchemas', served)) ??
+        [];
+    const registered = withheld !== null ? [] : dynamic;
+    const forcedRaw = readRunConstant(location, FORCED_OUTPUT_TOOL_KEY, served);
+    const forced = typeof forcedRaw === 'string' && forcedRaw.length > 0 ? forcedRaw : undefined;
+    return [registered, withheld, forced];
+}
+//# sourceMappingURL=tools.js.map

package/dist/esm/time-travel/servedView/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../../../src/time-travel/servedView/tools.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAE7E,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAE/D;;0EAE0E;AAC1E,SAAS,UAAU,CAAC,KAAc;IAChC,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE,KAAyB,CAAC,CAAC,CAAC,SAAS,CAAC;AACvE,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,OAAO,CACrB,QAAuB,EACvB,MAAe;IAMf,0EAA0E;IAC1E,4EAA4E;IAC5E,0EAA0E;IAC1E,+DAA+D;IAC/D,kEAAkE;IAClE,mCAAmC;IACnC,EAAE;IACF,4EAA4E;IAC5E,2EAA2E;IAC3E,qEAAqE;IACrE,0EAA0E;IAC1E,yEAAyE;IACzE,4EAA4E;IAC5E,4EAA4E;IAC5E,2BAA2B;IAC3B,MAAM,QAAQ,GAAG,aAAa,CAC5B,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,CAAC,EAC3C,UAAU,CAAC,QAAQ,EAAE,uBAAuB,EAAE,MAAM,CAAC,CACtD,CAAC;IACF,MAAM,OAAO,GACX,UAAU,CAAC,UAAU,CAAC,QAAQ,EAAE,oBAAoB,EAAE,MAAM,CAAC,CAAC;QAC9D,UAAU,CAAC,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,CAAC,CAAC;QACvD,EAAE,CAAC;IACL,MAAM,UAAU,GAAG,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;IACpD,MAAM,SAAS,GAAG,eAAe,CAAC,QAAQ,EAAE,sBAAsB,EAAE,MAAM,CAAC,CAAC;IAC5E,MAAM,MAAM,GAAG,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7F,OAAO,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;AACxC,CAAC"}

package/dist/esm/time-travel/servedView/value.d.ts

@@ -0,0 +1,38 @@
+import type { ServedView } from '../servedView.js';
+/**
+ * The BOUNDARY half of the fold law: a container that leaves this file is this
+ * file's own.
+ *
+ * `keyedFold` deep-freezes its answers, so nothing a consumer does to a view
+ * can reach a later epoch. This is the second, cheaper guarantee on top of it:
+ * the two arrays a view would otherwise ALIAS straight out of the fold — the
+ * conversation and the tool schemas — are copied, so `ServedView` is a value in
+ * its own right and not a window onto the fold's cache. Elements are the fold's
+ * frozen objects; the container is ours.
+ *
+ * Every other array on a view is built by a projection and aliases nothing,
+ * so it needs the COPY half of this and not the freeze — but it is
+ * frozen anyway, by {@link frozenView}, because the type says `readonly`
+ * throughout and a claim that is true of two containers out of six is a claim
+ * a reader cannot use.
+ */
+export declare function detachedList<T>(items: readonly T[]): readonly T[];
+/**
+ * A `ServedView` is a VALUE — all of it, not the two containers that happened
+ * to need copying.
+ *
+ * Freezing the whole view costs a handful of `Object.freeze` calls per epoch
+ * over containers that are already the right size to hand a person: a few
+ * system pieces, at most one request-only line, a tool list, the gaps. It buys
+ * one sentence a reader can rely on instead of a rule about which two arrays
+ * are safe. `messages.asSent` and `tools.schemas` are already frozen by
+ * {@link detachedList} — their ELEMENTS are the fold's own frozen objects and
+ * this function does not walk into them, because they are not ours to freeze
+ * twice.
+ *
+ * What this is NOT: protection against a shared reference. Nothing on a view
+ * except those two arrays is shared with anything — every other container is
+ * built here per call. The freeze makes the type's promise exact; the copy in
+ * `detachedList` is what makes the fold safe.
+ */
+export declare function frozenView(view: ServedView): ServedView;

package/dist/esm/time-travel/servedView/value.js

@@ -0,0 +1,57 @@
+/**
+ * The BOUNDARY half of the fold law: a container that leaves this file is this
+ * file's own.
+ *
+ * `keyedFold` deep-freezes its answers, so nothing a consumer does to a view
+ * can reach a later epoch. This is the second, cheaper guarantee on top of it:
+ * the two arrays a view would otherwise ALIAS straight out of the fold — the
+ * conversation and the tool schemas — are copied, so `ServedView` is a value in
+ * its own right and not a window onto the fold's cache. Elements are the fold's
+ * frozen objects; the container is ours.
+ *
+ * Every other array on a view is built by a projection and aliases nothing,
+ * so it needs the COPY half of this and not the freeze — but it is
+ * frozen anyway, by {@link frozenView}, because the type says `readonly`
+ * throughout and a claim that is true of two containers out of six is a claim
+ * a reader cannot use.
+ */
+export function detachedList(items) {
+    return Object.freeze([...items]);
+}
+/**
+ * A `ServedView` is a VALUE — all of it, not the two containers that happened
+ * to need copying.
+ *
+ * Freezing the whole view costs a handful of `Object.freeze` calls per epoch
+ * over containers that are already the right size to hand a person: a few
+ * system pieces, at most one request-only line, a tool list, the gaps. It buys
+ * one sentence a reader can rely on instead of a rule about which two arrays
+ * are safe. `messages.asSent` and `tools.schemas` are already frozen by
+ * {@link detachedList} — their ELEMENTS are the fold's own frozen objects and
+ * this function does not walk into them, because they are not ours to freeze
+ * twice.
+ *
+ * What this is NOT: protection against a shared reference. Nothing on a view
+ * except those two arrays is shared with anything — every other container is
+ * built here per call. The freeze makes the type's promise exact; the copy in
+ * `detachedList` is what makes the fold safe.
+ */
+export function frozenView(view) {
+    for (const piece of view.system.pieces)
+        Object.freeze(piece);
+    Object.freeze(view.system.pieces);
+    for (const line of view.messages.requestOnly)
+        Object.freeze(line);
+    Object.freeze(view.messages.requestOnly);
+    Object.freeze(view.tools.names);
+    for (const gap of view.gaps)
+        Object.freeze(gap);
+    Object.freeze(view.gaps);
+    if (view.basis !== undefined)
+        Object.freeze(view.basis);
+    Object.freeze(view.system);
+    Object.freeze(view.messages);
+    Object.freeze(view.tools);
+    return Object.freeze(view);
+}
+//# sourceMappingURL=value.js.map

package/dist/esm/time-travel/servedView/value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"value.js","sourceRoot":"","sources":["../../../../src/time-travel/servedView/value.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CAAI,KAAmB;IACjD,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,UAAU,CAAC,IAAgB;IACzC,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM;QAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC7D,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW;QAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAClE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IACzC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAChC,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,IAAI;QAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAChD,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS;QAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxD,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1B,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC7B,CAAC"}

package/dist/esm/time-travel/servedView.d.ts

@@ -92,8 +92,8 @@
  * That gap's sentence used to end with the causes that produce it. That is
  * PROSE DOING DATA'S JOB: a frozen constant cannot know what happened at the
  * site it is printed beside, so it listed the causes somebody could think of —
- * and a path it had never accounted for, the shape refusal in `readReceipt`
- * below, made the count AND the verdict false with nobody editing the string.
+ * and a path it had never accounted for, the shape refusal by `readReceipt`
+ * in `recordReads.ts`, made the count and verdict false without a string edit.
  * The discriminating fact moved to the one place that holds it: `readReceipt`
  * reports whether the receipt key held nothing or held something it refused,
  * and {@link ServedGap.cause} carries that answer out.
@@ -153,7 +153,9 @@
  */
 import type { LLMMessage, LLMToolSchema } from '../provider-contract/types.js';
 import type { ContextRole, ContextSlot, ContextSource } from '../events/types.js';
-import { type StoredReceipt } from '../core/agent/receipt/receipt.js';
+import type { StoredReceipt } from '../core/agent/receipt/receipt.js';
+import { SERVED_GAPS, UNGAPPED_FIELDS } from './servedView/gaps.js';
+export { SERVED_GAPS, UNGAPPED_FIELDS };
 /** One piece of the composed system string, in wire order. */
 export interface ServedPiece {
     readonly text: string;
@@ -301,68 +303,6 @@ export interface ServedGap {
      */
     readonly cause?: ServedGapCause;
 }
-/**
- * The gap catalogue. Exported because a reader that renders a served view
- * renders its gaps beside it, and a renderer should print the library's own
- * sentence rather than invent one.
- */
-export declare const SERVED_GAPS: Readonly<Record<ServedGapKind, Omit<ServedGap, 'gap'>>>;
-/**
- * The fields no gap names, and the reason each one needs none — the OTHER half
- * of the account.
- *
- * WHY IT EXISTS. `SERVED_GAPS` was hand-checked against the two shapes three
- * times in one release and came up short every time, because "is every field
- * named by a gap?" was a question a person answered by reading. It is now a
- * question a walk answers: `test/time-travel/gap-catalogue-walk.test.ts`
- * enumerates every field a real `Receipt` and a real `ServedView` carry and
- * requires each one to be named by a gap OR to be a key here. A field in
- * neither fails, by name.
- *
- * So this is not an exemption list. It is the place a field goes when NO GAP'S
- * MECHANISM EXPLAINS IT, and the value is the reason in one sentence, for the
- * next person who asks why the field has no gap. Adding a key here is as
- * reviewable as adding one to a gap, and that is the point: both are a claim
- * somebody wrote down.
- *
- * TWO reasons qualified when this list was written, and one of them has since
- * emptied out:
- *
- *   • NO FOLD CAN FAIL TO PRODUCE IT — the field is read straight off the
- *     located epoch, never through a fold. `callRuntimeStageId` is this kind.
- *   • ITS ABSENCE IS UNIVERSAL AND HAS NOTHING TO DO WITH THIS RECORDING — no
- *     chart IN THIS LIBRARY supplies it, on any run, so no gap about a limit of
- *     the rebuild describes it. `omittedForAttention` WAS this kind from
- *     9.88.0's fourth review round to 9.93.0, and is not any more: the
- *     measurement it rested on ("no chart drops for attention") had missed the
- *     agent chart's window stage, which evicts turns for budget on every run
- *     whose strategy engages and now files them on the receipt. A recorded
- *     drop can be lost in exactly one way — with the receipt — so the field is
- *     named by `no-receipt-on-chart` and is not here. The kind is kept on this
- *     list because the next universally-absent field will need it, and because
- *     a reason that was true for five releases and then measured false is
- *     worth a sentence where the next person looks.
- *
- * A field a gap DOES name never belongs here, whatever else is also true of it.
- * `epoch` was a key here through three rounds, on the true-but-irrelevant
- * ground that `servedAt(k)` hands `k` back; what a base-less fold changes is
- * what that number MEANS, `servedViews()` returns the fold's number outright,
- * and `no-fold-base` names it now.
- *
- * Paths are spelled as they are on the shape that HAS the field — both keys
- * here are `ServedView` fields. Gap `fields` are spelled as `Receipt` paths —
- * see {@link ServedGap.fields} for the places the two shapes differ.
- *
- * @example
- * ```ts
- * import { SERVED_GAPS, UNGAPPED_FIELDS } from 'agentfootprint';
- *
- * // Why does nothing explain `callRuntimeStageId`? Because nothing has to.
- * UNGAPPED_FIELDS['callRuntimeStageId'];
- * Object.keys(SERVED_GAPS).length; // 7 gap kinds
- * ```
- */
-export declare const UNGAPPED_FIELDS: Readonly<Record<string, string>>;
 /**
  * THE SERVED VIEW: what the model was handed on one epoch, rebuilt.
  *