@wrongstack/cli 1.0.19 → 1.0.26

package/data/providers.json

@@ -26,6 +26,50 @@
           "output": 128000
         }
       },
+      "gpt-6-sol": {
+        "id": "gpt-6-sol",
+        "name": "GPT-6 Sol",
+        "description": "Built to power complex coding and agentic workflows.",
+        "reasoning": true,
+        "reasoningConfig": {
+          "default": "enabled",
+          "disableSupported": false,
+          "effortSupported": true,
+          "effortLevels": ["low", "medium", "high", "xhigh", "max"],
+          "preserveThinking": "unsupported"
+        },
+        "tool_call": true,
+        "modalities": {
+          "input": ["text", "image"],
+          "output": ["text"]
+        },
+        "limit": {
+          "context": 872000,
+          "output": 128000
+        }
+      },
+      "gpt-6-luna": {
+        "id": "gpt-6-luna",
+        "name": "GPT-6 Luna",
+        "description": "Most efficient model for focused, high-volume tasks.",
+        "reasoning": true,
+        "reasoningConfig": {
+          "default": "enabled",
+          "disableSupported": false,
+          "effortSupported": true,
+          "effortLevels": ["low", "medium", "high", "xhigh", "max"],
+          "preserveThinking": "unsupported"
+        },
+        "tool_call": true,
+        "modalities": {
+          "input": ["text", "image"],
+          "output": ["text"]
+        },
+        "limit": {
+          "context": 872000,
+          "output": 128000
+        }
+      },
       "gpt-5.6-sol": {
         "id": "gpt-5.6-sol",
         "name": "GPT-5.6 Sol",

package/dist/{acp-INCNOH42.js → acp-LI665LO2.js}

@@ -4,17 +4,18 @@ import {
   loadCachedAcpRegistry,
   refreshAcpRegistry,
   setupProvider
-} from "./chunk-KEPABQYT.js";
+} from "./chunk-5SEYGOCH.js";
 import {
   createHqCommandDispatcher
-} from "./chunk-JY52HWL6.js";
+} from "./chunk-2EBVTYJR.js";
 import {
   startCliHqConnection
-} from "./chunk-CJTBLTS4.js";
-import "./chunk-XJXDOF63.js";
+} from "./chunk-KJS5543T.js";
+import "./chunk-S4FFHDJG.js";
+import "./chunk-F5DCFAKI.js";
 import "./chunk-SIGUWXAA.js";
+import "./chunk-LUMETJFO.js";
 import "./chunk-DAKVBMD4.js";
-import "./chunk-DR2OXU46.js";
 
 // src/subcommands/handlers/acp.ts
 import { randomBytes } from "node:crypto";
@@ -589,6 +590,11 @@ async function loadLive(deps) {
 }
 var acpCmd = async (args, deps) => {
   const sub = args[0];
+  const loginIndex = sub === "auth" ? 0 : (sub === "server" || sub === "serve") && args[1] === "auth" ? 1 : -1;
+  if (loginIndex >= 0) {
+    const { authCmd } = await import("./auth-TE55JF4Z.js");
+    return authCmd(args.slice(loginIndex + 1), deps);
+  }
   if (!sub || sub === "server" || sub === "serve") {
     return runACPServer(deps);
   }
@@ -803,6 +809,12 @@ async function runACPServer(deps) {
     return runACPWebSocketServer(deps, wsPort);
   }
   const echo = deps.flags?.echo === true || deps.flags?.echo === "true";
+  if (!echo && (!deps.config.provider || !deps.config.model)) {
+    deps.renderer.writeError(
+      "No model provider configured. Run `wstack auth` before starting ACP, or use `--echo` for a connectivity test.\n"
+    );
+    return 1;
+  }
   let stdioHqTelemetry;
   const server = new WrongStackACPServer(
     echo ? {} : (() => {
@@ -813,7 +825,6 @@ async function runACPServer(deps) {
         if (err instanceof AcpServerConfigError) {
           deps.renderer.writeError(`${err.message}
 `);
-          return {};
         }
         throw err;
       }
@@ -1168,4 +1179,4 @@ ${renderAcpBenchText(result)}
 export {
   acpCmd
 };
-//# sourceMappingURL=acp-INCNOH42.js.map
+//# sourceMappingURL=acp-LI665LO2.js.map

package/dist/arg-parser.d.ts

@@ -12,6 +12,7 @@ export interface ParsedArgs {
 export declare function parseArgs(argv: string[]): ParsedArgs;
 export interface AuthFlags {
     positional: string[];
+    alias?: string | undefined;
     label?: string | undefined;
     family?: import('@wrongstack/core/types').WireFamily | undefined;
     baseUrl?: string | undefined;

package/dist/ascii-mode-SG4PRNLP.js

@@ -0,0 +1,7 @@
+import {
+  applyAsciiMode
+} from "./chunk-PZQBGUVZ.js";
+export {
+  applyAsciiMode
+};
+//# sourceMappingURL=ascii-mode-SG4PRNLP.js.map

package/dist/{auth-YXK3EDUL.js → auth-TE55JF4Z.js}

@@ -16,24 +16,13 @@ import {
   runOAuthLoginKind,
   runOAuthLoginMenu,
   validateFamily
-} from "./chunk-RDHFXOJM.js";
+} from "./chunk-2ERX3RPN.js";
 import {
   renderAuthLocalHelpToString,
   wantsLocalHelp
-} from "./chunk-2VMJ3E5Z.js";
-import "./chunk-B4JLSXZB.js";
-import {
-  restoreFlags
-} from "./chunk-CSAPOCBP.js";
-import "./chunk-3VXYY5JC.js";
-import {
-  activeProfileConfigPath
-} from "./chunk-YMXXOOFN.js";
-import {
-  parseAuthFlags
-} from "./chunk-C3Z4N6A6.js";
+} from "./chunk-YTEOAWOJ.js";
+import "./chunk-5UZBUV2H.js";
 import "./chunk-SIGUWXAA.js";
-import "./chunk-DAKVBMD4.js";
 import {
   loadConfigProviders,
   maskedKey,
@@ -41,10 +30,22 @@ import {
   normalizeKeys,
   nowIso,
   writeKeysBack
-} from "./chunk-DR2OXU46.js";
+} from "./chunk-LUMETJFO.js";
+import "./chunk-DAKVBMD4.js";
+import {
+  activeProfileConfigPath
+} from "./chunk-YMXXOOFN.js";
+import {
+  restoreFlags
+} from "./chunk-CSAPOCBP.js";
+import "./chunk-WSTVGC2C.js";
+import {
+  parseAuthFlags
+} from "./chunk-Q4INH2DG.js";
 
 // src/subcommands/handlers/auth.ts
 import { color as color5 } from "@wrongstack/core/utils";
+import { authProfileAliasError as authProfileAliasError2 } from "@wrongstack/providers";
 
 // src/auth-menu/anthropic-oauth.ts
 import {
@@ -57,16 +58,31 @@ var REDIRECT_PATH = "/callback";
 var REDIRECT_URI = `http://localhost:${REDIRECT_PORT}${REDIRECT_PATH}`;
 
 // src/auth-menu/direct.ts
+import { authProfileAliasError } from "@wrongstack/providers";
 async function runAuthDirect(deps, opts) {
-  const { providerId } = opts;
+  const sourceId = opts.providerId;
+  const providerId = opts.alias?.trim() || sourceId;
+  const aliasError = authProfileAliasError(
+    opts.alias !== void 0 ? opts.alias.trim() : providerId
+  );
+  if (aliasError) {
+    deps.renderer.writeError(aliasError);
+    return 1;
+  }
   const providers = await loadProviders(deps);
   const existing = providers[providerId];
+  if (opts.alias && existing) {
+    deps.renderer.writeError(
+      `Auth profile "${providerId}" already exists. Choose another alias or manage its keys explicitly.`
+    );
+    return 1;
+  }
   if (!existing && !opts.family) {
     let knownFamily;
     let knownBase;
     let knownEnv;
     try {
-      const k = await deps.modelsRegistry.getProvider(providerId);
+      const k = await deps.modelsRegistry.getProvider(sourceId);
       if (k) {
         knownFamily = k.family;
         knownBase = k.apiBase;
@@ -98,8 +114,12 @@ async function runAuthDirect(deps, opts) {
     deps.profileConfigPath,
     deps.vault,
     (all) => {
-      const p = all[providerId] ?? { type: providerId };
-      if (!p.type) p.type = providerId;
+      if (opts.alias && all[providerId])
+        throw new Error(
+          `Auth profile "${providerId}" already exists. Choose another alias or manage its keys explicitly.`
+        );
+      const p = all[providerId] ?? { type: sourceId };
+      if (!p.type) p.type = sourceId;
       if (!p.family && opts.family) p.family = opts.family;
       if (!p.baseUrl && opts.baseUrl) p.baseUrl = opts.baseUrl;
       if (!p.envVars && opts.envVars) p.envVars = opts.envVars;
@@ -388,6 +408,7 @@ ${color4.amber("?")} Pick: `)).trim().toLowerCase();
 var authCmd = async (args, deps) => {
   args = restoreFlags(args, deps, [
     "label",
+    "alias",
     "family",
     "base-url",
     "env",
@@ -413,6 +434,29 @@ var authCmd = async (args, deps) => {
     vault: deps.vault,
     profileConfigPath
   };
+  if (flags.positional[0] !== "local" && (args.includes("--help") || args.includes("-h"))) {
+    deps.renderer.write(
+      [
+        "Usage: wstack auth",
+        "  wstack auth <provider-type> --alias <account>  Create a separately keyed auth profile",
+        "  wstack auth login <strategy> --alias <account>  Sign in to an auth profile",
+        "  wstack auth <saved-alias> --label <key-label>  Add a key inside an existing profile",
+        "  wstack auth list | status <alias> | remove <alias>",
+        "",
+        "Fallback targets are <auth-profile-alias>/<model-id>; provider type chooses the transport.",
+        "Direct flags: --alias, --label, --family, --base-url, --env",
+        ""
+      ].join("\n")
+    );
+    return 0;
+  }
+  if (flags.alias !== void 0) {
+    const invalid = authProfileAliasError2(flags.alias.trim());
+    if (invalid) {
+      deps.renderer.writeError(invalid);
+      return 1;
+    }
+  }
   if (flags.positional.length === 0) {
     return runTopMenu(menuDeps);
   }
@@ -434,6 +478,7 @@ var authCmd = async (args, deps) => {
     const modelIdx = args.indexOf("--model") >= 0 ? args.indexOf("--model") : args.indexOf("-m");
     return runAuthLocal(menuDeps, {
       name: flags.positional[1] ?? value("name"),
+      alias: flags.alias,
       baseUrl: flags.baseUrl ?? value("base-url"),
       label: flags.label,
       skipKey: has("no-key", "skip-key"),
@@ -465,9 +510,9 @@ var authCmd = async (args, deps) => {
   }
   if (first === "login") {
     const pid = (flags.positional[1] ?? "").toLowerCase();
-    if (!pid) return runOAuthLoginKind(menuDeps, "chatgpt");
+    if (!pid) return runOAuthLoginKind(menuDeps, "chatgpt", { providerId: flags.alias });
     const kind = resolveOAuthKind(pid, { allowNumeric: false, deps: menuDeps });
-    if (kind) return runOAuthLoginKind(menuDeps, kind);
+    if (kind) return runOAuthLoginKind(menuDeps, kind, { providerId: flags.alias });
     const available = providerAuthStrategiesFor(menuDeps);
     deps.renderer.writeError(`Unknown OAuth login strategy "${pid}".`);
     for (const strategy of available) {
@@ -482,6 +527,7 @@ var authCmd = async (args, deps) => {
   }
   return runAuthDirect(menuDeps, {
     providerId: first,
+    alias: flags.alias,
     label: flags.label,
     family: flags.family,
     baseUrl: flags.baseUrl,
@@ -625,4 +671,4 @@ async function runAuthRemove(deps, providerId) {
 export {
   authCmd
 };
-//# sourceMappingURL=auth-YXK3EDUL.js.map
+//# sourceMappingURL=auth-TE55JF4Z.js.map

package/dist/auth-menu/direct.d.ts

@@ -7,6 +7,7 @@ import type { AuthMenuDeps } from './types.js';
  */
 export declare function runAuthDirect(deps: AuthMenuDeps, opts: {
     providerId: string;
+    alias?: string | undefined;
     label?: string | undefined;
     family?: WireFamily | undefined;
     baseUrl?: string | undefined;

package/dist/auth-menu/local.d.ts

@@ -34,6 +34,8 @@ import { suggestLabel } from './shared.js';
 import type { AuthMenuDeps } from './types.js';
 export { LOCAL_LLM_PRESETS, type ProbeOptions, type ProbeResult, probeLocalLlm };
 export interface RunAuthLocalOptions {
+    /** Create a separately routed auth profile for this local provider preset. */
+    alias?: string | undefined;
     /**
      * Direct pick: skip the interactive menu and configure this preset.
      * `wstack auth local --name ollama` maps to `{ name: 'ollama' }`.

package/dist/auth-menu/oauth-menu.d.ts

@@ -17,7 +17,9 @@ export declare function runOAuthLoginChoice(deps: AuthMenuDeps, choice: string,
     allowNumeric?: boolean;
 }): Promise<boolean>;
 /** Run the OAuth login flow for an already-resolved kind. */
-export declare function runOAuthLoginKind(deps: AuthMenuDeps, kind: OAuthMenuKind): Promise<number>;
+export declare function runOAuthLoginKind(deps: AuthMenuDeps, kind: OAuthMenuKind, opts?: {
+    providerId?: string | undefined;
+}): Promise<number>;
 /** Sub-menu: pick a subscription to sign in with (OAuth). */
 export declare function runOAuthLoginMenu(deps: AuthMenuDeps): Promise<void>;
 //# sourceMappingURL=oauth-menu.d.ts.map

package/dist/auth-menu/panel-service.d.ts

@@ -1,3 +1,23 @@
+/**
+ * TUI auth-panel host — the structured, UI-agnostic surface behind the
+ * interactive `/auth` panel in the Ink TUI.
+ *
+ * Two kinds of operations:
+ *
+ *   - **Direct mutations** (set active key, delete key, remove provider):
+ *     plain async methods that mutate the config atomically and return an
+ *     error string or `null`.
+ *
+ *   - **Flows** (add key, add from catalog, add custom, add local, OAuth
+ *     sign-in, field edits): the existing battle-tested readline flows from
+ *     this package, driven through an {@link AuthFlowIo} bridge. The bridge
+ *     adapts `renderer.write*` → panel log lines (ANSI-stripped) and
+ *     `reader.readLine/readSecret` → the panel's modal prompt. A rejected
+ *     prompt (TUI Esc) aborts the flow before anything is saved.
+ *
+ * Secrets never cross into the TUI: key values are masked here, and the
+ * modal prompt sends the plaintext only INTO the flow (never back out).
+ */
 import type { ModelsRegistry, SecretScrubber, SecretVault } from '@wrongstack/core/types';
 import type { AuthPanelHost } from '@wrongstack/tui';
 import type { AuthMenuDeps } from './types.js';

package/dist/{bench-YBU6BVQP.js → bench-GTLPM22B.js}

@@ -1,6 +1,6 @@
 import {
   CLI_VERSION
-} from "./chunk-XJXDOF63.js";
+} from "./chunk-F5DCFAKI.js";
 
 // src/subcommands/handlers/bench.ts
 import * as fs from "node:fs/promises";
@@ -414,4 +414,4 @@ async function benchList(_args, deps) {
 export {
   benchCmd
 };
-//# sourceMappingURL=bench-YBU6BVQP.js.map
+//# sourceMappingURL=bench-GTLPM22B.js.map

package/dist/boot/append-system-prompt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Resolve `--append-system-prompt <text>` and `--append-system-prompt-file
+ * <path>` into the text appended to the host system prompt. Both may be given;
+ * the inline text comes first. Returns `undefined` when neither carries text.
+ *
+ * An unreadable file throws: silently dropping instructions the operator asked
+ * for would run the session under a prompt they did not intend.
+ */
+export declare function resolveAppendedSystemPrompt(flags: Readonly<Record<string, string | boolean>>, cwd: string): Promise<string | undefined>;
+//# sourceMappingURL=append-system-prompt.d.ts.map

package/dist/boot/ascii-mode.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `--ascii` (or `WRONGSTACK_TUI_ICON_STYLE=ascii`): plain-ASCII output for
+ * terminals and fonts without box drawing, emoji or Nerd Font glyphs.
+ *
+ * The flag sets the env var so the lazily loaded TUI (its glyph set and Ink
+ * wrapper read it at module load) and child `wstack` processes see the same
+ * choice. stdout/stderr are wrapped so the plain REPL, one-shot output and
+ * anything the TUI did not route through its `Text` wrapper come out ASCII too.
+ * Runs before any surface is loaded.
+ */
+export declare function applyAsciiMode(flags: Record<string, unknown>, env?: NodeJS.ProcessEnv, streams?: readonly NodeJS.WriteStream[]): boolean;
+//# sourceMappingURL=ascii-mode.d.ts.map

package/dist/boot/config-backup-recovery.d.ts

@@ -18,11 +18,12 @@ export declare function defaultProfileProvidersAreEmpty(profilePath: string): Pr
  * providers. Profile config history uses names such as
  * `profiles-default-config-2026-07-19T12-34-56-789.json`.
  */
-export declare function findLatestProviderBackup(globalRoot: string): Promise<ProviderConfigBackup | undefined>;
+export declare function findLatestProviderBackup(globalRoot: string, profileName?: string): Promise<ProviderConfigBackup | undefined>;
 /** Prompt once during an ordinary interactive boot. Enter accepts recovery. */
 export declare function maybeRestoreDefaultProfileFromBackup(opts: {
     globalRoot: string;
     profilePath: string;
+    profileName?: string | undefined;
     renderer: TerminalRenderer;
     reader: ReadlineInputReader;
 }): Promise<boolean>;

package/dist/boot/container-wiring.d.ts

@@ -3,16 +3,18 @@ import type { EventBus } from '@wrongstack/core/kernel';
 import type { Config, Logger, ModelsRegistry, Renderer } from '@wrongstack/core/types';
 import type { WstackPaths } from '@wrongstack/core/utils';
 import { createDefaultContainer } from '@wrongstack/runtime';
-import { makePromptDelegate } from '../permission-prompt.js';
+import { makeStdinPromptDelegate } from '../permission-prompt.js';
 import { type ApprovalMirrorRef } from '../permission-prompt-mirror.js';
 interface WireContainerDeps {
     config: Config;
     wpaths: WstackPaths;
     cwd: string;
     logger: Logger;
-    reader: Parameters<typeof makePromptDelegate>[0];
+    reader: Parameters<typeof makeStdinPromptDelegate>[0];
     renderer: Renderer;
     modelsRegistry: ModelsRegistry;
+    /** `--allowed-tools`, already validated at boot. */
+    launchAllowedTools?: readonly string[] | undefined;
 }
 /**
  * Build the PathResolver, create the EventBus, call

package/dist/boot/dispatch-singleshot.d.ts

@@ -12,6 +12,7 @@
  * closure mutation.
  */
 import type { Agent } from '@wrongstack/core/agent';
+import type { EventBus } from '@wrongstack/core/kernel';
 import type { TokenCounter } from '@wrongstack/core/types';
 import type { TerminalRenderer } from '../renderer.js';
 interface SingleShotDispatchContext {
@@ -19,12 +20,14 @@ interface SingleShotDispatchContext {
     agent: Agent;
     /** Joined positional args forming the query string. */
     query: string;
-    /** Parsed top-level CLI flags (e.g. `--output-json`). */
+    /** Parsed top-level CLI flags (e.g. `--output-json`, `--output-format`). */
     flags: Record<string, string | boolean>;
     /** Token counter for usage delta computation. */
     tokenCounter: TokenCounter;
     /** Terminal renderer for output. */
     renderer: TerminalRenderer;
+    /** Host event bus; required for `--max-budget-usd` to see spend as it lands. */
+    events?: Pick<EventBus, 'on'> | undefined;
 }
 /**
  * Run a single `agent.run()` turn and render the result.

package/dist/boot/dispatch-webui.d.ts

@@ -88,6 +88,17 @@ export interface WebUIDispatchContext {
         role?: string | undefined;
         skills?: string[] | undefined;
         tools?: string[] | undefined;
+        signal?: AbortSignal | undefined;
+        context?: {
+            sessionId?: string;
+            kanban?: {
+                boardId?: string;
+                taskId?: string;
+                projectRoot?: string;
+                leaseId?: string;
+                managementToken?: string;
+            };
+        } | undefined;
         name?: string | undefined;
         allowedCapabilities?: readonly string[] | undefined;
         onDone?: ((result: {

package/dist/boot/mcp-config-flag.d.ts

@@ -0,0 +1,22 @@
+import type { MCPServerConfig } from '@wrongstack/core/types';
+export type LaunchMcpServers = Record<string, Partial<MCPServerConfig>>;
+/**
+ * Normalize one server entry (Claude Code `type` or WrongStack `transport`
+ * form). Throws with the server name on anything unusable. The result carries
+ * no `enabled` decision — callers own that.
+ */
+export declare function normalizeMcpServerEntry(name: string, raw: unknown): Partial<MCPServerConfig>;
+/** Parse a document already read from disk or given inline. */
+export declare function parseLaunchMcpServers(text: string, source: string): LaunchMcpServers;
+/**
+ * Resolve the flag: inline JSON when the value starts with `{`, otherwise a
+ * path relative to `cwd`. `undefined` when the flag is absent.
+ */
+export declare function resolveLaunchMcpServers(flags: Readonly<Record<string, string | boolean>>, cwd: string): Promise<LaunchMcpServers | undefined>;
+/**
+ * The server set this process starts: config servers (unless strict) with the
+ * launch servers layered on top — a launch entry replaces a config entry of the
+ * same name rather than merging into it.
+ */
+export declare function effectiveMcpServers(configured: Readonly<Record<string, Partial<MCPServerConfig>>> | undefined, launch: LaunchMcpServers | undefined, strict: boolean): Record<string, Partial<MCPServerConfig>>;
+//# sourceMappingURL=mcp-config-flag.d.ts.map

package/dist/boot/piped-stdin.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Piped-stdin context for single-shot runs: `git diff | wstack "review this"`.
+ *
+ * The prompt still comes from argv; whatever was piped in is appended to it as
+ * context. Only single-shot mode reads it — the REPL and TUI own stdin.
+ *
+ * A parent process can hand us an open pipe it never writes to (a harness
+ * spawning `wstack` with default stdio), which would block forever waiting for
+ * EOF. So the read gives up if no first byte arrives within
+ * `firstByteTimeoutMs`; once data starts flowing it reads to EOF, capped at
+ * `maxBytes` so a runaway producer cannot blow the context window.
+ */
+import type { Readable } from 'node:stream';
+/** `process.stdin` in production; any readable in tests. */
+export type PipedStdinSource = Readable & {
+    readonly isTTY?: boolean | undefined;
+    unref?: (() => unknown) | undefined;
+};
+export interface PipedStdinResult {
+    /** Piped text, trimmed of trailing whitespace. Empty when nothing arrived. */
+    text: string;
+    /** True when the input exceeded `maxBytes` and was cut. */
+    truncated: boolean;
+    /** True when no first byte arrived in time and the read was abandoned. */
+    timedOut: boolean;
+}
+export interface ReadPipedStdinOptions {
+    firstByteTimeoutMs?: number | undefined;
+    maxBytes?: number | undefined;
+}
+export declare const PIPED_STDIN_FIRST_BYTE_TIMEOUT_MS = 3000;
+export declare const PIPED_STDIN_MAX_BYTES: number;
+/**
+ * Read piped stdin. Resolves `EMPTY` immediately for a TTY — an interactive
+ * terminal is never "piped input".
+ */
+export declare function readPipedStdin(source: PipedStdinSource, opts?: ReadPipedStdinOptions): Promise<PipedStdinResult>;
+/** Join the argv prompt with piped context. The prompt stays first: it is the instruction. */
+export declare function appendPipedStdin(query: string, piped: string): string;
+//# sourceMappingURL=piped-stdin.d.ts.map

package/dist/boot/restricted-mode.d.ts

@@ -0,0 +1,15 @@
+import type { ToolRestriction } from './tool-restriction-flags.js';
+export declare const RESTRICTED_ENV = "WRONGSTACK_RESTRICTED";
+export declare const RESTRICTED_DENY_CAPABILITIES: readonly string[];
+export declare function isRestrictedMode(flags: Readonly<Record<string, unknown>>): boolean;
+/** Throws on a conflicting flag. Returns whether restricted mode is on. */
+export declare function validateRestrictedMode(flags: Readonly<Record<string, unknown>>): boolean;
+/** Fold `--restricted` into the launch tool restriction (if any). */
+export declare function withRestrictedTools(restriction: ToolRestriction | undefined, restricted: boolean): ToolRestriction | undefined;
+export declare const RESTRICTED_NOTICE = "Restricted mode: no shell, network, installs or MCP tools; files stay inside the project; YOLO is off.";
+/**
+ * Validate, engage the process-wide locks, export the env switch and — once
+ * per process — tell the user. Throws on a conflicting flag.
+ */
+export declare function activateRestrictedMode(flags: Readonly<Record<string, unknown>>, write: (line: string) => void): boolean;
+//# sourceMappingURL=restricted-mode.d.ts.map

package/dist/boot/safe-mode.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `--safe-mode`: start with the user's and the project's customizations off,
+ * to tell a broken setup apart from a broken WrongStack.
+ *
+ * Off: third-party plugins, hooks (policy hooks stay, as with `--no-hooks` —
+ * they are enforcement, not customization), configured MCP servers, skills,
+ * and instruction override files (`instructions/` under the profile and the
+ * project). Unchanged: config itself, auth, model selection, permissions,
+ * built-in tools and built-in plugins. Servers named with `--mcp-config` still
+ * start: the flag is an explicit request for them.
+ *
+ * Every decision is read at its consumption point instead of being patched
+ * into config: a patched config can be saved back by any settings write, and
+ * one troubleshooting launch would then silently disable plugins for good.
+ *
+ * `WRONGSTACK_SAFE_MODE=1` is equivalent and is exported to child processes
+ * (WebUI session children, spawned tools) so they start the same way.
+ */
+export declare const SAFE_MODE_ENV = "WRONGSTACK_SAFE_MODE";
+export declare function isSafeMode(flags: Readonly<Record<string, unknown>>): boolean;
+/** Called once at boot: makes `--safe-mode` visible to child processes. */
+export declare function propagateSafeMode(flags: Readonly<Record<string, unknown>>): boolean;
+export declare const SAFE_MODE_NOTICE = "Safe mode: third-party plugins, hooks, configured MCP servers, skills and instruction overrides are off.";
+/**
+ * Propagate and, once per process, tell the user. Without the guard a real
+ * `--safe-mode` launch printed the notice twice, which reads like a second
+ * mode switch.
+ */
+export declare function announceSafeMode(flags: Readonly<Record<string, unknown>>, write: (line: string) => void): boolean;
+//# sourceMappingURL=safe-mode.d.ts.map

package/dist/boot/short-circuit-desktop.d.ts

@@ -1,3 +1,4 @@
+export declare function desktopExecutableCandidates(platform: string, home: string, env: NodeJS.ProcessEnv): string[];
 export declare function stripDesktopLauncherArgs(argv: string[]): string[];
 export declare function selectDesktopLauncherExecutable(execPath: string, runningUnderBun: boolean, nodeOverride?: string): string;
 export declare function handleDesktopShortCircuit(flags: Record<string, string | boolean>, argv: string[]): Promise<number | null>;

package/dist/boot/single-shot-budget.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `--max-budget-usd` for single-shot runs.
+ *
+ * Spend is the leader's cost delta since the run started plus every subagent's
+ * cumulative cost. Subagents run on their own token counters, so the leader's
+ * counter alone would let a delegating run blow straight past the cap.
+ *
+ * The check fires after each accounted request; the request that crosses the
+ * line has already been paid for, so the cap bounds the overshoot to one
+ * request rather than preventing it.
+ */
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { TokenCounter } from '@wrongstack/core/types';
+/** Parse the flag. `undefined` = not set; throws on a value that is set but unusable. */
+export declare function parseMaxBudgetUsd(value: string | boolean | undefined): number | undefined;
+export interface SingleShotBudget {
+    /** Spend so far, in USD. */
+    spent(): number;
+    /** True once the limit was crossed and `onExceeded` fired. */
+    readonly exceeded: boolean;
+    /** Detach the event listeners. */
+    dispose(): void;
+}
+export declare function watchSingleShotBudget(opts: {
+    limitUsd: number;
+    tokenCounter: Pick<TokenCounter, 'estimateCost'>;
+    events: Pick<EventBus, 'on'>;
+    onExceeded: () => void;
+}): SingleShotBudget;
+//# sourceMappingURL=single-shot-budget.d.ts.map