agentfootprint 7.15.0 → 7.16.0

package/dist/types/core/agent/buildAgentChart.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildAgentChart.d.ts","sourceRoot":"","sources":["../../../../src/core/agent/buildAgentChart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAc,MAAM,aAAa,CAAC;AAE5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAOxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAUrE;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAE/C;;;8DAG0D;IAC1D,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,OAAO,yCAAyC,EAAE,WAAW,CAAC;IAEpG;uEACmE;IACnE,QAAQ,CAAC,uBAAuB,EAAE,WAAW,CAAC;IAE9C;kDAC8C;IAC9C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAG/B,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,YAAY,GAAG,OAAO,CAAC;IAChE,QAAQ,CAAC,gBAAgB,EAAE,OAAO,aAAa,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;IAGxE,QAAQ,CAAC,sBAAsB,EAAE,SAAS,CAAC;IAC3C;;yDAEqD;IACrD,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,QAAQ,CAAC,mBAAmB,EAAE,SAAS,CAAC;IACxC,QAAQ,CAAC,eAAe,EAAE,SAAS,CAAC;IACpC,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,CAAC;IAMrC,QAAQ,CAAC,uBAAuB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEzD;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAG3C;;;;0CAIsC;IACtC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC5D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,SAAS,CA2W/D"}
+{"version":3,"file":"buildAgentChart.d.ts","sourceRoot":"","sources":["../../../../src/core/agent/buildAgentChart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAc,MAAM,aAAa,CAAC;AAE5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAOxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAUrE;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAE/C;;;8DAG0D;IAC1D,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,OAAO,yCAAyC,EAAE,WAAW,CAAC;IAEpG;uEACmE;IACnE,QAAQ,CAAC,uBAAuB,EAAE,WAAW,CAAC;IAE9C;kDAC8C;IAC9C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAG/B,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,YAAY,GAAG,OAAO,CAAC;IAChE,QAAQ,CAAC,gBAAgB,EAAE,OAAO,aAAa,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;IAGxE,QAAQ,CAAC,sBAAsB,EAAE,SAAS,CAAC;IAC3C;;yDAEqD;IACrD,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,QAAQ,CAAC,mBAAmB,EAAE,SAAS,CAAC;IACxC,QAAQ,CAAC,eAAe,EAAE,SAAS,CAAC;IACpC,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,CAAC;IAMrC,QAAQ,CAAC,uBAAuB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEzD;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAG3C;;;;0CAIsC;IACtC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC5D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,SAAS,CA4X/D"}

package/dist/types/core/agent/buildDynamicAgentChart.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildDynamicAgentChart.d.ts","sourceRoot":"","sources":["../../../../src/core/agent/buildDynamicAgentChart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAezD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAgD3D;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,cAAc,GAAG,SAAS,CAwXtE"}
+{"version":3,"file":"buildDynamicAgentChart.d.ts","sourceRoot":"","sources":["../../../../src/core/agent/buildDynamicAgentChart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAezD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAgD3D;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,cAAc,GAAG,SAAS,CAuYtE"}

package/dist/types/core/agent/compaction/errors.d.ts

@@ -0,0 +1,27 @@
+/**
+ * compaction/errors — the one refusal compaction makes out loud.
+ *
+ * Pattern: Typed terminal error (peer of PolicyHaltError).
+ * Role:    core/ layer.
+ * Emits:   N/A.
+ */
+/**
+ * Thrown when compaction is configured but the provider reports no token
+ * usage, so the threshold cannot be COUNTED.
+ *
+ * Compaction is counted, not guessed. Given a provider that reports nothing,
+ * the library has three options: guess the window size (a lie), silently do
+ * nothing (a configured budget that never applies — config that lies), or say
+ * so. It says so, by name, at the first iteration boundary where a completed
+ * call reported zero tokens in AND zero out.
+ *
+ * Terminal: `Agent.run` does not wrap this in `RunCheckpointError`, because
+ * resuming would walk into the same wall with the same provider.
+ */
+export declare class CompactionUnmeasurableError extends Error {
+    readonly name = "CompactionUnmeasurableError";
+    /** `provider.name` of the adapter that reported nothing. */
+    readonly provider: string;
+    constructor(provider: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/core/agent/compaction/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/compaction/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;GAYG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;IACpD,SAAkB,IAAI,iCAAiC;IACvD,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,QAAQ,EAAE,MAAM;CAY7B"}

package/dist/types/core/agent/compaction/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * compaction — keep the live window inside budget without ever losing the
+ * record.
+ *
+ * The one sentence: **compaction edits the WINDOW, never the LEDGER.** Folded
+ * turns stay in the commit log verbatim; the summary enters as its own
+ * recorded step naming every `runtimeStageId` it folded. A summary is a claim
+ * about the past, so this library files it as a claim — not as the past.
+ *
+ * Public surface (re-exported from the package root):
+ *   `CompactionOptions`   what `.compaction()` accepts
+ *   `CompactionRecord`    what each over-budget visit wrote to the ledger
+ *   `FoldRefusal(Reason)` why a turn refused to fold
+ *   `CompactionUnmeasurableError` the refusal for a provider that reports no usage
+ */
+export { CompactionUnmeasurableError } from './errors.js';
+export type { CompactionOptions, CompactionRecord, FoldRefusal, FoldRefusalReason, ResolvedCompaction, } from './types.js';
+export { COMPACTED_FRAME_PREFIX, isCompactedSummary } from './summarize.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/core/agent/compaction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/compaction/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAC1D,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/types/core/agent/compaction/strategy.d.ts

@@ -0,0 +1,104 @@
+/**
+ * compaction/strategy — INTERNAL. How a window strategy is shaped.
+ *
+ * Pattern: Strategy (GoF), deliberately kept private for now.
+ * Role:    core/ layer. The compaction 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, the meter readings, and the
+ *              options → 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.
+ *
+ * **Not exported from any barrel, and not part of the public API.** The only
+ * shipped implementation is `summarizeOldestStrategy` (what `.compaction()`
+ * configures). The interface lives here so that the day a second window
+ * strategy is warranted it is an added file rather than a rewrite of the
+ * stage — but a seam nobody has used twice is a guess, so it stays private
+ * until it has a second implementation to be right about.
+ */
+import type { LLMMessage } from '../../../adapters/types.js';
+import type { MessageOrigin } from '../../../recorders/core/CompactionMeter.js';
+import { type FoldabilityContext, type Turn } from './turns.js';
+import type { CompactionRecord, ResolvedCompaction } from './types.js';
+/** Everything a strategy is allowed to look at. */
+export interface WindowStrategyInput {
+    /** The window as it stands, detached. */
+    readonly history: readonly LLMMessage[];
+    /** The same window, segmented into turns. */
+    readonly turns: readonly Turn[];
+    /** Per-message provenance, aligned index-for-index with `history`. */
+    readonly origins: readonly MessageOrigin[];
+    /** What the provider REPORTED for the last call. Counted, never guessed. */
+    readonly measuredTokens: number;
+    /** What must not fold: unanswered calls, the paused tool, a pending check-in. */
+    readonly foldability: FoldabilityContext;
+    /** The ReAct iteration this decision belongs to. */
+    readonly iteration: number;
+    /** The run's cancellation signal, when there is one. */
+    readonly signal: AbortSignal | undefined;
+    /** Wall clock, injectable so a caller can pin `survivalMs`. */
+    readonly now: () => number;
+}
+/** One message leaving the window, with the facts an eviction event needs. */
+export interface WindowEviction {
+    /** Index in the PRE-change window — the index the content hash was built on. */
+    readonly index: number;
+    /** How long it lived in the window. Exact; 0 when its birth is unknown. */
+    readonly survivalMs: number;
+}
+/** What the stage should do next. Everything is optional except the record. */
+export interface WindowStrategyResult {
+    /** The new window. Absent = leave the window alone. */
+    readonly window?: readonly LLMMessage[];
+    /**
+     * How the meter must re-align its provenance to the new window, which is
+     * `[...head, <one new message>, ...tail]`. Present exactly when `window` is.
+     */
+    readonly rebase?: {
+        readonly headCount: number;
+        readonly keptTailCount: number;
+    };
+    /** What the ledger is told. Always present — a visit always explains itself. */
+    readonly record: CompactionRecord;
+    /** Messages that left the window, for `context.evicted`. */
+    readonly evictions: readonly WindowEviction[];
+    /** `planAction` for `context.budget_pressure`. */
+    readonly planAction: 'summarize' | 'none';
+    /** A billed call the strategy made, for the cost channel. */
+    readonly spend?: {
+        readonly model: string;
+        readonly usage: {
+            readonly input: number;
+            readonly output: number;
+        };
+    };
+    /** A one-per-run dev warning the stage should print. */
+    readonly warning?: string;
+}
+/**
+ * A window strategy: what the live window should become when it is over
+ * budget, and what the record must say about the change.
+ */
+export interface WindowStrategy {
+    /** Stable name — goes nowhere public yet; used in messages and tests. */
+    readonly name: string;
+    plan(input: WindowStrategyInput): Promise<WindowStrategyResult>;
+}
+/**
+ * The shipped strategy: fold the oldest contiguous run of foldable turns into
+ * one summary message, keeping the recent turns and stepping over anything
+ * unresolved.
+ *
+ * Everything it decides, it explains. Every path returns a record — including
+ * the paths that change nothing, which are the ones a person debugging an
+ * over-budget window actually needs.
+ */
+export declare function summarizeOldestStrategy(config: ResolvedCompaction, defaultModel: string): WindowStrategy;
+//# sourceMappingURL=strategy.d.ts.map

package/dist/types/core/agent/compaction/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/compaction/strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4CAA4C,CAAC;AAEhF,OAAO,EAAyB,KAAK,kBAAkB,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AACvF,OAAO,KAAK,EAAE,gBAAgB,EAAe,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEpF,mDAAmD;AACnD,MAAM,WAAW,mBAAmB;IAClC,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,6CAA6C;IAC7C,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IAChC,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,iFAAiF;IACjF,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;IACzC,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;IACzC,+DAA+D;IAC/D,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;CAC5B;AAED,8EAA8E;AAC9E,MAAM,WAAW,cAAc;IAC7B,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2EAA2E;IAC3E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,+EAA+E;AAC/E,MAAM,WAAW,oBAAoB;IACnC,uDAAuD;IACvD,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;IACjF,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,4DAA4D;IAC5D,QAAQ,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,CAAC;IAC9C,kDAAkD;IAClD,QAAQ,CAAC,UAAU,EAAE,WAAW,GAAG,MAAM,CAAC;IAC1C,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,CAAC,EAAE;QACf,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,KAAK,EAAE;YAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;KACrE,CAAC;IACF,wDAAwD;IACxD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,kBAAkB,EAC1B,YAAY,EAAE,MAAM,GACnB,cAAc,CA+HhB"}

package/dist/types/core/agent/compaction/summarize.d.ts

@@ -0,0 +1,62 @@
+/**
+ * compaction/summarize — the authored frame, and the call that fills it.
+ *
+ * Pattern: Template Method with an authored envelope + untrusted payload.
+ * Role:    core/ layer. Two boundaries are enforced here, and they are the
+ *          same boundary pointed in opposite directions:
+ *
+ *          1. Going OUT to the summarizer, the folded transcript is DATA —
+ *             wrapped in a delimiter the authored instruction names, so a
+ *             message inside the conversation cannot re-instruct the
+ *             summarizer just by looking like an instruction.
+ *          2. Coming BACK into the window, the summary is DATA — appended
+ *             after an authored label the library wrote. A summarizer that
+ *             returns "IGNORE ALL PREVIOUS INSTRUCTIONS" produces a message
+ *             that still says, in the library's own words and first, that
+ *             what follows is a summary written by a model.
+ *
+ *          The frame is authored. The summary is data. Neither can become
+ *          the other.
+ * Emits:   N/A (the stage emits; this file only builds and calls).
+ */
+import type { LLMMessage, LLMProvider, LLMResponse } from '../../../adapters/types.js';
+/** Opening of the authored label. Stable — tests and readers match on it. */
+export declare const COMPACTED_FRAME_PREFIX = "[compacted history";
+/**
+ * What the summarizer is asked to do. Authored, fixed, and never composed
+ * from run content — the only variable part of the summarizer's prompt is
+ * the transcript, and that arrives between delimiters this text names.
+ */
+export declare const SUMMARIZER_SYSTEM_PROMPT: string;
+/** The folded span, rendered as the summarizer's input payload. */
+export declare function renderTranscript(messages: readonly LLMMessage[]): string;
+/**
+ * Build the message that replaces the folded span IN THE WINDOW.
+ *
+ * `role: 'user'` because the folded span always contains message 0 — the
+ * providers that care (Anthropic) require the window to open on a user turn.
+ *
+ * The label is written by this function and always comes first. `summary` is
+ * appended to it verbatim: the library never edits model output, and it never
+ * lets model output speak in the library's voice either.
+ */
+export declare function buildSummaryMessage(summary: string, facts: {
+    readonly foldedMessageCount: number;
+    readonly iteration: number;
+    readonly model: string;
+}): LLMMessage;
+/** True when this message is a frame a previous fold wrote. */
+export declare function isCompactedSummary(msg: LLMMessage | undefined): boolean;
+export interface SummarizeResult {
+    readonly text: string;
+    readonly usage: LLMResponse['usage'];
+}
+/**
+ * Call the summarizer over the folded span.
+ *
+ * Throws whatever the provider throws — the STAGE decides that a broken
+ * summarizer means "no fold this iteration", not "no run". Deciding that
+ * here would hide the failure from the record.
+ */
+export declare function runSummarizer(provider: LLMProvider, model: string, span: readonly LLMMessage[], signal: AbortSignal | undefined): Promise<SummarizeResult>;
+//# sourceMappingURL=summarize.d.ts.map

package/dist/types/core/agent/compaction/summarize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarize.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/compaction/summarize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEvF,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB,uBAAuB,CAAC;AAM3D;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,QAYzB,CAAC;AAcb,mEAAmE;AACnE,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,GAAG,MAAM,CAExE;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE;IACL,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,GACA,UAAU,CAOZ;AAED,+DAA+D;AAC/D,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAEvE;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;CACtC;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,eAAe,CAAC,CAQ1B"}

package/dist/types/core/agent/compaction/turns.d.ts

@@ -0,0 +1,86 @@
+/**
+ * compaction/turns — where a turn boundary is, and which turns may fold.
+ *
+ * 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.
+ * Emits:   N/A.
+ *
+ * Testable on its own — see `test/core/agent/compaction-turns.test.ts`.
+ */
+import type { LLMMessage } from '../../../adapters/types.js';
+import type { FoldRefusal, FoldRefusalReason } from './types.js';
+/**
+ * One turn: a `user` / `assistant` / `system` message plus every `tool`
+ * message that answers it. Tool results belong to the assistant turn that
+ * requested them — that pairing is the thing a fold must never break.
+ */
+export interface Turn {
+    /** Index of this turn in the segmentation. */
+    readonly index: number;
+    /** Index of the turn's FIRST message in the window. */
+    readonly start: number;
+    /** Number of messages in the turn. */
+    readonly length: number;
+    readonly messages: readonly LLMMessage[];
+}
+/**
+ * Segment a window into turns.
+ *
+ * A new turn starts at any non-`tool` message; `tool` messages join the turn
+ * in progress. A leading `tool` message (only reachable from a hand-built
+ * history) starts its own turn rather than being silently dropped.
+ */
+export declare function segmentTurns(history: readonly LLMMessage[]): readonly Turn[];
+/** Context a foldability decision needs beyond the turn itself. */
+export interface FoldabilityContext {
+    /** Every `toolCallId` answered anywhere in the window. */
+    readonly answeredCallIds: ReadonlySet<string>;
+    /** The tool call this run is paused on, when it is paused. */
+    readonly pausedToolCallId?: string;
+    /** True when the pause is a check-in (human consent) rather than askHuman. */
+    readonly pausedCheckIn?: boolean;
+}
+/** Every tool_call id that has a matching `role: 'tool'` message. */
+export declare function answeredCallIds(history: readonly LLMMessage[]): ReadonlySet<string>;
+/**
+ * Why this turn may NOT fold, 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
+ * `unresolved-tool-call` on purpose: they are the same shape but a different
+ * fact about the world, and "we are waiting on a human" is what the person
+ * reading the trace needs to see.
+ */
+export declare function refusalFor(turn: Turn, ctx: FoldabilityContext): FoldRefusalReason | undefined;
+/** The span a fold will take, plus every refusal it had to name to get there. */
+export interface FoldPlan {
+    /** First turn index in the fold span; -1 when nothing folds. */
+    readonly from: number;
+    /** Last turn index in the fold span (inclusive); -1 when nothing folds. */
+    readonly to: number;
+    readonly refusals: readonly FoldRefusal[];
+}
+/**
+ * Choose the fold span: the LONGEST CONTIGUOUS run of foldable candidate
+ * turns, starting at the oldest foldable 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.
+ *
+ * @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
+ */
+export declare function planFold(turns: readonly Turn[], keepRecent: number, ctx: FoldabilityContext, isSummaryTurn: (turn: Turn) => boolean): FoldPlan;
+/** Total characters of message content in a window. Exact; not tokens. */
+export declare function windowChars(history: readonly LLMMessage[]): number;
+//# sourceMappingURL=turns.d.ts.map

package/dist/types/core/agent/compaction/turns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turns.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/compaction/turns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEjE;;;;GAIG;AACH,MAAM,WAAW,IAAI;IACnB,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sCAAsC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;CAC1C;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,GAAG,SAAS,IAAI,EAAE,CAqB5E;AAED,mEAAmE;AACnE,MAAM,WAAW,kBAAkB;IACjC,0DAA0D;IAC1D,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC9C,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,8EAA8E;IAC9E,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,GAAG,WAAW,CAAC,MAAM,CAAC,CAMnF;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,kBAAkB,GAAG,iBAAiB,GAAG,SAAS,CAkB7F;AAED,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACvB,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,kBAAkB,EACvB,aAAa,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,GACrC,QAAQ,CAyCV;AAED,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,GAAG,MAAM,CAIlE"}

package/dist/types/core/agent/compaction/types.d.ts

@@ -0,0 +1,149 @@
+/**
+ * compaction/types — the public shape of `.compaction()` and the record it
+ * writes into the ledger.
+ *
+ * Pattern: Value objects (no behavior) + one resolved-config type.
+ * Role:    core/ layer. The law this feature exists to keep is stated once,
+ *          here, because every other file in this folder implements a piece
+ *          of it: **compaction 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
+ * fold removes from the window were committed by `seed#0` / `tool-calls#N`
+ * BEFORE the fold and stay in those bundles byte-identical forever. A fold
+ * therefore cannot destroy history even in principle; it can only stop
+ * re-sending it. The summary is a CLAIM about the past, so it is filed as a
+ * claim — its own recorded step, naming every `runtimeStageId` it folded.
+ */
+import type { LLMProvider } from '../../../adapters/types.js';
+/**
+ * What `.compaction({...})` accepts.
+ *
+ * @example
+ * ```ts
+ * const agent = Agent.create({ provider: anthropic(), model: 'claude-sonnet-4-5' })
+ *   .compaction({
+ *     thresholdTokens: 120_000,
+ *     summarizer: anthropic(),          // usually the cheap one
+ *     model: 'claude-haiku-4-5',
+ *     keepRecentTurns: 6,
+ *   })
+ *   .build();
+ * ```
+ */
+export interface CompactionOptions {
+    /**
+     * Fold when the LAST call's adapter-reported input tokens exceed this.
+     *
+     * REQUIRED, with no default. A default budget here would be a number the
+     * library invented for a window whose size only the consumer's model and
+     * wallet know — and every run would silently inherit it.
+     */
+    readonly thresholdTokens: number;
+    /**
+     * How many of the most recent turns are never folded. Default 6.
+     *
+     * The recent turns are what the model is actually reasoning over; folding
+     * them is how a compacting agent loses the thread.
+     */
+    readonly keepRecentTurns?: number;
+    /**
+     * The provider that writes the summary. Explicitly chosen — the library
+     * never quietly bills your main model for compaction.
+     */
+    readonly summarizer: LLMProvider;
+    /**
+     * Model id for the summarizer call. Defaults to the agent's own model, so
+     * `summarizer: anthropic()` alone works; name a cheap model to spend less.
+     */
+    readonly model?: string;
+}
+/** Resolved form — defaults applied at build time, validated once. */
+export interface ResolvedCompaction {
+    readonly thresholdTokens: number;
+    readonly keepRecentTurns: number;
+    readonly summarizer: LLMProvider;
+    readonly model: string | undefined;
+}
+/**
+ * Why a turn refused to fold. Every one of these is NAMED in the commit —
+ * a fold that took less than it could have has to say why, or the next
+ * person debugging an over-budget window has to guess.
+ */
+export type FoldRefusalReason = 
+/** The turn holds a `role: 'system'` message. The envelope never folds. */
+'system-envelope'
+/**
+ * An assistant `tool_use` in this turn has no matching `tool_result` in the
+ * window. Folding an unanswered question destroys the answer's referent —
+ * and the referent may still arrive (a paused run resumes).
+ */
+ | 'unresolved-tool-call'
+/** The turn holds the tool call this run is currently paused on. */
+ | 'paused-tool'
+/** The turn holds a tool call waiting on a human check-in decision. */
+ | 'pending-check-in'
+/** Inside `keepRecentTurns` — the recent window is never a candidate. */
+ | 'inside-keep-window'
+/**
+ * The only foldable candidate is a summary a previous fold wrote. Folding a
+ * summary of a summary with nothing new to add spends a call to lose detail.
+ */
+ | 'only-existing-summary'
+/** The summarizer threw. No fold this iteration; the window stays big. */
+ | 'summarizer-failed'
+/**
+ * The summary came back no smaller than the span it would replace, so the
+ * fold was abandoned. Measured in chars on both sides — the same unit, an
+ * exact comparison, not a token guess. Folding here would spend a call to
+ * make the window BIGGER and lose the detail as well.
+ */
+ | 'summary-not-smaller';
+/** One named refusal, positioned so a reader can find the turn. */
+export interface FoldRefusal {
+    readonly reason: FoldRefusalReason;
+    /** Index of the turn in this iteration's turn segmentation. */
+    readonly turnIndex: number;
+    /** Index of the turn's first message in the pre-fold window. */
+    readonly messageIndex: number;
+}
+/**
+ * What one visit to the compaction stage put in the ledger. Appended to
+ * `scope.compactions`, so the run's whole compaction story is one array in
+ * the commit log — including the visits that folded NOTHING, which are the
+ * interesting ones.
+ *
+ * On `windowChars*` vs tokens: the char counts are EXACT and measured here.
+ * There is deliberately no `tokensAfter` — nothing can count the tokens of a
+ * window that has not been sent yet, and inventing one would be exactly the
+ * guess this feature exists to refuse. The honest "after" is the NEXT call's
+ * `stream.llm_end` usage.
+ */
+export interface CompactionRecord {
+    /** ReAct iteration this visit belongs to. */
+    readonly iteration: number;
+    /** Adapter-reported input tokens of the last call — what tripped the check. */
+    readonly measuredTokens: number;
+    /** The budget it was compared against. */
+    readonly thresholdTokens: number;
+    /** True when the measurement was over budget (a fold was attempted). */
+    readonly overBudget: boolean;
+    /** `runtimeStageId`s of the stages that appended the folded messages. */
+    readonly foldedStageIds: readonly string[];
+    /** How many messages left the window. */
+    readonly foldedMessageCount: number;
+    /** Window size in chars before / after this visit. Exact, and not tokens. */
+    readonly windowCharsBefore: number;
+    readonly windowCharsAfter: number;
+    /** Length of the summary text the summarizer produced (0 when none). */
+    readonly summaryChars: number;
+    /** What the summarizer call itself cost, when it reported usage. */
+    readonly summarizerTokens?: {
+        readonly input: number;
+        readonly output: number;
+    };
+    /** Every turn that refused to fold, named. */
+    readonly refusals: readonly FoldRefusal[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/core/agent/compaction/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/compaction/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED;;;;GAIG;AACH,MAAM,MAAM,iBAAiB;AAC3B,2EAA2E;AACzE,iBAAiB;AACnB;;;;GAIG;GACD,sBAAsB;AACxB,oEAAoE;GAClE,aAAa;AACf,uEAAuE;GACrE,kBAAkB;AACpB,yEAAyE;GACvE,oBAAoB;AACtB;;;GAGG;GACD,uBAAuB;AACzB,0EAA0E;GACxE,mBAAmB;AACrB;;;;;GAKG;GACD,qBAAqB,CAAC;AAE1B,mEAAmE;AACnE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAC/B,6CAA6C;IAC7C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+EAA+E;IAC/E,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,0CAA0C;IAC1C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,yCAAyC;IACzC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,6EAA6E;IAC7E,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,wEAAwE;IACxE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,oEAAoE;IACpE,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAChF,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAC3C"}

package/dist/types/core/agent/stages/compact.d.ts

@@ -0,0 +1,60 @@
+/**
+ * compact — the loop-head stage that keeps the window inside budget.
+ *
+ * Reads the last call's ADAPTER-REPORTED input tokens from the compaction
+ * meter and, when they exceed `thresholdTokens`, hands the window to a window
+ * strategy. Runs once per ReAct iteration boundary, as the loop target, so
+ * everything downstream in the turn — the injection engine's triggers, all
+ * three context slots, and the wire itself — sees ONE window. No component
+ * gets a different past than the model does.
+ *
+ * The law: **it edits the window, never the ledger.** The turns a fold removes
+ * were committed by `seed#0` / `tool-calls#N` before this stage ran and stay
+ * in those bundles byte-identical; footprintjs's commit log is append-only, so
+ * a fold cannot erase history even in principle. What it can do is stop
+ * re-sending it — and say so, in its own commit, naming every runtimeStageId
+ * it folded. A compacted run is still a provable run.
+ *
+ * This file is deliberately all WIRING. The decision — what the window should
+ * become — lives behind `WindowStrategy` (compaction/strategy.ts, internal),
+ * so the duty to record, emit and cost what happened stays in exactly one
+ * place instead of being re-implemented per strategy. `.compaction()` is the
+ * only strategy that ships.
+ *
+ * Emits (existing vocabulary only — no new event types):
+ *   agentfootprint.context.evicted          — one per message leaving the window
+ *   agentfootprint.context.budget_pressure  — one per over-budget visit
+ *   agentfootprint.cost.tick                — when a pricingTable is set: the
+ *                                             summarizer's call is a real
+ *                                             billed call and counts
+ *
+ * The summarizer call is deliberately NOT bracketed with
+ * `stream.llm_start` / `llm_end`: those carry an `iteration` and every
+ * consumer pairs them by it, so a second bracket inside one iteration would
+ * corrupt the pairing. Its cost rides the cost channel and its tokens are
+ * recorded in the commit instead.
+ */
+import type { TypedScope } from 'footprintjs';
+import type { PricingTable } from '../../../adapters/types.js';
+import type { CompactionMeterHandle } from '../../../recorders/core/CompactionMeter.js';
+import type { ResolvedCompaction } from '../compaction/types.js';
+import type { AgentState } from '../types.js';
+export interface CompactStageDeps {
+    /** Resolved `.compaction()` config (defaults already applied). */
+    readonly config: ResolvedCompaction;
+    /** The meter this stage reads. Attached inline by `Agent.createExecutor`. */
+    readonly meter: CompactionMeterHandle;
+    /** The agent's own model — the summarizer's default. */
+    readonly defaultModel: string;
+    /** The MAIN provider's name, for the unmeasurable refusal. */
+    readonly providerName: string;
+    /** Optional pricing adapter, so a summarizer call is costed like any other. */
+    readonly pricingTable?: PricingTable;
+    /** Optional cumulative USD cap per run. */
+    readonly costBudget?: number;
+    /** Injectable clock (tests pin survivalMs). */
+    readonly now?: () => number;
+}
+/** Build the compaction stage function. */
+export declare function buildCompactStage(deps: CompactStageDeps): (scope: TypedScope<AgentState>) => Promise<void>;
+//# sourceMappingURL=compact.d.ts.map

package/dist/types/core/agent/stages/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/stages/compact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AAOxF,OAAO,KAAK,EAAoB,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC;IACpC,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;IACtC,wDAAwD;IACxD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,+EAA+E;IAC/E,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IACrC,2CAA2C;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,+CAA+C;IAC/C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AAED,2CAA2C;AAC3C,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,GACrB,CAAC,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CA8FlD"}

package/dist/types/core/agent/types.d.ts

@@ -18,6 +18,7 @@ import type { CredentialProvider } from '../../identity/types.js';
 import type { ToolArgValidationMode } from './toolArgsValidation.js';
 import type { ThinkingBlock } from '../../thinking/types.js';
 import type { ReliabilityScope } from '../../reliability/types.js';
+import type { CompactionRecord } from './compaction/types.js';
 /**
  * Dials for the deferred observer queue (RFC-001) — only meaningful with
  * `observerDelivery: 'deferred'` (passing them without it throws at
@@ -407,6 +408,16 @@ export interface AgentState {
     /** The base system prompt `.configure()` resolved for THIS run, replacing
      *  `.system(...)`. Same rule: absent unless a resolver returned one. */
     resolvedInstructions?: string;
+    /** One record per OVER-BUDGET visit to the compaction stage — including the
+     *  visits that folded nothing, which are the interesting ones. Written only
+     *  by an agent built with `.compaction()`; absent otherwise, so an agent
+     *  without it commits exactly the keys it always did.
+     *
+     *  This array is the fold's half of the law: the window shrank, and the
+     *  ledger says which stages' messages left it, how many, and what the last
+     *  call actually measured. The messages themselves are untouched in the
+     *  commit bundles that wrote them. */
+    compactions?: readonly CompactionRecord[];
     /** Set when a `PermissionChecker` returns `{ result: 'halt', ... }`.
      *  `Agent.run()` reads these at the API boundary and throws a typed
      *  `PolicyHaltError` carrying the same context — the chart $break's

package/dist/types/core/agent/types.d.ts.map

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

package/dist/types/index.d.ts

@@ -27,6 +27,7 @@ export { LLMCall, LLMCallBuilder, type LLMCallInput, type LLMCallOptions, type L
 export { type MessageApiChartDeps } from './core/agent/buildMessageApiChart.js';
 export { buildAgentMessageApiChart, type AgentMessageApiChartDeps, } from './core/agent/buildAgentMessageApiChart.js';
 export { Agent, AgentBuilder, type AgentInput, type AgentOptions, type AgentOutput, type ObserverDeliveryOptions, } from './core/Agent.js';
+export { CompactionUnmeasurableError, COMPACTED_FRAME_PREFIX, isCompactedSummary, type CompactionOptions, type CompactionRecord, type FoldRefusal, type FoldRefusalReason, } from './core/agent/compaction/index.js';
 export type { SelfExplainOptions } from './lib/trace-toolpack/selfExplain.js';
 export type { ObserverDrainResult, ObserverStats } from 'footprintjs';
 export type { ToolArgValidationMode } from './core/agent/toolArgsValidation.js';