@wrongstack/cli 1.0.24 → 1.0.27

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

@@ -817,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." },
       {
@@ -830,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." }
     ],
@@ -959,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",
@@ -1080,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)"
@@ -1112,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",
@@ -1213,4 +1243,4 @@ export {
   subcommandsWithFocusedHelp,
   renderGenericHelp
 };
-//# sourceMappingURL=chunk-SKPDE62W.js.map
+//# sourceMappingURL=chunk-EPR42SWM.js.map

package/dist/{chunk-YBUCXXYZ.js → chunk-F5DCFAKI.js}

@@ -33,4 +33,4 @@ export {
   API_VERSION,
   STANDALONE_TARGET
 };
-//# sourceMappingURL=chunk-YBUCXXYZ.js.map
+//# sourceMappingURL=chunk-F5DCFAKI.js.map

package/dist/chunk-HDMFKTT3.js

@@ -0,0 +1,157 @@
+
+// src/boot/execution-mode.ts
+function resolveExecutionMode(positional, flags) {
+  const prompt = typeof flags["prompt"] === "string" ? flags["prompt"] : "";
+  if (positional.length > 0 || prompt.length > 0) return "single-shot";
+  if (flags.tui && flags["no-tui"] !== true && !flags.webui && !flags["webui-session-child"])
+    return "tui";
+  if (flags.webui || flags["webui-session-child"]) return "webui";
+  return "repl";
+}
+
+// src/hq-fleet-control.ts
+import {
+  areSubagentsAllowedForSession,
+  FLEET_ROSTER
+} from "@wrongstack/core/coordination";
+import { AgentError } from "@wrongstack/core/types";
+async function killHqSessionFleet(director, sessionId, scope) {
+  if (!director) return 0;
+  const owned = sessionId ? director.subagentIdsForSession(sessionId) : [];
+  if (owned.length > 0 && sessionId) {
+    await director.terminateSession(sessionId);
+    return owned.length;
+  }
+  if (scope.multiConversation) return 0;
+  let killed = 0;
+  for (const subagent of director.status().subagents) {
+    if (subagent.status === "running" || subagent.status === "idle") {
+      try {
+        await director.remove(subagent.id);
+        killed++;
+      } catch {
+      }
+    }
+  }
+  return killed;
+}
+async function terminateHqAgent(director, subagentId) {
+  if (!director) return false;
+  try {
+    await director.terminate(subagentId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function spawnHqAgent(director, sessionId, role, task, maxIterations) {
+  if (!director) {
+    throw new AgentError({
+      message: "Director is not available.",
+      code: "AGENT_RUN_FAILED",
+      context: { phase: "hq-spawn", role }
+    });
+  }
+  if (!areSubagentsAllowedForSession(sessionId)) {
+    throw new Error("Subagents are disabled for this session.");
+  }
+  const base = FLEET_ROSTER[role] ?? {
+    id: `manual-${Date.now()}`,
+    name: role,
+    maxIterations: maxIterations ?? 0,
+    maxToolCalls: 200
+  };
+  const overrides = maxIterations !== void 0 ? { maxIterations } : {};
+  const config = task !== void 0 ? { ...base, ...overrides, task } : { ...base, ...overrides };
+  return director.spawn({ ...config, originSessionId: sessionId });
+}
+function createHqFleetControl(getDirector, defaultSessionId, scope) {
+  return {
+    killFleet: (sessionId) => killHqSessionFleet(getDirector(), sessionId ?? defaultSessionId(), scope),
+    terminateAgent: (subagentId) => terminateHqAgent(getDirector(), subagentId),
+    spawnAgent: (role, task, maxIterations, sessionId) => spawnHqAgent(getDirector(), sessionId ?? defaultSessionId(), role, task, maxIterations)
+  };
+}
+
+// src/services/suggestion-store.ts
+var sharedSuggestions = [];
+var sharedAutoSuggestions = [];
+function setSuggestions(suggestions) {
+  sharedSuggestions = suggestions;
+}
+function setAutoSuggestions(suggestions) {
+  sharedAutoSuggestions = suggestions;
+}
+function getSuggestions() {
+  return sharedSuggestions;
+}
+function removeSuggestions(indices) {
+  if (indices.length === 0) return;
+  const set = new Set(indices);
+  sharedSuggestions = sharedSuggestions.filter((_, i) => !set.has(i));
+  sharedAutoSuggestions = [];
+}
+function clearSuggestions() {
+  sharedSuggestions = [];
+  sharedAutoSuggestions = [];
+}
+
+// src/tui-thinking-word.ts
+var DEFAULT_TUI_THINKING_WORD = "thinking";
+var MAX_TUI_THINKING_WORD_LENGTH = 16;
+function normalizeTuiThinkingWord(value) {
+  if (typeof value !== "string") return DEFAULT_TUI_THINKING_WORD;
+  const word = value.trim();
+  if (word.length === 0 || word.length > MAX_TUI_THINKING_WORD_LENGTH) {
+    return DEFAULT_TUI_THINKING_WORD;
+  }
+  if (!/^[\p{L}\p{N}_-]+$/u.test(word)) return DEFAULT_TUI_THINKING_WORD;
+  return word;
+}
+
+// src/services/run-git.ts
+import { spawn } from "node:child_process";
+import { toErrorMessage } from "@wrongstack/core/utils";
+async function runGit(args, cwd) {
+  try {
+    return await new Promise((resolve, reject) => {
+      const child = spawn("git", args, {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        signal: AbortSignal.timeout(3e4),
+        windowsHide: true
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (d) => {
+        stdout += d;
+      });
+      child.stderr?.on("data", (d) => {
+        stderr += d;
+      });
+      child.on("error", (err) => {
+        reject(new Error(`Failed to run git: ${err.message}`));
+      });
+      child.on("close", (code) => resolve({ stdout, stderr, code: code ?? 1 }));
+    });
+  } catch (err) {
+    throw new Error(toErrorMessage(err));
+  }
+}
+
+export {
+  resolveExecutionMode,
+  setSuggestions,
+  setAutoSuggestions,
+  getSuggestions,
+  removeSuggestions,
+  clearSuggestions,
+  killHqSessionFleet,
+  terminateHqAgent,
+  spawnHqAgent,
+  createHqFleetControl,
+  MAX_TUI_THINKING_WORD_LENGTH,
+  normalizeTuiThinkingWord,
+  runGit
+};
+//# sourceMappingURL=chunk-HDMFKTT3.js.map

package/dist/{chunk-PGKJ2OQP.js → chunk-HFZH2XJN.js}

@@ -1,10 +1,10 @@
 import {
   helpCmd,
   versionCmd
-} from "./chunk-2BKFWIER.js";
+} from "./chunk-5JYDKG5B.js";
 import {
   parseArgs
-} from "./chunk-MHEBWVXL.js";
+} from "./chunk-Q4INH2DG.js";
 
 // src/boot/short-circuit-flags.ts
 async function handleHelpVersionShortCircuit(argv) {
@@ -22,11 +22,11 @@ async function handleHelpVersionShortCircuit(argv) {
   }
   if (earlyFlags["help"] === true) {
     if (positional.length > 0) {
-      const { subcommandNames } = await import("./subcommands-ZTSIN7LG.js");
+      const { subcommandNames } = await import("./subcommands-BHQYLDSD.js");
       if (subcommandNames.includes(positional[0])) {
         const first = positional[0];
         const deep = positional[1];
-        const { renderDeepHelp, renderFocusedHelp } = await import("./per-subcommand-help-XE77MTGJ.js");
+        const { renderDeepHelp, renderFocusedHelp } = await import("./per-subcommand-help-QDAQASPZ.js");
         if (deep && renderDeepHelp(`${first}:${deep}`, stubRenderer)) {
           return 0;
         }
@@ -43,4 +43,4 @@ async function handleHelpVersionShortCircuit(argv) {
 export {
   handleHelpVersionShortCircuit
 };
-//# sourceMappingURL=chunk-PGKJ2OQP.js.map
+//# sourceMappingURL=chunk-HFZH2XJN.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-QFPQXKCG.js → chunk-KOEO4CJG.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-U3SS4NRH.js";
 import {
   checkForUpdate
-} from "./chunk-ZZRSG7VK.js";
+} from "./chunk-RZ4ZDRYA.js";
 
 // src/subcommands/handlers/update.ts
 import { spawn } from "node:child_process";
@@ -21,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",
@@ -77,11 +79,24 @@ async function runUpdateCommand(args, deps) {
     return 0;
   }
   if (isStandaloneBinary()) {
-    const { updateStandaloneBinary } = await import("./standalone-update-MW47J3AK.js");
-    return updateStandaloneBinary({
+    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
+      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;
@@ -184,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);
@@ -391,4 +406,4 @@ export {
   detectUpdatePackageManager,
   detectUpdatePackageName
 };
-//# sourceMappingURL=chunk-QFPQXKCG.js.map
+//# sourceMappingURL=chunk-KOEO4CJG.js.map

package/dist/chunk-LBPLTTZ6.js

@@ -0,0 +1,105 @@
+
+// src/preflight.ts
+import { ensureSessionShell } from "@wrongstack/tools/session-shell";
+
+// src/cli-update-notice.ts
+import { realpathSync } from "node:fs";
+import { isStandaloneBinary, writeErr } from "@wrongstack/core/utils";
+var NOTICE_FMT = `
+  \x1B[33m\u2191 Update available: v%s \u2192 v%s\x1B[0m  Run \`wrongstack update\` to upgrade.
+
+`;
+var READY_FMT = `
+  \x1B[33m\u2191 v%s is downloaded\x1B[0m  It replaces this executable when this session exits.
+
+`;
+var READY_MANUAL_FMT = `
+  \x1B[33m\u2191 v%s is downloaded\x1B[0m  Run \`wrongstack update\` to install it.
+
+`;
+var APPLIED_FMT = `
+  \x1B[32m\u2713 Updated wrongstack v%s \u2192 v%s\x1B[0m
+
+`;
+async function printStandaloneUpdateNotice(info, config) {
+  const [{ autoUpdateEnabled, standaloneUpdater, takeAppliedUpdate }, { isNewer }, version] = await Promise.all([
+    import("./standalone-auto-update-TOTRGCSA.js"),
+    import("./update-check-J5ZVKS73.js"),
+    import("./version-JB2UAV2A.js")
+  ]);
+  const applied = takeAppliedUpdate();
+  if (applied) writeErr(APPLIED_FMT.replace("%s", applied.from).replace("%s", applied.to));
+  const pending = standaloneUpdater({
+    executable: realpathSync(process.execPath),
+    target: version.STANDALONE_TARGET ?? "",
+    current: version.CLI_VERSION
+  }).pending();
+  if (pending && info && isNewer(pending.version, info.current) && pending.version === info.latest) {
+    const fmt = autoUpdateEnabled(config) ? READY_FMT : READY_MANUAL_FMT;
+    writeErr(fmt.replace("%s", pending.version));
+    return true;
+  }
+  return false;
+}
+async function printUpdateNotice(initialUpdateInfo, config) {
+  let info = initialUpdateInfo;
+  if (!info?.outdated) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 2e3);
+    try {
+      const { checkForUpdate } = await import("./update-check-J5ZVKS73.js");
+      info = await checkForUpdate(ac.signal);
+    } catch {
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  let reported = false;
+  if (isStandaloneBinary()) {
+    try {
+      reported = await printStandaloneUpdateNotice(info, config);
+    } catch {
+    }
+  }
+  if (info?.outdated && !reported) {
+    writeErr(NOTICE_FMT.replace("%s", info.current).replace("%s", info.latest));
+  }
+  return info;
+}
+
+// src/preflight.ts
+function applyNodeEnvDefault() {
+  if (process.env["NODE_ENV"] === void 0) {
+    process.env["NODE_ENV"] = "production";
+    process.env["WRONGSTACK_NODE_ENV_DEFAULTED"] = "1";
+  }
+}
+function applySessionShellDefault() {
+  ensureSessionShell();
+}
+async function applyPrintUpdateNotice(initialUpdateInfo, config) {
+  return await printUpdateNotice(initialUpdateInfo, config);
+}
+async function applyDebugStreamSeed(config) {
+  const { setDebugStreamEnabled } = await import("@wrongstack/providers");
+  if (config.debugStream) {
+    setDebugStreamEnabled(true);
+  }
+}
+async function runPreflight(config, initialUpdateInfo) {
+  applyNodeEnvDefault();
+  applySessionShellDefault();
+  const updateInfo = await applyPrintUpdateNotice(initialUpdateInfo, config);
+  await applyDebugStreamSeed(config);
+  return {
+    updateInfo,
+    debugStreamEnabled: Boolean(config.debugStream)
+  };
+}
+
+export {
+  applyNodeEnvDefault,
+  applySessionShellDefault,
+  runPreflight
+};
+//# sourceMappingURL=chunk-LBPLTTZ6.js.map

package/dist/{chunk-3OCUS3VN.js → chunk-LDCGZJTC.js}

@@ -1,9 +1,9 @@
-import {
-  activeProfileConfigPath
-} from "./chunk-YMXXOOFN.js";
 import {
   mutateConfigProviders
 } from "./chunk-LUMETJFO.js";
+import {
+  activeProfileConfigPath
+} from "./chunk-YMXXOOFN.js";
 
 // src/wiring/provider-persisters.ts
 import {
@@ -43,4 +43,4 @@ export {
   installProviderPersisters,
   applyProviderOAuthRefresh2 as applyProviderOAuthRefresh
 };
-//# sourceMappingURL=chunk-3OCUS3VN.js.map
+//# sourceMappingURL=chunk-LDCGZJTC.js.map