@wrongstack/core 0.306.3 → 0.307.0

package/dist/execution/auto-compaction-middleware.d.ts

@@ -78,8 +78,19 @@ export declare class AutoCompactionMiddleware {
      * 1 / 2.5 = 0.4.
      */
     private static readonly GUARD_GATE_LOAD;
+    /**
+     * How much the context must grow between two history-rewriting hygiene
+     * passes, as a fraction of the available input window and as an absolute
+     * floor. Every pass rewrites already-transmitted messages, which forces the
+     * provider to re-cache the whole prompt; spacing the passes out is what lets
+     * the conversation prefix stay cached for the turns in between.
+     */
+    private static readonly HYGIENE_GROWTH_RATIO;
+    private static readonly HYGIENE_MIN_GROWTH_TOKENS;
     /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
     private lastNoopAttempt;
+    /** Context size at the last hygiene pass; anchors the growth interval. */
+    private lastHygieneTokens;
     /**
      * Cached token estimate from the last handler() invocation. When the
      * message count and tool count haven't changed since the last estimate
@@ -128,6 +139,59 @@ export declare class AutoCompactionMiddleware {
      *  tokens or compacting. */
     setEnabled(enabled: boolean): void;
     handler(): MiddlewareHandler<Context>;
+    /**
+     * Full-request token total for the current context.
+     *
+     * Reuses the last estimate when the context hasn't grown since the previous
+     * check — common in autonomous idle loops. The cached value is invalidated
+     * whenever messages or tools change.
+     *
+     * IMPORTANT: the cache is only valid for the deterministic
+     * `estimateRequestTokensCalibrated` path (messages+system+tools → fixed
+     * output). When a custom `_estimator` is provided (e.g. in tests with a
+     * mutable closure, or a dynamic policy provider), always call it fresh — the
+     * estimator owns its own semantics and the middleware cannot safely cache its
+     * result across calls.
+     */
+    private estimateContextTokens;
+    /**
+     * Never-undercount send guard.
+     *
+     * The calibrated estimate can under-count dense content (CJK, base64,
+     * minified) by >1.5×, which would let an over-limit request slip past the
+     * thresholds and reach the provider. Once the calibrated load is high enough
+     * that even the max density factor (2.5×) *could* overflow (load ≥ 1/2.5 =
+     * 0.4), re-check with the upper-bound estimator and escalate to whichever
+     * load is larger. Below 0.4 an overflow is arithmetically impossible, so the
+     * extra scan is skipped.
+     */
+    private applySendGuard;
+    /**
+     * Rewrite acknowledged tool protocol in place.
+     *
+     * Tool results are protocol inputs for the immediately following model
+     * response, not unlimited durable prompt memory. Once a later assistant
+     * message proves the provider consumed them, keep a mode-sized raw window and
+     * replace the rest with semantic head/tail receipts, then fold fully-aged
+     * pairs into the history digest.
+     *
+     * Every one of those edits touches a message the provider has already seen,
+     * so each call costs a full prompt re-cache — it belongs behind
+     * {@link shouldRunHygiene}, never on the per-turn path. Content staleness is
+     * not a reason to bypass that gate: the edit/replace tools guard against
+     * acting on an out-of-date read with their own mtime + sha-256 check.
+     *
+     * @returns whether the conversation was rewritten.
+     */
+    private runHistoryHygiene;
+    /**
+     * Whether the history-rewriting hygiene pass may run this turn.
+     *
+     * Hard pressure always runs it — staying under the window outranks caching.
+     * Otherwise it runs at most once per growth interval, so the conversation
+     * stays append-only (and therefore cacheable by the provider) in between.
+     */
+    private shouldRunHygiene;
     /**
      * H1: try to read a pre-computed token total from `ctx.lastRequestTokens`
      * (set by the agent loop's pre-flight or its restash in emitContextPct).

package/dist/execution/autonomy-brain-llm.d.ts

@@ -0,0 +1,55 @@
+import type { BrainDecision, BrainDecisionRequest } from '../coordination/brain.js';
+import type { EventBus } from '../kernel/events.js';
+import type { Provider, ResponseFormat, Usage } from '../types/provider.js';
+import type { BrainCircuitBreaker } from './brain-circuit.js';
+export interface BrainLlmTarget {
+    provider: Provider;
+    model: string;
+    label?: string | undefined;
+}
+export interface BrainLlmCallResult {
+    text: string;
+    usage?: Usage | undefined;
+    stopReason?: string | undefined;
+}
+export declare const DEFAULT_BRAIN_MAX_TOKENS = 200;
+export type BrainLlmDenyKind = 'unavailable' | 'unparseable' | 'refused';
+export declare function markDenyKind(decision: BrainDecision, kind: BrainLlmDenyKind): BrainDecision;
+export declare function readLlmDenyKind(decision: BrainDecision): BrainLlmDenyKind | undefined;
+export declare function buildBrainUserMessage(request: BrainDecisionRequest): string;
+export declare function withDecisionDigest(user: string, digest: string | undefined): string;
+export declare function completeBrainLlm(target: BrainLlmTarget, input: {
+    system: string;
+    user: string;
+    timeoutMs: number;
+    maxTokens?: number | undefined;
+    signal?: AbortSignal | undefined;
+}): Promise<string>;
+export declare function completeBrainLlmDetailed(target: BrainLlmTarget, input: {
+    system: string;
+    user: string;
+    timeoutMs: number;
+    maxTokens?: number | undefined;
+    responseFormat?: ResponseFormat | undefined;
+    signal?: AbortSignal | undefined;
+}): Promise<BrainLlmCallResult>;
+export declare function extractUsage(result: unknown): Usage | undefined;
+export declare function extractStopReason(result: unknown): string | undefined;
+export declare function extractText(result: unknown): string;
+export declare function extractConfidence(rawText: string): number | undefined;
+export declare function isNonAnswer(text: string): boolean;
+export interface BrainFreeTextEnvelope {
+    decision: string;
+    rationale?: string | undefined;
+    confidence?: number | undefined;
+}
+export declare function parseFreeTextDecision(rawText: string): BrainFreeTextEnvelope | null;
+export declare function parseOptionDecision(rawText: string, options: NonNullable<BrainDecisionRequest['options']>): BrainDecision | null;
+export declare function llmDecide(request: BrainDecisionRequest, targets: BrainLlmTarget[], timeoutMs: number, digest?: string | undefined, trace?: {
+    events: EventBus;
+    content: boolean;
+} | undefined, maxTokens?: number | undefined, quality?: {
+    rejectUncertain: boolean;
+    minConfidence: number;
+} | undefined, circuit?: BrainCircuitBreaker | undefined): Promise<BrainDecision>;
+//# sourceMappingURL=autonomy-brain-llm.d.ts.map

package/dist/execution/autonomy-brain.d.ts

@@ -19,25 +19,14 @@
  * ## Decision Logging
  * Every decision is emitted via `onDecision` callback with a human-readable
  * summary suitable for chat history and journal entries.
- *
- * Usage:
- *   const brain = createAutonomyBrain({
- *     provider, model, maxAutoRisk: 'high',
- *     onDecision: (summary) => journal.push(summary),
- *   });
  */
 import { type BrainArbiter, type BrainDecision, type BrainDecisionRequest } from '../coordination/brain.js';
 import { type BrainHeuristicsConfig } from '../coordination/brain-heuristics.js';
 import type { EventBus } from '../kernel/events.js';
-import type { Provider, ResponseFormat, Usage } from '../types/provider.js';
+import type { Provider } from '../types/provider.js';
 import type { BrainCircuitBreaker } from './brain-circuit.js';
-/** One (provider, model) pair the Brain may call for a decision. */
-export interface BrainLlmTarget {
-    provider: Provider;
-    model: string;
-    /** Display label for logs/status (e.g. "anthropic/claude-haiku"). */
-    label?: string | undefined;
-}
+import { type BrainLlmTarget, DEFAULT_BRAIN_MAX_TOKENS, readLlmDenyKind, buildBrainUserMessage, withDecisionDigest, completeBrainLlm, completeBrainLlmDetailed, extractConfidence, isNonAnswer, parseFreeTextDecision, parseOptionDecision } from './autonomy-brain-llm.js';
+export { type BrainLlmTarget, DEFAULT_BRAIN_MAX_TOKENS, buildBrainUserMessage, withDecisionDigest, completeBrainLlm, completeBrainLlmDetailed, extractConfidence, isNonAnswer, parseFreeTextDecision, parseOptionDecision, readLlmDenyKind, };
 export interface AutonomyBrainOptions {
     /** LLM provider for decision-making. Ignored when `targets` is non-empty. */
     provider?: Provider | undefined;
@@ -107,21 +96,6 @@ export interface AutonomyBrainOptions {
 export type BrainAutoRisk = 'off' | 'low' | 'medium' | 'high' | 'all';
 /**
  * Resolve an autonomy ceiling to a level comparable against `RISK_LEVELS`.
- *
- * `RISK_LEVELS` is keyed by REQUEST risk (`low|medium|high|critical`), but a
- * ceiling is keyed by `BrainAutoRisk`, whose `'off'` and `'all'` values have
- * no entry there. Looking a ceiling up directly therefore silently produced
- * the fallback level — `'all'` resolved to `2` (= `high`), so
- * `createAutonomyBrain({ maxAutoRisk: 'all' })` auto-denied every `critical`
- * request despite being explicitly configured as permissive (see
- * `assembleBrainTiers`, which passes `'all'` precisely to keep the inner tier
- * ungated and let the tiered ceiling do the gating).
- *
- * Both the tiered arbiter and the single-LLM brain now share this one
- * resolver so the two ladders cannot drift apart again.
- *
- * @returns `-1` for `'off'` (nothing is auto-decidable), `3` for `'all'`
- *   (including `critical`), otherwise the matching `RISK_LEVELS` entry.
  */
 export declare function resolveRiskCeiling(ceiling: BrainAutoRisk | undefined): number;
 export interface TieredBrainArbiterOptions {
@@ -163,23 +137,6 @@ export interface TieredBrainArbiterOptions {
 /**
  * The standard Brain positioning: policy first, LLM/council second,
  * escalation last.
- *
- *   1. POLICY  — deterministic DefaultBrainArbiter (low-risk fast path,
- *      fallback semantics). Denies and option-backed answers pass through
- *      untouched. A fallback-produced `continue` answer (no optionId, the
- *      request declared `fallback: 'continue'`) is only PROVISIONAL: it
- *      means "nobody could decide", not "this is the right call", so the
- *      LLM tier still gets consulted within the ceiling. Historically it
- *      short-circuited here, which meant e.g. goal-completion checks never
- *      reached the LLM at all.
- *   2. COUNCIL — requests at/above the council floor (default 'high') are
- *      decided by the multi-LLM council when one is wired.
- *   3. LLM     — everything else within the live ceiling goes to the
- *      single-LLM autonomous brain. Only a real `answer` short-circuits;
- *      denials/failures fall through.
- *   4. ESCALATION — anything left escalates. Callers wrap this in
- *      `EscalationRoutingBrainArbiter` (interactive prompt or headless
- *      terminal policy) or the legacy `HumanEscalatingBrainArbiter`.
  */
 export declare function createTieredBrainArbiter(opts: TieredBrainArbiterOptions): BrainArbiter;
 /**
@@ -193,116 +150,6 @@ export declare function createAutonomyBrain(opts: AutonomyBrainOptions): BrainAr
 export declare function formatDecisionSummary(decision: BrainDecision, request: BrainDecisionRequest): string;
 /**
  * Fast heuristic decisions that don't need an LLM call.
- *
- * Deliberately narrow: heuristics never fire on option-bearing requests
- * (options are control-plane input demanding a structured choice, not a
- * keyword guess) and the continue fast-path only fires when the caller
- * itself declared continue the safe fallback AND the question offers no
- * alternative — "Should we continue or stop?" must reach the LLM.
  */
 export declare function quickDecide(request: BrainDecisionRequest, heuristics?: BrainHeuristicsConfig | undefined): BrainDecision | null;
-/**
- * Render a decision request as the user message for a Brain LLM call.
- * Shared by the single-LLM tier and every council voter so all of them see
- * the same question/context/options shape.
- */
-export declare function buildBrainUserMessage(request: BrainDecisionRequest): string;
-/** Append a decision-history digest to a Brain user message (shared shape). */
-export declare function withDecisionDigest(user: string, digest: string | undefined): string;
-/**
- * One Brain LLM call against a single target. Throws on transport failure,
- * timeout, or abort — callers own the pool/fallback semantics.
- */
-export declare function completeBrainLlm(target: BrainLlmTarget, input: {
-    system: string;
-    user: string;
-    timeoutMs: number;
-    maxTokens?: number | undefined;
-    /** External cancellation (e.g. a council's overall budget or user abort). */
-    signal?: AbortSignal | undefined;
-}): Promise<string>;
-/** Text plus the observable call metadata a trace/quality gate needs. */
-interface BrainLlmCallResult {
-    text: string;
-    usage?: Usage | undefined;
-    /**
-     * `'max_tokens'` means the response was CUT OFF. With the default 200-token
-     * budget a rationale can be truncated mid-sentence, and the free-text path
-     * would happily turn that fragment into a decision — so callers must be
-     * able to see it.
-     */
-    stopReason?: string | undefined;
-}
-/**
- * One Brain LLM call, returning the metadata `completeBrainLlm` discards.
- *
- * Usage was previously thrown away at this boundary, which is why the council
- * adapter reported hardcoded zero tokens for every seat and why "what do
- * Brain decisions cost" had no answer.
- *
- * The per-call timeout is composed with any caller-supplied `signal` so an
- * external abort (the council's overall budget, a user cancel) interrupts an
- * in-flight provider call instead of waiting out the per-call timeout.
- */
-export declare function completeBrainLlmDetailed(target: BrainLlmTarget, input: {
-    system: string;
-    user: string;
-    timeoutMs: number;
-    maxTokens?: number | undefined;
-    /**
-     * Wire-level response format (e.g. json_object). Callers that parse the
-     * response as JSON (the council seats) must pass this through — prompt
-     * wording alone does not put a provider into JSON mode.
-     */
-    responseFormat?: ResponseFormat | undefined;
-    signal?: AbortSignal | undefined;
-}): Promise<BrainLlmCallResult>;
-/**
- * Output budget for a Brain decision call.
- *
- * Deliberately small — a Brain response is one decision plus a one-sentence
- * rationale, not prose. Raise it via `brain.llm.maxTokens` if truncation
- * shows up in the trace as `stopReason: 'max_tokens'`.
- */
-export declare const DEFAULT_BRAIN_MAX_TOKENS = 200;
-/**
- * Ask the LLM pool for a decision on complex questions. Targets are tried
- * in the given order; the first one that answers wins. Uses a carefully
- * crafted system prompt that establishes the brain's identity, purpose,
- * and decision-making framework.
- */
-type BrainLlmDenyKind = 
-/** No target in the pool produced a response (transport/timeout). */
-'unavailable'
-/** A response came back but carried no exact valid option id. */
- | 'unparseable'
-/** The model considered the question and refused. */
- | 'refused';
-/**
- * Read the reason a Brain LLM tier denied, when known. Returns undefined for
- * decisions that did not come from `llmDecide` (policy denials, council
- * denials, ledger-guard denials), which callers should treat as decided.
- */
-export declare function readLlmDenyKind(decision: BrainDecision): BrainLlmDenyKind | undefined;
-/** Read a self-reported confidence out of a raw response, if it carries one. */
-export declare function extractConfidence(rawText: string): number | undefined;
-/** Does this free-text response decline to decide? */
-export declare function isNonAnswer(text: string): boolean;
-/** Structured envelope a Brain LLM may return for an optionless question. */
-interface BrainFreeTextEnvelope {
-    decision: string;
-    rationale?: string | undefined;
-    confidence?: number | undefined;
-}
-/**
- * Parse the optionless response.
- *
- * Accepts the structured envelope the prompt now asks for, and falls back to
- * bare prose so older/simpler models keep working. Returns null when the
- * model declined to decide — the caller must then fall through rather than
- * present the refusal as an answer.
- */
-export declare function parseFreeTextDecision(rawText: string): BrainFreeTextEnvelope | null;
-export declare function parseOptionDecision(rawText: string, options: NonNullable<BrainDecisionRequest['options']>): BrainDecision | null;
-export {};
 //# sourceMappingURL=autonomy-brain.d.ts.map

package/dist/execution/compaction-budget.d.ts

@@ -0,0 +1,38 @@
+import type { Message } from '../types/messages.js';
+export interface HardBudgetResult {
+    messages: Message[];
+    changed: boolean;
+    saved: number;
+    trimmedBlocks: number;
+    droppedMessages: number;
+    withinBudget: boolean;
+}
+export declare function headTailTruncate(text: string, keepHead: number, keepTail: number): string;
+export declare function truncateMessageText(m: Message, keepHead: number, keepTail: number, minTokens: number): {
+    message: Message;
+    trimmed: number;
+} | null;
+export declare function elideMessageToolIo(m: Message): {
+    message: Message;
+    trimmed: number;
+} | null;
+export declare function enforceHardBudget(messages: readonly Message[], budgetTokens: number, opts: {
+    preserveK: number;
+}, findPreserveStartFn?: (messages: readonly Message[], preserveK: number) => number): HardBudgetResult;
+export interface DedupResult {
+    messages: Message[];
+    changed: boolean;
+    saved: number;
+    deduped: number;
+}
+export declare function dedupStaleReads(messages: readonly Message[], repeatedReads: readonly {
+    file: string;
+    count: number;
+}[], opts: {
+    preserveK: number;
+}, findPreserveStartFn?: (messages: readonly Message[], preserveK: number) => number): DedupResult;
+export declare function buildLosslessDigest(messages: readonly Message[]): string;
+export declare function hasTextContent(m: Message): boolean;
+export declare function findSafeBoundary(messages: readonly Message[], from: number, to: number, hasTextContentFn?: (m: Message) => boolean): number;
+export declare function findExchangeStart(messages: readonly Message[], userIndex: number): number;
+//# sourceMappingURL=compaction-budget.d.ts.map

package/dist/execution/compaction-core.d.ts

@@ -1,170 +1,7 @@
-import type { Logger } from '../types/logger.js';
-import type { Message } from '../types/messages.js';
 import { estimateMessageTokens } from '../utils/token-estimate.js';
 export { buildSmartDigest, type ContentScore, extractText, hasLargeToolResult, hasToolUse, scoreMessage, } from './compaction-scoring.js';
-/** Set the module-level compaction debug logger (called by compactor constructors). */
-export declare function setCompactionDebugLogger(logger: Logger | undefined): void;
-/**
- * Token estimate for a message array (text + tool I/O). Re-exported from the
- * canonical `token-estimate` helper so compactors and the context-pressure
- * monitor share one number.
- */
+export { type AcknowledgedToolReceiptCollapse, type AcknowledgedToolResultElision, analyzeFileToolLifecycle, collapseAcknowledgedToolReceipts, compactionDebugEnabled, type CompactionMetrics, didFileMutationRun, eliseAcknowledgedToolResults, eliseOldToolResults, type EliseResult, emitCompactionMetrics, extractPathHints, type FileToolLifecycle, findPreserveStart, firstErrorLine, isElidedResultContent, isElidedToolInput, isFileMutationToolName, isReadToolName, normalizePathKey, readPathOf, safeToolResultString, sameFilePath, setCompactionDebugLogger, summarizeToolResultElision, summarizeToolUseInputElision, } from './compaction-elision.js';
+export { buildLosslessDigest, type DedupResult, dedupStaleReads, elideMessageToolIo, enforceHardBudget, findExchangeStart, findSafeBoundary, type HardBudgetResult, hasTextContent, headTailTruncate, truncateMessageText, } from './compaction-budget.js';
+export { CompactionSummaryCache, type CompactionSummaryCacheOptions, compactionSummaryKey, isPlaceholderSummary, PLACEHOLDER_SUMMARIES, } from './compaction-summary-cache.js';
 export declare const estimateMessages: typeof estimateMessageTokens;
-/**
- * Shared, pure compaction primitives.
- *
- * Before this module the three compactors (`HybridCompactor`,
- * `IntelligentCompactor`, `SelectiveCompactor`) each carried their own copies
- * of message-token estimation, tool-result elision, text detection and digest
- * rendering — with subtle divergences (notably Selective lacked the
- * tool_use/tool_result pair preservation, so it could elide the result of a
- * tool call it was supposed to keep). These helpers are the single source of
- * truth. They operate on plain `Message[]` and never touch `Context`/state, so
- * each compactor keeps its own `ctx.state.replaceMessages(...)` plumbing.
- */
-/** Does this message carry any non-empty text? */
-export declare function hasTextContent(m: Message): boolean;
-/**
- * Index where the preserved (recent) window starts. Walks back counting
- * user/assistant messages until `preserveK` are covered, then walks forward to
- * keep any tool_use/tool_result protocol pair intact — so a tool_result whose
- * tool_use is preserved is never elided.
- *
- * Instrumentation: emits `compaction.find_preserve_start.ended` with the
- * repair-loop block count so we can track whether protocol-pair repair is
- * scanning too much content.
- */
-export declare function findPreserveStart(messages: readonly Message[], preserveK: number): number;
-export interface EliseResult {
-    /** New message array, or the same reference when nothing changed. */
-    messages: Message[];
-    /** Estimated tokens reclaimed. */
-    saved: number;
-    changed: boolean;
-}
-export interface AcknowledgedToolResultElision extends EliseResult {
-    /** Raw tool-result blocks replaced with compact receipts. */
-    elidedResults: number;
-    /** Raw acknowledged tool I/O left verbatim after the pass. */
-    retainedTokens: number;
-}
-export interface AcknowledgedToolReceiptCollapse extends EliseResult {
-    /** Complete acknowledged tool exchanges folded into the bounded digest. */
-    collapsedPairs: number;
-}
-/**
- * Bound raw tool I/O that the model has already consumed successfully.
- *
- * A result is acknowledged only when a later assistant message exists. The
- * trailing tool-result batch therefore stays verbatim until it has actually
- * reached the provider; retries and recovered sessions cannot lose the input
- * needed for their next request. Among acknowledged pairs, the newest raw
- * payloads share `maxRetainedTokens`; older or individually oversized pairs
- * become semantic receipts while their exact payload remains in the session
- * log. Tool ids and provider metadata stay intact so strict provider replay
- * adjacency remains valid.
- */
-export declare function eliseAcknowledgedToolResults(messages: readonly Message[], opts: {
-    maxRetainedTokens: number;
-}): AcknowledgedToolResultElision;
-/**
- * Bound the number of acknowledged tool-protocol pairs retained in history.
- *
- * Raw payload elision bounds bytes, but every receipt still leaves an
- * assistant tool_use message and a user tool_result message behind. Long
- * autonomous sessions therefore continued to grow linearly in protocol
- * shells. This pass keeps the newest `maxPairs`, removes both halves of older
- * pairs, drops thinking that existed solely to authorize an omitted tool call,
- * and folds the count into one stable system digest. Surrounding assistant or
- * user text is preserved.
- */
-export declare function collapseAcknowledgedToolReceipts(messages: readonly Message[], opts: {
-    maxPairs: number;
-}): AcknowledgedToolReceiptCollapse;
-/**
- * Elide oversized tool I/O that falls before the preserve window. Pure:
- * returns a fresh array (or the same reference when unchanged). Replaces the
- * duplicate copies that lived in all three compactors.
- */
-export declare function eliseOldToolResults(messages: readonly Message[], opts: {
-    preserveK: number;
-    eliseThreshold: number;
-}): EliseResult;
-export interface HardBudgetResult {
-    /** New message array, or the same reference when nothing changed. */
-    messages: Message[];
-    changed: boolean;
-    /** Estimated message tokens reclaimed (before − after). */
-    saved: number;
-    /** Number of content blocks elided or truncated. */
-    trimmedBlocks: number;
-    /** Number of whole messages dropped (last-resort Pass 4). */
-    droppedMessages: number;
-    /** True when the message array fits `budgetTokens` after trimming. */
-    withinBudget: boolean;
-}
-/**
- * Last-resort trim that makes a request **structurally guaranteed** to fit its
- * budget. Call it after normal compaction when the message array still exceeds
- * the hard budget (a single huge paste, a preserved-window tool_result, or a
- * >1.5× token under-estimate). It escalates through four increasingly
- * destructive passes and stops the instant the array fits, so loss is
- * minimised:
- *
- *   1. Elide all old tool I/O before the preserve window (no threshold floor).
- *   2. Head/tail truncate large text in old messages.
- *   3. Head/tail truncate large text across the whole array (incl. preserved).
- *   4. Drop the oldest whole messages (never the last one) until it fits.
- *
- * A final `repairToolUseAdjacency` re-links any protocol pair Pass 4 orphaned.
- *
- * `budgetTokens` is the maximum tokens the **message array** may occupy — the
- * caller subtracts the system-prompt + tool-definition overhead from the
- * context window first, so this stays a pure function over `Message[]`.
- */
-export declare function enforceHardBudget(messages: readonly Message[], budgetTokens: number, opts: {
-    preserveK: number;
-}): HardBudgetResult;
-export interface DedupResult {
-    messages: Message[];
-    changed: boolean;
-    /** Estimated tokens reclaimed. */
-    saved: number;
-    /** Number of stale reads collapsed. */
-    deduped: number;
-}
-/**
- * Collapse **superseded** reads of the same file. When a file is read
- * repeatedly (tracked in `repeatedReads` evidence), every read of it before
- * the preserve window that is *not* the newest occurrence is redundant — the
- * later read replaced it. This replaces those stale `tool_result` payloads
- * with a one-line marker (and elides the paired `tool_use` input), keeping the
- * newest read verbatim. Complements `eliseOldToolResults`, which only fires on
- * results ≥ `eliseThreshold`: many small-but-repeated reads slip under that bar
- * and accumulate, so this catches the pattern `eliseThreshold` misses.
- */
-export declare function dedupStaleReads(messages: readonly Message[], repeatedReads: readonly {
-    file: string;
-    count: number;
-}[], opts: {
-    preserveK: number;
-}): DedupResult;
-/**
- * Lossless textual digest of a message range. Every text block is kept verbatim
- * (across all roles, so prior `system` digests fold forward and nothing
- * accumulates as loss). `tool_use` / `tool_result` blocks are counted and
- * replaced with a marker rather than serialized — their payload is already
- * persisted in the session log. Empty/tool-only messages are skipped.
- */
-export declare function buildLosslessDigest(messages: readonly Message[]): string;
-/**
- * Nearest safe cut boundary in [from, to]: the start of the exchange of the
- * closest user-with-text message. Returns -1 when no such boundary exists.
- */
-export declare function findSafeBoundary(messages: readonly Message[], from: number, to: number): number;
-/**
- * Walk backwards from a user message to find where its logical exchange began
- * (just after the last assistant message that made no tool calls).
- */
-export declare function findExchangeStart(messages: readonly Message[], userIndex: number): number;
 //# sourceMappingURL=compaction-core.d.ts.map

package/dist/execution/compaction-elision.d.ts

@@ -0,0 +1,58 @@
+import type { ToolResultBlock, ToolUseBlock } from '../types/blocks.js';
+import type { Logger } from '../types/logger.js';
+import type { Message } from '../types/messages.js';
+export interface CompactionMetrics {
+    messageCount: number;
+    preserveStart: number;
+    fastPathIterations: number;
+    fastPathInnerIterations: number;
+    fullPassIterations: number;
+    fullPassInnerIterations: number;
+    tokensSaved: number;
+    changed: boolean;
+}
+export declare function compactionDebugEnabled(): boolean;
+export declare function setCompactionDebugLogger(logger: Logger | undefined): void;
+export declare function emitCompactionMetrics(event: string, metrics: CompactionMetrics): void;
+export interface EliseResult {
+    messages: Message[];
+    saved: number;
+    changed: boolean;
+}
+export interface AcknowledgedToolResultElision extends EliseResult {
+    elidedResults: number;
+    retainedTokens: number;
+}
+export interface AcknowledgedToolReceiptCollapse extends EliseResult {
+    collapsedPairs: number;
+}
+export interface FileToolLifecycle {
+    activeReadIds: Set<string>;
+    staleReadPaths: Map<string, string>;
+}
+export declare function isReadToolName(name: string): boolean;
+export declare function isFileMutationToolName(name: string): boolean;
+export declare function didFileMutationRun(use: ToolUseBlock): boolean;
+export declare function sameFilePath(a: string, b: string): boolean;
+export declare function readPathOf(input: Record<string, unknown> | undefined): string | undefined;
+export declare function normalizePathKey(p: string): string;
+export declare function analyzeFileToolLifecycle(messages: readonly Message[], acknowledgedBefore: number): FileToolLifecycle;
+export declare function isElidedResultContent(content: string): boolean;
+export declare function isElidedToolInput(input: Record<string, unknown> | undefined): boolean;
+export declare function eliseAcknowledgedToolResults(messages: readonly Message[], opts: {
+    maxRetainedTokens: number;
+}): AcknowledgedToolResultElision;
+export declare function collapseAcknowledgedToolReceipts(messages: readonly Message[], opts: {
+    maxPairs: number;
+}): AcknowledgedToolReceiptCollapse;
+export declare function findPreserveStart(messages: readonly Message[], preserveK: number): number;
+export declare function eliseOldToolResults(messages: readonly Message[], opts: {
+    preserveK: number;
+    eliseThreshold: number;
+}, findPreserveStartFn?: (messages: readonly Message[], preserveK: number) => number): EliseResult;
+export declare function summarizeToolUseInputElision(block: ToolUseBlock, tokens: number): Record<string, unknown>;
+export declare function summarizeToolResultElision(block: ToolResultBlock, tokens: number): string;
+export declare function safeToolResultString(content: unknown): string;
+export declare function extractPathHints(content: unknown): string[];
+export declare function firstErrorLine(content: unknown): string | undefined;
+//# sourceMappingURL=compaction-elision.d.ts.map

package/dist/execution/council-orchestrator-helpers.d.ts

@@ -0,0 +1,39 @@
+import type { CouncilQuestion, CouncilResult, CouncilUsage, CouncilVoteResult, ResolvedCouncilProfile, ResolvedCouncilSeat } from '../types/council.js';
+import type { OneShotLLMResult } from '../types/one-shot-llm.js';
+export declare const COUNCIL_REFUSAL_OPTION_ID = "council_refuse";
+export declare const DEFAULT_COUNCIL_MAX_CONCURRENCY = 3;
+export declare const MAX_COUNCIL_CONCURRENCY = 8;
+export declare const OVERALL_TIMEOUT_REASON = "Council overall timeout exceeded.";
+export declare const CALL_CANCELLED_REASON = "Cancelled.";
+export interface UsageAccumulator {
+    calls: number;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+export declare function validateConcurrency(value: number): number;
+export declare function validateRefusalCollision(question: CouncilQuestion, refusalOptionId: string): void;
+export declare function optionLabel(question: CouncilQuestion, optionId: string | undefined): string | undefined;
+export declare function mapConcurrent<T, R>(items: readonly T[], concurrency: number, worker: (item: T, index: number) => Promise<R>): Promise<R[]>;
+export declare function distinctTargetKeys(votes: readonly CouncilVoteResult[], profile: ResolvedCouncilProfile): string[];
+export declare function distinctTargetCount(votes: readonly CouncilVoteResult[], profile: ResolvedCouncilProfile): number;
+export declare function distinctnessWarnings(votes: readonly CouncilVoteResult[], profile: ResolvedCouncilProfile): string[];
+export declare function cancelledVote(seat: ResolvedCouncilSeat): CouncilVoteResult;
+export declare function callMetadata(result: OneShotLLMResult): Omit<CouncilVoteResult, 'seatId' | 'persona' | 'status'>;
+export declare function addUsage(usage: UsageAccumulator, result: OneShotLLMResult): void;
+export declare function usageResult(usage: UsageAccumulator, startedAt: number): CouncilUsage;
+export declare function resultEnvelope(input: {
+    status: CouncilResult['status'];
+    answer?: string | undefined;
+    optionId?: string | undefined;
+    reason?: string | undefined;
+    resolution: CouncilResult['resolution'];
+    votes: CouncilVoteResult[];
+    profile: ResolvedCouncilProfile;
+    usage: UsageAccumulator;
+    startedAt: number;
+    warnings: string[];
+    errors: string[];
+    judgeUsed?: boolean | undefined;
+}): CouncilResult;
+//# sourceMappingURL=council-orchestrator-helpers.d.ts.map