@thinkingai/ae-cli 6.0.56 → 6.0.58

package/dist/index.js

@@ -1,4 +1,7 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  requiresConfirmation
+} from "./chunk-AMBFK2K3.js";
 import {
   allHeaderNames,
   allSheetNames,
@@ -14,53 +17,56 @@ import {
   validateAndFix,
   validateDraft,
   writeDraftXlsx
-} from "./chunk-KHS64JZQ.js";
-import "./chunk-2IYIYSUO.js";
+} from "./chunk-72NJKS7O.js";
+import "./chunk-QVRIDN42.js";
 import {
   EvalApiError
-} from "./chunk-X7DRLE62.js";
-import {
-  requiresConfirmation
-} from "./chunk-AMBFK2K3.js";
-import "./chunk-QSAR3GHY.js";
-import "./chunk-T44M3PLZ.js";
-import {
-  resolveHost
-} from "./chunk-P6VFCH3P.js";
+} from "./chunk-YVG6QD3V.js";
+import "./chunk-OAWPT7VP.js";
+import "./chunk-JEUXDY3B.js";
 import {
   TeAgentApiError,
   TeAgentCredentialsError
-} from "./chunk-2UWS5CUP.js";
+} from "./chunk-JSBLCLFE.js";
 import {
   CapabilityGatewayError,
   executeCapability,
   uploadInputFileBytes
-} from "./chunk-MXV3PYC3.js";
+} from "./chunk-UYJMEHAF.js";
+import {
+  resolveHost
+} from "./chunk-2F64AZYH.js";
 import {
+  printError,
+  printOutput
+} from "./chunk-WMDO53YK.js";
+import "./chunk-Y74WTIKJ.js";
+import {
+  BusinessDisabledError,
+  assertBusinessEnabled,
+  businessForCommand,
   failInstallation,
   fetchCliConfig,
   formatCapabilityMissCompatHint,
   getLocalCliPackageInfo,
   installVersion,
   newInstallationReport,
-  printError,
-  printOutput,
+  readCurrentBusinessConfig,
   resolveKbAutoDiscoveryFeature,
   runHostCompatCheck,
   shouldSkipAutoSync
-} from "./chunk-ELCR235M.js";
-import "./chunk-Y74WTIKJ.js";
+} from "./chunk-GBSACKFB.js";
 import {
   CredentialStoreUnreadableError,
   SecureStoreAuthError,
   getCliToken,
   peekCliToken
-} from "./chunk-P7KL7IOH.js";
+} from "./chunk-SOSFRU3O.js";
 import {
   getActiveHost,
   getConfigDir,
   safeJsonParse
-} from "./chunk-LMCYSVVA.js";
+} from "./chunk-4PSTYEG5.js";
 import {
   CliApiError,
   CliValidationError,
@@ -69,14 +75,17 @@ import {
   LocalDataUploadError,
   PermissionError,
   externalCliTokenRequestOptions,
+  kbExecutionContextRequired,
   logger,
   readExternalCliToken,
+  readKbExecutionContext,
   setExternalCliTokenFile
-} from "./chunk-ZW4VMY5H.js";
+} from "./chunk-Z3Q2AEIN.js";
 
 // src/index.ts
 import { Command as CommanderCommand, Option } from "commander";
 import { createRequire } from "module";
+import { constants as osConstants } from "os";
 
 // src/framework/runner.ts
 import * as readline from "readline";
@@ -135,7 +144,7 @@ async function runCommand(cmd, opts, globalOpts) {
       printError("validation", message, hint);
       process.exit(1);
     }
-    if (cmd.validate) {
+    if (cmd.validate && cmd.service !== "community") {
       cmd.validate(ctx);
     }
     const LIMIT_FLAG_PATTERNS = [/limit/i, /page_size/i, /pagesize/i, /row_limit/i, /block_limit/i, /top[-_]?k/i];
@@ -149,6 +158,30 @@ async function runCommand(cmd, opts, globalOpts) {
         }
         continue;
       }
+      if (flag.type === "int64") {
+        if (val === void 0 || val === null || val === "") continue;
+        const raw = String(val);
+        if (!/^-?(?:0|[1-9]\d*)$/.test(raw)) {
+          printError("validation", `--${flag.name} must be a base-10 integer (got: ${val})`);
+          process.exit(1);
+        }
+        const parsed = BigInt(raw);
+        const minInt64 = -(1n << 63n);
+        const maxInt64 = (1n << 63n) - 1n;
+        if (parsed < minInt64 || parsed > maxInt64) {
+          printError("validation", `--${flag.name} must fit in a signed 64-bit integer (got: ${val})`);
+          process.exit(1);
+        }
+        if (flag.min !== void 0 && parsed < BigInt(flag.min)) {
+          printError("validation", `--${flag.name} must be at least ${flag.min} (got: ${val})`);
+          process.exit(1);
+        }
+        if (flag.max !== void 0 && parsed > BigInt(flag.max)) {
+          printError("validation", `--${flag.name} must be at most ${flag.max} (got: ${val})`);
+          process.exit(1);
+        }
+        continue;
+      }
       if (flag.type !== "number") continue;
       if (flag.variadic) continue;
       if (val === void 0 || val === null || val === "") continue;
@@ -157,7 +190,7 @@ async function runCommand(cmd, opts, globalOpts) {
         printError("validation", `--${flag.name} must be a number (got: ${val})`);
         process.exit(1);
       }
-      const isLimitFlag = LIMIT_FLAG_PATTERNS.some((p) => p.test(flag.name));
+      const isLimitFlag = LIMIT_FLAG_PATTERNS.some((p) => p.test(flag.name)) || cmd.service === "community" && /page[-_]?(?:size|num)|row[-_]?limit/i.test(flag.name);
       if (isLimitFlag) {
         const min = flag.min ?? 1;
         const max = flag.max ?? 1e4;
@@ -187,6 +220,9 @@ async function runCommand(cmd, opts, globalOpts) {
         process.exit(1);
       }
     }
+    if (cmd.validate && cmd.service === "community") {
+      cmd.validate(ctx);
+    }
     if (globalOpts.validate && globalOpts.dryRun) {
       printError(
         "validation",
@@ -199,6 +235,10 @@ async function runCommand(cmd, opts, globalOpts) {
       if (cmd.validateInput) {
         const validateResult = await cmd.validateInput(ctx);
         await printOutput(validateResult, globalOpts.format, globalOpts.jq);
+      } else if (cmd.service === "community") {
+        throw new CliValidationError(`--validate is not supported for ${cmdName}`, {
+          hint: "Run without --validate, or inspect the underlying capability for server validation."
+        });
       } else {
         await printOutput(
           { message: "No --validate implementation for this command (capability gateway commands only)" },
@@ -211,6 +251,10 @@ async function runCommand(cmd, opts, globalOpts) {
       if (cmd.dryRun) {
         const dryResult = await cmd.dryRun(ctx);
         await printOutput(dryResult, globalOpts.format, globalOpts.jq);
+      } else if (cmd.service === "community") {
+        throw new CliValidationError(`--dry-run is not supported for ${cmdName}`, {
+          hint: "Run the read-only command without --dry-run; this command has no request preview."
+        });
       } else {
         await printOutput({ message: "No dry-run implementation for this command" }, globalOpts.format);
       }
@@ -335,14 +379,14 @@ function createRuntimeContext(cmd, opts, globalOpts) {
   let _communityReportModule = null;
   async function getCommunityReportClient() {
     if (!_communityReportModule) {
-      _communityReportModule = await import("./community-report-client-S2K3A3Q6.js");
+      _communityReportModule = await import("./community-report-client-TJVCLZ3K.js");
     }
     return _communityReportModule;
   }
   let _localDataUploadModule = null;
   async function getLocalDataUploadClient() {
     if (!_localDataUploadModule) {
-      _localDataUploadModule = await import("./local-data-upload-client-7HCPGIS3.js");
+      _localDataUploadModule = await import("./local-data-upload-client-KCMG6J62.js");
     }
     return _localDataUploadModule;
   }
@@ -362,9 +406,23 @@ function createRuntimeContext(cmd, opts, globalOpts) {
       if (val === void 0 || val === null || val === "") return void 0;
       return Number(val);
     },
+    int64(name) {
+      const val = opts[camelCase(name)];
+      if (val === void 0 || val === null || val === "") return 0n;
+      return BigInt(String(val));
+    },
+    optionalInt64(name) {
+      const val = opts[camelCase(name)];
+      if (val === void 0 || val === null || val === "") return void 0;
+      return BigInt(String(val));
+    },
     bool(name) {
       return Boolean(opts[camelCase(name)]);
     },
+    optionalBool(name) {
+      const val = opts[camelCase(name)];
+      return typeof val === "boolean" ? val : void 0;
+    },
     json(name) {
       const val = opts[camelCase(name)];
       if (val === void 0 || val === null) return void 0;
@@ -399,6 +457,10 @@ function createRuntimeContext(cmd, opts, globalOpts) {
       return globalOpts.host;
     },
     host() {
+      if (cmd.service === "kb" && ["+list", "+index", "+grep", "+read"].includes(cmd.command)) {
+        const context = readKbExecutionContext();
+        if (context) return globalOpts.host || context.origin;
+      }
       if (globalOpts.host) return globalOpts.host;
       return getActiveHost();
     },
@@ -456,10 +518,11 @@ function registerCommands(program2, commands) {
       const sub = parent.command(cmd.command, { hidden: cmd.hidden === true }).description(cmd.description);
       for (const flag of cmd.flags) {
         const flagStr = buildFlagString(flag);
+        const description = flag.required ? `${flag.desc} (required)` : flag.desc;
         if (flag.variadic) {
-          sub.option(flagStr, flag.desc, collectVariadic, []);
+          sub.option(flagStr, description, collectVariadic, []);
         } else if (flag.type === "boolean") {
-          const option = sub.createOption(flagStr, flag.desc);
+          const option = sub.createOption(flagStr, description);
           if (flag.name.startsWith("no-")) {
             option.negate = false;
             option.attributeName = () => flag.name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
@@ -467,9 +530,9 @@ function registerCommands(program2, commands) {
           option.argParser((value) => parseBooleanValue(value, flag.name));
           sub.addOption(option);
         } else if (flag.default !== void 0) {
-          sub.option(flagStr, flag.desc, String(flag.default));
+          sub.option(flagStr, description, String(flag.default));
         } else {
-          sub.option(flagStr, flag.desc);
+          sub.option(flagStr, description);
         }
       }
       if (cmd.usesAeHost !== false) {
@@ -529,6 +592,72 @@ function extractGlobalOptions(program2) {
   };
 }
 
+// src/core/resume-command.ts
+import childProcess from "child_process";
+import fs from "fs";
+import path from "path";
+async function resumeSyncedCommand(entrypoint, args = process.argv.slice(2)) {
+  try {
+    if (!entrypoint || !path.isAbsolute(entrypoint)) return { status: "not-started" };
+    if (!fs.statSync(entrypoint).isFile()) return { status: "not-started" };
+    fs.accessSync(entrypoint, fs.constants.R_OK);
+  } catch {
+    return { status: "not-started" };
+  }
+  return new Promise((resolve3) => {
+    const isolateProcessGroup = process.platform !== "win32";
+    let child;
+    try {
+      child = childProcess.spawn(process.execPath, [entrypoint, ...args], {
+        cwd: process.cwd(),
+        stdio: "inherit",
+        // Terminal group signals must reach the child only through this parent.
+        detached: isolateProcessGroup,
+        env: { ...process.env, AE_CLI_NO_COMPAT_CHECK: "1" }
+      });
+    } catch {
+      resolve3({ status: "not-started" });
+      return;
+    }
+    let started = false;
+    const forward = (signal) => {
+      try {
+        if (isolateProcessGroup) {
+          if (child.pid && child.pid > 0) process.kill(-child.pid, signal);
+        } else child.kill(signal);
+      } catch {
+      }
+    };
+    const handlers = /* @__PURE__ */ new Map([
+      ["SIGINT", () => forward("SIGINT")],
+      ["SIGTERM", () => forward("SIGTERM")]
+    ]);
+    if (isolateProcessGroup) {
+      handlers.set("SIGHUP", () => forward("SIGHUP"));
+      handlers.set("SIGTSTP", () => {
+        forward("SIGSTOP");
+        process.kill(process.pid, "SIGSTOP");
+      });
+      handlers.set("SIGCONT", () => forward("SIGCONT"));
+      handlers.set("SIGWINCH", () => forward("SIGWINCH"));
+    }
+    for (const [signal, handler] of handlers) process.on(signal, handler);
+    const finish = (result) => {
+      for (const [signal, handler] of handlers) process.removeListener(signal, handler);
+      resolve3(result);
+    };
+    child.once("spawn", () => {
+      started = true;
+    });
+    child.on("error", () => {
+      if (!started) finish({ status: "not-started" });
+    });
+    child.once("close", (code, signal) => {
+      finish(signal ? { status: "signaled", signal } : { status: "exited", code: code ?? 1 });
+    });
+  });
+}
+
 // src/core/feature-config-check.ts
 async function runFeatureConfigCheck(hostOverride, argv = process.argv) {
   if (shouldSkipAutoSync(argv) || argv.slice(2).some((arg) => arg === "--help" || arg === "-h" || arg === "--version" || arg === "-V")) return void 0;
@@ -545,7 +674,7 @@ async function runFeatureConfigCheck(hostOverride, argv = process.argv) {
 
 // src/commands/tracking/plan.ts
 import { readFile, writeFile, cp } from "fs/promises";
-import path2, { resolve as resolve2 } from "path";
+import path3, { resolve as resolve2 } from "path";
 
 // src/core/tracking-client.ts
 var DEBUG_BASE = "/v1/ta/bury/manage/debug";
@@ -742,8 +871,8 @@ var TrackingClient = class {
     }
     return env;
   }
-  async debugGet(path4, params) {
-    const data = await this.requestJson(`${DEBUG_BASE}${path4}`, { ...params, "@t": Date.now() });
+  async debugGet(path5, params) {
+    const data = await this.requestJson(`${DEBUG_BASE}${path5}`, { ...params, "@t": Date.now() });
     return data;
   }
   async listDevice(projectId) {
@@ -819,8 +948,8 @@ function normalize(data) {
 }
 
 // src/tracking/plan/draft.ts
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 
 // src/tracking/plan/autotrack.ts
 var TAG = {
@@ -1190,23 +1319,23 @@ function resolveTrackingHost(program2, opts) {
   }
   return host;
 }
-function isExistingDirectory(path4) {
-  if (!existsSync2(path4)) return false;
+function isExistingDirectory(path5) {
+  if (!existsSync2(path5)) return false;
   try {
-    return statSync(path4).isDirectory();
+    return statSync(path5).isDirectory();
   } catch {
     return false;
   }
 }
-function assertOutputFilePath(path4, optionName = "--out") {
-  const trimmed = path4.trim();
+function assertOutputFilePath(path5, optionName = "--out") {
+  const trimmed = path5.trim();
   if (trimmed.endsWith("/") || trimmed.endsWith("\\") || isExistingDirectory(trimmed)) {
     console.error(t("error.output_path_is_directory", { path: trimmed, option: optionName }));
     process.exit(1);
   }
 }
-function assertInputFilePath(path4, optionName = "--in") {
-  const trimmed = path4.trim();
+function assertInputFilePath(path5, optionName = "--in") {
+  const trimmed = path5.trim();
   if (!existsSync2(trimmed)) {
     console.error(t("error.input_path_not_found", { path: trimmed, option: optionName }));
     process.exit(1);
@@ -1357,7 +1486,7 @@ function registerPlan(cmd, rootProgram) {
       lastRes = await client.uploadProgramExcel({
         projectId: opts.project,
         file,
-        filename: path2.basename(opts.xlsx),
+        filename: path3.basename(opts.xlsx),
         lang: locale
       });
       console.log(JSON.stringify(lastRes, null, 2));
@@ -1562,7 +1691,7 @@ async function detectProject(cwd) {
 
 // src/tracking/xlsx/read.ts
 import * as nodeFs from "fs";
-import path3 from "path";
+import path4 from "path";
 var setXlsxFs = set_fs;
 if (typeof setXlsxFs === "function") {
   setXlsxFs(nodeFs);
@@ -1875,7 +2004,7 @@ async function readTemplateXlsx(filePath) {
   } catch (err) {
     throw new Error(t("error.xlsx_read_failed", { path: filePath, error: String(err) }));
   }
-  const planName = path3.basename(filePath, path3.extname(filePath));
+  const planName = path4.basename(filePath, path4.extname(filePath));
   const source = "template";
   let events = [];
   let event_properties = [];
@@ -2325,6 +2454,11 @@ async function parseProgram(program2, argv = process.argv) {
   try {
     await program2.parseAsync(normalizeSubcommandVersionOption(program2, argv));
   } catch (error) {
+    if (error instanceof BusinessDisabledError) {
+      printError("permission", error.message, error.hint, error.code);
+      process.exitCode = 1;
+      return;
+    }
     if (!(error instanceof CredentialStoreUnreadableError) && !(error instanceof ExternalCliTokenError)) throw error;
     printError("config", error.message, error.hint, error.code);
     process.exitCode = 1;
@@ -2430,6 +2564,57 @@ function registerInstall(program2) {
   });
 }
 
+// src/framework/business-filter.ts
+import { Help } from "commander";
+function commandPath(command) {
+  const result = [];
+  for (let current = command; current?.parent; current = current.parent) {
+    result.unshift(current.name());
+  }
+  return result;
+}
+function configureBusinessCommands(program2, options = {}) {
+  const readStates = options.readStates ?? (() => readCurrentBusinessConfig(options.hostOverride));
+  const isVisible = (command) => {
+    const business = businessForCommand(commandPath(command));
+    return !business || readStates()[business] !== false;
+  };
+  const helpConfiguration = {
+    visibleCommands(command) {
+      return Help.prototype.visibleCommands.call(this, command).filter(isVisible);
+    },
+    formatHelp(command, helper) {
+      if (!isVisible(command)) {
+        const business = businessForCommand(commandPath(command));
+        return `The '${business}' business is not enabled for the current environment.
+Run: ae-cli config refresh
+`;
+      }
+      return Help.prototype.formatHelp.call(this, command, helper);
+    }
+  };
+  const configureHelp = (command) => {
+    command.configureHelp(helpConfiguration);
+    command.commands.forEach(configureHelp);
+  };
+  configureHelp(program2);
+  program2.on("beforeAllHelp", (context) => {
+    if (isVisible(context.command)) return;
+    const business = businessForCommand(commandPath(context.command));
+    context.write(`The '${business}' business is not enabled for the current environment.
+Run: ae-cli config refresh
+`);
+    context.write = () => {
+    };
+  });
+  program2.hook("preAction", async (_root, actionCommand) => {
+    const business = businessForCommand(commandPath(actionCommand));
+    if (!business) return;
+    const opts = actionCommand.optsWithGlobals();
+    await (options.assertEnabled ?? assertBusinessEnabled)(business, opts.host ?? options.hostOverride);
+  });
+}
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
@@ -2455,105 +2640,105 @@ function warnLoadFailure(label, err) {
 async function loadCommands() {
   const commands = [];
   try {
-    const teAnalysis = await import("./te-analysis-RJB6VJC4.js");
+    const teAnalysis = await import("./te-analysis-WQ6D6YG4.js");
     commands.push(...teAnalysis.default);
   } catch (err) {
     warnLoadFailure("domain te-analysis", err);
   }
   try {
-    const engage = await import("./te-engage-KPTN4N2U.js");
+    const engage = await import("./te-engage-V2QW7TIC.js");
     commands.push(...engage.default);
   } catch (err) {
     warnLoadFailure("domain te-engage", err);
   }
   try {
-    const community = await import("./te-community-QN3WMPNT.js");
+    const community = await import("./te-community-VRWMFGI6.js");
     commands.push(...community.default);
   } catch (err) {
     warnLoadFailure("domain te-community", err);
   }
   try {
-    const dataops = await import("./te-dataops-UKD2XN3E.js");
+    const dataops = await import("./te-dataops-YTLFTTW7.js");
     commands.push(...dataops.default);
   } catch (err) {
     warnLoadFailure("domain te-dataops", err);
   }
   try {
-    const teKb = await import("./te-kb-SFZI3W5T.js");
+    const teKb = await import("./te-kb-4AQLISDR.js");
     commands.push(...teKb.default);
   } catch (err) {
     warnLoadFailure("domain te-kb", err);
   }
   try {
-    const teTeam = await import("./te-team-4KHCFM2I.js");
+    const teTeam = await import("./te-team-6ELNGBWT.js");
     commands.push(...teTeam.default);
   } catch (err) {
     warnLoadFailure("domain te-team", err);
   }
   try {
-    const teAgent = await import("./te-agent-L2BYNPHM.js");
+    const teAgent = await import("./te-agent-BJ36B4QI.js");
     commands.push(...teAgent.default);
   } catch (err) {
     warnLoadFailure("domain te-agent", err);
   }
   try {
-    const memory = await import("./memory-VCYLVPMI.js");
+    const memory = await import("./memory-SNFR5M23.js");
     commands.push(...memory.default);
   } catch (err) {
     warnLoadFailure("domain memory", err);
   }
-  const automation = await import("./automation-K32V2NKP.js");
+  const automation = await import("./automation-FD2QZUP6.js");
   commands.push(...automation.default);
   try {
-    const things = await import("./things-7JJUVAWL.js");
+    const things = await import("./things-HFWLGCUH.js");
     commands.push(...things.default);
   } catch (err) {
     warnLoadFailure("domain things", err);
   }
   try {
-    const workspace = await import("./workspace-Q5NMEKEN.js");
+    const workspace = await import("./workspace-2CKQX2XL.js");
     commands.push(...workspace.default);
   } catch (err) {
     warnLoadFailure("domain workspace", err);
   }
   try {
-    const teSystem = await import("./te-system-IE7NCKC3.js");
+    const teSystem = await import("./te-system-CYWSK3UN.js");
     commands.push(...teSystem.default);
   } catch (err) {
     warnLoadFailure("domain te-system", err);
   }
   try {
-    const metadata = await import("./metadata-TIWIOFTU.js");
+    const metadata = await import("./metadata-6QM6EED5.js");
     commands.push(...metadata.default);
   } catch (err) {
     warnLoadFailure("domain metadata", err);
   }
   try {
-    const personalSemanticPreference = await import("./personal-semantic-preference-SBKU2LOK.js");
+    const personalSemanticPreference = await import("./personal-semantic-preference-7VXQPP2N.js");
     commands.push(...personalSemanticPreference.default);
   } catch (err) {
     warnLoadFailure("domain personal-semantic-preference", err);
   }
   try {
-    const projectSemantic = await import("./project-semantic-SKNWLH3I.js");
+    const projectSemantic = await import("./project-semantic-PSEPYH2L.js");
     commands.push(...projectSemantic.default);
   } catch (err) {
     warnLoadFailure("domain project-semantic", err);
   }
   try {
-    const dataIntegration = await import("./data-integration-EXSUPUDZ.js");
+    const dataIntegration = await import("./data-integration-QE37EQ3A.js");
     commands.push(...dataIntegration.default);
   } catch (err) {
     warnLoadFailure("domain data-integration", err);
   }
   try {
-    const context = await import("./context-6RWLVOM5.js");
+    const context = await import("./context-CDB5H5PD.js");
     commands.push(...context.default);
   } catch (err) {
     warnLoadFailure("domain context", err);
   }
   try {
-    const evaluation = await import("./evaluation-5YT4QLCL.js");
+    const evaluation = await import("./evaluation-LR4YDYWL.js");
     commands.push(...evaluation.default);
   } catch (err) {
     warnLoadFailure("domain evaluation", err);
@@ -2562,7 +2747,7 @@ async function loadCommands() {
 }
 async function registerAuthCommands() {
   try {
-    const { registerAuth } = await import("./auth-U7MNUUEF.js");
+    const { registerAuth } = await import("./auth-A5OO4VS4.js");
     registerAuth(program);
   } catch (err) {
     warnLoadFailure("auth commands", err);
@@ -2570,7 +2755,7 @@ async function registerAuthCommands() {
 }
 async function registerConfigCommands() {
   try {
-    const { registerConfig } = await import("./config-ASSAAIOI.js");
+    const { registerConfig } = await import("./config-U4I7X25P.js");
     registerConfig(program);
   } catch (err) {
     warnLoadFailure("config commands", err);
@@ -2578,7 +2763,7 @@ async function registerConfigCommands() {
 }
 async function registerCapabilityCommands() {
   try {
-    const { registerCapability } = await import("./capability-VV7RHB3B.js");
+    const { registerCapability } = await import("./capability-SKI4GHF4.js");
     registerCapability(program);
   } catch (err) {
     warnLoadFailure("capability commands", err);
@@ -2586,7 +2771,7 @@ async function registerCapabilityCommands() {
 }
 async function registerSyncCommand() {
   try {
-    const { registerSync } = await import("./sync-7PP6KQ75.js");
+    const { registerSync } = await import("./sync-22ACDK5Z.js");
     registerSync(program);
   } catch (err) {
     warnLoadFailure("sync commands", err);
@@ -2594,7 +2779,7 @@ async function registerSyncCommand() {
 }
 async function registerModelCommand() {
   try {
-    const { registerModel } = await import("./model-DPJHSD73.js");
+    const { registerModel } = await import("./model-KEVCEXWD.js");
     registerModel(program);
   } catch (err) {
     warnLoadFailure("model commands", err);
@@ -2602,25 +2787,44 @@ async function registerModelCommand() {
 }
 async function registerUpdateCommand() {
   try {
-    const { registerUpdate } = await import("./update-AX66IFMJ.js");
+    const { registerUpdate } = await import("./update-3CRVVHV5.js");
     registerUpdate(program);
   } catch (err) {
     warnLoadFailure("update commands", err);
   }
 }
 async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 1 && args[0] === "--runtime-capabilities") {
+    process.stdout.write(JSON.stringify(require2("../bin/runtime-capabilities.json")) + "\n");
+    return;
+  }
+  const kbIndex = args.indexOf("kb");
+  const executionQuery = kbExecutionContextRequired() && kbIndex >= 0 && ["+list", "+index", "+grep", "+read"].includes(args[kbIndex + 1]);
+  if (executionQuery) readKbExecutionContext();
+  const helpRequested = isHelpInvocation(args);
   setExternalCliTokenFile(globalOptionValue(process.argv.slice(2), "--cli-token-file"));
-  if (!process.argv.slice(2).some((arg) => ["--help", "-h", "--version", "-V"].includes(arg))) {
+  if (!executionQuery && !helpRequested && !process.argv.slice(2).some((arg) => ["--version", "-V"].includes(arg))) {
     readExternalCliToken(globalOptionValue(process.argv.slice(2), "--host"));
   }
   const pkgInfo = getLocalCliPackageInfo();
-  if (!isRootUpdateCommand(process.argv.slice(2))) {
+  if (!executionQuery && !helpRequested && !isRootUpdateCommand(process.argv.slice(2))) {
     const compat = await runHostCompatCheck(
       pkgInfo,
       globalOptionValue(process.argv.slice(2), "--host")
     );
     if (compat.status === "synced") {
-      const message = compat.direction === "skills" ? `Skills were synchronized for ae-cli ${compat.expected}.` : `ae-cli changed from ${compat.current} to ${compat.expected} for this host.`;
+      const resumed = await resumeSyncedCommand(compat.entrypoint);
+      if (resumed.status === "exited") {
+        process.exitCode = resumed.code;
+        return;
+      }
+      if (resumed.status === "signaled") {
+        process.exitCode = 128 + osConstants.signals[resumed.signal];
+        process.kill(process.pid, resumed.signal);
+        return;
+      }
+      const message = compat.direction === "skills" ? `Skills synchronization for ae-cli ${compat.expected} succeeded, but the synchronized CLI could not be started. The requested command was not executed.` : `CLI and Skills synchronization from ${compat.current} to ${compat.expected} succeeded, but the synchronized CLI could not be started. The requested command was not executed.`;
       printError(
         "config",
         message,
@@ -2631,6 +2835,8 @@ async function main() {
           expected: compat.expected,
           cluster: compat.cluster,
           direction: compat.direction,
+          versionSyncSucceeded: true,
+          originalCommandExecuted: false,
           retryOriginalCommand: true
         },
         { log: false }
@@ -2639,7 +2845,7 @@ async function main() {
       return;
     }
   }
-  await runFeatureConfigCheck(globalOptionValue(process.argv.slice(2), "--host"));
+  if (!executionQuery && !helpRequested) await runFeatureConfigCheck(globalOptionValue(process.argv.slice(2), "--host"));
   const commands = await loadCommands();
   registerCommands(program, commands);
   await registerAuthCommands();
@@ -2650,9 +2856,23 @@ async function main() {
   await registerUpdateCommand();
   registerInstall(program);
   registerTracking(program);
+  if (!executionQuery) configureBusinessCommands(program, { hostOverride: globalOptionValue(process.argv.slice(2), "--host") });
   rejectUnknownHelpCommandPath(program, process.argv.slice(2));
   await parseProgram(program);
 }
+function isHelpInvocation(args) {
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) return true;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (token === "--") return false;
+    if (token.startsWith("-")) {
+      if (optionConsumesValue(token)) index += 1;
+      continue;
+    }
+    if (token === "help") return true;
+  }
+  return false;
+}
 try {
   await main();
 } catch (error) {