@wrongstack/core 0.280.0 → 0.281.0

package/dist/{todos-checkpoint-Bk2uP7Ex.d.ts → todos-checkpoint-B1QVkoa8.d.ts}

@@ -1,9 +1,9 @@
-import { A as AttachmentStore, a as AddAttachmentInput, b as AttachmentRef, c as Attachment } from './session-reader-Hk0WbNm9.js';
-import { i as ContentBlock, w as ConversationState, k as SessionStore, S as SessionEvent, j as SessionMetadata, b as SessionWriter, x as ResumedSession, y as SessionData, z as SessionSummary, A as TodoItem } from './tool-BkOgs_KL.js';
-import { E as EventBus, M as MemoryScope, b as MemoryEntry, c as MemoryStore, d as MemoryRelevanceContext, S as ScoredEntry } from './events-Bs2fmldo.js';
-import { C as Config, k as ConfigLoader, l as SyncConfig, m as ConfigStore } from './config-Cr3312zc.js';
+import { A as AttachmentStore, a as AddAttachmentInput, b as AttachmentRef, c as Attachment } from './session-reader-B-Fi9L6I.js';
+import { i as ContentBlock, u as ConversationState, k as SessionStore, S as SessionEvent, j as SessionMetadata, b as SessionWriter, v as ResumedSession, w as SessionData, x as SessionSummary, y as TodoItem } from './tool-LVSLiE1s.js';
+import { E as EventBus, M as MemoryScope, b as MemoryEntry, c as MemoryStore, d as MemoryRelevanceContext, S as ScoredEntry } from './events-C5hLU0AT.js';
+import { C as Config, i as ConfigLoader, j as SyncConfig, k as ConfigStore } from './config-CN-vdDEI.js';
 import { S as SecretVault } from './secret-vault-BAKpgFw_.js';
-import { W as WstackPaths } from './wstack-paths-CMl_cYgq.js';
+import { W as WstackPaths } from './wstack-paths-C3K40Qst.js';
 import { S as SecretScrubber } from './secret-scrubber-3MHDDAtm.js';
 
 interface AttachmentStoreOptions {
@@ -617,11 +617,22 @@ interface SessionStoreOptions {
      * conversation-turn gap (finding F-06).
      */
     secretScrubber?: SecretScrubber | undefined;
+    /**
+     * Optional guard consulted by {@link DefaultSessionStore.delete} before
+     * removing a session. Returns `true` if the session is currently in use by
+     * any live process (e.g. it is the active session of another terminal, TUI,
+     * or WebUI in this project). The store ALWAYS also checks `active.json`
+     * directly; this callback widens the check to cross-process live sessions
+     * via the SessionRegistry. When omitted, only the `active.json` check runs.
+     * Resolves to a human-readable reason when in use, or `null` when safe.
+     */
+    isSessionInUse?: ((sessionId: string) => Promise<string | null>) | undefined;
 }
 declare class DefaultSessionStore implements SessionStore {
     private readonly dir;
     private readonly events?;
     private readonly secretScrubber?;
+    private readonly isSessionInUse?;
     /**
      * In-memory cache for load() results, keyed by session ID. The cache is
      * invalidated when the file's mtimeMs or size changes (indicating the
@@ -777,7 +788,14 @@ declare class DefaultSessionStore implements SessionStore {
      * to the caller so prune() can report it.
      */
     private deleteSession;
+    /**
+     * Read the session id currently marked active in `active.json`, or `null`
+     * when the lock is absent/unreadable. Shared by {@link delete} and
+     * {@link prune} to avoid clobbering a session a live process is writing to.
+     */
+    private readActiveSessionId;
     delete(id: string): Promise<void>;
+    rename(id: string, name: string): Promise<SessionSummary>;
     prune(maxAgeDays?: number): Promise<number>;
     clearHistory(id: string): Promise<void>;
     private summarize;

package/dist/{tool-BkOgs_KL.d.ts → tool-LVSLiE1s.d.ts}

@@ -73,7 +73,6 @@ declare function isTextBlock(b: ContentBlock): b is TextBlock;
 declare function isToolUseBlock(b: ContentBlock): b is ToolUseBlock;
 declare function isToolResultBlock(b: ContentBlock): b is ToolResultBlock;
 declare function isImageBlock(b: ContentBlock): b is ImageBlock;
-declare function isThinkingBlock(b: ContentBlock): b is ThinkingBlock;
 
 /**
  * Side-effect risk classification for structured audit recording (P2 #5).
@@ -131,8 +130,6 @@ interface Message {
      */
     _estTokens?: number | undefined;
 }
-declare function asBlocks(content: string | ContentBlock[]): ContentBlock[];
-declare function asText(content: string | ContentBlock[]): string;
 
 /**
  * WrongStack error hierarchy.
@@ -1056,6 +1053,15 @@ type FileSnapshot = {
 interface SessionSummary {
     id: string;
     title: string;
+    /**
+     * Optional user-supplied name for the session. Unlike {@link title} (which
+     * is auto-derived from the first user message and overwritten on every
+     * rebuild), `name` is set explicitly via {@link SessionStore.rename} and
+     * persisted in the `.summary.json` sidecar and `_index.jsonl`. Listings
+     * should prefer `name` over `title` when present; `title` remains the
+     * fallback and stays in sync as the conversation evolves.
+     */
+    name?: string | undefined;
     startedAt: string;
     /** When the session finished (null if still running / crashed). */
     endedAt?: string | undefined;
@@ -1108,6 +1114,14 @@ interface SessionStore {
      */
     resume(id: string): Promise<ResumedSession>;
     list(limit?: number): Promise<SessionSummary[]>;
+    /**
+     * Set or clear a user-supplied name on a session. An empty/whitespace
+     * `name` clears the field (the summary's auto-derived `title` remains).
+     * Persists the change to the `.summary.json` sidecar and updates the
+     * `_index.jsonl` cache so subsequent `list()` calls reflect it.
+     * Returns the refreshed summary. Throws if the session does not exist.
+     */
+    rename(id: string, name: string): Promise<SessionSummary>;
     delete(id: string): Promise<void>;
     /**
      * Rewrite the session JSONL file to contain only a fresh session_start
@@ -1974,4 +1988,4 @@ interface ToolErrorInfo {
     readonly detail?: string;
 }
 
-export { type MessageRole as $, type TodoItem as A, AgentError as B, Context as C, type CompletedWorkEvidence as D, type CompletedWorkSource as E, ConfigError as F, type ContextEvidenceState as G, type ContextFileEvidence as H, type ContextInit as I, type JSONSchema as J, type ContextIntentEvidence as K, type ContextRepeatedReadEvidence as L, type Message as M, ERROR_CODES as N, type ErrorCode as O, type Provider as P, type ErrorSeverity as Q, type ReasoningRequest as R, type SessionEvent as S, type Tool as T, type Usage as U, type ErrorSubsystem as V, FetchError as W, type FileSnapshot as X, FsError as Y, type ImageBlock as Z, type JsonSchemaSpec as _, type ReasoningConfig as a, ParseError as a0, PluginError as a1, type ProviderErrorBody as a2, type ReadonlyConversationState as a3, type RequestCacheControl as a4, type ResponseFormat as a5, type RunEnv as a6, type SafetySetting as a7, SddError as a8, SessionError as a9, isPluginError as aA, isSddError as aB, isSessionError as aC, isTextBlock as aD, isThinkingBlock as aE, isToolError as aF, isToolResultBlock as aG, isToolUseBlock as aH, isToolValidationError as aI, isWrongStackError as aJ, toWrongStackError as aK, wrapAsState as aL, type SideEffect as aa, type SideEffectRisk as ab, type StateChange as ac, type StateChangeHandler as ad, type StopReason as ae, type StreamEvent as af, StreamHangError as ag, type ThinkingBlock as ah, type ToolCallContext as ai, ToolError as aj, type ToolErrorInfo as ak, type ToolEvidenceStatus as al, type ToolFinalEvent as am, type ToolIconId as an, type ToolStreamEvent as ao, ToolValidationError as ap, WrongStackError as aq, asBlocks as ar, asText as as, extractRunEnv as at, isAgentError as au, isConfigError as av, isFetchError as aw, isFsError as ax, isImageBlock as ay, isParseError as az, type SessionWriter as b, type Request as c, type Response as d, type Permission as e, type TokenCounter as f, type CacheStats as g, ProviderError as h, type ContentBlock as i, type SessionMetadata as j, type SessionStore as k, ToolErrorCategory as l, type ToolProgressEvent as m, type RiskTier as n, type ToolOutputMetadata as o, type ReasoningEffort as p, type CacheTtl as q, type Capabilities as r, type TextBlock as s, type ToolUseBlock as t, type ToolResultBlock as u, type RunOptions as v, ConversationState as w, type ResumedSession as x, type SessionData as y, type SessionSummary as z };
+export { type MessageRole as $, type ToolResultBlock as A, AgentError as B, type CacheStats as C, type CompletedWorkEvidence as D, type CompletedWorkSource as E, ConfigError as F, type ContextEvidenceState as G, type ContextFileEvidence as H, type ContextInit as I, type JSONSchema as J, type ContextIntentEvidence as K, type ContextRepeatedReadEvidence as L, type Message as M, ERROR_CODES as N, type ErrorCode as O, type Provider as P, type ErrorSeverity as Q, type ReasoningRequest as R, type SessionEvent as S, type TokenCounter as T, type Usage as U, type ErrorSubsystem as V, FetchError as W, type FileSnapshot as X, FsError as Y, type ImageBlock as Z, type JsonSchemaSpec as _, type ReasoningConfig as a, ParseError as a0, PluginError as a1, type ProviderErrorBody as a2, type ReadonlyConversationState as a3, type RequestCacheControl as a4, type ResponseFormat as a5, type RunEnv as a6, type SafetySetting as a7, SddError as a8, SessionError as a9, isSessionError as aA, isTextBlock as aB, isToolError as aC, isToolResultBlock as aD, isToolUseBlock as aE, isToolValidationError as aF, isWrongStackError as aG, toWrongStackError as aH, wrapAsState as aI, type SideEffect as aa, type SideEffectRisk as ab, type StateChange as ac, type StateChangeHandler as ad, type StopReason as ae, type StreamEvent as af, StreamHangError as ag, type ThinkingBlock as ah, type ToolCallContext as ai, ToolError as aj, type ToolErrorInfo as ak, type ToolEvidenceStatus as al, type ToolFinalEvent as am, type ToolIconId as an, type ToolStreamEvent as ao, ToolValidationError as ap, WrongStackError as aq, extractRunEnv as ar, isAgentError as as, isConfigError as at, isFetchError as au, isFsError as av, isImageBlock as aw, isParseError as ax, isPluginError as ay, isSddError as az, type SessionWriter as b, type Request as c, Context as d, type Response as e, type Permission as f, type Tool as g, ProviderError as h, type ContentBlock as i, type SessionMetadata as j, type SessionStore as k, ToolErrorCategory as l, type ToolProgressEvent as m, type RiskTier as n, type ToolOutputMetadata as o, type ReasoningEffort as p, type CacheTtl as q, type Capabilities as r, type TextBlock as s, type RunOptions as t, ConversationState as u, type ResumedSession as v, type SessionData as w, type SessionSummary as x, type TodoItem as y, type ToolUseBlock as z };

package/dist/{strategy-compactor-CQwhbErd.d.ts → tool-executor-BWtYwuPI.d.ts}

@@ -1,15 +1,16 @@
-import { C as Context, c as Request, P as Provider } from './tool-BkOgs_KL.js';
-import { E as EventBus } from './events-Bs2fmldo.js';
-import { M as MiddlewareHandler, b as Middleware } from './pipeline-BwAP21_4.js';
-import { S as SessionEventBridge } from './session-event-bridge-CqdiGnfU.js';
-import { C as Compactor, a as CompactReport } from './compactor-U3agvUIG.js';
-import { i as ContextWindowAggressiveOn, j as ContextWindowPolicy } from './config-Cr3312zc.js';
-import { h as Agent, D as DoneCondition } from './agent-subagent-runner-PoqNKiR4.js';
-import { R as RunResult, S as SystemPromptContributor, A as AgentPipelines, c as ToolCallPipelinePayload, U as UserInputPayload } from './index-kidebiDh.js';
-import { D as DesignStack, a as DesignStudioState, b as DesignKitLoader, c as DesignKitManifest, d as DesignKitEntry, e as DesignKitTokens } from './tool-executor-SiE1wlZo.js';
-import { M as MessageSelector } from './selector-Dy-MzKp1.js';
+import { d as Context, c as Request, P as Provider, h as ProviderError, g as Tool, z as ToolUseBlock, A as ToolResultBlock } from './tool-LVSLiE1s.js';
+import { E as EventBus } from './events-C5hLU0AT.js';
+import { M as MiddlewareHandler, b as Middleware } from './pipeline-E7_jqGyV.js';
+import { S as SessionEventBridge } from './session-event-bridge-vA2fLV58.js';
+import { C as Compactor, a as CompactReport } from './compactor-BxddyCFu.js';
+import { l as ContextWindowAggressiveOn, m as ContextWindowPolicy, M as ModelsRegistry, C as Config } from './config-CN-vdDEI.js';
+import { A as Agent, D as DoneCondition } from './agent-subagent-runner-DyOSK2Wy.js';
+import { R as RunResult, S as SystemPromptContributor, A as AgentPipelines, T as ToolCallPipelinePayload, U as UserInputPayload, f as ToolExecutorOptions, g as ToolExecutorStrategy, h as ToolBatchResult } from './index-C1E-_71T.js';
+import { D as DesignStack, a as DesignStudioState, b as DesignKitLoader, c as DesignKitManifest, d as DesignKitEntry, e as DesignKitTokens } from './parallel-eternal-engine-Cc2CNgmv.js';
+import { E as ErrorHandler, a as RecoveryDecision, R as RetryPolicy } from './retry-policy-V67lBOJz.js';
+import { M as MessageSelector } from './selector-Bx2HgUkU.js';
 import { S as SkillLoader, a as SkillManifest, b as SkillEntry } from './skill-DHniprNl.js';
-import { W as WstackPaths } from './wstack-paths-CMl_cYgq.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 {
@@ -219,6 +220,52 @@ interface AutonomyPromptContributorOptions {
  */
 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.
  *
@@ -420,6 +467,38 @@ 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): {
+        kind: 'rate_limit' | 'overloaded' | 'server' | 'client' | 'network' | 'abort' | 'context_overflow' | 'unknown';
+        retryable: boolean;
+    };
+    recover(err: unknown, ctx: Context): Promise<RecoveryDecision | null>;
+}
+
 declare function buildGoalPreamble(goal: string, deliverables?: string[]): string;
 
 /**
@@ -485,6 +564,26 @@ declare class IntelligentCompactor implements Compactor {
     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.
  */
@@ -708,4 +807,103 @@ interface StrategyCompactorOptions {
  */
 declare function createStrategyCompactor(opts?: StrategyCompactorOptions): Compactor;
 
-export { AutoCompactionMiddleware as A, installDesignStudioMiddleware as B, type CompactorStrategy as C, DefaultDesignKitLoader as D, loadActiveKit as E, loadProjectDesignRules as F, makeAutonomyPromptContributor as G, makeDesignDetectToolCallMiddleware as H, IntelligentCompactor as I, makeDesignDetectUserInputMiddleware as J, makeDesignStudioRequestMiddleware as K, makeDesignVerifyToolCallMiddleware as L, recordKitChoice as M, recordOverrides as N, renderPrompt as O, type PersistedActiveKit as P, resolveBundledDesignKitsDir as Q, setActiveKit as R, SelectiveCompactor as S, setDesignOverrides as T, type ContextWindowBudgetSnapshot as U, _resetDesignKitLoaderMemo as _, AutonomousRunner as a, type AutonomousRunnerOptions as b, type AutonomyPromptContributorOptions as c, DefaultPromptLoader as d, DefaultSkillLoader as e, type DesignKitLoaderOptions as f, type DesignOverrides as g, type DoneCheckResult as h, DoneConditionChecker as i, type IntelligentCompactorOptions as j, type PromptLoaderOptions as k, type SelectiveCompactorOptions as l, type SkillLoaderOptions as m, type StrategyCompactorOptions as n, _resetDesignRulesCache as o, activateDesign as p, applyTokenOverrides as q, buildGoalPreamble as r, clearActiveKit as s, clearPersistedActiveKit as t, createStrategyCompactor as u, designProjectDir as v, detectFrontendFile as w, detectFrontendIntent as x, getDesignKitLoader as y, getDesignState as z };
+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 };

package/dist/tools/index.d.ts

@@ -1,5 +1,5 @@
-import { T as Tool } from '../tool-BkOgs_KL.js';
-import { c as MCPServerConfig, C as Config } from '../config-Cr3312zc.js';
+import { g as Tool } from '../tool-LVSLiE1s.js';
+import { b as MCPServerConfig, C as Config } from '../config-CN-vdDEI.js';
 import '../dispatcher-types.d-BBeXBQgS.js';
 import 'node:https';
 import 'undici';