@wrongstack/cli 1.1.4 → 1.1.6

package/dist/tuneup-types.d.ts

@@ -0,0 +1,118 @@
+import type { Config } from '@wrongstack/core/types';
+import type { UpdateInfo } from './update-check.js';
+type TuneupSeverity = 'error' | 'warning' | 'info' | 'ok';
+/** Stable check-group ids — one section per group in the rendered report. */
+export type TuneupCategory = 'version' | 'autonomy' | 'skills' | 'mcp' | 'plugins' | 'memory' | 'hooks' | 'permissions' | 'performance' | 'reliability' | 'config';
+/**
+ * A structured, deterministic repair the command knows how to apply.
+ * `set-config` is the generic one — a dot-path into the global config plus the
+ * value to set — so most knobs need no bespoke apply logic.
+ */
+export type TuneupAction = {
+    kind: 'set-config';
+    path: string[];
+    value: unknown;
+    label: string;
+} | {
+    kind: 'add-exec-allow';
+    commands: string[];
+} | {
+    kind: 'normalize-hook-timeout';
+    event: string;
+    index: number;
+    timeoutMs: number;
+};
+export interface TuneupFinding {
+    category: TuneupCategory;
+    severity: TuneupSeverity;
+    /** One-line problem statement. */
+    problem: string;
+    /** Optional human hint about the recommended action. */
+    suggestion?: string | undefined;
+    /** Present when a deterministic auto-fix exists; short description shown in the report. */
+    fix?: string | undefined;
+    /** Machine-readable descriptor the command applies on `/tuneup fix`. */
+    action?: TuneupAction | undefined;
+    /** A line folded into the agent follow-up turn (fuzzy items with no mechanical fix). */
+    handoff?: string | undefined;
+}
+/** A discovered skill, reduced to what the checks need. */
+export interface TuneupSkill {
+    name: string;
+    source: string;
+    /** Body length in chars, when the command could read it (best-effort). */
+    bodyChars?: number | undefined;
+}
+/** Live MCP server status, reduced from `mcpRegistry.describe()`. */
+interface TuneupMcpServer {
+    name: string;
+    state: string;
+    enabled: boolean;
+    toolCount: number;
+}
+/** An instruction/memory file layer to compare + size-check. */
+export interface TuneupMemoryFile {
+    /** Human label, e.g. "user memory" or "project AGENTS.md". */
+    label: string;
+    path: string;
+    content: string;
+    /** True for committed/shared layers (project AGENTS.md, root CLAUDE.md). */
+    committed: boolean;
+}
+/** The persistent permission trust file, `~/.wrongstack/projects/<hash>/trust.json`. */
+export type TuneupTrustPolicy = Record<string, {
+    allow?: string[] | undefined;
+    deny?: string[] | undefined;
+    auto?: boolean | undefined;
+}>;
+/** Ambient facts the command precomputes (host / disk / env) for the checks. */
+interface TuneupEnv {
+    /** Logical CPU count, for the maxConcurrent sanity check. */
+    cpuCount?: number | undefined;
+    /** Number of configured providers, for the fallback-chain check. */
+    providerCount?: number | undefined;
+    /** Whether the secret vault is passphrase-hardened at rest. */
+    vaultHardened?: boolean | undefined;
+    /** Total bytes of on-disk session logs for this project (disk-hygiene check). */
+    sessionBytes?: number | undefined;
+}
+export interface TuneupInput {
+    config: Config;
+    skills: TuneupSkill[];
+    /** `config.skills.eagerMaxChars` or its default. */
+    eagerMaxChars: number;
+    skillMode: 'eager' | 'progressive';
+    /** Live MCP status when the host wired `mcpStatus`; undefined → skip live MCP checks. */
+    mcp?: TuneupMcpServer[] | undefined;
+    /** Instruction-file layers (user memory, project AGENTS.md, root CLAUDE.md/AGENTS.md). */
+    memoryFiles: TuneupMemoryFile[];
+    /** Self-update info (from `checkForUpdate`), when the version check ran. */
+    update?: UpdateInfo | undefined;
+    /** Parsed trust file, when present. */
+    trust?: TuneupTrustPolicy | undefined;
+    /**
+     * Denied read-only commands mined from session history (optional richer
+     * signal). Each entry is a command line and how many times it was denied.
+     */
+    deniedFromHistory?: Array<{
+        command: string;
+        count: number;
+    }> | undefined;
+    /** Ambient host/disk facts. */
+    env?: TuneupEnv | undefined;
+    /** Count of `/doctor`-style config issues (from `diagnoseConfig`). */
+    configIssues?: number | undefined;
+    /**
+     * Power profile: `/tuneup fix --power`. Gates the autonomy/yolo/director
+     * actions so a plain tune-up never flips them (respects the user-owned
+     * autonomy invariant).
+     */
+    power?: boolean | undefined;
+}
+export interface TuneupReport {
+    findings: TuneupFinding[];
+    /** Composed agent follow-up prompt for fuzzy items; empty when none. */
+    agentHandoff: string;
+}
+export {};
+//# sourceMappingURL=tuneup-types.d.ts.map

package/dist/tuneup.d.ts

@@ -1,3 +1,6 @@
+import type { TuneupFinding, TuneupInput, TuneupReport } from './tuneup-types.js';
+export { checkPerformance, checkPermissions, checkReliability, isReadOnlyCommand, } from './tuneup-runtime-checks.js';
+export type { TuneupAction, TuneupCategory, TuneupFinding, TuneupInput, TuneupMemoryFile, TuneupSkill, TuneupTrustPolicy, } from './tuneup-types.js';
 /**
  * Tune-up engine — deterministic health, context-cost, and performance checks
  * for a WrongStack session, mapping the "clean up + speed up your setup" idea
@@ -17,126 +20,8 @@
  *   - `handoff` — a line folded into an agent follow-up turn for the fuzzy,
  *                 judgement-heavy items (instruction-file dedup / split).
  */
-import type { Config } from '@wrongstack/core/types';
-import type { UpdateInfo } from './update-check.js';
-type TuneupSeverity = 'error' | 'warning' | 'info' | 'ok';
-/** Stable check-group ids — one section per group in the rendered report. */
-export type TuneupCategory = 'version' | 'autonomy' | 'skills' | 'mcp' | 'plugins' | 'memory' | 'hooks' | 'permissions' | 'performance' | 'reliability' | 'config';
-/**
- * A structured, deterministic repair the command knows how to apply.
- * `set-config` is the generic one — a dot-path into the global config plus the
- * value to set — so most knobs need no bespoke apply logic.
- */
-export type TuneupAction = {
-    kind: 'set-config';
-    path: string[];
-    value: unknown;
-    label: string;
-} | {
-    kind: 'add-exec-allow';
-    commands: string[];
-} | {
-    kind: 'normalize-hook-timeout';
-    event: string;
-    index: number;
-    timeoutMs: number;
-};
-export interface TuneupFinding {
-    category: TuneupCategory;
-    severity: TuneupSeverity;
-    /** One-line problem statement. */
-    problem: string;
-    /** Optional human hint about the recommended action. */
-    suggestion?: string | undefined;
-    /** Present when a deterministic auto-fix exists; short description shown in the report. */
-    fix?: string | undefined;
-    /** Machine-readable descriptor the command applies on `/tuneup fix`. */
-    action?: TuneupAction | undefined;
-    /** A line folded into the agent follow-up turn (fuzzy items with no mechanical fix). */
-    handoff?: string | undefined;
-}
-/** A discovered skill, reduced to what the checks need. */
-export interface TuneupSkill {
-    name: string;
-    source: string;
-    /** Body length in chars, when the command could read it (best-effort). */
-    bodyChars?: number | undefined;
-}
-/** Live MCP server status, reduced from `mcpRegistry.describe()`. */
-interface TuneupMcpServer {
-    name: string;
-    state: string;
-    enabled: boolean;
-    toolCount: number;
-}
-/** An instruction/memory file layer to compare + size-check. */
-export interface TuneupMemoryFile {
-    /** Human label, e.g. "user memory" or "project AGENTS.md". */
-    label: string;
-    path: string;
-    content: string;
-    /** True for committed/shared layers (project AGENTS.md, root CLAUDE.md). */
-    committed: boolean;
-}
-/** The persistent permission trust file, `~/.wrongstack/projects/<hash>/trust.json`. */
-export type TuneupTrustPolicy = Record<string, {
-    allow?: string[] | undefined;
-    deny?: string[] | undefined;
-    auto?: boolean | undefined;
-}>;
-/** Ambient facts the command precomputes (host / disk / env) for the checks. */
-interface TuneupEnv {
-    /** Logical CPU count, for the maxConcurrent sanity check. */
-    cpuCount?: number | undefined;
-    /** Number of configured providers, for the fallback-chain check. */
-    providerCount?: number | undefined;
-    /** Whether the secret vault is passphrase-hardened at rest. */
-    vaultHardened?: boolean | undefined;
-    /** Total bytes of on-disk session logs for this project (disk-hygiene check). */
-    sessionBytes?: number | undefined;
-}
-export interface TuneupInput {
-    config: Config;
-    skills: TuneupSkill[];
-    /** `config.skills.eagerMaxChars` or its default. */
-    eagerMaxChars: number;
-    skillMode: 'eager' | 'progressive';
-    /** Live MCP status when the host wired `mcpStatus`; undefined → skip live MCP checks. */
-    mcp?: TuneupMcpServer[] | undefined;
-    /** Instruction-file layers (user memory, project AGENTS.md, root CLAUDE.md/AGENTS.md). */
-    memoryFiles: TuneupMemoryFile[];
-    /** Self-update info (from `checkForUpdate`), when the version check ran. */
-    update?: UpdateInfo | undefined;
-    /** Parsed trust file, when present. */
-    trust?: TuneupTrustPolicy | undefined;
-    /**
-     * Denied read-only commands mined from session history (optional richer
-     * signal). Each entry is a command line and how many times it was denied.
-     */
-    deniedFromHistory?: Array<{
-        command: string;
-        count: number;
-    }> | undefined;
-    /** Ambient host/disk facts. */
-    env?: TuneupEnv | undefined;
-    /** Count of `/doctor`-style config issues (from `diagnoseConfig`). */
-    configIssues?: number | undefined;
-    /**
-     * Power profile: `/tuneup fix --power`. Gates the autonomy/yolo/director
-     * actions so a plain tune-up never flips them (respects the user-owned
-     * autonomy invariant).
-     */
-    power?: boolean | undefined;
-}
-interface TuneupReport {
-    findings: TuneupFinding[];
-    /** Composed agent follow-up prompt for fuzzy items; empty when none. */
-    agentHandoff: string;
-}
 /** Default eager skill-body budget (mirrors `SkillsConfig.eagerMaxChars`). */
 export declare const DEFAULT_EAGER_MAX_CHARS = 24000;
-/** True when `command` is safely read-only by our conservative heuristic. */
-export declare function isReadOnlyCommand(command: string): boolean;
 export declare function checkSkills(input: TuneupInput): TuneupFinding[];
 export declare function checkMcp(input: TuneupInput): TuneupFinding[];
 export declare function checkPlugins(input: TuneupInput): TuneupFinding[];
@@ -146,9 +31,6 @@ export declare function checkHooks(input: TuneupInput): TuneupFinding[];
 export declare function checkAutonomy(input: TuneupInput): TuneupFinding[];
 /** Power-only: yolo + director launch defaults (explicit `--power` opt-in). */
 export declare function checkPowerProfile(input: TuneupInput): TuneupFinding[];
-export declare function checkPermissions(input: TuneupInput): TuneupFinding[];
-export declare function checkPerformance(input: TuneupInput): TuneupFinding[];
-export declare function checkReliability(input: TuneupInput): TuneupFinding[];
 export declare function checkConfigDoctor(input: TuneupInput): TuneupFinding[];
 /** Run every check and compose the report + agent hand-off text. */
 export declare function runTuneup(input: TuneupInput): TuneupReport;
@@ -158,5 +40,4 @@ export declare function runTuneup(input: TuneupInput): TuneupReport;
  * tier). Kept here so it is unit-testable alongside the checks.
  */
 export declare function buildDeepPrompt(report: TuneupReport): string;
-export {};
 //# sourceMappingURL=tuneup.d.ts.map

package/dist/{typesafe-YBEADNAH.js → typesafe-QLSMFU7J.js}

@@ -341,4 +341,4 @@ async function lintConventions(deps, write) {
 export {
   typesafeCmd
 };
-//# sourceMappingURL=typesafe-YBEADNAH.js.map
+//# sourceMappingURL=typesafe-QLSMFU7J.js.map

package/dist/{version-help-RBZC5GZZ.js → version-help-X6CC4CFY.js}

@@ -1,11 +1,11 @@
 import {
   helpCmd,
   versionCmd
-} from "./chunk-6VPWQ4TG.js";
+} from "./chunk-UROB7MK5.js";
 import "./chunk-HKMOIIPQ.js";
 import "./chunk-W23PY4IJ.js";
 export {
   helpCmd,
   versionCmd
 };
-//# sourceMappingURL=version-help-RBZC5GZZ.js.map
+//# sourceMappingURL=version-help-X6CC4CFY.js.map

package/dist/{webui-server-CB64CFDG.js → webui-server-6I6QOECV.js}

@@ -15,8 +15,15 @@ import {
   createHqCommandDispatcher,
   createProjectKanbanAssignHandler,
   createProjectKanbanTransitionHandler,
-  installedBridgeAgents
-} from "./chunk-JKTJSLUT.js";
+  installedBridgeAgents,
+  readCachedWrongForgeInfo,
+  refreshWrongForgeInfoCache,
+  reportWrongForgeQuota
+} from "./chunk-QRWXHGLB.js";
+import {
+  WRONGFORGE_AGENT_ID,
+  resolveWrongForgeEndpoint
+} from "./chunk-PGC44T7N.js";
 import {
   startCliHqConnection
 } from "./chunk-76JE54WD.js";
@@ -26,7 +33,7 @@ import {
 import {
   ACP_LEADER_PROVIDER_ID,
   setAcpLeaderSessionAgents
-} from "./chunk-GKGWPFW2.js";
+} from "./chunk-X4DEQLAZ.js";
 import {
   CLI_VERSION
 } from "./chunk-HKMOIIPQ.js";
@@ -1118,12 +1125,42 @@ function acpLeaderPickable(config) {
     }
   ];
 }
+var HOST_BUILT_LEADERS = /* @__PURE__ */ new Set([ACP_LEADER_PROVIDER_ID, "wrongforge"]);
 function buildAcpLeaderProvider(registry, providerId, config) {
   const type = config.type ?? providerId;
-  if (type !== ACP_LEADER_PROVIDER_ID || !registry?.has(type)) return void 0;
+  if (!HOST_BUILT_LEADERS.has(type) || !registry?.has(type)) return void 0;
   return registry.create({ ...config, type: providerId }, type);
 }
 
+// src/wrongforge-leader/wrongforge-leader-picker.ts
+function wrongForgeLeaderPickable() {
+  const ep = resolveWrongForgeEndpoint();
+  if (!ep) return [];
+  void reportWrongForgeQuota({ endpoint: ep });
+  refreshWrongForgeInfoCache(ep);
+  const info = readCachedWrongForgeInfo();
+  if (!info) return [];
+  return [
+    {
+      id: WRONGFORGE_AGENT_ID,
+      type: WRONGFORGE_AGENT_ID,
+      refreshQuota: () => reportWrongForgeQuota({ endpoint: ep, force: true }),
+      models: info.models.map((id) => {
+        const details = info.modelDetails?.find((model) => model.id === id);
+        return {
+          id,
+          name: id === info.defaultModel ? `${id} (WrongForge default)` : id,
+          description: details?.description || "WrongForge leading the session",
+          ...details ? {
+            reasoningEffortLevels: details.effortLevels,
+            effortSupported: details.effortLevels.length > 0
+          } : {}
+        };
+      })
+    }
+  ];
+}
+
 // src/webui-server/credential-watcher.ts
 import { TOKENS } from "@wrongstack/core/kernel";
 import { watchProviderConfig } from "@wrongstack/core/storage";
@@ -1209,7 +1246,8 @@ function createEmbeddedProviderPlane(input) {
     getDisabledProviders: () => opts.appConfig?.disabledProviders ?? [],
     // `acp` with the installed ACP agents: an agent such as Claude Code can
     // lead a tab like a model (see docs/slash/acp.md).
-    hostProviders: () => acpLeaderPickable(opts.appConfig),
+    // `wrongforge` with the models the machine's WrongForge serves.
+    hostProviders: () => [...acpLeaderPickable(opts.appConfig), ...wrongForgeLeaderPickable()],
     send,
     broadcast,
     log: (m) => console.log(m)
@@ -2496,4 +2534,4 @@ async function runWebUI(opts) {
 export {
   runWebUI
 };
-//# sourceMappingURL=webui-server-CB64CFDG.js.map
+//# sourceMappingURL=webui-server-6I6QOECV.js.map

package/dist/wiring/provider-runtime-setup.d.ts

@@ -8,7 +8,9 @@ export declare function serializeProviderRuntimeSnapshot(snapshot: unknown): str
 type AnyObj = any;
 export interface ProviderRuntimeDeps {
     config: Config;
-    /** Called whenever the function patches config, so the caller stays in sync. */
+    /** Re-run the canonical layered config loader for file-triggered hot reload. */
+    loadConfig: () => Promise<Config>;
+    /** Called whenever the live ConfigStore changes, so the caller stays in sync. */
     onConfigUpdate: (config: Config) => void;
     configStore: AnyObj;
     /** Shared live fallback profile manager from the runtime container. */

package/dist/wiring/session-runtime.d.ts

@@ -47,7 +47,7 @@ interface SessionRuntimeArgs {
     governanceHandle: GovernanceHandle;
 }
 export declare function setupSessionRuntime(args: SessionRuntimeArgs): {
-    errorRing: import("../session-event-wiring.js").ErrorEntry[];
+    errorRing: import("../session-event-wiring-types.js").ErrorEntry[];
     sessionBridge: import("@wrongstack/core/storage").SessionEventBridge;
     stats: SessionStats;
     pipelines: import("@wrongstack/core/agent").AgentPipelines;

package/dist/wrongforge-gateway-UOFBK56J.js

@@ -0,0 +1,92 @@
+import {
+  serveToolGatewayHttp
+} from "./chunk-RN5CFAVQ.js";
+import {
+  createToolGateway,
+  resolveGatewayRegistry
+} from "./chunk-LYWOV4OX.js";
+import "./chunk-W23PY4IJ.js";
+
+// src/fleet/wrongforge-gateway.ts
+import { randomBytes } from "node:crypto";
+var DUPLICATES_OF_WRONGFORGE_TOOLS = [
+  "read",
+  "glob",
+  "grep",
+  "fetch",
+  "read_url_content",
+  "tree"
+];
+var WORKER_WITHHELD_TOOLS = /* @__PURE__ */ new Set([
+  "delegate",
+  "spawn_subagent",
+  "define_subagent",
+  "assign_task",
+  "await_tasks",
+  "roll_up",
+  "ask_subagent",
+  "ask_result",
+  "fleet",
+  "fleet_status",
+  "fleet_emit",
+  "session_note",
+  "session_rename",
+  "terminate_subagent",
+  "terminate_all",
+  "work_complete",
+  "nextsteps",
+  "collab_debug",
+  "plugin_manager",
+  "mcp_control"
+]);
+var gateways = /* @__PURE__ */ new Map();
+function sharedWrongForgeGateway(opts) {
+  const existing = gateways.get(opts.projectRoot);
+  if (existing) return existing;
+  const started = startGateway(opts);
+  gateways.set(opts.projectRoot, started);
+  started.catch(() => {
+    if (gateways.get(opts.projectRoot) === started) gateways.delete(opts.projectRoot);
+  });
+  return started;
+}
+async function startGateway(opts) {
+  const registry = resolveGatewayRegistry(opts.registry, opts.config);
+  const gateway = await createToolGateway({
+    registry,
+    config: opts.config,
+    cwd: opts.projectRoot,
+    projectRoot: opts.projectRoot,
+    yolo: true,
+    ...opts.yoloPlus ? { yoloPlus: opts.yoloPlus } : {},
+    whitelist: new Set(
+      registry.list().map((t) => t.name).filter((name) => !WORKER_WITHHELD_TOOLS.has(name))
+    ),
+    remoteAgent: true,
+    ...opts.log ? { onWarning: opts.log } : {}
+  });
+  const token = randomBytes(24).toString("hex");
+  const handle = await serveToolGatewayHttp({
+    gateway,
+    registry,
+    token,
+    port: 0,
+    host: "127.0.0.1",
+    unref: true,
+    ...opts.log ? { log: opts.log } : {}
+  });
+  return {
+    url: handle.url.replace(/\/+$/, ""),
+    token,
+    list_path: "/v1/tools",
+    call_path: "/v1/tools/{name}/call",
+    name_prefix: "wstack_",
+    deny: DUPLICATES_OF_WRONGFORGE_TOOLS,
+    optional: true
+  };
+}
+export {
+  WORKER_WITHHELD_TOOLS,
+  sharedWrongForgeGateway
+};
+//# sourceMappingURL=wrongforge-gateway-UOFBK56J.js.map

package/dist/wrongforge-leader/wrongforge-leader-gateway.d.ts

@@ -0,0 +1,9 @@
+import type { AcpLeaderHost } from '../acp-leader/acp-leader-host.js';
+import type { WrongForgeGatewaySpec } from '../fleet/wrongforge-client.js';
+export interface LeaderGateway {
+    spec: WrongForgeGatewaySpec;
+    tools: string[];
+    close(): Promise<void>;
+}
+export declare function startLeaderGateway(host: AcpLeaderHost, sessionId: string): Promise<LeaderGateway | undefined>;
+//# sourceMappingURL=wrongforge-leader-gateway.d.ts.map

package/dist/wrongforge-leader/wrongforge-leader-picker.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The machine's WrongForge as a pickable provider for the WebUI: `wrongforge`,
+ * with the models it serves. It has no saved record and no models.dev entry,
+ * so the WebUI pickers only offer it through this list.
+ *
+ * The WebUI asks synchronously, so this reads the cached `/v1/info` list and
+ * refreshes the cache in the background for the next look.
+ */
+import type { PickableHostProvider } from '../acp-leader/acp-leader-picker.js';
+/** The `wrongforge` entry, or none when no WrongForge is set up here or its models are unknown. */
+export declare function wrongForgeLeaderPickable(): PickableHostProvider[];
+//# sourceMappingURL=wrongforge-leader-picker.d.ts.map

package/dist/wrongforge-leader/wrongforge-leader-provider.d.ts

@@ -0,0 +1,56 @@
+import type { AgentContextUsage, Capabilities, Config, Provider, ProviderFactory, Request, Response, StreamEvent } from '@wrongstack/core/types';
+export declare const WRONGFORGE_LEADER_PROVIDER_ID = "wrongforge";
+export interface WrongForgeLeaderProviderOptions {
+    id?: string | undefined;
+    bootConfig: Config;
+    /** Build a WrongStack provider by id, for side requests when `acp.leader.sideModel` is set. */
+    buildProvider(providerId: string, config: Config): Provider | undefined;
+    fetchImpl?: typeof fetch | undefined;
+}
+export declare class WrongForgeLeaderProvider implements Provider {
+    private readonly opts;
+    readonly id: string;
+    readonly capabilities: Capabilities;
+    private readonly sessions;
+    private readonly sideProviders;
+    constructor(opts: WrongForgeLeaderProviderOptions);
+    private config;
+    private client;
+    private info;
+    private model;
+    /**
+     * A side model for a turn WrongForge does not lead. `explicitOnly` (a side
+     * request through `complete()`) takes only the model the user named in
+     * `acp.leader.sideModel`: WrongForge answers those itself (`oneShot`), and
+     * handing them to `fallbackModels[0]` let that model take over the session.
+     * A worker's turn may still fall back to the fallback chain, since `oneShot`
+     * would leave it without tools.
+     */
+    private sideProvider;
+    complete(req: Request, opts: {
+        signal: AbortSignal;
+    }): Promise<Response>;
+    /** WrongForge as a plain model: one step, no tools, its own throwaway session. */
+    private oneShot;
+    stream(req: Request, opts: {
+        signal: AbortSignal;
+    }): AsyncIterable<StreamEvent>;
+    /** The turn's prompt; WrongForge joining a conversation under way gets the turns before it. */
+    private promptText;
+    private wfSessionExists;
+    private sessionFor;
+    private observeContext;
+    /** `/compact` on this route: WrongForge compacts its own session. */
+    compactOwnContext(opts: {
+        sessionId: string;
+        signal: AbortSignal;
+    }): Promise<AgentContextUsage | undefined>;
+    /** Close every session gateway (process shutdown). */
+    closeAll(): Promise<void>;
+}
+/**
+ * Registered with the provider registry at boot. Inert unless the session
+ * names it (`--provider wrongforge`, `/model wrongforge/<model>`).
+ */
+export declare function createWrongForgeLeaderProviderFactory(opts: Omit<WrongForgeLeaderProviderOptions, 'id'>): ProviderFactory;
+//# sourceMappingURL=wrongforge-leader-provider.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/cli",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "license": "MIT",
   "description": "WrongStack CLI — terminal AI coding agent with provider catalog from models.dev. Provides `wrongstack` and `wstack` binaries.",
   "keywords": [