@wrongstack/cli 0.284.1 → 0.286.0

package/dist/subcommands/handlers/bench-run-help.d.ts

@@ -0,0 +1,145 @@
+import type { TerminalRenderer } from '../../renderer.js';
+/**
+ * Per-flag help data for `wstack bench run`.
+ *
+ * The `BENCH_RUN_FLAGS` array is the **single source of truth** for
+ * the `wstack bench run` flag list. It's consumed by:
+ *
+ *   - This file's `renderBenchRunHelpToString()` (renders the
+ *     column-aligned help block)
+ *   - `packages/cli/src/subcommands/handlers/bench.ts`'s
+ *     `benchRun()` function (parses the flags — see the
+ *     `flagStr` / `flagBool` reads there)
+ *   - The `bench:run` deep-help entry in
+ *     `per-subcommand-help.ts` via its `customBody` field
+ *     (delivers the rendered block to every help surface)
+ *
+ * Adding a new flag to `wstack bench run` is a one-line change
+ * here; the parser picks it up automatically and the help block
+ * re-renders with the new flag in place. Drift between the
+ * three surfaces is structurally impossible.
+ *
+ * The flags are organized into three semantic groups:
+ *
+ *   - **Suite selection** — which benchmark suite to run, plus
+ *     suite-specific flags (`--suite`, `--polyglot-dir`,
+ *     `--languages`, `--dataset-dir`, `--docker`)
+ *   - **Model matrix** — which model cells to evaluate
+ *     (`--models`)
+ *   - **Run control** — scaling and output (`--limit`, `--out`,
+ *     `--concurrency`)
+ *
+ * The grouping is reflected in the `group` field of each entry,
+ * which the renderer uses to print a "Flags" section with
+ * subheaders ("Suite selection:", "Model matrix:", "Run control:")
+ * so the help block reads top-to-bottom in the order a user
+ * would configure a run.
+ *
+ * The `kind` field discriminates the parser behavior:
+ *
+ *   - `'boolean'` — the flag accepts `--flag` (sets to true).
+ *     The parser uses `flagBool(deps, name)` to read these.
+ *   - `'value'` — the flag accepts a value (`--flag <value>`).
+ *     The parser reads these via `flagStr(deps, name)` directly.
+ */
+export type BenchRunFlagGroup = 'suite' | 'models' | 'control';
+export interface BenchRunFlag {
+    /** The flag's canonical name (no `--` prefix, no value placeholder). */
+    name: string;
+    /**
+     * The display form, with the `--` prefix and any value
+     * placeholder. For boolean flags, the renderer shows just
+     * `--flag` (no `--no-flag` counterpart — `bench run` flags
+     * are positive-only).
+     */
+    flag: string;
+    /** One-line description shown in the help block. */
+    description: string;
+    /** Which semantic group the flag belongs to. */
+    group: BenchRunFlagGroup;
+    /** Parser shape: `boolean` for toggles, `value` for `--flag <v>`. */
+    kind: 'boolean' | 'value';
+    /**
+     * Default value (only for value-kind flags). Rendered in the
+     * description as `(default: <value>)`. The parser's default
+     * behavior matches — both surfaces stay in sync because the
+     * description is data-driven from the same source.
+     */
+    defaultValue?: string;
+    /**
+     * When `true`, the flag is required (the parser errors out
+     * if it's missing). Rendered as "(required)" in the
+     * description. Only meaningful for value-kind flags.
+     */
+    required?: boolean;
+}
+/**
+ * The flag list — the canonical source of truth for
+ * `wstack bench run`. Order matters: it's the order the flags
+ * render in the help block.
+ */
+export declare const BENCH_RUN_FLAGS: ReadonlyArray<BenchRunFlag>;
+/**
+ * The names of the boolean flags (the parser iterates these to
+ * read each toggle via `flagBool`). The list is derived from
+ * `BENCH_RUN_FLAGS` to keep the two in sync — a new boolean
+ * flag added to `BENCH_RUN_FLAGS` shows up here automatically.
+ */
+export declare const BENCH_RUN_BOOLEAN_FLAG_NAMES: ReadonlyArray<string>;
+/**
+ * The names of the value flags (the parser reads these via
+ * `flagStr` directly). Same derivation strategy as the
+ * boolean list.
+ */
+export declare const BENCH_RUN_VALUE_FLAG_NAMES: ReadonlyArray<string>;
+/**
+ * The width of the flag column in the rendered help block.
+ * Chosen so the longest flag (`--polyglot-dir <path>`) fits
+ * with one space of padding before the description starts.
+ */
+export declare const BENCH_RUN_FLAG_COLUMN_WIDTH = 28;
+/**
+ * Build the `wstack bench run` help block as a string. The
+ * returned string is the exact bytes the renderer would have
+ * written — color codes and all. Used by surfaces that can't
+ * hold a `TerminalRenderer` (slash commands return
+ * `{ message: string }` instead of writing directly) and by
+ * the `bench:run` deep-help entry in `per-subcommand-help.ts`
+ * via its `customBody` field.
+ *
+ * Single source of truth: the body here is the same string
+ * `wstack bench run --help`, `wstack bench run -- --help`,
+ * `/bench run help`, and `/help bench run` all render. Drift
+ * between the four surfaces is structurally impossible.
+ *
+ * The block layout is:
+ *   1. Bold title line
+ *   2. Dimmed description (1-2 lines, wrapped at the call site)
+ *   3. Empty line
+ *   4. Bold "Usage" + the usage line (constructed from
+ *      `BENCH_RUN_FLAGS` so the flag ordering matches the list)
+ *   5. Empty line
+ *   6. Bold "Flags" + the flags, grouped by `group` with
+ *      subheaders ("Suite selection:" / "Model matrix:" /
+ *      "Run control:") when the group changes
+ *   7. Empty line
+ *   8. Dimmed "See also:" line (single line, hardcoded)
+ */
+export declare function renderBenchRunHelpToString(): string;
+/**
+ * Render the `wstack bench run` help block directly to a
+ * renderer. Thin wrapper over `renderBenchRunHelpToString()`
+ * for callers that have a `TerminalRenderer` in hand (e.g.
+ * the `wstack bench run --help` bypass in `bench.ts`).
+ */
+export declare function renderBenchRunHelp(renderer: TerminalRenderer): void;
+/**
+ * Build the `Usage:` line that `benchRun` could write to
+ * stderr if the `--suite polyglot` path is missing the
+ * required `--polyglot-dir` flag. This is a parser-side
+ * fallback; the help block's usage line is the canonical
+ * version. Future refactor opportunity: have the parser
+ * import this function and call it directly.
+ */
+export declare function buildBenchRunUsageLine(): string;
+//# sourceMappingURL=bench-run-help.d.ts.map

package/dist/subcommands/handlers/bench-run-help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bench-run-help.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/bench-run-help.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE/D,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,KAAK,EAAE,iBAAiB,CAAC;IACzB,qEAAqE;IACrE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,aAAa,CAAC,YAAY,CAuEvD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,EAAE,aAAa,CAAC,MAAM,CAE1C,CAAC;AAEtB;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,EAAE,aAAa,CAAC,MAAM,CAExC,CAAC;AAEtB;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAiBnD;AA2DD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAEnE;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C"}

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

@@ -0,0 +1,13 @@
+import type { SubcommandHandler } from '../index.js';
+/**
+ * `wstack bench` — run model-independent agentic benchmarks (local manifests,
+ * Aider polyglot, SWE-bench Verified) with deterministic graders and a harness
+ * fingerprint.
+ *
+ *   wstack bench run    --suite <id> --models <config> [...]
+ *   wstack bench mine   --transcript <session.jsonl> [--out <eval-dir>]
+ *   wstack bench report <dir>
+ *   wstack bench list   [--models <config>]
+ */
+export declare const benchCmd: SubcommandHandler;
+//# sourceMappingURL=bench.d.ts.map

package/dist/subcommands/handlers/bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bench.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/bench.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErE;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,EAAE,iBAgBtB,CAAC"}

package/dist/subcommands/handlers/config-history.d.ts

@@ -0,0 +1,10 @@
+import type { SubcommandHandler } from '../index.js';
+/**
+ * `wrongstack config history` — list history entries or show details.
+ */
+export declare const historyCmd: SubcommandHandler;
+/**
+ * `wrongstack config restore <id>` or `wrongstack config restore --latest`
+ */
+export declare const restoreCmd: SubcommandHandler;
+//# sourceMappingURL=config-history.d.ts.map

package/dist/subcommands/handlers/config-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-history.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/config-history.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,iBA6CxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,iBA2BxB,CAAC"}

package/dist/subcommands/handlers/diag-doctor.d.ts

@@ -0,0 +1,4 @@
+import type { SubcommandHandler } from '../index.js';
+export declare const diagCmd: SubcommandHandler;
+export declare const doctorCmd: SubcommandHandler;
+//# sourceMappingURL=diag-doctor.d.ts.map

package/dist/subcommands/handlers/diag-doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diag-doctor.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/diag-doctor.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGrD,eAAO,MAAM,OAAO,EAAE,iBAuBrB,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,iBAgJvB,CAAC"}

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

@@ -0,0 +1,3 @@
+import type { SubcommandHandler } from '../index.js';
+export declare const exportCmd: SubcommandHandler;
+//# sourceMappingURL=export.d.ts.map

package/dist/subcommands/handlers/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/export.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,eAAO,MAAM,SAAS,EAAE,iBAkDvB,CAAC"}

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

@@ -0,0 +1,2 @@
+export declare function redactKeys(obj: unknown): unknown;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/subcommands/handlers/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/helpers.ts"],"names":[],"mappings":"AAEA,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAShD"}

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

@@ -0,0 +1,3 @@
+import type { SubcommandHandler } from '../index.js';
+export declare const hqCmd: SubcommandHandler;
+//# sourceMappingURL=hq.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hq.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/hq.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOrE,eAAO,MAAM,KAAK,EAAE,iBAoBnB,CAAC"}

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

@@ -0,0 +1,7 @@
+import type { SubcommandHandler } from '../index.js';
+/**
+ * @deprecated Use `wstack auth` instead. The auth command handles provider setup,
+ * key management, and model selection in one interactive workflow.
+ */
+export declare const initCmd: SubcommandHandler;
+//# sourceMappingURL=init.d.ts.map

package/dist/subcommands/handlers/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/init.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,iBAarB,CAAC"}

package/dist/subcommands/handlers/mailbox-serve.d.ts

@@ -0,0 +1,3 @@
+import type { SubcommandHandler } from '../index.js';
+export declare const mailboxServeCmd: SubcommandHandler;
+//# sourceMappingURL=mailbox-serve.d.ts.map

package/dist/subcommands/handlers/mailbox-serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mailbox-serve.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/mailbox-serve.ts"],"names":[],"mappings":"AAoFA,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAwDrE,eAAO,MAAM,eAAe,EAAE,iBAc7B,CAAC"}

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

@@ -0,0 +1,3 @@
+import type { SubcommandHandler } from '../index.js';
+export declare const mcpCmd: SubcommandHandler;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/subcommands/handlers/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/mcp.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrE,eAAO,MAAM,MAAM,EAAE,iBAyCpB,CAAC"}

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

@@ -0,0 +1,3 @@
+import type { SubcommandHandler } from '../index.js';
+export declare const modeldiagCmd: SubcommandHandler;
+//# sourceMappingURL=modeldiag.d.ts.map

package/dist/subcommands/handlers/modeldiag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modeldiag.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/modeldiag.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AA0erD,eAAO,MAAM,YAAY,EAAE,iBA4qB1B,CAAC"}

package/dist/subcommands/handlers/models-add-help.d.ts

@@ -0,0 +1,142 @@
+import type { TerminalRenderer } from '../../renderer.js';
+/**
+ * Per-flag help data for `wstack models add`.
+ *
+ * The `MODELS_ADD_FLAGS` array is the **single source of truth** for
+ * the `wstack models add` flag list. It's consumed by:
+ *
+ *   - This file's `renderModelsAddHelpToString()` (renders the
+ *     column-aligned help block)
+ *   - `packages/cli/src/subcommands/handlers/providers-models.ts`'s
+ *     `modelsAdd()` function (parses the flags — see the
+ *     `parseBoolFlag` / value-flag reads there)
+ *   - The `models:add` deep-help entry in
+ *     `per-subcommand-help.ts` via its `customBody` field
+ *     (delivers the rendered block to every help surface)
+ *
+ * Adding a new flag to `wstack models add` is a one-line change
+ * here; the parser picks it up automatically and the help block
+ * re-renders with the new flag in place. Drift between the
+ * three surfaces is structurally impossible.
+ *
+ * The flags are organized into two semantic groups:
+ *
+ *   - **Identity** — flags that identify the model in the catalog
+ *     (`--provider`, `--name`, plus the `<mid>` positional which
+ *     is shown in the usage line, not in this array).
+ *   - **Capabilities** — flags that describe what the model can do
+ *     (`--max-context`, `--max-output`, `--tools`, `--vision`,
+ *     `--reasoning`, `--streaming`, `--json-mode`).
+ *
+ * The grouping is reflected in the `group` field of each entry,
+ * which the renderer uses to print a "Flags" section with
+ * subheaders ("Identity:" and "Capabilities:") so the help block
+ * reads top-to-bottom in the order a user would set them.
+ *
+ * The `kind` field discriminates the parser behavior:
+ *
+ *   - `'boolean'` — the flag accepts `--flag` (sets to true) and
+ *     `--no-flag` (sets to false). The parser uses
+ *     `parseBoolFlag(flags, flagName)` to read these.
+ *   - `'value'` — the flag accepts a value (`--flag <value>`).
+ *     The parser reads these via `flags[flagName]` directly.
+ */
+export type ModelsAddFlagGroup = 'identity' | 'capabilities';
+export interface ModelsAddFlag {
+    /** The flag's canonical name (no `--` prefix, no value placeholder). */
+    name: string;
+    /**
+     * The display form, with the `--` prefix and any value
+     * placeholder. For boolean flags, the renderer appends the
+     * ` / --no-<name>` counterpart automatically.
+     */
+    flag: string;
+    /** One-line description shown in the help block. */
+    description: string;
+    /** Which semantic group the flag belongs to. */
+    group: ModelsAddFlagGroup;
+    /** Parser shape: `boolean` for toggles, `value` for `--flag <v>`. */
+    kind: 'boolean' | 'value';
+}
+/**
+ * The flag list — the canonical source of truth for `wstack models add`.
+ *
+ * Order matters: it's the order the flags render in the help block,
+ * and the order the parser iterates them when reading boolean values.
+ * The list is grouped by `group` (identity first, then capabilities)
+ * but the renderer preserves the original order and prints subheaders
+ * when the group changes.
+ */
+export declare const MODELS_ADD_FLAGS: ReadonlyArray<ModelsAddFlag>;
+/**
+ * The names of the boolean flags (the parser iterates these to
+ * read each toggle via `parseBoolFlag`). The list is derived from
+ * `MODELS_ADD_FLAGS` to keep the two in sync — a new boolean
+ * flag added to `MODELS_ADD_FLAGS` shows up here automatically.
+ */
+export declare const MODELS_ADD_BOOLEAN_FLAG_NAMES: ReadonlyArray<string>;
+/**
+ * The names of the value flags (the parser reads these via
+ * `flags[name]` directly). Same derivation strategy as the
+ * boolean list.
+ */
+export declare const MODELS_ADD_VALUE_FLAG_NAMES: ReadonlyArray<string>;
+/**
+ * The width of the flag column in the rendered help block.
+ * Chosen so the longest flag (`--max-context <N>`) fits with
+ * one space of padding before the description starts.
+ */
+export declare const MODELS_ADD_FLAG_COLUMN_WIDTH = 30;
+/**
+ * Build the `wstack models add` help block as a string. The
+ * returned string is the exact bytes the renderer would have
+ * written — color codes and all. Used by surfaces that can't
+ * hold a `TerminalRenderer` (slash commands return
+ * `{ message: string }` instead of writing directly) and by
+ * the `models:add` deep-help entry in `per-subcommand-help.ts`
+ * via its `customBody` field.
+ *
+ * Single source of truth: the body here is the same string
+ * `wstack models add --help`, `wstack models add -- --help`,
+ * `/models add help`, and `/help models add` all render. Drift
+ * between the four surfaces is structurally impossible.
+ *
+ * The block layout is:
+ *   1. Bold title line
+ *   2. Dimmed description (1-2 lines, wrapped at the call site)
+ *   3. Empty line
+ *   4. Bold "Usage" + the usage line (constructed from
+ *      `MODELS_ADD_FLAGS` so the flag ordering matches the list)
+ *   5. Empty line
+ *   6. Bold "Flags" + the flags, grouped by `group` with
+ *      subheaders ("Identity:" / "Capabilities:") when the
+ *      group changes
+ *   7. Empty line
+ *   8. Dimmed "See also:" line (single line, hardcoded)
+ */
+export declare function renderModelsAddHelpToString(): string;
+/**
+ * Render the `wstack models add` help block directly to a
+ * renderer. Thin wrapper over `renderModelsAddHelpToString()`
+ * for callers that have a `TerminalRenderer` in hand (e.g.
+ * the `wstack models add --help` bypass in
+ * `providers-models.ts`).
+ */
+export declare function renderModelsAddHelp(renderer: TerminalRenderer): void;
+/**
+ * Build the `Usage:` line that `modelsAdd` writes to stderr
+ * when the `<mid>` positional is missing. This is the parser's
+ * equivalent of the help block's usage line — it should match
+ * what `buildUsageLine()` produces so the two stay in sync.
+ *
+ * The two are not currently auto-derived from the same source
+ * (the parser writes a literal string for the stderr path, the
+ * help block builds it from `MODELS_ADD_FLAGS`). Future refactor
+ * opportunity: have the parser import this function and call it
+ * directly. For now, the test
+ * `modelsAddHelpParity > usage line matches` pins the contract
+ * (a future contributor who changes one without the other fails
+ * the test).
+ */
+export declare function buildModelsAddUsageLine(): string;
+//# sourceMappingURL=models-add-help.d.ts.map

package/dist/subcommands/handlers/models-add-help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models-add-help.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/models-add-help.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,cAAc,CAAC;AAE7D,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,KAAK,EAAE,kBAAkB,CAAC;IAC1B,qEAAqE;IACrE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAAC,aAAa,CAkEzD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,EAAE,aAAa,CAAC,MAAM,CAE3C,CAAC;AAEtB;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,EAAE,aAAa,CAAC,MAAM,CAEzC,CAAC;AAEtB;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,CAiBpD;AA2CD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAEpE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}

package/dist/subcommands/handlers/per-subcommand-help.d.ts

@@ -0,0 +1,136 @@
+import type { TerminalRenderer } from '../../renderer.js';
+/**
+ * One entry per subcommand the user can ask `--help` for. Each
+ * entry is `{ title, description, usage, subcommands?, flags? }`
+ * — the renderer is responsible for the column-aligned output.
+ *
+ * Subcommands with no flags of their own (e.g. `init`, `version`)
+ * just supply title/description/usage. Subcommands with a
+ * subcommand hierarchy (e.g. `mcp`, `plugin`, `models`) supply
+ * a `subcommands` table — a list of `{ name, description }` rows
+ * for the dispatch tree. The user can then run
+ * `wstack <subcommand> <sub-sub> --help` for the focused help of
+ * any deeper level.
+ */
+export interface PerSubcommandHelp {
+    /** The subcommand name as it appears in argv (e.g. 'init', 'mcp'). */
+    name: string;
+    /** Display title for the help block (e.g. 'wstack init — …'). */
+    title: string;
+    /** One-line description of what the command does. */
+    description: string;
+    /** Usage line — `wstack <subcommand> [args]`. */
+    usage: string;
+    /** Optional subcommand table. Empty for subcommands that take no subargs. */
+    subcommands?: ReadonlyArray<{
+        name: string;
+        description: string;
+    }>;
+    /**
+     * Optional "see also" pointer — the most common adjacent
+     * subcommand the user will want to read about. Renders as
+     * a single dim line at the bottom of the help block.
+     */
+    seeAlso?: string;
+    /**
+     * Optional custom body renderer. When set, the standard
+     * title / description / usage / subcommands / seeAlso layout
+     * is **replaced** by whatever this function returns. The
+     * caller is responsible for the full layout — including
+     * the title line, the usage line, and any closing "see
+     * also" pointer.
+     *
+     * **See the top-of-file JSDoc for the full "delegation pattern"
+     * documentation** (when to use, when NOT to use, a worked
+     * example for adding a new delegated entry, and the
+     * single-source-of-truth contract). The worked example walks
+     * through creating a hypothetical `plugin-official-help.ts`
+     * module and wiring it into the `deepHelpTable` via
+     * `customBody`.
+     *
+     * **For the on-ramp guide, see `docs/help-modules.md`**. It
+     * walks through the full pattern (when to write a help
+     * module, the canonical data shape, wiring the dispatcher,
+     * testing, and a worked example) — the canonical reference
+     * for new contributors adding their first help module.
+     *
+     * Use case: a deep-help entry whose help text is already
+     * maintained by a dedicated module (e.g. `auth-local-help.ts`
+     * owns the `wstack auth local` flag list). The deep entry
+     * delegates to that module's renderer so the flag list
+     * stays single-source-of-truth. Setting `customBody` to a
+     * thunk that calls the module's string renderer gives
+     * `/auth local help`, `/help auth local`, and
+     * `wstack auth local --help` the same exact block.
+     *
+     * Note: when `customBody` is set, the `title`, `description`,
+     * `usage`, `subcommands`, and `seeAlso` fields are still
+     * required by the type but are **not rendered** — the
+     * `customBody` function owns the full block. The required
+     * fields exist so the test infrastructure can still iterate
+     * the entry shape uniformly.
+     */
+    customBody?: () => string;
+}
+/**
+ * Build the rendered help text for one entry — the same string that
+ * `renderBlock` would write to a renderer, returned instead of being
+ * emitted. Used by surfaces that can't write directly (slash commands
+ * return `{ message: string }` instead of holding a `TerminalRenderer`).
+ *
+ * Note: the title/description/usage are formatted with ANSI color
+ * codes (from `@wrongstack/core/color`). Surfaces that display the
+ * returned string in a non-ANSI context (a log file, a test assertion)
+ * will see the raw escape codes. Tests should match on substrings,
+ * not the full block; UI surfaces should render to a TTY.
+ */
+export declare function renderBlockToString(help: PerSubcommandHelp): string;
+/**
+ * Render a deep-subcommand focused help block (e.g. for
+ * `wstack mcp add --help`). The key format is `"<top>:<deep>"`
+ * (e.g. `"mcp:add"`). Returns `true` if a block was rendered,
+ * `false` if no deep help is registered for the key — callers
+ * fall back to the top-level help short-circuit.
+ */
+export declare function renderDeepHelp(key: string, renderer: TerminalRenderer): boolean;
+/**
+ * String-returning variant of `renderDeepHelp` for slash commands.
+ * Returns the rendered deep-help text, or `undefined` if the
+ * `<top>:<deep>` key is not in the table.
+ */
+export declare function renderDeepHelpToString(key: string): string | undefined;
+/**
+ * The list of deep-subcommand keys that have focused help blocks.
+ * Same shape as `subcommandsWithFocusedHelp` but for the
+ * `<top>:<deep>` table. Used by tests to assert the contract.
+ */
+export declare const deepSubcommandsWithFocusedHelp: ReadonlyArray<string>;
+/**
+ * Render the focused help block for the given subcommand. Returns
+ * `true` if a block was rendered (the subcommand was found in
+ * the table) and `false` if no focused help exists — callers can
+ * fall back to the generic "see top-level help" message.
+ */
+export declare function renderFocusedHelp(subcommand: string, renderer: TerminalRenderer): boolean;
+/**
+ * String-returning variant of `renderFocusedHelp` for surfaces that
+ * can't hold a `TerminalRenderer` — slash commands return
+ * `{ message: string }` instead of writing directly. Returns the
+ * rendered help text, or `undefined` if the subcommand is not in
+ * the table (callers fall back to the inline `help` field).
+ */
+export declare function renderFocusedHelpToString(subcommand: string): string | undefined;
+/**
+ * The list of subcommand names that have a focused help block.
+ * Subcommands not in this list fall back to the generic
+ * `renderGenericHelp` message — the bypass still works (the user
+ * gets something) but the output is terser.
+ */
+export declare const subcommandsWithFocusedHelp: ReadonlyArray<string>;
+/**
+ * Generic help block for subcommands that don't have a focused
+ * entry in the help table. Tells the user that the subcommand
+ * takes no flags and points at the top-level help for the rest.
+ */
+export declare function renderGenericHelp(subcommand: string, renderer: TerminalRenderer): void;
+//# sourceMappingURL=per-subcommand-help.d.ts.map

package/dist/subcommands/handlers/per-subcommand-help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"per-subcommand-help.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/per-subcommand-help.ts"],"names":[],"mappings":"AA2LA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAK1D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,iBAAiB;IAChC,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,WAAW,CAAC,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,UAAU,CAAC,EAAE,MAAM,MAAM,CAAC;CAC3B;AAGD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAiCnE;AA89BD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAKT;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGtE;AAED;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,EAAE,aAAa,CAAC,MAAM,CACrC,CAAC;AAE7B;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAKT;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,GACjB,MAAM,GAAG,SAAS,CAGpB;AAED;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,EAAE,aAAa,CAAC,MAAM,CACrC,CAAC;AAEzB;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,gBAAgB,GACzB,IAAI,CAaN"}

package/dist/subcommands/handlers/plugin-usage.d.ts

@@ -0,0 +1,4 @@
+import type { SubcommandHandler } from '../index.js';
+export declare const pluginCmd: SubcommandHandler;
+export declare const usageCmd: SubcommandHandler;
+//# sourceMappingURL=plugin-usage.d.ts.map

package/dist/subcommands/handlers/plugin-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-usage.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/plugin-usage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,eAAO,MAAM,SAAS,EAAE,iBAavB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,iBAOtB,CAAC"}

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

@@ -0,0 +1,3 @@
+import type { SubcommandHandler } from '../index.js';
+export declare const projectsCmd: SubcommandHandler;
+//# sourceMappingURL=projects.d.ts.map

package/dist/subcommands/handlers/projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projects.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/projects.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,eAAO,MAAM,WAAW,EAAE,iBAyBzB,CAAC"}

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

@@ -0,0 +1,4 @@
+import type { SubcommandHandler } from '../index.js';
+export declare const providersCmd: SubcommandHandler;
+export declare const modelsCmd: SubcommandHandler;
+//# sourceMappingURL=providers-models.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"providers-models.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/providers-models.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,eAAO,MAAM,YAAY,EAAE,iBA6C1B,CAAC;AAoDF,eAAO,MAAM,SAAS,EAAE,iBA+IvB,CAAC"}

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

@@ -0,0 +1,14 @@
+import type { SubcommandHandler } from '../index.js';
+/**
+ * `wrongstack quick` — launch directly into the TUI with sensible defaults.
+ *
+ * NOTE: The actual handling is done in `boot()` (boot.ts) which intercepts 'quick'
+ * before the subcommand dispatch in cli-main.ts. boot() sets flags.quick and
+ * flags.tui, lists plugins, clears positional, and returns BootContext.
+ * execute() then goes to the TUI path with initialAgentsMonitorOpen: true.
+ *
+ * This handler is kept for completeness (registered in subcommands/index.ts) but
+ * is never called in the `wrongstack quick` flow.
+ */
+export declare const quickCmd: SubcommandHandler;
+//# sourceMappingURL=quick.d.ts.map

package/dist/subcommands/handlers/quick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quick.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/quick.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,EAAE,iBAItB,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { SubcommandHandler } from '../index.js';
+/**
+ * `wstack replay <sessionId>` — convenience wrapper around
+ * `wstack --replay <sessionId>`. Lists the recorded entries for
+ * the session and shows a hint for the user to re-run with
+ * the actual replay flag. Keeps the flag-based path canonical
+ * (so the boot container wiring stays simple) while exposing
+ * a discoverable subcommand for users who type `wstack replay`
+ * expecting it to exist.
+ */
+export declare const replayCmd: SubcommandHandler;
+//# sourceMappingURL=replay.d.ts.map

package/dist/subcommands/handlers/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/replay.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,EAAE,iBA2EvB,CAAC"}

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

@@ -0,0 +1,3 @@
+import type { SubcommandHandler } from '../index.js';
+export declare const rewindCmd: SubcommandHandler;
+//# sourceMappingURL=rewind.d.ts.map

package/dist/subcommands/handlers/rewind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewind.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/rewind.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAwCrD,eAAO,MAAM,SAAS,EAAE,iBA4HvB,CAAC"}

package/dist/subcommands/handlers/sessions-config.d.ts

@@ -0,0 +1,4 @@
+import type { SubcommandHandler } from '../index.js';
+export declare const sessionsCmd: SubcommandHandler;
+export declare const configCmd: SubcommandHandler;
+//# sourceMappingURL=sessions-config.d.ts.map

package/dist/subcommands/handlers/sessions-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions-config.d.ts","sourceRoot":"","sources":["../../../src/subcommands/handlers/sessions-config.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGrE,eAAO,MAAM,WAAW,EAAE,iBAqEzB,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,iBAmBvB,CAAC"}