agentfootprint 2.5.0 → 2.6.0

package/dist/esm/cache/CacheDecisionSubflow.js

@@ -0,0 +1,166 @@
+/**
+ * CacheDecision subflow — provider-agnostic translation from
+ * `activeInjections + DSL directives` → `CacheMarker[]`.
+ *
+ * This is the core "policy → markers" Lego layer. It runs every
+ * iteration (after slot subflows produce their output, before the
+ * CacheGate decider). Pure transform: no IO, no LLM calls, no
+ * provider knowledge.
+ *
+ * Algorithm:
+ *   1. Build a `CachePolicyContext` from agent state
+ *   2. For each injection in `activeInjections`, evaluate its
+ *      `metadata.cache` directive against the context → cacheable boolean
+ *   3. For each slot (system / tools / messages):
+ *      a. Walk the slot's contributions in order
+ *      b. Find the LAST index that's contiguous-from-start cacheable
+ *      c. Emit one CacheMarker at that boundary if any cacheable
+ *
+ * Each marker is provider-agnostic. Provider strategy translates
+ * to wire format in Phase 6+.
+ *
+ * Special case — base system prompt: the agent's
+ * `agent.getSystemPromptCachePolicy()` value is folded in at index 0
+ * of the system slot. Always-on injections (Steering / Fact /
+ * always-active rules) follow.
+ */
+import { flowChart } from 'footprintjs';
+/**
+ * Evaluate a `CachePolicy` against the current context.
+ * Returns `true` if the policy says THIS iteration's content is cacheable.
+ */
+export function evaluateCachePolicy(policy, ctx) {
+    if (policy === 'always')
+        return true;
+    if (policy === 'never')
+        return false;
+    if (policy === 'while-active') {
+        // Membership in `activeInjections` IS being-active. By the time
+        // the subflow walks an injection, the InjectionEngine has already
+        // confirmed it's active for THIS iteration. So 'while-active'
+        // policy → cacheable while in the list.
+        return true;
+    }
+    if (typeof policy === 'object' && policy !== null && 'until' in policy) {
+        // Cache UNTIL predicate returns true. So cacheable iff !predicate.
+        try {
+            return !policy.until(ctx);
+        }
+        catch {
+            // Failing predicates are treated as "do not cache" — fail-closed.
+            // Avoids the failure mode where a buggy predicate accidentally
+            // caches volatile content.
+            return false;
+        }
+    }
+    // Unknown policy form — fail-closed (don't cache).
+    return false;
+}
+/**
+ * Identify which slots an injection contributes to. An injection can
+ * target multiple slots simultaneously (Skills target both system +
+ * tools); we visit each contributing slot independently.
+ */
+export function injectionTargetSlots(injection) {
+    const slots = [];
+    if (injection.inject.systemPrompt && injection.inject.systemPrompt.length > 0) {
+        slots.push('system');
+    }
+    if (injection.inject.tools && injection.inject.tools.length > 0) {
+        slots.push('tools');
+    }
+    if (injection.inject.messages && injection.inject.messages.length > 0) {
+        slots.push('messages');
+    }
+    return slots;
+}
+/**
+ * Pure transform: state → markers. Exported so tests can exercise
+ * the algorithm directly without the FlowChartExecutor ceremony of
+ * mounting the subflow as a child of a parent chart.
+ *
+ * The subflow body (`decide` below) is a thin wrapper that pulls
+ * state from scope and delegates here.
+ */
+export function computeCacheMarkers(state) {
+    // Kill switch short-circuits immediately
+    if (state.cachingDisabled)
+        return [];
+    const ctx = {
+        iteration: state.iteration,
+        iterationsRemaining: Math.max(0, state.maxIterations - state.iteration),
+        userMessage: state.userMessage,
+        ...(state.lastToolName !== undefined && { lastToolName: state.lastToolName }),
+        cumulativeInputTokens: state.cumulativeInputTokens,
+    };
+    const perSlot = {
+        system: [],
+        tools: [],
+        messages: [],
+    };
+    // Index 0 of system slot is the base system prompt
+    perSlot.system.push({
+        cacheable: evaluateCachePolicy(state.systemPromptCachePolicy, ctx),
+        reason: 'base system prompt',
+    });
+    // Walk each active injection
+    for (const inj of state.activeInjections) {
+        const policy = inj.metadata?.cache ?? 'never';
+        const cacheable = evaluateCachePolicy(policy, ctx);
+        const reason = `${inj.flavor}:${inj.id}`;
+        for (const slot of injectionTargetSlots(inj)) {
+            perSlot[slot].push({ cacheable, reason });
+        }
+    }
+    // Find per-slot last-contiguous-cacheable boundary; emit a marker per
+    // slot that has at least one cacheable entry from index 0.
+    const markers = [];
+    for (const slot of ['system', 'tools', 'messages']) {
+        const entries = perSlot[slot];
+        let boundary = -1;
+        let lastReason = '';
+        for (let i = 0; i < entries.length; i++) {
+            if (!entries[i].cacheable)
+                break;
+            boundary = i;
+            lastReason = entries[i].reason;
+        }
+        if (boundary >= 0) {
+            markers.push({
+                field: slot,
+                boundaryIndex: boundary,
+                ttl: 'short',
+                reason: `${slot} stable prefix (${boundary + 1} entries, ending at ${lastReason})`,
+            });
+        }
+    }
+    return markers;
+}
+/**
+ * The decision function. Thin scope-binding wrapper around
+ * `computeCacheMarkers`.
+ */
+function decide(scope) {
+    scope.cacheMarkers = computeCacheMarkers({
+        activeInjections: scope.activeInjections,
+        iteration: scope.iteration,
+        maxIterations: scope.maxIterations,
+        userMessage: scope.userMessage,
+        ...(scope.lastToolName !== undefined && { lastToolName: scope.lastToolName }),
+        cumulativeInputTokens: scope.cumulativeInputTokens,
+        systemPromptCachePolicy: scope.systemPromptCachePolicy,
+        cachingDisabled: scope.cachingDisabled,
+    });
+}
+/**
+ * The cache-decision subflow. Mounted into the agent's main chart
+ * after the slot subflows (System / Messages / Tools) and before
+ * the CacheGate decider stage.
+ *
+ * Mounted via `addSubFlowChartNext(SUBFLOW_IDS.CACHE_DECISION, ...)`
+ * with `arrayMerge: ArrayMergeMode.Replace` on the outputMapper —
+ * `cacheMarkers` MUST replace, not concatenate, across iterations
+ * (same lesson as the v2.5.1 InjectionEngine fix).
+ */
+export const cacheDecisionSubflow = flowChart('DecideCacheMarkers', decide, 'decide-cache-markers', undefined, 'CacheDecision: walk activeInjections, evaluate cache directives, emit CacheMarker[]').build();
+//# sourceMappingURL=CacheDecisionSubflow.js.map

package/dist/esm/cache/CacheDecisionSubflow.js.map

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

package/dist/esm/cache/CacheGateDecider.js

@@ -0,0 +1,116 @@
+/**
+ * CacheGate — runtime decider that gates cache-marker application.
+ *
+ * Runs every iteration AFTER the CacheDecision subflow produces
+ * `scope.cacheMarkers` and BEFORE the BuildLLMRequest stage applies
+ * them. Three rules can fall through to "no-markers" (skip caching);
+ * default branch is "apply-markers" (proceed with caching).
+ *
+ * Why a decider stage and not a function: footprintjs's `decide()`
+ * captures evidence on `FlowRecorder.onDecision` natively. The
+ * `cacheRecorder()` (Phase 9) reads
+ * `event.evidence.rules.find(r => r.matched).inputs[]` to surface
+ * WHY caching was applied or skipped each iter. Same channel
+ * footprintjs uses for every other decision; same renderer in Lens.
+ *
+ * Three rules (evaluated top-down; first match wins):
+ *   1. Kill switch — `Agent.create({ caching: 'off' })` was set
+ *   2. Hit-rate floor — recent hit rate < 30%; cache writes outpacing
+ *      reads, auto-disable to avoid the cache-write penalty
+ *   3. Skill churn — active skills changing too rapidly for caching
+ *      to amortize (Anthropic LLM expert's concern from Phase 4 review)
+ *
+ * Default branch (no rule matches): `'apply-markers'`.
+ */
+import { decide } from 'footprintjs';
+/**
+ * Hit-rate floor below which we auto-disable caching. The 30% number
+ * is calibrated for Anthropic's pricing: cache write costs +25%
+ * premium, cache read costs 90% off. Break-even at ~25% hit rate.
+ * 30% gives a buffer; below that we're losing money on writes that
+ * never recoup.
+ *
+ * Reasoning: if hit rate is X, cost-per-token vs no caching is
+ *   (1 - X) * 1.0 + X * 0.1                                    // baseline
+ *   minus
+ *   write_iters * 1.25 + read_iters * 0.1                       // with caching
+ * Solving for break-even gives X ≈ 0.25 for typical agent shapes.
+ */
+export const HIT_RATE_FLOOR = 0.3;
+/**
+ * Window size for skill-churn detection. Last 5 iterations of
+ * active skill IDs are inspected.
+ */
+export const SKILL_CHURN_WINDOW = 5;
+/**
+ * Threshold above which skill churn is considered detected: this many
+ * UNIQUE skills in the rolling window. With window=5 and threshold=3,
+ * the pattern A → B → A → C still triggers (3 unique skills in 4 iters).
+ */
+export const SKILL_CHURN_THRESHOLD = 3;
+/**
+ * Pure helper: detect skill churn given a rolling history.
+ * Exported for direct testing without decider/scope ceremony.
+ */
+export function detectSkillChurn(history, windowSize = SKILL_CHURN_WINDOW, threshold = SKILL_CHURN_THRESHOLD) {
+    if (history.length < threshold)
+        return false; // not enough history yet
+    const recent = history.slice(-windowSize);
+    const uniqueSkills = new Set();
+    for (const s of recent) {
+        if (s !== undefined)
+            uniqueSkills.add(s);
+    }
+    return uniqueSkills.size >= threshold;
+}
+/**
+ * The decider function. Mounted via `addDeciderFunction` in the
+ * agent's main chart in Phase 6.
+ *
+ * Returns a `DecisionResult` (footprintjs's `decide()` helper output)
+ * which the engine unwraps via `.branch` for routing AND publishes
+ * `evidence.rules[matched].inputs[]` to FlowRecorder.onDecision.
+ * cacheRecorder (Phase 9) subscribes to that channel for the audit trail.
+ *
+ * For non-routing consumers (testing the decision in isolation), read
+ * the `.branch` field of the returned DecisionResult.
+ */
+export function cacheGateDecide(scope) {
+    return decide(scope, [
+        {
+            when: (s) => s.cachingDisabled === true,
+            then: 'no-markers',
+            label: "kill switch active (Agent.create({ caching: 'off' }))",
+        },
+        {
+            when: (s) => s.recentHitRate !== undefined && s.recentHitRate < HIT_RATE_FLOOR,
+            then: 'no-markers',
+            label: `hit rate < ${HIT_RATE_FLOOR * 100}% — auto-disable`,
+        },
+        {
+            when: (s) => detectSkillChurn(s.skillHistory),
+            then: 'no-markers',
+            label: `skill churn (≥${SKILL_CHURN_THRESHOLD} unique skills in last ${SKILL_CHURN_WINDOW} iters)`,
+        },
+    ], 'apply-markers');
+}
+/**
+ * Update the skill-history rolling window. Called as a function
+ * stage BEFORE the CacheGate decider. Reads the current iteration's
+ * active skill (head of `activatedInjectionIds`) and appends to the
+ * `skillHistory` array.
+ *
+ * Window length is bounded at `SKILL_CHURN_WINDOW * 2` so the array
+ * doesn't grow unboundedly across long agent runs. Old entries
+ * fall off the front naturally.
+ */
+export function updateSkillHistory(scope) {
+    const current = scope.activatedInjectionIds?.[0];
+    const prior = scope.skillHistory ?? [];
+    const next = [...prior, current];
+    // Bounded buffer — keep window*2 to give detectSkillChurn room
+    // without pinning every prior iteration in memory.
+    const trimmed = next.length > SKILL_CHURN_WINDOW * 2 ? next.slice(-SKILL_CHURN_WINDOW * 2) : next;
+    scope.skillHistory = trimmed;
+}
+//# sourceMappingURL=CacheGateDecider.js.map

package/dist/esm/cache/CacheGateDecider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheGateDecider.js","sourceRoot":"","sources":["../../../src/cache/CacheGateDecider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,MAAM,EAAwC,MAAM,aAAa,CAAC;AA6B3E;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,GAAG,CAAC;AAElC;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAEpC;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAEvC;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAAwC,EACxC,aAAqB,kBAAkB,EACvC,YAAoB,qBAAqB;IAEzC,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS;QAAE,OAAO,KAAK,CAAC,CAAC,yBAAyB;IACvE,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,CAAC;IAC1C,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IACvC,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,IAAI,CAAC,KAAK,SAAS;YAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC3C,CAAC;IACD,OAAO,YAAY,CAAC,IAAI,IAAI,SAAS,CAAC;AACxC,CAAC;AAQD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,KAAiC;IAC/D,OAAO,MAAM,CACX,KAAK,EACL;QACE;YACE,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,eAAe,KAAK,IAAI;YACvC,IAAI,EAAE,YAAY;YAClB,KAAK,EAAE,uDAAuD;SAC/D;QACD;YACE,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,KAAK,SAAS,IAAI,CAAC,CAAC,aAAa,GAAG,cAAc;YAC9E,IAAI,EAAE,YAAY;YAClB,KAAK,EAAE,cAAc,cAAc,GAAG,GAAG,kBAAkB;SAC5D;QACD;YACE,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC,YAAY,CAAC;YAC7C,IAAI,EAAE,YAAY;YAClB,KAAK,EAAE,iBAAiB,qBAAqB,0BAA0B,kBAAkB,SAAS;SACnG;KACF,EACD,eAAe,CAChB,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAGE;IAEF,MAAM,OAAO,GAAG,KAAK,CAAC,qBAAqB,EAAE,CAAC,CAAC,CAAC,CAAC;IACjD,MAAM,KAAK,GAAG,KAAK,CAAC,YAAY,IAAI,EAAE,CAAC;IACvC,MAAM,IAAI,GAAG,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC;IACjC,+DAA+D;IAC/D,mDAAmD;IACnD,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,kBAAkB,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,kBAAkB,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAClG,KAAK,CAAC,YAAY,GAAG,OAAO,CAAC;AAC/B,CAAC"}

package/dist/esm/cache/applyCachePolicy.js

@@ -0,0 +1,50 @@
+/**
+ * applyCachePolicy — internal helper for injection factories.
+ *
+ * Each factory (`defineSkill`, `defineSteering`, `defineFact`,
+ * `defineInstruction`, `defineMemory`) calls this to merge the
+ * consumer-supplied `cache` option with the flavor-specific default.
+ * The merged policy lands in `Injection.metadata.cache` for the
+ * CacheDecision subflow (Phase 4) to read back.
+ *
+ * Why it lives in src/cache/ (not co-located with each factory):
+ *   - Single source of truth for per-flavor defaults
+ *   - Tests for the defaults live in one place (test/cache/)
+ *   - Adding a new factory means adding one entry to the map below;
+ *     not duplicating the default-resolution logic five times
+ */
+/**
+ * Per-flavor default `cache` values when consumer doesn't specify.
+ * These match the documentation in `CachePolicy`'s JSDoc — keep
+ * synchronized.
+ */
+const FLAVOR_DEFAULTS = Object.freeze({
+    steering: 'always',
+    fact: 'always',
+    skill: 'while-active',
+    instruction: 'never',
+    memory: 'while-active',
+});
+/**
+ * Resolve the effective `cache` policy for an injection.
+ *
+ * @param flavor - The injection flavor (drives the default if `consumerValue` undefined)
+ * @param consumerValue - What the consumer wrote in `cache:` (or undefined)
+ * @returns The effective CachePolicy. Always defined.
+ */
+export function resolveCachePolicy(flavor, consumerValue) {
+    if (consumerValue !== undefined)
+        return consumerValue;
+    // Fall back to per-flavor default; if flavor unknown, default is 'never'
+    // (conservative — unfamiliar injections shouldn't accidentally cache).
+    return FLAVOR_DEFAULTS[flavor] ?? 'never';
+}
+/**
+ * Read-only access to the per-flavor default table. Exported for
+ * tests asserting the documented defaults are wired correctly. Not
+ * intended for runtime use — callers should use `resolveCachePolicy`.
+ */
+export function getFlavorDefault(flavor) {
+    return FLAVOR_DEFAULTS[flavor] ?? 'never';
+}
+//# sourceMappingURL=applyCachePolicy.js.map

package/dist/esm/cache/applyCachePolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyCachePolicy.js","sourceRoot":"","sources":["../../../src/cache/applyCachePolicy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;;GAIG;AACH,MAAM,eAAe,GAA0C,MAAM,CAAC,MAAM,CAAC;IAC3E,QAAQ,EAAE,QAAQ;IAClB,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,cAAc;IACrB,WAAW,EAAE,OAAO;IACpB,MAAM,EAAE,cAAc;CACvB,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAA6C,EAC7C,aAAsC;IAEtC,IAAI,aAAa,KAAK,SAAS;QAAE,OAAO,aAAa,CAAC;IACtD,yEAAyE;IACzE,uEAAuE;IACvE,OAAO,eAAe,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC;AAC5C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC7C,OAAO,eAAe,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC;AAC5C,CAAC"}

package/dist/esm/cache/cacheRecorder.js

@@ -0,0 +1,116 @@
+/**
+ * cacheRecorder() — observability for the v2.6 cache layer.
+ *
+ * Subscribes to:
+ *   - `FlowRecorder.onDecision` — captures CacheGate routing decisions
+ *     (apply-markers / no-markers + the rule that fired + evidence
+ *     from `decide()`). Read directly from `event.evidence.rules[matched]`
+ *     since footprintjs already auto-captures predicate `inputs[]`.
+ *   - `agentfootprint.stream.llm_end` events — read provider's `usage`
+ *     and call the agent's CacheStrategy.extractMetrics() to normalize
+ *     into CacheMetrics (cacheReadTokens / cacheWriteTokens / fresh).
+ *
+ * Produces:
+ *   - per-iteration `agentfootprint.cache.applied` events (markers
+ *     applied this iter or empty if skipped) — for Lens trace
+ *   - per-iteration `agentfootprint.cache.metrics` events (hit/write
+ *     token counts + estimated dollars via PricingTable) — for
+ *     dashboards
+ *   - a turn-end summary printable via `recorder.report()` —
+ *     numeric tally plus dollars saved
+ *
+ * v2.6 LIMITATION: doesn't yet write `scope.recentHitRate` back into
+ * agent state. CacheGate's hit-rate-floor rule won't fire automatically;
+ * consumers can manually wire feedback via `Agent.create(...).attach(rec)`.
+ * Full feedback loop deferred to v2.7 (needs an agent-side accessor
+ * convention since recorders don't normally write to scope).
+ */
+export function cacheRecorder(options = {}) {
+    const perIter = [];
+    let lastDecision;
+    let iterationCounter = 0;
+    function dollars(tokens, kind) {
+        if (!options.pricing)
+            return 0;
+        const model = options.model ?? 'unknown';
+        return tokens * options.pricing.pricePerToken(model, kind);
+    }
+    const handle = {
+        id: 'cache-recorder',
+        onDecision(event) {
+            // Only care about CacheGate decisions; identified by the
+            // decider's stage id (the third arg to addDeciderFunction).
+            if (event.decider !== 'cache-gate')
+                return;
+            const matched = event.evidence?.rules.find((r) => r.matched);
+            lastDecision = {
+                branch: event.chosen,
+                ...(matched?.label !== undefined && { rule: matched.label }),
+            };
+        },
+        onEmit(event) {
+            if (event.type !== 'agentfootprint.stream.llm_end')
+                return;
+            iterationCounter++;
+            const usage = event.payload.usage;
+            const metrics = options.strategy?.extractMetrics(usage);
+            const branch = lastDecision?.branch ?? 'apply-markers';
+            // Compute dollar math:
+            //   spent = freshInput * inputPrice
+            //         + cacheRead * cacheReadPrice
+            //         + cacheWrite * cacheWritePrice
+            //   no-cache cost = (freshInput + cacheRead + cacheWrite) * inputPrice
+            //   saved        = no-cache cost - spent
+            let dollarsSpent = 0;
+            let savedVsNoCache = 0;
+            if (metrics) {
+                dollarsSpent =
+                    dollars(metrics.freshInputTokens, 'input') +
+                        dollars(metrics.cacheReadTokens, 'cacheRead') +
+                        dollars(metrics.cacheWriteTokens, 'cacheWrite');
+                const noCacheCost = dollars(metrics.freshInputTokens + metrics.cacheReadTokens + metrics.cacheWriteTokens, 'input');
+                savedVsNoCache = noCacheCost - dollarsSpent;
+            }
+            const entry = {
+                iteration: iterationCounter,
+                branch,
+                ...(lastDecision?.rule !== undefined && { rule: lastDecision.rule }),
+                ...(metrics !== undefined && { metrics }),
+                dollarsSpent,
+                dollarsSavedVsNoCache: savedVsNoCache,
+            };
+            perIter.push(entry);
+            lastDecision = undefined;
+        },
+        report() {
+            const apply = perIter.filter((p) => p.branch === 'apply-markers').length;
+            const skip = perIter.filter((p) => p.branch === 'no-markers').length;
+            const cacheRead = perIter.reduce((s, p) => s + (p.metrics?.cacheReadTokens ?? 0), 0);
+            const cacheWrite = perIter.reduce((s, p) => s + (p.metrics?.cacheWriteTokens ?? 0), 0);
+            const fresh = perIter.reduce((s, p) => s + (p.metrics?.freshInputTokens ?? 0), 0);
+            const totalRequest = cacheRead + cacheWrite + fresh;
+            const hitRate = totalRequest > 0 ? cacheRead / totalRequest : 0;
+            const dollarsSpent = perIter.reduce((s, p) => s + p.dollarsSpent, 0);
+            const dollarsSaved = perIter.reduce((s, p) => s + p.dollarsSavedVsNoCache, 0);
+            return Object.freeze({
+                totalIterations: perIter.length,
+                applyMarkersIterations: apply,
+                noMarkersIterations: skip,
+                cacheReadTokensTotal: cacheRead,
+                cacheWriteTokensTotal: cacheWrite,
+                freshInputTokensTotal: fresh,
+                hitRate,
+                estimatedDollarsSpent: dollarsSpent,
+                estimatedDollarsSavedVsNoCache: dollarsSaved,
+                perIter: Object.freeze([...perIter]),
+            });
+        },
+        reset() {
+            perIter.length = 0;
+            lastDecision = undefined;
+            iterationCounter = 0;
+        },
+    };
+    return handle;
+}
+//# sourceMappingURL=cacheRecorder.js.map

package/dist/esm/cache/cacheRecorder.js.map

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

package/dist/esm/cache/index.js

@@ -0,0 +1,36 @@
+/**
+ * agentfootprint/cache — public surface for the cache layer (v2.6+).
+ *
+ * Importing this module side-effect-registers every built-in cache
+ * strategy in the registry. The agentfootprint main barrel imports
+ * from here so consumers get the registered strategies without
+ * needing to know they exist.
+ *
+ * Strategies registered as of v2.6:
+ *   - NoOp (wildcard '*' fallback) — always available, registered by
+ *     the registry module itself
+ *   - AnthropicCacheStrategy ('anthropic', 'browser-anthropic')
+ *
+ * Future strategies (Phase 8+):
+ *   - OpenAICacheStrategy
+ *   - BedrockCacheStrategy
+ *   - GeminiCacheStrategy (v2.7+, async handle-based)
+ *
+ * Public types (re-exported for consumers):
+ *   - CachePolicy, CacheMarker, CacheStrategy, CacheCapabilities,
+ *     CacheMetrics, CachePolicyContext, CacheStrategyContext
+ */
+// Side-effect imports — register strategies on module load.
+import './strategies/AnthropicCacheStrategy.js';
+import './strategies/OpenAICacheStrategy.js';
+import './strategies/BedrockCacheStrategy.js';
+// Strategy registry
+export { getDefaultCacheStrategy, registerCacheStrategy, listRegisteredStrategies, } from './strategyRegistry.js';
+// Built-in strategy classes (for consumers who want explicit overrides)
+export { NoOpCacheStrategy } from './strategies/NoOpCacheStrategy.js';
+export { AnthropicCacheStrategy } from './strategies/AnthropicCacheStrategy.js';
+export { OpenAICacheStrategy } from './strategies/OpenAICacheStrategy.js';
+export { BedrockCacheStrategy } from './strategies/BedrockCacheStrategy.js';
+// Recorder
+export { cacheRecorder } from './cacheRecorder.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/cache/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,4DAA4D;AAC5D,OAAO,wCAAwC,CAAC;AAChD,OAAO,qCAAqC,CAAC;AAC7C,OAAO,sCAAsC,CAAC;AAa9C,oBAAoB;AACpB,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,uBAAuB,CAAC;AAE/B,wEAAwE;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAChF,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAE5E,WAAW;AACX,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/esm/cache/strategies/AnthropicCacheStrategy.js

@@ -0,0 +1,98 @@
+/**
+ * AnthropicCacheStrategy — translates agnostic CacheMarker[] to
+ * Anthropic API's `cache_control: { type: 'ephemeral' }` markers.
+ *
+ * Anthropic-specific behaviors honored:
+ *   - **4-marker limit**: Anthropic allows ≤4 cache breakpoints per
+ *     request. Strategy clamps oversize candidate sets, keeping the
+ *     first 4 in slot order.
+ *   - **TTL mapping**: 'short' → default 5min ephemeral; 'long' →
+ *     `ttl: '1h'` (1-hour beta).
+ *   - **Provider-side hashing**: this strategy doesn't hash — Anthropic
+ *     keys cache by exact byte prefix server-side. We don't need
+ *     content hashes for the v2.6 surface; reserved for v2.7+ if a
+ *     pre-flight cache-warm-check API ships.
+ *
+ * What this strategy DOES vs DOESN'T do:
+ *   - DOES: clamp markers, attach to LLMRequest.cacheMarkers,
+ *     extract metrics from response.usage
+ *   - DOES NOT: rewrite the wire body. The provider
+ *     (BrowserAnthropicProvider) reads `cacheMarkers` and applies
+ *     `cache_control` blocks during body construction. Separation of
+ *     concerns: strategy decides WHAT to cache; provider knows HOW
+ *     to encode on its specific wire.
+ *
+ * Auto-registers in the strategy registry on module import for
+ * provider names: 'anthropic', 'browser-anthropic'.
+ */
+import { registerCacheStrategy } from '../strategyRegistry.js';
+/** Anthropic enforces 4 cache breakpoints per request. */
+const ANTHROPIC_MAX_MARKERS = 4;
+const ANTHROPIC_CAPABILITIES = Object.freeze({
+    enabled: true,
+    maxMarkers: ANTHROPIC_MAX_MARKERS,
+    ttls: ['short', 'long'],
+    fields: ['system', 'tools', 'messages'],
+    automatic: false,
+});
+export class AnthropicCacheStrategy {
+    providerName = 'anthropic';
+    capabilities = ANTHROPIC_CAPABILITIES;
+    async prepareRequest(req, candidates, ctx) {
+        // Honor the agent-side kill switch even if reached this far —
+        // belt-and-suspenders. CacheGate should have routed to no-markers
+        // already, leaving `candidates` empty, but if a buggy gate lets
+        // markers through with cachingDisabled=true, we still respect it.
+        if (ctx.cachingDisabled) {
+            return { request: req, markersApplied: [] };
+        }
+        if (candidates.length === 0) {
+            return { request: req, markersApplied: [] };
+        }
+        // Clamp to Anthropic's 4-marker limit. Keep the first N in
+        // slot order so we cover the most-stable prefixes (system /
+        // always-on injections / tools) before less-stable trailing ones.
+        const markersApplied = candidates.length <= ANTHROPIC_MAX_MARKERS
+            ? candidates
+            : candidates.slice(0, ANTHROPIC_MAX_MARKERS);
+        const request = {
+            ...req,
+            cacheMarkers: markersApplied,
+        };
+        return { request, markersApplied };
+    }
+    extractMetrics(usage) {
+        if (!usage || typeof usage !== 'object')
+            return undefined;
+        const u = usage;
+        const cacheRead = u.cache_read_input_tokens ?? 0;
+        const cacheWrite = u.cache_creation_input_tokens ?? 0;
+        const fresh = u.input_tokens ?? 0;
+        // If neither cache field present, response didn't involve caching.
+        // Returning undefined signals "no cache info" so cacheRecorder
+        // doesn't compute a misleading 0% hit rate.
+        if (cacheRead === 0 && cacheWrite === 0)
+            return undefined;
+        return {
+            cacheReadTokens: cacheRead,
+            cacheWriteTokens: cacheWrite,
+            freshInputTokens: fresh,
+        };
+    }
+}
+// Auto-register on module import. Both 'anthropic' (server-side) and
+// 'browser-anthropic' (browser fetch) providers map to this strategy.
+{
+    const strategy = new AnthropicCacheStrategy();
+    registerCacheStrategy(strategy);
+    // Register the browser variant by cloning with the matching provider name.
+    // Same behavior, different provider.name match-key.
+    const browserStrategy = {
+        providerName: 'browser-anthropic',
+        capabilities: strategy.capabilities,
+        prepareRequest: strategy.prepareRequest.bind(strategy),
+        extractMetrics: strategy.extractMetrics.bind(strategy),
+    };
+    registerCacheStrategy(browserStrategy);
+}
+//# sourceMappingURL=AnthropicCacheStrategy.js.map

package/dist/esm/cache/strategies/AnthropicCacheStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnthropicCacheStrategy.js","sourceRoot":"","sources":["../../../../src/cache/strategies/AnthropicCacheStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAUH,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,0DAA0D;AAC1D,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAEhC,MAAM,sBAAsB,GAAsB,MAAM,CAAC,MAAM,CAAC;IAC9D,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,qBAAqB;IACjC,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,CAAkC;IACxD,MAAM,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,CAAiD;IACvF,SAAS,EAAE,KAAK;CACjB,CAAC,CAAC;AAEH,MAAM,OAAO,sBAAsB;IACxB,YAAY,GAAG,WAAW,CAAC;IAC3B,YAAY,GAAG,sBAAsB,CAAC;IAE/C,KAAK,CAAC,cAAc,CAClB,GAAe,EACf,UAAkC,EAClC,GAAyB;QAKzB,8DAA8D;QAC9D,kEAAkE;QAClE,gEAAgE;QAChE,kEAAkE;QAClE,IAAI,GAAG,CAAC,eAAe,EAAE,CAAC;YACxB,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC;QAC9C,CAAC;QAED,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC;QAC9C,CAAC;QAED,2DAA2D;QAC3D,4DAA4D;QAC5D,kEAAkE;QAClE,MAAM,cAAc,GAClB,UAAU,CAAC,MAAM,IAAI,qBAAqB;YACxC,CAAC,CAAC,UAAU;YACZ,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC;QAEjD,MAAM,OAAO,GAAe;YAC1B,GAAG,GAAG;YACN,YAAY,EAAE,cAAc;SAC7B,CAAC;QACF,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;IACrC,CAAC;IAED,cAAc,CAAC,KAAc;QAC3B,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,SAAS,CAAC;QAC1D,MAAM,CAAC,GAAG,KAIT,CAAC;QACF,MAAM,SAAS,GAAG,CAAC,CAAC,uBAAuB,IAAI,CAAC,CAAC;QACjD,MAAM,UAAU,GAAG,CAAC,CAAC,2BAA2B,IAAI,CAAC,CAAC;QACtD,MAAM,KAAK,GAAG,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC;QAClC,mEAAmE;QACnE,+DAA+D;QAC/D,4CAA4C;QAC5C,IAAI,SAAS,KAAK,CAAC,IAAI,UAAU,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC1D,OAAO;YACL,eAAe,EAAE,SAAS;YAC1B,gBAAgB,EAAE,UAAU;YAC5B,gBAAgB,EAAE,KAAK;SACxB,CAAC;IACJ,CAAC;CACF;AAED,qEAAqE;AACrE,sEAAsE;AACtE,CAAC;IACC,MAAM,QAAQ,GAAG,IAAI,sBAAsB,EAAE,CAAC;IAC9C,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IAChC,2EAA2E;IAC3E,oDAAoD;IACpD,MAAM,eAAe,GAAkB;QACrC,YAAY,EAAE,mBAAmB;QACjC,YAAY,EAAE,QAAQ,CAAC,YAAY;QACnC,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;QACtD,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;KACvD,CAAC;IACF,qBAAqB,CAAC,eAAe,CAAC,CAAC;AACzC,CAAC"}