@wrongstack/core 0.280.0 → 0.281.0

package/dist/{multi-agent-coordinator-CieyUoEL.d.ts → multi-agent-coordinator-IpHCuHUa.d.ts}

@@ -1,4 +1,4 @@
-import { S as SubagentConfig, M as MultiAgentCoordinator, c as MultiAgentConfig, d as SubagentRunner, e as BudgetSessionIdSource, F as FleetBus, f as SpawnResult, T as TaskSpec, a as BridgeMessage, A as AgentBridge, C as CoordinatorStatus, g as TaskResult } from './agent-subagent-runner-PoqNKiR4.js';
+import { S as SubagentConfig, M as MultiAgentCoordinator, b as MultiAgentConfig, c as SubagentRunner, B as BudgetSessionIdSource, F as FleetBus, d as SpawnResult, T as TaskSpec, e as BridgeMessage, f as AgentBridge, C as CoordinatorStatus, g as TaskResult, h as AwaitAnyResult } from './agent-subagent-runner-DyOSK2Wy.js';
 import { EventEmitter } from 'node:events';
 
 /**
@@ -266,12 +266,40 @@ declare class DefaultMultiAgentCoordinator extends EventEmitter implements Multi
     getStatus(): CoordinatorStatus;
     /** Expose snapshot of completed results — useful for callers awaiting all done. */
     results(): readonly TaskResult[];
+    /** Defensive snapshot of the still-queued (not yet dispatched) tasks. */
+    listPendingTasks(): readonly TaskSpec[];
+    /**
+     * Re-pin a still-PENDING task to a different subagent (`undefined` =
+     * unpin, any idle worker may take it), then try to dispatch. Returns
+     * `false` when the task is not in the pending queue — already
+     * dispatched, completed, or unknown. Running tasks can never be pulled;
+     * they can only be steered or terminated. The mutation is synchronous
+     * (same tick as the check), so it cannot race a concurrent dispatch:
+     * `tryDispatchNext` runs on this same call stack or a later one.
+     *
+     * The task keeps its id, so waiters, the report-back notifier, and
+     * checkpoint bookkeeping resolve unchanged when it eventually completes.
+     */
+    retargetPendingTask(taskId: string, subagentId: string | undefined): boolean;
     /**
      * 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[]>;
+    /**
+     * Wait until AT LEAST ONE of the named tasks completes. Returns every
+     * requested result already available at that moment (drain-what's-done)
+     * plus the ids still outstanding, so callers can loop "handle finishers,
+     * re-await the remainder" instead of blocking on the whole batch.
+     *
+     * Unlike `awaitTasks`, this never rejects and deliberately does NOT
+     * inherit `config.timeoutMs` — a "return whatever is done" call has no
+     * business timing out unless the caller asks for a window explicitly.
+     */
+    awaitTasksAny(taskIds: string[], opts?: {
+        timeoutMs?: number;
+    }): Promise<AwaitAnyResult>;
     /**
      * Manual completion — for callers that drive subagents without a runner
      * (e.g. external orchestrators). When a runner is configured the coordinator

package/dist/{null-fleet-bus-DkdmZJ_W.d.ts → null-fleet-bus-ZBkKGR9j.d.ts}

@@ -1,12 +1,43 @@
-import { A as AgentPhase, b as AgentDefinition, a as DefaultMultiAgentCoordinator, D as DispatchClassifier } from './multi-agent-coordinator-CieyUoEL.js';
-import { E as EventBus, B as BrainArbiter } from './events-Bs2fmldo.js';
-import { F as FleetBus, j as FleetUsage, S as SubagentConfig, k as FleetUsageAggregator, g as TaskResult, C as CoordinatorStatus, T as TaskSpec, c as MultiAgentConfig, d as SubagentRunner } from './agent-subagent-runner-PoqNKiR4.js';
-import { b as SessionWriter, T as Tool, k as SessionStore } from './tool-BkOgs_KL.js';
+import { i as BridgeTransport, e as BridgeMessage, f as AgentBridge, j as AgentBridgeConfig, F as FleetBus, k as FleetUsage, S as SubagentConfig, l as FleetUsageAggregator, g as TaskResult, C as CoordinatorStatus, T as TaskSpec, b as MultiAgentConfig, c as SubagentRunner, h as AwaitAnyResult } from './agent-subagent-runner-DyOSK2Wy.js';
+import { A as AgentPhase, b as AgentDefinition, a as DefaultMultiAgentCoordinator, D as DispatchClassifier } from './multi-agent-coordinator-IpHCuHUa.js';
+import { E as EventBus, B as BrainArbiter } from './events-C5hLU0AT.js';
+import { b as SessionWriter, g as Tool, k as SessionStore } from './tool-LVSLiE1s.js';
 import { EventEmitter } from 'node:events';
 import { L as Logger } from './logger-B63L5bTg.js';
 import { D as DirectorStateSnapshot } from './director-state-BfeCUbmk.js';
-import { d as ModelMatrixEntry } from './config-Cr3312zc.js';
-import { I as InMemoryAgentBridge } from './agent-bridge-DXC6QDJ4.js';
+import { a as ModelMatrixEntry } from './config-CN-vdDEI.js';
+
+/**
+ * In-memory pub/sub transport for agent-to-agent messaging.
+ * Subscribers register by agentId and receive messages via callback.
+ */
+declare class InMemoryBridgeTransport implements BridgeTransport {
+    private readonly subs;
+    send(msg: BridgeMessage, to: string): Promise<void>;
+    subscribe(agentId: string, handler: (msg: BridgeMessage) => void): () => void;
+    close(agentId: string): Promise<void>;
+}
+
+declare class InMemoryAgentBridge implements AgentBridge {
+    readonly agentId: string;
+    readonly coordinatorId: string;
+    private readonly transport;
+    private readonly subscriptions;
+    private readonly pendingRequests;
+    private stopped;
+    private timeoutMs;
+    /** Guards request() so concurrent calls on the same id can't silently overwrite. */
+    private readonly inflightGuards;
+    /** Stores the transport unsubscribe function so it can be called on stop(). */
+    private _transportUnsubscribe?;
+    constructor(config: AgentBridgeConfig, transport: BridgeTransport);
+    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>;
+}
+declare function createMessage<T = unknown>(type: BridgeMessage['type'], from: string, payload: T, to?: string | undefined): BridgeMessage<T>;
 
 /**
  * Agent catalog aggregator.
@@ -609,11 +640,40 @@ declare class FleetCostCapError extends Error {
  * symmetric with how other agents are built and avoids smuggling a
  * heavy LLM dependency into core just for the director path.
  */
+/**
+ * Payload handed to {@link DirectorOptions.taskResultNotifier} when a
+ * fire-and-forget task completes (no `awaitTasks` waiter was pending).
+ */
+interface TaskResultNotification {
+    taskId: string;
+    /** Task description (or task id when no description was recorded). */
+    title: string;
+    status: TaskResult['status'];
+    subagentId: string;
+    /** Human-readable subagent name from the fleet manifest, when known. */
+    subagentName?: string | undefined;
+    /** The subagent's textual result (stringified when structured). */
+    resultText?: string | undefined;
+    /** Flattened `kind: message` error string for non-success statuses. */
+    errorText?: string | undefined;
+    iterations: number;
+    toolCalls: number;
+    durationMs: number;
+}
 interface DirectorOptions {
     config: MultiAgentConfig;
     runner?: SubagentRunner | undefined;
     /** Optional Brain arbiter above the director for policy/decision escalation. */
     brain?: BrainArbiter | undefined;
+    /**
+     * Called when a task completes with NO pending `awaitTasks` waiter —
+     * i.e. a fire-and-forget `assign_task`. Wire this to the project
+     * mailbox so the result reaches the leader's conversation automatically
+     * instead of waiting for a poll. Synchronous `delegate` calls attach a
+     * waiter up front, so they never double-report through this hook.
+     * Internal tasks (shadow passes) are excluded. Errors are swallowed.
+     */
+    taskResultNotifier?: ((n: TaskResultNotification) => void | Promise<void>) | undefined;
     /** Optional logger for structured debug/error logging. Falls back to console if omitted. */
     logger?: Logger | undefined;
     /**
@@ -862,6 +922,13 @@ declare class Director implements ICoordinator {
      *  coordinator emits `task.completed` for a given task id. Each entry
      *  is created lazily on first poll/await and cleared once consumed. */
     private readonly taskWaiters;
+    /** First-completion waiters registered by `awaitTasksAny`. Kept separate
+     *  from `taskWaiters` on purpose: a `taskWaiters` entry marks a result as
+     *  "will be delivered in-band" and suppresses the fire-and-forget
+     *  report-back — but an any-await only consumes ONE of its ids, so the
+     *  losers must stay eligible for the mailbox notifier. Entries carry an
+     *  optional timeout timer so `shutdown()` can clear them. */
+    private readonly anyWaiters;
     /** Cache of completed results in case the consumer asks AFTER the
      *  coordinator already fired the event — `awaitTasks(['t-1'])` after
      *  t-1 finished should resolve immediately, not hang. */
@@ -883,6 +950,8 @@ declare class Director implements ICoordinator {
     private readonly roster?;
     private readonly directorPreamble;
     private readonly subagentBaseline;
+    /** See {@link DirectorOptions.taskResultNotifier}. */
+    private readonly taskResultNotifier?;
     /** Absolute path to the fleet's shared scratchpad directory, or null
      *  when none was configured. Exposed as a readonly getter for callers
      *  that need to surface the path to the user (e.g. the CLI logging
@@ -1145,6 +1214,35 @@ declare class Director implements ICoordinator {
      * whose results were already cached.
      */
     awaitTasks(taskIds: string[]): Promise<TaskResult[]>;
+    /**
+     * Wait until AT LEAST ONE of the named tasks completes, then return every
+     * requested result already cached plus the still-pending ids. This is the
+     * leader's "handle whichever finishes next" primitive — unlike
+     * `awaitTasks` it never blocks on the slowest sibling, and the siblings
+     * that complete later still reach the leader through the fire-and-forget
+     * report-back (see the consumed-in-band rule in `taskCompletedListener`).
+     *
+     * Deliberately does NOT register `taskWaiters` entries for the pending
+     * ids: a `taskWaiters` entry would mark those results as in-band-consumed
+     * and silence the mailbox notifier for results this caller never receives.
+     *
+     * With `timeoutMs`, resolves (never rejects) `{timedOut: true}` and zero
+     * completions when the window elapses first.
+     */
+    awaitTasksAny(taskIds: string[], opts?: {
+        timeoutMs?: number;
+    }): Promise<AwaitAnyResult>;
+    /** Defensive snapshot of tasks still queued (not yet dispatched). */
+    listPendingTasks(): readonly TaskSpec[];
+    /**
+     * Re-pin a still-pending task to a different subagent (`undefined` =
+     * unpin) — the rebalancing primitive used by the FleetSupervisor and
+     * available to hosts. Only queued tasks can move; a dispatched task
+     * returns `false` (steer or terminate its worker instead). Keeps
+     * ownership bookkeeping (taskOwners, checkpoint, fleet manifest) in
+     * sync with the coordinator's queue.
+     */
+    retargetPendingTask(taskId: string, subagentId: string | undefined): boolean;
     terminate(subagentId: string): Promise<void>;
     terminateAll(): Promise<void>;
     remove(subagentId: string): Promise<void>;
@@ -1911,4 +2009,4 @@ declare const FLEET_ROSTER_WITHACP: Record<string, SubagentConfig>;
  */
 declare const NULL_FLEET_BUS: FleetBus;
 
-export { getAgentDefinition as $, ACP_AGENTS as A, BUG_HUNTER_AGENT as B, type CollabBudgetConfig as C, DEFAULT_DIRECTOR_PREAMBLE as D, FLEET_ROSTER_WITHACP as E, FLEET_ROSTER as F, FleetCostCapError as G, FleetManager as H, type FleetManagerOptions as I, type FleetRosterBudget as J, FleetSpawnBudgetError as K, type ICoordinator as L, type IFleetManager as M, LargeAnswerStore as N, NULL_FLEET_BUS as O, type RefactorPhase as P, type RefactorPlan as Q, REFACTOR_PLANNER_AGENT as R, SECURITY_SCANNER_AGENT as S, type SharedFileEntry as T, type SharedFileSnapshot as U, type SubagentPromptParts as V, applyRosterBudget as W, attachAutoExtend as X, composeDirectorPrompt as Y, composeSubagentPrompt as Z, createDelegateTool as _, AGENTS_BY_PHASE as a, makeAskResultTool as a0, makeAskTool as a1, makeAssignTool as a2, makeAwaitTasksTool as a3, makeCollabDebugTool as a4, makeDirectorSessionFactory as a5, makeFleetEmitTool as a6, makeFleetTool as a7, makeRollUpTool as a8, makeSpawnTool as a9, makeTerminateAllTool as aa, makeTerminateTool as ab, makeWorkCompleteTool as ac, rosterSummaryFromConfigs as ad, AGENT_CATALOG as b, ALL_AGENT_DEFINITIONS as c, ALL_FLEET_AGENTS as d, AUDIT_LOG_AGENT as e, type AutoExtendCeiling as f, type AutoExtendPolicy as g, type BugFinding as h, type CollabBudgetOverrides as i, type CollabBudgetWarningPayload as j, type CollabDebugReport as k, CollabSession as l, type CollabSessionOptions as m, type CreateDelegateToolOptions as n, type CriticConcern as o, type CriticEvaluation as p, DEFAULT_SUBAGENT_BASELINE as q, type DelegateHost as r, Director as s, type DirectorAlert as t, DirectorAlertLevel as u, type DirectorCancelCollabPayload as v, type DirectorPromptParts as w, type DirectorSessionFactory as x, type DirectorSessionFactoryOptions as y, FLEET_ROSTER_BUDGETS as z };
+export { composeDirectorPrompt as $, ACP_AGENTS as A, BUG_HUNTER_AGENT as B, type CollabBudgetConfig as C, DEFAULT_DIRECTOR_PREAMBLE as D, FLEET_ROSTER_WITHACP as E, FLEET_ROSTER as F, FleetCostCapError as G, FleetManager as H, type FleetManagerOptions as I, type FleetRosterBudget as J, FleetSpawnBudgetError as K, type ICoordinator as L, type IFleetManager as M, InMemoryAgentBridge as N, InMemoryBridgeTransport as O, LargeAnswerStore as P, NULL_FLEET_BUS as Q, REFACTOR_PLANNER_AGENT as R, type RefactorPhase as S, type RefactorPlan as T, SECURITY_SCANNER_AGENT as U, type SharedFileEntry as V, type SharedFileSnapshot as W, type SubagentPromptParts as X, type TaskResultNotification as Y, applyRosterBudget as Z, attachAutoExtend as _, AGENTS_BY_PHASE as a, composeSubagentPrompt as a0, createDelegateTool as a1, createMessage as a2, getAgentDefinition as a3, makeAskResultTool as a4, makeAskTool as a5, makeAssignTool as a6, makeAwaitTasksTool as a7, makeCollabDebugTool as a8, makeDirectorSessionFactory as a9, makeFleetEmitTool as aa, makeFleetTool as ab, makeRollUpTool as ac, makeSpawnTool as ad, makeTerminateAllTool as ae, makeTerminateTool as af, makeWorkCompleteTool as ag, rosterSummaryFromConfigs as ah, AGENT_CATALOG as b, ALL_AGENT_DEFINITIONS as c, ALL_FLEET_AGENTS as d, AUDIT_LOG_AGENT as e, type AutoExtendCeiling as f, type AutoExtendPolicy as g, type BugFinding as h, type CollabBudgetOverrides as i, type CollabBudgetWarningPayload as j, type CollabDebugReport as k, CollabSession as l, type CollabSessionOptions as m, type CreateDelegateToolOptions as n, type CriticConcern as o, type CriticEvaluation as p, DEFAULT_SUBAGENT_BASELINE as q, type DelegateHost as r, Director as s, type DirectorAlert as t, DirectorAlertLevel as u, type DirectorCancelCollabPayload as v, type DirectorPromptParts as w, type DirectorSessionFactory as x, type DirectorSessionFactoryOptions as y, FLEET_ROSTER_BUDGETS as z };

package/dist/observability/index.d.ts

@@ -1,7 +1,7 @@
 import { M as MetricsSink, d as MetricLabels, f as MetricsSnapshot, H as HealthRegistry, a as HealthCheck, A as AggregateHealth, T as Tracer, S as Span } from '../observability-D-HZN_mF.js';
-import { E as EventBus } from '../events-Bs2fmldo.js';
-import '../tool-BkOgs_KL.js';
-import '../permission-Dx6dIqS2.js';
+import { E as EventBus } from '../events-C5hLU0AT.js';
+import '../tool-LVSLiE1s.js';
+import '../permission-B6YAtNFz.js';
 
 /**
  * In-memory metrics sink. Suitable for embedded use, tests, and /metrics

package/dist/{tool-executor-SiE1wlZo.d.ts → parallel-eternal-engine-Cc2CNgmv.d.ts}

@@ -1,58 +1,8 @@
-import { C as Context, h as ProviderError, T as Tool, t as ToolUseBlock, u as ToolResultBlock, l as ToolErrorCategory } from './tool-BkOgs_KL.js';
-import { C as Compactor, a as CompactReport } from './compactor-U3agvUIG.js';
-import { E as ErrorHandler, a as RecoveryDecision, R as RetryPolicy } from './retry-policy-D4feSLk3.js';
-import { M as ModelsRegistry, C as Config } from './config-Cr3312zc.js';
-import { h as Agent, i as AgentFactory } from './agent-subagent-runner-PoqNKiR4.js';
-import { B as BrainArbiter, E as EventBus } from './events-Bs2fmldo.js';
-import { J as JournalEntry } from './goal-store-C4F6DjC0.js';
-import { D as DispatchClassifier, a as DefaultMultiAgentCoordinator } from './multi-agent-coordinator-CieyUoEL.js';
-import { T as ToolExecutorOptions, a as ToolExecutorStrategy, b as ToolBatchResult } from './index-kidebiDh.js';
-
-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;
-}
+import { A as Agent, a as AgentFactory } from './agent-subagent-runner-DyOSK2Wy.js';
+import { B as BrainArbiter, E as EventBus } from './events-C5hLU0AT.js';
+import { C as Compactor } from './compactor-BxddyCFu.js';
+import { J as JournalEntry } from './goal-store-BLGZq16t.js';
+import { D as DispatchClassifier, a as DefaultMultiAgentCoordinator } from './multi-agent-coordinator-IpHCuHUa.js';
 
 /**
  * Design Studio — curated frontend/mobile UI design kits.
@@ -145,38 +95,6 @@ interface DesignKitLoader {
     invalidateCache(): 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>;
-}
-
 /**
  * Sense-decide-execute-reflect loop on top of a long-running Goal.
  *
@@ -569,118 +487,4 @@ declare class ParallelEternalEngine {
     private persistState;
 }
 
-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;
-    /** 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;
-}
-/**
- * Classify a tool execution error into a structured ToolErrorCategory.
- * Used for observability (span attributes) and retry strategy decisions.
- */
-declare function classifyToolError(err: unknown): {
-    category: ToolErrorCategory;
-    retryable: boolean;
-    detail?: string;
-};
-
-export { type CompactorOptions as C, type DesignStack as D, EternalAutonomyEngine as E, HybridCompactor as H, type IterationStage as I, type ParallelEngineState as P, type RecoveryStrategy as R, ToolExecutor as T, type DesignStudioState as a, type DesignKitLoader as b, type DesignKitManifest as c, type DesignKitEntry as d, type DesignKitTokens as e, DEFAULT_RECOVERY_STRATEGIES as f, DESIGN_STACKS as g, DefaultErrorHandler as h, DefaultRetryPolicy as i, type DesignTokenSet as j, type EternalAutonomyOptions as k, type EternalEngineState as l, ParallelEternalEngine as m, type ParallelEternalOptions as n, type ParallelIterationStage as o, buildRecoveryStrategies as p, classifyToolError as q, isDesignStack as r };
+export { type DesignStack as D, EternalAutonomyEngine as E, type IterationStage as I, type ParallelEngineState as P, type DesignStudioState as a, type DesignKitLoader as b, type DesignKitManifest as c, type DesignKitEntry as d, type DesignKitTokens as e, DESIGN_STACKS as f, type DesignTokenSet as g, type EternalAutonomyOptions as h, type EternalEngineState as i, ParallelEternalEngine as j, type ParallelEternalOptions as k, type ParallelIterationStage as l, isDesignStack as m };

package/dist/path-resolver-CMS5307d.d.ts

@@ -0,0 +1,13 @@
+import { P as PathResolver } from './path-resolver-CPRj4bFY.js';
+
+declare class DefaultPathResolver implements PathResolver {
+    readonly projectRoot: string;
+    readonly cwd: string;
+    constructor(cwd?: string);
+    detectProjectRoot(start: string): string;
+    resolve(input: string): string;
+    isInsideRoot(absPath: string): boolean;
+    ensureInsideRoot(absPath: string): string;
+}
+
+export { DefaultPathResolver as D };

package/dist/{permission-Dx6dIqS2.d.ts → permission-B6YAtNFz.d.ts}

@@ -1,4 +1,4 @@
-import { e as Permission, T as Tool, C as Context } from './tool-BkOgs_KL.js';
+import { f as Permission, g as Tool, d as Context } from './tool-LVSLiE1s.js';
 
 interface TrustPolicy {
     [toolNameOrPattern: string]: {

package/dist/{pipeline-BwAP21_4.d.ts → pipeline-E7_jqGyV.d.ts}

@@ -1,6 +1,6 @@
-import { T as Tool, s as TextBlock, i as ContentBlock } from './tool-BkOgs_KL.js';
+import { g as Tool, s as TextBlock, i as ContentBlock } from './tool-LVSLiE1s.js';
 import { a as MailboxAgentStatus } from './mailbox-types-BGZWrYTJ.js';
-import { H as HookEvent, f as HookMatcher, I as InProcessHook, S as ShellHook, g as HookEntry, T as ToolResultRenderMode } from './config-Cr3312zc.js';
+import { H as HookEvent, f as HookMatcher, I as InProcessHook, S as ShellHook, g as HookEntry, T as ToolResultRenderMode } from './config-CN-vdDEI.js';
 
 /** Model capabilities relevant to prompt composition. */
 interface ModelCapabilities {

package/dist/{provider-model-resolve-CwQNZWt_.d.ts → provider-model-resolve-KgIdiEQ6.d.ts}

@@ -1,7 +1,7 @@
-import { P as Provider, M as Message } from './tool-BkOgs_KL.js';
-import { M as MessageSelector, S as SelectorResult } from './selector-Dy-MzKp1.js';
+import { P as Provider, M as Message } from './tool-LVSLiE1s.js';
+import { M as MessageSelector, S as SelectorResult } from './selector-Bx2HgUkU.js';
 import { M as ModeStore, a as ModeConfig, b as Mode } from './mode-CZlO9iU1.js';
-import { e as ModelsDevModel, R as ResolvedProvider } from './config-Cr3312zc.js';
+import { M as ModelsRegistry, c as ModelsDevPayload, d as ResolvedProvider, R as ResolvedModel, W as WireFamily, e as ModelsDevModel } from './config-CN-vdDEI.js';
 
 /**
  * Offline **floor** for the ChatGPT "Sign in with ChatGPT" (`openai-codex`)
@@ -109,6 +109,111 @@ interface ModeLoaderOptions {
 declare function loadProjectModes(modesDir: string): Promise<Mode[]>;
 declare function loadUserModes(modesDir: string): Promise<Mode[]>;
 
+interface DefaultModelsRegistryOptions {
+    cacheFile: string;
+    url?: string | undefined;
+    ttlSeconds?: number | undefined;
+    fetchImpl?: typeof fetch | undefined;
+    /** Pre-seeded payload — useful for offline scenarios and tests. */
+    seed?: ModelsDevPayload | undefined;
+    /**
+     * Maximum age in seconds for stale cache fallback when network fails.
+     * Defaults to 7 days. Set to `Infinity` for full offline resilience
+     * (risk: deprecated models, wrong pricing). Set to `0` to disable
+     * stale fallback entirely.
+     */
+    maxStaleAgeSeconds?: number | undefined;
+    /**
+     * Timeout in milliseconds for the models.dev network fetch. When exceeded,
+     * the fetch is aborted and cache/stale fallback is used instead.
+     * Defaults to 15 seconds. Set to `0` to disable (infinite wait).
+     */
+    refreshTimeoutMs?: number | undefined;
+    /**
+     * Curated override payload deep-merged ON TOP of the models.dev base via
+     * `mergeModelsPayload` — adds providers/models the base lacks and overrides
+     * fields it gets wrong. Resolution order (first non-empty wins): this
+     * in-memory `overlay` → `overlayUrl` (fetched, cached) → `overlayFile`
+     * (bundled, read from disk). A missing/broken overlay degrades to `{}` and
+     * never throws, so the base alone still works.
+     */
+    overlay?: ModelsDevPayload | undefined;
+    /** GitHub-raw (or any) URL serving the curated overlay `providers.json`. */
+    overlayUrl?: string | undefined;
+    /** Path to the bundled overlay `providers.json` (offline floor). */
+    overlayFile?: string | undefined;
+    /** Cache file for the fetched `overlayUrl`. Defaults next to `cacheFile`. */
+    overlayCacheFile?: string | undefined;
+}
+declare function classifyFamily(npm: string | undefined): WireFamily;
+declare class DefaultModelsRegistry implements ModelsRegistry {
+    /** Merged (base + overlay) payload — what every reader sees. */
+    private payload?;
+    /** Memoised overlay payload (in-memory / fetched / file). */
+    private overlayPayload?;
+    /**
+     * Extra providers injected at runtime via `mergeOverlay()` — e.g. an
+     * openai-compatible server (omniroute, LiteLLM, …) auto-discovered from its
+     * `/v1/models` endpoint at boot. Applied LAST (on top of base + curated
+     * overlay) and re-applied across `refresh()` so the discovered catalog
+     * survives a models.dev refetch.
+     */
+    private extraOverlay?;
+    private fetchedAt?;
+    private readonly cacheFile;
+    private readonly url;
+    private readonly ttlMs;
+    private readonly fetchImpl;
+    private readonly seed?;
+    private readonly maxStaleAgeMs;
+    private readonly refreshTimeoutMs;
+    private readonly overlay?;
+    private readonly overlayUrl?;
+    private readonly overlayFile?;
+    private readonly overlayCacheFile?;
+    constructor(opts: DefaultModelsRegistryOptions);
+    load(opts?: {
+        force?: boolean | undefined;
+    }): Promise<ModelsDevPayload>;
+    /**
+     * Merge an additional provider payload on top of the resolved catalog. Used
+     * for runtime-discovered openai-compatible providers. Remembered so it is
+     * re-applied across `refresh()`. A no-op for an empty payload.
+     */
+    mergeOverlay(payload: ModelsDevPayload): void;
+    private withExtraOverlay;
+    /**
+     * Load the models.dev base payload: fresh cache → network → stale cache.
+     * On total failure, degrade to `{}` (so a non-empty overlay still drives
+     * the catalog) rather than throwing — unless there's no curated overlay to
+     * fall back on, in which case the original error propagates so pure-
+     * models.dev setups still surface the problem.
+     */
+    private loadBase;
+    /** Fetch + cache the models.dev base. Throws on failure (used by `refresh`). */
+    private refreshBase;
+    /**
+     * Resolve the curated overlay, memoised. Order: in-memory `overlay` →
+     * fetched `overlayUrl` (cached, same TTL/stale rules) → `overlayFile` on
+     * disk. Never throws — a missing/broken overlay yields `{}`.
+     */
+    private loadOverlay;
+    private loadOverlayFromUrl;
+    private readOverlayFile;
+    refresh(): Promise<ModelsDevPayload>;
+    listProviders(): Promise<ResolvedProvider[]>;
+    getProvider(id: string): Promise<ResolvedProvider | undefined>;
+    getModel(providerId: string, modelId: string): Promise<ResolvedModel | undefined>;
+    suggestModel(providerId: string): Promise<string | undefined>;
+    ageSeconds(): Promise<number>;
+    private resolveProvider;
+    private isFresh;
+    private isWithinMaxStaleAge;
+    private readCacheAt;
+    /** Used by `wstack models refresh` to expose where the cache lives. */
+    cacheLocation(): string;
+}
+
 /**
  * A model descriptor shaped for the WebUI `provider.models` message. All
  * metadata fields are optional because OAuth / subscription providers that
@@ -145,6 +250,14 @@ declare function describeCatalogModel(m: ModelsDevModel): ProviderModelDescripto
  *     produced the "not found in catalog" notification flood when the WebUI
  *     model switcher lazy-loaded every saved provider).
  */
-declare function resolveProviderModelList(savedModels: string[] | undefined, catalog: ResolvedProvider | undefined): ProviderModelDescriptor[];
+declare function resolveProviderModelList(savedModels: string[] | undefined, catalog: ResolvedProvider | undefined, 
+/**
+ * Provider id / wire family the list is being resolved for. Lets the
+ * resolver fall back to a known offline catalog (currently the ChatGPT
+ * `openai-codex` models) when the saved allowlist is empty AND the
+ * models.dev catalog is unavailable — so deleting the models from config
+ * never leaves the provider showing zero models.
+ */
+providerHint?: string | undefined): ProviderModelDescriptor[];
 
-export { CODEX_MODELS as C, DefaultModeStore as D, LLMSelector as L, type ModeLoaderOptions as M, type ProviderModelDescriptor as P, type CodexModelMeta as a, type LLMSelectorOptions as b, codexModelMeta as c, describeCatalogModel as d, loadUserModes as e, loadProjectModes as l, resolveProviderModelList as r };
+export { CODEX_MODELS as C, DefaultModeStore as D, LLMSelector as L, type ModeLoaderOptions as M, type ProviderModelDescriptor as P, type CodexModelMeta as a, DefaultModelsRegistry as b, type DefaultModelsRegistryOptions as c, type LLMSelectorOptions as d, classifyFamily as e, codexModelMeta as f, describeCatalogModel as g, loadUserModes as h, loadProjectModes as l, resolveProviderModelList as r };

package/dist/{provider-runner-CYHFImzV.d.ts → provider-runner-DxWXNHL1.d.ts}

@@ -1,8 +1,8 @@
-import { E as EventBus } from './events-Bs2fmldo.js';
+import { E as EventBus } from './events-C5hLU0AT.js';
 import { L as Logger } from './logger-B63L5bTg.js';
 import { T as Tracer } from './observability-D-HZN_mF.js';
-import { P as Provider, c as Request, C as Context, d as Response } from './tool-BkOgs_KL.js';
-import { R as RetryPolicy } from './retry-policy-D4feSLk3.js';
+import { P as Provider, c as Request, d as Context, e as Response } from './tool-LVSLiE1s.js';
+import { R as RetryPolicy } from './retry-policy-V67lBOJz.js';
 
 /**
  * Options passed to a ProviderRunner when calling the provider.

package/dist/{retry-policy-D4feSLk3.d.ts → retry-policy-V67lBOJz.d.ts}

@@ -1,4 +1,4 @@
-import { C as Context, d as Response, h as ProviderError } from './tool-BkOgs_KL.js';
+import { d as Context, e as Response, h as ProviderError } from './tool-LVSLiE1s.js';
 
 type RecoveryDecision = {
     /**
@@ -39,7 +39,7 @@ interface ErrorHandler {
 
 interface RetryPolicy {
     shouldRetry(err: ProviderError | Error, attempt: number): boolean;
-    delayMs(attempt: number): number;
+    delayMs(attempt: number, err?: ProviderError | Error): number;
     maxAttempts(err: ProviderError | Error): number;
 }