agentfootprint 7.16.0 → 7.17.0

package/dist/core/agent/window/strategies/slidingWindow.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * slidingWindow — keep the last N turns, drop what is older.
+ *
+ * Pattern: WindowStrategy implementation. Its own module, registering
+ *          nothing at import.
+ * Role:    core/ layer.
+ * Emits:   N/A — the stage emits, records and costs; this file decides.
+ *
+ * The market's simplest window policy (LangChain's `trim_messages`, the
+ * "last N messages" every framework ships). Two things are different here:
+ *
+ *   1. **It refuses by name.** It goes through the SAME turn segmentation and
+ *      the SAME refusal engine as compaction, so it will not drop half of a
+ *      `tool_use` / `tool_result` pair, will not drop an unanswered tool call
+ *      whose answer may still arrive, will not drop the tool a paused run is
+ *      waiting on or a pending check-in, and cannot touch the system
+ *      envelope. Message-counting trimmers split those pairs and the vendor
+ *      rejects the request; this one steps over them and says so in the
+ *      record.
+ *   2. **It says what it dropped.** Every dropped message is an eviction
+ *      event with its measured lifetime, and the record names the stage ids
+ *      the messages came from. The turns themselves stay in the commit log,
+ *      byte for byte.
+ *
+ * It triggers on turn COUNT, not tokens — so it needs no summarizer, makes no
+ * LLM call, and runs on ANY provider, including the ones that report no usage
+ * at all. Nothing here is unmeasurable, so nothing here throws.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slidingWindow = exports.SLIDING_WINDOW = void 0;
+const drop_js_1 = require("./drop.js");
+const options_js_1 = require("../options.js");
+/** `WindowRecord.strategy` written by every record this strategy files. */
+exports.SLIDING_WINDOW = 'sliding-window';
+/**
+ * Keep the most recent `keepRecentTurns` turns in the live window and drop
+ * the older ones — except anything that refuses.
+ *
+ * @example
+ * ```ts
+ * import { Agent, slidingWindow } from 'agentfootprint';
+ * import { ollama } from 'agentfootprint/llm-providers';
+ *
+ * // Works on a provider that reports no usage at all: the trigger is turns.
+ * const agent = Agent.create({ provider: ollama(), model: 'llama3' })
+ *   .window(slidingWindow({ keepRecentTurns: 12 }))
+ *   .build();
+ * ```
+ */
+function slidingWindow(options) {
+    const config = (0, options_js_1.resolveSlidingWindowOptions)(options, 'slidingWindow');
+    return {
+        name: exports.SLIDING_WINDOW,
+        async plan(input) {
+            // Did not engage: the window is already within its target depth. No
+            // record — the ledger tracks what this strategy DID, not every time it
+            // looked and there was nothing to do.
+            if (input.turns.length <= config.keepRecentTurns)
+                return undefined;
+            const outcome = (0, drop_js_1.dropOldestSpan)(input, config.keepRecentTurns, exports.SLIDING_WINDOW);
+            const record = {
+                strategy: exports.SLIDING_WINDOW,
+                iteration: input.iteration,
+                keepRecentTurns: config.keepRecentTurns,
+                removedStageIds: outcome.removedStageIds,
+                removedMessageCount: outcome.removedMessageCount,
+                windowCharsBefore: outcome.windowCharsBefore,
+                windowCharsAfter: outcome.windowCharsAfter,
+                turnsBefore: outcome.turnsBefore,
+                turnsAfter: outcome.turnsAfter,
+                refusals: outcome.refusals,
+            };
+            // No `budgetPressure`: this strategy has no token budget. Reporting a
+            // cap nobody configured would be the invented number the family exists
+            // to refuse — so it reports evictions and stays quiet about budgets.
+            return {
+                ...(outcome.window !== undefined && { window: outcome.window }),
+                ...(outcome.rebase !== undefined && { rebase: outcome.rebase }),
+                record,
+                evictions: outcome.evictions,
+            };
+        },
+    };
+}
+exports.slidingWindow = slidingWindow;
+//# sourceMappingURL=slidingWindow.js.map

package/dist/core/agent/window/strategies/slidingWindow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slidingWindow.js","sourceRoot":"","sources":["../../../../../src/core/agent/window/strategies/slidingWindow.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;;;AAEH,uCAA2C;AAC3C,8CAA4D;AAI5D,2EAA2E;AAC9D,QAAA,cAAc,GAAG,gBAAgB,CAAC;AAE/C;;;;;;;;;;;;;;GAcG;AACH,SAAgB,aAAa,CAAC,OAA6B;IACzD,MAAM,MAAM,GAAG,IAAA,wCAA2B,EAAC,OAAO,EAAE,eAAe,CAAC,CAAC;IAErE,OAAO;QACL,IAAI,EAAE,sBAAc;QAEpB,KAAK,CAAC,IAAI,CAAC,KAA0B;YACnC,oEAAoE;YACpE,uEAAuE;YACvE,sCAAsC;YACtC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,IAAI,MAAM,CAAC,eAAe;gBAAE,OAAO,SAAS,CAAC;YAEnE,MAAM,OAAO,GAAG,IAAA,wBAAc,EAAC,KAAK,EAAE,MAAM,CAAC,eAAe,EAAE,sBAAc,CAAC,CAAC;YAC9E,MAAM,MAAM,GAAwB;gBAClC,QAAQ,EAAE,sBAAc;gBACxB,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,eAAe,EAAE,MAAM,CAAC,eAAe;gBACvC,eAAe,EAAE,OAAO,CAAC,eAAe;gBACxC,mBAAmB,EAAE,OAAO,CAAC,mBAAmB;gBAChD,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;gBAC5C,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;gBAC1C,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,QAAQ,EAAE,OAAO,CAAC,QAAQ;aAC3B,CAAC;YAEF,sEAAsE;YACtE,uEAAuE;YACvE,qEAAqE;YACrE,OAAO;gBACL,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;gBAC/D,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;gBAC/D,MAAM;gBACN,SAAS,EAAE,OAAO,CAAC,SAAS;aAC7B,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AArCD,sCAqCC"}

package/dist/core/agent/window/strategies/summarizeOldest.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * summarizeOldest — fold the oldest foldable turns into one summary message.
+ *
+ * Pattern: WindowStrategy implementation. Its own module, importing nothing
+ *          that registers anything, so a bundle that never mentions it never
+ *          carries it (and never carries the summarizer machinery either).
+ * Role:    core/ layer.
+ * Emits:   N/A — the stage emits, records and costs; this file decides.
+ *
+ * This is what `.compaction({...})` configures, and the market's familiar
+ * move (Claude Code / the Claude Agent SDK call it compaction). What is
+ * different here is not the fold — it is that the fold is filed as a claim:
+ * a summary is a claim ABOUT the past, and the past itself stays in the
+ * commit log, byte for byte.
+ *
+ * Everything it decides, it explains. Every engaged path returns a record —
+ * including the paths that change nothing, which are the ones a person
+ * debugging an over-budget window actually needs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeOldest = exports.SUMMARIZE_OLDEST = void 0;
+const errors_js_1 = require("../errors.js");
+const options_js_1 = require("../options.js");
+const removal_js_1 = require("../removal.js");
+const summarize_js_1 = require("../summarize.js");
+const turns_js_1 = require("../turns.js");
+/** `WindowRecord.strategy` written by every record this strategy files. */
+exports.SUMMARIZE_OLDEST = 'summarize-oldest';
+/**
+ * Fold the oldest contiguous run of foldable turns into one summary message,
+ * keeping the recent turns and stepping over anything unresolved.
+ *
+ * Triggered by COUNTED tokens: the last call's adapter-reported input tokens
+ * against `thresholdTokens`. A provider that reports no usage gets
+ * `CompactionUnmeasurableError` rather than an invented number.
+ *
+ * @example
+ * ```ts
+ * import { Agent, summarizeOldest } from 'agentfootprint';
+ *
+ * const agent = Agent.create({ provider: anthropic(), model: 'claude-sonnet-4-5' })
+ *   .window(summarizeOldest({ thresholdTokens: 120_000, summarizer: anthropic() }))
+ *   .build();
+ * // `.compaction({ ... })` is this exact line, spelled shorter.
+ * ```
+ */
+function summarizeOldest(options) {
+    const config = (0, options_js_1.resolveCompactionOptions)(options, 'summarizeOldest');
+    return {
+        name: exports.SUMMARIZE_OLDEST,
+        async plan(input) {
+            const { history, turns, iteration, measured } = input;
+            // Iteration 1: nothing has been sent, so nothing has been counted. A
+            // compactor that acted here would be guessing.
+            if (measured === undefined)
+                return undefined;
+            if (measured.input === 0 && measured.output === 0) {
+                throw new errors_js_1.CompactionUnmeasurableError(input.providerName);
+            }
+            if (measured.input <= config.thresholdTokens)
+                return undefined;
+            const model = config.model ?? input.agentModel;
+            const charsBefore = (0, turns_js_1.windowChars)(history);
+            const base = {
+                strategy: exports.SUMMARIZE_OLDEST,
+                iteration,
+                measuredTokens: measured.input,
+                thresholdTokens: config.thresholdTokens,
+                overBudget: true,
+                windowCharsBefore: charsBefore,
+            };
+            const unchanged = (refusals, extra = {}) => ({
+                record: {
+                    ...base,
+                    removedStageIds: [],
+                    removedMessageCount: 0,
+                    foldedStageIds: [],
+                    foldedMessageCount: 0,
+                    windowCharsAfter: charsBefore,
+                    summaryChars: 0,
+                    refusals,
+                    ...extra,
+                },
+                evictions: [],
+                budgetPressure: {
+                    capTokens: config.thresholdTokens,
+                    projectedTokens: measured.input,
+                    planAction: 'none',
+                },
+            });
+            const plan = input.planRemoval(config.keepRecentTurns, (turn) => (0, summarize_js_1.isCompactedSummary)(turn.messages[0]));
+            if (plan.from === -1) {
+                // Nothing foldable. The window stays over budget and the run proceeds
+                // — reported, not silently truncated.
+                return unchanged(plan.refusals);
+            }
+            const spanStart = turns[plan.from].start;
+            const spanEnd = turns[plan.to].start + turns[plan.to].length;
+            const head = history.slice(0, spanStart);
+            const span = history.slice(spanStart, spanEnd);
+            const tail = history.slice(spanEnd);
+            // A broken summarizer must not take down the run.
+            let summary;
+            try {
+                const result = await (0, summarize_js_1.runSummarizer)(config.summarizer, model, span, input.signal);
+                summary = {
+                    text: result.text,
+                    usage: { input: result.usage.input, output: result.usage.output },
+                };
+            }
+            catch (err) {
+                return {
+                    ...unchanged([
+                        { reason: 'summarizer-failed', turnIndex: plan.from, messageIndex: spanStart },
+                        ...plan.refusals,
+                    ]),
+                    warning: `the summarizer threw, so nothing was folded this iteration and the window ` +
+                        `stays over budget (${measured.input} tokens vs a threshold of ` +
+                        `${config.thresholdTokens}). The run continues. Cause: ` +
+                        `${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+            const summaryMessage = (0, summarize_js_1.buildSummaryMessage)(summary.text, {
+                foldedMessageCount: span.length,
+                iteration,
+                model,
+            });
+            const spend = { model, usage: summary.usage };
+            // Would the fold actually help? A summary plus its authored frame can be
+            // LONGER than a handful of short turns; folding then spends a call to
+            // grow the window and lose detail at the same time. Both sides are
+            // measured in chars — one unit, an exact comparison, not a token guess.
+            if (summaryMessage.content.length >= (0, turns_js_1.windowChars)(span)) {
+                return {
+                    ...unchanged([
+                        { reason: 'summary-not-smaller', turnIndex: plan.from, messageIndex: spanStart },
+                        ...plan.refusals,
+                    ], { summaryChars: summaryMessage.content.length, summarizerTokens: summary.usage }),
+                    spend, // the call still happened, so it still counts
+                };
+            }
+            const foldedAtMs = input.now();
+            const facts = input.removalFacts((0, removal_js_1.indexRange)(spanStart, spanEnd), foldedAtMs);
+            const window = [...head, summaryMessage, ...tail];
+            const record = {
+                ...base,
+                removedStageIds: facts.removedStageIds,
+                removedMessageCount: span.length,
+                // The 7.16 names for the two values above, kept and deprecated.
+                foldedStageIds: facts.removedStageIds,
+                foldedMessageCount: span.length,
+                windowCharsAfter: (0, turns_js_1.windowChars)(window),
+                summaryChars: summaryMessage.content.length,
+                summarizerTokens: summary.usage,
+                refusals: plan.refusals,
+            };
+            return {
+                window,
+                rebase: {
+                    headCount: head.length,
+                    keptTailCount: tail.length,
+                    insertedAtMs: foldedAtMs,
+                },
+                record,
+                evictions: facts.evictions,
+                budgetPressure: {
+                    capTokens: config.thresholdTokens,
+                    projectedTokens: measured.input,
+                    planAction: 'summarize',
+                },
+                spend,
+            };
+        },
+    };
+}
+exports.summarizeOldest = summarizeOldest;
+//# sourceMappingURL=summarizeOldest.js.map

package/dist/core/agent/window/strategies/summarizeOldest.js.map

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

package/dist/core/agent/window/strategies/tokenBudget.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * tokenBudget — compaction's trigger discipline, without the summarizer.
+ *
+ * Pattern: WindowStrategy implementation. Its own module, registering
+ *          nothing at import.
+ * Role:    core/ layer.
+ * Emits:   N/A — the stage emits, records and costs; this file decides.
+ *
+ * The market's other familiar policy: cap the window at a token budget
+ * (Mastra's `TokenLimiter` is the closest sibling). What is different here is
+ * the same thing that is different about compaction — the number is COUNTED,
+ * never guessed:
+ *
+ *   • the trigger reads the input tokens the PROVIDER reported for the last
+ *     call, not a character estimate and not a divide-by-four heuristic;
+ *   • a provider that reports no usage gets `CompactionUnmeasurableError` by
+ *     name, the same refusal `.compaction()` makes, rather than an invented
+ *     window size or a configured budget that silently never applies.
+ *
+ * When over budget it drops the oldest contiguous removable span — the same
+ * span compaction would have folded, chosen by the same refusal engine — and
+ * writes no summary at all. Nothing is claimed about what left, because
+ * nothing was read: the record and the eviction events name it, and the
+ * commit log still has it verbatim.
+ *
+ * Use it over `summarizeOldest` when you would rather lose the old turns than
+ * pay a summarizer to paraphrase them, and over `slidingWindow` when the
+ * thing you are actually defending is a token bill rather than a turn depth.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenBudget = exports.TOKEN_BUDGET = void 0;
+const drop_js_1 = require("./drop.js");
+const errors_js_1 = require("../errors.js");
+const options_js_1 = require("../options.js");
+/** `WindowRecord.strategy` written by every record this strategy files. */
+exports.TOKEN_BUDGET = 'token-budget';
+/**
+ * Drop the oldest turns whenever the last call's adapter-reported input
+ * tokens exceed `thresholdTokens`.
+ *
+ * @example
+ * ```ts
+ * import { Agent, tokenBudget } from 'agentfootprint';
+ *
+ * const agent = Agent.create({ provider: anthropic(), model: 'claude-sonnet-4-5' })
+ *   .window(tokenBudget({ thresholdTokens: 120_000 }))
+ *   .build();
+ * ```
+ */
+function tokenBudget(options) {
+    const config = (0, options_js_1.resolveTokenBudgetOptions)(options, 'tokenBudget');
+    return {
+        name: exports.TOKEN_BUDGET,
+        async plan(input) {
+            const { measured } = input;
+            // Iteration 1: nothing has been sent, so nothing has been counted.
+            if (measured === undefined)
+                return undefined;
+            // Counted, not guessed — the same wall compaction hits, by the same name.
+            if (measured.input === 0 && measured.output === 0) {
+                throw new errors_js_1.CompactionUnmeasurableError(input.providerName);
+            }
+            if (measured.input <= config.thresholdTokens)
+                return undefined;
+            const outcome = (0, drop_js_1.dropOldestSpan)(input, config.keepRecentTurns, exports.TOKEN_BUDGET);
+            const record = {
+                strategy: exports.TOKEN_BUDGET,
+                iteration: input.iteration,
+                measuredTokens: measured.input,
+                thresholdTokens: config.thresholdTokens,
+                overBudget: true,
+                keepRecentTurns: config.keepRecentTurns,
+                removedStageIds: outcome.removedStageIds,
+                removedMessageCount: outcome.removedMessageCount,
+                windowCharsBefore: outcome.windowCharsBefore,
+                windowCharsAfter: outcome.windowCharsAfter,
+                refusals: outcome.refusals,
+            };
+            return {
+                ...(outcome.window !== undefined && { window: outcome.window }),
+                ...(outcome.rebase !== undefined && { rebase: outcome.rebase }),
+                record,
+                evictions: outcome.evictions,
+                budgetPressure: {
+                    capTokens: config.thresholdTokens,
+                    projectedTokens: measured.input,
+                    planAction: outcome.removedMessageCount > 0 ? 'evict' : 'none',
+                },
+            };
+        },
+    };
+}
+exports.tokenBudget = tokenBudget;
+//# sourceMappingURL=tokenBudget.js.map

package/dist/core/agent/window/strategies/tokenBudget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenBudget.js","sourceRoot":"","sources":["../../../../../src/core/agent/window/strategies/tokenBudget.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;;;AAEH,uCAA2C;AAC3C,4CAA2D;AAC3D,8CAA0D;AAI1D,2EAA2E;AAC9D,QAAA,YAAY,GAAG,cAAc,CAAC;AAE3C;;;;;;;;;;;;GAYG;AACH,SAAgB,WAAW,CAAC,OAA2B;IACrD,MAAM,MAAM,GAAG,IAAA,sCAAyB,EAAC,OAAO,EAAE,aAAa,CAAC,CAAC;IAEjE,OAAO;QACL,IAAI,EAAE,oBAAY;QAElB,KAAK,CAAC,IAAI,CAAC,KAA0B;YACnC,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;YAE3B,mEAAmE;YACnE,IAAI,QAAQ,KAAK,SAAS;gBAAE,OAAO,SAAS,CAAC;YAC7C,0EAA0E;YAC1E,IAAI,QAAQ,CAAC,KAAK,KAAK,CAAC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAClD,MAAM,IAAI,uCAA2B,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAC5D,CAAC;YACD,IAAI,QAAQ,CAAC,KAAK,IAAI,MAAM,CAAC,eAAe;gBAAE,OAAO,SAAS,CAAC;YAE/D,MAAM,OAAO,GAAG,IAAA,wBAAc,EAAC,KAAK,EAAE,MAAM,CAAC,eAAe,EAAE,oBAAY,CAAC,CAAC;YAC5E,MAAM,MAAM,GAAsB;gBAChC,QAAQ,EAAE,oBAAY;gBACtB,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,cAAc,EAAE,QAAQ,CAAC,KAAK;gBAC9B,eAAe,EAAE,MAAM,CAAC,eAAe;gBACvC,UAAU,EAAE,IAAI;gBAChB,eAAe,EAAE,MAAM,CAAC,eAAe;gBACvC,eAAe,EAAE,OAAO,CAAC,eAAe;gBACxC,mBAAmB,EAAE,OAAO,CAAC,mBAAmB;gBAChD,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;gBAC5C,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;gBAC1C,QAAQ,EAAE,OAAO,CAAC,QAAQ;aAC3B,CAAC;YAEF,OAAO;gBACL,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;gBAC/D,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;gBAC/D,MAAM;gBACN,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,cAAc,EAAE;oBACd,SAAS,EAAE,MAAM,CAAC,eAAe;oBACjC,eAAe,EAAE,QAAQ,CAAC,KAAK;oBAC/B,UAAU,EAAE,OAAO,CAAC,mBAAmB,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM;iBAC/D;aACF,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AA7CD,kCA6CC"}

package/dist/core/agent/window/strategy.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * window/strategy — PUBLIC. How a window strategy is shaped.
+ *
+ * Pattern: Strategy (GoF), with the dangerous half of the decision handed in
+ *          pre-bound rather than left to the implementer to re-derive.
+ * Role:    core/ layer. The window stage does the wiring — read the meter,
+ *          write the window, emit, record, cost — and delegates the one
+ *          interesting question to a strategy:
+ *
+ *              given the segmented turns and what the provider actually
+ *              counted → what should the window become, and what does the
+ *              ledger need to be told about it?
+ *
+ * Emits:   N/A. A strategy is pure decision + (optionally) its own LLM call;
+ *          it never touches scope, never emits, and never writes. That is
+ *          what makes it testable without a chart, and what keeps the
+ *          "record everything you did" duty in ONE place (the stage) rather
+ *          than duplicated per strategy.
+ *
+ * Three strategies ship — `summarizeOldest` (what `.compaction()`
+ * configures), `slidingWindow`, `tokenBudget` — and `.window(...)` takes any
+ * object that satisfies `WindowStrategy`.
+ *
+ * Two things are deliberately NOT left to the implementer:
+ *
+ *   1. **The refusal rules.** `planRemoval` arrives already bound to this
+ *      iteration's turns and guards. A strategy cannot forget that an
+ *      unanswered tool call must not leave the window, because it never gets
+ *      the chance to decide that for itself — it asks, and it is told, with
+ *      every refusal named. That is safety by construction, not by docs.
+ *   2. **Provenance.** `removalFacts` turns "these indices left" into the
+ *      stage ids that wrote them and how long each lived. A strategy cannot
+ *      file a removal it cannot name.
+ *
+ * The TRIGGER, by contrast, is entirely the strategy's own: `plan` is called
+ * at every ReAct iteration boundary and answers `undefined` when it did not
+ * engage. That is why `slidingWindow` can run on a provider that reports no
+ * usage at all while `summarizeOldest` and `tokenBudget` refuse by name.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=strategy.js.map

package/dist/core/agent/window/strategy.js.map

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

package/dist/core/agent/window/summarize.js.map

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

package/dist/core/agent/{compaction → window}/turns.js

@@ -1,19 +1,28 @@
 "use strict";
 /**
- * compaction/turns — where a turn boundary is, and which turns may fold.
+ * window/turns — where a turn boundary is, and which turns may leave.
  *
  * Pattern: Pure functions over the window (no scope, no I/O, no clock).
- * Role:    core/ layer. The whole safety argument of compaction lives here:
- *          a fold that splits an assistant's `tool_use` from its
- *          `tool_result` produces a request the vendor rejects, and a fold
- *          that swallows an unanswered question destroys the referent of the
- *          answer that has not arrived yet.
+ * Role:    core/ layer. THE refusal engine. Every window strategy — the three
+ *          that ship, and any a consumer writes — decides what leaves the
+ *          window by calling these functions and nothing else, because the
+ *          whole safety argument of the family lives here:
+ *
+ *            a removal that splits an assistant's `tool_use` from its
+ *            `tool_result` produces a request the vendor rejects, and a
+ *            removal that swallows an unanswered question destroys the
+ *            referent of the answer that has not arrived yet.
+ *
+ *          Strategies never import this module. `WindowStrategyInput` hands
+ *          them `planRemoval` already bound to this iteration's turns and
+ *          guards, so a strategy CANNOT skip the refusal rules — that is a
+ *          property of the seam, not of the documentation.
  * Emits:   N/A.
  *
- * Testable on its own — see `test/core/agent/compaction-turns.test.ts`.
+ * Testable on its own — see `test/core/window-turns.test.ts`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.windowChars = exports.planFold = exports.refusalFor = exports.answeredCallIds = exports.segmentTurns = void 0;
+exports.windowChars = exports.planRemoval = exports.refusalFor = exports.answeredCallIds = exports.segmentTurns = void 0;
 /**
  * Segment a window into turns.
  *
@@ -54,7 +63,7 @@ function answeredCallIds(history) {
 }
 exports.answeredCallIds = answeredCallIds;
 /**
- * Why this turn may NOT fold, or `undefined` when it may.
+ * Why this turn may NOT leave the window, or `undefined` when it may.
  *
  * Order matters only for which reason gets reported first; every check is
  * independent. `paused-tool` / `pending-check-in` are separated from
@@ -62,22 +71,22 @@ exports.answeredCallIds = answeredCallIds;
  * fact about the world, and "we are waiting on a human" is what the person
  * reading the trace needs to see.
  */
-function refusalFor(turn, ctx) {
+function refusalFor(turn, guards) {
     for (const msg of turn.messages) {
         if (msg.role === 'system')
             return 'system-envelope';
     }
-    const paused = ctx.pausedToolCallId;
+    const paused = guards.pausedToolCallId;
     if (paused !== undefined && paused.length > 0) {
         for (const msg of turn.messages) {
             const holdsPaused = msg.toolCallId === paused || (msg.toolCalls ?? []).some((tc) => tc.id === paused);
             if (holdsPaused)
-                return ctx.pausedCheckIn === true ? 'pending-check-in' : 'paused-tool';
+                return guards.pausedCheckIn === true ? 'pending-check-in' : 'paused-tool';
         }
     }
     for (const msg of turn.messages) {
         for (const call of msg.toolCalls ?? []) {
-            if (!ctx.answeredCallIds.has(call.id))
+            if (!guards.answeredCallIds.has(call.id))
                 return 'unresolved-tool-call';
         }
     }
@@ -85,22 +94,31 @@ function refusalFor(turn, ctx) {
 }
 exports.refusalFor = refusalFor;
 /**
- * Choose the fold span: the LONGEST CONTIGUOUS run of foldable candidate
- * turns, starting at the oldest foldable one.
+ * Choose the removal span: the LONGEST CONTIGUOUS run of removable candidate
+ * turns, starting at the oldest removable one.
  *
  * Contiguity is not fussiness — it is what keeps the conversation in order.
  * A fold replaces its span with ONE summary message; if the span skipped over
- * an unfoldable turn, that turn would end up after a summary of things that
- * happened before it. So an unfoldable turn at the front is stepped over (the
- * fold "takes the next oldest instead") and an unfoldable turn in the middle
- * ends the span. Everything not folded keeps its position.
+ * an unremovable turn, that turn would end up after a summary of things that
+ * happened before it. So an unremovable turn at the front is stepped over (the
+ * span "takes the next oldest instead") and an unremovable turn in the middle
+ * ends the span. Everything not removed keeps its position.
+ *
+ * The drop strategies take the same span for a second reason: it is what makes
+ * a refusal reason mean the same thing under every strategy. A turn that ends
+ * the span this iteration is retried the next one — by which time the tool
+ * result it was waiting on has usually arrived.
  *
- * @param turns         the window's turn segmentation
- * @param keepRecent    how many trailing turns are off-limits
- * @param ctx           foldability inputs
- * @param isSummaryTurn true for a turn that is a summary a prior fold wrote
+ * @param turns             the window's turn segmentation
+ * @param keepRecent        how many trailing turns are off-limits
+ * @param guards            what must not leave (unanswered calls, the pause)
+ * @param isExistingSummary optional: true for a turn that is a summary a prior
+ *   fold wrote. When the whole span is one such turn, the plan refuses with
+ *   `only-existing-summary` — re-summarizing a summary spends an LLM call to
+ *   lose detail. The drop strategies omit it: a drop spends nothing, so there
+ *   is nothing to protect against.
  */
-function planFold(turns, keepRecent, ctx, isSummaryTurn) {
+function planRemoval(turns, keepRecent, guards, isExistingSummary) {
     const refusals = [];
     const candidateCount = Math.max(0, turns.length - keepRecent);
     for (let i = candidateCount; i < turns.length; i++) {
@@ -114,7 +132,7 @@ function planFold(turns, keepRecent, ctx, isSummaryTurn) {
     let to = -1;
     for (let i = 0; i < candidateCount; i++) {
         const turn = turns[i];
-        const reason = refusalFor(turn, ctx);
+        const reason = refusalFor(turn, guards);
         if (reason === undefined) {
             if (from === -1)
                 from = i;
@@ -123,12 +141,16 @@ function planFold(turns, keepRecent, ctx, isSummaryTurn) {
         }
         before.push({ reason, turnIndex: i, messageIndex: turn.start });
         if (from !== -1)
-            break; // an unfoldable turn ENDS the span
+            break; // an unremovable turn ENDS the span
     }
     // A span that is nothing but one existing summary is not worth a call:
     // re-summarizing a summary spends tokens to lose detail and names nothing
     // new. It becomes foldable again as soon as a real turn joins it.
-    if (from !== -1 && from === to && isSummaryTurn(turns[from])) {
+    const summaryOnly = isExistingSummary !== undefined &&
+        from !== -1 &&
+        from === to &&
+        isExistingSummary(turns[from]);
+    if (summaryOnly) {
         return {
             from: -1,
             to: -1,
@@ -141,7 +163,7 @@ function planFold(turns, keepRecent, ctx, isSummaryTurn) {
     }
     return { from, to, refusals: [...before, ...refusals] };
 }
-exports.planFold = planFold;
+exports.planRemoval = planRemoval;
 /** Total characters of message content in a window. Exact; not tokens. */
 function windowChars(history) {
     let total = 0;

package/dist/core/agent/window/turns.js.map

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

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

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * window/types — what each window strategy accepts, and what it writes into
+ * the ledger.
+ *
+ * Pattern: Value objects (no behavior) + resolved-config types.
+ * Role:    core/ layer. The law this whole folder exists to keep is stated
+ *          once, here, because every other file implements a piece of it:
+ *          **a window strategy edits the WINDOW, never the LEDGER.**
+ * Emits:   N/A (types only).
+ *
+ * The window is `scope.history` — the array `call-llm` hands the provider.
+ * The ledger is footprintjs's commit log, which is append-only: the turns a
+ * strategy removes from the window were committed by `seed#0` /
+ * `tool-calls#N` BEFORE the removal and stay in those bundles byte-identical
+ * forever. A strategy therefore cannot destroy history even in principle; it
+ * can only stop re-sending it. A summary is a CLAIM about the past, so it is
+ * filed as a claim — its own recorded step, naming every `runtimeStageId` it
+ * folded. A drop is an ABSENCE, and it is filed the same way: the record and
+ * the eviction events name what left, by id.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

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

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