@wrongstack/cli 1.0.19 → 1.0.26

package/dist/chunk-CZTXF6HY.js

@@ -0,0 +1,140 @@
+
+// src/context-limit.ts
+import { refreshCatalogIfStale } from "@wrongstack/core/models";
+import { mergeCustomModelDefs, toErrorMessage } from "@wrongstack/core/utils";
+import { capabilitiesFor } from "@wrongstack/providers";
+var SIBLING_CATALOG = {
+  "anthropic-oauth": "anthropic",
+  "openai-codex": "openai",
+  "github-copilot": "openai",
+  "google-antigravity": "google"
+};
+async function resolveRuntimeMaxContextDetailed(input) {
+  const providerConfig = input.runtimeProviderConfig ?? input.config.providers?.[input.providerId];
+  const providerOverride = positiveNumber(readConfiguredMaxContext(providerConfig));
+  if (providerOverride) return { maxContext: providerOverride, branch: "provider-override" };
+  const catalogId = providerConfig?.type && providerConfig.type !== input.providerId ? providerConfig.type : input.providerId;
+  const sibling = providerConfig?.family ? SIBLING_CATALOG[providerConfig.family] : void 0;
+  if (sibling && input.modelsRegistry) {
+    const mergedModels = mergeCustomModelDefs(providerConfig?.customModels, input.config.models);
+    const ownModel = await input.modelsRegistry.getModel(catalogId, input.modelId).catch(() => void 0);
+    if (ownModel) {
+      const ownCaps = await capabilitiesFor(
+        input.modelsRegistry,
+        catalogId,
+        input.modelId,
+        mergedModels
+      ).catch(() => void 0);
+      const ownMax = positiveNumber(ownCaps?.maxContext) ?? positiveNumber(ownModel.capabilities.maxContext);
+      if (ownMax) return { maxContext: ownMax, branch: "catalog-capabilities" };
+    }
+    const caps = await capabilitiesFor(
+      input.modelsRegistry,
+      sibling,
+      input.modelId,
+      mergedModels
+    ).catch(() => void 0);
+    const siblingMax = positiveNumber(caps?.maxContext);
+    if (siblingMax) return { maxContext: siblingMax, branch: "sibling-capabilities" };
+    const directModel = await input.modelsRegistry.getModel(sibling, input.modelId).catch(() => void 0);
+    const directMax = positiveNumber(directModel?.capabilities.maxContext);
+    if (directMax) return { maxContext: directMax, branch: "sibling-direct-model" };
+  }
+  let divergedFromCatalog = false;
+  if (input.modelsRegistry) {
+    const topLevelBaseUrlApplies = input.providerId === input.config.provider;
+    const configuredBaseUrl = providerConfig?.baseUrl ?? (topLevelBaseUrlApplies ? input.config.baseUrl : void 0);
+    let divergesFromCatalog = false;
+    if (configuredBaseUrl) {
+      const resolved = await safeGetProvider(input.modelsRegistry, catalogId);
+      divergesFromCatalog = normalizeBaseUrl(configuredBaseUrl) !== normalizeBaseUrl(resolved?.apiBase);
+    }
+    divergedFromCatalog = divergesFromCatalog;
+    if (!divergesFromCatalog) {
+      const mergedModels = mergeCustomModelDefs(providerConfig?.customModels, input.config.models);
+      const caps = await capabilitiesFor(
+        input.modelsRegistry,
+        catalogId,
+        input.modelId,
+        mergedModels
+      ).catch(() => void 0);
+      const catalogMax = positiveNumber(caps?.maxContext);
+      if (catalogMax) return { maxContext: catalogMax, branch: "catalog-capabilities" };
+      const directModel = await input.modelsRegistry.getModel(catalogId, input.modelId).catch(() => void 0);
+      const directMax = positiveNumber(directModel?.capabilities.maxContext);
+      if (directMax) return { maxContext: directMax, branch: "catalog-direct-model" };
+    }
+  }
+  const explicitContext = positiveNumber(input.config.context?.effectiveMaxContext);
+  if (explicitContext) {
+    return { maxContext: explicitContext, branch: "explicit-config-fallback" };
+  }
+  const familyDefault = positiveNumber(input.provider.capabilities.maxContext) ?? 0;
+  const branch = familyDefault === 0 ? "unknown" : divergedFromCatalog ? "diverging-baseurl-family-default" : "family-default";
+  return { maxContext: familyDefault, branch };
+}
+async function resolveRuntimeMaxContext(input) {
+  const { maxContext } = await resolveRuntimeMaxContextDetailed(input);
+  return maxContext;
+}
+var SUSPICIOUS_SHRINK_BRANCHES = /* @__PURE__ */ new Set([
+  "family-default",
+  "diverging-baseurl-family-default"
+]);
+function describeMaxContextChange(params) {
+  const { previous, current, providerId, modelId } = params;
+  if (current === previous) return void 0;
+  const branch = params.branch ?? "unknown";
+  const shrank = previous > 0 && current > 0 && current < previous;
+  const suspicious = SUSPICIOUS_SHRINK_BRANCHES.has(branch);
+  const detail = `max-context ${previous} \u2192 ${current} for ${providerId}/${modelId} (branch=${branch}${shrank ? ", DECREASED" : ""})`;
+  return shrank && suspicious ? {
+    level: "warn",
+    message: `Context window shrank via a non-catalog branch: ${detail}`,
+    shrank,
+    branch
+  } : { level: "debug", message: detail, shrank, branch };
+}
+async function refreshRuntimeModelCatalog(input) {
+  if (!input.modelsRegistry) return false;
+  try {
+    if (await refreshCatalogIfStale(input.modelsRegistry) === "recent") return false;
+    input.logger?.debug?.(
+      `models.dev catalog refreshed${input.reason ? ` (${input.reason})` : ""}`
+    );
+    return true;
+  } catch (err) {
+    input.logger?.warn?.(
+      `models.dev refresh failed${input.reason ? ` (${input.reason})` : ""}: ${toErrorMessage(err)}; using cached catalog`
+    );
+    return false;
+  }
+}
+async function safeGetProvider(registry, id) {
+  try {
+    return await registry.getProvider(id);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeBaseUrl(url) {
+  if (!url) return "";
+  return url.trim().toLowerCase().replace(/\/+$/, "");
+}
+function readConfiguredMaxContext(providerConfig) {
+  if (!providerConfig || typeof providerConfig !== "object") return void 0;
+  const capabilities = providerConfig.capabilities;
+  if (!capabilities || typeof capabilities !== "object") return void 0;
+  return capabilities.maxContext;
+}
+function positiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+
+export {
+  resolveRuntimeMaxContextDetailed,
+  resolveRuntimeMaxContext,
+  describeMaxContextChange,
+  refreshRuntimeModelCatalog
+};
+//# sourceMappingURL=chunk-CZTXF6HY.js.map

package/dist/{chunk-JX6KL7OF.js → chunk-EPR42SWM.js}

@@ -1,6 +1,6 @@
 import {
   renderAuthLocalHelpToString
-} from "./chunk-2VMJ3E5Z.js";
+} from "./chunk-YTEOAWOJ.js";
 
 // src/subcommands/handlers/per-subcommand-help.ts
 import { color as color3 } from "@wrongstack/core/utils";
@@ -780,10 +780,11 @@ var helpTable = {
     name: "config",
     title: "wstack config \u2014 show or edit effective config",
     description: "Print the resolved config (with the on-disk overrides merged on top), or open the active profile config in $EDITOR for interactive edits. Also exposes a small audit log of recent config-history changes for diagnostics.",
-    usage: "wstack config [show|edit|history|restore] [...]",
+    usage: "wstack config [show|edit|backup|history|restore] [...]",
     subcommands: [
       { name: "show", description: "Print the resolved config to stdout (default)." },
       { name: "edit", description: "Open the active profile config in $EDITOR." },
+      { name: "backup", description: "Create a recoverable snapshot of the active profile." },
       { name: "history", description: "List recent config-history entries." },
       { name: "restore <id>", description: "Restore a previous config-history entry." }
     ],
@@ -816,7 +817,7 @@ var helpTable = {
     name: "sessions",
     title: "wstack sessions \u2014 list and resume recent sessions",
     description: "List recent sessions, show one session in detail, resume a session, or inspect a session's audit log. The audit log is stored as JSONL next to each session's recording.",
-    usage: "wstack sessions [list|show|resume|fork|doctor|config|fleet] [...]",
+    usage: "wstack sessions [list|show|resume|fork|move|doctor|config|fleet] [...]",
     subcommands: [
       { name: "list", description: "List the most recent sessions." },
       {
@@ -829,6 +830,10 @@ var helpTable = {
         name: "fork [<id>] [--to N]",
         description: "Create an isolated child journal at a persisted boundary."
       },
+      {
+        name: "move <id> --to <path>",
+        description: "Move a closed session to another git worktree of this repository, or to another project (its journal moves to that project)."
+      },
       { name: "config", description: "Show or edit session-specific config." },
       { name: "fleet", description: "List the active fleet of sessions." }
     ],
@@ -958,6 +963,13 @@ var helpTable = {
     usage: "wstack update [--check-only] [--pm <manager>] [--allow-scripts (alias: --lifecycle-scripts)]",
     seeAlso: "wstack version (read-only version info)"
   },
+  remote: {
+    name: "remote",
+    title: "wstack remote \u2014 run WrongStack on another machine over SSH",
+    description: "Runs WrongStack on the remote machine, in the given project directory, and opens its WebUI here through an SSH tunnel; the agent, its tools and its daemons run remotely. The system ssh is used, so ~/.ssh/config, your agent and known_hosts apply. The matching build is uploaded once per version to ~/.wrongstack/remote and checked by SHA-256. A dropped connection is reopened; the remote host keeps running meanwhile. Nothing from your local configuration is copied: set up a provider in the remote WebUI the first time.",
+    usage: "wstack remote <user@host:/path | ssh://user@host:port/path> [--port <n>] [--open] [--keep] [--ssh-config <file>] [--remote-binary <file>]",
+    seeAlso: "wstack --remote <target> (same command)"
+  },
   // -- ACP (Agent Client Protocol) --------------------------------------
   acp: {
     name: "acp",
@@ -1079,13 +1091,17 @@ var helpTable = {
   // -- Permissions ────────────────────────────────────────────────────
   permissions: {
     name: "permissions",
-    title: "wstack permissions \u2014 explain tool permission decisions",
-    description: "Side-effect-free permission decision explainer. Evaluates the effective permission rules for a tool and input arguments without prompting, modifying trust files, or mutating state.",
-    usage: "wstack permissions explain <tool> [--input '<json>'] [--json]",
+    title: "wstack permissions \u2014 list and explain the permission rules",
+    description: "Side-effect-free views of the permission policy the agent runs under: every rule in the order it is checked, and how one tool call is decided, without prompting, modifying trust files, or mutating state. Inside a session, /permissions also sets allow/deny rules for that session only.",
+    usage: "wstack permissions [rules|explain <tool> [--input '<json>']] [--json]",
     subcommands: [
+      {
+        name: "rules",
+        description: "List every permission rule, in the order they are checked (first match decides)."
+      },
       {
         name: "explain <tool>",
-        description: "Explain how the permission policy evaluates a tool call."
+        description: "Explain how the permission policy decides a tool call, and name the rule."
       }
     ],
     seeAlso: "wstack tools (list available tools)"
@@ -1111,6 +1127,21 @@ var helpTable = {
     subcommands: [{ name: "status", description: "Show daemon and attachment-broker health." }],
     seeAlso: "wstack doctor (broader environment diagnostics)"
   },
+  "import-claude-code": {
+    name: "import-claude-code",
+    title: "wstack import-claude-code \u2014 bring a Claude Code setup across",
+    description: "Import MCP servers from ~/.claude.json (user + this project) and the repository's .mcp.json into the active profile. Previews by default. Repository servers arrive disabled unless --enable-project-servers. Skills are read in place; hooks, permission rules and CLAUDE.md are reported with next steps, not translated.",
+    usage: "wstack import-claude-code [--apply] [--overwrite] [--enable-project-servers]",
+    subcommands: [
+      { name: "--apply", description: "Write the plan (default: preview only)." },
+      { name: "--overwrite", description: "Replace servers that already exist by name." },
+      {
+        name: "--enable-project-servers",
+        description: "Enable the repository's .mcp.json servers on import."
+      }
+    ],
+    seeAlso: "wstack mcp list; --mcp-config (one-off servers without importing)"
+  },
   // -- Chronicle ──────────────────────────────────────────────────────
   chronicle: {
     name: "chronicle",
@@ -1212,4 +1243,4 @@ export {
   subcommandsWithFocusedHelp,
   renderGenericHelp
 };
-//# sourceMappingURL=chunk-JX6KL7OF.js.map
+//# sourceMappingURL=chunk-EPR42SWM.js.map

package/dist/chunk-F5DCFAKI.js

@@ -0,0 +1,36 @@
+
+// src/version.ts
+import { createRequire } from "node:module";
+var req = createRequire(import.meta.url);
+var standaloneBuild = globalThis[/* @__PURE__ */ Symbol.for("wrongstack.standalone-build")];
+function readOwnVersion() {
+  if (standaloneBuild?.version) return standaloneBuild.version;
+  const candidates = ["../package.json", "../../package.json"];
+  for (const rel of candidates) {
+    try {
+      const pkg = req(rel);
+      if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
+    } catch {
+    }
+  }
+  return "dev";
+}
+var CLI_VERSION = readOwnVersion();
+function readApiVersion() {
+  if (standaloneBuild?.apiVersion) return standaloneBuild.apiVersion;
+  try {
+    const corePkg = req("@wrongstack/core/package.json");
+    if (corePkg.wrongstackApiVersion) return corePkg.wrongstackApiVersion;
+  } catch {
+  }
+  return "0.0.0";
+}
+var API_VERSION = readApiVersion();
+var STANDALONE_TARGET = standaloneBuild?.target;
+
+export {
+  CLI_VERSION,
+  API_VERSION,
+  STANDALONE_TARGET
+};
+//# sourceMappingURL=chunk-F5DCFAKI.js.map

package/dist/chunk-HLSHFXTO.js

@@ -0,0 +1,97 @@
+
+// src/boot/mcp-config-flag.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringRecord(value, where) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value) || Object.values(value).some((v) => typeof v !== "string")) {
+    throw new Error(`${where} must be an object of strings`);
+  }
+  return value;
+}
+function normalizeMcpServerEntry(name, raw) {
+  if (!isRecord(raw)) throw new Error(`server "${name}" must be an object`);
+  const where = `server "${name}"`;
+  const { type, transport: rawTransport, ...rest } = raw;
+  let transport;
+  if (rawTransport !== void 0) {
+    if (rawTransport !== "stdio" && rawTransport !== "sse" && rawTransport !== "streamable-http") {
+      throw new Error(`${where}: unknown transport "${String(rawTransport)}"`);
+    }
+    transport = rawTransport;
+  } else if (type !== void 0) {
+    if (type === "http") transport = "streamable-http";
+    else if (type === "sse" || type === "stdio") transport = type;
+    else throw new Error(`${where}: unknown type "${String(type)}"`);
+  } else if (typeof rest["command"] === "string") {
+    transport = "stdio";
+  }
+  if (transport === "stdio" && typeof rest["command"] !== "string") {
+    throw new Error(`${where}: stdio needs a "command"`);
+  }
+  if ((transport === "sse" || transport === "streamable-http") && typeof rest["url"] !== "string") {
+    throw new Error(`${where}: ${transport} needs a "url"`);
+  }
+  if (rest["args"] !== void 0 && !Array.isArray(rest["args"])) {
+    throw new Error(`${where}: "args" must be an array`);
+  }
+  const env = stringRecord(rest["env"], `${where} "env"`);
+  const headers = stringRecord(rest["headers"], `${where} "headers"`);
+  return {
+    ...rest,
+    ...transport ? { transport } : {},
+    ...env ? { env } : {},
+    ...headers ? { headers } : {}
+  };
+}
+function parseLaunchMcpServers(text, source) {
+  let doc;
+  try {
+    doc = JSON.parse(text);
+  } catch (err) {
+    throw new Error(`--mcp-config: ${source} is not valid JSON (${err.message})`);
+  }
+  if (!isRecord(doc)) throw new Error(`--mcp-config: ${source} must be a JSON object`);
+  const servers = isRecord(doc["mcpServers"]) ? doc["mcpServers"] : doc;
+  const out = {};
+  for (const [name, raw] of Object.entries(servers)) {
+    try {
+      out[name] = { ...normalizeMcpServerEntry(name, raw), enabled: true };
+    } catch (err) {
+      throw new Error(`--mcp-config: ${source}: ${err.message}`);
+    }
+  }
+  return out;
+}
+async function resolveLaunchMcpServers(flags, cwd) {
+  const value = flags["mcp-config"];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("--mcp-config needs a JSON file path or an inline JSON object");
+  }
+  const trimmed = value.trim();
+  if (trimmed.startsWith("{")) return parseLaunchMcpServers(trimmed, "inline JSON");
+  const file = path.resolve(cwd, trimmed);
+  let text;
+  try {
+    text = await fs.readFile(file, "utf8");
+  } catch (err) {
+    const reason = err.code ?? String(err);
+    throw new Error(`--mcp-config: cannot read ${file} (${reason})`);
+  }
+  return parseLaunchMcpServers(text, file);
+}
+function effectiveMcpServers(configured, launch, strict) {
+  return { ...strict ? {} : configured ?? {}, ...launch ?? {} };
+}
+
+export {
+  normalizeMcpServerEntry,
+  parseLaunchMcpServers,
+  resolveLaunchMcpServers,
+  effectiveMcpServers
+};
+//# sourceMappingURL=chunk-HLSHFXTO.js.map

package/dist/{chunk-CJTBLTS4.js → chunk-KJS5543T.js}

@@ -1,6 +1,6 @@
 import {
   CLI_VERSION
-} from "./chunk-XJXDOF63.js";
+} from "./chunk-F5DCFAKI.js";
 
 // src/hq-publisher.ts
 import { createHqPublisherFromEnv, resolveHqConfig } from "@wrongstack/core/hq";
@@ -10,6 +10,7 @@ import { WebSocket } from "ws";
 import {
   deriveHqProjectId,
   MAX_HQ_KANBAN_BOARD_BYTES,
+  MAX_HQ_KANBAN_BOARDS,
   redactHqEventPayload
 } from "@wrongstack/core/hq";
 import {
@@ -337,7 +338,7 @@ function chunkSnapshotPayload(projectId, generatedAt, boards, tombstones) {
         { code: "WRONGSTACK_HQ_KANBAN_OVERSIZED_RECORD" }
       );
     }
-    if ((currentBoards.length > 0 || currentTombstones.length > 0) && currentBytes + additionalBytes > MAX_KANBAN_SNAPSHOT_PAYLOAD_BYTES) {
+    if ((currentBoards.length > 0 || currentTombstones.length > 0) && (currentBytes + additionalBytes > MAX_KANBAN_SNAPSHOT_PAYLOAD_BYTES || itemCount >= MAX_HQ_KANBAN_BOARDS)) {
       pushCurrent();
     }
     if (kind === "boards") {
@@ -517,4 +518,4 @@ function startCliHqConnection(options) {
 export {
   startCliHqConnection
 };
-//# sourceMappingURL=chunk-CJTBLTS4.js.map
+//# sourceMappingURL=chunk-KJS5543T.js.map

package/dist/{chunk-DE7BZDNK.js → chunk-KOEO4CJG.js}

@@ -3,12 +3,13 @@ import {
 } from "./chunk-U3SS4NRH.js";
 import {
   checkForUpdate
-} from "./chunk-YLQEGYV4.js";
+} from "./chunk-RZ4ZDRYA.js";
 
 // src/subcommands/handlers/update.ts
 import { spawn } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
 import * as path from "node:path";
+import { isStandaloneBinary } from "@wrongstack/core/utils";
 var MAX_UPDATE_OUTPUT_CHARS = 256 * 1024;
 async function runUpdateCommand(args, deps) {
   const cwd = deps.cwd;
@@ -20,6 +21,8 @@ async function runUpdateCommand(args, deps) {
     (flag) => ![
       "check-only",
       "c",
+      // `-c` after the top-level parser's expansion; see mergeUpdateArgs.
+      "continue",
       "pm",
       "package-manager",
       "allow-scripts",
@@ -55,7 +58,7 @@ async function runUpdateCommand(args, deps) {
   });
   if (info.checkFailed) {
     deps.renderer.write(
-      `Update check failed for ${packageName}. Check your internet connection and try again.
+      `Update check failed for ${isStandaloneBinary() ? "the GitHub releases" : packageName}. Check your internet connection and try again.
 `
     );
     return 1;
@@ -75,6 +78,26 @@ async function runUpdateCommand(args, deps) {
 `);
     return 0;
   }
+  if (isStandaloneBinary()) {
+    const [{ updateStandaloneBinary }, { standaloneUpdater }, { STANDALONE_TARGET }] = await Promise.all([
+      import("./standalone-update-LZO3MNLH.js"),
+      import("./standalone-auto-update-TOTRGCSA.js"),
+      import("./version-JB2UAV2A.js")
+    ]);
+    const updater = standaloneUpdater({
+      executable: realpathSync(process.execPath),
+      target: STANDALONE_TARGET ?? "",
+      current: info.current
+    });
+    const code = await updateStandaloneBinary({
+      current: info.current,
+      renderer: deps.renderer,
+      // A build the background updater already downloaded and verified.
+      staged: updater.pending()
+    });
+    if (code === 0) updater.clear();
+    return code;
+  }
   const packageManager = parsed.packageManager ?? detectUpdatePackageManager();
   let updateCommand;
   try {
@@ -176,7 +199,7 @@ function mergeUpdateArgs(args, flags) {
     if (flags[name] === true || flags[name] === "true") merged.push(`--${alias}`);
   };
   addBoolean("check-only");
-  if (flags["c"] === true || flags["c"] === "true") merged.push("-c");
+  if (flags["continue"] === true || flags["c"] === true || flags["c"] === "true") merged.push("-c");
   addBoolean("allow-scripts");
   addBoolean("lifecycle-scripts");
   for (const pm of ["npm", "pnpm", "yarn", "bun"]) addBoolean(pm);
@@ -383,4 +406,4 @@ export {
   detectUpdatePackageManager,
   detectUpdatePackageName
 };
-//# sourceMappingURL=chunk-DE7BZDNK.js.map
+//# sourceMappingURL=chunk-KOEO4CJG.js.map