@wrongstack/cli 1.1.2 → 1.1.5

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-HIUY3RHD.js → webui-server-V2R5WQUK.js}

@@ -14,14 +14,26 @@ import {
 import {
   createHqCommandDispatcher,
   createProjectKanbanAssignHandler,
-  createProjectKanbanTransitionHandler
-} from "./chunk-XT3NAHRX.js";
+  createProjectKanbanTransitionHandler,
+  installedBridgeAgents,
+  readCachedWrongForgeInfo,
+  refreshWrongForgeInfoCache,
+  reportWrongForgeQuota
+} from "./chunk-5SGMUDP5.js";
+import {
+  WRONGFORGE_AGENT_ID,
+  resolveWrongForgeEndpoint
+} from "./chunk-VEESMPTX.js";
 import {
   startCliHqConnection
 } from "./chunk-76JE54WD.js";
 import {
   WebSocketServer
 } from "./chunk-OZCYZYN2.js";
+import {
+  ACP_LEADER_PROVIDER_ID,
+  setAcpLeaderSessionAgents
+} from "./chunk-LUEO5HLZ.js";
 import {
   CLI_VERSION
 } from "./chunk-HKMOIIPQ.js";
@@ -1092,6 +1104,63 @@ import {
   createEmbeddedProviderOperations
 } from "@wrongstack/webui-server";
 
+// src/acp-leader/acp-leader-picker.ts
+import { findAgentDescriptor } from "@wrongstack/acp";
+function acpLeaderPickable(config) {
+  const agents = installedBridgeAgents(config?.acp);
+  if (agents.length === 0) return [];
+  return [
+    {
+      id: ACP_LEADER_PROVIDER_ID,
+      type: ACP_LEADER_PROVIDER_ID,
+      models: agents.map((id) => {
+        const descriptor = findAgentDescriptor(id);
+        return {
+          id,
+          name: descriptor?.displayName ?? id,
+          description: "ACP agent leading the session",
+          ...descriptor?.contextWindow ? { contextWindow: descriptor.contextWindow } : {}
+        };
+      })
+    }
+  ];
+}
+var HOST_BUILT_LEADERS = /* @__PURE__ */ new Set([ACP_LEADER_PROVIDER_ID, "wrongforge"]);
+function buildAcpLeaderProvider(registry, providerId, config) {
+  const type = config.type ?? providerId;
+  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";
@@ -1175,6 +1244,10 @@ function createEmbeddedProviderPlane(input) {
     providerAuthRegistry: opts.providerAuthRegistry,
     getDisabledModels: () => opts.appConfig?.disabledModels ?? [],
     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).
+    // `wrongforge` with the models the machine's WrongForge serves.
+    hostProviders: () => [...acpLeaderPickable(opts.appConfig), ...wrongForgeLeaderPickable()],
     send,
     broadcast,
     log: (m) => console.log(m)
@@ -1308,6 +1381,8 @@ function createWebuiRouteContexts({
     getConfig: () => opts.appConfig,
     onMaxContextResolved: opts.onModelContextResolved,
     persistPrefs,
+    // The ACP leader's factory lives in the CLI's provider registry.
+    buildProvider: (providerId, config) => buildAcpLeaderProvider(opts.agent.providers, providerId, config),
     send,
     broadcast,
     log: (m) => console.log(m)
@@ -2302,6 +2377,7 @@ async function runWebUI(opts) {
     abortControllers
   );
   sessionAgentsRef = sessionAgents;
+  setAcpLeaderSessionAgents((sessionId) => sessionAgents.peek(sessionId));
   const autoWakeHost = opts.leaderAutoWake ? createWebuiLeaderAutoWakeHost({
     controller: opts.leaderAutoWake,
     events: opts.events,
@@ -2458,4 +2534,4 @@ async function runWebUI(opts) {
 export {
   runWebUI
 };
-//# sourceMappingURL=webui-server-HIUY3RHD.js.map
+//# sourceMappingURL=webui-server-V2R5WQUK.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,49 @@
+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 configured side model, when the user named one. */
+    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