@wrongstack/cli 1.1.2 → 1.1.5

package/dist/chunk-5SGMUDP5.js

@@ -0,0 +1,752 @@
+import {
+  resolveWrongForgeEndpoint,
+  wrongForgeCall
+} from "./chunk-VEESMPTX.js";
+
+// src/fleet/acp-wrongstack-bridge.ts
+import { statSync } from "node:fs";
+import { join } from "node:path";
+import { findAgentDescriptor, REGISTRY_ID_ALIASES } from "@wrongstack/acp";
+import { cliSpawnArgs, isStandaloneBinary } from "@wrongstack/core/utils";
+var DEFAULT_BRIDGE_AGENTS = ["claude-code"];
+var DEFAULT_BRIDGE_SERVERS = [
+  "codebase-index",
+  "sage",
+  "mailbox",
+  "kanban"
+];
+function wstackLaunch(args, entry = process.argv[1]) {
+  if (isStandaloneBinary() || entry && /wstack|wrongstack|index\.(js|ts|mjs|cjs)$/.test(entry)) {
+    return { command: process.execPath, args: cliSpawnArgs(entry ?? "", args) };
+  }
+  return { command: "wstack", args };
+}
+function wstackToolsCommand(entry = process.argv[1], platform = process.platform) {
+  const launch = wstackLaunch(["tools"], entry);
+  return [launch.command, ...launch.args].map((word) => shellWord(word, platform)).join(" ");
+}
+function shellWord(word, platform) {
+  const w = platform === "win32" ? word.replace(/\\/g, "/") : word;
+  return /^[A-Za-z0-9_./:@=+-]+$/.test(w) ? w : `"${w.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+function cliIndexNote(cmd) {
+  return [
+    `- \`${cmd} run <tool> -- --<field> <value>\` (run through your shell): a prebuilt, ranked`,
+    "  symbol index of this repository, caught up with the disk on every call. Prefer it over",
+    '  grep/glob and whole-file reads for code navigation: codebase-context --query "<task>"',
+    "  (files relevant to a task), codebase-search --query <name> (where something is defined),",
+    "  codebase-incoming-calls / codebase-outgoing-calls --symbol <name> (callers, callees),",
+    "  codebase-read-symbol --file <path> --symbol <name> (one symbol's source),",
+    "  codebase-skeleton --path <file-or-dir> (an outline), codebase-impact-analysis --symbol",
+    `  <name> (what a change affects). \`${cmd} describe <tool>\` lists a tool's fields;`,
+    `  \`${cmd} batch\` runs several JSONL calls ({"tool":\u2026,"input":\u2026}) in one process.`,
+    "  Use grep for literal text such as strings, comments and config values."
+  ];
+}
+function serviceNotes(servers, delegated, indexCli) {
+  const viaCli = indexCli !== void 0 && servers.includes("codebase-index");
+  const mcp = viaCli ? servers.filter((s) => s !== "codebase-index") : servers;
+  return [
+    ...mcp.length > 0 ? [
+      "WrongStack's project services are available as MCP servers:",
+      ...mcp.map((s) => SERVER_NOTES[s](delegated))
+    ] : [],
+    ...viaCli ? [
+      ...mcp.length > 0 ? [""] : [],
+      "WrongStack's codebase index is available through its CLI:",
+      ...cliIndexNote(indexCli)
+    ] : []
+  ];
+}
+var SERVER_NAMES = {
+  sage: "wrongstack-sage",
+  mailbox: "wrongstack-mailbox",
+  kanban: "wrongstack-kanban",
+  "codebase-index": "wrongstack-index",
+  "requirement-intake": "wrongstack-intake"
+};
+var SERVER_NOTES = {
+  sage: () => "- wrongstack-sage: the project's shared memory. Recall what is relevant before you start; when you learn something durable (a decision, a gotcha, a convention), propose it with memory_candidates (WrongStack reviews proposals).",
+  mailbox: (delegated) => "- wrongstack-mailbox: the project's agent mailbox, already signed in as you. Send progress, blockers and questions to " + (delegated ? '"@session" (the WrongStack session that delegated this task), ' : '"all" (the agents working in this project), ') + '(a send needs a type, e.g. "note"), check unread mail during long work, and acknowledge what you handle.',
+  kanban: () => "- wrongstack-kanban: the project's board. If the task names a card, keep its status current. Lists return only the most recently updated (pass limit for more); use the stats action for totals and workbench for what is in flight.",
+  "codebase-index": () => "- wrongstack-index: a prebuilt, ranked symbol index of this repository, kept fresh by WrongStack. Prefer it over grep/glob and whole-file reads for code navigation: codebase_search (where something is defined), codebase_incoming_calls / codebase_outgoing_calls (callers, callees), codebase_read_symbol (one symbol's source), codebase_skeleton (a file or folder outline), codebase_impact_analysis (what a change affects), codebase_context (files relevant to a task), codebase_repo_map (overview). Use grep for literal text such as strings, comments and config values.",
+  "requirement-intake": () => "- wrongstack-intake: the project's requirements intake. List open requests; file a new one when you are handed an unrecorded software request."
+};
+function serviceWorkflow(servers, indexCli) {
+  return [
+    ...servers.includes("codebase-index") ? indexCli !== void 0 ? [
+      "Use the WrongStack index first for code navigation; use your file tools for edits,",
+      "exact literal searches, and verification. Start a code task with",
+      `${indexCli} run codebase-context -- --query "<the task in a few words>"; for a named`,
+      `symbol use ${indexCli} run codebase-search -- --query <name>. If the index lacks a`,
+      "result, fall back to your tools."
+    ] : [
+      "Use wrongstack-index first for code navigation; use your file tools for edits, exact",
+      "literal searches, and verification. Start a code task with",
+      "mcp__wrongstack-index__codebase_context (task description); for a named symbol use",
+      "mcp__wrongstack-index__codebase_search. If the index lacks a result, fall back to your tools."
+    ] : [],
+    ...servers.includes("sage") ? [
+      "Recall relevant decisions from wrongstack-sage before substantial work; propose durable",
+      "findings to memory_candidates after verification. Start with",
+      "mcp__wrongstack-sage__memory_search using the task topic."
+    ] : [],
+    ...servers.includes("mailbox") ? [
+      "Check wrongstack-mailbox for unread messages when starting and during long work;",
+      'use mcp__wrongstack-mailbox__mailbox_read with action "inbox" to read your',
+      "messages. Send meaningful",
+      "progress or blockers and acknowledge messages you handle."
+    ] : [],
+    ...servers.includes("kanban") ? [
+      "Use wrongstack-kanban when work is tied to a board task; inspect its current state",
+      "with mcp__wrongstack-kanban__kanban_read and update it as work progresses."
+    ] : [],
+    "If a project service is unavailable, continue with available tools and report the gap."
+  ];
+}
+function bridgeTaskKickoff(servers, indexCli) {
+  return [
+    "Project-service kickoff for this task:",
+    ...servers.includes("codebase-index") ? [
+      indexCli !== void 0 ? `First run ${indexCli} run codebase-context -- --query "<the task>" to locate relevant code.` : "First use mcp__wrongstack-index__codebase_context to locate relevant code."
+    ] : [],
+    ...servers.includes("sage") ? ["Use mcp__wrongstack-sage__memory_search for prior project guidance."] : [],
+    ...servers.includes("mailbox") ? ['Check mcp__wrongstack-mailbox__mailbox_read with action "inbox".'] : [],
+    ...servers.includes("kanban") ? ["If the task names a board card, inspect it with mcp__wrongstack-kanban__kanban_read."] : [],
+    "Then use file and other tools as the task requires."
+  ].join("\n");
+}
+function serverArgs(server, projectRoot, ctx) {
+  const actor = ctx.subagentId;
+  const base = ["mcp", "serve", server, `--project-root=${projectRoot}`];
+  switch (server) {
+    case "sage":
+      return [...base, `--origin=${actor}`];
+    case "mailbox": {
+      const name = ctx.config.name ?? actor;
+      return [
+        ...base,
+        `--actor=${actor}`,
+        `--name=${name}`,
+        ...ctx.config.role ? [`--role=${ctx.config.role}`] : [],
+        ...ctx.sessionId ? [`--session-id=${ctx.sessionId}`] : [],
+        // Switch last: the global parser would read a following word as its value.
+        "--writable"
+      ];
+    }
+    case "kanban":
+      return [...base, `--actor=${actor}`, "--writable"];
+    case "codebase-index":
+      return [...base, "--watch"];
+    case "requirement-intake":
+      return [...base, "--writable"];
+  }
+}
+function bridgeNote(servers, delegated = true, indexCli) {
+  return [
+    "You are working as a delegated worker inside a WrongStack project.",
+    "WrongStack is the orchestrator the user runs: it sent you this task and receives your",
+    "final reply, so end with a clear summary of what you did and what is left.",
+    ...delegated ? [
+      "While you work, the WrongStack session can steer you: such a message arrives as a",
+      'user message starting with "[WrongStack <kind> from <agent>]". Treat it as coming',
+      "from the user who delegated the task, and answer what it asks."
+    ] : [],
+    "",
+    ...serviceNotes(servers, delegated, indexCli),
+    "",
+    ...serviceWorkflow(servers, indexCli),
+    "",
+    "WrongStack applies the user's rules to your edits and commands. A refused permission",
+    "comes from them (a deny rule the user wrote, a history-rewriting git command, a",
+    "credential read): do not retry it or work around it; finish what you can and name what",
+    "was refused in your final reply."
+  ].join("\n");
+}
+function leaderBridgeNote(servers, indexCli) {
+  return [
+    "You are the leader of a WrongStack session. The user talks to you through WrongStack",
+    "(its terminal UI or web UI), which shows your replies, your tool calls and their results.",
+    "",
+    ...serviceNotes(servers, false, indexCli),
+    "",
+    ...serviceWorkflow(servers, indexCli),
+    "",
+    "WrongStack applies the user's rules to your edits and commands and asks the user when one",
+    "needs approval. A refused permission is the user's decision or rule: do not retry it or",
+    "work around it.",
+    "",
+    "When you finish a turn and a concrete follow-on action exists, end your reply with a",
+    "<nextsteps> block of 1-4 exact prompts the user can send back to you, one per numbered",
+    "line, for example:",
+    "<nextsteps>",
+    "1. Run the package tests and fix any failure",
+    "</nextsteps>",
+    "When the work is done, end with <nextsteps-complete/> instead."
+  ].join("\n");
+}
+function onPath(command, env = process.env, platform = process.platform) {
+  const pathVar = env.PATH ?? env.Path ?? "";
+  const exts = platform === "win32" ? ["", ...(env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";")] : [""];
+  const sep = platform === "win32" ? ";" : ":";
+  for (const dir of pathVar.split(sep)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      try {
+        if (statSync(join(dir, command + ext)).isFile()) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function installedBridgeAgents(acp, isOnPath = (c) => onPath(c)) {
+  if ((acp?.bridge?.servers ?? DEFAULT_BRIDGE_SERVERS).length === 0) return [];
+  const toCatalogId = new Map(Object.entries(REGISTRY_ID_ALIASES).map(([c, r]) => [r, c]));
+  const out = [];
+  for (const listed of acp?.bridge?.agents ?? DEFAULT_BRIDGE_AGENTS) {
+    const id = findAgentDescriptor(listed) ? listed : toCatalogId.get(listed) ?? listed;
+    if (out.includes(id)) continue;
+    const probe = findAgentDescriptor(id)?.probe.command;
+    if (acp?.agents?.[id] || acp?.agents?.[listed] || probe && isOnPath(probe)) out.push(id);
+  }
+  return out;
+}
+function wrongstackBridgeSetup(agentId, projectRoot, config, role = "worker") {
+  const agents = config?.agents ?? DEFAULT_BRIDGE_AGENTS;
+  const listed = (a) => a === agentId || REGISTRY_ID_ALIASES[a] === agentId || REGISTRY_ID_ALIASES[agentId] === a;
+  if (!agents.some(listed)) return void 0;
+  const servers = [...new Set(config?.servers ?? DEFAULT_BRIDGE_SERVERS)].filter(
+    (s) => Object.hasOwn(SERVER_NAMES, s)
+  );
+  if (servers.length === 0) return void 0;
+  const indexCli = config?.indexSurface === "cli" && servers.includes("codebase-index") ? wstackToolsCommand() : void 0;
+  const attached = indexCli ? servers.filter((s) => s !== "codebase-index") : servers;
+  return (_task, ctx) => ({
+    promptPrefix: bridgeTaskKickoff(servers, indexCli),
+    mcpServers: attached.map((server) => {
+      const launch = wstackLaunch(serverArgs(server, projectRoot, ctx));
+      return { name: SERVER_NAMES[server], ...launch, env: [] };
+    }),
+    meta: {
+      systemPrompt: {
+        // `@session` only reaches someone when a WrongStack session delegated the task.
+        append: role === "leader" ? leaderBridgeNote(servers, indexCli) : bridgeNote(servers, ctx.sessionId !== void 0, indexCli)
+      }
+    }
+  });
+}
+
+// src/hq-command-controller.ts
+function createProjectKanbanTransitionHandler(projectRoot) {
+  return async (input) => {
+    const { transitionTask } = await import("@wrongstack/kanban");
+    const result = await transitionTask(projectRoot, input.boardId, input.taskId, {
+      to: input.to,
+      actor: "hq-operator",
+      comment: input.comment,
+      sessionId: input.sessionId ?? "hq-mobile"
+    });
+    if (result === null) throw new Error(`kanban task not found: ${input.taskId}`);
+    return `task ${input.taskId} transitioned to ${input.to}`;
+  };
+}
+function createProjectKanbanAssignHandler(projectRoot) {
+  return async (input) => {
+    const { assignTask } = await import("@wrongstack/kanban");
+    const result = await assignTask(
+      projectRoot,
+      input.boardId,
+      input.taskId,
+      {
+        agentId: input.agentId,
+        name: input.assignee,
+        assignee: input.assignee,
+        status: "assigned",
+        protectActiveAssignment: true
+      },
+      {
+        actor: "hq-operator",
+        note: input.comment,
+        sessionId: input.sessionId ?? "hq-mobile"
+      }
+    );
+    if (result === null) throw new Error(`kanban task not found: ${input.taskId}`);
+    return `task ${input.taskId} assigned to ${input.assignee}`;
+  };
+}
+function createHqCommandDispatcher(controller) {
+  return async (command) => {
+    const cmd = command;
+    try {
+      const result = await dispatch(
+        controller,
+        cmd.commandId,
+        cmd.type,
+        cmd.payload
+      );
+      return result;
+    } catch (err) {
+      return {
+        commandId: command.commandId,
+        status: "failed",
+        message: err instanceof Error ? err.message : String(err)
+      };
+    }
+  };
+}
+function resolveCommandSessionId(controller, payload) {
+  const named = payload["sessionId"];
+  if (typeof named === "string" && named.length > 0) return named;
+  return controller.sessionId?.();
+}
+function rejectUnknownSession(controller, commandId, sessionId) {
+  const named = sessionId;
+  if (named === void 0) return null;
+  const owns = controller.ownsSession?.(named) ?? (controller.sessionId === void 0 ? true : controller.sessionId() === named);
+  if (owns) return null;
+  return {
+    commandId,
+    status: "rejected",
+    message: `session ${named} is not active on this client`
+  };
+}
+function leaderSessionAffinity(to, sessionId) {
+  if (to.trim().toLowerCase() !== "leader") return {};
+  if (typeof sessionId !== "string" || sessionId.length === 0) return {};
+  return { sessionAffinity: { sessionId } };
+}
+async function dispatch(controller, commandId, type, payload) {
+  const sessionId = resolveCommandSessionId(controller, payload);
+  const namedSession = typeof payload["sessionId"] === "string" ? payload["sessionId"] : void 0;
+  if (type !== "broadcast") {
+    const rejected = rejectUnknownSession(controller, commandId, namedSession);
+    if (rejected !== null) return rejected;
+  }
+  switch (type) {
+    case "steer": {
+      const mailbox = controller.steerMailbox;
+      if (mailbox === void 0) {
+        return { commandId, status: "rejected", message: "no mailbox available" };
+      }
+      const to = typeof payload["to"] === "string" ? payload["to"] : "leader";
+      const subject = typeof payload["subject"] === "string" ? payload["subject"] : "HQ steer";
+      const body = typeof payload["body"] === "string" ? payload["body"] : "";
+      const priority = payload["priority"] === "high" ? "high" : payload["priority"] === "low" ? "low" : "normal";
+      const from = `hq@${controller.sessionTag()}`;
+      await mailbox.send({
+        from,
+        to,
+        type: "steer",
+        subject,
+        body,
+        priority,
+        ...leaderSessionAffinity(to, sessionId)
+      });
+      return { commandId, status: "accepted", message: `steered ${to}` };
+    }
+    case "btw": {
+      const mailbox = controller.steerMailbox;
+      if (mailbox === void 0) {
+        return { commandId, status: "rejected", message: "no mailbox available" };
+      }
+      const to = typeof payload["to"] === "string" ? payload["to"] : "leader";
+      const subject = typeof payload["subject"] === "string" ? payload["subject"] : "HQ note";
+      const body = typeof payload["body"] === "string" ? payload["body"] : "";
+      const priority = payload["priority"] === "high" ? "high" : payload["priority"] === "low" ? "low" : "normal";
+      const from = `hq@${controller.sessionTag()}`;
+      await mailbox.send({
+        from,
+        to,
+        type: "btw",
+        subject,
+        body,
+        priority,
+        ...leaderSessionAffinity(to, sessionId)
+      });
+      return { commandId, status: "accepted", message: `noted ${to}` };
+    }
+    case "queue": {
+      const mailbox = controller.steerMailbox;
+      if (mailbox === void 0) {
+        return { commandId, status: "rejected", message: "no mailbox available" };
+      }
+      const to = typeof payload["to"] === "string" ? payload["to"] : "leader";
+      const subject = typeof payload["subject"] === "string" ? payload["subject"] : "HQ prompt";
+      const body = typeof payload["body"] === "string" ? payload["body"] : "";
+      const priority = payload["priority"] === "high" ? "high" : payload["priority"] === "low" ? "low" : "normal";
+      const from = `hq@${controller.sessionTag()}`;
+      await mailbox.send({
+        from,
+        to,
+        type: "note",
+        subject,
+        body,
+        priority,
+        ...leaderSessionAffinity(to, sessionId)
+      });
+      return { commandId, status: "accepted", message: `queued for ${to}` };
+    }
+    case "broadcast": {
+      const mailbox = controller.steerMailbox;
+      if (mailbox === void 0) {
+        return { commandId, status: "rejected", message: "no mailbox available" };
+      }
+      const subject = typeof payload["subject"] === "string" ? payload["subject"] : "HQ broadcast";
+      const body = typeof payload["body"] === "string" ? payload["body"] : "";
+      const priority = payload["priority"] === "high" ? "high" : payload["priority"] === "low" ? "low" : "normal";
+      const from = `hq@${controller.sessionTag()}`;
+      await mailbox.send({ from, to: "all", type: "broadcast", subject, body, priority });
+      return { commandId, status: "accepted", message: "broadcast sent" };
+    }
+    case "abort": {
+      const target = typeof payload["target"] === "string" ? payload["target"] : "leader";
+      if (target === "leader") {
+        const aborted = controller.interruptLeader(sessionId);
+        return {
+          commandId,
+          status: aborted ? "completed" : "accepted",
+          message: aborted ? "leader aborted" : "no active leader run"
+        };
+      }
+      if (target === "fleet") {
+        if (controller.killFleet === void 0) {
+          return {
+            commandId,
+            status: "rejected",
+            message: "this client does not manage a fleet"
+          };
+        }
+        const killed = await controller.killFleet(sessionId);
+        return {
+          commandId,
+          status: "completed",
+          message: `fleet stopped (${killed} agents)`
+        };
+      }
+      if (controller.terminateAgent === void 0) {
+        return {
+          commandId,
+          status: "rejected",
+          message: "this client does not manage subagents"
+        };
+      }
+      const terminated = await controller.terminateAgent(target, sessionId);
+      return {
+        commandId,
+        status: terminated ? "completed" : "rejected",
+        message: terminated ? `agent ${target} terminated` : `agent ${target} not found`
+      };
+    }
+    case "spawn": {
+      const role = typeof payload["role"] === "string" ? payload["role"] : "";
+      const task = typeof payload["task"] === "string" ? payload["task"] : void 0;
+      const maxIterations = typeof payload["maxIterations"] === "number" ? payload["maxIterations"] : void 0;
+      if (controller.spawnAgent === void 0) {
+        return { commandId, status: "rejected", message: "no director active" };
+      }
+      const subagentId = await controller.spawnAgent(role, task, maxIterations, sessionId);
+      return { commandId, status: "completed", message: `spawned ${subagentId}` };
+    }
+    case "kanban-transition": {
+      if (controller.kanbanTransition === void 0) {
+        return { commandId, status: "rejected", message: "kanban control is unavailable" };
+      }
+      const message = await controller.kanbanTransition({
+        boardId: payload["boardId"],
+        taskId: payload["taskId"],
+        to: payload["to"],
+        comment: payload["comment"],
+        ...sessionId !== void 0 ? { sessionId } : {}
+      });
+      return { commandId, status: "completed", message };
+    }
+    case "kanban-assign": {
+      if (controller.kanbanAssign === void 0) {
+        return { commandId, status: "rejected", message: "kanban assignment is unavailable" };
+      }
+      const message = await controller.kanbanAssign({
+        boardId: payload["boardId"],
+        taskId: payload["taskId"],
+        agentId: payload["agentId"],
+        assignee: payload["assignee"],
+        comment: payload["comment"],
+        ...sessionId !== void 0 ? { sessionId } : {}
+      });
+      return { commandId, status: "completed", message };
+    }
+    case "kanban-dispatch": {
+      if (controller.kanbanDispatch === void 0) {
+        return { commandId, status: "rejected", message: "kanban dispatch is unavailable" };
+      }
+      const message = await controller.kanbanDispatch({
+        boardId: payload["boardId"],
+        taskId: payload["taskId"],
+        comment: payload["comment"],
+        ...sessionId !== void 0 ? { sessionId } : {}
+      });
+      return { commandId, status: "completed", message };
+    }
+    case "approve": {
+      const resolveApproval = controller.resolveApproval;
+      if (resolveApproval === void 0) {
+        return {
+          commandId,
+          status: "rejected",
+          message: "this client does not mirror approvals"
+        };
+      }
+      const toolUseId = typeof payload["toolUseId"] === "string" ? payload["toolUseId"] : "";
+      const decision = payload["decision"];
+      if (toolUseId.length === 0 || decision !== "yes" && decision !== "no" && decision !== "always" && decision !== "always-exact" && decision !== "always-command" && decision !== "always-tool" && decision !== "deny") {
+        return { commandId, status: "rejected", message: "malformed approve command" };
+      }
+      const applied = resolveApproval(toolUseId, decision, sessionId);
+      if (!applied) {
+        return {
+          commandId,
+          status: "rejected",
+          // Says WHY, because "rejected" alone reads as a failure the operator
+          // should retry — and retrying a settled prompt does nothing.
+          message: `approval ${toolUseId} is no longer pending (already answered, aborted or timed out)`
+        };
+      }
+      return { commandId, status: "completed", message: `approval ${decision}` };
+    }
+    case "answer-input": {
+      const resolver = controller.resolveUserInput;
+      if (!resolver)
+        return {
+          commandId,
+          status: "rejected",
+          message: "this client does not mirror user input forms"
+        };
+      const requestId = typeof payload["requestId"] === "string" ? payload["requestId"] : "";
+      const response = payload["response"];
+      if (!requestId || !response || !Array.isArray(response.answers))
+        return { commandId, status: "rejected", message: "malformed answer-input command" };
+      if (!resolver(requestId, response, sessionId))
+        return {
+          commandId,
+          status: "rejected",
+          message: `user input ${requestId} is no longer pending`
+        };
+      return { commandId, status: "completed", message: "user input submitted" };
+    }
+    case "run-command": {
+      if (!controller.allowRunCommand()) {
+        return {
+          commandId,
+          status: "rejected",
+          message: "run-command requires operator opt-in (--hq-allow-exec)"
+        };
+      }
+      const mailbox = controller.steerMailbox;
+      const command = typeof payload["command"] === "string" ? payload["command"] : "";
+      if (mailbox !== void 0 && command.length > 0) {
+        const from = `hq@${controller.sessionTag()}`;
+        await mailbox.send({
+          from,
+          to: "leader",
+          type: "steer",
+          subject: "Run command (HQ)",
+          body: `Run the following shell command:
+
+\`\`\`
+${command}
+\`\`\``,
+          priority: "high",
+          ...leaderSessionAffinity("leader", sessionId)
+        });
+        return { commandId, status: "accepted", message: "run-command routed to leader as steer" };
+      }
+      return { commandId, status: "rejected", message: "cannot route run-command (no mailbox)" };
+    }
+    default:
+      return { commandId, status: "rejected", message: `unknown command type: ${type}` };
+  }
+}
+
+// src/fleet/wrongforge-info.ts
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { wstackGlobalRoot } from "@wrongstack/core/utils";
+function wrongForgeInfoCacheFile() {
+  return path.join(wstackGlobalRoot(), "cache", "wrongforge-info.json");
+}
+function parseWrongForgeInfo(body) {
+  const o = body && typeof body === "object" ? body : {};
+  const strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && x.length > 0) : [];
+  const def = o["default_model"] ?? o["defaultModel"];
+  const details = o["model_details"] ?? o["modelDetails"];
+  const effort = o["effort"];
+  const levels = effort?.levels ?? o["effortLevels"];
+  return {
+    models: strings(o["models"]),
+    ...typeof def === "string" && def ? { defaultModel: def } : {},
+    features: strings(o["features"]),
+    ...Array.isArray(levels) ? { effortLevels: strings(levels) } : {},
+    ...Array.isArray(details) ? {
+      modelDetails: details.flatMap((value) => {
+        if (!value || typeof value !== "object") return [];
+        const d = value;
+        if (typeof d["id"] !== "string" || !d["id"]) return [];
+        return [
+          {
+            id: d["id"],
+            description: typeof d["description"] === "string" ? d["description"] : "",
+            effortLevels: strings(d["effort_levels"] ?? d["effortLevels"])
+          }
+        ];
+      })
+    } : {}
+  };
+}
+function readCachedWrongForgeInfo(file = wrongForgeInfoCacheFile()) {
+  try {
+    const info = parseWrongForgeInfo(JSON.parse(readFileSync(file, "utf8").replace(/^\uFEFF/, "")));
+    return info.models.length > 0 ? info : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeWrongForgeInfoCache(info, file = wrongForgeInfoCacheFile()) {
+  if (info.models.length === 0) return;
+  try {
+    mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(info)}
+`);
+    renameSync(tmp, file);
+  } catch {
+  }
+}
+async function fetchWrongForgeInfo(ep, opts = {}) {
+  const res = await (opts.fetchImpl ?? fetch)(`${ep.url}/v1/info`, {
+    headers: { authorization: `Bearer ${ep.apiKey}` },
+    ...opts.signal ? { signal: opts.signal } : {}
+  });
+  if (!res.ok) throw new Error(`WrongForge /v1/info answered ${res.status}`);
+  return parseWrongForgeInfo(await res.json());
+}
+function refreshWrongForgeInfoCache(ep) {
+  if (!ep) return;
+  void fetchWrongForgeInfo(ep, { signal: AbortSignal.timeout(3e3) }).then((info) => writeWrongForgeInfoCache(info)).catch(() => void 0);
+}
+
+// src/fleet/wrongforge-quota.ts
+import {
+  DEFAULT_QUOTA_METER,
+  recordProviderQuota
+} from "@wrongstack/core/quota";
+var reads = /* @__PURE__ */ new Map();
+var REFRESH_MS = 2e4;
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function percent(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 100;
+}
+async function reportWrongForgeQuota(opts = {}) {
+  const endpoint = opts.endpoint ?? resolveWrongForgeEndpoint();
+  if (!endpoint) return false;
+  const providerId = opts.providerId ?? "wrongforge";
+  const key = `${providerId}\0${endpoint.url}\0${endpoint.apiKey}`;
+  const prior = reads.get(key);
+  if (prior?.pending) {
+    if (opts.force && !prior.forced) {
+      await prior.pending;
+      return reportWrongForgeQuota(opts);
+    }
+    return prior.pending;
+  }
+  if (!opts.force && prior && Date.now() - prior.at < REFRESH_MS) return prior.ok;
+  const state = { at: Date.now(), ok: false, forced: opts.force === true };
+  reads.set(key, state);
+  if (reads.size > 128)
+    for (const [id, entry] of reads) {
+      if (!entry.pending && id !== key) {
+        reads.delete(id);
+        break;
+      }
+    }
+  state.pending = (async () => {
+    try {
+      const signal = AbortSignal.timeout(opts.timeoutMs ?? 1e4);
+      const body = object(
+        await wrongForgeCall(endpoint, opts.fetchImpl)(
+          "GET",
+          `/v1/usage${opts.force ? "?force=1" : ""}`,
+          void 0,
+          signal
+        )
+      );
+      if (signal.aborted) return false;
+      const windows = [];
+      for (const spec of [
+        { key: "five_hour", id: "primary", label: "5h", windowMinutes: 300 },
+        { key: "weekly", id: "secondary", label: "weekly", windowMinutes: 10080 }
+      ]) {
+        const raw = object(body[spec.key]);
+        if (!percent(raw.percent)) continue;
+        const reset = typeof raw.resetsAt === "string" ? Date.parse(raw.resetsAt) : Number.NaN;
+        windows.push({
+          id: spec.id,
+          label: spec.label,
+          windowMinutes: spec.windowMinutes,
+          usedPercent: raw.percent,
+          ...Number.isFinite(reset) ? { resetsAt: Math.floor(reset / 1e3) } : {}
+        });
+      }
+      if (windows.length === 0) return false;
+      const extra = object(body.extra_usage);
+      const snapshot = {
+        providerId,
+        meterId: DEFAULT_QUOTA_METER,
+        meterLabel: "WrongForge \xB7 Claude subscription",
+        windows,
+        capturedAt: Date.now()
+      };
+      if (extra.enabled === false) snapshot.credits = { hasCredits: false, unlimited: false };
+      if (extra.enabled === true) {
+        snapshot.note = percent(extra.utilization) ? `Extra usage enabled \xB7 ${extra.utilization}% used` : "Extra usage enabled";
+        if (typeof extra.usedCredits === "number" && Number.isFinite(extra.usedCredits) && extra.usedCredits >= 0 && typeof extra.monthlyLimit === "number" && Number.isFinite(extra.monthlyLimit) && extra.monthlyLimit >= 0) {
+          const remaining = Math.max(0, extra.monthlyLimit - extra.usedCredits);
+          snapshot.credits = {
+            hasCredits: remaining > 0,
+            unlimited: false,
+            balance: `${remaining} credits remaining (${extra.usedCredits}/${extra.monthlyLimit})`
+          };
+        }
+      } else if (extra.enabled === false) snapshot.note = "Extra usage disabled";
+      const exhausted = windows.filter(
+        (window) => window.usedPercent >= 100 && (window.resetsAt === void 0 || window.resetsAt * 1e3 > snapshot.capturedAt)
+      );
+      exhausted.sort((a, b) => (b.resetsAt ?? Infinity) - (a.resetsAt ?? Infinity));
+      if (exhausted[0]) snapshot.reachedWindowId = exhausted[0].id;
+      recordProviderQuota(providerId, [snapshot]);
+      state.ok = true;
+      return true;
+    } catch {
+      return false;
+    } finally {
+      delete state.pending;
+    }
+  })();
+  return state.pending;
+}
+
+export {
+  DEFAULT_BRIDGE_SERVERS,
+  installedBridgeAgents,
+  wrongstackBridgeSetup,
+  createProjectKanbanTransitionHandler,
+  createProjectKanbanAssignHandler,
+  createHqCommandDispatcher,
+  parseWrongForgeInfo,
+  readCachedWrongForgeInfo,
+  writeWrongForgeInfoCache,
+  refreshWrongForgeInfoCache,
+  reportWrongForgeQuota
+};
+//# sourceMappingURL=chunk-5SGMUDP5.js.map