@wrongstack/cli 1.0.28 → 1.0.29

package/dist/sage-FFKUOCQL.js

@@ -0,0 +1,475 @@
+import {
+  restoreFlags
+} from "./chunk-CSAPOCBP.js";
+
+// src/subcommands/handlers/sage.ts
+import { accessSync, constants, readFileSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path2 from "node:path";
+import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
+
+// src/sage-connect.ts
+import * as path from "node:path";
+import { toErrorMessage } from "@wrongstack/core/utils";
+var SAGE_CONNECT_TARGETS = ["claude-code", "codex", "cursor", "antigravity"];
+function isSageConnectTarget(value) {
+  return SAGE_CONNECT_TARGETS.includes(value);
+}
+function resolveSageLaunch(client, opts) {
+  const serveArgs = ["sage", "mcp", "--origin", client];
+  const command = opts.command?.trim() || "wstack";
+  const resolved = opts.findOnPath(command);
+  const platform = opts.platform ?? process.platform;
+  const shim = platform === "win32" && resolved !== null && /\.(cmd|bat)$/i.test(path.extname(resolved));
+  const launch = shim ? { command: "cmd", args: ["/c", command, ...serveArgs] } : { command, args: serveArgs };
+  if (resolved === null) {
+    return {
+      launch,
+      warning: `"${command}" is not on PATH, so ${client} will fail to start the server. Install wstack globally or pass --command <path to wstack>.`
+    };
+  }
+  return { launch };
+}
+var MANAGED_NOTE = "<!-- Managed by `wstack sage connect`; `wstack sage disconnect` removes it. -->";
+function layoutFor(target, skillName) {
+  switch (target) {
+    case "claude-code":
+      return {
+        mcpFile: ".mcp.json",
+        mcpFormat: "json",
+        guideFile: path.join(".claude", "skills", skillName, "SKILL.md"),
+        guideFormat: "skill",
+        notes: ["Claude Code asks once to approve project MCP servers from .mcp.json."]
+      };
+    case "codex":
+      return {
+        mcpFile: path.join(".codex", "config.toml"),
+        mcpFormat: "toml",
+        guideFile: path.join(".agents", "skills", skillName, "SKILL.md"),
+        guideFormat: "skill",
+        notes: [
+          "Codex reads a project .codex/config.toml only when the project is trusted; mark it trusted in Codex if the server does not appear."
+        ]
+      };
+    case "cursor":
+      return {
+        mcpFile: path.join(".cursor", "mcp.json"),
+        mcpFormat: "json",
+        guideFile: path.join(".cursor", "rules", `${skillName}.mdc`),
+        guideFormat: "cursor-rule",
+        notes: ["Enable the server once in Cursor Settings > MCP if it starts disabled."]
+      };
+    case "antigravity":
+      return {
+        mcpFile: path.join(".agents", "mcp_config.json"),
+        mcpFormat: "json",
+        guideFile: path.join(".agents", "skills", skillName, "SKILL.md"),
+        guideFormat: "skill",
+        notes: [
+          "If the server does not appear, add the `wstack sage connect print` JSON to ~/.gemini/config/mcp_config.json (some Antigravity CLI builds load MCP servers only from the global file)."
+        ]
+      };
+  }
+}
+function planSageConnect(target, opts) {
+  const layout = layoutFor(target, opts.guide.skillName);
+  const mcpPath = path.join(opts.projectRoot, layout.mcpFile);
+  const guidePath = path.join(opts.projectRoot, layout.guideFile);
+  const mcpBefore = opts.read(mcpPath);
+  const mcpAfter = layout.mcpFormat === "json" ? setJsonMcpServer(mcpBefore, opts.guide.serverName, jsonEntry(target, opts.launch), mcpPath) : setTomlMcpServer(mcpBefore, opts.guide.serverName, opts.launch);
+  const guideBefore = opts.read(guidePath);
+  const guideAfter = renderGuide(layout.guideFormat, opts.guide);
+  return {
+    target,
+    changes: [
+      change(mcpPath, mcpBefore, mcpAfter, `MCP server "${opts.guide.serverName}"`),
+      change(guidePath, guideBefore, guideAfter, guideSummary(layout.guideFormat))
+    ],
+    notes: layout.notes
+  };
+}
+function planSageDisconnect(target, opts) {
+  const layout = layoutFor(target, opts.guide.skillName);
+  const mcpPath = path.join(opts.projectRoot, layout.mcpFile);
+  const guidePath = path.join(opts.projectRoot, layout.guideFile);
+  const changes = [];
+  const mcpBefore = opts.read(mcpPath);
+  if (mcpBefore !== void 0) {
+    const after = layout.mcpFormat === "json" ? removeJsonMcpServer(mcpBefore, opts.guide.serverName, mcpPath) : removeTomlMcpServer(mcpBefore, opts.guide.serverName);
+    changes.push(removal(mcpPath, mcpBefore, after, `MCP server "${opts.guide.serverName}"`));
+  }
+  const guideBefore = opts.read(guidePath);
+  const sharedWith = SAGE_CONNECT_TARGETS.filter(
+    (other) => other !== target && layoutFor(other, opts.guide.skillName).guideFile === layout.guideFile && isSageConnected(other, opts)
+  );
+  if (guideBefore !== void 0) {
+    if (sharedWith.length > 0) {
+      changes.push({
+        path: guidePath,
+        action: "unchanged",
+        summary: `${guideSummary(layout.guideFormat)} (still used by ${sharedWith.join(", ")})`
+      });
+    } else if (guideBefore.includes(MANAGED_NOTE)) {
+      changes.push({
+        path: guidePath,
+        action: "delete",
+        summary: guideSummary(layout.guideFormat)
+      });
+    } else {
+      changes.push({
+        path: guidePath,
+        action: "unchanged",
+        summary: `${guideSummary(layout.guideFormat)} (edited by hand; left in place)`
+      });
+    }
+  }
+  return { target, changes, notes: [] };
+}
+function change(absPath, before, after, summary) {
+  if (before === after) return { path: absPath, action: "unchanged", summary };
+  return {
+    path: absPath,
+    action: before === void 0 ? "create" : "update",
+    content: after,
+    summary
+  };
+}
+function removal(absPath, before, after, summary) {
+  if (after === before)
+    return { path: absPath, action: "unchanged", summary: `${summary} (not present)` };
+  if (after.trim() === "" || after.trim() === "{}")
+    return { path: absPath, action: "delete", summary };
+  return { path: absPath, action: "update", content: after, summary };
+}
+function guideSummary(format) {
+  return format === "skill" ? "SAGE memory skill" : "SAGE memory rule";
+}
+function isSageConnected(target, opts) {
+  const layout = layoutFor(target, opts.guide.skillName);
+  const content = opts.read(path.join(opts.projectRoot, layout.mcpFile));
+  if (content === void 0) return false;
+  if (layout.mcpFormat === "toml") {
+    return content.split(/\r?\n/).some((line) => isOwnedTomlHeader(line, opts.guide.serverName));
+  }
+  try {
+    const servers = JSON.parse(content).mcpServers;
+    return typeof servers === "object" && servers !== null && opts.guide.serverName in servers;
+  } catch {
+    return false;
+  }
+}
+function jsonEntry(target, launch) {
+  return target === "claude-code" ? { type: "stdio", command: launch.command, args: launch.args } : { command: launch.command, args: launch.args };
+}
+function parseJsonObject(content, absPath) {
+  if (content === void 0 || content.trim() === "") return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (error) {
+    throw new Error(
+      `${absPath} is not valid JSON (${toErrorMessage(error)}); fix it by hand, nothing was changed.`
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${absPath} is not a JSON object; nothing was changed.`);
+  }
+  return parsed;
+}
+function serializeJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function setJsonMcpServer(content, name, entry, absPath) {
+  const root = parseJsonObject(content, absPath);
+  const servers = root["mcpServers"];
+  if (servers !== void 0 && (typeof servers !== "object" || servers === null || Array.isArray(servers))) {
+    throw new Error(`${absPath}: "mcpServers" is not an object; nothing was changed.`);
+  }
+  const next = {
+    ...root,
+    mcpServers: { ...servers ?? {}, [name]: entry }
+  };
+  const serialized = serializeJson(next);
+  if (content !== void 0 && serializeJson(root) === serialized) return content;
+  return serialized;
+}
+function removeJsonMcpServer(content, name, absPath) {
+  const root = parseJsonObject(content, absPath);
+  const servers = root["mcpServers"];
+  if (typeof servers !== "object" || servers === null || Array.isArray(servers) || !(name in servers)) {
+    return content;
+  }
+  const { [name]: _removed, ...rest } = servers;
+  const next = { ...root };
+  if (Object.keys(rest).length === 0) delete next["mcpServers"];
+  else next["mcpServers"] = rest;
+  return serializeJson(next);
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function isOwnedTomlHeader(line, name) {
+  const header = line.trim();
+  const bare = `mcp_servers.${name}`;
+  const quoted = `mcp_servers."${name}"`;
+  return [bare, quoted].some((key) => header === `[${key}]` || header.startsWith(`[${key}.`));
+}
+function stripTomlTable(content, name) {
+  const lines = content.split(/\r?\n/);
+  const kept = [];
+  let skipping = false;
+  for (const line of lines) {
+    if (/^\s*\[/.test(line)) skipping = isOwnedTomlHeader(line, name);
+    if (!skipping) kept.push(line);
+  }
+  return kept.join("\n");
+}
+function setTomlMcpServer(content, name, launch) {
+  const table = [
+    `[mcp_servers.${name}]`,
+    `command = ${tomlString(launch.command)}`,
+    `args = [${launch.args.map(tomlString).join(", ")}]`
+  ].join("\n");
+  const base = stripTomlTable(content ?? "", name).replace(/\s+$/, "");
+  const next = base ? `${base}
+
+${table}
+` : `${table}
+`;
+  if (content !== void 0 && content.replace(/\r\n/g, "\n") === next) return content;
+  return next;
+}
+function removeTomlMcpServer(content, name) {
+  const stripped = stripTomlTable(content, name);
+  if (stripped === content.replace(/\r\n/g, "\n")) return content;
+  const trimmed = stripped.replace(/\s+$/, "");
+  return trimmed ? `${trimmed}
+` : "";
+}
+function yamlString(value) {
+  return JSON.stringify(value);
+}
+function renderGuide(format, guide) {
+  const frontmatter = format === "skill" ? [`name: ${guide.skillName}`, `description: ${yamlString(guide.skillDescription)}`] : [`description: ${yamlString(guide.skillDescription)}`, "alwaysApply: false"];
+  return ["---", ...frontmatter, "---", "", guide.skillBody.trimEnd(), "", MANAGED_NOTE, ""].join(
+    "\n"
+  );
+}
+function renderSageConnectSnippets(launch, serverName) {
+  const json = JSON.stringify(
+    { mcpServers: { [serverName]: { command: launch.command, args: launch.args } } },
+    null,
+    2
+  );
+  return [
+    "JSON (Claude Desktop, Cursor, Antigravity, Windsurf, most MCP clients):",
+    json,
+    "",
+    "TOML (Codex):",
+    `[mcp_servers.${serverName}]`,
+    `command = ${tomlString(launch.command)}`,
+    `args = [${launch.args.map(tomlString).join(", ")}]`,
+    "",
+    "Start the client from the project root (or set its working directory to it):",
+    "the server serves the memory of the WrongStack project it is launched in."
+  ].join("\n");
+}
+
+// src/subcommands/handlers/sage.ts
+var USAGE = [
+  "Usage:",
+  `  wstack sage connect <${SAGE_CONNECT_TARGETS.join("|")}|all> [--dry-run] [--command <path>]`,
+  "  wstack sage connect print",
+  `  wstack sage disconnect <${SAGE_CONNECT_TARGETS.join("|")}|all> [--dry-run]`,
+  "  wstack sage mcp [--origin <name>]",
+  "  wstack sage sync [--restart-service]",
+  "",
+  "Connects this project's SAGE memory to another coding agent over MCP. The",
+  "server attaches to the SAGE daemon while wstack is open in this project; it",
+  "never starts one. Tools: memory_search, memory_for_file, memory_for_path,",
+  "memory_graph, and memory_candidates (list/propose only)."
+].join("\n");
+function optionValue(args, name) {
+  const flag = `--${name}`;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === flag) {
+      const next = args[i + 1];
+      return next !== void 0 && !next.startsWith("--") ? next : void 0;
+    }
+    if (arg.startsWith(`${flag}=`)) return arg.slice(flag.length + 1);
+  }
+  return void 0;
+}
+function positionals(args, valued) {
+  const out = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (valued.includes(arg.slice(2)) && !arg.includes("=")) i++;
+      continue;
+    }
+    out.push(arg);
+  }
+  return out;
+}
+function findExecutableOnPath(cmd) {
+  const exists = (p) => {
+    try {
+      accessSync(p, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (cmd.includes("/") || cmd.includes("\\")) return exists(cmd) ? path2.resolve(cmd) : null;
+  const suffixes = process.platform === "win32" && path2.extname(cmd) === "" ? (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+  for (const dir of (process.env["PATH"] ?? "").split(path2.delimiter)) {
+    if (!dir) continue;
+    for (const suffix of suffixes) {
+      const candidate = path2.join(dir, cmd + suffix);
+      if (exists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function readIfExists(absPath) {
+  try {
+    return readFileSync(absPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function applyChange(change2, projectRoot) {
+  if (change2.action === "delete") {
+    await fs.rm(change2.path, { force: true });
+    const root = path2.resolve(projectRoot);
+    let dir = path2.dirname(path2.resolve(change2.path));
+    while (dir !== root && dir.startsWith(root + path2.sep)) {
+      try {
+        await fs.rmdir(dir);
+      } catch {
+        break;
+      }
+      dir = path2.dirname(dir);
+    }
+    return;
+  }
+  if (change2.action === "create" || change2.action === "update") {
+    await fs.mkdir(path2.dirname(change2.path), { recursive: true });
+    await fs.writeFile(change2.path, change2.content ?? "", "utf8");
+  }
+}
+async function loadGuide() {
+  const mcp = await import("@wrongstack/sage-mcp");
+  return {
+    serverName: mcp.SAGE_MCP_SERVER_NAME,
+    skillName: mcp.SAGE_SKILL_NAME,
+    skillDescription: mcp.SAGE_SKILL_DESCRIPTION,
+    skillBody: mcp.SAGE_SKILL_BODY
+  };
+}
+function targetsFrom(word) {
+  if (word === "all") return [...SAGE_CONNECT_TARGETS];
+  if (word && isSageConnectTarget(word)) return [word];
+  return null;
+}
+var sageCmd = async (rawArgs, deps) => {
+  const args = restoreFlags(rawArgs, deps, ["origin", "command", "dry-run", "restart-service"]);
+  const words = positionals(args, ["origin", "command"]);
+  const sub = words[0];
+  const out = (line) => deps.renderer.write(`${line}
+`);
+  if (sub === "sync") {
+    const { runSageHqSyncCommand } = await import("./sage-sync-ZMTHB477.js");
+    return runSageHqSyncCommand(deps, args.includes("--restart-service"));
+  }
+  if (sub === "mcp") {
+    const client = optionValue(args, "origin")?.trim() || "mcp-client";
+    const { serveAttachedSageMcpStdio } = await import("@wrongstack/sage-mcp");
+    await serveAttachedSageMcpStdio({
+      projectRoot: deps.projectRoot,
+      directory: deps.config.Sage?.storage?.directory,
+      origin: client
+    });
+    return 0;
+  }
+  if (sub !== "connect" && sub !== "disconnect") {
+    out(USAGE);
+    return sub === void 0 || sub === "help" ? 0 : 1;
+  }
+  const guide = await loadGuide();
+  const dryRun = args.includes("--dry-run");
+  const command = optionValue(args, "command");
+  if (sub === "connect" && words[1] === "print") {
+    const { launch, warning } = resolveSageLaunch("mcp-client", {
+      command,
+      findOnPath: findExecutableOnPath
+    });
+    out(renderSageConnectSnippets(launch, guide.serverName));
+    if (warning) out(`
+warning: ${warning}`);
+    return 0;
+  }
+  const targets = targetsFrom(words[1]);
+  if (!targets) {
+    out(USAGE);
+    return words[1] === void 0 ? 0 : 1;
+  }
+  let failed = false;
+  const warnings = /* @__PURE__ */ new Set();
+  out(
+    `${dryRun ? "Preview (nothing written)" : sub === "connect" ? "Connecting" : "Disconnecting"} SAGE memory \u2014 project ${deps.projectRoot}`
+  );
+  for (const target of targets) {
+    out(`
+${target}:`);
+    try {
+      let plan;
+      if (sub === "connect") {
+        const { launch, warning } = resolveSageLaunch(target, {
+          command,
+          findOnPath: findExecutableOnPath
+        });
+        if (warning) warnings.add(warning);
+        plan = planSageConnect(target, {
+          projectRoot: deps.projectRoot,
+          launch,
+          guide,
+          read: readIfExists
+        });
+      } else {
+        plan = planSageDisconnect(target, {
+          projectRoot: deps.projectRoot,
+          guide,
+          read: readIfExists
+        });
+      }
+      if (plan.changes.length === 0) out("  nothing to remove");
+      for (const change2 of plan.changes) {
+        const rel = path2.relative(deps.projectRoot, change2.path) || change2.path;
+        out(`  ${change2.action.padEnd(9)} ${rel} \u2014 ${change2.summary}`);
+        if (!dryRun) await applyChange(change2, deps.projectRoot);
+      }
+      if (sub === "connect") for (const note of plan.notes) out(`  note: ${note}`);
+    } catch (error) {
+      failed = true;
+      deps.renderer.writeError(`  ${target}: ${toErrorMessage2(error)}`);
+    }
+  }
+  for (const warning of warnings) out(`
+warning: ${warning}`);
+  if (sub === "connect" && !dryRun && !failed) {
+    out(
+      "\nMemory is served while wstack is open in this project. Restart the client (or reload its MCP servers) to pick the server up."
+    );
+  }
+  return failed ? 1 : 0;
+};
+export {
+  findExecutableOnPath,
+  sageCmd
+};
+//# sourceMappingURL=sage-FFKUOCQL.js.map

package/dist/sage-connect.d.ts

@@ -0,0 +1,62 @@
+export declare const SAGE_CONNECT_TARGETS: readonly ['claude-code', 'codex', 'cursor', 'antigravity'];
+export type SageConnectTarget = (typeof SAGE_CONNECT_TARGETS)[number];
+export declare function isSageConnectTarget(value: string): value is SageConnectTarget;
+/** The guide pieces, injected so this module stays free of the MCP package. */
+export interface SageConnectGuide {
+    serverName: string;
+    skillName: string;
+    skillDescription: string;
+    skillBody: string;
+}
+export interface SageLaunch {
+    command: string;
+    args: string[];
+}
+export interface ResolveSageLaunchOptions {
+    /** `--command`: an explicit executable, used as written. */
+    command?: string | undefined;
+    platform?: NodeJS.Platform | undefined;
+    /** Resolve a bare command on PATH; `null` when absent. */
+    findOnPath: (cmd: string) => string | null;
+}
+/**
+ * The command a client runs. Bare `wstack` keeps project files portable
+ * between machines. On Windows an npm install is a `.cmd` shim, which a
+ * client spawning without a shell cannot start, so it goes through `cmd /c`.
+ */
+export declare function resolveSageLaunch(client: string, opts: ResolveSageLaunchOptions): {
+    launch: SageLaunch;
+    warning?: string;
+};
+export type PlannedChangeAction = 'create' | 'update' | 'delete' | 'unchanged';
+export interface PlannedChange {
+    /** Absolute path. */
+    path: string;
+    action: PlannedChangeAction;
+    /** New content for create/update. */
+    content?: string | undefined;
+    summary: string;
+}
+export interface SageConnectPlan {
+    target: SageConnectTarget;
+    changes: PlannedChange[];
+    notes: string[];
+}
+export interface PlanSageConnectOptions {
+    projectRoot: string;
+    launch: SageLaunch;
+    guide: SageConnectGuide;
+    /** Current content, `undefined` when the file does not exist. */
+    read: (absPath: string) => string | undefined;
+}
+export declare function planSageConnect(target: SageConnectTarget, opts: PlanSageConnectOptions): SageConnectPlan;
+export declare function planSageDisconnect(target: SageConnectTarget, opts: Omit<PlanSageConnectOptions, 'launch'>): SageConnectPlan;
+/** Whether `target`'s MCP file currently carries the SAGE server entry. */
+export declare function isSageConnected(target: SageConnectTarget, opts: Pick<PlanSageConnectOptions, 'projectRoot' | 'guide' | 'read'>): boolean;
+export declare function setJsonMcpServer(content: string | undefined, name: string, entry: Record<string, unknown>, absPath: string): string;
+export declare function removeJsonMcpServer(content: string, name: string, absPath: string): string;
+export declare function setTomlMcpServer(content: string | undefined, name: string, launch: SageLaunch): string;
+export declare function removeTomlMcpServer(content: string, name: string): string;
+/** `wstack sage connect print`: config for any MCP client, by hand. */
+export declare function renderSageConnectSnippets(launch: SageLaunch, serverName: string): string;
+//# sourceMappingURL=sage-connect.d.ts.map

package/dist/sage-hq-sync.d.ts

@@ -0,0 +1,8 @@
+import { type HqPublisher, type HqSageSnapshotPayload } from '@wrongstack/core/hq';
+/** Uses the single SQLite owner over IPC, including writes from MCP and other hosts. */
+export declare function createSageHqSync(projectRoot: string, publisher: HqPublisher, directory?: string): {
+    handleRemote(snapshot: HqSageSnapshotPayload): Promise<void>;
+    refresh: () => Promise<void>;
+    stop(): void;
+};
+//# sourceMappingURL=sage-hq-sync.d.ts.map

package/dist/sage-sync-ZMTHB477.js

@@ -0,0 +1,69 @@
+import {
+  startCliHqConnection
+} from "./chunk-4UWCMBPG.js";
+import "./chunk-F5DCFAKI.js";
+
+// src/subcommands/handlers/sage-sync.ts
+import { resolveHqConfig } from "@wrongstack/core/hq";
+import { SageProjectServerConnection } from "@wrongstack/sage";
+async function runSageHqSyncCommand(deps, restartService, signal) {
+  if (signal?.aborted) return 0;
+  if (!resolveHqConfig({ config: deps.config.hq })?.enabled) {
+    deps.renderer.writeError("HQ is disabled. Enable HQ before starting SAGE synchronization.\n");
+    return 1;
+  }
+  if (restartService) {
+    const control = new SageProjectServerConnection(
+      deps.projectRoot,
+      deps.config.Sage?.storage?.directory,
+      { spawnIfMissing: false }
+    );
+    try {
+      const result = await control.shutdown("operator-requested SAGE sync upgrade");
+      if (!result.stopped && result.reason !== "not-running") {
+        deps.renderer.writeError(`SAGE restart failed: ${result.reason ?? "unknown error"}
+`);
+        return 1;
+      }
+    } finally {
+      control.close();
+    }
+  }
+  if (signal?.aborted) return 0;
+  const connection = startCliHqConnection({
+    clientKind: "cli",
+    projectRoot: deps.projectRoot,
+    appConfig: deps.config,
+    capabilities: ["telemetry.publish"],
+    ownKanbanSync: false,
+    ownSageSync: true
+  });
+  deps.renderer.write(
+    `SAGE HQ sync running for ${connection.getPublisher()?.project.projectId ?? deps.projectRoot}. Reconnect is automatic; Ctrl+C stops this bridge.
+`
+  );
+  try {
+    await new Promise((resolve) => {
+      const keepAlive = setInterval(() => {
+      }, 6e4);
+      const stop = () => {
+        clearInterval(keepAlive);
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+        signal?.removeEventListener("abort", stop);
+        resolve();
+      };
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+      signal?.addEventListener("abort", stop, { once: true });
+      if (signal?.aborted) stop();
+    });
+    return 0;
+  } finally {
+    connection.stop();
+  }
+}
+export {
+  runSageHqSyncCommand
+};
+//# sourceMappingURL=sage-sync-ZMTHB477.js.map

package/dist/{sessions-config-XHLXJ5C3.js → sessions-config-JGIZRNT6.js}

@@ -18,13 +18,24 @@ import { color as color2, expectDefined } from "@wrongstack/core/utils";
 
 // src/subcommands/handlers/helpers.ts
 import { isSecretField } from "@wrongstack/core/security";
-function redactKeys(obj) {
+function redactKeys(obj, seen = /* @__PURE__ */ new WeakSet()) {
   if (!obj || typeof obj !== "object") return obj;
-  if (Array.isArray(obj)) return obj.map(redactKeys);
+  if (seen.has(obj)) return "[Circular]";
+  seen.add(obj);
+  if (Array.isArray(obj)) return obj.map((item) => redactKeys(item, seen));
   const out = {};
   for (const [k, v] of Object.entries(obj)) {
+    if (k === "__proto__") {
+      Object.defineProperty(out, k, {
+        value: redactKeys(v, seen),
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+      continue;
+    }
     if (isSecretField(k) && typeof v === "string" && v.length > 0) out[k] = "[REDACTED]";
-    else out[k] = redactKeys(v);
+    else out[k] = redactKeys(v, seen);
   }
   return out;
 }
@@ -525,4 +536,4 @@ export {
   configCmd,
   sessionsCmd
 };
-//# sourceMappingURL=sessions-config-XHLXJ5C3.js.map
+//# sourceMappingURL=sessions-config-JGIZRNT6.js.map

package/dist/{short-circuit-flags-BSIPTAPD.js → short-circuit-flags-5N2LPK4R.js}

@@ -1,10 +1,10 @@
 import {
   handleHelpVersionShortCircuit
-} from "./chunk-L5TD7UIG.js";
-import "./chunk-5JYDKG5B.js";
+} from "./chunk-IFQ6NQPL.js";
+import "./chunk-BZHT5GPF.js";
 import "./chunk-F5DCFAKI.js";
 import "./chunk-Q4INH2DG.js";
 export {
   handleHelpVersionShortCircuit
 };
-//# sourceMappingURL=short-circuit-flags-BSIPTAPD.js.map
+//# sourceMappingURL=short-circuit-flags-5N2LPK4R.js.map

package/dist/subcommands/handlers/helpers.d.ts

@@ -1,2 +1,2 @@
-export declare function redactKeys(obj: unknown): unknown;
+export declare function redactKeys(obj: unknown, seen?: WeakSet<object>): unknown;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/subcommands/handlers/sage-sync.d.ts

@@ -0,0 +1,4 @@
+import type { SubcommandDeps } from '../contracts.js';
+/** A memory-only HQ connection for headless hosts and upgrading active sessions. */
+export declare function runSageHqSyncCommand(deps: SubcommandDeps, restartService: boolean, signal?: AbortSignal): Promise<number>;
+//# sourceMappingURL=sage-sync.d.ts.map

package/dist/subcommands/handlers/sage.d.ts

@@ -0,0 +1,5 @@
+import type { SubcommandHandler } from '../contracts.js';
+/** PATH lookup with PATHEXT on Windows; an explicit path is checked as written. */
+export declare function findExecutableOnPath(cmd: string): string | null;
+export declare const sageCmd: SubcommandHandler;
+//# sourceMappingURL=sage.d.ts.map