@wrongstack/core 0.9.19 → 0.10.0

package/dist/models-registry-gwMAo6E3.d.ts

@@ -0,0 +1,86 @@
+import { b as ModelsRegistry, M as ModelsDevPayload, c as ResolvedProvider, R as ResolvedModel, W as WireFamily } from './models-registry-BcYJDKLm.js';
+
+interface DefaultModelsRegistryOptions {
+    cacheFile: string;
+    url?: string;
+    ttlSeconds?: number;
+    fetchImpl?: typeof fetch;
+    /** Pre-seeded payload — useful for offline scenarios and tests. */
+    seed?: ModelsDevPayload;
+    /**
+     * 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;
+    /**
+     * 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;
+    /** GitHub-raw (or any) URL serving the curated overlay `providers.json`. */
+    overlayUrl?: string;
+    /** Path to the bundled overlay `providers.json` (offline floor). */
+    overlayFile?: string;
+    /** Cache file for the fetched `overlayUrl`. Defaults next to `cacheFile`. */
+    overlayCacheFile?: string;
+}
+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?;
+    private fetchedAt?;
+    private readonly cacheFile;
+    private readonly url;
+    private readonly ttlMs;
+    private readonly fetchImpl;
+    private readonly seed?;
+    private readonly maxStaleAgeMs;
+    private readonly overlay?;
+    private readonly overlayUrl?;
+    private readonly overlayFile?;
+    private readonly overlayCacheFile?;
+    constructor(opts: DefaultModelsRegistryOptions);
+    load(opts?: {
+        force?: boolean;
+    }): Promise<ModelsDevPayload>;
+    /**
+     * 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;
+}
+
+export { DefaultModelsRegistry as D, type DefaultModelsRegistryOptions as a, classifyFamily as c };

package/dist/{multi-agent-3ZnTB1aT.d.ts → multi-agent-C1O8EFzb.d.ts}

@@ -1,5 +1,5 @@
-import { $ as Usage } from './context-BRNbHmRM.js';
-import { E as EventBus } from './events-CiG9qUM_.js';
+import { $ as Usage } from './context-7u93AcGD.js';
+import { E as EventBus } from './events-Bw1K5E6K.js';
 
 type BridgeMessageType = 'task' | 'result' | 'progress' | 'error' | 'heartbeat' | 'stop' | 'delegate' | 'budget_threshold';
 interface BridgeMessage<T = unknown> {
@@ -45,8 +45,21 @@ interface BudgetLimits {
     maxTokens?: number;
     /** Estimated USD cost ceiling. */
     maxCostUsd?: number;
-    /** Wall-clock timeout from start() to checkTimeout(). */
+    /**
+     * Hard wall-clock timeout measured from `start()`. Off by default — set it
+     * explicitly only when a task must finish within an absolute window. For
+     * the everyday "don't kill an agent that's still working" guard, prefer
+     * `idleTimeoutMs`, which resets on activity.
+     */
     timeoutMs?: number;
+    /**
+     * Idle timeout: the maximum gap (ms) between activity signals (iterations,
+     * tool calls, token usage, streamed progress) before the subagent is
+     * considered hung and reaped. Unlike `timeoutMs`, an actively-working
+     * agent continuously resets this clock via `markActivity()`, so it never
+     * trips on a long-but-productive run — only on a genuine stall.
+     */
+    idleTimeoutMs?: number;
 }
 /**
  * Controls how the budget behaves when `onThreshold` is set and a limit is hit.
@@ -133,19 +146,16 @@ declare class SubagentBudget {
     private tokenOutput;
     private costUsd;
     private startTime;
-    private _onThreshold;
     /**
-     * Tracks which budget kinds currently have an extension request
-     * in flight. While a kind is here, further `checkLimit` calls for the
-     * same kind are no-ops — without this dedup, every `recordIteration`
-     * after the limit is reached spawns a fresh decision Promise (until
-     * the first one lands and patches limits), flooding the FleetBus
-     * with redundant threshold events. Cleared in `negotiateExtension`'s
-     * `finally`.
+     * Timestamp of the most recent activity (iteration / tool call / token
+     * usage / streamed progress). Drives the idle timeout — reset by
+     * `markActivity()`. Initialised to `start()` time so a never-active agent
+     * still eventually trips its idle window.
      */
-    private readonly pendingExtensions;
+    private lastActivityTime;
+    private _onThreshold;
     /**
-     * Hard cap on how long `negotiateExtension` waits for the coordinator to
+     * Hard cap on how long `_negotiateExtension` waits for the coordinator to
      * respond before defaulting to 'stop'. Without this fallback an absent
      * or hung listener (Director not built / event filter detached mid-run)
      * leaves the budget over-limit and never enforces anything.
@@ -176,6 +186,18 @@ declare class SubagentBudget {
     get mode(): BudgetNegotiationMode;
     constructor(limits?: BudgetLimits, mode?: BudgetNegotiationMode);
     start(): void;
+    /**
+     * Reset the idle clock. Called on any sign of forward progress —
+     * iterations, tool calls, token usage, and streamed tool/text progress —
+     * so a long-but-productive subagent never trips its `idleTimeoutMs`.
+     */
+    markActivity(): void;
+    /**
+     * Milliseconds since the last activity signal. Returns 0 before `start()`
+     * (nothing to measure yet). Used by the coordinator watchdog to decide
+     * whether to re-arm (still active) or reap (genuinely idle).
+     */
+    idleMs(): number;
     /** Returns true if we're within 10% of any limit — useful for pre-flight checks. */
     isNearLimit(): boolean;
     /**
@@ -189,31 +211,53 @@ declare class SubagentBudget {
      * - `mode === 'auto'` + no listener  → throw `BudgetExceededError` (hard stop; no one to ask)
      * - `mode === 'auto'` + listener     → throw `BudgetThresholdSignal` with async decision promise
      */
-    private checkLimit;
+    /**
+     * Collects all exceeded budget kinds into a single NOOP-free negotiation.
+     * Called by recordIteration / recordToolCall / recordUsage — each may call
+     * this for its own kind. The first call starts the negotiation and stores
+     * the Promise in _pendingNegotiation. Subsequent calls for DIFFERENT
+     * kinds (while a negotiation is in flight) are NOOPs — they don't start
+     * new conversations with the coordinator. This prevents an EventBus flood
+     * when multiple budget kinds are exceeded simultaneously in one iteration.
+     *
+     * Returns the kinds that were found to be exceeded (for logging/debugging).
+     */
+    private checkLimits;
+    /**
+     * Per-kind in-flight negotiation Promises. Each budget kind can have its
+     * own concurrent negotiation — e.g. iterations and timeout can both
+     * be exceeded simultaneously without blocking each other. The same kind
+     * cannot start two concurrent negotiations (dedup guard).
+     * Cleared in `_negotiateExtension`'s `finally` block.
+     */
+    private _pendingNegotiations;
     /**
      * Drive the threshold handler to a decision. Resolves with `'stop'`
      * (signal the runner to abort) or `{ extend: ... }` (limits already
-     * patched in-place; the runner should not abort). Always releases the
-     * `pendingExtensions` slot in `finally`.
+     * patched in-place; the runner should not abort). Clears the
+     * per-kind slot in `_pendingNegotiations` in `finally`.
      *
      * The 'continue' return from a sync handler is treated as
      * `{ extend: {} }` — keep going without patching; next overrun fires
      * a fresh signal.
      */
-    private negotiateExtension;
+    private _negotiateExtension;
     recordIteration(): void;
     recordToolCall(): void;
     recordUsage(usage: Usage, costUsd?: number): void;
     /**
-     * Wall-clock budget check. Unlike other limits, timeout check passes through
-     * `checkLimit` and is subject to the same negotiation-mode decision table.
-     * In practice, `'sync'` mode (the usual test configuration) means a timeout
-     * immediately throws `BudgetExceededError`. In production with a coordinator,
-     * a timeout emits `budget.threshold_reached` so the Director can decide whether
-     * to extend or abort.
+     * Wall-clock budget check. Unlike other limits, timeout is always a hard stop
+     * — wall-clock time cannot be "extended" by the coordinator, so it throws
+     * synchronously rather than entering the negotiation flow.
+     *
+     * Decision table:
+     * - no `onThreshold` handler         → throw `BudgetExceededError`
+     * - `mode === 'sync'`               → throw `BudgetExceededError`
+     * - `mode === 'auto'` + no listener  → throw `BudgetExceededError`
+     * - `mode === 'auto'` + listener     → throw `BudgetExceededError` (timeout is not extendable)
      */
     checkTimeout(): void;
-    /** Returns true if a timeout has occurred without throwing. Useful for races. */
+    /** Returns true if a wall-clock or idle timeout has occurred without throwing. */
     isTimedOut(): boolean;
     usage(): BudgetUsage;
 }
@@ -227,7 +271,15 @@ interface SubagentConfig {
     maxToolCalls?: number;
     maxTokens?: number;
     maxCostUsd?: number;
+    /** Hard wall-clock cap (ms) from start. Opt-in; prefer `idleTimeoutMs`. */
     timeoutMs?: number;
+    /**
+     * Idle timeout (ms): reap the subagent only after this long with no
+     * activity. Resets on every iteration / tool call / streamed progress, so
+     * an actively-working agent runs until its task naturally ends. This is the
+     * default reaper for delegated subagents (see `applyRosterBudget`).
+     */
+    idleTimeoutMs?: number;
     tools?: string[];
     model?: string;
     priority?: number;
@@ -391,6 +443,7 @@ interface MultiAgentConfig {
         maxTokens?: number;
         maxCostUsd?: number;
         timeoutMs?: number;
+        idleTimeoutMs?: number;
     };
 }
 interface SpawnResult {

package/dist/{multi-agent-coordinator-bRaI_aD1.d.ts → multi-agent-coordinator-DoVSBFNx.d.ts}

@@ -1,5 +1,5 @@
-import { n as SubagentConfig, l as MultiAgentCoordinator, M as MultiAgentConfig, t as SubagentRunner, S as SpawnResult, v as TaskSpec, B as BridgeMessage, A as AgentBridge, k as CoordinatorStatus, u as TaskResult } from './multi-agent-3ZnTB1aT.js';
-import { F as FleetBus } from './agent-subagent-runner-C4qt9e5Y.js';
+import { n as SubagentConfig, l as MultiAgentCoordinator, M as MultiAgentConfig, t as SubagentRunner, S as SpawnResult, v as TaskSpec, B as BridgeMessage, A as AgentBridge, k as CoordinatorStatus, u as TaskResult } from './multi-agent-C1O8EFzb.js';
+import { F as FleetBus } from './agent-subagent-runner-KwufTWwn.js';
 import { EventEmitter } from 'node:events';
 
 /**
@@ -178,6 +178,15 @@ declare class DefaultMultiAgentCoordinator extends EventEmitter implements Multi
     private runner?;
     private fleetBus?;
     private readonly subagents;
+    /**
+     * Base nickname keys already handed out this run (e.g. `einstein`, `tesla`).
+     * Prevents two workers sharing a name. Direct `coordinator.spawn()` callers
+     * (parallel/eternal engine, SDD parallel run) don't go through
+     * `Director.spawn()` where nicknames are normally assigned, so the
+     * coordinator upgrades placeholder names ("Executor", "slot-ab12cd", role
+     * names) to memorable ones here — that's what surfaces in the fleet monitor.
+     */
+    private readonly usedNicknames;
     private pendingTasks;
     private completedResults;
     private totalIterations;
@@ -211,6 +220,15 @@ declare class DefaultMultiAgentCoordinator extends EventEmitter implements Multi
      * immediately tries to fill the freed slots from the pending queue.
      */
     setMaxConcurrent(n: number): void;
+    /**
+     * Upgrade a placeholder/role-derived name to a memorable scientist nickname
+     * (e.g. "Einstein (Executor)"). A name is treated as a placeholder when it is
+     * empty, equals the role (case-insensitive), is a generic default
+     * ("subagent"/"adhoc"/"generic"), or is an auto-generated `slot-…` id.
+     * Explicit, human-chosen names — including nicknames already assigned by
+     * `Director.spawn()` — are left untouched, so this never double-assigns.
+     */
+    private withNickname;
     spawn(subagent: SubagentConfig): Promise<SpawnResult>;
     assign(task: TaskSpec): Promise<void>;
     delegate(to: string, msg: BridgeMessage): Promise<void>;