@wrongstack/cli 1.0.28 → 1.0.32

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

@@ -9,6 +9,42 @@ function resolveExecutionMode(positional, flags) {
   return "repl";
 }
 
+// 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/hq-fleet-control.ts
 import {
   areSubagentsAllowedForSession,
@@ -73,42 +109,6 @@ function createHqFleetControl(getDirector, defaultSessionId, scope) {
   };
 }
 
-// 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";
@@ -149,12 +149,12 @@ export {
   getSuggestions,
   removeSuggestions,
   clearSuggestions,
+  MAX_TUI_THINKING_WORD_LENGTH,
+  normalizeTuiThinkingWord,
   killHqSessionFleet,
   terminateHqAgent,
   spawnHqAgent,
   createHqFleetControl,
-  MAX_TUI_THINKING_WORD_LENGTH,
-  normalizeTuiThinkingWord,
   runGit
 };
-//# sourceMappingURL=chunk-7IQWQCBH.js.map
+//# sourceMappingURL=chunk-3LEFXLAW.js.map

package/dist/{chunk-WSTVGC2C.js → chunk-4BX2YDTQ.js}

@@ -187,7 +187,14 @@ async function ensureHistoryDir(homeFn = defaultHomeDir, targetConfigPath) {
 async function readIndex(homeFn = defaultHomeDir, targetConfigPath) {
   try {
     const raw = await fs.readFile(historyIndexPath(homeFn, targetConfigPath), "utf8");
-    return JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && Array.isArray(parsed.entries)) {
+      const entries = parsed.entries.filter(
+        (e) => e !== null && typeof e === "object" && typeof e.id === "string"
+      );
+      return { version: 1, entries };
+    }
+    return { version: 1, entries: [] };
   } catch {
     return { version: 1, entries: [] };
   }
@@ -301,11 +308,11 @@ async function listHistory(homeFn = defaultHomeDir, targetConfigPath) {
   return idx.entries;
 }
 async function getHistoryEntry(id, homeFn = defaultHomeDir, targetConfigPath) {
+  const dir = historyDir(homeFn, targetConfigPath);
+  const filePath = path.join(dir, `${id}.json`);
+  if (path.dirname(path.resolve(filePath)) !== path.resolve(dir)) return null;
   try {
-    const raw = await fs.readFile(
-      path.join(historyDir(homeFn, targetConfigPath), `${id}.json`),
-      "utf8"
-    );
+    const raw = await fs.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -391,4 +398,4 @@ export {
   restoreFromHistory,
   restoreLast
 };
-//# sourceMappingURL=chunk-WSTVGC2C.js.map
+//# sourceMappingURL=chunk-4BX2YDTQ.js.map

package/dist/{chunk-SFBFYIOW.js → chunk-4MDRHMX4.js}

@@ -1,7 +1,7 @@
 import {
   appendHistory,
   backupCurrent
-} from "./chunk-WSTVGC2C.js";
+} from "./chunk-4BX2YDTQ.js";
 
 // src/settings-menu.ts
 import * as fs from "node:fs/promises";
@@ -55,6 +55,7 @@ var PROJECT_SAFE_FIELDS = /* @__PURE__ */ new Set([
   "fallbackProfile",
   "favoriteModels",
   "disabledModels",
+  "disabledProviders",
   "favoriteModelsOnly",
   "modelAvailabilitySchedule",
   "fallbackAuto",
@@ -268,4 +269,4 @@ export {
   persistTelegramConfig,
   deriveFsAccessPair
 };
-//# sourceMappingURL=chunk-SFBFYIOW.js.map
+//# sourceMappingURL=chunk-4MDRHMX4.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-RDGGWMTI.js → chunk-65VNCAF6.js}

@@ -1,11 +1,6 @@
 import {
   resolveProviderCfgWithProxy
 } from "./chunk-SDJCLEK6.js";
-import {
-  fallbackCodexProviderModels,
-  filterCurrentCodexModelIds,
-  isCodexCatalogModel
-} from "./chunk-SIGUWXAA.js";
 
 // src/acp-agent-list.ts
 import { REGISTRY_ID_ALIASES } from "@wrongstack/acp";
@@ -117,7 +112,7 @@ async function loadCachedAcpRegistry(paths) {
     const raw = await fs.readFile(acpRegistryCachePath(paths), "utf8");
     const env = JSON.parse(raw);
     if (!Array.isArray(env.agents)) return null;
-    const byId = {};
+    const byId = /* @__PURE__ */ Object.create(null);
     for (const a of env.agents) {
       if (!a?.id || !a.acp?.command) continue;
       byId[a.id] = {
@@ -227,21 +222,6 @@ async function setupProvider(params) {
       let models;
       if (savedModels && savedModels.length > 0) {
         models = savedModels.map((m) => ({ id: m, name: m }));
-      } else if (family === "openai-codex") {
-        const openaiProvider = await modelsRegistry.getProvider("openai").catch(() => void 0);
-        if (openaiProvider) {
-          const catalogById = new Map(
-            openaiProvider.models.filter(isCodexCatalogModel).map((m) => [m.id, { id: m.id, name: m.name }])
-          );
-          const catalogModels = filterCurrentCodexModelIds(catalogById.keys()).map((id) => catalogById.get(id)).filter((m) => Boolean(m));
-          if (catalogModels.length > 0) {
-            models = catalogModels;
-          } else {
-            models = fallbackCodexProviderModels();
-          }
-        } else {
-          models = fallbackCodexProviderModels();
-        }
       } else {
         models = [];
       }
@@ -336,4 +316,4 @@ export {
   setupProvider,
   createGracefulShutdown
 };
-//# sourceMappingURL=chunk-RDGGWMTI.js.map
+//# sourceMappingURL=chunk-65VNCAF6.js.map

package/dist/{chunk-WQZW3RDP.js → chunk-7BNBD4PE.js}

@@ -1,6 +1,6 @@
 import {
   loadManifest
-} from "./chunk-IS2PPBQV.js";
+} from "./chunk-X4LW5CZM.js";
 
 // src/project-picker.ts
 import { color } from "@wrongstack/core/utils";
@@ -415,4 +415,4 @@ export {
   skipDivider,
   runProjectPicker
 };
-//# sourceMappingURL=chunk-WQZW3RDP.js.map
+//# sourceMappingURL=chunk-7BNBD4PE.js.map

package/dist/chunk-CFHWIFXL.js

@@ -0,0 +1,123 @@
+
+// src/boot/auto-discover-providers.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { discoverOpenAICompatibleModels, resolveDiscoveryTargets } from "@wrongstack/providers";
+async function readCache(file) {
+  try {
+    return JSON.parse(await fs.readFile(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function discoverAndMergeProviders(opts) {
+  const targets = resolveDiscoveryTargets(opts.config);
+  if (targets.length === 0) return;
+  const cacheFile = path.join(opts.cacheDir, "discovered-models-cache.json");
+  const cache = await readCache(cacheFile);
+  let cacheDirty = false;
+  await Promise.all(
+    targets.map(async (target) => {
+      const previousCacheKey = target.cacheKey;
+      const {
+        id,
+        cfg,
+        baseUrl,
+        apiKey,
+        modelDiscoveryPath,
+        modelDiscoveryAuthoritative,
+        accountCatalog,
+        copilotCatalog,
+        modelsUrl,
+        headers,
+        prepareApiKey
+      } = target;
+      let failureReason = "model catalog request failed";
+      const provider = await discoverOpenAICompatibleModels(id, {
+        baseUrl,
+        apiKey,
+        headers: { ...cfg.headers, ...headers },
+        accountCatalog,
+        copilotCatalog,
+        modelsUrl,
+        providerName: id,
+        modelDiscoveryPath,
+        fetchImpl: opts.fetchImpl,
+        prepareApiKey,
+        onFailure: (reason) => {
+          failureReason = reason;
+        }
+      });
+      if (target.isCurrent && !target.isCurrent()) return;
+      const { cacheKey } = target;
+      if (provider) {
+        if (accountCatalog) cfg.models = Object.keys(provider.models);
+        const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+        cache[cacheKey] = { fetchedAt, provider };
+        cacheDirty = true;
+        if (modelDiscoveryAuthoritative) {
+          opts.registry.mergeOverlay(
+            { [id]: provider },
+            { observedAt: fetchedAt, authoritativeProviderIds: [id] }
+          );
+        } else {
+          opts.registry.mergeOverlay({ [id]: provider });
+        }
+        opts.logger?.info(
+          `auto-discovered ${Object.keys(provider.models).length} models for "${id}" from ${baseUrl}`
+        );
+        return;
+      }
+      const cached = cache[cacheKey] ?? cache[previousCacheKey];
+      if (cached) {
+        if (cacheKey !== previousCacheKey) {
+          cache[cacheKey] = cached;
+          cacheDirty = true;
+        }
+        if (accountCatalog) cfg.models = Object.keys(cached.provider.models);
+        if (modelDiscoveryAuthoritative) {
+          opts.registry.mergeOverlay(
+            { [id]: cached.provider },
+            { observedAt: cached.fetchedAt, authoritativeProviderIds: [id] }
+          );
+        } else {
+          opts.registry.mergeOverlay({ [id]: cached.provider });
+        }
+        opts.logger?.warn(
+          `auto-discovery for "${id}" failed; using ${Object.keys(cached.provider.models).length} cached models from ${cached.fetchedAt} (${failureReason})`
+        );
+      } else {
+        if (accountCatalog) {
+          cfg.models = [];
+          opts.registry.mergeOverlay(
+            {
+              [id]: {
+                id,
+                name: id,
+                npm: "@ai-sdk/openai-compatible",
+                api: baseUrl,
+                env: [],
+                models: {}
+              }
+            },
+            { authoritativeProviderIds: [id] }
+          );
+        }
+        opts.logger?.warn(
+          `auto-discovery for "${id}" failed and no cache available (${failureReason}; catalog at ${baseUrl})`
+        );
+      }
+    })
+  );
+  if (cacheDirty) {
+    try {
+      await fs.writeFile(cacheFile, JSON.stringify(cache), "utf8");
+    } catch {
+    }
+  }
+}
+
+export {
+  discoverAndMergeProviders
+};
+//# sourceMappingURL=chunk-CFHWIFXL.js.map

package/dist/{chunk-RZ4ZDRYA.js → chunk-DIOODAYM.js}

@@ -144,7 +144,7 @@ async function checkForUpdate(signalOrOptions, legacyHomeFn) {
     };
   }
   try {
-    const latest = packageName === "standalone-binary" ? await (await import("./standalone-update-LZO3MNLH.js")).fetchLatestStandaloneVersion(3e3, signal) : await fetchLatestFromNpm(packageName, 3e3, signal);
+    const latest = packageName === "standalone-binary" ? await (await import("./standalone-update-HZHDZZOR.js")).fetchLatestStandaloneVersion(3e3, signal) : await fetchLatestFromNpm(packageName, 3e3, signal);
     await writeCache({ timestamp: Date.now(), latestVersion: latest, packageName }, hf);
     return {
       current,
@@ -183,4 +183,4 @@ export {
   checkForUpdate,
   getUpdateNotification
 };
-//# sourceMappingURL=chunk-RZ4ZDRYA.js.map
+//# sourceMappingURL=chunk-DIOODAYM.js.map

package/dist/{chunk-L2RVEQWO.js → chunk-HHRYIDOW.js}

@@ -1,6 +1,6 @@
 import {
   backupCurrent
-} from "./chunk-WSTVGC2C.js";
+} from "./chunk-4BX2YDTQ.js";
 
 // src/wiring/external-plugins.ts
 import { isAbsolute, join, resolve } from "node:path";
@@ -1109,4 +1109,4 @@ export {
   PLUGIN_AUDIT_ENTRIES,
   runPluginManagementCommand
 };
-//# sourceMappingURL=chunk-L2RVEQWO.js.map
+//# sourceMappingURL=chunk-HHRYIDOW.js.map

package/dist/chunk-LIZXJHZQ.js

@@ -0,0 +1,61 @@
+
+// src/subcommands/index.ts
+var loaders = {
+  automation: async () => (await import("./automation-MCDFCIMV.js")).automationCmd,
+  sandbox: async () => (await import("./sandbox-TYGD6FI2.js")).sandboxCmd,
+  acp: async () => (await import("./acp-EDGUWU7N.js")).acpCmd,
+  init: async () => (await import("./init-DRMMFG2G.js")).initCmd,
+  auth: async () => (await import("./auth-SUHKFFO4.js")).authCmd,
+  update: async () => (await import("./update-J5WHAFPE.js")).updateCmd,
+  remote: async () => (await import("./remote-C74BCNND.js")).remoteCmd,
+  sessions: async () => (await import("./sessions-config-VE26SB56.js")).sessionsCmd,
+  config: async () => (await import("./sessions-config-VE26SB56.js")).configCmd,
+  "config-export": async () => (await import("./config-transfer-UE37X4B5.js")).configExportCmd,
+  "config-import": async () => (await import("./config-transfer-UE37X4B5.js")).configImportCmd,
+  rewind: async () => (await import("./rewind-7AULJS7F.js")).rewindCmd,
+  replay: async () => (await import("./replay-JJ2NOWD6.js")).replayCmd,
+  audit: async () => (await import("./audit-KCBTHUQI.js")).auditCmd,
+  tools: async () => (await import("./tools-skills-33AI6K6S.js")).toolsCmd,
+  skills: async () => (await import("./tools-skills-33AI6K6S.js")).skillsCmd,
+  "skill-suggest": async () => (await import("./skill-suggest-L2EVWB6R.js")).skillSuggestCmd,
+  typesafe: async () => (await import("./typesafe-NHC322W5.js")).typesafeCmd,
+  providers: async () => (await import("./providers-models-W57I3QOA.js")).providersCmd,
+  models: async () => (await import("./providers-models-W57I3QOA.js")).modelsCmd,
+  mcp: async () => (await import("./mcp-LBS45HWZ.js")).mcpCmd,
+  plugin: async () => (await import("./plugin-usage-3TZGROK7.js")).pluginCmd,
+  plugins: async () => (await import("./plugin-usage-3TZGROK7.js")).pluginCmd,
+  diag: async () => (await import("./diag-doctor-BIZAFIAT.js")).diagCmd,
+  doctor: async () => (await import("./diag-doctor-BIZAFIAT.js")).doctorCmd,
+  "proxy-status": async () => (await import("./diag-doctor-BIZAFIAT.js")).proxyCmd,
+  export: async () => (await import("./export-VVRIOWFV.js")).exportCmd,
+  usage: async () => (await import("./plugin-usage-3TZGROK7.js")).usageCmd,
+  version: async () => (await import("./version-help-ATOKGMTK.js")).versionCmd,
+  help: async () => (await import("./version-help-ATOKGMTK.js")).helpCmd,
+  projects: async () => (await import("./projects-T4CZCA25.js")).projectsCmd,
+  modeldiag: async () => (await import("./modeldiag-PQILD7TN.js")).modeldiagCmd,
+  quick: async () => (await import("./quick-CNB4Z3HS.js")).quickCmd,
+  bench: async () => (await import("./bench-MMZHFHDL.js")).benchCmd,
+  chronicle: async () => (await import("./chronicle-PBJS7BN6.js")).chronicleCmd,
+  hq: async () => (await import("./hq-KBFDKTDD.js")).hqCmd,
+  mailbox: async () => (await import("./mailbox-serve-S536N66F.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
+};
+var subcommands = Object.fromEntries(
+  Object.entries(loaders).map(
+    ([name, load]) => [
+      name,
+      async (args, deps) => (await load())(args, deps)
+    ]
+  )
+);
+var subcommandNames = Object.keys(loaders);
+
+export {
+  subcommands,
+  subcommandNames
+};
+//# sourceMappingURL=chunk-LIZXJHZQ.js.map

package/dist/{chunk-YHYINL47.js → chunk-LKFKO4JW.js}

@@ -4,7 +4,7 @@ import {
 import {
   PLUGIN_AUDIT_ENTRIES,
   loadExternalPlugins
-} from "./chunk-L2RVEQWO.js";
+} from "./chunk-HHRYIDOW.js";
 
 // src/wiring/plugins.ts
 import { join } from "node:path";
@@ -306,4 +306,4 @@ export {
   BUILTIN_PLUGIN_NAME_HINTS,
   setupPlugins
 };
-//# sourceMappingURL=chunk-YHYINL47.js.map
+//# sourceMappingURL=chunk-LKFKO4JW.js.map

package/dist/{chunk-Q4INH2DG.js → chunk-MPQCHBDJ.js}

@@ -74,6 +74,7 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "token-saving-mode",
   "system-lite",
   "system-pro",
+  "system-scout",
   "hq",
   "hq-allow-exec",
   "tunnel",
@@ -306,4 +307,4 @@ export {
   parseAuthFlags,
   parseSpawnFlags
 };
-//# sourceMappingURL=chunk-Q4INH2DG.js.map
+//# sourceMappingURL=chunk-MPQCHBDJ.js.map