@wrongstack/cli 1.0.33 → 1.0.35

package/dist/settings-behavior-sections.d.ts

@@ -12,7 +12,6 @@
  * therefore structurally free of credentials and model-routing data.
  */
 export declare const BEHAVIOR_SECTION_KEYS: readonly ['context', 'tools', 'log', 'features', 'session', 'indexing', 'circuitBreaker', 'modelRuntime', 'Sage', 'skills', 'systemPrompt', 'autonomy', 'maxConcurrent', 'yolo', 'nextPrediction', 'hints', 'debugStream'];
-export type BehaviorSectionKey = (typeof BEHAVIOR_SECTION_KEYS)[number];
 /** Deep-copy the behavior sections out of a loaded config. */
 export declare function extractBehaviorSettings(config: Record<string, unknown>): Record<string, unknown>;
 /** Merge behavior sections from a portable export over an existing config object. */

package/dist/short-circuit-flags-EXJBJ5GT.js

@@ -0,0 +1,10 @@
+import {
+  handleHelpVersionShortCircuit
+} from "./chunk-LDV4ERNV.js";
+import "./chunk-CJSHS2K7.js";
+import "./chunk-AKESWZH5.js";
+import "./chunk-F5DCFAKI.js";
+export {
+  handleHelpVersionShortCircuit
+};
+//# sourceMappingURL=short-circuit-flags-EXJBJ5GT.js.map

package/dist/{skill-suggest-L2EVWB6R.js → skill-suggest-THANK3LV.js}

@@ -287,4 +287,4 @@ function truncate(text, max) {
 export {
   skillSuggestCmd
 };
-//# sourceMappingURL=skill-suggest-L2EVWB6R.js.map
+//# sourceMappingURL=skill-suggest-THANK3LV.js.map

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

@@ -263,6 +263,8 @@ export interface SlashCommandContext {
     onContextLimit?: ((tokens?: number) => number) | undefined;
     /** Toggle or query YOLO mode at runtime. Pass undefined to query, boolean to set. */
     onYolo?: ((setTo?: boolean) => boolean) | undefined;
+    /** Read or set YOLO+ (nothing ever asks). On implies YOLO. */
+    onYoloPlus?: ((setTo?: boolean) => boolean) | undefined;
     /**
      * Read, or set, which kinds of damage still prompt while YOLO is on.
      *

package/dist/slash-commands/fallback-chain-view.d.ts

@@ -0,0 +1,3 @@
+import type { SlashCommandContext } from './command-context.js';
+export declare function renderFallbackView(opts: SlashCommandContext): string;
+//# sourceMappingURL=fallback-chain-view.d.ts.map

package/dist/slash-commands/fallback-ref-validation.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Reason a ref may NOT be stored in a chain or profile, or undefined when it
+ * is acceptable. Only hard, user-owned rules live here:
+ *
+ *  1. It parses to a non-empty model.
+ *  2. It is in `favoriteModels` (skipped when favorites are empty — legacy
+ *     behavior: no favorites ⇒ no enforcement). This is an explicit policy
+ *     the user turned on, so it stays blocking.
+ *
+ * The `providers[].models` allow-list is deliberately NOT blocking: it is an
+ * unrefreshed snapshot that re-auth and manual edits rewrite, so a stale entry
+ * would refuse a model the provider actually serves. It is surfaced as a
+ * warning instead (see {@link refStaleModelListWarning}).
+ */
+export declare function refInvalidReason(ref: string, config: {
+    provider: string;
+    providers?: Record<string, {
+        models?: string[] | undefined;
+    }> | undefined;
+    favoriteModels?: string[] | undefined;
+}): string | undefined;
+/**
+ * Advisory note when a ref names a model the provider's saved `models` list
+ * does not contain. The runtime still tries the entry (the list drifts), so
+ * this is a "check this" hint, never a drop — the previous wording claimed the
+ * entry was "inactive", which was true then and would be misleading now.
+ */
+export declare function refStaleModelListWarning(ref: string, config: {
+    provider: string;
+    providers?: Record<string, {
+        models?: string[] | undefined;
+    }> | undefined;
+}): string | undefined;
+//# sourceMappingURL=fallback-ref-validation.d.ts.map

package/dist/slash-commands/goal-refiner.d.ts

@@ -1,6 +1,6 @@
 import type { OneShotOrchestrator } from '@wrongstack/core/execution';
 import { type RefinedMission } from '@wrongstack/core/goal';
-import type { Provider } from '@wrongstack/core/types';
+import type { Provider, Usage } from '@wrongstack/core/types';
 export { refineGoalHeuristic, resolveRefinerTarget } from '@wrongstack/core/goal';
 /**
  * Result of refining a user's raw goal into a clear, actionable mission.
@@ -27,6 +27,11 @@ interface GoalRefinerOptions {
      * chain support and cheap-model defaulting.
      */
     oneShotOrchestrator?: OneShotOrchestrator | undefined;
+    /** Token-usage hook: fired by the serving tier with the reported usage. */
+    onUsage?: ((usage: Usage, source: {
+        providerId: string;
+        model: string;
+    }) => void) | undefined;
 }
 /**
  * Refine a raw goal using the best available model/provider, with a
@@ -45,5 +50,8 @@ export declare function refineGoalWithFallback(rawGoal: string, opts: GoalRefine
  * with unambiguous deliverables. Returns null if no LLM is available
  * or the call fails.
  */
-export declare function refineGoal(rawGoal: string, provider: Provider, model: string, oneShotOrchestrator?: OneShotOrchestrator | undefined): Promise<RefinedGoal | null>;
+export declare function refineGoal(rawGoal: string, provider: Provider, model: string, oneShotOrchestrator?: OneShotOrchestrator | undefined, onUsage?: ((usage: Usage, source: {
+    providerId: string;
+    model: string;
+}) => void) | undefined): Promise<RefinedGoal | null>;
 //# sourceMappingURL=goal-refiner.d.ts.map

package/dist/slash-commands/goals.d.ts

@@ -0,0 +1,6 @@
+import { type GoalSummary } from '@wrongstack/core/goal';
+import type { SlashCommand } from '@wrongstack/core/types';
+import type { SlashCommandContext } from './command-context.js';
+export declare function formatGoalSummary(goal: GoalSummary): string;
+export declare function buildGoalsCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=goals.d.ts.map

package/dist/slash-commands/kanban-task-completion.d.ts

@@ -0,0 +1,17 @@
+interface CompleteKanbanTaskInput {
+    sub: string;
+    rest: string[];
+    board: import('@wrongstack/kanban').KanbanBoard;
+    eventContext: import('@wrongstack/kanban').KanbanEventContext;
+    projectRoot: string;
+    boardId: string;
+    syncTaskToContext: (opts: import('./command-context.js').SlashCommandContext, task: import('@wrongstack/kanban').KanbanTask | undefined, options?: {
+        remove?: boolean;
+    }) => Promise<void>;
+    opts: import('./command-context.js').SlashCommandContext;
+}
+export declare function completeKanbanTask({ sub, rest, board, eventContext, projectRoot, boardId, syncTaskToContext, opts, }: CompleteKanbanTaskInput): Promise<{
+    message: string;
+} | undefined>;
+export {};
+//# sourceMappingURL=kanban-task-completion.d.ts.map

package/dist/slash-commands/mcp.d.ts

@@ -1,6 +1,5 @@
 import type { SlashCommand } from '@wrongstack/core/types';
 import type { SlashCommandContext } from './command-context.js';
-export type { McpParsedArgs } from '../services/mcp-management.js';
 export { parseMcpArgs, runMcpManagementCommand } from '../services/mcp-management.js';
 /**
  * /mcp slash command — manage MCP servers from the REPL.

package/dist/slash-commands/memory-purge-domain-terms.d.ts

@@ -0,0 +1,5 @@
+import type { getSageSurface } from '@wrongstack/sage';
+export declare function runPurgeDomainTerms(Sage: ReturnType<typeof getSageSurface>, rest: readonly string[]): Promise<{
+    message: string;
+}>;
+//# sourceMappingURL=memory-purge-domain-terms.d.ts.map

package/dist/slash-commands/nextsteps-mode.d.ts

@@ -0,0 +1,13 @@
+import type { SlashCommand } from '@wrongstack/core/types';
+import type { SlashCommandContext } from './command-context.js';
+/** Offered limits for consecutive automatic turns; 0 = unlimited. */
+export declare const NEXT_STEPS_LIMIT_PRESETS: readonly [5, 10, 20, 50, 100, 0];
+/** Parse a limit argument: a preset, any non-negative integer, or "unlimited". */
+export declare function parseNextStepsLimit(raw: string): number | undefined;
+/**
+ * `/nextsteps` — whether the leader must end every finished turn with
+ * suggestions (`autonomy.nextSteps`), and how many consecutive automatic turns
+ * `auto` autonomy may run on them (`autonomy.autoProceedMaxIterations`).
+ */
+export declare function buildNextStepsModeCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=nextsteps-mode.d.ts.map

package/dist/slash-commands/session-live-status.d.ts

@@ -0,0 +1,21 @@
+export declare function formatBytes(value: number | undefined): string;
+export declare function isSafeSessionKillPid(pid: number): boolean;
+/**
+ * Build a compact one-line-per-event summary of a recovery plan's
+ * pending events. Stops early once we've shown enough to be useful
+ * (cap = 12 lines) — the recovery is informational, not a re-execution.
+ */
+export declare function summarizePending(events: import('@wrongstack/core/types').SessionEvent[]): string[];
+export declare function listLiveSessions(): Promise<{
+    message: string;
+}>;
+export declare function sessionStatusDetail(sessionId: string): Promise<{
+    message: string;
+}>;
+export declare function listLiveAgents(): Promise<{
+    message: string;
+}>;
+export declare function killSession(sessionId: string, confirm?: (question: string, defaultYes?: boolean) => Promise<boolean | null>): Promise<{
+    message: string;
+}>;
+//# sourceMappingURL=session-live-status.d.ts.map

package/dist/slash-commands/session.d.ts

@@ -1,6 +1,6 @@
 import type { SlashCommand } from '@wrongstack/core/types';
 import type { SlashCommandContext } from './command-context.js';
-export declare function isSafeSessionKillPid(pid: number): boolean;
+export { isSafeSessionKillPid } from './session-live-status.js';
 export declare function buildSaveCommand(_opts: SlashCommandContext): SlashCommand;
 export declare function buildLoadCommand(opts: SlashCommandContext): SlashCommand;
 export declare function buildExitCommand(opts: SlashCommandContext): SlashCommand;

package/dist/slash-commands/settings-feature-ui-mutations.d.ts

@@ -0,0 +1,8 @@
+/** `/settings` mutations for feature flags, fleet chat, loop limits, logging and TUI presentation. */
+import type { SlashCommandContext } from './command-context.js';
+import type { SettingsPersistDeps } from './settings-persist-deps.js';
+/** Feature flag, fleet, iteration, logging and presentation keys. Returns undefined for a key it does not own. */
+export declare function executeFeatureAndUiSettings(sub: string, rest: string[], persistDeps: SettingsPersistDeps, opts: SlashCommandContext, _activeProfile: string): Promise<{
+    message: string;
+} | undefined>;
+//# sourceMappingURL=settings-feature-ui-mutations.d.ts.map

package/dist/slash-commands/settings-hq-autonomy-mutations.d.ts

@@ -0,0 +1,8 @@
+/** `/settings` mutations for HQ, autonomy pacing, config scope, filesystem access and the prompt refiner. */
+import type { SlashCommandContext } from './command-context.js';
+import type { SettingsPersistDeps } from './settings-persist-deps.js';
+/** HQ, autonomy, scope, filesystem-access and refiner keys. Returns undefined for a key it does not own. */
+export declare function executeHqAndAutonomySettings(sub: string, rest: string[], persistDeps: SettingsPersistDeps, opts: SlashCommandContext, activeProfile: string): Promise<{
+    message: string;
+} | undefined>;
+//# sourceMappingURL=settings-hq-autonomy-mutations.d.ts.map

package/dist/slash-commands/settings-persist-deps.d.ts

@@ -0,0 +1,10 @@
+/** Persistence target shared by every `/settings` mutation group. */
+import type { SlashCommandContext } from './command-context.js';
+export declare function buildSettingsPersistDeps(opts: SlashCommandContext, activeProfile: string): {
+    configStore: import("@wrongstack/core/types").ConfigStore;
+    profileConfigPath: string;
+    inProjectConfigPath: string;
+    vault: import("@wrongstack/core/types").SecretVault;
+};
+export type SettingsPersistDeps = ReturnType<typeof buildSettingsPersistDeps>;
+//# sourceMappingURL=settings-persist-deps.d.ts.map

package/dist/slash-commands/settings-runtime-mutations.d.ts

@@ -0,0 +1,12 @@
+/** `/settings` mutations for versioning, the shell circuit breaker and model-runtime behaviour. */
+import type { SlashCommandContext } from './command-context.js';
+import type { SettingsPersistDeps } from './settings-persist-deps.js';
+/** semver-part and circuit-breaker keys. Returns undefined for a key it does not own. */
+export declare function executeBreakerSettings(sub: string, rest: string[], persistDeps: SettingsPersistDeps, _opts: SlashCommandContext, _activeProfile: string): Promise<{
+    message: string;
+} | undefined>;
+/** Title animation, reasoning, cache TTL and stream-watchdog keys. Returns undefined for a key it does not own. */
+export declare function executeModelRuntimeSettings(sub: string, rest: string[], persistDeps: SettingsPersistDeps, _opts: SlashCommandContext, _activeProfile: string): Promise<{
+    message: string;
+} | undefined>;
+//# sourceMappingURL=settings-runtime-mutations.d.ts.map

package/dist/slash-commands/shadow.d.ts

@@ -13,5 +13,4 @@ import type { SlashCommandContext } from './command-context.js';
  * - Can intervene via "hoop" command to stop agents and send notifications
  */
 export declare function buildShadowCommand(opts: SlashCommandContext): SlashCommand;
-export declare const shadowCommand: typeof buildShadowCommand;
 //# sourceMappingURL=shadow.d.ts.map

package/dist/slash-commands/tool-auto-thin-commands.d.ts

@@ -0,0 +1,15 @@
+import type { DisabledToolMeta } from '@wrongstack/core/types';
+interface CreateToolAutoThinCommandsInput {
+    getCurrentTools: () => import('@wrongstack/core/types').ToolsConfig;
+    opts: import('./command-context.js').SlashCommandContext;
+}
+export declare function createToolAutoThinCommands({ getCurrentTools, opts, }: CreateToolAutoThinCommandsInput): {
+    persistDisabledWithMeta: (names: string[], metaDelta: Record<string, DisabledToolMeta>) => Promise<void>;
+    cmdAutoThinStatus: () => Promise<string>;
+    cmdAutoThinCandidates: () => Promise<string>;
+    cmdAutoThinApply: () => Promise<string>;
+    cmdAutoThinUndo: () => Promise<string>;
+    cmdAutoThinConfig: (rest: string) => Promise<string>;
+};
+export {};
+//# sourceMappingURL=tool-auto-thin-commands.d.ts.map

package/dist/subcommands/handlers/acp-agents.d.ts

@@ -0,0 +1,9 @@
+/** `wstack acp list|sync|spawn|parallel|probe|bench` — driving other ACP agents. */
+import type { SubcommandDeps } from '../contracts.js';
+export declare function listACPAgents(deps: SubcommandDeps): Promise<number>;
+export declare function syncACPRegistry(deps: SubcommandDeps): Promise<number>;
+export declare function spawnACPAgent(args: string[], deps: SubcommandDeps): Promise<number>;
+export declare function parallelACPAgents(args: string[], deps: SubcommandDeps): Promise<number>;
+export declare function probeACPAgents(args: string[], deps: SubcommandDeps): Promise<number>;
+export declare function benchACPAgents(args: string[], deps: SubcommandDeps): Promise<number>;
+//# sourceMappingURL=acp-agents.d.ts.map

package/dist/subcommands/handlers/acp-server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `wstack acp` server mode: WrongStack as an ACP agent over stdio JSON-RPC or,
+ * with `--ws[=port]`, over a loopback WebSocket.
+ */
+import type { SubcommandDeps } from '../contracts.js';
+export declare function runACPServer(deps: SubcommandDeps): Promise<number>;
+//# sourceMappingURL=acp-server.d.ts.map

package/dist/subcommands/handlers/hq.d.ts

@@ -20,6 +20,5 @@
  * @module subcommands/handlers/hq
  */
 import type { SubcommandHandler } from '../contracts.js';
-export { resolveAuditActor } from '../../hq-server/audit-actor.js';
 export declare const hqCmd: SubcommandHandler;
 //# sourceMappingURL=hq.d.ts.map

package/dist/subcommands/handlers/providers-models-custom.d.ts

@@ -0,0 +1,33 @@
+import { type CustomModelDefinition, type ProviderConfig } from '@wrongstack/core/types';
+import type { SubcommandHandler } from '../contracts.js';
+/** Parse `--key value` flags from a flat args array. */
+export declare function parseFlags(args: string[]): Record<string, string | boolean>;
+/** Filter out flag args and return only positional (non-flag) args. */
+export declare function positionals(args: string[]): string[];
+export declare function fmtPrice(usdPer1M: number | undefined): string;
+export declare function modelsResetCustomModel(providerId: string, modelId: string, saved: ProviderConfig, deps: Parameters<SubcommandHandler>[1]): Promise<number>;
+export declare function modelsReset(args: string[], deps: Parameters<SubcommandHandler>[1]): Promise<number>;
+export declare function modelsCaps(args: string[], deps: Parameters<SubcommandHandler>[1]): Promise<number>;
+/**
+ * Load → mutate → encrypt → atomic-write for the `models` section.
+ */
+export declare function mutateModelsConfig(deps: Parameters<SubcommandHandler>[1], mutator: (models: Record<string, CustomModelDefinition>) => void): Promise<void>;
+/** Parse a human-readable size like "128k", "1M", "200000" into a number. */
+export declare function parseSizeFlag(raw: string | undefined): number | undefined;
+/**
+ * Flags visible to this subcommand.
+ *
+ * `parseArgs` pulls every `--flag` out of argv and hands the handler only the
+ * positional remainder, so a handler parsing just its own `args` sees none of
+ * them — `models <provider> --search x` and `models add <id> --tools` both lost
+ * theirs silently. `deps.flags` is what that top-level parse captured. The
+ * local parse still wins, so a directly-invoked handler (and anything after
+ * `--`) keeps overriding it.
+ */
+export declare function subcommandFlags(args: string[], deps: Parameters<SubcommandHandler>[1]): Record<string, string | boolean>;
+/** Parse a boolean flag like "--tools" / "--no-tools". */
+export declare function parseBoolFlag(flags: Record<string, string | boolean>, key: string): boolean | undefined;
+export declare function modelsAdd(args: string[], deps: Parameters<SubcommandHandler>[1]): Promise<number>;
+export declare function modelsRemove(args: string[], deps: Parameters<SubcommandHandler>[1]): Promise<number>;
+export declare function modelsList(_args: string[], deps: Parameters<SubcommandHandler>[1]): Promise<number>;
+//# sourceMappingURL=providers-models-custom.d.ts.map

package/dist/subcommands/handlers/providers-models-visibility.d.ts

@@ -0,0 +1,29 @@
+import type { ProviderConfig } from '@wrongstack/core/types';
+import type { SubcommandHandler } from '../contracts.js';
+export declare function aliasProviderId(configProviderId: string, cfg: ProviderConfig | undefined): string;
+/**
+ * One-shot `/v1/models` auto-discovery, merged into the registry overlay.
+ *
+ * The REPL learns a gateway's models because boot runs this; subcommands have
+ * no boot, so without it `wstack models ai-gateway` reported "not in catalog"
+ * for a provider serving 200+ models. Best-effort and silent, exactly as at
+ * boot — a down server must not turn a listing into a hard error.
+ */
+export declare function discoverProviderModels(deps: Parameters<SubcommandHandler>[1], ids: string[], onlyProviderId?: string | undefined): Promise<Awaited<ReturnType<typeof deps.modelsRegistry.getProvider>>>;
+export declare function getCatalogProviderForConfigProvider(providerId: string, deps: Parameters<SubcommandHandler>[1]): Promise<{
+    providerId: string;
+    provider: Awaited<ReturnType<typeof deps.modelsRegistry.getProvider>>;
+}>;
+export declare function usesAccountCatalog(cfg: ProviderConfig | undefined): boolean;
+export declare function uniqueStrings(values: string[]): string[];
+export declare function modelsHide(args: string[], deps: Parameters<SubcommandHandler>[1]): Promise<number>;
+export declare function modelsShow(args: string[], deps: Parameters<SubcommandHandler>[1]): Promise<number>;
+export declare function modelsHidden(args: string[], deps: Parameters<SubcommandHandler>[1]): Promise<number>;
+/**
+ * Reflect a provider change in this process's config. The loaded config is
+ * frozen (`ConfigLoader.load`), so assigning into it threw AFTER the change had
+ * already been written to disk: the command printed a stack trace and exited
+ * non-zero on success. Replace the object instead of mutating it.
+ */
+export declare function publishProviderConfig(deps: Parameters<SubcommandHandler>[1], providerId: string, next: ProviderConfig): void;
+//# sourceMappingURL=providers-models-visibility.d.ts.map

package/dist/subcommands/handlers/skill-suggest.d.ts

@@ -14,8 +14,6 @@
  * request text to TypeSafe, so `--eval` prints what it is about to spend before
  * it spends it.
  */
-import { type LabeledRequest, type ScoredCase } from '@wrongstack/core/skills';
 import type { SubcommandHandler } from '../contracts.js';
 export declare const skillSuggestCmd: SubcommandHandler;
-export type { LabeledRequest, ScoredCase };
 //# sourceMappingURL=skill-suggest.d.ts.map

package/dist/{subcommands-CLI6QTLU.js → subcommands-DTKBXLPU.js}

@@ -1,9 +1,9 @@
 import {
   subcommandNames,
   subcommands
-} from "./chunk-24C6VVLM.js";
+} from "./chunk-LDXXMPMS.js";
 export {
   subcommandNames,
   subcommands
 };
-//# sourceMappingURL=subcommands-CLI6QTLU.js.map
+//# sourceMappingURL=subcommands-DTKBXLPU.js.map

package/dist/{update-J5WHAFPE.js → update-6OEPAEUV.js}

@@ -3,8 +3,8 @@ import {
   detectUpdatePackageName,
   runUpdateCommand,
   updateCmd
-} from "./chunk-PGNERAZL.js";
-import "./chunk-U3SS4NRH.js";
+} from "./chunk-RWNI5OWT.js";
+import "./chunk-BHXAKTBE.js";
 import "./chunk-DIOODAYM.js";
 import "./chunk-F5DCFAKI.js";
 export {
@@ -13,4 +13,4 @@ export {
   runUpdateCommand,
   updateCmd
 };
-//# sourceMappingURL=update-J5WHAFPE.js.map
+//# sourceMappingURL=update-6OEPAEUV.js.map

package/dist/utils/win32-cmd.d.ts

@@ -6,5 +6,5 @@
  * left metacharacter-bearing arguments unquoted under `shell: true`. Keeping one
  * implementation in core removes the divergence risk (WS-004 / CMDI-005).
  */
-export { buildWin32CmdShimInvocation, type Win32CmdShimInvocation, } from '@wrongstack/core/utils';
+export { buildWin32CmdShimInvocation, } from '@wrongstack/core/utils';
 //# sourceMappingURL=win32-cmd.d.ts.map

package/dist/{version-help-ATOKGMTK.js → version-help-JQGRPDJW.js}

@@ -1,10 +1,10 @@
 import {
   helpCmd,
   versionCmd
-} from "./chunk-WHEYHDIE.js";
+} from "./chunk-AKESWZH5.js";
 import "./chunk-F5DCFAKI.js";
 export {
   helpCmd,
   versionCmd
 };
-//# sourceMappingURL=version-help-ATOKGMTK.js.map
+//# sourceMappingURL=version-help-JQGRPDJW.js.map

package/dist/webui-server/host-settings.d.ts

@@ -0,0 +1,17 @@
+/** Static settings for the CLI-embedded WebUI host, resolved from options and the environment. */
+import type { CliWebUIOptions } from '../webui-server-options.js';
+export declare function resolveWebuiHostSettings(opts: CliWebUIOptions): {
+    host: string;
+    publicUrl: string | undefined;
+    publicWsUrl: string | undefined;
+    requireToken: boolean;
+    surface: "simpleui" | "webui";
+    requestedHttpPort: number;
+    strictPort: boolean;
+    globalRoot: string;
+    profileConfigPath: string;
+    profileDir: string;
+    rateLimitMax: number;
+    publicHostnames: string[];
+};
+//# sourceMappingURL=host-settings.d.ts.map

package/dist/webui-server/http-bridge.d.ts

@@ -0,0 +1,32 @@
+/**
+ * HTTP + WebSocket listeners for the CLI-embedded WebUI host: the static
+ * frontend (when built), the authenticated WS bridge, the deferred SimpleUI
+ * bind, the IPv6 loopback proxy and the ready banner.
+ */
+import type { Server as HttpServer, IncomingMessage } from 'node:http';
+import { type SessionAgentRegistry } from '@wrongstack/webui-server';
+import type { CliWebUIOptions } from '../webui-server-options.js';
+import type { WebuiTransport } from './transport.js';
+export interface WebuiHttpBridgeInput {
+    opts: CliWebUIOptions;
+    surface: 'webui' | 'simpleui';
+    host: string;
+    httpPort: number;
+    strictPort: boolean;
+    globalRoot: string;
+    wsToken: string;
+    publicUrl: string | undefined;
+    publicWsUrl: string | undefined;
+    requireToken: boolean;
+    getSessionAgents: () => SessionAgentRegistry | undefined;
+    onFleetPing: () => void;
+    broadcast: WebuiTransport['broadcast'];
+    /** The bind advanced past the requested port; called before anything else reads the port. */
+    onPortRebound: (port: number) => void;
+}
+export declare function startWebuiHttpBridge(input: WebuiHttpBridgeInput): Promise<{
+    httpServer: import("@wrongstack/webui-server").StaticServeHandle | null;
+    wss: import("ws").Server<typeof import("ws").WebSocket, typeof IncomingMessage>;
+    ipv6LoopbackServer: HttpServer<typeof IncomingMessage, typeof import("node:http").ServerResponse> | null;
+}>;
+//# sourceMappingURL=http-bridge.d.ts.map

package/dist/webui-server/instance-registration.d.ts

@@ -0,0 +1,19 @@
+/** Registers the CLI-embedded WebUI host in the shared instance registry. */
+import type { CliWebUIOptions } from '../webui-server-options.js';
+export interface EmbeddedInstanceRegistrationInput {
+    opts: CliWebUIOptions;
+    surface: 'webui' | 'simpleui';
+    host: string;
+    httpPort: number;
+    publicUrl: string | undefined;
+    registryBaseDir: string;
+    wsToken: string;
+    currentSessionId: () => string;
+}
+/**
+ * Resolves true once the instance is registered. A session child awaits the
+ * registration (its parent reads the record to attach); every other host
+ * registers in the background and reports success optimistically.
+ */
+export declare function registerEmbeddedWebuiInstance(input: EmbeddedInstanceRegistrationInput): Promise<boolean>;
+//# sourceMappingURL=instance-registration.d.ts.map

package/dist/webui-server/kanban-services.d.ts

@@ -0,0 +1,9 @@
+/** Kanban run mirror + supervisor for the CLI-embedded WebUI host (only when a project root is known). */
+import type { CliWebUIOptions } from '../webui-server-options.js';
+import type { WebuiTransport } from './transport.js';
+export declare function createWebuiKanbanServices(opts: CliWebUIOptions, broadcast: WebuiTransport['broadcast']): {
+    kanbanRunMirror: import("./kanban-run-mirror.js").KanbanRunMirror | null;
+    kanbanSupervisor: import("./kanban-supervisor.js").KanbanSupervisor | null;
+    stopKanbanSupervisorMemoryStats: (() => Promise<void>) | undefined;
+};
+//# sourceMappingURL=kanban-services.d.ts.map

package/dist/webui-server/message-router.d.ts

@@ -0,0 +1,14 @@
+/** Maps the CLI host's route contexts and domain handlers onto the shared embedded message router. */
+import { createEmbeddedMessageRouter } from '@wrongstack/webui-server';
+import type { CliWebUIOptions } from '../webui-server-options.js';
+import type { createWebuiDomainHandlers } from './domain-handlers.js';
+import type { createWebuiRouteContexts } from './route-contexts.js';
+type EmbeddedRouterOptions = Parameters<typeof createEmbeddedMessageRouter>[0];
+export type CliEmbeddedRouterInput = Pick<EmbeddedRouterOptions, 'trustBoundary' | 'send' | 'sendResult' | 'sessionPayload' | 'currentSessionId' | 'shutdown' | 'onDispose' | 'providerCtx' | 'kanbanHostRoutes'> & {
+    opts: CliWebUIOptions;
+    routeContexts: ReturnType<typeof createWebuiRouteContexts>;
+    domainHandlers: ReturnType<typeof createWebuiDomainHandlers>;
+};
+export declare function createCliEmbeddedMessageRouter(input: CliEmbeddedRouterInput): import("@wrongstack/webui-server").EmbeddedMessageRouter;
+export {};
+//# sourceMappingURL=message-router.d.ts.map

package/dist/webui-server/prefs-seeding.d.ts

@@ -1,6 +1,5 @@
 import type { ModelBlackoutRule } from '@wrongstack/core/models';
 import type { Config } from '@wrongstack/core/types';
-import { PREF_KEYS } from '@wrongstack/webui-server';
 interface CliWebUIOptions {
     agent: {
         ctx: {
@@ -35,7 +34,6 @@ interface CliWebUIOptions {
     } | undefined;
 }
 type PrefSnapshot = Record<string, unknown>;
-export { PREF_KEYS };
 export declare function seedConfigToMeta(opts: CliWebUIOptions): Promise<void>;
 export interface PrefsSeeding {
     /**
@@ -51,4 +49,5 @@ export interface PrefsSeeding {
     persistPrefs: (payload: PrefSnapshot) => Promise<void>;
 }
 export declare function createPrefsSeeding(opts: CliWebUIOptions): PrefsSeeding;
+export {};
 //# sourceMappingURL=prefs-seeding.d.ts.map

package/dist/webui-server/provider-config.d.ts

@@ -1,6 +1,5 @@
 import { DefaultSecretVault } from '@wrongstack/core/security';
 import type { ProviderConfig } from '@wrongstack/core/types';
-export { expectDefined, maskedKey, normalizeKeys, nowIso, writeKeysBack, } from '../provider-config-utils.js';
 /**
  * PR 4 of Issue #30 (webui-server 8-PR refactor):
  * provider-config IO.

package/dist/webui-server/provider-plane.d.ts

@@ -0,0 +1,14 @@
+/** Provider routes context + credential hot-reload for the CLI-embedded WebUI host. */
+import { type EmbeddedProviderContext } from '@wrongstack/webui-server';
+import type { CliWebUIOptions } from '../webui-server-options.js';
+import type { WebuiTransport } from './transport.js';
+export declare function createEmbeddedProviderPlane(input: {
+    opts: CliWebUIOptions;
+    profileConfigPath: string;
+    send: WebuiTransport['send'];
+    broadcast: WebuiTransport['broadcast'];
+}): {
+    wsHandlerCtx: EmbeddedProviderContext;
+    credentialWatcherClose: (() => void) | undefined;
+};
+//# sourceMappingURL=provider-plane.d.ts.map

package/dist/webui-server/session-agents.d.ts

@@ -0,0 +1,18 @@
+/** Per-tab agents for the CLI-embedded WebUI host. */
+import type { WebSocket } from 'ws';
+import type { CliWebUIOptions } from '../webui-server-options.js';
+import type { ConnectedClient } from './connection-handler.js';
+/**
+ * One Agent per open tab.
+ *
+ * The embedded host used to hand every tab the same leader Agent, so the
+ * second tab to start a run hit `Agent.run()`'s concurrency guard —
+ * "already in progress on this instance". Four tabs need four Agents; the
+ * registry clones the leader's wiring and gives each session its own
+ * `Context`, which is the state a run actually mutates.
+ */
+export declare function createEmbeddedSessionAgents(opts: CliWebUIOptions, clients: Map<WebSocket, ConnectedClient>, abortControllers: Map<string, AbortController>): {
+    sessionAgents: import("@wrongstack/webui-server").SessionAgentRegistry;
+    isSessionDisplayed: (sessionId: string) => boolean;
+};
+//# sourceMappingURL=session-agents.d.ts.map

package/dist/webui-server/session-start-live.d.ts

@@ -0,0 +1,11 @@
+/** The CLI host's `session.start` payload builder, bound to the live options and per-tab agents. */
+import type { SessionAgentRegistry } from '@wrongstack/webui-server';
+import { type BuildSessionStartPayload, type SessionStartPayloadDeps } from './session-start-payload.js';
+/**
+ * The host's builder, reading the live `opts` and the per-tab agent registry.
+ * `getSessionAgents` is a forward reference: the registry is built after the
+ * builder, so a payload for a background tab still reports that tab's model,
+ * mode and context window rather than the leader's.
+ */
+export declare function createLiveSessionStartPayloadBuilder<T extends SessionStartPayloadDeps>(opts: T, getSessionAgents: () => SessionAgentRegistry | undefined): BuildSessionStartPayload;
+//# sourceMappingURL=session-start-live.d.ts.map

package/dist/webui-server/stream-coalescer.d.ts

@@ -1,2 +1,2 @@
-export { createStreamCoalescer, type StreamCoalescer, type StreamCoalescerDeps, type ToolProgressPayload, } from '@wrongstack/webui-server';
+export { createStreamCoalescer, type StreamCoalescer, } from '@wrongstack/webui-server';
 //# sourceMappingURL=stream-coalescer.d.ts.map

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

@@ -0,0 +1,12 @@
+/** Outbound frame delivery for the CLI-embedded WebUI host: unicast, session-aware broadcast, fan-out. */
+import type { WebSocket } from 'ws';
+import type { ConnectedClient } from './connection-handler.js';
+import type { WSServerMessage } from './contracts.js';
+export interface WebuiTransport {
+    send(ws: WebSocket, msg: WSServerMessage): void;
+    broadcast(msg: WSServerMessage, targetSessionId?: string): void;
+    broadcastEveryone(msg: WSServerMessage): void;
+    sendResult(ws: WebSocket, success: boolean, message: string): void;
+}
+export declare function createWebuiTransport(clients: Map<WebSocket, ConnectedClient>): WebuiTransport;
+//# sourceMappingURL=transport.d.ts.map