@wrongstack/core 0.284.0 → 0.285.0

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

@@ -1,906 +0,0 @@
-import { d as Context, c as Request, P as Provider, h as ProviderError, g as Tool, B as ToolUseBlock, D as ToolResultBlock } from './tool-BNlnIJvo.js';
-import { E as EventBus } from './events-Bgnh43r9.js';
-import { M as MiddlewareHandler, b as Middleware } from './pipeline-DGDyIohT.js';
-import { S as SessionEventBridge } from './session-event-bridge-D_z_mBwk.js';
-import { C as Compactor, a as CompactReport } from './compactor-DQLL4HTo.js';
-import { o as ContextWindowAggressiveOn, p as ContextWindowPolicy, M as ModelsRegistry, j as Config } from './config-MRqn1V-u.js';
-import { A as Agent, c as DoneCondition } from './multi-agent-coordinator-4RCRZKjN.js';
-import { f as RunResult, S as SystemPromptContributor, A as AgentPipelines, T as ToolCallPipelinePayload, U as UserInputPayload, g as ToolExecutorOptions, h as ToolExecutorStrategy, i as ToolBatchResult } from './index--Gm41aBJ.js';
-import { D as DesignStack, a as DesignStudioState, b as DesignKitLoader, c as DesignKitManifest, d as DesignKitEntry, e as DesignKitTokens } from './parallel-eternal-engine-HUrtePLd.js';
-import { E as ErrorHandler, a as RecoveryDecision, R as RetryPolicy } from './retry-policy-CQ7KwXJa.js';
-import { M as MessageSelector } from './selector-D8O6B_Rm.js';
-import { S as SkillLoader, a as SkillManifest, b as SkillEntry } from './skill-DHniprNl.js';
-import { W as WstackPaths } from './wstack-paths-C3K40Qst.js';
-import { P as PromptLoader, a as PromptEntry, b as PromptSearchOptions, c as PromptCategoryCount } from './prompt-DLd35n4Q.js';
-
-interface ContextWindowBudgetSnapshot {
-    maxContext: number;
-    inputTokens: number;
-    availableInputTokens: number;
-    remainingInputTokens: number;
-    reservedOutputTokens: number;
-    reservedSafetyTokens: number;
-    load: number;
-    overflowTokens: number;
-}
-type CompactionFailureMode = 'throw' | 'throw_on_hard' | 'continue';
-interface AutoCompactionOptions {
-    aggressiveOn?: ContextWindowAggressiveOn | undefined;
-    events?: EventBus | undefined;
-    failureMode?: CompactionFailureMode | undefined;
-    policyProvider?: (ctx: Context) => Pick<ContextWindowPolicy, 'thresholds' | 'aggressiveOn'> | null | undefined;
-    /** Optional bridge for writing compaction events into the persistent session log. */
-    sessionBridge?: SessionEventBridge | undefined;
-}
-/**
- * Pipeline middleware that monitors context token load and automatically
- * triggers compaction when the warn/soft/hard thresholds are crossed.
- * Runs before the next agent iteration.
- *
- * Uses `estimateRequestTokens` for accurate full-request token counting:
- * messages + systemPrompt + toolDefs. This replaces the previous pattern
- * of applying an OVERHEAD_FACTOR to a messages-only estimate.
- */
-declare class AutoCompactionMiddleware {
-    readonly name = "AutoCompaction";
-    private readonly compactor;
-    /** Deprecated. Kept for backward compat with tests that pass simpleEstimator. */
-    private readonly _estimator?;
-    private readonly warnThreshold;
-    private readonly softThreshold;
-    private readonly hardThreshold;
-    /** Writable so model-switch can update the denominator without re-registering the middleware. */
-    private _maxContext;
-    /**
-     * Runtime on/off gate. The middleware is always installed in the pipeline so
-     * auto-compaction can be toggled live from the TUI `/settings` picker; when
-     * disabled the handler is a pass-through. Defaults to enabled.
-     */
-    private _enabled;
-    private readonly aggressiveOn;
-    private readonly events?;
-    private readonly failureMode;
-    private readonly policyProvider?;
-    private readonly sessionBridge?;
-    /**
-     * Once a compaction attempt reduces nothing (preserveK protects everything,
-     * no oversized tool_results remain to elide), retrying on every iteration
-     * just spams `compaction.fired` events without making progress. We remember
-     * the no-op and skip until either the pressure level escalates or context
-     * has grown by at least this many tokens since the failed attempt.
-     */
-    private static readonly NOOP_RETRY_DELTA_TOKENS;
-    /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
-    private lastNoopAttempt;
-    /**
-     * Cached token estimate from the last handler() invocation. When the
-     * message count and tool count haven't changed since the last estimate
-     * (autonomous idle loops), we skip the expensive O(n) token estimation
-     * and reuse this value. Reset to -1 when the context changes.
-     */
-    private _cachedTokens;
-    private _cachedMsgCount;
-    private _cachedToolCount;
-    /**
-     * @param compactor        Compactor to use for compaction.
-     * @param maxContext Provider's max context window in tokens.
-     * @param _estimator       Deprecated parameter kept for backward compatibility.
-     *                         The middleware now uses `estimateRequestTokens` internally
-     *                         for accurate full-request token counting (messages +
-     *                         systemPrompt + toolDefs).
-     * @param thresholds       Threshold fractions (0-1) of maxContext.
-     * @param opts             Optional behavior. By default, failures at the
-     *                         hard threshold throw AGENT_CONTEXT_OVERFLOW so
-     *                         the agent does not continue into a likely
-     *                         provider context overflow. Warn/soft failures
-     *                         still emit compaction.failed and continue.
-     */
-    constructor(compactor: Compactor, maxContext: number, _estimator: (ctx: Context) => number, thresholds: {
-        warn: number;
-        soft: number;
-        hard: number;
-    }, optsOrAggressiveOn?: AutoCompactionOptions | ContextWindowAggressiveOn, events?: EventBus | undefined);
-    /** Allow callers (e.g. model-switch in WebUI) to update the context window
-     *  denominator when the active model changes. */
-    setMaxContext(maxContext: number): void;
-    /** Whether auto-compaction is currently active. */
-    get enabled(): boolean;
-    /** Toggle auto-compaction on a live session (TUI `/settings`). When disabled
-     *  the middleware passes every iteration straight through without estimating
-     *  tokens or compacting. */
-    setEnabled(enabled: boolean): void;
-    handler(): MiddlewareHandler<Context>;
-    /**
-     * 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).
-     * Returns the uncalibrated total when the stash is valid for the current
-     * context shape (positive number, and the message count it was computed
-     * at matches the current one — otherwise tool results have been appended
-     * since and the value is stale). Returns null when missing or stale so
-     * the caller falls back to a fresh walk.
-     */
-    private tryStashedTokens;
-    /**
-     * Returns true when the previous compaction at the same or higher pressure
-     * level reduced nothing and context has not grown materially since. Prevents
-     * a stuck preserveK window from spamming compaction events every iteration.
-     */
-    private shouldSkipNoopRetry;
-    private recordAttempt;
-    private compact;
-}
-
-type AutonomousResult = RunResult & {
-    toolCalls: number;
-    reason?: string | undefined;
-};
-interface DoneCheckResult {
-    done: boolean;
-    reason?: string | undefined;
-    iterations: number;
-    toolCalls: number;
-}
-declare class DoneConditionChecker {
-    private readonly condition;
-    private readonly compiledRegex;
-    constructor(condition: DoneCondition);
-    check(state: {
-        iterations: number;
-        toolCalls: number;
-        lastOutput?: string | undefined;
-    }): DoneCheckResult;
-}
-interface AutonomousRunnerOptions {
-    agent: Agent;
-    context: Context;
-    doneCondition: DoneCondition;
-    iterationTimeoutMs?: number | undefined;
-    onIteration?: (state: {
-        iteration: number | undefined;
-        toolCalls: number;
-    }) => void;
-    onDone?: (((result: AutonomousResult) => void)) | undefined;
-    /**
-     * When true and `doneCondition.type === 'directive'`, the runner
-     * runs the agent with `autonomousContinue: true` so the agent loop
-     * handles its own [continue]/[done] markers internally (no outer
-     * re-invocation needed). The runner still provides iteration/timeouts.
-     */
-    enableAutonomousContinue?: boolean | undefined;
-}
-declare class AutonomousRunner {
-    private readonly opts;
-    private iterations;
-    private toolCalls;
-    private lastOutput?;
-    private stopped;
-    private readonly doneChecker;
-    constructor(opts: AutonomousRunnerOptions);
-    run(): Promise<AutonomousResult>;
-    private runLoop;
-    stop(): void;
-}
-
-/**
- * System-prompt contributor that surfaces eternal-autonomy state to the
- * model on every turn.
- *
- * Why this exists: when the engine drives a long-running loop, the
- * per-iteration directive carries the rules. But the directive is a USER
- * message — it scrolls out of working memory after a few compactions and
- * the model forgets it's in autonomy mode (forgets `[GOAL_COMPLETE]`,
- * forgets the todo-state protocol, forgets the no-confirmation rule).
- * Injecting the same anchor as a CACHED system-prompt block solves that
- * — the rules sit next to the identity layer and survive compactions.
- *
- * Block is tagged `ephemeral` so its content (journal tail, iteration
- * counter) changes each turn without invalidating the upstream prefix
- * cache.
- */
-
-interface AutonomyPromptContributorOptions {
-    /** Absolute path to the project's `goal.json`. */
-    goalPath: string;
-    /**
-     * Gating function. The contributor consults this on every build and
-     * returns an empty array when `false` — without this, the block would
-     * leak into interactive runs that happen to have a goal on disk and
-     * teach the model loop-control markers it shouldn't emit.
-     *
-     * Typical wiring: enable while `eternal` or `eternal-parallel` autonomy is active.
-     */
-    enabled: () => boolean;
-    /** Number of journal entries to include in the recent-tail block. Default 5. */
-    journalTailSize?: number | undefined;
-}
-/**
- * Build a contributor that renders the autonomy-state system block.
- * Returns `[]` when disabled, no goal exists, or the goal has been
- * completed/abandoned — all silent fast-paths.
- */
-declare function makeAutonomyPromptContributor(opts: AutonomyPromptContributorOptions): SystemPromptContributor;
-
-interface CompactorOptions {
-    preserveK?: number | undefined;
-    eliseThreshold?: number | undefined;
-    /**
-     * Enable content-aware digest mode. When true, `collapseAncientTurns` uses
-     * `buildSmartDigest` which scores messages by importance: critical content
-     * (errors, corrections, decisions) is kept verbatim; normal exchanges get
-     * first-sentence summaries; large tool outputs and repeated failures are
-     * aggressively compressed. Defaults to false (lossless digest).
-     */
-    smart?: boolean | undefined;
-    /**
-     * @deprecated Ignored. Token estimation is centralized in
-     * `compaction-core`/`token-estimate` so all compactors and the context-pressure
-     * monitor agree on one number. Kept only for backward-compatible call sites.
-     */
-    estimator?: (((text: string) => number)) | undefined;
-}
-
-declare class HybridCompactor implements Compactor {
-    private readonly preserveK;
-    private readonly eliseThreshold;
-    private readonly smart;
-    constructor(opts?: CompactorOptions);
-    compact(ctx: Context, opts?: {
-        aggressive?: boolean | undefined;
-    }): Promise<CompactReport>;
-    /**
-     * Estimate the full API request token count: messages + systemPrompt + toolDefs.
-     * This is the accurate figure for context-window pressure monitoring.
-     */
-    private estimateFullRequest;
-    /**
-     * Lossless rule-based collapse of ancient turns into a single digest message.
-     *
-     * Preserves ALL textual content of the collapsed range — user instructions,
-     * assistant decisions/conclusions, and any prior digests (chained forward so
-     * the digest stays lossless across repeated compactions). Only `tool_use` /
-     * `tool_result` protocol blocks are dropped and replaced with a count marker;
-     * their full payload already lives in the session log. No sub-LLM call.
-     *
-     * Returns the token savings and the digest text (for audit logging).
-     */
-    private collapseAncientTurns;
-}
-
-/**
- * Design Studio detection + injection middleware.
- *
- * The system prompt is built ONCE per session (boot / project-switch), so a
- * system-prompt contributor cannot react to "the model just started building a
- * UI" mid-session. Instead, detection and injection ride the per-turn pipelines:
- *
- *   - userInput  middleware → detect UI intent in the user's message
- *   - toolCall   middleware → detect a frontend file being written
- *       (both set `ctx.meta.designStudio`)
- *   - request    middleware → on every turn, read `ctx.meta.designStudio` and
- *       append an ephemeral block to `req.system`: the kit menu (until a kit is
- *       chosen) or a one-line adherence reminder (once chosen).
- *
- * Keeping the heavy kit body out of this path — the model loads it on demand via
- * the `design` tool — is what keeps per-turn token cost low.
- */
-
-declare function getDesignState(ctx: {
-    meta: Record<string, unknown>;
-}): DesignStudioState | undefined;
-/** Mark Design Studio active and merge in detected signals/stack. */
-declare function activateDesign(ctx: {
-    meta: Record<string, unknown>;
-}, signals: string[], stack?: DesignStack): DesignStudioState;
-/** Record the kit the model/user committed to. */
-declare function setActiveKit(ctx: {
-    meta: Record<string, unknown>;
-}, kitId: string, stack?: DesignStack, overrides?: Record<string, string> | undefined): void;
-/** Merge color/token overrides into the live state (used by `design set`). */
-declare function setDesignOverrides(ctx: {
-    meta: Record<string, unknown>;
-}, overrides: Record<string, string>): void;
-/** Clear the active kit (e.g. `/design off`), leaving detection state intact. */
-declare function clearActiveKit(ctx: {
-    meta: Record<string, unknown>;
-}): void;
-/**
- * Inspect user text for UI/design intent. Returns the strongest stack hint and
- * the matched signals, or `null` when nothing UI-ish was found.
- */
-declare function detectFrontendIntent(text: string): {
-    stack?: DesignStack;
-    signals: string[];
-} | null;
-/** Detect whether a written/edited file path is a frontend file. */
-declare function detectFrontendFile(filePath: string): {
-    stack?: DesignStack;
-} | null;
-/** userInput middleware: detect UI intent from the user's message. */
-declare function makeDesignDetectUserInputMiddleware(): Middleware<UserInputPayload>;
-/** toolCall middleware: detect frontend file writes/edits. */
-declare function makeDesignDetectToolCallMiddleware(): Middleware<ToolCallPipelinePayload>;
-/**
- * toolCall middleware: after a frontend file is written/edited AND a kit is
- * pinned, scan the file for off-palette colors and append a non-blocking
- * warning to the tool result. This makes adherence PASSIVE — the model is
- * nudged toward kit tokens the moment it drifts, without anyone running
- * `design verify` by hand. Best-effort: any failure leaves the result untouched.
- */
-declare function makeDesignVerifyToolCallMiddleware(): Middleware<ToolCallPipelinePayload>;
-/**
- * request middleware: per-turn, inject the kit menu (until a kit is chosen) or a
- * compact adherence reminder (once chosen). No-op when Design Studio is inactive.
- *
- * Closes over the live `Context` because the `request` pipeline payload is just
- * the `Request` — it carries no ctx. `req.system` shares the array reference
- * with `ctx.systemPrompt`, so we return a NEW array rather than mutating it.
- */
-declare function makeDesignStudioRequestMiddleware(deps: {
-    ctx: Context;
-    loader: DesignKitLoader;
-    enabled?: () => boolean;
-}): Middleware<Request>;
-/**
- * Install the Design Studio per-turn middleware onto an agent's pipelines.
- * Shared by every host (CLI/TUI + both WebUI servers) so auto-detection behaves
- * identically everywhere. All three are PREPENDED:
- *   - detection runs first so a short-circuiting middleware can't suppress it;
- *   - the request injector must sit ahead of `ModelRuntimeSettings`, which does
- *     not call `next` and would otherwise end the chain before us.
- *
- * The `design` tool and `/design` command are wired separately (builtin pack +
- * slash registry); this only installs the activation behavior.
- */
-declare function installDesignStudioMiddleware(deps: {
-    pipelines: AgentPipelines;
-    ctx: Context;
-    /** When false, nothing is installed (tool + /design stay manual). */
-    enabled?: boolean | undefined;
-}): void;
-
-interface DesignKitLoaderOptions {
-    /** <project>/.wrongstack/design-kits */
-    inProjectDir: string;
-    /** ~/.wrongstack/design-kits */
-    globalDir: string;
-    /** Bundled kits shipped with @wrongstack/core (packages/core/design-kits). */
-    bundledDir?: string | undefined;
-}
-/**
- * Discovery order (highest priority first; later layers are shadowed by name):
- *   1. Project-committed:  <project>/.wrongstack/design-kits/
- *   2. User-global:        ~/.wrongstack/design-kits/
- *   3. Bundled with build: packages/core/design-kits/
- *
- * The `_foundations` directory is a reserved kit id holding the mandatory
- * cross-cutting baseline; it is excluded from the selectable menu.
- */
-declare class DefaultDesignKitLoader implements DesignKitLoader {
-    private readonly dirs;
-    private cache?;
-    private readonly bodyCache;
-    private readonly tokenCache;
-    constructor(opts: DesignKitLoaderOptions);
-    list(): Promise<DesignKitManifest[]>;
-    /** Selectable kits only (excludes the reserved `_foundations` entry). */
-    private selectable;
-    listEntries(): Promise<DesignKitEntry[]>;
-    find(id: string): Promise<DesignKitManifest | undefined>;
-    menuText(): Promise<string>;
-    readBody(id: string, stack?: DesignStack): Promise<string>;
-    readTokens(id: string): Promise<DesignKitTokens | undefined>;
-    foundationsText(stack?: DesignStack): Promise<string>;
-    invalidateCache(): void;
-}
-/**
- * Resolve the bundled `design-kits/` directory shipped alongside this module.
- * The directory is a sibling of `src/` (dev) and `dist/` (built), so we probe a
- * few candidate depths relative to the compiled module location and return the
- * first that exists. Returns `undefined` if none is found (treated as "no
- * bundled kits this run").
- */
-declare function resolveBundledDesignKitsDir(): string | undefined;
-/**
- * Memoized per-project loader. Used by the `design` tool and the Design Studio
- * middleware/slash-command so they share one cached instance without threading
- * the loader through every boot path. The loader is a pure disk reader (no
- * injected services), so a module-level memo is safe.
- */
-declare function getDesignKitLoader(projectRoot: string): DefaultDesignKitLoader;
-/** Test helper — clears the per-project loader memo. */
-declare function _resetDesignKitLoaderMemo(): void;
-
-/**
- * Project-local Design Studio store — a gitignored `<project>/.design/` directory
- * that persists design DECISIONS and project-specific design RULES across
- * sessions, separate from the committed `.wrongstack/design-kits/` (shared
- * custom kits). Layout:
- *
- *   .design/.gitignore   `*`  — self-ignores so the dir is untracked in ANY repo
- *   .design/rules.md     project design rules (always injected when UI work is active)
- *   .design/active.json  { kit, stack } — the pinned kit, restored on session start
- *   .design/decisions.md append-only log of kit choices (timestamp · kit · stack · via)
- *
- * All writes are best-effort: a failure here must never break the tool, slash
- * command, or a turn.
- */
-declare function designProjectDir(projectRoot: string): string;
-/** Read `.design/rules.md` (or RULES.md / design.md). Cached per project root. */
-declare function loadProjectDesignRules(projectRoot: string): Promise<string | undefined>;
-/**
- * User color/token overrides. Keys are token names (`primary`, `bg`, …) applied
- * to BOTH themes, or theme-scoped (`light.primary`, `dark.bg`). Values are any
- * token string (OKLCH/hex). These override kit `tokens.json` everywhere tokens
- * are consumed — the `use` snapshot, `materialize`, and `verify`.
- */
-type DesignOverrides = Record<string, string>;
-interface PersistedActiveKit {
-    kit: string;
-    stack?: string | undefined;
-    overrides?: DesignOverrides | undefined;
-}
-/** Read the persisted active kit from `.design/active.json`, if any. */
-declare function loadActiveKit(projectRoot: string): Promise<PersistedActiveKit | undefined>;
-/**
- * Apply token overrides onto a kit's light/dark token sets. A bare key
- * (`primary`) is applied to both themes; a scoped key (`light.bg`/`dark.bg`)
- * only to that theme. Returns NEW objects — never mutates the input.
- */
-declare function applyTokenOverrides<T extends {
-    light?: Record<string, string> | undefined;
-    dark?: Record<string, string> | undefined;
-}>(tokens: T, overrides: DesignOverrides | undefined): T;
-/**
- * Persist a kit choice: update `active.json` and append to `decisions.md`.
- * `isoTime` is passed in so callers control the timestamp (and tests stay
- * deterministic). Best-effort — swallows all errors.
- */
-declare function recordKitChoice(projectRoot: string, kit: string, stack: string | undefined, source: string, isoTime: string, overrides?: DesignOverrides | undefined): Promise<void>;
-/**
- * Merge color/token overrides into `active.json` WITHOUT changing the pinned
- * kit (used by `design set primary=…`). Returns the merged override map, or
- * undefined if there is no active kit to attach them to. Best-effort on write.
- */
-declare function recordOverrides(projectRoot: string, patch: DesignOverrides, isoTime: string): Promise<DesignOverrides | undefined>;
-/** Clear the persisted active kit (e.g. `/design off`). Best-effort. */
-declare function clearPersistedActiveKit(projectRoot: string): Promise<void>;
-/** Test helper — clears the rules cache. */
-declare function _resetDesignRulesCache(): void;
-
-/**
- * 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 | undefined;
-    /** 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 | undefined;
-    modelsRegistry?: ModelsRegistry | undefined;
-    getConfig?: (() => Config) | undefined;
-}): RecoveryStrategy[];
-declare const DEFAULT_RECOVERY_STRATEGIES: RecoveryStrategy[];
-declare class DefaultErrorHandler implements ErrorHandler {
-    private readonly strategies;
-    constructor(strategies?: RecoveryStrategy[]);
-    classify(err: unknown): ReturnType<ErrorHandler['classify']>;
-    recover(err: unknown, ctx: Context): Promise<RecoveryDecision | null>;
-}
-
-declare function buildGoalPreamble(goal: string, deliverables?: string[]): string;
-
-/**
- * Options for IntelligentCompactor.
- */
-interface IntelligentCompactorOptions {
-    /** Provider to use for LLM-assisted summarization. Required. */
-    provider: Provider;
-    /** Fraction of maxContext that triggers a warning (default 0.6). */
-    warnThreshold?: number | undefined;
-    /** Fraction of maxContext that triggers soft compaction (default 0.75). */
-    softThreshold?: number | undefined;
-    /** Fraction of maxContext that triggers hard compaction (default 0.9). */
-    hardThreshold?: number | undefined;
-    /** Max context window in tokens (used only for threshold fraction math). */
-    maxContext?: number | undefined;
-    /** How many recent (user+assistant) pairs to always preserve (default 4). */
-    preserveK?: number | undefined;
-    /** Token threshold below which tool results are not elided (default 500). */
-    eliseThreshold?: number | undefined;
-    /** System prompt for the summarizer sub-LLM. */
-    summarizerPrompt?: string | undefined;
-    /**
-     * Model ID to use for summarization. When not set, the same model as the
-     * agent is used (which risks cascading failure on context overflow). Set to
-     * a fast/cheap configured model for resilience.
-     */
-    summarizerModel?: string | undefined;
-}
-/**
- * IntelligentCompactor uses an LLM to:
- *  - Analyze message importance and preserve critical context
- *  - Generate semantic summaries for old message ranges
- *  - Make intelligent decisions about what to compact
- *
- * It builds on the shared `compaction-core` elision/boundary primitives and
- * adds LLM-assisted summarization on top. When the summarizer call fails it
- * falls back to the same lossless rule-based digest used by HybridCompactor.
- */
-declare class IntelligentCompactor implements Compactor {
-    private readonly provider;
-    private readonly warnThreshold;
-    private readonly softThreshold;
-    private readonly hardThreshold;
-    private readonly maxContext;
-    private readonly preserveK;
-    private readonly eliseThreshold;
-    private readonly summarizerPrompt;
-    private readonly summarizerModel?;
-    constructor(opts: IntelligentCompactorOptions);
-    compact(ctx: Context, opts?: {
-        aggressive?: boolean | undefined;
-    }): Promise<CompactReport>;
-    /**
-     * Estimate the full API request token count: messages + systemPrompt + toolDefs.
-     * This is the accurate figure for context-window pressure monitoring.
-     */
-    private estimateFullRequest;
-    /** Run shared tool-result elision and commit through ConversationState. */
-    private elide;
-    private summarizeAncientTurns;
-    private callSummarizer;
-    private messagesToText;
-}
-
-declare class DefaultRetryPolicy implements RetryPolicy {
-    shouldRetry(err: Error | ProviderError, attempt: number): boolean;
-    maxAttempts(err: Error | ProviderError): number;
-    /**
-     * Compute the retry delay.
-     *
-     * Precedence:
-     *   1. If `err` is a `ProviderError` with a populated
-     *      `body.retryAfterMs`, honour it — clamped into
-     *      [0, MAX_RETRY_AFTER_MS]. The provider told us exactly when
-     *      to come back; we should listen.
-     *   2. Otherwise fall through to the exponential-with-jitter
-     *      schedule (`1000 * 2^attempt + jitter`, capped at 30s).
-     *
-     * `err` is optional for back-compat with the existing interface;
-     * callers should pass it whenever available.
-     */
-    delayMs(attempt: number, err?: Error | ProviderError): number;
-}
-
-/**
- * Options for SelectiveCompactor — the most configurable compactor.
- */
-interface SelectiveCompactorOptions {
-    /** Provider for LLM calls (selector + summarizer). Required. */
-    provider: Provider;
-    /** Selector for LLM-driven importance analysis. */
-    selector?: MessageSelector | undefined;
-    /** Fraction of maxContext that triggers a warning (default 0.6). */
-    warnThreshold?: number | undefined;
-    /** Fraction of maxContext that triggers soft compaction (default 0.75). */
-    softThreshold?: number | undefined;
-    /** Fraction of maxContext that triggers hard compaction (default 0.9). */
-    hardThreshold?: number | undefined;
-    /** Max context window in tokens (used for threshold fraction math). */
-    maxContext?: number | undefined;
-    /** How many recent (user+assistant) pairs to always preserve (default 4). */
-    preserveK?: number | undefined;
-    /** Token threshold below which tool results are not elided (default 500). */
-    eliseThreshold?: number | undefined;
-    /** Model for selector LLM calls (default: same as provider default). */
-    selectorModel?: string | undefined;
-    /** Max output tokens for the selector LLM call (default: 1024). */
-    selectorMaxOutputTokens?: number | undefined;
-    /** Summarizer model for collapsed ranges (default: same as selectorModel). */
-    summarizerModel?: string | undefined;
-    /** Prompt for the summarizer sub-LLM. */
-    summarizerPrompt?: string | undefined;
-}
-/**
- * SelectiveCompactor uses an LLM-driven MessageSelector to make
- * surgical decisions about which message ranges to keep vs collapse.
- *
- * Compared to HybridCompactor / IntelligentCompactor:
- * - HybridCompactor: rule-based (preserveK + elision), no LLM calls
- * - IntelligentCompactor: LLM summarization but no structured selection
- * - SelectiveCompactor: full LLM-driven selection + optional summarization
- */
-declare class SelectiveCompactor implements Compactor {
-    private readonly provider;
-    private readonly selector;
-    private readonly warnThreshold;
-    private readonly softThreshold;
-    private readonly hardThreshold;
-    private readonly maxContext;
-    private readonly preserveK;
-    private readonly eliseThreshold;
-    private readonly summarizerModel;
-    private readonly summarizerPrompt;
-    constructor(opts: SelectiveCompactorOptions);
-    compact(ctx: Context, opts?: {
-        aggressive?: boolean | undefined;
-    }): 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 repairProtocolAdjacency;
-    /**
-     * Run the LLM selector to decide what to keep vs collapse.
-     * Returns the token savings achieved.
-     */
-    private runSelector;
-    /**
-     * Execute a SelectorResult plan: collapse/remove ranges and
-     * insert summaries where the selector provided them.
-     */
-    private executePlan;
-    private summarizeRange;
-    private messagePreview;
-    /**
-     * Fallback when selector fails: aggressively trim from the oldest end
-     * until we hit targetBudget.
-     */
-    private aggressiveRecencyTrim;
-    private computeTargetBudget;
-    private eliseOldToolResults;
-    private hasTextContent;
-    /**
-     * Estimate message-array tokens via the shared `estimateMessages` primitive
-     * so SelectiveCompactor's before/after/load figures agree with the
-     * middleware threshold math and the other compactors. Previously this used a
-     * private `ceil(len/3.5)` walk that diverged from the calibrated shared
-     * estimator, causing the selective `load`/`targetBudget` comparison to mix
-     * two incompatible token scales.
-     */
-    private estimateTokens;
-}
-
-interface SkillLoaderOptions {
-    paths: WstackPaths;
-    bundledDir?: string | undefined;
-    /** Read foreign `.claude/skills` dirs (project + user). Default `true`. */
-    readClaudeSkills?: boolean | undefined;
-    /** Scan other agents' skill dirs (codex/cursor/agents/qwen/trae/…). Default `true` (all); `string[]` restricts, `false` disables. */
-    foreignSources?: boolean | string[] | undefined;
-    /** Extra skill directories to scan (lowest priority, before bundled). */
-    extraDirs?: string[] | undefined;
-}
-/**
- * Discovery order (we walk highest priority first and skip names already
- * seen, so earlier layers shadow later ones):
- *   1. Project-committed:   <project>/.wrongstack/skills/
- *   2. Project foreign:     <project>/.claude/skills/      (opt-out)
- *   3. Project foreign:     <project>/.{codex,cursor,agents,…}/skills/
- *   4. User-global:         ~/.wrongstack/skills/
- *   5. User foreign:        ~/.claude/skills/              (opt-out)
- *   6. User foreign:        ~/.{codex,cursor,agents,…}/skills/
- *   7. Extra dirs:          config.skills.extraDirs         (user config only)
- *   8. Bundled with build:  packages/core/skills/
- *
- * The `.claude/*` layers let skills authored for other coding agents (Claude
- * Code, Codex, Gemini, `asm`, `gh skill`) be used without copying. They are
- * read-only — the installer never writes there.
- */
-declare class DefaultSkillLoader implements SkillLoader {
-    private readonly dirs;
-    private cache?;
-    private entriesCache?;
-    private readonly bodyCache;
-    constructor(opts: SkillLoaderOptions);
-    list(): Promise<SkillManifest[]>;
-    find(name: string): Promise<SkillManifest | undefined>;
-    manifestText(): Promise<string>;
-    listEntries(): Promise<SkillEntry[]>;
-    invalidateCache(): void;
-    readBody(name: string): Promise<string>;
-    readSaveBody(name: string): Promise<string>;
-}
-
-interface PromptLoaderOptions {
-    paths: WstackPaths;
-    /** Directory containing the bundled dataset (`data/prompts`), if shipped. */
-    bundledDir?: string | undefined;
-}
-/**
- * DefaultPromptLoader — read-side view over the three prompt layers, merged and
- * de-duplicated by `slug`. Mirrors `DefaultSkillLoader`.
- *
- * Discovery order (higher priority shadows lower by slug):
- *   1. Project-committed:  <project>/.wrongstack/prompts/   (writable, source 'project')
- *   2. User-global:        ~/.wrongstack/prompts/           (writable, source 'user'/'synced')
- *   3. Bundled with build:  <core>/data/prompts/prompts/**  (read-only, source 'builtin')
- *
- * Writes go to the user layer by default (or the project layer when
- * `scope:'project'`). Favoriting/editing a builtin copies it down into the user
- * layer (copy-on-write) so the read-only dataset is never mutated.
- */
-declare class DefaultPromptLoader implements PromptLoader {
-    private readonly projectStore?;
-    private readonly userStore?;
-    private readonly builtinDir?;
-    private cache?;
-    private builtinCache?;
-    constructor(opts: PromptLoaderOptions);
-    list(): Promise<PromptEntry[]>;
-    find(slugOrId: string): Promise<PromptEntry | undefined>;
-    search(query: string, opts?: PromptSearchOptions): Promise<PromptEntry[]>;
-    categories(): Promise<PromptCategoryCount[]>;
-    save(entry: PromptEntry, opts?: {
-        scope?: 'user' | 'project';
-    }): Promise<void>;
-    delete(slugOrId: string): Promise<boolean>;
-    setFavorite(slugOrId: string, favorite: boolean): Promise<PromptEntry | undefined>;
-    invalidateCache(): void;
-    private readBuiltin;
-}
-/**
- * Fill a prompt's `{{variable}}` placeholders with `values`. Unknown
- * placeholders are left intact unless a declared variable supplies a `default`.
- * Returns the rendered string, any required variables left unfilled
- * (`missing`), and any supplied values outside a variable's declared `enum`
- * (`invalid`).
- */
-declare function renderPrompt(entry: PromptEntry, values?: Record<string, string>): {
-    text: string;
-    missing: string[];
-    invalid: string[];
-};
-
-type CompactorStrategy = 'hybrid' | 'intelligent' | 'selective';
-interface StrategyCompactorOptions {
-    /** Which compactor to use. Defaults to 'hybrid' (lossless, no LLM). */
-    strategy?: CompactorStrategy | string | undefined;
-    /** Recent user/assistant pairs to always preserve. */
-    preserveK?: number | undefined;
-    /** Token threshold below which tool results are not elided. */
-    eliseThreshold?: number | undefined;
-    /**
-     * Enable content-aware smart digest for 'hybrid' strategy. When true,
-     * collapsed ancient turns use buildSmartDigest: critical content (errors,
-     * corrections, decisions) stays verbatim; normal exchanges get first-sentence
-     * summaries; noise (repeated failures, large tool outputs) is aggressively
-     * compressed. Defaults to false (lossless digest).
-     */
-    smart?: boolean | undefined;
-    /** Model used by the LLM-backed strategies for summarization/selection. */
-    summarizerModel?: string | undefined;
-    /** Max output tokens for the selector LLM call in 'selective' strategy (default: 1024). */
-    selectorMaxOutputTokens?: number | undefined;
-    /**
-     * Legacy shortcut for `strategy: 'selective'`. When `strategy` is unset (or
-     * 'hybrid') and this is true, the selective (LLM-driven) compactor is used.
-     * An explicit `strategy` always wins.
-     */
-    llmSelector?: boolean | undefined;
-}
-/**
- * Build the compactor named by `config.context.strategy`.
- *
- * - `hybrid` (default): lossless rule-based — no provider needed.
- * - `intelligent` / `selective`: LLM-backed. These need a `provider`, which is
- *   only known per-run, so we return a thin wrapper that resolves the concrete
- *   compactor from `ctx` at `compact()`-time. This deliberately avoids the
- *   container/provider construction-ordering problem: `TOKENS.Compactor` is
- *   resolved (and memoized) before `context.provider` exists, but `ctx.provider`
- *   is always present once a run is actually compacting. If no provider is
- *   available at compact-time the wrapper degrades to the lossless hybrid rules
- *   rather than failing.
- */
-declare function createStrategyCompactor(opts?: StrategyCompactorOptions): Compactor;
-
-declare class ToolExecutor {
-    private readonly registry;
-    private opts;
-    /** Minimum gap between coalesced `partial_output` tool.progress emits. */
-    static readonly PROGRESS_EMIT_INTERVAL_MS = 100;
-    /** Max chars of accumulated stream text carried per coalesced emit (tail). */
-    static readonly PROGRESS_TAIL_CHARS = 16384;
-    /** Max chars of the head (beginning of output) kept alongside the tail. */
-    static readonly PROGRESS_HEAD_CHARS = 16384;
-    private readonly serializer;
-    private readonly iterationTimeoutMs;
-    private readonly maxToolTimeoutMs;
-    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;
-    /**
-     * Push the tool's per-tool result-render mode into the renderer as the
-     * next-result render mode. The config key is `tools.resultRenderMode[name]`
-     * — independent of the LLM-side `descriptionMode` so the two can be
-     * toggled separately (`/tool read desc simple` vs `/tool read result
-     * simple`). Defaults to `extend` when no entry is set.
-     *
-     * The hint is one-shot: the renderer consumes it on the next
-     * `writeToolResult` call so an unset follow-up doesn't inherit a
-     * previous tool's mode. Safe no-op when the renderer doesn't implement
-     * `setResultRenderMode` (e.g. headless/test renderers).
-     */
-    private hintRenderMode;
-    private toolLogBase;
-    private logToolSuccess;
-    private logToolFailure;
-    /**
-     * 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<{
-        block: ToolResultBlock;
-        bytes: number;
-    }>;
-    /**
-     * Async "produce" phase: run the tool, serialize, scrub, and spill an
-     * oversized output to a disk artifact. Returns the pre-cap text. This is
-     * the long-running, concurrency-safe part — it touches NO shared budget
-     * state, so multiple invocations can run in parallel without racing.
-     *
-     * The `budgetHint` only gates the disk-spill threshold (a heuristic for
-     * "is this output large enough to persist"); it is NOT the output cap.
-     * The authoritative cap is applied synchronously in settleToolOutput()
-     * against the live budget.
-     */
-    private produceToolOutput;
-    /**
-     * Synchronous "settle" phase: enforce the output cap against the CURRENT
-     * budget, render, and build the result block. This MUST stay synchronous
-     * (no awaits) so that, in the parallel/smart strategies, two tools settling
-     * one after another against the shared closure budget can't interleave a
-     * stale read with a write. The first to settle consumes its bytes; the next
-     * settles against the reduced budget; once the budget hits 0, enforceCap
-     * truncates — making the per-iteration cap genuinely CUMULATIVE across
-     * parallel tools instead of degrading into a per-tool cap.
-     */
-    private settleToolOutput;
-    private runWithTimeout;
-    /** Best-effort tool cleanup; never let it mask the original error. */
-    private runToolCleanup;
-    private runStreamedTool;
-    private unknownToolResult;
-    private malformedInputResult;
-    private deniedResult;
-    private blockedByHookResult;
-    /**
-     * Subtract a string-content result's UTF-8 byte length from the
-     * iteration output budget. Used for synthesized results (unknown tool,
-     * validation error, blocked, threw) where the content is a small
-     * string built in the executor. The success path no longer goes
-     * through here — `executeTool` carries the exact byte count it spent
-     * in its return value, derived from `enforceCap`'s `newBudget`.
-     *
-     * Floors the result at 0 to match the pre-fix `decrementBudget`
-     * semantics (over-budget spends don't underflow the running total).
-     */
-    private budgetForString;
-}
-
-export { DEFAULT_RECOVERY_STRATEGIES as $, AutoCompactionMiddleware as A, detectFrontendIntent as B, type CompactorOptions as C, DefaultDesignKitLoader as D, getDesignKitLoader as E, getDesignState as F, installDesignStudioMiddleware as G, HybridCompactor as H, IntelligentCompactor as I, loadActiveKit as J, loadProjectDesignRules as K, makeAutonomyPromptContributor as L, makeDesignDetectToolCallMiddleware as M, makeDesignDetectUserInputMiddleware as N, makeDesignStudioRequestMiddleware as O, type PersistedActiveKit as P, makeDesignVerifyToolCallMiddleware as Q, recordKitChoice as R, SelectiveCompactor as S, ToolExecutor as T, recordOverrides as U, renderPrompt as V, resolveBundledDesignKitsDir as W, setActiveKit as X, setDesignOverrides as Y, type ContextWindowBudgetSnapshot as Z, _resetDesignKitLoaderMemo as _, AutonomousRunner as a, type RecoveryStrategy as a0, buildRecoveryStrategies as a1, type AutonomousRunnerOptions as b, type AutonomyPromptContributorOptions as c, type CompactorStrategy as d, DefaultErrorHandler as e, DefaultPromptLoader as f, DefaultRetryPolicy as g, DefaultSkillLoader as h, type DesignKitLoaderOptions as i, type DesignOverrides as j, type DoneCheckResult as k, DoneConditionChecker as l, type IntelligentCompactorOptions as m, type PromptLoaderOptions as n, type SelectiveCompactorOptions as o, type SkillLoaderOptions as p, type StrategyCompactorOptions as q, _resetDesignRulesCache as r, activateDesign as s, applyTokenOverrides as t, buildGoalPreamble as u, clearActiveKit as v, clearPersistedActiveKit as w, createStrategyCompactor as x, designProjectDir as y, detectFrontendFile as z };