@wrongstack/cli 0.284.0 → 0.285.0

package/dist/settings-menu.d.ts

@@ -0,0 +1,87 @@
+import { type ConfigStore, type SecretVault } from '@wrongstack/core';
+import type { ReadlineInputReader } from './input-reader.js';
+import type { TerminalRenderer } from './renderer.js';
+export interface SettingsMenuDeps {
+    renderer: TerminalRenderer;
+    reader: ReadlineInputReader;
+    configStore: ConfigStore;
+    globalConfigPath: string;
+    vault: SecretVault;
+}
+/**
+ * Interactive settings manager. Shows current configuration values,
+ * lets the user edit them, and persists changes back to the config file.
+ * Loops until the user exits.
+ */
+export declare function runSettingsMenu(deps: SettingsMenuDeps): Promise<number>;
+/** The subset of {@link SettingsMenuDeps} needed to persist a setting —
+ *  no renderer/reader, so this is safe to call from non-interactive surfaces
+ *  (the TUI, headless runs, the arg-driven `/settings` slash command). */
+export interface PersistSettingDeps {
+    configStore: ConfigStore;
+    globalConfigPath: string;
+    /** Per-project config path (<project>/.wrongstack/config.json).
+     *  Used when configScope === 'project'. Lives inside the project
+     *  root so it can be gitignored or team-shared. */
+    inProjectConfigPath?: string | undefined;
+    vault: SecretVault;
+    /** Force writes to ~/.wrongstack/config.json even when configScope is project. */
+    forceGlobal?: boolean | undefined;
+}
+/**
+ * Strip credential-bearing and machine-specific fields from a config object
+ * so it is safe to write into a per-project `.wrongstack/config.json` file.
+ * Returns a new object — the original is not mutated.
+ */
+export declare function filterSafeForProject(cfg: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Read the config file, apply `mutator` to its `autonomy` block, and write it
+ * back atomically (then mirror into the in-memory config store). Pure I/O — no
+ * terminal interaction — so it works identically under the plain REPL and the
+ * Ink TUI.
+ */
+export declare function persistAutonomySetting(deps: PersistSettingDeps, mutator: (autonomy: {
+    autoProceedDelayMs?: number | undefined;
+    defaultMode?: string | undefined;
+    enhance?: boolean | undefined;
+    enhanceDelayMs?: number | undefined;
+    enhanceLanguage?: string | undefined;
+}) => void): Promise<void>;
+/**
+ * Read the config file, apply `mutator` to the full decrypted object, and
+ * write it back atomically. This is used for small top-level settings that do
+ * not warrant a dedicated helper.
+ */
+export declare function persistConfigSetting(deps: PersistSettingDeps, mutator: (config: Record<string, unknown>) => void): Promise<void>;
+/**
+ * Persist Telegram plugin config to `extensions.telegram` in the global config
+ * file. Mirrors `persistAutonomySetting` — reads the config, applies the
+ * mutator, encrypts secrets, writes atomically, then updates ConfigStore.
+ */
+export declare function persistTelegramConfig(deps: PersistSettingDeps, mutator: (telegram: Record<string, unknown>) => void): Promise<void>;
+/**
+ * Derive the filesystem-access pair (`features.allowOutsideProjectRoot` and
+ * `tools.restrictToProjectRoot`) from a save input. The two are inverses
+ * of each other and the codebase intentionally keeps both in sync for
+ * backward compatibility with older readers that only know about
+ * `tools.restrictToProjectRoot`.
+ *
+ * Single source of truth: `allowOutsideProjectRoot`. If the caller only
+ * sets `restrictFsToRoot`, it is converted to its inverse. If both are
+ * set (which the picker should not do, but defensive code paths may),
+ * `allowOutsideProjectRoot` wins. Returns `undefined` if neither is set,
+ * so the caller can skip the write.
+ *
+ * The input is duck-typed (only the two relevant fields are read) so any
+ * caller can pass a partial shape: the TUI's full `LiveSettingsInput`,
+ * a slash-command's `{ restrictFsToRoot: boolean }`, or any future
+ * save-handler that only carries these two knobs.
+ */
+export declare function deriveFsAccessPair(input: {
+    allowOutsideProjectRoot?: boolean | undefined;
+    restrictFsToRoot?: boolean | undefined;
+}): {
+    allowOutsideProjectRoot: boolean;
+    restrictToProjectRoot: boolean;
+} | undefined;
+//# sourceMappingURL=settings-menu.d.ts.map

package/dist/settings-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-menu.d.ts","sourceRoot":"","sources":["../src/settings-menu.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,WAAW,EAMhB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGtD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,WAAW,EAAE,WAAW,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,WAAW,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CA+B7E;AAyID;;0EAE0E;AAC1E,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,WAAW,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB;;uDAEmD;IACnD,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,KAAK,EAAE,WAAW,CAAC;IACnB,kFAAkF;IAClF,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACnC;AA+DD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQ1F;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,CAAC,QAAQ,EAAE;IAClB,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC,KAAK,IAAI,GACT,OAAO,CAAC,IAAI,CAAC,CAmEf;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GACjD,OAAO,CAAC,IAAI,CAAC,CA+Df;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GACnD,OAAO,CAAC,IAAI,CAAC,CAkDf;AAiBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,uBAAuB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9C,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACxC,GACG;IAAE,uBAAuB,EAAE,OAAO,CAAC;IAAC,qBAAqB,EAAE,OAAO,CAAA;CAAE,GACpE,SAAS,CAUZ"}

package/dist/shutdown-cleanup.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Graceful shutdown for the CLI host process.
+ *
+ * Bug history: cli-main.ts used to call `process.exit(0)` immediately in its
+ * SIGINT/SIGTERM handlers, after kicking off async cleanup with `void
+ * cleanup()`. The async work (most importantly `registry.markClosing()`, an
+ * awaited atomic disk write) was being cut off — leaving the cross-process
+ * session registry thinking the host was still alive after Ctrl+C.
+ *
+ * This helper is the same pattern `webui-server/lifecycle.ts` uses
+ * (`createWebuiShutdown`) and `cli-entry-point.ts` uses for its natural-exit
+ * drain: idempotent guard, await the work, set `exitCode`, give the event
+ * loop a bounded grace period, then force exit. A repeated signal that
+ * somehow re-fires our handler (e.g. someone re-installs it, or the
+ * `beforeExit` and a `SIGINT` race) short-circuits to immediate exit instead
+ * of waiting for the cleanup to settle a second time.
+ *
+ * The cleanup function is responsible for whatever the caller needs to flush
+ * — registry writes, unsubscribe, dispose, etc. The wrapper only handles the
+ * process-exit handshake around it.
+ */
+export interface ShutdownCleanup {
+    /**
+     * Async cleanup. Called exactly once across all signals. May throw — errors
+     * are swallowed so a stuck cleanup can't wedge the exit path.
+     */
+    run: () => Promise<void>;
+    /** Exit code to use on a clean shutdown (default 0). */
+    exitCode?: number;
+}
+export interface ShutdownHandle {
+    /** Install SIGINT + SIGTERM + beforeExit listeners. Idempotent. */
+    install: () => void;
+    /** Uninstall listeners (for tests). */
+    uninstall: () => void;
+    /** True iff cleanup has been kicked off (by any signal). */
+    get cleanupStarted(): boolean;
+}
+/**
+ * Build a graceful-shutdown handle. Pass the cleanup function; the wrapper
+ * installs signal handlers that call it once and let the event loop drain.
+ */
+export declare function createGracefulShutdown(cleanup: ShutdownCleanup): ShutdownHandle;
+//# sourceMappingURL=shutdown-cleanup.d.ts.map

package/dist/shutdown-cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown-cleanup.d.ts","sourceRoot":"","sources":["../src/shutdown-cleanup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,mEAAmE;IACnE,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,uCAAuC;IACvC,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,4DAA4D;IAC5D,IAAI,cAAc,IAAI,OAAO,CAAC;CAC/B;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,eAAe,GAAG,cAAc,CAqD/E"}

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

@@ -0,0 +1,23 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * /acp — discover and drive the ACP-supporting coding CLIs installed on this
+ * machine (Claude Code, Codex CLI, Gemini CLI, OpenCode, …) from inside the
+ * WrongStack interface. These external agents run as subprocesses using THEIR
+ * OWN login, so you exploit them without spending API credits here.
+ *
+ *   /acp                         list detected agents (✓ installed / ✗ missing)
+ *   /acp <agent-id> <task>       run a task on one agent (inline, streamed)
+ *   /acp <agent-id> --bg <task>  run it as a background fleet subagent
+ *   /acp parallel <csv> <task>   fan a task out to several agents at once
+ *   /acp probe [csv]             handshake-test agents (what actually works)
+ *   /acp bench [csv] [--fs]      end-to-end verify each agent + graded report
+ *   /acp sync                    pull the official agentclientprotocol/registry
+ *   /acp help
+ *
+ * The agent list comes from the official registry
+ * (https://github.com/agentclientprotocol/registry) once synced — cached
+ * locally and merged over the bundled offline catalog.
+ */
+export declare function buildAcpCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=acp.d.ts.map

package/dist/slash-commands/acp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp.d.ts","sourceRoot":"","sources":["../../src/slash-commands/acp.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAOrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CA0DvE"}

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

@@ -0,0 +1,16 @@
+/**
+ * `/agents` — agent monitoring and timeline streaming commands.
+ *
+ * Commands:
+ *   /agents               — Show legacy subagent status
+ *   /agents help          — Show detailed help
+ *   /agents stream on     — Show agent conversations in the main chat timeline
+ *   /agents stream off    — Hide agent conversations from the main chat
+ *   /agents stream status — Show current stream state
+ *   /agents list          — List all active subagents
+ *   /agents show <id>     — Show transcript for a specific agent
+ */
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+export declare function buildAgentsCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=agents.d.ts.map

package/dist/slash-commands/agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/slash-commands/agents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAiBtD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAoI1E"}

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

@@ -0,0 +1,11 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * /audit — opens the TUI AuditPanel overlay showing the side-effect
+ * timeline (bash commands, package installs, network requests).
+ *
+ * P2 #5 Phase 4: in the REPL (non-TUI) context, falls back to the /diag
+ * output which already includes the side-effect section.
+ */
+export declare function buildAuditCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=audit.d.ts.map

package/dist/slash-commands/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../src/slash-commands/audit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAmEzE"}

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

@@ -0,0 +1,20 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * `/auth` — manage provider credentials.
+ *
+ * In the TUI, a bare `/auth` opens the interactive auth panel (providers,
+ * key CRUD, catalog/local/custom adds, OAuth sign-in) via the panel-open
+ * bridge — the same UX as `wstack auth`, embedded in the session. `/auth
+ * login` jumps straight to the OAuth sign-in view.
+ *
+ * In the plain REPL (no TUI mounted) the command falls back to a
+ * read-only dashboard and points at `wstack auth`:
+ *   /auth                  Show saved providers and key status
+ *   /auth login            Open OAuth sign-in (TUI) / show hint (REPL)
+ *   /auth status <id>      Show detail for one provider
+ *   /auth open             Open the panel (TUI) / show launch hint (REPL)
+ *   /auth help             Show this help
+ */
+export declare function buildAuthCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=auth.d.ts.map

package/dist/slash-commands/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/slash-commands/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAwCtD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAwMxE"}

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

@@ -0,0 +1,5 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+export type AutonomyMode = 'off' | 'suggest' | 'auto' | 'eternal' | 'eternal-parallel';
+export declare function buildAutonomyCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=autonomy.d.ts.map

package/dist/slash-commands/autonomy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autonomy.d.ts","sourceRoot":"","sources":["../../src/slash-commands/autonomy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,kBAAkB,CAAC;AAkBvF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAwP5E"}

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

@@ -0,0 +1,13 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * Build the /autophase slash command.
+ *
+ * AutoPhase turns a free-text goal into a real, LLM-driven build: the host
+ * plans phases (each holding many todos), persists the phase-graph as
+ * per-project JSON under ~/.wrongstack/projects/<hash>/autophase, and drives
+ * the orchestrator — one subagent per task — in the background. Live progress
+ * is shown in the TUI PhaseMonitor.
+ */
+export declare function buildAutoPhaseCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=autophase.d.ts.map

package/dist/slash-commands/autophase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autophase.d.ts","sourceRoot":"","sources":["../../src/slash-commands/autophase.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAA6B,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGhF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAiEtD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CA+J7E"}

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

@@ -0,0 +1,4 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+export declare function buildBrainCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=brain.d.ts.map

package/dist/slash-commands/brain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain.d.ts","sourceRoot":"","sources":["../../src/slash-commands/brain.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAiB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAWtD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CA6HzE"}

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

@@ -0,0 +1,13 @@
+import { type SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * `/btw <note>` — non-aborting mid-run steering ("by the way").
+ *
+ * Stashes a short note on the live run context. Unlike `/steer` (which aborts
+ * the iteration and prepends a heavy STEERING preamble), `/btw` lets the agent
+ * keep working and folds the note in at the start of its next iteration —
+ * between tool batches. If no run is active, the note rides along on the next
+ * turn the agent takes.
+ */
+export declare function buildBtwCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=btw.d.ts.map

package/dist/slash-commands/btw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"btw.d.ts","sourceRoot":"","sources":["../../src/slash-commands/btw.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,YAAY,EAAc,MAAM,kBAAkB,CAAC;AAClF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAqCvE"}

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

@@ -0,0 +1,4 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+export declare function buildClearCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=clear.d.ts.map

package/dist/slash-commands/clear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear.d.ts","sourceRoot":"","sources":["../../src/slash-commands/clear.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CA6CzE"}

package/dist/slash-commands/codebase-reindex.d.ts

@@ -0,0 +1,11 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * `/codebase-reindex` — manually refresh the `codebase-search` symbol index.
+ *
+ * Incremental by default (unchanged files skipped via mtime); `force` clears and
+ * rebuilds from scratch. Runs through the shared background indexer's mutex, so
+ * it serializes safely with the session-start scan and live per-edit reindexes.
+ */
+export declare function buildCodebaseReindexCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=codebase-reindex.d.ts.map

package/dist/slash-commands/codebase-reindex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codebase-reindex.d.ts","sourceRoot":"","sources":["../../src/slash-commands/codebase-reindex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAG9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGtD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAsCnF"}

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

@@ -0,0 +1,26 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * /collab — operator-side controls for the live-collaboration feature
+ * (Phase 1 of idea #13 from IDEAS.md).
+ *
+ * The CLI doesn't speak the WebSocket protocol itself — the *observer*
+ * client is a browser (webui). But the CLI user is the agent's owner
+ * and needs to know:
+ *
+ *   - Is anyone watching this session right now?
+ *   - How do I give someone a link to join?
+ *   - What's been happening (so I can summarize for a teammate)?
+ *
+ * That's what these three subcommands do. The "actual join" flow
+ * lives in the webui's `CollabPanel`.
+ *
+ * Note: the observer count is currently best-effort. The webui server
+ * keeps a live participant list per session but the CLI doesn't see
+ * that state directly. For now we show "observer count: unknown" and
+ * the invite URL; a future iteration can pipe the count through the
+ * kernel's EventBus (e.g. by listening to `collab.participant.joined`
+ * in the CLI's own EventBus subscriber).
+ */
+export declare function buildCollabCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=collab.d.ts.map

package/dist/slash-commands/collab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collab.d.ts","sourceRoot":"","sources":["../../src/slash-commands/collab.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAgC1E"}

package/dist/slash-commands/commit-llm.d.ts

@@ -0,0 +1,41 @@
+/**
+ * LLM-powered commit message generation.
+ * Generates proper commit messages by analyzing git diffs via the configured LLM provider.
+ */
+export interface CommitLLMProvider {
+    complete(req: {
+        model: string;
+        system?: {
+            type: 'text' | undefined;
+            text: string;
+        }[];
+        messages: {
+            role: string;
+            content: {
+                type: 'text';
+                text: string;
+            }[];
+        }[];
+        maxTokens: number;
+        temperature?: number | undefined;
+    }, opts: {
+        signal: AbortSignal;
+    }): Promise<{
+        /** Normalized content blocks (Anthropic/OpenAI compatible) */
+        content: {
+            type: 'text';
+            text: string;
+        }[];
+        model: string;
+    }>;
+}
+export interface CommitLLMOpts {
+    provider: CommitLLMProvider;
+    model: string;
+}
+/**
+ * Generate a proper commit message by asking the LLM to analyze the diff.
+ * Falls back to heuristics on failure.
+ */
+export declare function generateCommitMessageWithLLM(diff: string, opts: CommitLLMOpts): Promise<string>;
+//# sourceMappingURL=commit-llm.d.ts.map

package/dist/slash-commands/commit-llm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-llm.d.ts","sourceRoot":"","sources":["../../src/slash-commands/commit-llm.ts"],"names":[],"mappings":"AACA;;;GAGG;AAEH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CACN,GAAG,EAAE;QACH,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE;YAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QACtD,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE;gBAAE,IAAI,EAAE,MAAM,CAAC;gBAAC,IAAI,EAAE,MAAM,CAAA;aAAE,EAAE,CAAA;SAAE,EAAE,CAAC;QACxE,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;KAClC,EACD,IAAI,EAAE;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,GAC5B,OAAO,CAAC;QACT,8DAA8D;QAC9D,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QAC1C,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,MAAM,CAAC,CAsCjB"}

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

@@ -0,0 +1,4 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+export declare function buildCompactCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=compact.d.ts.map

package/dist/slash-commands/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../src/slash-commands/compact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CA6D3E"}

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

@@ -0,0 +1,4 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+export declare function buildContextCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/slash-commands/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAWtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAiL3E"}

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

@@ -0,0 +1,4 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+export declare function buildCoordinatorCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=coordinator.d.ts.map

package/dist/slash-commands/coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinator.d.ts","sourceRoot":"","sources":["../../src/slash-commands/coordinator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAuL/E"}

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

@@ -0,0 +1,17 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * /delegate — user-facing counterpart to the AI's `delegate` tool.
+ *
+ * Hands a task to a subagent. With --role, spawns that specific role.
+ * Without --role, uses smart dispatch (heuristic + LLM classifier) to
+ * pick the best agent — same engine as /fleet dispatch.
+ *
+ * Usage:
+ *   /delegate [--role=<role>] [--name=<label>] <task description>
+ *   /delegate list                      List available roles
+ *
+ * Requires director mode. Run /director first.
+ */
+export declare function buildDelegateCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=delegate.d.ts.map

package/dist/slash-commands/delegate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate.d.ts","sourceRoot":"","sources":["../../src/slash-commands/delegate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGtD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CA8H5E"}

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

@@ -0,0 +1,16 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * `/design` — manual control over the Design Studio kit picker.
+ *
+ *   /design                 list kits + show the active one
+ *   /design <kit-id> [stack] pin a kit and load its full spec next turn
+ *   /design off             clear the active kit (detection stays on)
+ *   /design foundations     print the mandatory baseline
+ *
+ * Pinning sets `ctx.meta.designStudio.activeKit` so the per-turn request
+ * middleware switches to the adherence reminder, and emits `runText` so the
+ * model loads the full kit body via the `design` tool on the next turn.
+ */
+export declare function buildDesignCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=design.d.ts.map

package/dist/slash-commands/design.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"design.d.ts","sourceRoot":"","sources":["../../src/slash-commands/design.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAerD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAYtD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAuH1E"}

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

@@ -0,0 +1,9 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * `/dev <shell command>` — execute a shell command from the chat input and
+ * display its output. The LLM does NOT see the result — this is a developer
+ * convenience shortcut, not a tool invocation.
+ */
+export declare function buildDevCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=dev.d.ts.map

package/dist/slash-commands/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/slash-commands/dev.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAW,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAE9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAkGtD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CA6CvE"}

package/dist/slash-commands/diag-stats.d.ts

@@ -0,0 +1,5 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+export declare function buildDiagCommand(opts: SlashCommandContext): SlashCommand;
+export declare function buildStatsCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=diag-stats.d.ts.map

package/dist/slash-commands/diag-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diag-stats.d.ts","sourceRoot":"","sources":["../../src/slash-commands/diag-stats.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAUxE;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAWzE"}

package/dist/slash-commands/dispatch-llm.d.ts

@@ -0,0 +1,12 @@
+/**
+ * LLM-backed classifier for the smart agent dispatcher.
+ *
+ * Wraps the session provider in the `complete(prompt) => text` shape that
+ * `makeLLMClassifier` expects, so `/fleet dispatch` can fall back to the model
+ * when the heuristic router is ambiguous. Mirrors the one-shot completion
+ * pattern used by `generateCommitMessageWithLLM`.
+ */
+import { type DispatchClassifier } from '@wrongstack/core';
+import type { CommitLLMProvider } from './commit-llm.js';
+export declare function makeProviderClassifier(provider: CommitLLMProvider, model: string): DispatchClassifier;
+//# sourceMappingURL=dispatch-llm.d.ts.map

package/dist/slash-commands/dispatch-llm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-llm.d.ts","sourceRoot":"","sources":["../../src/slash-commands/dispatch-llm.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,KAAK,kBAAkB,EAAqB,MAAM,kBAAkB,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,MAAM,GACZ,kBAAkB,CA8BpB"}

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

@@ -0,0 +1,13 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * `/doctor` — diagnose and auto-repair the persisted config files.
+ *
+ * Report mode (bare `/doctor`) never writes anything. `/doctor fix` backs the
+ * file up first (config.json.last + a timestamped .bak, the same convention
+ * config-history uses), then writes the repaired config and mirrors it into
+ * the in-memory store. A config that fails to parse at all is restored from
+ * the newest parsable backup.
+ */
+export declare function buildDoctorCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/slash-commands/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/slash-commands/doctor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAMrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGtD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CA8N1E"}

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

@@ -0,0 +1,13 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * `/enhance` — toggle prompt refinement ("did you mean this?").
+ *
+ * When on, free-text prompts are rewritten by a separate one-shot LLM call into
+ * a clearer instruction and briefly previewed before reaching the main agent.
+ * The live toggle is flipped via the shared `enhanceController` (the TUI
+ * installs a dispatch-backed setter on mount); the choice is persisted to
+ * `config.autonomy.enhance` so it survives restarts.
+ */
+export declare function buildEnhanceCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=enhance.d.ts.map

package/dist/slash-commands/enhance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhance.d.ts","sourceRoot":"","sources":["../../src/slash-commands/enhance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAiF3E"}

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

@@ -0,0 +1,17 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * /ensemble <agent-csv> <task description>
+ *
+ * Fan a single task out to multiple ACP-supporting agents in parallel.
+ * Each agent runs in its own process; the command waits for all of them
+ * and reports per-agent outcomes.
+ *
+ * Examples:
+ *   /ensemble claude-code,gemini-cli "review this diff"
+ *   /ensemble claude-code,codex-cli "refactor auth/session.ts"
+ *
+ * Run /ensemble (no args) to see usage and the list of available agents.
+ */
+export declare function buildEnsembleCommand(_opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=ensemble.d.ts.map

package/dist/slash-commands/ensemble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensemble.d.ts","sourceRoot":"","sources":["../../src/slash-commands/ensemble.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,mBAAmB,GAAG,YAAY,CAgF7E"}

package/dist/slash-commands/f-keys.d.ts

@@ -0,0 +1,18 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * Build the `/f` slash command and its hidden `/f1`–`/f12` aliases.
+ *
+ * - `/f` (no args) — list numbered F-key options
+ * - `/f 1` … `/f 12` — open the corresponding panel
+ * - `/f1` … `/f12` — same as above (hidden aliases, not shown in the picker)
+ *
+ * The TUI handles panel opening via `onPanelOpen`; the REPL shows a message.
+ */
+export declare function buildFKeysCommand(opts: SlashCommandContext): SlashCommand;
+/**
+ * Build hidden `/f1`–`/f12` alias commands.
+ * These are registered individually so typing `/f1` (no space) also works.
+ */
+export declare function buildFKeyAliasCommands(opts: SlashCommandContext): SlashCommand[];
+//# sourceMappingURL=f-keys.d.ts.map

package/dist/slash-commands/f-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"f-keys.d.ts","sourceRoot":"","sources":["../../src/slash-commands/f-keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAsBtD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAiCzE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,EAAE,CAgBhF"}

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

@@ -0,0 +1,20 @@
+import { type SlashCommand } from '@wrongstack/core';
+import type { SlashCommandContext } from './index.js';
+/**
+ * `/fallback` — view or change the cross-provider fallback chain that the
+ * agent rotates to when the primary model is rate-limited / overloaded
+ * (429/529/5xx) and its own retries are exhausted. Argument-driven (never
+ * blocks on readline) so it behaves identically in the REPL and the TUI.
+ * Persists to ~/.wrongstack/config.json.
+ *
+ * Subcommands:
+ *   (none)              Show the active chain (explicit or smart-default
+ *                       preview) and the smart-default toggle.
+ *   add <provider/model> Append a model reference to the explicit chain.
+ *   remove <n|ref>      Remove by 1-based index or by exact reference.
+ *   clear               Empty the explicit chain (smart default takes over
+ *                       again when `auto` is on).
+ *   auto on|off         Toggle the smart default (config.fallbackAuto).
+ */
+export declare function buildFallbackCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=fallback.d.ts.map