@wrongstack/cli 1.1.1 → 1.1.4

package/dist/chunk-COGI7EQU.js

@@ -0,0 +1,1458 @@
+import {
+  wrongstackBridgeSetup
+} from "./chunk-JKTJSLUT.js";
+import {
+  isRestrictedMode
+} from "./chunk-3LEIFO5D.js";
+import {
+  buildProviderForId,
+  resolveProviderCfgWithProxy
+} from "./chunk-UFRVTBV6.js";
+import {
+  ACP_LEADER_PROVIDER_ID,
+  acpLeaderHost,
+  trackAcpLeader
+} from "./chunk-GKGWPFW2.js";
+
+// src/acp-agent-list.ts
+import { REGISTRY_ID_ALIASES } from "@wrongstack/acp";
+function reverseAliases(aliases = REGISTRY_ID_ALIASES) {
+  const out = {};
+  for (const [ours, theirs] of Object.entries(aliases)) {
+    if (ours !== theirs) out[theirs] = ours;
+  }
+  return out;
+}
+function distKind(command) {
+  if (command === "npx") return "npx";
+  if (command === "uvx") return "uvx";
+  return "local";
+}
+function localProbe(registryId, alias, detectedById) {
+  return detectedById.get(registryId) ?? (alias ? detectedById.get(alias) : void 0);
+}
+function formatRegistryRow(agent, alias, local, idWidth) {
+  const kind = distKind(agent.acp.command);
+  const aliasBit = alias ? `  (also ${alias})` : "";
+  if (kind === "local") {
+    if (local?.installed) {
+      const ver = local.version?.split("\n")[0]?.trim();
+      const note2 = ver ? `  ${ver}` : "  on PATH";
+      return `  \u2713 ${agent.id.padEnd(idWidth)}  ${agent.displayName}${aliasBit}${note2}`;
+    }
+    const reason = local?.reason ?? "not on PATH";
+    return `  \u2717 ${agent.id.padEnd(idWidth)}  ${agent.displayName}${aliasBit}  (${reason})`;
+  }
+  const pkg = (agent.acp.args ?? []).find((a) => a !== "-y" && !a.startsWith("--"));
+  const note = pkg ? `${kind} ${pkg}` : kind;
+  return `  \u25B8 ${agent.id.padEnd(idWidth)}  ${agent.displayName}${aliasBit}  ${note}`;
+}
+function formatAcpAgentList(opts) {
+  const { live, detected } = opts;
+  const detectedById = new Map(detected.map((d) => [d.id, d]));
+  if (live && live.agents.length > 0) {
+    const aliasOf = reverseAliases();
+    const when = live.fetchedAt ? live.fetchedAt.slice(0, 19).replace("T", " ") : "locally";
+    const rows = [...live.agents].sort((a, b) => {
+      const rank = (command) => {
+        const k = distKind(command);
+        return k === "local" ? 0 : k === "uvx" ? 1 : 2;
+      };
+      const r = rank(a.acp.command) - rank(b.acp.command);
+      return r !== 0 ? r : a.id.localeCompare(b.id);
+    });
+    const idWidth = Math.max(16, ...rows.map((a) => a.id.length));
+    const lines2 = [
+      `Official ACP registry \u2014 ${live.agents.length} agents (synced ${when}).`,
+      "Spawn ids below are what `/acp <id> <task>` and `/acp <id> --bg` accept.",
+      ""
+    ];
+    for (const agent of rows) {
+      const alias = aliasOf[agent.id];
+      lines2.push(
+        formatRegistryRow(agent, alias, localProbe(agent.id, alias, detectedById), idWidth)
+      );
+    }
+    const leftover = detected.filter((d) => {
+      if (live.byId[d.id]) return false;
+      const mapped = REGISTRY_ID_ALIASES[d.id];
+      return !(mapped && live.byId[mapped]);
+    });
+    if (leftover.length > 0) {
+      lines2.push("");
+      lines2.push("Bundled extras (not in the official registry \u2014 experimental):");
+      for (const d of leftover) {
+        const mark = d.installed ? "\u2713" : "\u2717";
+        const extra = d.installed ? d.version?.split("\n")[0] ?? "" : d.reason ?? "not installed";
+        lines2.push(`  ${mark} ${d.id.padEnd(16)}  ${d.displayName}  (${extra})`);
+      }
+    }
+    lines2.push("");
+    lines2.push(
+      "Spawn: /acp <id> <task>   Background: /acp <id> --bg <task>   Probe: /acp probe <id>"
+    );
+    return lines2.join("\n");
+  }
+  const installed = detected.filter((a) => a.installed);
+  const missing = detected.filter((a) => !a.installed);
+  const lines = [
+    "Bundled offline catalog (not the official registry).",
+    "Run `/acp sync` to replace this list with agentclientprotocol/registry.",
+    ""
+  ];
+  for (const a of installed) {
+    const ver = a.version ? `  (${a.version.split("\n")[0]})` : "";
+    lines.push(`  \u2713 ${a.id.padEnd(16)} ${a.displayName}${ver}`);
+  }
+  for (const a of missing) {
+    lines.push(`  \u2717 ${a.id.padEnd(16)} ${a.displayName}  (${a.reason ?? "not installed"})`);
+  }
+  lines.push("");
+  lines.push(`${installed.length} of ${detected.length} bundled agents installed locally.`);
+  return lines.join("\n");
+}
+
+// src/acp-registry-cache.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { fetchAcpRegistry } from "@wrongstack/acp";
+function acpRegistryCachePath(paths) {
+  return path.join(paths.cacheDir, "acp-registry.json");
+}
+async function loadCachedAcpRegistry(paths) {
+  try {
+    const raw = await fs.readFile(acpRegistryCachePath(paths), "utf8");
+    const env = JSON.parse(raw);
+    if (!Array.isArray(env.agents)) return null;
+    const byId = /* @__PURE__ */ Object.create(null);
+    for (const a of env.agents) {
+      if (!a?.id || !a.acp?.command) continue;
+      byId[a.id] = {
+        command: a.acp.command,
+        args: a.acp.args ?? [],
+        ...a.acp.env ? { env: a.acp.env } : {}
+      };
+    }
+    return { fetchedAt: env.fetchedAt ?? "", byId, agents: env.agents };
+  } catch {
+    return null;
+  }
+}
+async function refreshAcpRegistry(paths, opts) {
+  const result = await fetchAcpRegistry({
+    ...opts?.signal ? { signal: opts.signal } : {},
+    ...opts?.timeoutMs ? { timeoutMs: opts.timeoutMs } : {}
+  });
+  const location = acpRegistryCachePath(paths);
+  await fs.mkdir(path.dirname(location), { recursive: true });
+  const env = { fetchedAt: result.fetchedAt, agents: result.agents };
+  await fs.writeFile(location, JSON.stringify(env), "utf8");
+  return { count: result.agents.length, location, fetchedAt: result.fetchedAt };
+}
+
+// src/shutdown-cleanup.ts
+function createGracefulShutdown(cleanup) {
+  const exitCode = cleanup.exitCode ?? 0;
+  let started = false;
+  let installed = false;
+  const runOnce = (force) => {
+    if (started) {
+      if (force) process.exit(exitCode);
+      return;
+    }
+    started = true;
+    void cleanup.run().catch(() => {
+    }).finally(() => {
+      if (force) {
+        process.exitCode = exitCode;
+        const t = setTimeout(() => process.exit(exitCode), 500);
+        t.unref();
+      }
+    });
+  };
+  const signalHandler = () => runOnce(true);
+  const beforeExitHandler = () => runOnce(false);
+  return {
+    install() {
+      if (installed) return;
+      installed = true;
+      process.once("SIGINT", signalHandler);
+      process.once("SIGTERM", signalHandler);
+      process.once("beforeExit", beforeExitHandler);
+    },
+    uninstall() {
+      if (!installed) return;
+      installed = false;
+      process.removeListener("SIGINT", signalHandler);
+      process.removeListener("SIGTERM", signalHandler);
+      process.removeListener("beforeExit", beforeExitHandler);
+    },
+    get cleanupStarted() {
+      return started;
+    }
+  };
+}
+
+// src/acp-leader/acp-leader-provider.ts
+import { findAgentDescriptor } from "@wrongstack/acp";
+import { consumeBtwNotes as consumeBtwNotes2 } from "@wrongstack/core/agent";
+import { ProviderError as ProviderError2 } from "@wrongstack/core/types";
+import { subjectForToolInput } from "@wrongstack/core/utils";
+
+// src/fleet/acp-permission-bridge.ts
+import { ToolCapabilities } from "@wrongstack/core/security";
+import { toErrorMessage } from "@wrongstack/core/utils";
+var str = (v) => typeof v === "string" && v ? v : void 0;
+var MCP_TOOL = /^mcp__[^_].*__.+/;
+function mcpToolName(call) {
+  const meta = call._meta;
+  const name = str(meta?.claudeCode?.toolName) ?? str(call.title);
+  return name && MCP_TOOL.test(name) ? name : void 0;
+}
+function translate(req) {
+  const call = req.toolCall;
+  const raw = call.rawInput ?? {};
+  const label = str(call.title) ?? call.kind ?? "unknown";
+  const refuse = (why) => ({
+    refuse: why,
+    call: { tool: label, input: raw }
+  });
+  const path3 = str(raw.file_path) ?? str(raw.path) ?? str(raw.notebook_path) ?? call.locations?.[0]?.path;
+  switch (call.kind) {
+    case "execute": {
+      const command = str(raw.command);
+      return command ? { call: { tool: "bash", input: { command } } } : refuse("a command request that names no command");
+    }
+    case "edit":
+      if (!path3) return refuse("an edit that names no file");
+      return typeof raw.old_string === "string" ? {
+        call: {
+          tool: "edit",
+          input: { path: path3, old_string: raw.old_string, new_string: str(raw.new_string) ?? "" }
+        }
+      } : {
+        call: {
+          tool: "write",
+          input: { path: path3, content: typeof raw.content === "string" ? raw.content : "" }
+        }
+      };
+    case "delete":
+      return path3 ? { call: { tool: "bash", input: { command: `rm ${JSON.stringify(path3)}` } } } : refuse("a delete that names no file");
+    case "move": {
+      const to = str(raw.destination) ?? str(raw.new_path) ?? call.locations?.[1]?.path;
+      return path3 && to ? {
+        call: {
+          tool: "bash",
+          input: { command: `mv ${JSON.stringify(path3)} ${JSON.stringify(to)}` }
+        }
+      } : refuse("a move that names no source or destination");
+    }
+    case "read":
+    case "search":
+      return path3 ? { call: { tool: "read", input: { path: path3 } } } : { safe: true };
+    case "fetch": {
+      const host = str(raw.host);
+      const url = str(raw.url) ?? (host ? `https://${host}` : void 0);
+      if (url) return { call: { tool: "fetch", input: { url } } };
+      const query = str(raw.query);
+      return query ? { call: { tool: "fetch", input: { query } } } : refuse("a network request that names no URL or query");
+    }
+    case "think":
+    case "switch_mode":
+      return { safe: true };
+    default: {
+      const mcp = mcpToolName(call);
+      return mcp ? { call: { tool: mcp, input: raw }, mcp: true } : refuse("no WrongStack counterpart to check it against");
+    }
+  }
+}
+function pick(req, allow) {
+  const kinds = allow ? ["allow_once"] : ["reject_once", "reject_always"];
+  const option = req.options.find((o) => kinds.includes(o.kind));
+  return option ? { outcome: "selected", optionId: option.optionId } : { outcome: "cancelled" };
+}
+function mcpToolFor(name) {
+  return { name, capabilities: [ToolCapabilities.MCP_PROXY] };
+}
+function wrongstackAcpPermissionPolicy(opts) {
+  const refuse = (req, call, reason) => {
+    opts.onRefused?.(call, reason);
+    return pick(req, false);
+  };
+  return async (req) => {
+    if (req.signal.aborted) return { outcome: "cancelled" };
+    const translated = translate(req);
+    if ("safe" in translated) return pick(req, true);
+    if ("refuse" in translated) return refuse(req, translated.call, translated.refuse);
+    const { call } = translated;
+    let tool = opts.getTool(call.tool);
+    if (!tool && translated.mcp) {
+      if (opts.allowMcp === false) return refuse(req, call, "MCP tools are off in this run");
+      tool = mcpToolFor(call.tool);
+    }
+    if (!tool) return refuse(req, call, `${call.tool} is not available in this run`);
+    let decision;
+    try {
+      decision = await opts.evaluate(tool, call.input, {
+        projectRoot: opts.projectRoot,
+        cwd: opts.projectRoot
+      });
+    } catch (err) {
+      decision = {
+        permission: "deny",
+        source: "default",
+        reason: `permission check failed: ${toErrorMessage(err)}`
+      };
+    }
+    if (decision.permission === "auto") return pick(req, true);
+    if (decision.permission === "confirm" && opts.confirm) {
+      let approved = false;
+      try {
+        approved = await opts.confirm(tool, call, {
+          toolCallId: req.toolCall.toolCallId,
+          signal: req.signal
+        });
+      } catch {
+        approved = false;
+      }
+      if (req.signal.aborted) return { outcome: "cancelled" };
+      return approved ? pick(req, true) : refuse(req, call, "declined by the user");
+    }
+    return refuse(req, call, decision.reason ?? decision.source);
+  };
+}
+
+// src/fleet/acp-quota-reading.ts
+import { recordProviderQuota } from "@wrongstack/core/quota";
+var WINDOWS = {
+  five_hour: { id: "5h", minutes: 300 },
+  seven_day: { id: "7d", minutes: 10080 },
+  seven_day_opus: { id: "7d opus", minutes: 10080 },
+  seven_day_sonnet: { id: "7d sonnet", minutes: 10080 }
+};
+var lastWindows = /* @__PURE__ */ new Map();
+var num = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : void 0;
+var toSeconds = (v) => Math.trunc(v > 1e12 ? v / 1e3 : v);
+function windowFrom(name, raw) {
+  const spec = WINDOWS[name];
+  if (!spec || !raw || typeof raw !== "object") return void 0;
+  const utilization = num(raw.utilization);
+  if (utilization === void 0) return void 0;
+  const resetsAt = num(raw.resetsAt);
+  return {
+    id: spec.id,
+    label: spec.id,
+    // Sent as a 0..1 fraction; anything above 1 can only be a percent already.
+    usedPercent: Math.min(
+      100,
+      Math.round((utilization <= 1 ? utilization * 100 : utilization) * 100) / 100
+    ),
+    windowMinutes: spec.minutes,
+    ...resetsAt !== void 0 && resetsAt > 0 ? { resetsAt: toSeconds(resetsAt) } : {}
+  };
+}
+function recordAcpRateLimit(agentId, info, now = Date.now()) {
+  const known = lastWindows.get(agentId) ?? /* @__PURE__ */ new Map();
+  const unified = info.unifiedWindows;
+  if (unified && typeof unified === "object") {
+    for (const [name, raw] of Object.entries(unified)) {
+      const window = windowFrom(name, raw);
+      if (window) known.set(window.id, window);
+    }
+  }
+  const type = typeof info.rateLimitType === "string" ? info.rateLimitType : void 0;
+  const reached = info.status === "rejected" && type ? WINDOWS[type]?.id : void 0;
+  if (known.size === 0 && reached === void 0) return;
+  lastWindows.set(agentId, known);
+  recordProviderQuota(
+    agentId,
+    [
+      {
+        providerId: agentId,
+        meterId: "claude",
+        meterLabel: "Claude subscription (delegated worker)",
+        windows: [...known.values()],
+        ...reached !== void 0 ? { reachedWindowId: reached } : {},
+        capturedAt: now
+      }
+    ],
+    now
+  );
+}
+
+// src/fleet/acp-turn-reminders.ts
+import {
+  buildBtwBlock,
+  consumeBtwNotes,
+  pendingBtwCount,
+  setBtwNote
+} from "@wrongstack/core/agent";
+var INBOX_NUDGE = '[WrongStack mailbox] New mail is waiting. Call mcp__wrongstack-mailbox__mailbox_read with action "inbox"; acknowledge messages you handle, then continue your current task.';
+function acpBtwBlock(notes) {
+  const ordinary = notes.filter((note) => !note.startsWith("[MAILBOX BTW]"));
+  const mailWaiting = ordinary.length !== notes.length;
+  return [ordinary.length > 0 ? buildBtwBlock(ordinary) : "", mailWaiting ? INBOX_NUDGE : ""].filter(Boolean).join("\n\n");
+}
+function startAcpTurnReminders(options) {
+  let stopped = false;
+  let btwInFlight = false;
+  let mailInFlight = false;
+  let lastMailNoticeAt = Number.NEGATIVE_INFINITY;
+  let lastMailNoticeCount = 0;
+  const checkBtw = async () => {
+    const context = options.context;
+    if (stopped || btwInFlight || !context || pendingBtwCount(context) === 0) return;
+    btwInFlight = true;
+    const notes = consumeBtwNotes(context);
+    try {
+      const outcome = await options.steer(acpBtwBlock(notes));
+      if (outcome !== "injected") for (const note of notes) setBtwNote(context, note);
+    } catch {
+      for (const note of notes) setBtwNote(context, note);
+    } finally {
+      btwInFlight = false;
+    }
+  };
+  const checkMail = async () => {
+    if (stopped || mailInFlight || !options.unreadCount) return;
+    mailInFlight = true;
+    try {
+      const count = await options.unreadCount();
+      if (stopped || !Number.isFinite(count) || count <= 0) {
+        lastMailNoticeCount = 0;
+        return;
+      }
+      const now = Date.now();
+      if (count === lastMailNoticeCount && now - lastMailNoticeAt < 6e4) return;
+      const outcome = await options.steer(
+        `[WrongStack mailbox] ${count} unread message(s). ${INBOX_NUDGE}`
+      );
+      if (outcome === "injected") {
+        lastMailNoticeCount = count;
+        lastMailNoticeAt = now;
+      }
+    } catch {
+    } finally {
+      mailInFlight = false;
+    }
+  };
+  const btwTimer = options.context ? setInterval(() => void checkBtw(), options.btwPollMs ?? 1e3) : void 0;
+  const mailTimer = options.unreadCount ? setInterval(() => void checkMail(), options.mailPollMs ?? 15e3) : void 0;
+  btwTimer?.unref?.();
+  mailTimer?.unref?.();
+  return () => {
+    stopped = true;
+    if (btwTimer) clearInterval(btwTimer);
+    if (mailTimer) clearInterval(mailTimer);
+  };
+}
+
+// src/acp-leader/acp-leader-confirm.ts
+import { confirmObserverCount } from "@wrongstack/core/agent";
+var ACP_CONFIRM_TIMEOUT_MS = 12e4;
+async function confirmThroughEvents(req) {
+  if (req.events.listenerCount("tool.confirm_needed") - confirmObserverCount() <= 0) return false;
+  const timeoutMs = req.timeoutMs ?? ACP_CONFIRM_TIMEOUT_MS;
+  const answer = await new Promise((resolve) => {
+    let settled = false;
+    const settle = (choice, source) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      req.signal.removeEventListener("abort", onAbort);
+      req.events.emit("tool.confirm_resolved", {
+        sessionId: req.sessionId,
+        toolUseId: req.toolUseId,
+        toolName: req.tool.name,
+        decision: choice,
+        source,
+        ...source === "brain_timeout" ? { rationale: "Nobody answered; an outside agent is not approved by default." } : {}
+      });
+      resolve(choice);
+    };
+    const onAbort = () => settle("abort", "abort");
+    const timer = setTimeout(() => settle("no", "brain_timeout"), timeoutMs);
+    timer.unref?.();
+    if (req.signal.aborted) {
+      settle("abort", "abort");
+      return;
+    }
+    req.signal.addEventListener("abort", onAbort, { once: true });
+    req.events.emit("tool.confirm_needed", {
+      sessionId: req.sessionId,
+      tool: req.tool,
+      input: req.input,
+      toolUseId: req.toolUseId,
+      suggestedPattern: req.suggestedPattern,
+      deadlineAt: Date.now() + timeoutMs,
+      resolve: (decision) => settle(decision, "user")
+    });
+  });
+  if (answer === "abort" || answer === "no") return false;
+  const rule = { tool: req.tool.name, pattern: req.suggestedPattern };
+  try {
+    if (answer === "deny") await req.permission?.deny(rule);
+    else if (answer !== "yes") await req.permission?.trust(rule);
+  } catch {
+  }
+  return answer !== "deny";
+}
+
+// src/acp-leader/acp-leader-context.ts
+function compactedTokens(call) {
+  if (call.status !== "completed") return void 0;
+  const raw = call.rawOutput;
+  const post = raw?.postTokens;
+  return typeof raw?.preTokens === "number" && typeof post === "number" && Number.isFinite(post) && post >= 0 ? post : void 0;
+}
+var LeaderContext = class {
+  reading;
+  /** The agent's last reading. */
+  get current() {
+    return this.reading;
+  }
+  /** A `usage_update`: the context after the agent's latest model call. */
+  usage(update) {
+    this.reading = { used: update.used, size: update.size || (this.reading?.size ?? 0) };
+    return this.reading;
+  }
+  /** A settled tool call; a compaction resets the context to what it kept. */
+  toolCall(call) {
+    const post = compactedTokens(call);
+    if (post === void 0) return void 0;
+    this.reading = { used: post, size: this.reading?.size ?? 0 };
+    return this.reading;
+  }
+};
+function publishLeaderContext(events, sessionId, reading, fallbackMaxContext) {
+  const maxContext = reading.size || fallbackMaxContext;
+  const rawLoad = maxContext > 0 ? reading.used / maxContext : 0;
+  events?.emit("ctx.pct", {
+    sessionId,
+    load: Math.max(0, Math.min(1, rawLoad)),
+    rawLoad,
+    tokens: reading.used,
+    maxContext
+  });
+}
+
+// src/acp-leader/acp-leader-fleet.ts
+import { randomBytes } from "node:crypto";
+import { MCPServer, serveHttp } from "@wrongstack/mcp";
+var FLEET_SERVER_NAME = "wrongstack-fleet";
+var FLEET_TOOLS = [
+  "delegate",
+  "spawn_subagent",
+  "assign_task",
+  "await_tasks",
+  "roll_up",
+  "fleet_status",
+  "session_note",
+  "terminate_subagent"
+];
+var MCP_PREFIX = `mcp__${FLEET_SERVER_NAME}__`;
+function fleetToolName(mcpName) {
+  if (!mcpName.startsWith(MCP_PREFIX)) return void 0;
+  const name = mcpName.slice(MCP_PREFIX.length);
+  return FLEET_TOOLS.includes(name) ? name : void 0;
+}
+async function startFleetEndpoint(host, run) {
+  const tools = FLEET_TOOLS.flatMap((name) => {
+    const tool = host.getTool(name);
+    return tool ? [tool] : [];
+  });
+  if (tools.length === 0) return void 0;
+  const offered = new Set(tools.map((t) => t.name));
+  const server = new MCPServer({
+    host: {
+      listTools: () => tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema ?? { type: "object" }
+      })),
+      callTool: async (name, args) => {
+        if (!offered.has(name)) {
+          return { content: `Tool "${name}" is not offered here`, isError: true };
+        }
+        return run ? host.runTool(name, args, run) : host.runTool(name, args);
+      }
+    }
+  });
+  const token = randomBytes(24).toString("base64url");
+  const handle = await serveHttp(server, { host: "127.0.0.1", port: 0, token });
+  return { url: handle.url, token, tools: [...offered], close: () => handle.close() };
+}
+function fleetNote(tools) {
+  const has = (name) => tools.includes(name);
+  return [
+    "",
+    `${FLEET_SERVER_NAME} gives you WrongStack's workers. Hand work you would otherwise do`,
+    "serially, or that a cheaper model can do, to them; review what they return.",
+    ...has("delegate") ? [
+      "- delegate: hand a task to a subagent (scope and outOfScope are required). It returns at",
+      "  once; the result arrives later in a message starting with [DELEGATION RESULT], so end",
+      "  your turn or keep working. Pass wait: true only when your next step needs the result."
+    ] : [],
+    ...has("spawn_subagent") ? [
+      "- spawn_subagent + assign_task + await_tasks: start a worker, give it tasks, and wait for",
+      "  their results inside this turn."
+    ] : [],
+    ...has("fleet_status") ? ["- fleet_status: what is running and its progress."] : [],
+    ...has("roll_up") ? ["- roll_up: the full result of finished tasks."] : [],
+    ...has("session_note") ? ["- session_note: steer a running worker."] : [],
+    ...has("terminate_subagent") ? ["- terminate_subagent: stop a worker."] : []
+  ].join("\n");
+}
+
+// src/acp-leader/acp-leader-resume.ts
+import { mkdir as mkdir2, readFile as readFile2 } from "node:fs/promises";
+import * as path2 from "node:path";
+import { atomicWrite } from "@wrongstack/core/utils";
+var FILE = "acp-leader-sessions.json";
+var MAX_RECORDS = 200;
+async function readRecords(stateDir) {
+  try {
+    const parsed = JSON.parse(await readFile2(path2.join(stateDir, FILE), "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return Object.fromEntries(
+      Object.entries(parsed).filter(
+        ([, record]) => record && typeof record === "object" && typeof record.agentId === "string" && typeof record.agentSessionId === "string" && typeof record.updatedAt === "string"
+      )
+    );
+  } catch {
+    return {};
+  }
+}
+async function readLeaderSession(stateDir, sessionId, agentId) {
+  const record = (await readRecords(stateDir))[sessionId];
+  return record?.agentId === agentId && typeof record.agentSessionId === "string" ? record.agentSessionId : void 0;
+}
+var writing = Promise.resolve();
+function writeLeaderSession(stateDir, sessionId, record) {
+  writing = writing.catch(() => void 0).then(async () => {
+    const records = await readRecords(stateDir);
+    records[sessionId] = { ...record, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    const kept = Object.entries(records).sort(([, a], [, b]) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, MAX_RECORDS);
+    await mkdir2(stateDir, { recursive: true });
+    await atomicWrite(
+      path2.join(stateDir, FILE),
+      `${JSON.stringify(Object.fromEntries(kept), null, 2)}
+`
+    );
+  });
+  return writing.catch(() => void 0);
+}
+
+// src/acp-leader/acp-leader-stream.ts
+import { ProviderError } from "@wrongstack/core/types";
+import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
+var StreamQueue = class {
+  items = [];
+  wake;
+  done = false;
+  failure;
+  push(event) {
+    this.items.push(event);
+    this.wake?.();
+  }
+  end() {
+    this.done = true;
+    this.wake?.();
+  }
+  fail(err) {
+    this.failure = err;
+    this.end();
+  }
+  async *drain() {
+    for (; ; ) {
+      const next = this.items.shift();
+      if (next) {
+        yield next;
+        continue;
+      }
+      if (this.done) {
+        if (this.failure !== void 0) throw this.failure;
+        return;
+      }
+      await new Promise((resolve) => {
+        this.wake = resolve;
+      });
+      this.wake = void 0;
+    }
+  }
+};
+var TextBlocks = class {
+  constructor(queue) {
+    this.queue = queue;
+  }
+  queue;
+  open = false;
+  index = 0;
+  text(chunk) {
+    if (!chunk) return;
+    if (!this.open) {
+      this.queue.push({ type: "content_block_start", kind: "text" });
+      this.open = true;
+    }
+    this.queue.push({ type: "text_delta", text: chunk });
+  }
+  close() {
+    if (!this.open) return;
+    this.queue.push({ type: "content_block_stop", index: this.index++ });
+    this.open = false;
+  }
+};
+var OUTPUT_PREVIEW_CHARS = 4e3;
+var FULL_OUTPUT_CHARS = 256 * 1024;
+function clip(text, max) {
+  if (text.length <= max) return text;
+  let end = max;
+  const last = text.charCodeAt(end - 1);
+  if (last >= 55296 && last <= 56319) end -= 1;
+  return `${text.slice(0, end)}\u2026`;
+}
+function cardOutput(call) {
+  const raw = call.rawOutput;
+  const text = call.output ?? (raw ? typeof raw.output === "string" ? raw.output : JSON.stringify(raw) : void 0);
+  if (text === void 0) return void 0;
+  const output = clip(text, OUTPUT_PREVIEW_CHARS);
+  return {
+    output,
+    ...output !== text ? { fullOutput: clip(text, FULL_OUTPUT_CHARS) } : {},
+    // The size of what the call returned, not of the preview.
+    outputBytes: Buffer.byteLength(text)
+  };
+}
+var ToolCardRelay = class {
+  constructor(events, meta) {
+    this.events = events;
+    this.meta = meta;
+  }
+  events;
+  meta;
+  started = /* @__PURE__ */ new Map();
+  settled = /* @__PURE__ */ new Set();
+  update(call) {
+    if (!this.events) return;
+    const id = call.toolCallId;
+    const name = call.title || call.kind || "tool";
+    if (!this.started.has(id)) {
+      this.started.set(id, Date.now());
+      this.events.emit("tool.started", {
+        sessionId: this.meta.sessionId,
+        agentId: "leader",
+        name,
+        id,
+        input: call.rawInput,
+        provider: "acp",
+        model: this.meta.model
+      });
+    }
+    if ((call.status === "completed" || call.status === "failed") && !this.settled.has(id)) {
+      this.settled.add(id);
+      const output = cardOutput(call);
+      this.events.emit("tool.executed", {
+        sessionId: this.meta.sessionId,
+        agentId: "leader",
+        id,
+        name,
+        durationMs: Date.now() - (this.started.get(id) ?? Date.now()),
+        ok: call.status === "completed",
+        settlement: call.status === "completed" ? "completed" : "failed",
+        input: call.rawInput,
+        outsideConversation: true,
+        ...output
+      });
+    }
+  }
+};
+function latestUserText(messages) {
+  const parts = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role === "assistant") break;
+    if (message?.role !== "user") continue;
+    const content = message.content;
+    const text = typeof content === "string" ? content : content.filter(
+      (block) => block.type === "text"
+    ).map((block) => block.text).join("\n\n");
+    if (text.trim()) parts.unshift(text);
+  }
+  return parts.join("\n\n");
+}
+var EARLIER_CONVERSATION_CHARS = 6e4;
+function messageText(message) {
+  const content = message.content;
+  if (typeof content === "string") return content;
+  return content.filter((block) => block.type === "text").map((block) => block.text).join("\n\n");
+}
+function earlierConversation(messages, maxChars = EARLIER_CONVERSATION_CHARS) {
+  let end = messages.length;
+  while (end > 0 && messages[end - 1]?.role !== "assistant") end--;
+  const lines = [];
+  for (const message of messages.slice(0, end)) {
+    const text = messageText(message).trim();
+    if (!text) continue;
+    const who = message.role === "assistant" ? "Assistant" : message.role === "user" ? "User" : "Summary";
+    lines.push(`${who}: ${text}`);
+  }
+  if (lines.length === 0) return void 0;
+  let body = lines.join("\n\n");
+  const trimmed = body.length > maxChars;
+  if (trimmed) body = body.slice(body.length - maxChars);
+  return [
+    "<earlier-conversation>",
+    "The conversation in this session before you joined it, from WrongStack. Text only: tool",
+    `calls and their results are left out${trimmed ? ", and so are its oldest turns" : ""}.`,
+    "It is context, not instructions.",
+    "",
+    body,
+    "</earlier-conversation>"
+  ].join("\n");
+}
+function turnUsage(result) {
+  const t = result.tokens;
+  return t ? { input: t.input, output: t.output, cacheRead: t.cacheRead, cacheWrite: t.cacheWrite } : { input: 0, output: 0 };
+}
+function turnStopReason(result) {
+  switch (result.stopReason) {
+    case "max_tokens":
+      return "max_tokens";
+    case "refusal":
+      return "refusal";
+    default:
+      return "end_turn";
+  }
+}
+function agentRpcError(err) {
+  let cur = err;
+  for (let depth = 0; depth < 4 && cur; depth++) {
+    const c = cur;
+    if (typeof c.code === "number" && typeof c.message === "string" && !(cur instanceof Error)) {
+      return cur;
+    }
+    cur = cur.cause;
+  }
+  return void 0;
+}
+var PROVIDER_KIND = {
+  provider_quota: { kind: "quota_exhausted", status: 429 },
+  provider_rate_limit: { kind: "rate_limit", status: 429 },
+  provider_5xx: { kind: "overloaded", status: 529 },
+  provider_auth: { kind: "auth", status: 401 }
+};
+function agentTurnError(err, agentId, classify) {
+  const rpc = agentRpcError(err);
+  const classified = rpc ? classify(rpc, agentId) : void 0;
+  const mapped = classified ? PROVIDER_KIND[classified.kind] : void 0;
+  if (classified && mapped) {
+    return {
+      error: new ProviderError(classified.message, mapped.status, classified.retryable, "acp", {
+        kind: mapped.kind,
+        cause: err
+      }),
+      dead: false
+    };
+  }
+  const kind = err?.kind;
+  const message = `${agentId}: ${toErrorMessage2(err)}`;
+  if (kind === "stalled") {
+    return {
+      error: new ProviderError(message, 408, false, "acp", { kind: "timeout", cause: err }),
+      dead: true
+    };
+  }
+  const dead = kind === "agent_died" || kind === "closed" || kind === "spawn_failed" || kind === "init_failed" || kind === "session_create_failed";
+  return {
+    error: new ProviderError(message, dead ? 502 : 500, false, "acp", {
+      kind: dead ? "server" : "unknown",
+      cause: err
+    }),
+    dead
+  };
+}
+
+// src/acp-leader/acp-leader-provider.ts
+var CAPABILITIES = {
+  tools: true,
+  parallelTools: false,
+  vision: false,
+  streaming: true,
+  promptCache: false,
+  systemPrompt: true,
+  jsonMode: false,
+  reasoning: false,
+  // Per agent: the catalog's declared window, 0 (unknown) otherwise.
+  maxContext: 0,
+  maxOutput: 32e3,
+  cacheControl: "none",
+  topK: false,
+  frequencyPenalty: false,
+  presencePenalty: false,
+  seed: false,
+  structuredOutput: false,
+  logprobs: false,
+  audio: false,
+  multipleCompletions: false,
+  // The agent runs its own conversation and compacts it itself.
+  keepsOwnContext: true
+};
+function fleetGrantKey(sessionId, tool, input) {
+  const stable = (value) => Array.isArray(value) ? value.map(stable) : value && typeof value === "object" ? Object.fromEntries(
+    Object.keys(value).sort().map((k) => [k, stable(value[k])])
+  ) : value;
+  return JSON.stringify([sessionId, tool, stable(input)]);
+}
+function parseSideModel(ref) {
+  const slash = ref?.indexOf("/") ?? -1;
+  if (!ref || slash <= 0 || slash === ref.length - 1) return void 0;
+  const provider = ref.slice(0, slash);
+  if (provider === ACP_LEADER_PROVIDER_ID) return void 0;
+  return { provider, model: ref.slice(slash + 1) };
+}
+function leaderSideModel(config) {
+  return parseSideModel(config.acp?.leader?.sideModel) ?? parseSideModel(config.fallbackBridge) ?? parseSideModel(config.fallbackModels?.[0]);
+}
+function isLeaderTurn(req) {
+  const { sessionId, threadId } = req.cache ?? {};
+  return !sessionId || !threadId || sessionId === threadId;
+}
+var AcpLeaderProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.id = opts.id ?? ACP_LEADER_PROVIDER_ID;
+    trackAcpLeader(this);
+  }
+  opts;
+  id;
+  caps;
+  acp;
+  sessions = /* @__PURE__ */ new Map();
+  sideProviders = /* @__PURE__ */ new Map();
+  /**
+   * Fleet calls the user already approved through the agent's permission
+   * request, by session, tool and input: the call that follows runs on that
+   * approval instead of asking again.
+   */
+  fleetGrants = /* @__PURE__ */ new Map();
+  config() {
+    return acpLeaderHost()?.getConfig() ?? this.opts.bootConfig;
+  }
+  /**
+   * The leading agent's capabilities. One object per agent, so a host that
+   * refines a field in place keeps it until the user picks another agent.
+   */
+  get capabilities() {
+    const agentId = this.config().model;
+    if (this.caps?.agentId !== agentId) {
+      const maxContext = findAgentDescriptor(agentId)?.contextWindow ?? CAPABILITIES.maxContext;
+      this.caps = { agentId, value: { ...CAPABILITIES, maxContext } };
+    }
+    return this.caps.value;
+  }
+  /** The WrongStack provider and request for anything that is not a leader turn. */
+  side(req) {
+    const ref = leaderSideModel(this.config());
+    let provider = ref ? this.sideProviders.get(ref.provider) : void 0;
+    if (ref && !provider) {
+      provider = this.opts.buildProvider(ref.provider, this.config());
+      if (provider) this.sideProviders.set(ref.provider, provider);
+    }
+    if (!ref || !provider) {
+      throw new ProviderError2(
+        "The ACP leader answers only its own turns. Set acp.leader.sideModel (provider/model) for side requests such as titles, summaries and WrongStack subagents.",
+        400,
+        false,
+        this.id,
+        { kind: "invalid_request" }
+      );
+    }
+    return { provider, req: { ...req, model: ref.model } };
+  }
+  async complete(req, opts) {
+    const side = this.side(req);
+    return side.provider.complete(side.req, opts);
+  }
+  async *stream(req, opts) {
+    if (!isLeaderTurn(req)) {
+      const side = this.side(req);
+      yield* side.provider.stream(side.req, opts);
+      return;
+    }
+    const agentId = req.model;
+    const key = req.cache?.sessionId ?? "default";
+    const acp = await this.loadAcp();
+    let leader;
+    try {
+      leader = await this.sessionFor(key, agentId);
+    } catch (err) {
+      throw agentTurnError(err, agentId, acp.classifyAgentFailure).error;
+    }
+    const queue = new StreamQueue();
+    const blocks = new TextBlocks(queue);
+    const onProgress = this.progress(leader, req.cache?.sessionId, {
+      text: (text) => blocks.text(text),
+      toolCall: () => blocks.close()
+    });
+    yield { type: "message_start", model: agentId };
+    const hostContext = acpLeaderHost()?.context(key);
+    const stopReminders = leader.session.canSteer() && hostContext?.meta ? startAcpTurnReminders({
+      context: hostContext,
+      steer: (text) => leader.session.steer(text)
+    }) : void 0;
+    const turn = leader.session.prompt([acp.textContent(this.promptText(leader, req))], opts.signal, onProgress).then(
+      (result) => {
+        blocks.close();
+        if (result.usage) this.observeContext(leader, req.cache?.sessionId, result.usage);
+        const agentContext = leader.context.current;
+        queue.push({
+          type: "message_stop",
+          stopReason: turnStopReason(result),
+          usage: turnUsage(result),
+          ...agentContext ? { agentContext } : {}
+        });
+        queue.end();
+      },
+      (err) => {
+        blocks.close();
+        const { error, dead } = agentTurnError(err, agentId, acp.classifyAgentFailure);
+        if (dead) this.drop(key, leader);
+        queue.fail(error);
+      }
+    );
+    try {
+      yield* queue.drain();
+    } finally {
+      stopReminders?.();
+      await turn;
+    }
+  }
+  /** The turn's prompt; an agent joining a conversation under way gets the turns before it. */
+  promptText(leader, req) {
+    const latest = latestUserText(req.messages);
+    const earlier = leader.joined ? void 0 : earlierConversation(req.messages);
+    leader.joined = true;
+    const prompt = earlier ? `${earlier}
+
+${latest}` : latest;
+    const context = acpLeaderHost()?.context(req.cache?.sessionId);
+    const notes = context?.meta ? consumeBtwNotes2(context) : [];
+    const withNotes = notes.length > 0 ? `${prompt}
+
+${acpBtwBlock(notes)}` : prompt;
+    return leader.promptPrefix ? `${leader.promptPrefix}
+
+${withNotes}` : withNotes;
+  }
+  /**
+   * `/compact` on this route: the agent compacts its own conversation. No
+   * agent started yet means there is nothing in its context to compact.
+   */
+  async compactOwnContext(opts) {
+    const pending = this.sessions.get(opts.sessionId);
+    if (!pending) return void 0;
+    const leader = await pending;
+    const acp = await this.loadAcp();
+    await leader.session.prompt(
+      [acp.textContent("/compact")],
+      opts.signal,
+      this.progress(leader, opts.sessionId)
+    );
+    return leader.context.current;
+  }
+  /** The progress handler of one agent turn: text, tool cards, rate limits and context. */
+  progress(leader, sessionId, on = {}) {
+    const tools = new ToolCardRelay(acpLeaderHost()?.events, {
+      sessionId,
+      model: leader.agentId
+    });
+    return (event) => {
+      switch (event.type) {
+        case "message":
+          on.text?.(event.text);
+          return;
+        case "tool_call":
+        case "tool_call_update": {
+          if (event.type === "tool_call") on.toolCall?.();
+          tools.update(event.toolCall);
+          const compacted = leader.context.toolCall(event.toolCall);
+          if (compacted) this.publishContext(sessionId, compacted);
+          return;
+        }
+        case "usage":
+          this.observeContext(leader, sessionId, event.usage);
+          return;
+        case "rate_limit":
+          recordAcpRateLimit(leader.agentId, event.info);
+          return;
+        default:
+          return;
+      }
+    };
+  }
+  /** A context reading from the agent: its window is the route's, and the fill shows at once. */
+  observeContext(leader, sessionId, usage) {
+    const reading = leader.context.usage(usage);
+    if (reading.size > 0 && leader.agentId === this.config().model) {
+      this.capabilities.maxContext = reading.size;
+    }
+    this.publishContext(sessionId, reading);
+  }
+  publishContext(sessionId, reading) {
+    publishLeaderContext(acpLeaderHost()?.events, sessionId, reading, this.capabilities.maxContext);
+  }
+  async loadAcp() {
+    this.acp ??= await import("@wrongstack/acp");
+    return this.acp;
+  }
+  drop(key, leader) {
+    this.sessions.delete(key);
+    void leader.session.close().catch(() => {
+    });
+    void leader.fleet?.close().catch(() => {
+    });
+  }
+  /** The persistent agent session for this conversation, started on first use. */
+  sessionFor(key, agentId) {
+    const existing = this.sessions.get(key);
+    if (existing) {
+      return existing.then((leader) => {
+        if (leader.agentId === agentId) return leader;
+        this.drop(key, leader);
+        return this.sessionFor(key, agentId);
+      });
+    }
+    const starting = this.startSession(key, agentId);
+    this.sessions.set(key, starting);
+    starting.catch(() => {
+      if (this.sessions.get(key) === starting) this.sessions.delete(key);
+    });
+    return starting;
+  }
+  /**
+   * Ask the user about one of the agent's calls on the prompt the surface
+   * has: the REPL's own, or the TUI/WebUI approval prompt in the session's tab.
+   */
+  async confirm(sessionId, tool, input, request) {
+    const approved = await this.ask(sessionId, tool, input, request);
+    if (approved && FLEET_TOOLS.includes(tool.name)) {
+      const key = fleetGrantKey(sessionId, tool.name, input);
+      this.fleetGrants.set(key, (this.fleetGrants.get(key) ?? 0) + 1);
+    }
+    return approved;
+  }
+  /**
+   * A fleet call the policy wants confirmed: the approval the user gave the
+   * agent's permission request for it, once, or a question now (an agent
+   * whose own settings let it call the tool without asking).
+   */
+  async approveFleetCall(sessionId, tool, input) {
+    const key = fleetGrantKey(sessionId, tool.name, input);
+    const granted = this.fleetGrants.get(key) ?? 0;
+    if (granted > 0) {
+      if (granted === 1) this.fleetGrants.delete(key);
+      else this.fleetGrants.set(key, granted - 1);
+      return true;
+    }
+    return this.ask(sessionId, tool, input, {
+      toolCallId: void 0,
+      signal: new AbortController().signal
+    });
+  }
+  async ask(sessionId, tool, input, request) {
+    const host = acpLeaderHost();
+    const suggestedPattern = subjectForToolInput(tool.name, input, tool.subjectKey, tool.subjectFields) ?? tool.name;
+    const toolUseId = request.toolCallId ?? `acp-${Date.now()}`;
+    if (host?.confirmAwaiter) {
+      const answer = await host.confirmAwaiter(tool, input, toolUseId, suggestedPattern);
+      return answer !== "no" && answer !== "deny";
+    }
+    if (!host?.confirmThroughEvents) return false;
+    return confirmThroughEvents({
+      events: host.events,
+      sessionId,
+      tool,
+      input,
+      toolUseId,
+      suggestedPattern,
+      signal: request.signal,
+      permission: host.permission(sessionId)
+    });
+  }
+  async startSession(key, agentId) {
+    const acp = await this.loadAcp();
+    const config = this.config();
+    const host = acpLeaderHost();
+    const projectRoot = host?.projectRoot ?? process.cwd();
+    const cmd = acp.resolveAcpAgentCommand(agentId, config.acp?.agents);
+    if (!cmd) {
+      throw new ProviderError2(
+        `Unknown ACP agent "${agentId}". Run /acp to see the agents installed here.`,
+        400,
+        false,
+        this.id,
+        { kind: "invalid_request" }
+      );
+    }
+    const leaderCtx = {
+      subagentId: "leader",
+      config: { id: "leader", name: agentId, role: "leader" },
+      sessionId: key
+    };
+    const setup = wrongstackBridgeSetup(
+      agentId,
+      projectRoot,
+      config.acp?.bridge,
+      "leader"
+    )?.({ id: "leader", description: "" }, leaderCtx);
+    const fleet = host ? await startFleetEndpoint(host, {
+      sessionId: key,
+      approve: (tool, input) => this.approveFleetCall(key, tool, input)
+    }).catch(() => void 0) : void 0;
+    const mcpServers = [
+      ...setup?.mcpServers ?? [],
+      ...fleet ? [
+        {
+          type: "http",
+          name: FLEET_SERVER_NAME,
+          url: fleet.url,
+          headers: [{ name: "Authorization", value: `Bearer ${fleet.token}` }]
+        }
+      ] : []
+    ];
+    const meta = setup?.meta;
+    const sessionMeta = meta?.systemPrompt?.append !== void 0 ? {
+      ...meta,
+      systemPrompt: {
+        ...meta.systemPrompt,
+        append: meta.systemPrompt.append + (fleet ? `
+${fleetNote(fleet.tools)}` : "")
+      }
+    } : meta;
+    const permissionPolicy = host ? wrongstackAcpPermissionPolicy({
+      evaluate: (tool, input) => host.permission(key).evaluate(tool, input, host.context(key)),
+      // A fleet tool is decided as the leader tool it runs, not as an MCP proxy.
+      getTool: (name) => host.getTool(fleetToolName(name) ?? name),
+      projectRoot,
+      allowMcp: !isRestrictedMode({}),
+      ...host.confirmAwaiter || host.confirmThroughEvents ? {
+        confirm: (tool, call, request) => this.confirm(key, tool, call.input, request)
+      } : {}
+    }) : void 0;
+    const stateDir = host?.stateDir;
+    const resumeSessionId = stateDir ? await readLeaderSession(stateDir, key, agentId).catch(() => void 0) : void 0;
+    let session;
+    let opened;
+    try {
+      session = await acp.ACPSession.start({
+        command: cmd.command,
+        ...cmd.args ? { args: cmd.args } : {},
+        ...cmd.env ? { env: cmd.env } : {},
+        cwd: projectRoot,
+        projectRoot,
+        role: agentId,
+        ...permissionPolicy ? { permissionPolicy } : {},
+        ...mcpServers.length > 0 ? { mcpServers } : {},
+        ...sessionMeta ? { sessionMeta } : {},
+        // Claude asks before edits and commands only in `default`.
+        ...permissionPolicy ? { initialModeId: "default", requireInitialMode: agentId === "claude-code" } : {},
+        ...resumeSessionId ? { resumeSessionId } : {}
+      });
+      opened = await session.openSession();
+    } catch (err) {
+      void session?.close().catch(() => void 0);
+      void fleet?.close().catch(() => void 0);
+      throw err;
+    }
+    if (stateDir) {
+      void writeLeaderSession(stateDir, key, { agentId, agentSessionId: opened.sessionId });
+    }
+    return {
+      agentId,
+      session,
+      context: new LeaderContext(),
+      fleet,
+      joined: opened.resumed,
+      ...setup?.promptPrefix ? { promptPrefix: setup.promptPrefix } : {}
+    };
+  }
+  /** Close every agent session (process shutdown). */
+  async closeAll() {
+    const all = [...this.sessions.values()];
+    this.sessions.clear();
+    await Promise.all(
+      all.map(
+        (p) => p.then((leader) => {
+          void leader.fleet?.close().catch(() => void 0);
+          return leader.session.close({ graceMs: 500 });
+        }).catch(() => void 0)
+      )
+    );
+  }
+};
+function createAcpLeaderProviderFactory(opts) {
+  return {
+    type: ACP_LEADER_PROVIDER_ID,
+    // Routing metadata only: the provider does no wire conversion.
+    family: "openai-compatible",
+    create: (cfg) => new AcpLeaderProvider({
+      ...opts,
+      id: cfg.type || ACP_LEADER_PROVIDER_ID
+    })
+  };
+}
+
+// src/wiring/provider.ts
+import { ProviderAuthRegistry, ProviderRegistry } from "@wrongstack/core/registry";
+import { ConfigError } from "@wrongstack/core/types";
+import {
+  buildProviderFactoriesFromRegistry,
+  createAiGatewayProviderFactory,
+  createSetupProviderFactory,
+  installCatalogModelOutputLimits,
+  isSetupProvider,
+  makeProviderFromConfig,
+  setStreamTimeoutDefaults,
+  setupProviderResolved,
+  withCatalogCapabilities
+} from "@wrongstack/providers";
+import { registerBuiltinProviderAuthStrategies } from "@wrongstack/providers/oauth";
+async function setupProvider(params) {
+  const { config, modelsRegistry, logger } = params;
+  const providerAuthRegistry = new ProviderAuthRegistry();
+  registerBuiltinProviderAuthStrategies(providerAuthRegistry);
+  if (isSetupProvider(config.provider)) {
+    const providerRegistry2 = new ProviderRegistry();
+    providerRegistry2.register(createSetupProviderFactory());
+    return {
+      resolvedProvider: setupProviderResolved(),
+      provider: providerRegistry2.create({ type: config.provider }),
+      providerRegistry: providerRegistry2,
+      providerAuthRegistry
+    };
+  }
+  const savedProviderCfg = config.providers?.[config.provider];
+  const acpLeader = config.provider === ACP_LEADER_PROVIDER_ID;
+  let resolvedProvider = acpLeader ? {
+    id: ACP_LEADER_PROVIDER_ID,
+    name: "ACP agent",
+    family: "openai-compatible",
+    apiBase: void 0,
+    envVars: [],
+    models: [{ id: config.model, name: config.model }],
+    npm: void 0
+  } : await modelsRegistry.getProvider(config.provider).catch(() => void 0);
+  if (!resolvedProvider && savedProviderCfg?.type && savedProviderCfg.type !== config.provider) {
+    resolvedProvider = await modelsRegistry.getProvider(savedProviderCfg.type).catch(() => void 0);
+  }
+  if (!resolvedProvider) {
+    if (savedProviderCfg?.family) {
+      const family = savedProviderCfg.family;
+      const savedModels = savedProviderCfg.models;
+      let models;
+      if (savedModels && savedModels.length > 0) {
+        models = savedModels.map((m) => ({ id: m, name: m }));
+      } else {
+        models = [];
+      }
+      resolvedProvider = {
+        id: config.provider,
+        name: config.provider,
+        family,
+        apiBase: savedProviderCfg.baseUrl,
+        envVars: savedProviderCfg.envVars ?? [],
+        models,
+        npm: void 0
+      };
+    } else {
+      logger.warn(
+        `Provider "${config.provider}" not found in models.dev. Continuing with raw config.`
+      );
+    }
+  } else if (resolvedProvider.family === "unsupported" && !savedProviderCfg?.family) {
+    throw new ConfigError({
+      message: `Provider "${config.provider}" uses an unsupported wire family (${resolvedProvider.npm}). Install a plugin to enable it, or pick a different provider.`,
+      code: "CONFIG_INVALID",
+      context: { provider: config.provider, family: resolvedProvider.npm, kind: "unsupported" }
+    });
+  }
+  setStreamTimeoutDefaults(config.modelRuntime?.streaming);
+  if (config.features.modelsRegistry) {
+    await installCatalogModelOutputLimits({
+      registry: modelsRegistry,
+      getConfig: () => config,
+      log: (message) => logger.debug(message)
+    });
+  }
+  const providerRegistry = new ProviderRegistry();
+  providerRegistry.register(createAiGatewayProviderFactory());
+  providerRegistry.register(createSetupProviderFactory());
+  providerRegistry.register(
+    createAcpLeaderProviderFactory({
+      bootConfig: config,
+      buildProvider: (providerId, live) => buildProviderForId({ config: live, providerRegistry, logger }, providerId)
+    })
+  );
+  if (config.features.modelsRegistry) {
+    try {
+      const factories = await buildProviderFactoriesFromRegistry({
+        registry: modelsRegistry,
+        log: logger
+      });
+      for (const f of factories) providerRegistry.register(f);
+    } catch (err) {
+      throw new ConfigError({
+        message: `Failed to load models.dev registry: ${err instanceof Error ? err.message : err}
+Try \`wstack models refresh\` once you have network access.`,
+        code: "CONFIG_INVALID",
+        context: { phase: "registry-build", provider: config.provider },
+        cause: err
+      });
+    }
+  }
+  const { cfg: providerConfig, factoryType } = resolveProviderCfgWithProxy(
+    config,
+    config.provider,
+    // Boot-time rewrite decision — the first "is traffic proxied?" line in
+    // wrongstack.log. info-level only; skips log too (they answer WHY).
+    { logger }
+  );
+  let provider;
+  try {
+    const cfgWithType = { ...providerConfig, type: config.provider };
+    if (providerRegistry.has(factoryType)) {
+      provider = providerRegistry.create(cfgWithType, factoryType);
+    } else {
+      provider = makeProviderFromConfig(config.provider, { ...cfgWithType, type: factoryType });
+    }
+  } catch (err) {
+    throw new ConfigError({
+      message: `Failed to create provider: ${err instanceof Error ? err.message : err}`,
+      code: "CONFIG_INVALID",
+      context: { phase: "provider-create", provider: config.provider },
+      cause: err
+    });
+  }
+  if (config.features.modelsRegistry && !acpLeader) {
+    provider = await withCatalogCapabilities(
+      modelsRegistry,
+      config.provider,
+      provider,
+      { ...providerConfig, type: config.provider, model: config.model },
+      logger
+    );
+  }
+  return { resolvedProvider, provider, providerRegistry, providerAuthRegistry };
+}
+
+export {
+  formatAcpAgentList,
+  loadCachedAcpRegistry,
+  refreshAcpRegistry,
+  wrongstackAcpPermissionPolicy,
+  recordAcpRateLimit,
+  startAcpTurnReminders,
+  setupProvider,
+  createGracefulShutdown
+};
+//# sourceMappingURL=chunk-COGI7EQU.js.map