@wrongstack/cli 0.299.0 → 0.301.0

package/dist/{sessions-config-NLCMK3BY.js → sessions-config-XXN7267N.js}

@@ -1,12 +1,15 @@
+import {
+  restoreFlags
+} from "./chunk-CSAPOCBP.js";
 import {
   getHistoryEntry,
   listHistory,
   restoreFromHistory,
   restoreLast
-} from "./chunk-YWUPHRGB.js";
+} from "./chunk-263G3FMB.js";
 import {
   activeProfileConfigPath
-} from "./chunk-DPJZQCVP.js";
+} from "./chunk-YMXXOOFN.js";
 import "./chunk-7OCVIDC7.js";
 
 // src/subcommands/handlers/sessions-config.ts
@@ -233,6 +236,7 @@ Fleet Run: ${runId}
 
 // src/subcommands/handlers/sessions-config.ts
 var sessionsCmd = async (args, deps) => {
+  args = restoreFlags(args, deps, ["to", "id", "latest", "l"]);
   const sub = args[0];
   if (sub === "fleet") {
     return sessionsFleetCmd(args.slice(1), deps);
@@ -302,6 +306,7 @@ var sessionsCmd = async (args, deps) => {
   return 0;
 };
 var configCmd = async (args, deps) => {
+  args = restoreFlags(args, deps, ["id", "latest", "l"]);
   const sub = args[0];
   if (!sub || sub === "show") {
     deps.renderer.write(JSON.stringify(redactKeys(deps.config), null, 2) + "\n");
@@ -406,4 +411,4 @@ export {
   configCmd,
   sessionsCmd
 };
-//# sourceMappingURL=sessions-config-NLCMK3BY.js.map
+//# sourceMappingURL=sessions-config-XXN7267N.js.map

package/dist/slash-commands/command-context.d.ts

@@ -130,6 +130,25 @@ export interface SlashCommandContext {
      * Get live coordinator status for /fleet. Returns null when no fleet is active.
      */
     onFleetStatus?: (() => import('@wrongstack/core/types').CoordinatorStatus | null) | undefined;
+    /**
+     * Read-only concurrency + lifetime spawn budget for `/fleet status`.
+     * Returns null when no fleet host is available.
+     */
+    onFleetBudget?: (() => {
+        maxConcurrent: number;
+        activeAgents: number;
+        maxSpawns: number;
+        usedSpawns: number;
+        remainingSpawns: number;
+        maxTokens?: number | undefined;
+        usedTokens?: number | undefined;
+        remainingTokens?: number | undefined;
+        maxCostUsd?: number | undefined;
+        usedCostUsd?: number | undefined;
+        remainingCostUsd?: number | undefined;
+        checkpointMaxSpawns?: number | undefined;
+        ceilingMismatch?: boolean | undefined;
+    } | null) | undefined;
     /**
      * Get fleet usage summary for /fleet usage.
      */

package/dist/subcommands/flags.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Re-attach the flags `parseArgs` stripped before a subcommand handler ran.
+ *
+ * The dispatcher (`boot.ts`) hands a handler only `positional.slice(1)`, while
+ * `parseArgs` has already pulled every `--flag` into `flags`. A handler that
+ * parses its own `args` therefore saw NONE of the flags it documents:
+ * `rewind --last 2` printed usage, `export --format json --out r.json` dumped
+ * markdown to stdout, `plugin add X --disabled` wrote it enabled, and
+ * `chronicle prune --days 7 --dry-run` performed a real 30-day purge.
+ *
+ * Re-injecting every flag at the dispatcher would be wrong: top-level switches
+ * (`--verbose`, `--yolo`, `--tui`) would land in the subcommand's argv too, and
+ * handlers with an "Unknown flag" branch — `export.ts` has one — would start
+ * rejecting valid invocations. So each handler declares the flags it owns and
+ * gets back exactly those.
+ *
+ * A spelling already present in `args` always wins: a directly-invoked handler
+ * (and anything the caller placed after `--`) keeps overriding.
+ */
+export declare function restoreFlags(args: string[], deps: {
+    flags?: Record<string, string | boolean> | undefined;
+}, names: readonly string[]): string[];
+//# sourceMappingURL=flags.d.ts.map

package/dist/terminal-format.d.ts

@@ -0,0 +1,15 @@
+export type TerminalTone = 'blue' | 'cyan' | 'green' | 'magenta' | 'muted' | 'success' | 'yellow';
+export interface TerminalStyleOptions {
+    readonly bold?: boolean;
+    /** Capability override for deterministic tests; production derives this from env/TTY. */
+    readonly enabled?: boolean;
+}
+/** Match the CLI banner's NO_COLOR/FORCE_COLOR/TTY precedence. */
+export declare function terminalFormattingEnabled(env?: NodeJS.ProcessEnv, isTty?: boolean): boolean;
+/** Add semantic color while preserving plain text when formatting is disabled. */
+export declare function terminalText(text: string, tone: TerminalTone, options?: TerminalStyleOptions): string;
+/** Render a colored OSC 8 hyperlink, falling back to the visible URL unchanged. */
+export declare function terminalLink(url: string, options?: TerminalStyleOptions & {
+    readonly tone?: TerminalTone;
+}): string;
+//# sourceMappingURL=terminal-format.d.ts.map

package/dist/webui-server/setup-events.d.ts

@@ -29,6 +29,23 @@ export interface SetupEventsDeps {
     eventUnsubscribers: Array<() => void>;
     globalConfigPath?: string | undefined;
     onFleetBroadcaster?: ((fn: () => Promise<void>) => void) | undefined;
+    /**
+     * Live fleet budget snapshot (issue #323). Merged into
+     * `fleet.concurrency_update` so the WebUI can show used/remaining spawns
+     * without a probe spawn.
+     */
+    getFleetBudget?: (() => {
+        maxSpawns?: number | undefined;
+        usedSpawns?: number | undefined;
+        remainingSpawns?: number | undefined;
+        maxConcurrent?: number | undefined;
+        activeAgents?: number | undefined;
+        maxSpawnsSource?: string | undefined;
+        maxConcurrentSource?: string | undefined;
+        effectiveSource?: string | undefined;
+        checkpointMaxSpawns?: number | undefined;
+        ceilingMismatch?: boolean | undefined;
+    } | null) | undefined;
 }
 /** CLI adapter around the canonical EventBus→WebSocket subscription graph. */
 export declare function createSetupEvents(deps: SetupEventsDeps): () => void;

package/dist/webui-server/terminal-log-view.d.ts

@@ -6,25 +6,42 @@ interface ConsoleTarget {
     error: ConsoleMethod;
     debug: ConsoleMethod;
 }
-export interface BoundedTerminalLogViewOptions {
-    maxLines?: number | undefined;
-    refreshMs?: number | undefined;
+export interface QuietSurfaceConsoleOptions {
     isTTY?: boolean | undefined;
+    /** Pass everything through untouched (the `WEBUI_VERBOSE=1` escape hatch). */
+    verbose?: boolean | undefined;
     consoleTarget?: ConsoleTarget | undefined;
-    write?: ((chunk: string) => void) | undefined;
-    setIntervalFn?: ((callback: () => void, delay: number) => NodeJS.Timeout) | undefined;
-    clearIntervalFn?: ((timer: NodeJS.Timeout) => void) | undefined;
+    /** Ring-buffer size for {@link QuietSurfaceConsole.recent}. */
+    bufferLines?: number | undefined;
 }
-export interface BoundedTerminalLogView {
+export interface QuietSurfaceConsole {
+    /** `false` when the console was left untouched (non-TTY or verbose). */
     readonly enabled: boolean;
-    redraw(): void;
+    /** Chatter lines dropped from the terminal so far. */
+    readonly mutedCount: number;
+    /** Newest muted lines, oldest first — for a diagnostic dump on failure. */
+    recent(): readonly string[];
     stop(): void;
 }
 /**
- * Periodically redraw an interactive WebUI/SimpleUI terminal with only its
- * newest physical log lines. Non-TTY output is deliberately untouched so
- * redirected output and log collectors retain the complete append-only log.
+ * Keep an interactive WebUI/SimpleUI terminal quiet while the browser owns
+ * the output surface.
+ *
+ * Two things fill that terminal, and this handles both:
+ *
+ *   - **Chatter.** Every `console.log`/`info`/`debug` from the server is
+ *     progress the browser already shows. Those are dropped from the
+ *     terminal (still counted, and the newest are kept in memory for a
+ *     failure dump); `console.warn`/`error` are forwarded untouched.
+ *
+ *   - **Repetition.** A warning that fires on a timer used to append an
+ *     identical line every tick until the terminal was pages deep in the
+ *     same text. Consecutive identical lines now collapse into a single
+ *     `↑ previous line repeated N×` notice emitted when the streak ends.
+ *
+ * Non-TTY output is deliberately untouched so redirected output and log
+ * collectors retain the complete append-only log, as is `WEBUI_VERBOSE=1`.
  */
-export declare function startBoundedTerminalLogView(options?: BoundedTerminalLogViewOptions): BoundedTerminalLogView;
+export declare function startQuietSurfaceConsole(options?: QuietSurfaceConsoleOptions): QuietSurfaceConsole;
 export {};
 //# sourceMappingURL=terminal-log-view.d.ts.map

package/dist/{webui-server-PCLSXX6L.js → webui-server-DD35QFNO.js}

@@ -41,11 +41,12 @@ import {
   resolveAuthToken,
   SddBoardWebSocketHandler,
   SddWizardWebSocketHandler,
+  sendSerialized,
   SpecsWebSocketHandler,
   TerminalWebSocketHandler,
   WorktreeWebSocketHandler
 } from "@wrongstack/webui-server";
-import { WebSocket, WebSocketServer } from "ws";
+import { WebSocketServer } from "ws";
 
 // src/webui-server/client-registration.ts
 import { createWebuiClientPresence } from "@wrongstack/webui-server";
@@ -679,9 +680,23 @@ function createSetupEvents(deps) {
   let fleetConcurrency = 0;
   let fleetConcurrencyMax = 4;
   const emitConcurrency = () => {
+    const budget = deps.getFleetBudget?.() ?? null;
     deps.broadcast({
       type: "fleet.concurrency_update",
-      payload: deps.sessionPayload({ fleetConcurrency, fleetConcurrencyMax })
+      payload: deps.sessionPayload({
+        fleetConcurrency: budget?.activeAgents ?? fleetConcurrency,
+        fleetConcurrencyMax: budget?.maxConcurrent ?? fleetConcurrencyMax,
+        ...budget ? {
+          maxSpawns: budget.maxSpawns,
+          usedSpawns: budget.usedSpawns,
+          remainingSpawns: budget.remainingSpawns,
+          maxSpawnsSource: budget.maxSpawnsSource,
+          maxConcurrentSource: budget.maxConcurrentSource,
+          effectiveSource: budget.effectiveSource,
+          checkpointMaxSpawns: budget.checkpointMaxSpawns,
+          ceilingMismatch: budget.ceilingMismatch
+        } : {}
+      })
     });
   };
   return function setupEvents() {
@@ -761,24 +776,35 @@ import {
 
 // src/webui-server/terminal-log-view.ts
 import { format } from "node:util";
-var DEFAULT_MAX_LINES = 5;
-var DEFAULT_REFRESH_MS = 5e3;
-var CLEAR_VISIBLE_TERMINAL = "\x1B[2J\x1B[H";
-function startBoundedTerminalLogView(options = {}) {
-  const isTTY = options.isTTY ?? process.stdout.isTTY === true;
-  if (!isTTY) {
-    return { enabled: false, redraw: () => {
-    }, stop: () => {
-    } };
+var DEFAULT_BUFFER_LINES = 200;
+var MUTED_LEVELS = ["log", "info", "debug"];
+var FORWARDED_LEVELS = ["warn", "error"];
+var DISABLED = {
+  enabled: false,
+  mutedCount: 0,
+  recent: () => [],
+  stop: () => {
+  }
+};
+function envVerbose() {
+  for (const name of ["WEBUI_VERBOSE", "WRONGSTACK_WEBUI_VERBOSE"]) {
+    const value = process.env[name]?.trim().toLowerCase();
+    if (value === "1" || value === "true" || value === "yes" || value === "on") return true;
   }
-  const maxLines = Math.max(1, Math.trunc(options.maxLines ?? DEFAULT_MAX_LINES));
-  const refreshMs = Math.max(100, Math.trunc(options.refreshMs ?? DEFAULT_REFRESH_MS));
+  return false;
+}
+function startQuietSurfaceConsole(options = {}) {
+  const isTTY = options.isTTY ?? process.stdout.isTTY === true;
+  const verbose = options.verbose ?? envVerbose();
+  if (!isTTY || verbose) return DISABLED;
+  const bufferLines = Math.max(1, Math.trunc(options.bufferLines ?? DEFAULT_BUFFER_LINES));
   const target = options.consoleTarget ?? console;
-  const write = options.write ?? ((chunk) => process.stdout.write(chunk));
-  const setIntervalFn = options.setIntervalFn ?? setInterval;
-  const clearIntervalFn = options.clearIntervalFn ?? clearInterval;
-  const lines = [];
+  const muted = [];
+  let mutedCount = 0;
   let stopped = false;
+  let lastLine = null;
+  let lastEmit = null;
+  let repeats = 0;
   const originals = {
     log: target.log,
     info: target.info,
@@ -787,35 +813,47 @@ function startBoundedTerminalLogView(options = {}) {
     debug: target.debug
   };
   const wrappers = {};
-  const remember = (args) => {
-    for (const line of format(...args).split(/\r?\n/u)) {
-      lines.push(line);
-      if (lines.length > maxLines) lines.shift();
-    }
+  const flushRepeats = () => {
+    if (repeats === 0 || !lastEmit) return;
+    const count = repeats;
+    repeats = 0;
+    lastEmit.call(target, `  \u2191 previous line repeated ${count}\xD7`);
   };
-  for (const level of Object.keys(originals)) {
+  for (const level of MUTED_LEVELS) {
+    const wrapper = (...args) => {
+      mutedCount += 1;
+      muted.push(format(...args));
+      if (muted.length > bufferLines) muted.shift();
+    };
+    wrappers[level] = wrapper;
+    target[level] = wrapper;
+  }
+  for (const level of FORWARDED_LEVELS) {
     const original = originals[level];
     const wrapper = (...args) => {
-      remember(args);
+      const line = format(...args);
+      if (line === lastLine) {
+        repeats += 1;
+        return;
+      }
+      flushRepeats();
+      lastLine = line;
+      lastEmit = original;
       original.apply(target, args);
     };
     wrappers[level] = wrapper;
     target[level] = wrapper;
   }
-  const redraw = () => {
-    if (stopped || lines.length === 0) return;
-    write(`${CLEAR_VISIBLE_TERMINAL}${lines.join("\n")}
-`);
-  };
-  const timer = setIntervalFn(redraw, refreshMs);
-  timer.unref?.();
   return {
     enabled: true,
-    redraw,
+    get mutedCount() {
+      return mutedCount;
+    },
+    recent: () => [...muted],
     stop: () => {
       if (stopped) return;
       stopped = true;
-      clearIntervalFn(timer);
+      flushRepeats();
       for (const level of Object.keys(originals)) {
         if (target[level] === wrappers[level]) target[level] = originals[level];
       }
@@ -825,6 +863,7 @@ function startBoundedTerminalLogView(options = {}) {
 
 // src/webui-server.ts
 async function runWebUI(opts) {
+  const terminalLogView = startQuietSurfaceConsole();
   const trustBoundary = opts.trustBoundary ?? createCompatibilityTrustBoundary({ policyId: "cli-webui-trusted-host-compat-v1" });
   const host = opts.host ?? process.env["WEBUI_HOST"] ?? process.env["WS_HOST"] ?? "127.0.0.1";
   const publicUrl = opts.publicUrl ?? process.env["WEBUI_PUBLIC_URL"];
@@ -1060,7 +1099,10 @@ async function runWebUI(opts) {
       publicUrl,
       projectRoot: opts.projectRoot,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      registryBaseDir
+      registryBaseDir,
+      // Lets a same-project TUI/REPL authenticate `POST /api/fleet/ping` now
+      // that the API requires a token on every bind (H3).
+      authToken: wsToken
     });
   }
   const eventUnsubscribers = [];
@@ -1096,7 +1138,8 @@ async function runWebUI(opts) {
     globalConfigPath: path5.join(globalRoot, "config.json"),
     onFleetBroadcaster: (fn) => {
       fleetBroadcastCli = fn;
-    }
+    },
+    ...opts.getFleetBudget ? { getFleetBudget: opts.getFleetBudget } : {}
   });
   const wsHandlerCtx = {
     providerStore: createProviderConfigStore(
@@ -1172,7 +1215,10 @@ async function runWebUI(opts) {
             ...snapshot.baseUrl !== void 0 ? { baseUrl: snapshot.baseUrl } : {}
           };
           const oldMax = opts.agent.ctx.provider.capabilities?.maxContext;
-          const prov = makeProviderFromConfig(activeId, { ...newCfg, type: activeId });
+          const prov = makeProviderFromConfig(activeId, {
+            ...newCfg,
+            type: newCfg.type ?? activeId
+          });
           if (oldMax != null && prov.capabilities) prov.capabilities.maxContext = oldMax;
           opts.agent.ctx.provider = prov;
           console.log(`[WebUI] Provider credentials reloaded from config.json (${activeId})`);
@@ -1352,7 +1398,6 @@ async function runWebUI(opts) {
     kanbanHostRoutes,
     statusTracker: opts.statusTracker
   });
-  const terminalLogView = startBoundedTerminalLogView();
   const stopped = new Promise((resolve) => {
     let listeningAnnounced = false;
     const announceListening = () => {
@@ -1431,6 +1476,28 @@ async function runWebUI(opts) {
         flushAllStreamBuffers();
         for (const unsub of eventUnsubscribers) unsub();
       },
+      // Issue #322: kill session-owned children (MCP, bash/exec, tool-spawned
+      // dev servers) before closing the listen socket so Windows process trees
+      // do not outlive the parent and strand the event loop on open stdio.
+      stopOwnedChildren: async () => {
+        try {
+          const { getProcessRegistry } = await import("@wrongstack/tools");
+          getProcessRegistry().killAll({ force: true, includeProtected: true });
+        } catch (err) {
+          console.debug(
+            `[webui-server] process-registry killAll failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        if (opts.mcpRegistry) {
+          try {
+            await opts.mcpRegistry.stopAll();
+          } catch (err) {
+            console.debug(
+              `[webui-server] mcpRegistry.stopAll failed: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      },
       disposeResources: () => {
         credentialWatcherClose?.();
         credentialWatcherClose = void 0;
@@ -1455,8 +1522,13 @@ async function runWebUI(opts) {
       pid: process.pid,
       registryBaseDir,
       onStopped: () => {
-        terminalLogView.redraw();
+        const muted = terminalLogView.mutedCount;
         terminalLogView.stop();
+        if (muted > 0) {
+          console.log(
+            `[WebUI] ${muted} progress line(s) kept out of this terminal \u2014 set WEBUI_VERBOSE=1 to see them.`
+          );
+        }
         opts.onExit?.();
         resolve();
       }
@@ -1464,20 +1536,11 @@ async function runWebUI(opts) {
     registerWebuiSignalHandlers(signalShutdown);
   });
   function send(ws, msg) {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify(msg));
-    }
+    sendSerialized(ws, JSON.stringify(msg));
   }
   function broadcast(msg) {
     const data = JSON.stringify(msg);
-    for (const [ws] of clients) {
-      if (ws.readyState === WebSocket.OPEN) {
-        try {
-          ws.send(data);
-        } catch {
-        }
-      }
-    }
+    for (const [ws] of clients) sendSerialized(ws, data);
   }
   function sendResult(ws, success, message) {
     send(ws, { type: "key.operation_result", payload: { success, message } });
@@ -1487,4 +1550,4 @@ async function runWebUI(opts) {
 export {
   runWebUI
 };
-//# sourceMappingURL=webui-server-PCLSXX6L.js.map
+//# sourceMappingURL=webui-server-DD35QFNO.js.map

package/dist/webui-server-options.d.ts

@@ -36,6 +36,22 @@ export interface CliWebUIOptions {
     surface?: 'webui' | 'simpleui' | undefined;
     /** Fixed access token/password. Defaults to WEBUI_TOKEN or random per process. */
     accessToken?: string | undefined;
+    /**
+     * Live fleet concurrency + lifetime spawn budget for WebUI (issue #323).
+     * Merged into `fleet.concurrency_update` broadcasts.
+     */
+    getFleetBudget?: (() => {
+        maxSpawns?: number | undefined;
+        usedSpawns?: number | undefined;
+        remainingSpawns?: number | undefined;
+        maxConcurrent?: number | undefined;
+        activeAgents?: number | undefined;
+        maxSpawnsSource?: string | undefined;
+        maxConcurrentSource?: string | undefined;
+        effectiveSource?: string | undefined;
+        checkpointMaxSpawns?: number | undefined;
+        ceilingMismatch?: boolean | undefined;
+    } | null) | undefined;
     /** Browser-facing HTTP URL, used when WebUI is exposed behind a tunnel/proxy. */
     publicUrl?: string | undefined;
     /** Browser-facing WebSocket URL injected into the frontend. */

package/dist/wiring/brain-and-orchestration.d.ts

@@ -1,7 +1,7 @@
 import { BrainDecisionQueue, type BrainEscalationMode, ObservableBrainArbiter } from '@wrongstack/core/coordination';
 import { type BrainAutoRisk, type BrainRuntime } from '@wrongstack/core/execution';
 import type { ToolRegistry } from '@wrongstack/core/registry';
-import type { Config, Provider, SecretVault, SessionWriter } from '@wrongstack/core/types';
+import { type Config, type Provider, type SecretVault, type SessionWriter } from '@wrongstack/core/types';
 import { MultiAgentHost } from '../multi-agent.js';
 type AnyObj = any;
 /**
@@ -49,6 +49,9 @@ export interface BrainOrchestrationDeps {
     stateCheckpointPath: string | undefined;
     fleetRootForPromotion: string;
     maxConcurrent: number | undefined;
+    maxSpawns?: number | undefined;
+    maxConcurrentSource?: import('../fleet/budget-source.js').FleetBudgetSource | undefined;
+    maxSpawnsSource?: import('../fleet/budget-source.js').FleetBudgetSource | undefined;
     effectiveMaxContextRef: {
         current: number;
     };

package/dist/wiring/director-setup.d.ts

@@ -23,6 +23,10 @@ export interface DirectorAutonomyResult {
     director: Director | null;
     directorMode: boolean;
     maxConcurrent: number | undefined;
+    /** Lifetime spawn ceiling resolved from flag/env/profile/default. */
+    maxSpawns: number;
+    maxConcurrentSource: import('../fleet/budget-source.js').FleetBudgetSource;
+    maxSpawnsSource: import('../fleet/budget-source.js').FleetBudgetSource;
     autonomyMode: import('../services/autonomy-mode.js').AutonomyMode;
     nextPredictEnabled: boolean;
     currentSuggestions: string[];

package/dist/wiring/fallback-gate.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Factory for the fallback gate function.
+ *
+ * The gate is injected into `createFallbackModelExtension` as `fallbackGate`.
+ * When the fallback chain is about to engage, the gate:
+ *
+ * 1. Registers a `provider.fallback_choice` listener keyed on `requestId`.
+ * 2. Emits `provider.fallback_pending` on the EventBus — carrying the
+ *    candidate list, countdown duration, and the caller-supplied
+ *    `requestId` (generated by the fallback-model extension so the
+ *    `provider.fallback` completion event can share the same id).
+ * 3. Waits for the choice event (the user manually picked a model), OR for
+ *    the countdown timer to expire (auto-switch to the chain head).
+ * 4. Resolves with the chosen model reference, or `null` for auto-switch.
+ *
+ * Registration happens BEFORE the emit so a same-tick choice reply from a
+ * synchronous EventBus listener (test harness, automated UI pick) is not
+ * dropped.
+ *
+ * An absolute deadline (autoSwitchSeconds * 1.5) ensures the gate never
+ * hangs indefinitely even if neither signal arrives (headless mode, no UI
+ * listener, etc.).
+ */
+import type { FallbackGateFn } from '@wrongstack/core/agent';
+import type { EventBus } from '@wrongstack/core/kernel';
+/**
+ * Create a fallback gate that emits `provider.fallback_pending` and waits
+ * for a `provider.fallback_choice` event or the countdown timer.
+ */
+export declare function createFallbackGate(_events: EventBus): FallbackGateFn;
+//# sourceMappingURL=fallback-gate.d.ts.map

package/dist/wiring/fleet-command-handlers.d.ts

@@ -3,7 +3,7 @@ import type { EventBus } from '@wrongstack/core/kernel';
 import type { MultiAgentHost } from '../multi-agent.js';
 import type { BuiltinSlashCommandDeps } from './slash-commands.js';
 type SlashCommandDeps = BuiltinSlashCommandDeps;
-export type FleetCommandHandlers = Pick<SlashCommandDeps, 'onSpawn' | 'onSpawnAndWait' | 'onAgents' | 'onFleet' | 'onFleetStatus' | 'onFleetUsage' | 'onFleetKill' | 'onFleetTerminate' | 'onFleetSpawn' | 'onFleetLog' | 'onFleetRetry' | 'onDirector'>;
+export type FleetCommandHandlers = Pick<SlashCommandDeps, 'onSpawn' | 'onSpawnAndWait' | 'onAgents' | 'onFleet' | 'onFleetStatus' | 'onFleetBudget' | 'onFleetUsage' | 'onFleetKill' | 'onFleetTerminate' | 'onFleetSpawn' | 'onFleetLog' | 'onFleetRetry' | 'onDirector'>;
 export interface FleetCommandHandlersInput {
     multiAgentHost: MultiAgentHost;
     getDirector: () => Director | null;

package/dist/wiring/mailbox-bridge-bootstrap.d.ts

@@ -33,7 +33,9 @@ export declare const MAILBOX_BRIDGE_META_KEY = "mailboxBridge";
  */
 export declare function bootstrapMailboxBridgeAtStartup(params: {
     projectRoot: string | undefined;
-    config: Pick<Config, 'features'> | undefined;
+    config: {
+        features: Pick<Config['features'], 'mailboxBridge'>;
+    } | undefined;
     logger: Logger;
     /** Surface label — logged for debugging when something goes wrong. */
     source: 'cli' | 'webui' | 'eternal';

package/dist/wiring/management-tools.d.ts

@@ -1,4 +1,5 @@
 import type { Config } from '@wrongstack/core/types';
+import { type PluginManagerHookRunner } from '@wrongstack/core/tools';
 import type { ToolRegistry } from '@wrongstack/core/registry';
 type ConfigStoreLike = {
     get(): Config;
@@ -9,7 +10,14 @@ export interface RegisterCliManagementToolsDeps {
     configStore: ConfigStoreLike;
     profileConfigPath: string;
     stdinInteractive: boolean;
+    /**
+     * Late-bound PreToolUse pipeline for plugin_manager's nested `use` path.
+     * The hook runner is created by `setupLifecycleAndPlugins` AFTER the
+     * management tools register, so cli-main passes a ref-backed getter that
+     * starts null and is filled once wiring completes.
+     */
+    getHookRunner?: (() => PluginManagerHookRunner | null) | undefined;
 }
-export declare function registerCliManagementTools({ toolRegistry, configStore, profileConfigPath, stdinInteractive, }: RegisterCliManagementToolsDeps): void;
+export declare function registerCliManagementTools({ toolRegistry, configStore, profileConfigPath, stdinInteractive, getHookRunner, }: RegisterCliManagementToolsDeps): void;
 export {};
 //# sourceMappingURL=management-tools.d.ts.map

package/dist/wiring/pipeline.d.ts

@@ -1,9 +1,9 @@
 import { Agent, type AgentPipelines, type Context } from '@wrongstack/core/agent';
 import { AutoCompactionMiddleware } from '@wrongstack/core/execution';
-import type { Config, Logger, ModelsRegistry, Provider } from '@wrongstack/core/types';
-import type { SessionEventBridge } from '@wrongstack/core/storage';
 import { type EventBus } from '@wrongstack/core/kernel';
 import type { ProviderRegistry, ToolRegistry } from '@wrongstack/core/registry';
+import type { SessionEventBridge } from '@wrongstack/core/storage';
+import type { Config, Logger, ModelsRegistry, Provider } from '@wrongstack/core/types';
 type CompactionDriver = ConstructorParameters<typeof AutoCompactionMiddleware>[0];
 export declare function setupPipelines(params: {
     events: EventBus;
@@ -90,9 +90,9 @@ export declare function createAgent(params: {
     /**
      * Full Config object, used for `features.mailboxBridge` gating and
      * forwarded to `bootstrapMailboxBridgeAtStartup`. Optional — when
-     * omitted, the bootstrap defaults to 'auto' (i.e. always run).
-     * Tests can pass a stub with just `{ features: { mailboxBridge: 'off' } }`
-     * to skip the bridge entirely without touching the host config.
+     * omitted, the bootstrap defaults to 'off' (i.e. never run), so tests
+     * and embedders get no detached bridge process unless they ask for one
+     * with `{ features: { mailboxBridge: 'auto' } }`.
      */
     fullConfig?: Pick<Config, 'features'> | undefined;
     /** Surface label for the bootstrap log breadcrumb. */

package/dist/wiring/plugins.d.ts

@@ -1,10 +1,9 @@
 import type { AgentPipelines } from '@wrongstack/core/agent';
-import type { Config, HealthRegistry, Logger, MetricsRuntimeStatus, MetricsSinkView, ModelsRegistry, Plugin, PromptLoader, SkillLoader } from '@wrongstack/core/types';
 import type { ExtensionRegistry } from '@wrongstack/core/extension';
-import type { PluginHostHandle } from '@wrongstack/core/plugin';
-import type { ConfigStore, SessionWriter } from '@wrongstack/core/types';
 import type { Container, EventBus } from '@wrongstack/core/kernel';
+import type { PluginAPIInit, PluginHostHandle } from '@wrongstack/core/plugin';
 import type { ProviderRegistry, SlashCommandRegistry, ToolRegistry } from '@wrongstack/core/registry';
+import type { Config, ConfigStore, HealthRegistry, Logger, MetricsRuntimeStatus, MetricsSinkView, ModelsRegistry, Plugin, PromptLoader, SessionWriter, SkillLoader } from '@wrongstack/core/types';
 import type { MCPRegistry } from '@wrongstack/mcp';
 export declare const DEPRECATED_PLUGIN_NAMES: Record<string, string>;
 export declare const BUILTIN_PLUGIN_CONFIG_NAMES: Set<string>;
@@ -71,13 +70,7 @@ export interface PluginsWiringDeps {
      * default model, and a factory for named-provider overrides. Optional —
      * minimal hosts omit it and plugins see `api.llm === undefined`.
      */
-    llm?: {
-        provider: import('@wrongstack/core/types').Provider;
-        model: string;
-        getProvider?: (() => import('@wrongstack/core/types').Provider) | undefined;
-        getModel?: (() => string) | undefined;
-        createProvider?: ((name: string, model?: string) => import('@wrongstack/core/types').Provider) | undefined;
-    } | undefined;
+    llm?: PluginAPIInit['llm'];
     /** Health registry — injected so the observability built-in can run /health. */
     healthRegistry?: HealthRegistry | undefined;
     /** Skill loader — injected so the skills built-in can list/read skills. */