@wrongstack/cli 1.0.27 → 1.0.29

package/data/providers.json

@@ -4,6 +4,28 @@
     "name": "OpenAI Codex (ChatGPT sign-in)",
     "doc": "https://developers.openai.com/codex/models",
     "models": {
+      "gpt-6.1-sol": {
+        "id": "gpt-6.1-sol",
+        "name": "GPT-6.1 Sol",
+        "description": "Latest workhorse model for coding and everyday work.",
+        "reasoning": true,
+        "reasoningConfig": {
+          "default": "enabled",
+          "disableSupported": false,
+          "effortSupported": true,
+          "effortLevels": ["low", "medium", "high", "xhigh", "max"],
+          "preserveThinking": "unsupported"
+        },
+        "tool_call": true,
+        "modalities": {
+          "input": ["text", "image"],
+          "output": ["text"]
+        },
+        "limit": {
+          "context": 872000,
+          "output": 128000
+        }
+      },
       "gpt-6-astra": {
         "id": "gpt-6-astra",
         "name": "GPT-6 Astra",

package/dist/{acp-M4565YUW.js → acp-QWCBMQSO.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-NRXWOMK7.js";
 import {
   startCliHqConnection
-} from "./chunk-RGFWGUAB.js";
+} from "./chunk-4UWCMBPG.js";
 import "./chunk-SDJCLEK6.js";
 import "./chunk-F5DCFAKI.js";
 import "./chunk-SIGUWXAA.js";
@@ -1192,4 +1192,4 @@ ${renderAcpBenchText(result)}
 export {
   acpCmd
 };
-//# sourceMappingURL=acp-M4565YUW.js.map
+//# sourceMappingURL=acp-QWCBMQSO.js.map

package/dist/{chunk-RGFWGUAB.js → chunk-4UWCMBPG.js}

@@ -426,6 +426,146 @@ async function writeState(projectRoot, state) {
   await writeKanbanMetadata(projectRoot, SYNC_STATE_KEY, JSON.stringify(state));
 }
 
+// src/sage-hq-sync.ts
+import {
+  chunkHqSageRecords,
+  compareHqSageRecords,
+  isHqSageRecord,
+  MAX_HQ_SAGE_RECORD_BYTES
+} from "@wrongstack/core/hq";
+import { toErrorMessage } from "@wrongstack/core/utils";
+import { SageProjectServerConnection } from "@wrongstack/sage";
+function createSageHqSync(projectRoot, publisher, directory) {
+  const connection = new SageProjectServerConnection(projectRoot, directory);
+  const acknowledged = /* @__PURE__ */ new Map();
+  const sent = /* @__PURE__ */ new Map();
+  const warned = /* @__PURE__ */ new Map();
+  const remote = /* @__PURE__ */ new Map();
+  const controller = new AbortController();
+  const callOptions = { meta: { clientId: "hq-sage-sync" }, signal: controller.signal };
+  let stopped = false;
+  let running;
+  let lastFailure;
+  let lastScanVersion;
+  let generation = 0;
+  const version = (r) => `${r.revision}:${r.changeId}`;
+  const synchronize = async () => {
+    const startedGeneration = generation;
+    while (remote.size && !stopped && startedGeneration === generation) {
+      const batch = chunkHqSageRecords(publisher.project.projectId, remote.values()).next();
+      if (batch.done) break;
+      const records = batch.value.records;
+      for (const r of records) remote.delete(r.id);
+      try {
+        await connection.call("applyHqSync", { records }, callOptions);
+        for (const r of records) {
+          if (startedGeneration !== generation) break;
+          acknowledged.set(r.id, version(r));
+          if (sent.get(r.id) === version(r)) sent.delete(r.id);
+        }
+      } catch (error) {
+        if (stopped || startedGeneration !== generation) return;
+        for (const r of records) {
+          const pending = remote.get(r.id);
+          if (!pending || compareHqSageRecords(r, pending) > 0) remote.set(r.id, r);
+        }
+        throw error;
+      }
+    }
+    const scanVersion = await connection.call("getHqSyncVersion", {}, callOptions);
+    if (stopped || startedGeneration !== generation || !publisher.connected) return;
+    if (scanVersion === lastScanVersion && sent.size === 0) return;
+    let after = "";
+    while (!stopped && publisher.connected) {
+      const page = await connection.call("listHqSync", { after }, callOptions);
+      if (stopped || startedGeneration !== generation || !publisher.connected) return;
+      if (!page.length) {
+        lastScanVersion = scanVersion;
+        return;
+      }
+      const outgoing = page.filter((r) => {
+        if (acknowledged.get(r.id) === version(r)) {
+          sent.delete(r.id);
+          return false;
+        }
+        if (isHqSageRecord(r)) {
+          warned.delete(r.id);
+          return true;
+        }
+        if (warned.get(r.id) !== version(r)) {
+          process.emitWarning(
+            `SAGE memory ${r.id} cannot sync: invalid record or exceeds ${MAX_HQ_SAGE_RECORD_BYTES} bytes. Other memories will continue syncing.`,
+            { code: "WRONGSTACK_HQ_SAGE_RECORD_REJECTED" }
+          );
+          warned.set(r.id, version(r));
+        }
+        return false;
+      });
+      for (const payload of chunkHqSageRecords(publisher.project.projectId, outgoing)) {
+        for (const r of payload.records) sent.set(r.id, version(r));
+        publisher.publishEvent({
+          type: "sage.snapshot",
+          payload,
+          maxSummaryLength: MAX_HQ_SAGE_RECORD_BYTES
+        });
+      }
+      after = page[page.length - 1].id;
+    }
+  };
+  const refresh = () => {
+    if (stopped || !publisher.connected) return Promise.resolve();
+    if (running) return running;
+    running = synchronize().then(() => {
+      lastFailure = void 0;
+    }).catch((error) => {
+      const message = toErrorMessage(error);
+      if (!stopped && lastFailure !== message) {
+        process.emitWarning(`SAGE HQ sync will retry: ${message}`, {
+          code: "WRONGSTACK_HQ_SAGE_SYNC_FAILED"
+        });
+        lastFailure = message;
+      }
+    }).finally(() => {
+      running = void 0;
+    });
+    return running;
+  };
+  const unsubscribe = publisher.onConnected(() => {
+    generation++;
+    remote.clear();
+    acknowledged.clear();
+    sent.clear();
+    lastScanVersion = void 0;
+    void refresh();
+  });
+  const timer = setInterval(() => void refresh(), 3e3);
+  timer.unref?.();
+  void refresh();
+  return {
+    async handleRemote(snapshot) {
+      if (stopped || snapshot.projectId !== publisher.project.projectId) return;
+      for (const r of snapshot.records) {
+        const pending = remote.get(r.id);
+        if (!pending || compareHqSageRecords(r, pending) > 0) remote.set(r.id, r);
+      }
+      await refresh();
+    },
+    refresh,
+    stop() {
+      stopped = true;
+      controller.abort();
+      clearInterval(timer);
+      unsubscribe();
+      remote.clear();
+      acknowledged.clear();
+      sent.clear();
+      warned.clear();
+      connection.close();
+      void running?.finally(() => connection.close());
+    }
+  };
+}
+
 // src/hq-publisher.ts
 var HQ_DISCOVERY_CONNECTION_KEY = "<discover>";
 function nodeWsSocketFactory(url) {
@@ -450,15 +590,20 @@ function resolvedHqConnectionKey(options) {
   const endpoint = config.discover === true ? HQ_DISCOVERY_CONNECTION_KEY : `${config.url}
 ${config.token ?? ""}`;
   return `${endpoint}
-raw=${String(config.rawContent)}`;
+raw=${String(config.rawContent)}
+sage=${options.appConfig?.Sage?.storage?.directory ?? ""}`;
 }
 function startCliHqConnection(options) {
   const shouldOwnKanbanSync = options.ownKanbanSync !== false && options.onKanbanSnapshot === void 0;
   let kanbanSync;
+  let sageSync;
+  const shouldOwnSageSync = (options.ownSageSync ?? options.ownKanbanSync !== false) && options.onSageSnapshot === void 0;
   const publisherOptions = shouldOwnKanbanSync ? {
     ...options,
     onKanbanSnapshot: (snapshot) => kanbanSync?.handleRemote(snapshot)
-  } : options;
+  } : { ...options };
+  if (shouldOwnSageSync)
+    publisherOptions.onSageSnapshot = (snapshot) => sageSync?.handleRemote(snapshot);
   let publisher;
   let publisherKey;
   let timer;
@@ -467,6 +612,8 @@ function startCliHqConnection(options) {
     if (publisher === void 0) return;
     kanbanSync?.stop();
     kanbanSync = void 0;
+    sageSync?.stop();
+    sageSync = void 0;
     publisher.close();
     publisher = void 0;
     publisherKey = void 0;
@@ -484,6 +631,8 @@ function startCliHqConnection(options) {
 `)) publisher.refreshEndpoint();
       return;
     }
+    sageSync?.stop();
+    sageSync = void 0;
     publisher?.close();
     publisher = void 0;
     publisherKey = void 0;
@@ -495,6 +644,12 @@ function startCliHqConnection(options) {
       kanbanSync?.stop();
       kanbanSync = createKanbanHqSync(options.projectRoot, next.project.projectId);
     }
+    if (shouldOwnSageSync)
+      sageSync = createSageHqSync(
+        options.projectRoot,
+        next,
+        current.appConfig?.Sage?.storage?.directory
+      );
     next.connect();
     if (kanbanSync !== void 0) {
       kanbanSync.attachPublisher(next).catch((error) => {
@@ -520,6 +675,7 @@ function startCliHqConnection(options) {
         timer = void 0;
       }
       kanbanSync?.stop();
+      sageSync?.stop();
       publisher?.close();
       publisher = void 0;
       publisherKey = void 0;
@@ -530,4 +686,4 @@ function startCliHqConnection(options) {
 export {
   startCliHqConnection
 };
-//# sourceMappingURL=chunk-RGFWGUAB.js.map
+//# sourceMappingURL=chunk-4UWCMBPG.js.map

package/dist/{chunk-ENRYW73H.js → chunk-6A7URMWN.js}

@@ -1689,7 +1689,7 @@ import { WebSocket } from "ws";
 var HQ_SNAPSHOT_BROADCAST_DEBOUNCE_MS = 100;
 var HQ_SNAPSHOT_PERSIST_MIN_INTERVAL_MS = 3e3;
 var HQ_BROWSER_MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
-function sendGuarded(ws, data) {
+function sendGuarded(ws, data, callback) {
   if (ws.readyState !== WebSocket.OPEN) return false;
   const buffered = Number.isFinite(ws.bufferedAmount) ? ws.bufferedAmount : 0;
   if (buffered + Buffer.byteLength(data, "utf8") > HQ_BROWSER_MAX_BUFFERED_BYTES) {
@@ -1704,7 +1704,8 @@ function sendGuarded(ws, data) {
     return false;
   }
   try {
-    ws.send(data);
+    if (callback) ws.send(data, callback);
+    else ws.send(data);
     return true;
   } catch {
     return false;
@@ -3770,7 +3771,8 @@ function createHqServerShutdown(params) {
         params.persistence.eventLog.drain(),
         params.persistence.snapshotStore.drain(),
         params.persistence.timeseries.drain(),
-        params.persistence.kanban.drain()
+        params.persistence.kanban.drain(),
+        params.persistence.sage?.drain()
       ]).then(() => clearHqRuntimeMarker(params.dataDir, params.hqUrl)).catch(() => void 0).finally(() => res());
     });
   });
@@ -3849,16 +3851,56 @@ import {
   tightenHqRedactionPolicy as tightenHqRedactionPolicy2,
   tokenHasCapability as tokenHasCapability3
 } from "@wrongstack/core/hq";
+import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
 import { WebSocket as WebSocket3 } from "ws";
 
+// src/hq-server/sage-sync-send.ts
+import { chunkHqSageRecords } from "@wrongstack/core/hq";
+async function sendSageSnapshot(ws, snapshot) {
+  for (const part of chunkHqSageRecords(snapshot.projectId, snapshot.records)) {
+    const delivered = await new Promise((resolve) => {
+      let settled = false;
+      const finish = (ok) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        ws.removeListener("close", onClose);
+        resolve(ok);
+      };
+      const onClose = () => finish(false);
+      const timer = setTimeout(() => {
+        finish(false);
+        try {
+          ws.terminate();
+        } catch {
+        }
+      }, 1e4);
+      timer.unref?.();
+      ws.once("close", onClose);
+      const accepted = sendGuarded(
+        ws,
+        JSON.stringify({ type: "hq.sage_snapshot", payload: part }),
+        (error) => finish(!error)
+      );
+      if (!accepted) finish(false);
+    });
+    if (!delivered) return false;
+  }
+  return true;
+}
+
 // src/hq-server/ws-client-events.ts
 import {
+  chunkHqSageRecords as chunkHqSageRecords2,
   HQ_TRANSCRIPT_TEXT_CAP,
+  isHqSageSnapshotPayload,
+  MAX_HQ_SAGE_RECORD_BYTES,
   parseHqEventPayload,
   redactHqEvent,
   tightenHqRedactionPolicy,
   tokenHasCapability as tokenHasCapability2
 } from "@wrongstack/core/hq";
+import { toErrorMessage } from "@wrongstack/core/utils";
 function fanoutKanbanDelta(message, clients, _browsers, projectId) {
   let clientsNotified = 0;
   for (const peer of clients.values()) {
@@ -3908,12 +3950,33 @@ function handleIncomingClientEvent(ws, incomingEvent, clients, browsers, auth, s
       // Chat-transcript events carry full turns — the generic 500-char
       // summary cap would truncate them a second time after the
       // publisher already applied the transcript cap.
-      ...incomingEvent.type === "session.transcript" || incomingEvent.type === "agent.message" ? { maxSummaryLength: HQ_TRANSCRIPT_TEXT_CAP } : {}
+      ...incomingEvent.type === "sage.snapshot" ? { maxSummaryLength: MAX_HQ_SAGE_RECORD_BYTES } : incomingEvent.type === "session.transcript" || incomingEvent.type === "agent.message" ? { maxSummaryLength: HQ_TRANSCRIPT_TEXT_CAP } : {}
     }
   ).value;
   if (event.type === "client.heartbeat") {
     return;
   }
+  if (event.type === "sage.snapshot") {
+    const payload = event.payload;
+    if (!isHqSageSnapshotPayload(payload) || payload.projectId !== client.projectId || !persistence?.sage)
+      return;
+    void persistence.sage.merge(payload).then((merged) => {
+      for (const part of chunkHqSageRecords2(client.projectId, merged.records)) {
+        fanoutKanbanDelta(
+          JSON.stringify({ type: "hq.sage_snapshot", payload: part }),
+          clients,
+          browsers,
+          client.projectId
+        );
+      }
+    }).catch(
+      (error) => process.stderr.write(
+        `${JSON.stringify({ level: "warn", event: "hq.sage_sync_failed", projectId: client.projectId, message: toErrorMessage(error) })}
+`
+      )
+    );
+    return;
+  }
   if (event.type === "kanban.snapshot") {
     const payload = event.payload;
     if (payload.projectId !== client.projectId || persistence === void 0) return;
@@ -3934,7 +3997,7 @@ function handleIncomingClientEvent(ws, incomingEvent, clients, browsers, auth, s
         JSON.stringify({
           level: "warn",
           event: "hq.kanban_merge_failed",
-          message: error instanceof Error ? error.message : String(error),
+          message: toErrorMessage(error),
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         })
       );
@@ -4343,7 +4406,7 @@ function handleBrowser(ws, snapshotBroadcaster, browsers, eventLog) {
       JSON.stringify({
         level: "warn",
         event: "hq.browser_socket_error",
-        message: err instanceof Error ? err.message : String(err),
+        message: toErrorMessage2(err),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       })
     );
@@ -4424,7 +4487,7 @@ function handleClient(ws, clients, browsers, eventLog, auth, snapshotBroadcaster
       JSON.stringify({
         level: "warn",
         event: "hq.client_socket_error",
-        message: err instanceof Error ? err.message : String(err),
+        message: toErrorMessage2(err),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       })
     );
@@ -4525,6 +4588,14 @@ function handleClient(ws, clients, browsers, eventLog, auth, snapshotBroadcaster
           sendGuarded(ws, JSON.stringify({ type: "hq.kanban_snapshot", payload: p }));
         }).catch(() => void 0);
       }
+      if (persistence?.sage !== void 0) {
+        void persistence.sage.load(client.projectId).then((snapshot) => sendSageSnapshot(ws, snapshot)).catch(
+          (error) => process.stderr.write(
+            `${JSON.stringify({ level: "warn", event: "hq.sage_restore_failed", projectId: client.projectId, message: toErrorMessage2(error) })}
+`
+          )
+        );
+      }
       const event = redactHqEvent2(
         {
           id: randomUUID5(),
@@ -5296,4 +5367,4 @@ export {
   startHqServer,
   HqInsecureExposureError2 as HqInsecureExposureError
 };
-//# sourceMappingURL=chunk-ENRYW73H.js.map
+//# sourceMappingURL=chunk-6A7URMWN.js.map

package/dist/{chunk-HDMFKTT3.js → chunk-7IQWQCBH.js}

@@ -112,17 +112,20 @@ function normalizeTuiThinkingWord(value) {
 // src/services/run-git.ts
 import { spawn } from "node:child_process";
 import { toErrorMessage } from "@wrongstack/core/utils";
-async function runGit(args, cwd) {
+async function runGit(args, cwd, env) {
   try {
     return await new Promise((resolve, reject) => {
       const child = spawn("git", args, {
         cwd,
+        ...env ? { env: { ...process.env, ...env } } : {},
         stdio: ["ignore", "pipe", "pipe"],
         signal: AbortSignal.timeout(3e4),
         windowsHide: true
       });
       let stdout = "";
       let stderr = "";
+      child.stdout?.setEncoding("utf8");
+      child.stderr?.setEncoding("utf8");
       child.stdout?.on("data", (d) => {
         stdout += d;
       });
@@ -154,4 +157,4 @@ export {
   normalizeTuiThinkingWord,
   runGit
 };
-//# sourceMappingURL=chunk-HDMFKTT3.js.map
+//# sourceMappingURL=chunk-7IQWQCBH.js.map

package/dist/{chunk-5JYDKG5B.js → chunk-BZHT5GPF.js}

@@ -56,6 +56,11 @@ var helpCmd = async (_args, deps) => {
       ["wstack config-export | config-import", "Move behaviour settings via ./wstack-config.json"],
       ["wstack mcp", "MCP servers: list, add, remove, serve"],
       ["wstack import-claude-code", "Import MCP servers from Claude Code (preview; --apply)"],
+      [
+        "wstack sage connect",
+        "SAGE memory in Claude Code, Codex, Cursor, Antigravity (MCP + skill)"
+      ],
+      ["wstack sage sync", "Keep project SAGE memory synchronized through HQ"],
       ["wstack plugin", "Plugins: list, install, enable, disable, remove"],
       ["wstack tools | skills", "List registered tools / discovered skills"],
       ["wstack typesafe", "TypeSafe account: status, login, test"],
@@ -151,4 +156,4 @@ export {
   versionCmd,
   helpCmd
 };
-//# sourceMappingURL=chunk-5JYDKG5B.js.map
+//# sourceMappingURL=chunk-BZHT5GPF.js.map

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

@@ -1,7 +1,7 @@
 import {
   helpCmd,
   versionCmd
-} from "./chunk-5JYDKG5B.js";
+} from "./chunk-BZHT5GPF.js";
 import {
   parseArgs
 } from "./chunk-Q4INH2DG.js";
@@ -22,11 +22,11 @@ async function handleHelpVersionShortCircuit(argv) {
   }
   if (earlyFlags["help"] === true) {
     if (positional.length > 0) {
-      const { subcommandNames } = await import("./subcommands-BHQYLDSD.js");
+      const { subcommandNames } = await import("./subcommands-WX4GDMWB.js");
       if (subcommandNames.includes(positional[0])) {
         const first = positional[0];
         const deep = positional[1];
-        const { renderDeepHelp, renderFocusedHelp } = await import("./per-subcommand-help-QDAQASPZ.js");
+        const { renderDeepHelp, renderFocusedHelp } = await import("./per-subcommand-help-MWQWFIAV.js");
         if (deep && renderDeepHelp(`${first}:${deep}`, stubRenderer)) {
           return 0;
         }
@@ -43,4 +43,4 @@ async function handleHelpVersionShortCircuit(argv) {
 export {
   handleHelpVersionShortCircuit
 };
-//# sourceMappingURL=chunk-HFZH2XJN.js.map
+//# sourceMappingURL=chunk-IFQ6NQPL.js.map

package/dist/{chunk-N57IU5FG.js → chunk-KT34LWIS.js}

@@ -1,13 +1,13 @@
 
 // src/subcommands/index.ts
 var loaders = {
-  acp: async () => (await import("./acp-M4565YUW.js")).acpCmd,
+  acp: async () => (await import("./acp-QWCBMQSO.js")).acpCmd,
   init: async () => (await import("./init-DRMMFG2G.js")).initCmd,
   auth: async () => (await import("./auth-TE55JF4Z.js")).authCmd,
   update: async () => (await import("./update-TDZX4IL2.js")).updateCmd,
   remote: async () => (await import("./remote-GB5VXCCT.js")).remoteCmd,
-  sessions: async () => (await import("./sessions-config-XHLXJ5C3.js")).sessionsCmd,
-  config: async () => (await import("./sessions-config-XHLXJ5C3.js")).configCmd,
+  sessions: async () => (await import("./sessions-config-JGIZRNT6.js")).sessionsCmd,
+  config: async () => (await import("./sessions-config-JGIZRNT6.js")).configCmd,
   "config-export": async () => (await import("./config-transfer-RUWLDCNK.js")).configExportCmd,
   "config-import": async () => (await import("./config-transfer-RUWLDCNK.js")).configImportCmd,
   rewind: async () => (await import("./rewind-JA3ZLCNM.js")).rewindCmd,
@@ -16,7 +16,7 @@ var loaders = {
   tools: async () => (await import("./tools-skills-GH24UCBY.js")).toolsCmd,
   skills: async () => (await import("./tools-skills-GH24UCBY.js")).skillsCmd,
   "skill-suggest": async () => (await import("./skill-suggest-L2EVWB6R.js")).skillSuggestCmd,
-  typesafe: async () => (await import("./typesafe-U7YB2RRV.js")).typesafeCmd,
+  typesafe: async () => (await import("./typesafe-WA5O3KVS.js")).typesafeCmd,
   providers: async () => (await import("./providers-models-5Z2PJTEW.js")).providersCmd,
   models: async () => (await import("./providers-models-5Z2PJTEW.js")).modelsCmd,
   mcp: async () => (await import("./mcp-LBS45HWZ.js")).mcpCmd,
@@ -27,17 +27,18 @@ var loaders = {
   "proxy-status": async () => (await import("./diag-doctor-BIZAFIAT.js")).proxyCmd,
   export: async () => (await import("./export-VVRIOWFV.js")).exportCmd,
   usage: async () => (await import("./plugin-usage-CIGOOTX3.js")).usageCmd,
-  version: async () => (await import("./version-help-XJJQ7YSH.js")).versionCmd,
-  help: async () => (await import("./version-help-XJJQ7YSH.js")).helpCmd,
+  version: async () => (await import("./version-help-HN32QYQN.js")).versionCmd,
+  help: async () => (await import("./version-help-HN32QYQN.js")).helpCmd,
   projects: async () => (await import("./projects-T4CZCA25.js")).projectsCmd,
   modeldiag: async () => (await import("./modeldiag-W7XAE625.js")).modeldiagCmd,
   quick: async () => (await import("./quick-CNB4Z3HS.js")).quickCmd,
   bench: async () => (await import("./bench-GTLPM22B.js")).benchCmd,
   chronicle: async () => (await import("./chronicle-UTFETHP6.js")).chronicleCmd,
-  hq: async () => (await import("./hq-44F4OQH2.js")).hqCmd,
-  mailbox: async () => (await import("./mailbox-serve-GNGXEQ2R.js")).mailboxServeCmd,
+  hq: async () => (await import("./hq-BNK67HOE.js")).hqCmd,
+  mailbox: async () => (await import("./mailbox-serve-FW3JCCPK.js")).mailboxServeCmd,
   permissions: async () => (await import("./permissions-PL27UHYD.js")).permissionsCmd,
   project: async () => (await import("./project-AOQI5XTK.js")).projectCmd,
+  sage: async () => (await import("./sage-FFKUOCQL.js")).sageCmd,
   governance: async () => (await import("./governance-RYSHV675.js")).governanceCmd,
   "import-claude-code": async () => (await import("./import-claude-code-AYG24RG2.js")).importClaudeCodeCmd
 };
@@ -55,4 +56,4 @@ export {
   subcommands,
   subcommandNames
 };
-//# sourceMappingURL=chunk-N57IU5FG.js.map
+//# sourceMappingURL=chunk-KT34LWIS.js.map

package/dist/{chunk-UZ2TMHNH.js → chunk-UKP7H2U4.js}

@@ -8,6 +8,7 @@ var TTL_UNIT_MS = {
   d: 864e5,
   w: 6048e5
 };
+var MAX_SAFE_TTL_MS = 864e13;
 function parseTokenTtlValue(raw) {
   const trimmed = raw.trim();
   if (trimmed.length === 0) {
@@ -18,6 +19,9 @@ function parseTokenTtlValue(raw) {
     if (!Number.isFinite(ms) || ms <= 0) {
       return { error: `TTL value must be positive (got ${raw})` };
     }
+    if (!Number.isSafeInteger(ms) || ms > MAX_SAFE_TTL_MS) {
+      return { error: `TTL value exceeds maximum safe duration (got ${raw})` };
+    }
     return { value: ms };
   }
   const match = /^(?<value>\d+)(?<unit>ms|s|m|h|d|w)$/i.exec(trimmed);
@@ -28,7 +32,11 @@ function parseTokenTtlValue(raw) {
     if (!Number.isFinite(value) || value <= 0 || multiplier === void 0) {
       return { error: `TTL value must be positive with a valid unit (got ${raw})` };
     }
-    return { value: value * multiplier };
+    const totalMs = value * multiplier;
+    if (!Number.isSafeInteger(value) || !Number.isSafeInteger(totalMs) || totalMs > MAX_SAFE_TTL_MS) {
+      return { error: `TTL value exceeds maximum safe duration (got ${raw})` };
+    }
+    return { value: totalMs };
   }
   return {
     error: `TTL must be a positive integer (milliseconds) or <number><unit> where unit is one of ms, s, m, h, d, w (got ${raw})`
@@ -38,4 +46,4 @@ function parseTokenTtlValue(raw) {
 export {
   parseTokenTtlValue
 };
-//# sourceMappingURL=chunk-UZ2TMHNH.js.map
+//# sourceMappingURL=chunk-UKP7H2U4.js.map

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

@@ -1142,6 +1142,25 @@ var helpTable = {
     ],
     seeAlso: "wstack mcp list; --mcp-config (one-off servers without importing)"
   },
+  sage: {
+    name: "sage",
+    title: "wstack sage \u2014 this project's SAGE memory in other coding agents",
+    description: "Wire SAGE memory into Claude Code, Codex, Cursor or Antigravity over MCP: writes the MCP server entry plus a skill/rule telling the agent when to recall and how to propose. The server attaches to the SAGE daemon while wstack is open in this project and never starts one. Tools are read-only plus memory_candidates (list/propose); a proposal becomes memory only through WrongStack review. Search is lexical: semantic recall runs inside a WrongStack host.",
+    usage: "wstack sage connect <claude-code|codex|cursor|antigravity|all|print> [--dry-run]",
+    subcommands: [
+      { name: "connect <client|all>", description: "Write the MCP entry and skill for a client." },
+      { name: "connect print", description: "Print JSON/TOML config for any other MCP client." },
+      { name: "disconnect <client|all>", description: "Remove what connect wrote." },
+      { name: "mcp [--origin <name>]", description: "The stdio MCP server clients run." },
+      {
+        name: "sync [--restart-service]",
+        description: "Run project memory sync with HQ; optionally restart this project\u2019s SAGE owner."
+      },
+      { name: "--dry-run", description: "Show the file changes without writing." },
+      { name: "--command <path>", description: "Executable to launch instead of wstack." }
+    ],
+    seeAlso: "wstack mcp serve (all WrongStack tools over MCP)"
+  },
   // -- Chronicle ──────────────────────────────────────────────────────
   chronicle: {
     name: "chronicle",
@@ -1243,4 +1262,4 @@ export {
   subcommandsWithFocusedHelp,
   renderGenericHelp
 };
-//# sourceMappingURL=chunk-EPR42SWM.js.map
+//# sourceMappingURL=chunk-WRYZLEXP.js.map