@wrongstack/core 0.63.4 → 0.68.0

package/dist/multi-agent-SASYOrWA.d.ts

@@ -1,554 +0,0 @@
-import { $ as Usage } from './context-iFMEO2rN.js';
-import { E as EventBus } from './events-k8CHjcrN.js';
-
-type BridgeMessageType = 'task' | 'result' | 'progress' | 'error' | 'heartbeat' | 'stop' | 'delegate' | 'budget_threshold';
-interface BridgeMessage<T = unknown> {
-    id: string;
-    type: BridgeMessageType;
-    from: string;
-    to?: string;
-    payload: T;
-    timestamp: number;
-    priority?: 'low' | 'normal' | 'high' | 'critical';
-}
-interface AgentBridgeConfig {
-    agentId: string;
-    coordinatorId: string;
-    timeoutMs?: number;
-    bufferSize?: number;
-}
-interface AgentBridge {
-    readonly agentId: string;
-    readonly coordinatorId: string;
-    send(msg: BridgeMessage): Promise<void>;
-    broadcast(msg: BridgeMessage): Promise<void>;
-    subscribe(handler: (msg: BridgeMessage) => void | Promise<void>): () => void;
-    request<T>(msg: BridgeMessage, timeoutMs?: number): Promise<BridgeMessage<T>>;
-    stop(): Promise<void>;
-}
-interface BridgeTransport {
-    send(msg: BridgeMessage, to: string): Promise<void>;
-    subscribe(agentId: string, handler: (msg: BridgeMessage) => void | Promise<void>): () => void;
-    close(agentId: string): Promise<void>;
-}
-
-type BudgetKind = 'tool_calls' | 'iterations' | 'tokens' | 'timeout' | 'idle_timeout' | 'cost';
-declare class BudgetExceededError extends Error {
-    readonly kind: BudgetKind;
-    readonly limit: number;
-    readonly observed: number;
-    constructor(kind: BudgetKind, limit: number, observed: number);
-}
-interface BudgetLimits {
-    maxIterations?: number;
-    maxToolCalls?: number;
-    maxTokens?: number;
-    /** Estimated USD cost ceiling. */
-    maxCostUsd?: number;
-    /**
-     * Hard wall-clock timeout measured from `start()`. Off by default — set it
-     * explicitly only when a task must finish within an absolute window. For
-     * the everyday "don't kill an agent that's still working" guard, prefer
-     * `idleTimeoutMs`, which resets on activity.
-     */
-    timeoutMs?: number;
-    /**
-     * Idle timeout: the maximum gap (ms) between activity signals (iterations,
-     * tool calls, token usage, streamed progress) before the subagent is
-     * considered hung and reaped. Unlike `timeoutMs`, an actively-working
-     * agent continuously resets this clock via `markActivity()`, so it never
-     * trips on a long-but-productive run — only on a genuine stall.
-     */
-    idleTimeoutMs?: number;
-}
-/**
- * Controls how the budget behaves when `onThreshold` is set and a limit is hit.
- *
- * `'auto'` — emit `budget.threshold_reached` on the EventBus and wait for a
- * coordinator response (extend/stop). If no listener responds within
- * `DECISION_TIMEOUT_MS` the decision defaults to `'stop'`.
- * `'sync'` — do not emit any event; treat the threshold as a hard stop and
- * throw `BudgetExceededError` synchronously. Useful for fire-and-forget
- * subagents that have an `onThreshold` handler for logging/metrics but are
- * not wired into a coordinator.
- *
- * @default 'auto'
- */
-type BudgetNegotiationMode = 'auto' | 'sync';
-interface BudgetUsage {
-    iterations: number;
-    toolCalls: number;
-    tokens: {
-        input: number;
-        output: number;
-        total: number;
-    };
-    costUsd: number;
-    elapsedMs: number;
-}
-/**
- * Thrown by `SubagentBudget.record*` when a soft limit is hit and
- * an `onThreshold` handler is configured that wants to ask the
- * coordinator (via `budget.threshold_reached` event). The runner
- * catches this and awaits the embedded `decision` promise to get
- * the coordinator's extend/stop decision.
- *
- * Distinct from `BudgetExceededError` which is a hard stop.
- */
-declare class BudgetThresholdSignal extends Error {
-    readonly kind: BudgetKind;
-    readonly limit: number;
-    readonly used: number;
-    /** Resolves to 'extend' (with optional new limits) or 'stop' */
-    readonly decision: Promise<BudgetThresholdDecision>;
-    constructor(kind: BudgetKind, limit: number, used: number, decision: Promise<BudgetThresholdDecision>);
-}
-type BudgetThresholdDecision = 'stop' | {
-    extend: Partial<BudgetLimits>;
-};
-/**
- * Callback invoked when a budget limit is about to be exceeded.
- * Return 'throw' for hard stop (default — throws BudgetExceededError).
- * Return 'continue' to allow one more unit and re-check next time.
- * Return a Promise to ask the coordinator via `budget.threshold_reached`
- * event (uses the same grant/deny pattern as `iteration.limit_reached`).
- */
-type BudgetThresholdHandler = (info: {
-    kind: BudgetKind;
-    used: number;
-    limit: number;
-    requestDecision: () => Promise<BudgetThresholdDecision>;
-}) => 'throw' | 'continue' | Promise<BudgetThresholdDecision>;
-/**
- * Per-subagent budget enforcement. Each subagent gets its own instance so a
- * runaway agent can't drain the cost ceiling of its siblings. All record/check
- * methods are O(1) and safe to call from hot paths.
- *
- * Behavior without `onThreshold`: hard stops synchronously on every limit hit.
- *
- * Behavior with `onThreshold` and `_mode === 'auto'`: emits `budget.threshold_reached`
- * on the EventBus and throws `BudgetThresholdSignal`. The coordinator's verdict
- * (extend/stop) resolves the embedded promise. If no listener responds within
- * `DECISION_TIMEOUT_MS` the decision defaults to `'stop'`.
- *
- * Behavior with `onThreshold` and `_mode === 'sync'`: throws `BudgetExceededError`
- * synchronously regardless of EventBus state or listener presence. This is useful
- * for fire-and-forget subagents that have an `onThreshold` handler for logging/metrics
- * but are not wired into a coordinator — the `'sync'` mode makes the hard-stop
- * behavior explicit and means tests can use `expect().toThrow()` even without
- * a fully-wired EventBus.
- */
-declare class SubagentBudget {
-    readonly limits: Readonly<BudgetLimits>;
-    private iterations;
-    private toolCalls;
-    private tokenInput;
-    private tokenOutput;
-    private costUsd;
-    private startTime;
-    /**
-     * Timestamp of the most recent activity (iteration / tool call / token
-     * usage / streamed progress). Drives the idle timeout — reset by
-     * `markActivity()`. Initialised to `start()` time so a never-active agent
-     * still eventually trips its idle window.
-     */
-    private lastActivityTime;
-    private _onThreshold;
-    /**
-     * Hard cap on how long `_negotiateExtension` waits for the coordinator to
-     * respond before defaulting to 'stop'. Without this fallback an absent
-     * or hung listener (Director not built / event filter detached mid-run)
-     * leaves the budget over-limit and never enforces anything.
-     */
-    private static readonly DECISION_TIMEOUT_MS;
-    /**
-     * Injected by the runner when wiring the budget to its EventBus.
-     * Used to emit `budget.threshold_reached` events in `'auto'` mode.
-     */
-    _events?: EventBus;
-    /**
-     * Negotiation mode — controls whether a threshold hit tries to emit
-     * `budget.threshold_reached` and wait for a coordinator decision, or
-     * falls straight through to a synchronous hard stop.
-     *
-     * `'auto'` (default) — emit on the EventBus and wait; times out to 'stop'.
-     * `'sync'` — throw `BudgetExceededError` immediately regardless of listeners.
-     */
-    private _mode;
-    /**
-     * Optional callback for soft-limit handling. When set, the budget will
-     * invoke it rather than throw immediately. The handler decides whether to
-     * throw synchronously, continue, or ask the coordinator for an extension.
-     */
-    get onThreshold(): BudgetThresholdHandler | undefined;
-    set onThreshold(fn: BudgetThresholdHandler | undefined);
-    /** Returns the current negotiation mode. */
-    get mode(): BudgetNegotiationMode;
-    constructor(limits?: BudgetLimits, mode?: BudgetNegotiationMode);
-    start(): void;
-    /**
-     * Reset the idle clock. Called on any sign of forward progress —
-     * iterations, tool calls, token usage, and streamed tool/text progress —
-     * so a long-but-productive subagent never trips its `idleTimeoutMs`.
-     */
-    markActivity(): void;
-    /**
-     * Milliseconds since the last activity signal. Returns 0 before `start()`
-     * (nothing to measure yet). Used by the coordinator watchdog to decide
-     * whether to re-arm (still active) or reap (genuinely idle).
-     */
-    idleMs(): number;
-    /** Returns true if we're within 10% of any limit — useful for pre-flight checks. */
-    isNearLimit(): boolean;
-    /**
-     * Synchronous budget check. Always throws synchronously so callers (especially
-     * test event handlers using `expect().toThrow()`) get an unhandled rejection
-     * when the budget is exceeded without a handler.
-     *
-     * Decision table:
-     * - no `onThreshold` handler         → throw `BudgetExceededError` (hard stop, always)
-     * - `mode === 'sync'`               → throw `BudgetExceededError` (hard stop, always)
-     * - `mode === 'auto'` + no listener  → throw `BudgetExceededError` (hard stop; no one to ask)
-     * - `mode === 'auto'` + listener     → throw `BudgetThresholdSignal` with async decision promise
-     */
-    /**
-     * Collects all exceeded budget kinds into a single NOOP-free negotiation.
-     * Called by recordIteration / recordToolCall / recordUsage — each may call
-     * this for its own kind. The first call starts the negotiation and stores
-     * the Promise in _pendingNegotiation. Subsequent calls for DIFFERENT
-     * kinds (while a negotiation is in flight) are NOOPs — they don't start
-     * new conversations with the coordinator. This prevents an EventBus flood
-     * when multiple budget kinds are exceeded simultaneously in one iteration.
-     *
-     * Returns the kinds that were found to be exceeded (for logging/debugging).
-     */
-    private checkLimits;
-    /**
-     * Per-kind in-flight negotiation Promises. Each budget kind can have its
-     * own concurrent negotiation — e.g. iterations and timeout can both
-     * be exceeded simultaneously without blocking each other. The same kind
-     * cannot start two concurrent negotiations (dedup guard).
-     * Cleared in `_negotiateExtension`'s `finally` block.
-     */
-    private _pendingNegotiations;
-    /**
-     * Drive the threshold handler to a decision. Resolves with `'stop'`
-     * (signal the runner to abort) or `{ extend: ... }` (limits already
-     * patched in-place; the runner should not abort). Clears the
-     * per-kind slot in `_pendingNegotiations` in `finally`.
-     *
-     * The 'continue' return from a sync handler is treated as
-     * `{ extend: {} }` — keep going without patching; next overrun fires
-     * a fresh signal.
-     */
-    private _negotiateExtension;
-    recordIteration(): void;
-    recordToolCall(): void;
-    recordUsage(usage: Usage, costUsd?: number): void;
-    /**
-     * Wall-clock budget check. Unlike other limits, timeout is always a hard stop
-     * — wall-clock time cannot be "extended" by the coordinator, so it throws
-     * synchronously rather than entering the negotiation flow.
-     *
-     * Decision table:
-     * - no `onThreshold` handler         → throw `BudgetExceededError`
-     * - `mode === 'sync'`               → throw `BudgetExceededError`
-     * - `mode === 'auto'` + no listener  → throw `BudgetExceededError`
-     * - `mode === 'auto'` + listener     → throw `BudgetExceededError` (timeout is not extendable)
-     */
-    checkTimeout(): void;
-    /** Returns true if a wall-clock or idle timeout has occurred without throwing. */
-    isTimedOut(): boolean;
-    usage(): BudgetUsage;
-}
-
-interface SubagentConfig {
-    id?: string;
-    name: string;
-    role?: string;
-    prompt?: string;
-    maxIterations?: number;
-    maxToolCalls?: number;
-    maxTokens?: number;
-    maxCostUsd?: number;
-    /** Hard wall-clock cap (ms) from start. Opt-in; prefer `idleTimeoutMs`. */
-    timeoutMs?: number;
-    /**
-     * Idle timeout (ms): reap the subagent only after this long with no
-     * activity. Resets on every iteration / tool call / streamed progress, so
-     * an actively-working agent runs until its task naturally ends. This is the
-     * default reaper for delegated subagents (see `applyRosterBudget`).
-     */
-    idleTimeoutMs?: number;
-    tools?: string[];
-    model?: string;
-    priority?: number;
-    /**
-     * Working directory for this subagent's tools. Defaults to the factory's
-     * cwd. AutoPhase sets this to a per-phase git worktree so parallel phases
-     * edit isolated checkouts instead of clobbering one shared working tree.
-     * `projectRoot` is intentionally left unchanged — tools resolve the
-     * worktree's `.git` gitlink from `cwd` while staying bounded to the repo.
-     */
-    cwd?: string;
-    /**
-     * Provider registry id (e.g. `'anthropic'`, `'openai'`, `'google'`).
-     * Allows a director to mix providers across siblings — one subagent on
-     * Sonnet, another on GPT-5, another on Haiku. Falls back to the
-     * factory's default provider when omitted, which is the legacy
-     * single-provider behavior.
-     */
-    provider?: string;
-    /**
-     * Per-subagent session JSONL path. When omitted the orchestrator-
-     * supplied factory derives a path under `<sessionRoot>/<runId>/`.
-     * Override to redirect the transcript elsewhere (long-term storage,
-     * a different filesystem, etc.).
-     */
-    sessionPath?: string;
-    /**
-     * Additional text appended to the role's base system prompt. Does not
-     * replace it. Useful for last-mile guidance like "you may only call
-     * read tools, never write" or "respond in JSON only".
-     */
-    systemPromptOverride?: string;
-    /**
-     * Routing for streaming output. `'director'` (default) forwards
-     * text/tool events to the parent's FleetBus so the director can read
-     * the subagent's stream. `'silent'` keeps everything subagent-local;
-     * the director only sees the final task result. `'user'` forwards
-     * direct to the user-facing renderer (gate this behind an explicit
-     * config flag — it can confuse the chat surface).
-     */
-    textStream?: 'director' | 'silent' | 'user';
-    toolStream?: 'director' | 'silent' | 'user';
-}
-/**
- * Discriminator for every distinct failure mode a subagent can hit. The
- * coordinator's classifier (`classifySubagentError` in
- * coordination/multi-agent-coordinator.ts) maps raw exceptions to one of
- * these — callers (delegate tool, /agents UI, retry policies) can then
- * branch on `kind` instead of grepping `error.message`. Each kind
- * documents its retryability so an orchestrator can act on it without
- * extra knowledge.
- */
-type SubagentErrorKind = 
-/** Provider returned 5xx. Transient server-side issue — safe to retry with backoff. */
-'provider_5xx'
-/** Provider returned 429. Rate-limited — retry with `backoffMs` delay. */
- | 'provider_rate_limit'
-/** Provider call timed out at the network layer (TCP / TLS / read). Retry safe. */
- | 'provider_timeout'
-/** Provider rejected the credentials (401/403). NOT retryable — config fix required. */
- | 'provider_auth'
-/** Model returned a "context length exceeded" error. Retrying without trimming will fail again. */
- | 'context_overflow'
-/** A tool's `execute()` returned `ok:false`. Logical task failure, not a crash. */
- | 'tool_failed'
-/** A tool's `execute()` threw an exception. Often retryable but cause-dependent. */
- | 'tool_threw'
-/** Hit the per-subagent `maxIterations` budget. Either raise budget or narrow task. */
- | 'budget_iterations'
-/** Hit the per-subagent `maxToolCalls` budget. Either raise budget or narrow task. */
- | 'budget_tool_calls'
-/** Hit the per-subagent `maxTokens` budget. */
- | 'budget_tokens'
-/** Hit the per-subagent `maxCostUsd` budget. */
- | 'budget_cost'
-/** Hit the per-subagent `timeoutMs` wall-clock budget. */
- | 'budget_timeout'
-/** Parent agent's AbortController fired (user Ctrl+C, parent unwound, sibling failure cascade). */
- | 'aborted_by_parent'
-/** LLM returned end_turn with no textual content. Often a prompt issue. */
- | 'empty_response'
-/** Parent-child bridge transport failed (rare — IPC / writer crash). */
- | 'bridge_failed'
-/** Everything else. Classifier fallback — should narrow over time as new modes appear. */
- | 'unknown';
-/**
- * Structured failure envelope. Replaces the prior `error?: string` so
- * callers can switch on `kind`, respect `retryable`, and apply
- * provider-suggested `backoffMs` instead of guessing from substring
- * matches on the message.
- */
-interface SubagentError {
-    /** Discriminator — see SubagentErrorKind doc strings for semantics. */
-    kind: SubagentErrorKind;
-    /** Human-readable summary, suitable for direct UI display. Always populated. */
-    message: string;
-    /** True if the operation can be retried as-is (possibly with backoff). */
-    retryable: boolean;
-    /** Suggested backoff before retry, in ms. Set for `provider_rate_limit` and `provider_5xx`. */
-    backoffMs?: number;
-    /** Original cause snapshot for diagnostics — never used for control flow. */
-    cause?: {
-        name: string;
-        message: string;
-        stack?: string;
-    };
-}
-interface TaskResult<T = unknown> {
-    subagentId: string;
-    taskId: string;
-    status: 'success' | 'failed' | 'timeout' | 'stopped';
-    result?: T;
-    /**
-     * Structured failure envelope. Populated whenever `status !== 'success'`.
-     * Prefer reading `error.kind` over substring-matching `error.message`.
-     */
-    error?: SubagentError;
-    iterations: number;
-    toolCalls: number;
-    durationMs: number;
-}
-interface TaskSpec {
-    id: string;
-    description: string;
-    subagentId?: string;
-    priority?: number;
-    maxToolCalls?: number;
-    timeoutMs?: number;
-    context?: Record<string, unknown>;
-}
-interface DoneCondition {
-    type: 'iterations' | 'tool_calls' | 'output_match' | 'custom' | 'all_tasks_done' | 'directive';
-    maxIterations?: number;
-    maxToolCalls?: number;
-    pattern?: string;
-    predicate?: string;
-    /**
-     * For `directive` type — stop when model emits [done] and keep going
-     * on [continue]/[next step]/[proceed] WITHOUT returning to the outer runner.
-     * When false (default), the runner behaves normally (one agent.run per loop).
-     * When true, the runner passes `autonomousContinue: true` to the agent and
-     * re-runs internally when the model signals continue.
-     */
-    autonomous?: boolean;
-}
-interface MultiAgentConfig {
-    coordinatorId: string;
-    leaderSystemPrompt?: string;
-    subagents?: SubagentConfig[];
-    maxConcurrent?: number;
-    doneCondition: DoneCondition;
-    timeoutMs?: number;
-    /**
-     * Optional default budget applied to every spawned subagent. Per-subagent
-     * fields in `SubagentConfig` override these. Coordinator enforces them by
-     * constructing a `SubagentBudget` per spawn — see `SubagentRunContext.budget`.
-     */
-    defaultBudget?: {
-        maxIterations?: number;
-        maxToolCalls?: number;
-        maxTokens?: number;
-        maxCostUsd?: number;
-        timeoutMs?: number;
-        idleTimeoutMs?: number;
-    };
-}
-interface SpawnResult {
-    subagentId: string;
-    agentId: string;
-}
-interface TaskDelegation {
-    task: TaskSpec;
-    subagentId: string;
-}
-interface CoordinatorEvents {
-    'task.assigned': {
-        task: TaskSpec;
-        subagentId: string;
-    };
-    'task.completed': {
-        task: TaskSpec;
-        result: TaskResult;
-    };
-    'subagent.started': {
-        subagent: SubagentConfig;
-    };
-    'subagent.stopped': {
-        subagentId: string;
-        reason: string;
-    };
-    done: {
-        results: TaskResult[];
-        totalIterations: number;
-    };
-}
-interface MultiAgentCoordinator {
-    readonly coordinatorId: string;
-    readonly config: MultiAgentConfig;
-    spawn(subagent: SubagentConfig): Promise<SpawnResult>;
-    assign(task: TaskSpec): Promise<void>;
-    delegate(to: string, msg: BridgeMessage): Promise<void>;
-    stop(subagentId: string): Promise<void>;
-    stopAll(): Promise<void>;
-    /**
-     * Stop a subagent and remove it from the coordinator. Releases all
-     * associated resources. The subagent id can be reused in a future spawn.
-     */
-    remove(subagentId: string): Promise<void>;
-    getStatus(): CoordinatorStatus;
-    /**
-     * Wait for one or more tasks to complete and return their results.
-     * If a task is already done when called, returns immediately.
-     * Resolves to an array in the same order as `taskIds`.
-     */
-    awaitTasks(taskIds: string[]): Promise<TaskResult[]>;
-    /** Snapshot of completed task results. */
-    results(): readonly TaskResult[];
-}
-/**
- * Caller-supplied runner that actually executes a task. The coordinator
- * provides isolated state (own budget, own AbortSignal, own bridge handle)
- * and enforces concurrency limits — the runner just runs the task and reports
- * the outcome. This is the injection seam that decouples the coordinator
- * from `Agent` so it can be tested with mocks and reused for non-Agent
- * subagents (workers, MCP-driven subagents, etc.).
- */
-type SubagentRunner = (task: TaskSpec, ctx: SubagentRunContext) => Promise<SubagentRunOutcome>;
-interface SubagentRunContext {
-    subagentId: string;
-    config: SubagentConfig;
-    budget: SubagentBudget;
-    signal: AbortSignal;
-    /** Null until `setSubagentBridge` is called for this subagent. */
-    bridge: AgentBridge | null;
-}
-interface SubagentRunOutcome {
-    result?: unknown;
-    iterations: number;
-    toolCalls: number;
-}
-interface CoordinatorStatus {
-    coordinatorId: string;
-    subagents: {
-        id: string;
-        name: string;
-        status: 'running' | 'idle' | 'stopped' | 'error';
-        currentTask?: string;
-        /** Cumulative budget auto-extensions granted to this subagent, when the
-         *  status is produced by a Director that tracks them. */
-        extensions?: number;
-    }[];
-    pendingTasks: number;
-    completedTasks: number;
-    totalIterations: number;
-    done: boolean;
-}
-interface SubagentContext {
-    subagentId: string;
-    tasks: TaskSpec[];
-    /**
-     * Two-phase initialization: `spawn()` creates the subagent before the
-     * bridge is wired (`setSubagentBridge()`), so `parentBridge` is nullable
-     * by design. Readers must `hasParentBridge()`-guard or null-check before
-     * use; the prior `null as unknown as AgentBridge` cast was a type lie
-     * that hid this from the compiler.
-     */
-    parentBridge: AgentBridge | null;
-    doneCondition: DoneCondition;
-    maxConcurrent: number;
-}
-
-export { type AgentBridge as A, type BridgeMessage as B, type CoordinatorEvents as C, type DoneCondition as D, type MultiAgentConfig as M, type SpawnResult as S, type TaskDelegation as T, type AgentBridgeConfig as a, type BridgeTransport as b, BudgetExceededError as c, type BudgetKind as d, type BudgetLimits as e, type BudgetNegotiationMode as f, type BudgetThresholdDecision as g, type BudgetThresholdHandler as h, BudgetThresholdSignal as i, type BudgetUsage as j, type CoordinatorStatus as k, type MultiAgentCoordinator as l, SubagentBudget as m, type SubagentConfig as n, type SubagentContext as o, type SubagentError as p, type SubagentErrorKind as q, type SubagentRunContext as r, type SubagentRunOutcome as s, type SubagentRunner as t, type TaskResult as u, type TaskSpec as v };

package/dist/tool-executor-CIjpGaRA.d.ts

@@ -1,111 +0,0 @@
-import { d as Context, n as ProviderError, Q as Tool, _ as ToolUseBlock, Y as ToolResultBlock } from './context-iFMEO2rN.js';
-import { a as Compactor, C as CompactReport } from './compactor-0vjZ8KTk.js';
-import { R as RecoveryDecision, E as ErrorHandler, a as RetryPolicy } from './retry-policy-BfBScewS.js';
-import { b as ModelsRegistry } from './models-registry-BcYJDKLm.js';
-import { G as ToolExecutorOptions, I as ToolExecutorStrategy, T as ToolBatchResult } from './index-Bc6BiP5q.js';
-
-interface CompactorOptions {
-    preserveK?: number;
-    eliseThreshold?: number;
-    estimator?: (text: string) => number;
-}
-
-declare class HybridCompactor implements Compactor {
-    private readonly preserveK;
-    private readonly eliseThreshold;
-    private readonly estimator;
-    constructor(opts?: CompactorOptions);
-    compact(ctx: Context, opts?: {
-        aggressive?: boolean;
-    }): Promise<CompactReport>;
-    /**
-     * Estimate the full API request token count: messages + systemPrompt + toolDefs.
-     * This is the accurate figure for context-window pressure monitoring.
-     */
-    private estimateFullRequest;
-    private eliseOldToolResults;
-    private collapseAncientTurns;
-    private estimateMessages;
-}
-
-/**
- * Tiered error recovery strategies.
- * Each strategy is attempted in order until one returns a decision.
- */
-interface RecoveryStrategy {
-    /** Human-readable label for logs. */
-    label: string;
-    /** Optional compactor for context_overflow recovery. */
-    compactor?: Compactor;
-    /** Returns an explicit recovery decision, or null to fall through. */
-    attempt: (err: unknown, ctx: Context) => Promise<RecoveryDecision | null>;
-}
-/**
- * Builds the ordered list of recovery strategies used by DefaultErrorHandler.
- * Exported so callers can customise or extend the strategy chain.
- */
-declare function buildRecoveryStrategies(opts?: {
-    compactor?: Compactor;
-    modelsRegistry?: ModelsRegistry;
-}): RecoveryStrategy[];
-declare const DEFAULT_RECOVERY_STRATEGIES: RecoveryStrategy[];
-declare class DefaultErrorHandler implements ErrorHandler {
-    private readonly strategies;
-    constructor(strategies?: RecoveryStrategy[]);
-    classify(err: unknown): {
-        kind: 'rate_limit' | 'overloaded' | 'server' | 'client' | 'network' | 'abort' | 'context_overflow' | 'unknown';
-        retryable: boolean;
-    };
-    recover(err: unknown, ctx: Context): Promise<RecoveryDecision | null>;
-}
-
-declare class DefaultRetryPolicy implements RetryPolicy {
-    shouldRetry(err: Error | ProviderError, attempt: number): boolean;
-    maxAttempts(err: Error | ProviderError): number;
-    delayMs(attempt: number): number;
-}
-
-declare class ToolExecutor {
-    private readonly registry;
-    private opts;
-    private readonly serializer;
-    private readonly iterationTimeoutMs;
-    constructor(registry: {
-        get(name: string): Tool | undefined;
-        list(): Tool[];
-    }, opts: ToolExecutorOptions);
-    /**
-     * Clear the interactive confirm awaiter so the executor returns
-     * `ToolConfirmPendingResult` instead of blocking on stdin. Used by
-     * the CLI to switch from inline prompts (REPL) to event-driven
-     * confirmation (TUI) at runtime.
-     */
-    clearConfirmAwaiter(): void;
-    /**
-     * Execute a batch of tool uses using the configured strategy.
-     * Returns the execution results and the remaining output budget.
-     */
-    executeBatch(toolUses: ToolUseBlock[], ctx: Context, strategy: ToolExecutorStrategy): Promise<ToolBatchResult>;
-    /**
-     * Execute a single tool with timeout, permission check, and output capping.
-     * Emits `tool.started` via the injected EventBus (if any) right before
-     * invoking the tool — closes the observability gap between "model decided
-     * to call a tool" and "tool.executed".
-     */
-    executeTool(tool: Tool, use: ToolUseBlock, ctx: Context, budget: number): Promise<ToolResultBlock>;
-    private runWithTimeout;
-    private runStreamedTool;
-    private unknownToolResult;
-    private malformedInputResult;
-    private deniedResult;
-    private blockedByHookResult;
-    private decrementBudget;
-    /**
-     * Compute the suggestedPattern string for a tool+input pair.
-     * Matches the logic in DefaultPermissionPolicy so the TUI shows the
-     * same subject that the trust file would use.
-     */
-    private subjectFor;
-}
-
-export { type CompactorOptions as C, DEFAULT_RECOVERY_STRATEGIES as D, HybridCompactor as H, type RecoveryStrategy as R, ToolExecutor as T, DefaultErrorHandler as a, DefaultRetryPolicy as b, buildRecoveryStrategies as c };