@wrongstack/cli 1.0.33 → 1.0.36

package/dist/goal-host-types.d.ts

@@ -0,0 +1,94 @@
+import type { BrainArbiter } from '@wrongstack/core/coordination';
+import type { PhaseGraph, PhaseOrchestrator, PhaseProgress } from '@wrongstack/core/goal';
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { Config, TaskNode } from '@wrongstack/core/types';
+import type { MultiAgentHost } from './multi-agent.js';
+export interface GoalHostDeps {
+    multiAgentHost: MultiAgentHost;
+    /** Read the *current* Config lazily (it may be patched, e.g. YOLO toggles). */
+    getConfig: () => Config;
+    /** Shared app EventBus — orchestrator events feed the TUI PhaseMonitor. */
+    events: EventBus;
+    /** Current parent session id for worktree lifecycle events. */
+    getSessionId?: (() => string | undefined) | undefined;
+    /** Directory for per-project phase-graph engine checkpoints. */
+    storeDir: string;
+    /** Project root — base for git-worktree isolation. */
+    projectRoot: string;
+    /** SDD board snapshot dir — `/worktree clean` skips while an SDD run is live. */
+    sddBoardsDir?: string | undefined;
+    /**
+     * Enable per-phase git-worktree isolation (default true). When on and the
+     * project is a git repo, parallelizable phases run in isolated worktrees and
+     * merge back sequentially. Disable with WRONGSTACK_GOAL_WORKTREES=0.
+     */
+    worktrees?: boolean | undefined;
+    /** Max parallel phases when worktrees are active (default 4). */
+    maxConcurrentPhases?: number | undefined;
+    /** Optional global Brain arbiter for Goal policy decisions. */
+    brain?: BrainArbiter | undefined;
+    /** Optional progress logger (rendered to the user during start). */
+    log?: ((line: string) => void) | undefined;
+}
+/** A live, read-only view of the running Goal, exposed to slash commands. */
+interface GoalRunnerView {
+    graph: PhaseGraph;
+    getProgress: () => PhaseProgress | null;
+    isRunning: () => boolean;
+}
+export type GoalStartResult = {
+    ok: true;
+    graph: PhaseGraph;
+} | {
+    ok: false;
+    error: string;
+};
+export interface GoalHostHooks {
+    onGoalStart: (opts: {
+        goal: string;
+        projectContext?: string | undefined;
+    }) => Promise<GoalStartResult>;
+    onGoalPause: () => void;
+    onGoalResume: () => void;
+    /**
+     * Resume a persisted PhaseGraph. The graph must already have been loaded
+     * from the PhaseStore. Creates a fresh orchestrator and starts executing
+     * pending tasks.
+     */
+    onGoalResumeFromGraph: (graph: PhaseGraph) => Promise<GoalStartResult>;
+    onGoalStop: () => void;
+    getGoalRunner: () => GoalRunnerView | null;
+    /** Interactive board: move a task to another phase. */
+    onGoalMoveTask: (taskId: string, toPhaseId: string) => boolean;
+    /** Interactive board: (re)assign a task to a specific agent (clear with both omitted). */
+    onGoalAssignTask: (taskId: string, agentId?: string, agentName?: string) => boolean;
+    /** Interactive board: add a new task to a phase. Returns the new task id. */
+    onGoalAddTask: (phaseId: string, spec: {
+        title: string;
+        description?: string;
+        type?: TaskNode['type'];
+        priority?: TaskNode['priority'];
+    }) => string | null;
+    /** Interactive board: requeue a task to pending so it (re)runs. */
+    onGoalRetryTask: (taskId: string) => boolean;
+    /** Backs the /worktree slash command (list / merge / prune / clean). */
+    onWorktree: (action: 'list' | 'merge' | 'prune' | 'clean', target?: string) => Promise<string>;
+}
+export interface ActiveRun {
+    graph: PhaseGraph;
+    orchestrator: PhaseOrchestrator;
+    abort: AbortController;
+    unsubscribe: () => void;
+    releaseRunLease: () => Promise<void>;
+    runPromise?: Promise<void> | undefined;
+}
+/** Minimal shape of an agent.run result we depend on. */
+export interface RunResult {
+    status: string;
+    finalText?: string | undefined;
+    error?: {
+        message?: string | undefined;
+    };
+}
+export {};
+//# sourceMappingURL=goal-host-types.d.ts.map

package/dist/goal-host.d.ts

@@ -1,94 +1,5 @@
 export { configureGoalPolicy, isGoalCommandAllowed, resetGoalPolicy } from './goal-commands.js';
-/**
- * Goal host wiring for the CLI.
- *
- * Turns a free-text goal into a real, LLM-driven phase run:
- *   1. PLAN   — a one-shot subagent generates a phase-by-phase plan where each
- *               phase carries many concrete todos (GoalPlanner).
- *   2. BUILD  — PhaseGraphBuilder materializes the plan into a PhaseGraph with a
- *               populated TaskGraph per phase, persisted as per-project JSON.
- *   3. RUN    — PhaseOrchestrator drives the graph in the background; every task
- *               is executed by a fresh subagent (full tool access). Phase/task
- *               events flow on the shared EventBus so the TUI PhaseMonitor stays
- *               live, and the graph is re-persisted as phases complete.
- *
- * This is "SDD logic but different": phased, persisted task-lists like SDD, but
- * driven by the autonomous orchestrator + concurrent subagents rather than
- * single-thread turn injection.
- */
-import { type BrainArbiter } from '@wrongstack/core/coordination';
-import { type PhaseGraph, type PhaseProgress } from '@wrongstack/core/goal';
-import type { EventBus } from '@wrongstack/core/kernel';
-import type { Config, TaskNode } from '@wrongstack/core/types';
-import type { MultiAgentHost } from './multi-agent.js';
-export interface GoalHostDeps {
-    multiAgentHost: MultiAgentHost;
-    /** Read the *current* Config lazily (it may be patched, e.g. YOLO toggles). */
-    getConfig: () => Config;
-    /** Shared app EventBus — orchestrator events feed the TUI PhaseMonitor. */
-    events: EventBus;
-    /** Current parent session id for worktree lifecycle events. */
-    getSessionId?: (() => string | undefined) | undefined;
-    /** Directory for per-project phase-graph engine checkpoints. */
-    storeDir: string;
-    /** Project root — base for git-worktree isolation. */
-    projectRoot: string;
-    /**
-     * Enable per-phase git-worktree isolation (default true). When on and the
-     * project is a git repo, parallelizable phases run in isolated worktrees and
-     * merge back sequentially. Disable with WRONGSTACK_GOAL_WORKTREES=0.
-     */
-    worktrees?: boolean | undefined;
-    /** Max parallel phases when worktrees are active (default 4). */
-    maxConcurrentPhases?: number | undefined;
-    /** Optional global Brain arbiter for Goal policy decisions. */
-    brain?: BrainArbiter | undefined;
-    /** Optional progress logger (rendered to the user during start). */
-    log?: ((line: string) => void) | undefined;
-}
-/** A live, read-only view of the running Goal, exposed to slash commands. */
-interface GoalRunnerView {
-    graph: PhaseGraph;
-    getProgress: () => PhaseProgress | null;
-    isRunning: () => boolean;
-}
-type GoalStartResult = {
-    ok: true;
-    graph: PhaseGraph;
-} | {
-    ok: false;
-    error: string;
-};
-export interface GoalHostHooks {
-    onGoalStart: (opts: {
-        goal: string;
-        projectContext?: string | undefined;
-    }) => Promise<GoalStartResult>;
-    onGoalPause: () => void;
-    onGoalResume: () => void;
-    /**
-     * Resume a persisted PhaseGraph. The graph must already have been loaded
-     * from the PhaseStore. Creates a fresh orchestrator and starts executing
-     * pending tasks.
-     */
-    onGoalResumeFromGraph: (graph: PhaseGraph) => Promise<GoalStartResult>;
-    onGoalStop: () => void;
-    getGoalRunner: () => GoalRunnerView | null;
-    /** Interactive board: move a task to another phase. */
-    onGoalMoveTask: (taskId: string, toPhaseId: string) => boolean;
-    /** Interactive board: (re)assign a task to a specific agent (clear with both omitted). */
-    onGoalAssignTask: (taskId: string, agentId?: string, agentName?: string) => boolean;
-    /** Interactive board: add a new task to a phase. Returns the new task id. */
-    onGoalAddTask: (phaseId: string, spec: {
-        title: string;
-        description?: string;
-        type?: TaskNode['type'];
-        priority?: TaskNode['priority'];
-    }) => string | null;
-    /** Interactive board: requeue a task to pending so it (re)runs. */
-    onGoalRetryTask: (taskId: string) => boolean;
-    /** Backs the /worktree slash command (list / merge / prune / clean). */
-    onWorktree: (action: 'list' | 'merge' | 'prune' | 'clean', target?: string) => Promise<string>;
-}
+import type { GoalHostDeps, GoalHostHooks } from './goal-host-types.js';
+export type { GoalHostDeps, GoalHostHooks } from './goal-host-types.js';
 export declare function createGoalHost(deps: GoalHostDeps): GoalHostHooks;
 //# sourceMappingURL=goal-host.d.ts.map

package/dist/{hq-KBFDKTDD.js → hq-BBLGEEUH.js}

@@ -7,7 +7,7 @@ import {
 import {
   normalizeHqPublicOrigin,
   resolveAuditActor
-} from "./chunk-5EA6OTLJ.js";
+} from "./chunk-AFOH6CHO.js";
 import {
   parseHqIpAllowlist
 } from "./chunk-Q7E3BPDU.js";
@@ -316,7 +316,7 @@ var hqCmd = async (args, deps) => {
     return hqAlertsCmd(args.slice(1), deps);
   }
   if (sub === "service") {
-    const { hqServiceCmd } = await import("./hq-service-FGB7BY2D.js");
+    const { hqServiceCmd } = await import("./hq-service-4Q64WFNT.js");
     return hqServiceCmd(args.slice(1), deps);
   }
   if (sub === "help" || sub === "--help") {
@@ -329,7 +329,7 @@ var hqCmd = async (args, deps) => {
   return 1;
 };
 async function startServer(deps) {
-  const { startHqServer } = await import("./hq-server-AVNKZ2PV.js");
+  const { startHqServer } = await import("./hq-server-5TR6NBGS.js");
   const dataDir = resolveDataDir(deps);
   const flags = deps.flags ?? {};
   const rawPublicUrl = typeof flags["hq-public-url"] === "string" ? flags["hq-public-url"] : process.env.WRONGSTACK_HQ_PUBLIC_URL;
@@ -1007,7 +1007,6 @@ function printTokenHelp(deps) {
 `);
 }
 export {
-  hqCmd,
-  resolveAuditActor
+  hqCmd
 };
-//# sourceMappingURL=hq-KBFDKTDD.js.map
+//# sourceMappingURL=hq-BBLGEEUH.js.map

package/dist/hq-server/handle-types.d.ts

@@ -5,7 +5,7 @@
  * `subcommands/handlers/hq.ts`) can depend on the public types without
  * pulling in the HQ server implementation. Breaks a long-standing type-only
  * import edge `handlers/hq.ts → hq-server.ts` that participated in the
- * 33-member CLI SCC (see docs/reports/modularity-assessment-2026-08-22.md).
+ * 33-member CLI SCC (see docs/archive/reports/modularity-assessment-2026-08-22.md).
  *
  * This module MUST contain no runtime imports.
  */

package/dist/hq-server/routes/auth-handlers.d.ts

@@ -1,4 +1,4 @@
-export { authorizeAuthAdmin, callerCanAdministerAuth, HQ_AUTH_ADMIN_CAPABILITY, isLoopbackRequest, writeAuthAdminRequired, type ApplyHqAuthFile, } from './auth/common.js';
+export { callerCanAdministerAuth, type ApplyHqAuthFile, } from './auth/common.js';
 export { handleApiAuthStatus, handleApiLogin, handleApiLogout, handleApiPassword, } from './auth/password-routes.js';
 export { handleApiLoginVerify, handleApiTotpDisable, handleApiTotpEnable, handleApiTotpSetup, } from './auth/totp-routes.js';
 export { handleApiBootstrap, handleApiTokenUpgrade, } from './auth/bootstrap-routes.js';

package/dist/hq-server/routes.d.ts

@@ -16,21 +16,12 @@ import * as HqServerAuth from './auth.js';
 import type { HqMailboxGatewayHealth } from './mailbox-gateway-health.js';
 import { type ApplyHqAuthFile } from './routes/auth-handlers.js';
 import * as HqServerUtils from './utils.js';
-export declare const setHqSecurityHeaders: typeof HqServerAuth.setHqSecurityHeaders;
 export declare const hasTrustedBrowserOrigin: typeof HqServerAuth.hasTrustedBrowserOrigin;
 export declare const authenticateBrowserRequest: typeof HqServerAuth.authenticateBrowserRequest;
 export declare const isTokenAuth: typeof HqServerAuth.isTokenAuth;
 export declare const isCookieAuth: typeof HqServerAuth.isCookieAuth;
-export declare const hqAuthRequired: typeof HqServerAuth.hqAuthRequired;
-export declare const setHqSessionCookie: typeof HqServerAuth.setHqSessionCookie;
-export declare const clearHqSessionCookie: typeof HqServerAuth.clearHqSessionCookie;
-export declare const serializeHqSessionCookie: typeof HqServerAuth.serializeHqSessionCookie;
 export declare const parseHqSessionCookie: typeof HqServerAuth.parseHqSessionCookie;
-export declare const parseCookieHeader: typeof HqServerAuth.parseCookieHeader;
-export declare const HQ_SESSION_COOKIE = "hq.session";
 export declare const decodePathSegment: typeof HqServerUtils.decodePathSegment;
-export declare const readRequestBody: typeof HqServerUtils.readRequestBody;
-export declare const writeInvalidBody: typeof HqServerUtils.writeInvalidBody;
 export declare const sanitizeApiError: typeof HqServerUtils.sanitizeApiError;
 export declare const buildHttpUrl: typeof HqServerUtils.buildHttpUrl;
 export declare const buildBootstrapHttpUrl: typeof HqServerUtils.buildBootstrapHttpUrl;
@@ -38,12 +29,9 @@ export declare const buildClientWsUrl: typeof HqServerUtils.buildClientWsUrl;
 export declare const agentRingKey: typeof HqServerUtils.agentRingKey;
 export declare const agentMessageToEntry: typeof HqServerUtils.agentMessageToEntry;
 export declare const readLocalSubagentTranscript: typeof HqServerUtils.readLocalSubagentTranscript;
-export declare const lanIPv4Addresses: typeof HqServerUtils.lanIPv4Addresses;
-export declare const hqRuntimeMarkerPath: typeof HqServerUtils.hqRuntimeMarkerPath;
 import type { HqIpAllowlist } from './ip-allowlist.js';
 import type { LoginAttemptStore } from './login-attempt-store.js';
-import type { ConnectedClient, HqRouterMutableAuth, HqSessionEntry, HqSnapshotBroadcaster, ProjectDetail, TranscriptRing } from './types.js';
-export type { ConnectedClient, HqSnapshotBroadcaster, ProjectDetail, TranscriptRing };
+import type { ConnectedClient, HqRouterMutableAuth, HqSessionEntry, TranscriptRing } from './types.js';
 export interface HqRouterMailboxGateway {
     mailbox: Mailbox;
     router: ReturnType<typeof createMailboxHttpRouter>;

package/dist/hq-server/utils.d.ts

@@ -125,5 +125,5 @@ export declare function recordTimeseriesSignal(persistence: HqPersistence, event
  * it and forwarded `String(err)` verbatim instead. One implementation now
  * serves every server surface.
  */
-export { sanitizeApiError, scrubErrorDetail } from '@wrongstack/core/security';
+export { sanitizeApiError } from '@wrongstack/core/security';
 //# sourceMappingURL=utils.d.ts.map

package/dist/{hq-server-AVNKZ2PV.js → hq-server-5TR6NBGS.js}

@@ -10,9 +10,9 @@ import {
   readLocalSubagentTranscript,
   sanitizeApiError,
   startHqServer
-} from "./chunk-RQ4UBKYH.js";
+} from "./chunk-GF7LUWQS.js";
 import "./chunk-HXJYHAR4.js";
-import "./chunk-5EA6OTLJ.js";
+import "./chunk-AFOH6CHO.js";
 import "./chunk-Q7E3BPDU.js";
 export {
   DEFAULT_HOST,
@@ -27,4 +27,4 @@ export {
   sanitizeApiError,
   startHqServer
 };
-//# sourceMappingURL=hq-server-AVNKZ2PV.js.map
+//# sourceMappingURL=hq-server-5TR6NBGS.js.map

package/dist/{hq-service-FGB7BY2D.js → hq-service-4Q64WFNT.js}

@@ -4,8 +4,8 @@ import {
 import {
   detectUpdatePackageManager,
   detectUpdatePackageName
-} from "./chunk-PGNERAZL.js";
-import "./chunk-U3SS4NRH.js";
+} from "./chunk-ZWBI7ORM.js";
+import "./chunk-BHXAKTBE.js";
 import "./chunk-DIOODAYM.js";
 import "./chunk-F5DCFAKI.js";
 
@@ -511,4 +511,4 @@ export {
   hqServiceCmd,
   renderHqServiceAssets
 };
-//# sourceMappingURL=hq-service-FGB7BY2D.js.map
+//# sourceMappingURL=hq-service-4Q64WFNT.js.map

package/dist/{import-claude-code-AYG24RG2.js → import-claude-code-GHIS2F7Y.js}

@@ -1,6 +1,6 @@
 import {
   normalizeMcpServerEntry
-} from "./chunk-HLSHFXTO.js";
+} from "./chunk-WY74MMDB.js";
 import {
   activeProfileConfigPath
 } from "./chunk-YMXXOOFN.js";
@@ -156,7 +156,7 @@ async function readJson(file) {
     return void 0;
   }
   try {
-    const parsed = JSON.parse(raw);
+    const parsed = JSON.parse(raw.replace(/^\uFEFF/, ""));
     return isRecord(parsed) ? parsed : void 0;
   } catch {
     throw new Error(`${file} is not valid JSON`);
@@ -265,4 +265,4 @@ export {
   planClaudeCodeImport,
   readClaudeCodeSources
 };
-//# sourceMappingURL=import-claude-code-AYG24RG2.js.map
+//# sourceMappingURL=import-claude-code-GHIS2F7Y.js.map

package/dist/index.js

@@ -2,10 +2,10 @@
 import {
   applyNodeEnvDefault,
   applySessionShellDefault
-} from "./chunk-WTJDSTYD.js";
+} from "./chunk-T5KR6SNO.js";
 import {
   parseArgs
-} from "./chunk-MPQCHBDJ.js";
+} from "./chunk-CJSHS2K7.js";
 import {
   CLI_VERSION
 } from "./chunk-F5DCFAKI.js";
@@ -121,7 +121,7 @@ async function main(argv) {
     applyAsciiMode(earlyFlags);
   }
   if (earlyFlags["help"] === true || earlyFlags["version"] === true) {
-    const { handleHelpVersionShortCircuit } = await import("./short-circuit-flags-D6VAG47Y.js");
+    const { handleHelpVersionShortCircuit } = await import("./short-circuit-flags-IEV3FEOT.js");
     const earlyExit = await handleHelpVersionShortCircuit(argv);
     if (earlyExit !== null) return earlyExit;
   }
@@ -130,7 +130,7 @@ async function main(argv) {
     shouldCaptureTuiStartup(parsed.flags, parsed.positional)
   );
   try {
-    const { initializeCli } = await import("./cli-context-7HK67B2Z.js");
+    const { initializeCli } = await import("./cli-context-I6HJCVCV.js");
     const cliCtx = await initializeCli(argv, {
       onNonTuiLaunch: () => startupOutput.stop()
     });
@@ -140,7 +140,7 @@ async function main(argv) {
     } else {
       startupOutput.stop();
     }
-    const { runInteractive } = await import("./cli-main-TQGLKB6D.js");
+    const { runInteractive } = await import("./cli-main-X7KD7IOC.js");
     return await runInteractive(cliCtx);
   } finally {
     startupOutput.stop();

package/dist/live-settings-input.d.ts

@@ -105,6 +105,8 @@ export interface LiveSettingsInput {
      * `tools.nextsteps.enabled`; read at boot, so it applies next session.
      */
     nextStepsTool?: boolean | undefined;
+    /** Persisted as `autonomy.nextSteps` ('required' when true). Read live. */
+    nextStepsRequired?: boolean | undefined;
     /** Minimum relation strength for SAGE memory injection. Default: 0.85. */
     sageMemoryInjectThreshold?: number | undefined;
     /**

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

@@ -22,8 +22,6 @@
  *    log a warning, REPL runs without mailbox-bridge. The user
  *    can run `wstack mailbox serve` manually later.
  */
-import { type MailboxBridgeLock, readLiveLock } from '@wrongstack/core/coordination';
-export declare const MAILBOX_BRIDGE_HEALTHZ_PROBE_MS = 500;
 export interface MailboxBridgeHandle {
     /** Bound URL — empty string if we couldn't bring the bridge up. */
     url: string;
@@ -99,6 +97,5 @@ export type ProbeFn = (url: string, timeoutMs: number) => Promise<boolean>;
  * that prefer to log a warning over crashing the host process.
  */
 export declare function tryAcquireMailboxBridge(opts: BootstrapOptions): Promise<MailboxBridgeHandle>;
-export { type MailboxBridgeLock, readLiveLock };
-export declare function readTokenFromFile(tokenPath: string): Promise<string | null>;
+export {};
 //# sourceMappingURL=mailbox-bridge-bootstrap.d.ts.map

package/dist/{mailbox-serve-S536N66F.js → mailbox-serve-DRWJVMYU.js}

@@ -1,6 +1,6 @@
 import {
   startCliHqConnection
-} from "./chunk-4UWCMBPG.js";
+} from "./chunk-BJH44J7G.js";
 import "./chunk-F5DCFAKI.js";
 
 // src/subcommands/handlers/mailbox-serve.ts
@@ -362,4 +362,4 @@ function printHelp(deps) {
 export {
   mailboxServeCmd
 };
-//# sourceMappingURL=mailbox-serve-S536N66F.js.map
+//# sourceMappingURL=mailbox-serve-DRWJVMYU.js.map

package/dist/{modeldiag-NEPTLFZW.js → modeldiag-F3LUF4VJ.js}

@@ -1,6 +1,6 @@
 import {
   applyProviderOAuthRefresh
-} from "./chunk-TWSQTQKR.js";
+} from "./chunk-4R6TVMYA.js";
 import {
   discoverAndMergeProviders
 } from "./chunk-PA4VBCXS.js";
@@ -20,7 +20,7 @@ import {
 } from "./chunk-YL4KCHZG.js";
 import {
   mutateConfigProviders
-} from "./chunk-ZYACRPLN.js";
+} from "./chunk-ULYAI7CP.js";
 import {
   activeProfileConfigPath
 } from "./chunk-YMXXOOFN.js";
@@ -843,4 +843,4 @@ var modeldiagCmd = async (args, deps) => {
 export {
   modeldiagCmd
 };
-//# sourceMappingURL=modeldiag-NEPTLFZW.js.map
+//# sourceMappingURL=modeldiag-F3LUF4VJ.js.map

package/dist/picker-effort.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Reasoning-effort strip for the STARTUP model picker — the pre-TUI twin of
+ * the `/model` picker's ←/→ strip (tui/components/model-picker-effort.ts).
+ *
+ * The vocabulary is model-aware the same way: a model whose catalog entry
+ * documents its levels offers only those, an undocumented reasoner offers the
+ * full canonical set (the runtime resolver drops what the wire cannot carry),
+ * and a non-reasoning model — or one documented as having no effort control —
+ * offers nothing. The list is always led by {@link EFFORT_KEEP}, so pressing
+ * Enter without touching ←/→ keeps the configured effort exactly as before.
+ */
+import { type ModelsDevModel, type ReasoningEffort } from '@wrongstack/core/types';
+/** Sentinel first option: leave the persisted reasoning effort untouched. */
+export declare const EFFORT_KEEP = "default";
+export type StartupEffortChoice = typeof EFFORT_KEEP | ReasoningEffort;
+/** Effort choices for one model, weakest → strongest, led by `default`. */
+export declare function startupEffortOptions(model: Pick<ModelsDevModel, 'reasoning' | 'reasoningConfig'> | undefined): readonly StartupEffortChoice[];
+/** Cycle the current choice by `delta`, wrapping around the list. */
+export declare function cycleStartupEffort(options: readonly StartupEffortChoice[], current: string, delta: number): StartupEffortChoice;
+/**
+ * Tri-state effort vocabulary for the settings field-24 gate (the ←/→ cycle
+ * in the settings picker): `undefined` — undocumented reasoner, the cycle
+ * keeps the full canonical set; `[]` — the model documents
+ * `effortSupported === false` (no effort control at all; the runtime resolver
+ * drops any effort, so the cycle must go inert); otherwise the documented
+ * levels. Mirrors {@link startupEffortOptions}'s tri-state handling.
+ */
+export declare function reasoningEffortVocabulary(rc: {
+    effortSupported?: boolean | undefined;
+    effortLevels?: readonly string[] | undefined;
+} | undefined): string[] | undefined;
+//# sourceMappingURL=picker-effort.d.ts.map

package/dist/picker-model-picker.d.ts

@@ -1,6 +1,17 @@
 import type { ModelsDevModel, ResolvedProvider } from '@wrongstack/core/types';
+import { type StartupEffortChoice } from './picker-effort.js';
 export declare const LIVE_PICKER_MAX_VISIBLE = 15;
 export declare function filterModels(query: string, models: ModelsDevModel[]): ModelsDevModel[];
-export declare function renderLiveModelList(query: string, filtered: ModelsDevModel[], selectedIdx: number, header: string): string;
-export declare function runLiveModelPicker(provider: ResolvedProvider, defaultModel?: string): Promise<ModelsDevModel | undefined>;
+/** Effort strip state for the focused row; omitted → no strip line at all. */
+export interface LiveModelEffortStrip {
+    options: readonly StartupEffortChoice[];
+    choice: StartupEffortChoice;
+}
+export interface LiveModelPick {
+    model: ModelsDevModel;
+    /** {@link EFFORT_KEEP} when the user left the configured effort alone. */
+    effort: StartupEffortChoice;
+}
+export declare function renderLiveModelList(query: string, filtered: ModelsDevModel[], selectedIdx: number, header: string, effort?: LiveModelEffortStrip): string;
+export declare function runLiveModelPicker(provider: ResolvedProvider, defaultModel?: string): Promise<LiveModelPick | undefined>;
 //# sourceMappingURL=picker-model-picker.d.ts.map

package/dist/picker-provider-list.d.ts

@@ -0,0 +1,66 @@
+import type { ResolvedProvider } from '@wrongstack/core/types';
+/**
+ * Filter providers by a free-text query: case-insensitive substring match
+ * against the provider id OR display name. An empty/whitespace query returns
+ * all providers (as a copy). Input order is preserved. Powers the live
+ * type-to-filter provider picker.
+ */
+/**
+ * Append synthetic entries for the built-in local-server presets
+ * (OmniRoute / Ollama / vLLM / LM Studio) that aren't already present in
+ * the merged list. These are keyless loopback gateways, so they pass the
+ * `isKeylessLocalProvider` filter and become immediately selectable even
+ * on a fresh install with no config and no catalog entry — mirroring the
+ * `wstack auth local` shortcut. An entry is skipped when an id-match
+ * already exists (catalog or saved config), so a user's customized
+ * provider always wins over the preset default. Mutates and returns
+ * `merged` for call-site convenience. Pure aside from the push.
+ */
+export declare function appendLocalPresetProviders(merged: ResolvedProvider[]): ResolvedProvider[];
+export declare function filterProviders(query: string, providers: ResolvedProvider[]): ResolvedProvider[];
+/** Preferred family display order; remaining families follow in insertion order. */
+export declare const PROVIDER_FAMILY_PREFERRED_ORDER: string[];
+/**
+ * Order providers for display: grouped by wire family in preferred order, then
+ * alphabetical by id within each family. Pure. Shared by the live render and
+ * the raw-stdin loop so the selection index and the rendered cursor always
+ * refer to the same provider.
+ */
+export declare function orderProvidersForDisplay(filtered: ResolvedProvider[]): ResolvedProvider[];
+/**
+ * Render the live type-to-filter provider view as one string: the query line,
+ * providers grouped by wire family (preferred order, alphabetical within each
+ * family), the selected provider marked with ▶, and a key hint. Capped to
+ * LIVE_PICKER_MAX_VISIBLE rows so a frame always fits the viewport (the raw
+ * loop redraws by moving the cursor up and clearing). Pure.
+ */
+export declare function renderLiveProviderList(query: string, filtered: ResolvedProvider[], selectedIdx: number, savedSet?: Set<string>): string;
+/**
+ * Interactive provider + model picker. Lists supported providers grouped
+ * by wire family — by default only those with an API key (env or stored
+ * config), so you see only what you can actually launch into. Falls back
+ * to the full catalog when no keys are found anywhere.
+ *
+ * When `defaultProvider`/`defaultModel` are passed, they're pre-selected
+ * so the user can press Enter to accept the previous choice.
+ */
+/**
+ * Live type-to-filter provider picker (TTY only). Takes over stdin in raw mode
+ * and redraws the filtered, family-grouped list on every keystroke. Thin I/O
+ * shell around the pure filterProviders / applyPickerKey / renderLiveProviderList
+ * helpers (which are fully unit-tested). Returns the chosen provider, or
+ * undefined on cancel. runPicker only calls this when stdin is a TTY; non-TTY
+ * callers (CI, piped input, tests) fall through to the numbered readLine picker.
+ */
+export declare const QUERY_MARKER = "Select provider:";
+/**
+ * Park the terminal cursor at the end of the live query text inside the
+ * boxed frame. The frame is multi-line with a border, so we (1) find which
+ * physical line holds the query, (2) move up from the last line to it, then
+ * (3) move to the visible column just after the typed query. Visible width
+ * is measured with stripAnsi so the box border + accent colors don't offset
+ * the cursor.
+ */
+export declare function cursorToQuery(frame: string, query: string): void;
+export declare function runLiveProviderPicker(displayList: ResolvedProvider[], savedSet?: Set<string>): Promise<ResolvedProvider | undefined>;
+//# sourceMappingURL=picker-provider-list.d.ts.map

package/dist/picker.d.ts

@@ -1,29 +1,29 @@
-import type { Config, ModelsRegistry, ResolvedProvider } from '@wrongstack/core/types';
+import type { Config, ModelsRegistry, ReasoningEffort } from '@wrongstack/core/types';
 import type { ReadlineInputReader } from './input-reader.js';
 import type { TerminalRenderer } from './renderer.js';
 export { applyPickerKey, type ProviderPickerState } from './picker-key-state.js';
 export { filterModels, LIVE_PICKER_MAX_VISIBLE, renderLiveModelList, } from './picker-model-picker.js';
+export { filterProviders, renderLiveProviderList, runLiveProviderPicker, } from './picker-provider-list.js';
 export { codexPickerPreamble } from './picker-ui.js';
-export declare function filterProviders(query: string, providers: ResolvedProvider[]): ResolvedProvider[];
-/**
- * Render the live type-to-filter provider view as one string: the query line,
- * providers grouped by wire family (preferred order, alphabetical within each
- * family), the selected provider marked with ▶, and a key hint. Capped to
- * LIVE_PICKER_MAX_VISIBLE rows so a frame always fits the viewport (the raw
- * loop redraws by moving the cursor up and clearing). Pure.
- */
-export declare function renderLiveProviderList(query: string, filtered: ResolvedProvider[], selectedIdx: number, savedSet?: Set<string>): string;
 /**
  * Save provider + model to the global config file.
  * Creates backups + history entries before writing.
  * Returns true if saved successfully.
  */
-export declare function saveToGlobalConfig(configPath: string, provider: string, model: string, homeFn?: () => string): Promise<boolean>;
+export declare function saveToGlobalConfig(configPath: string, provider: string, model: string, options?: {
+    /** Written to `modelRuntime.reasoning.effort` — the key `/effort` and the settings panel own. */
+    effort?: ReasoningEffort | undefined;
+    homeFn?: (() => string) | undefined;
+}): Promise<boolean>;
 export interface PickerResult {
     provider: string;
     model: string;
+    /**
+     * Reasoning effort chosen on the model's ←/→ strip. Absent when the user
+     * kept `default` (or the model has no strip) — the configured effort stays.
+     */
+    effort?: ReasoningEffort | undefined;
 }
-export declare function runLiveProviderPicker(displayList: ResolvedProvider[], savedSet?: Set<string>): Promise<ResolvedProvider | undefined>;
 export declare function runPicker(deps: {
     modelsRegistry: ModelsRegistry;
     renderer: TerminalRenderer;

package/dist/plugin-config.d.ts

@@ -1,5 +1,11 @@
 import type { PluginConfig } from '@wrongstack/core/types';
 import type { PluginManagementDeps, PluginManagementResult } from './plugin-management-types.js';
+/**
+ * Read the profile config for a read-modify-write. Only a MISSING file reads as
+ * `{}`: callers write the result back over the whole profile, so treating an
+ * unreadable or corrupt file as empty wiped every provider, key and setting.
+ * A leading UTF-8 BOM is ignorable (RFC 8259) — the config loader accepts it.
+ */
 export declare function readConfig(file: string): Promise<Record<string, unknown>>;
 export declare function pluginName(p: string | PluginConfig): string;
 export declare function upsertPlugin(spec: string, opts: {

package/dist/{plugin-usage-3TZGROK7.js → plugin-usage-EM752WHG.js}

@@ -1,10 +1,10 @@
 import {
   runPluginManagementCommand
-} from "./chunk-HHRYIDOW.js";
+} from "./chunk-ACW64W4M.js";
 import {
   activeProfileConfigPath
 } from "./chunk-YMXXOOFN.js";
-import "./chunk-4BX2YDTQ.js";
+import "./chunk-4JMAWKLA.js";
 import {
   restoreFlags
 } from "./chunk-CSAPOCBP.js";
@@ -41,4 +41,4 @@ export {
   pluginCmd,
   usageCmd
 };
-//# sourceMappingURL=plugin-usage-3TZGROK7.js.map
+//# sourceMappingURL=plugin-usage-EM752WHG.js.map