@thinkingai/ae-cli 6.1.27 → 6.1.29

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,62 +17,75 @@ import {
   validateAndFix,
   validateDraft,
   writeDraftXlsx
-} from "./chunk-5XJYLEVC.js";
-import "./chunk-CT7QDJS6.js";
+} from "./chunk-72NJKS7O.js";
+import "./chunk-QVRIDN42.js";
+import "./chunk-OAWPT7VP.js";
+import "./chunk-JEUXDY3B.js";
 import {
-  requiresConfirmation
-} from "./chunk-AMBFK2K3.js";
-import "./chunk-AP7YP2NX.js";
-import "./chunk-S6M42KND.js";
+  EvalApiError
+} from "./chunk-YVG6QD3V.js";
+import {
+  resolveHost
+} from "./chunk-IN7KKL6K.js";
 import {
   TeAgentApiError,
   TeAgentCredentialsError
-} from "./chunk-3YVEAZUN.js";
+} from "./chunk-RJHGDWSC.js";
+import {
+  printError,
+  printOutput
+} from "./chunk-QZLRHGVH.js";
 import {
   CapabilityGatewayError,
   executeCapability,
   uploadInputFileBytes
-} from "./chunk-VZZNLV3I.js";
-import {
-  resolveHost
-} from "./chunk-OP44TT4H.js";
+} from "./chunk-3SDHJOCR.js";
+import "./chunk-Y74WTIKJ.js";
 import {
+  BusinessDisabledError,
+  assertBusinessEnabled,
+  businessForCommand,
   failInstallation,
   fetchCliConfig,
   formatCapabilityMissCompatHint,
   getLocalCliPackageInfo,
   installVersion,
   newInstallationReport,
-  printError,
-  printOutput,
+  readCurrentBusinessConfig,
   resolveKbAutoDiscoveryFeature,
   runHostCompatCheck,
   shouldSkipAutoSync
-} from "./chunk-6VNIR4AP.js";
-import "./chunk-Y74WTIKJ.js";
+} from "./chunk-2UW3Y463.js";
 import {
   CredentialStoreUnreadableError,
   SecureStoreAuthError,
   getCliToken,
   peekCliToken
-} from "./chunk-GHXZK54S.js";
+} from "./chunk-H3K5UGYC.js";
 import {
   getActiveHost,
   getConfigDir,
   safeJsonParse
-} from "./chunk-ZL7SGNIA.js";
+} from "./chunk-JNVVJ273.js";
 import {
   CliApiError,
   CliValidationError,
   CommunityReportError,
+  ExternalCliTokenError,
   LocalDataUploadError,
   PermissionError,
-  logger
-} from "./chunk-WNGFSIOB.js";
+  externalCliTokenRequestOptions,
+  kbExecutionContextRequired,
+  logger,
+  readExternalCliToken,
+  readKbExecutionContext,
+  setExternalCliTokenFile
+} 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";
@@ -128,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];
@@ -142,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;
@@ -150,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;
@@ -180,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",
@@ -192,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)" },
@@ -204,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);
       }
@@ -236,7 +287,7 @@ async function runCommand(cmd, opts, globalOpts) {
       process.exit(1);
     }
     const message = err.message || String(err);
-    if (!(err instanceof CommunityReportError)) {
+    if (!(err instanceof CommunityReportError) && !(err instanceof EvalApiError)) {
       if (!(err instanceof LocalDataUploadError)) logger.error(`Command failed: ${message}`);
     }
     if (err instanceof CliValidationError) {
@@ -250,17 +301,26 @@ async function runCommand(cmd, opts, globalOpts) {
     } else if (err instanceof TeAgentCredentialsError) {
       printError("config", message, err.hint);
     } else if (err instanceof PermissionError) {
-      printError("permission", message, err.hint, err.code, void 0, { details: err.details });
+      printError("permission", message, err.hint, err.code, err.meta, { details: err.details });
     } else if (err instanceof CliApiError) {
       printError("api", message, err.hint, err.code, err.meta);
     } else if (err instanceof CapabilityGatewayError) {
-      printError(err.type, message, err.hint ?? capabilityGatewayHint(err), err.code, err.meta);
+      printError(
+        err.type,
+        message,
+        err.hint ?? capabilityGatewayHint(err),
+        err.code,
+        err.meta,
+        { details: err.details }
+      );
     } else if (err instanceof CommunityReportError) {
       printError("api", message, err.hint, err.code, err.meta, { log: false });
     } else if (err instanceof LocalDataUploadError) {
       printError("api", message, err.hint, err.code, err.meta, { log: false });
-    } else if (err instanceof CredentialStoreUnreadableError) {
+    } else if (err instanceof CredentialStoreUnreadableError || err instanceof ExternalCliTokenError) {
       printError("config", message, err.hint, err.code);
+    } else if (err instanceof EvalApiError) {
+      printError("api", message, err.hint, err.code, void 0, { log: false });
     } else if (err instanceof SecureStoreAuthError) {
       printError("auth", message, "Run: ae-cli auth login", err.code);
     } else if (err instanceof TeAgentApiError) {
@@ -326,14 +386,14 @@ function createRuntimeContext(cmd, opts, globalOpts) {
   let _communityReportModule = null;
   async function getCommunityReportClient() {
     if (!_communityReportModule) {
-      _communityReportModule = await import("./community-report-client-PEERQCX2.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-TWMHFLUA.js");
+      _localDataUploadModule = await import("./local-data-upload-client-KCMG6J62.js");
     }
     return _localDataUploadModule;
   }
@@ -353,9 +413,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;
@@ -363,6 +437,11 @@ function createRuntimeContext(cmd, opts, globalOpts) {
       try {
         return safeJsonParse(String(val));
       } catch {
+        if (cmd.flags.some((flag) => flag.name === name && flag.sensitive)) {
+          throw new CliValidationError(`Invalid JSON for --${name}.`, {
+            hint: "Provide valid JSON with quoted keys and strings. Sensitive input is omitted from diagnostics."
+          });
+        }
         printError("validation", `Invalid JSON for --${name}: ${val}`);
         process.exit(1);
       }
@@ -385,6 +464,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();
     },
@@ -442,14 +525,21 @@ 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") {
-          sub.option(flagStr, flag.desc, (value) => parseBooleanValue(value, flag.name));
+          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());
+          }
+          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) {
@@ -509,6 +599,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;
@@ -525,7 +681,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";
@@ -661,7 +817,7 @@ var TrackingClient = class {
       headers["content-type"] = "application/json";
       init.body = JSON.stringify(body);
     }
-    const resp = await fetch(url, init);
+    const resp = await fetch(url, { ...init, ...externalCliTokenRequestOptions(url) });
     const env = safeJsonParse(await resp.text());
     logger.api(method, url, resp.status, body, env);
     if (resp.status === 401) {
@@ -722,8 +878,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) {
@@ -799,8 +955,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 = {
@@ -1170,23 +1326,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);
@@ -1337,7 +1493,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));
@@ -1542,7 +1698,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);
@@ -1855,7 +2011,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 = [];
@@ -2305,7 +2461,12 @@ async function parseProgram(program2, argv = process.argv) {
   try {
     await program2.parseAsync(normalizeSubcommandVersionOption(program2, argv));
   } catch (error) {
-    if (!(error instanceof CredentialStoreUnreadableError)) throw 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;
   }
@@ -2410,12 +2571,63 @@ 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");
 var { version } = pkg;
 var program = new CommanderCommand();
-program.name("ae-cli").version(version).description("CLI tool for ThinkingAI (AE) analytics platform").option("--host <url>", "Override active AE host URL (e.g., https://ta.thinkingdata.cn)").option("--mcp-url <url>", "Override MCP server URL (e.g., http://localhost/mcp/http/example)").option("--format <format>", "Output format: json | table", "json").option("--jq <expr>", "jq 1.8 filter over command payload (via jq-wasm), applied before output envelope").option(
+program.name("ae-cli").version(version).description("CLI tool for ThinkingAI (AE) analytics platform").option("--host <url>", "Override active AE host URL (e.g., https://ta.thinkingdata.cn)").option("--cli-token-file <path>", "Use a read-only JSON CLI token file containing url and token for this invocation").option("--mcp-url <url>", "Override MCP server URL (e.g., http://localhost/mcp/http/example)").option("--format <format>", "Output format: json | table", "json").option("--jq <expr>", "jq 1.8 filter over command payload (via jq-wasm), applied before output envelope").option(
   "--validate",
   "Optional: validate/normalize capability input only (gateway /validate). Use alone while fixing complex params/qp; do not stack with --dry-run",
   false
@@ -2435,114 +2647,120 @@ function warnLoadFailure(label, err) {
 async function loadCommands() {
   const commands = [];
   try {
-    const teAnalysis = await import("./te-analysis-GP7DSQ7Q.js");
+    const teAnalysis = await import("./te-analysis-USIK6ZZG.js");
     commands.push(...teAnalysis.default);
   } catch (err) {
     warnLoadFailure("domain te-analysis", err);
   }
   try {
-    const engage = await import("./te-engage-2CO6LRCX.js");
+    const engage = await import("./te-engage-6C3HCFQR.js");
     commands.push(...engage.default);
   } catch (err) {
     warnLoadFailure("domain te-engage", err);
   }
   try {
-    const experiment = await import("./te-experiment-652CLXMU.js");
+    const experiment = await import("./te-experiment-LVTRI3QK.js");
     commands.push(...experiment.default);
   } catch (err) {
     warnLoadFailure("domain te-experiment", err);
   }
   try {
-    const community = await import("./te-community-42M7ICDO.js");
+    const community = await import("./te-community-WE2UU4XV.js");
     commands.push(...community.default);
   } catch (err) {
     warnLoadFailure("domain te-community", err);
   }
   try {
-    const dataops = await import("./te-dataops-BNKNZ4F2.js");
+    const dataops = await import("./te-dataops-XNMO7MBF.js");
     commands.push(...dataops.default);
   } catch (err) {
     warnLoadFailure("domain te-dataops", err);
   }
   try {
-    const teKb = await import("./te-kb-ULATOTQ3.js");
+    const teKb = await import("./te-kb-TUPGMVBY.js");
     commands.push(...teKb.default);
   } catch (err) {
     warnLoadFailure("domain te-kb", err);
   }
   try {
-    const teTeam = await import("./te-team-YA6SNOJ3.js");
+    const teTeam = await import("./te-team-G4VEJJNL.js");
     commands.push(...teTeam.default);
   } catch (err) {
     warnLoadFailure("domain te-team", err);
   }
   try {
-    const teAgent = await import("./te-agent-AORRE2FM.js");
+    const teAgent = await import("./te-agent-5ENVZJUH.js");
     commands.push(...teAgent.default);
   } catch (err) {
     warnLoadFailure("domain te-agent", err);
   }
   try {
-    const memory = await import("./memory-CQKH2JAV.js");
+    const memory = await import("./memory-HHPX3NF2.js");
     commands.push(...memory.default);
   } catch (err) {
     warnLoadFailure("domain memory", err);
   }
-  const automation = await import("./automation-VAAQBM7Y.js");
+  const automation = await import("./automation-NAR5DDGL.js");
   commands.push(...automation.default);
   try {
-    const things = await import("./things-DTCOQIQB.js");
+    const things = await import("./things-22KQWC23.js");
     commands.push(...things.default);
   } catch (err) {
     warnLoadFailure("domain things", err);
   }
   try {
-    const workspace = await import("./workspace-JEOHKFPX.js");
+    const workspace = await import("./workspace-LYDAP647.js");
     commands.push(...workspace.default);
   } catch (err) {
     warnLoadFailure("domain workspace", err);
   }
   try {
-    const teSystem = await import("./te-system-UGHVKBVV.js");
+    const teSystem = await import("./te-system-YM657FKO.js");
     commands.push(...teSystem.default);
   } catch (err) {
     warnLoadFailure("domain te-system", err);
   }
   try {
-    const metadata = await import("./metadata-NR3PHR23.js");
+    const metadata = await import("./metadata-TIFY24LW.js");
     commands.push(...metadata.default);
   } catch (err) {
     warnLoadFailure("domain metadata", err);
   }
   try {
-    const personalSemanticPreference = await import("./personal-semantic-preference-2RAI36P3.js");
+    const personalSemanticPreference = await import("./personal-semantic-preference-WKJEGPTM.js");
     commands.push(...personalSemanticPreference.default);
   } catch (err) {
     warnLoadFailure("domain personal-semantic-preference", err);
   }
   try {
-    const projectSemantic = await import("./project-semantic-3BUGP3ZM.js");
+    const projectSemantic = await import("./project-semantic-EIQVZNHW.js");
     commands.push(...projectSemantic.default);
   } catch (err) {
     warnLoadFailure("domain project-semantic", err);
   }
   try {
-    const dataIntegration = await import("./data-integration-BCLQFTGU.js");
+    const dataIntegration = await import("./data-integration-6UAZO4GG.js");
     commands.push(...dataIntegration.default);
   } catch (err) {
     warnLoadFailure("domain data-integration", err);
   }
   try {
-    const context = await import("./context-NGVFPCBK.js");
+    const context = await import("./context-F6FCGTF3.js");
     commands.push(...context.default);
   } catch (err) {
     warnLoadFailure("domain context", err);
   }
+  try {
+    const evaluation = await import("./evaluation-4LO2O4AF.js");
+    commands.push(...evaluation.default);
+  } catch (err) {
+    warnLoadFailure("domain evaluation", err);
+  }
   return commands;
 }
 async function registerAuthCommands() {
   try {
-    const { registerAuth } = await import("./auth-WA7YGGRT.js");
+    const { registerAuth } = await import("./auth-OBQ5KVQM.js");
     registerAuth(program);
   } catch (err) {
     warnLoadFailure("auth commands", err);
@@ -2550,7 +2768,7 @@ async function registerAuthCommands() {
 }
 async function registerConfigCommands() {
   try {
-    const { registerConfig } = await import("./config-JOD5DOPE.js");
+    const { registerConfig } = await import("./config-YZ6O2UQ2.js");
     registerConfig(program);
   } catch (err) {
     warnLoadFailure("config commands", err);
@@ -2558,7 +2776,7 @@ async function registerConfigCommands() {
 }
 async function registerCapabilityCommands() {
   try {
-    const { registerCapability } = await import("./capability-GAAYJ3IQ.js");
+    const { registerCapability } = await import("./capability-LFSVNI5B.js");
     registerCapability(program);
   } catch (err) {
     warnLoadFailure("capability commands", err);
@@ -2566,7 +2784,7 @@ async function registerCapabilityCommands() {
 }
 async function registerSyncCommand() {
   try {
-    const { registerSync } = await import("./sync-RZIAV37C.js");
+    const { registerSync } = await import("./sync-RV3OPCTI.js");
     registerSync(program);
   } catch (err) {
     warnLoadFailure("sync commands", err);
@@ -2574,7 +2792,7 @@ async function registerSyncCommand() {
 }
 async function registerModelCommand() {
   try {
-    const { registerModel } = await import("./model-VX5M2CJ6.js");
+    const { registerModel } = await import("./model-7UHGWYVR.js");
     registerModel(program);
   } catch (err) {
     warnLoadFailure("model commands", err);
@@ -2582,21 +2800,44 @@ async function registerModelCommand() {
 }
 async function registerUpdateCommand() {
   try {
-    const { registerUpdate } = await import("./update-ESNYKUVR.js");
+    const { registerUpdate } = await import("./update-XX4ILU7X.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 (!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,
@@ -2607,6 +2848,8 @@ async function main() {
           expected: compat.expected,
           cluster: compat.cluster,
           direction: compat.direction,
+          versionSyncSucceeded: true,
+          originalCommandExecuted: false,
           retryOriginalCommand: true
         },
         { log: false }
@@ -2615,7 +2858,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();
@@ -2626,10 +2869,30 @@ 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);
 }
-await main();
+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) {
+  if (!(error instanceof ExternalCliTokenError) && !(error instanceof CliValidationError)) throw error;
+  printError(error instanceof ExternalCliTokenError ? "config" : "validation", error.message, error.hint, error.code);
+  process.exitCode = 1;
+}
 function rejectUnknownHelpCommandPath(root, args) {
   if (!args.includes("--help") && !args.includes("-h")) {
     return;
@@ -2662,15 +2925,23 @@ function optionConsumesValue(token) {
   if (token.includes("=")) {
     return false;
   }
-  return token === "--host" || token === "--mcp-url" || token === "--format" || token === "--jq" || token === "--agent-context";
+  return token === "--host" || token === "--cli-token-file" || token === "--mcp-url" || token === "--format" || token === "--jq" || token === "--agent-context";
 }
 function globalOptionValue(args, option) {
+  let value;
   for (let i = 0; i < args.length; i += 1) {
     const token = args[i];
-    if (token === option) return args[i + 1];
-    if (token.startsWith(`${option}=`)) return token.slice(option.length + 1);
+    if (token === "--") break;
+    if (optionConsumesValue(token)) {
+      const next = args[i + 1];
+      if (next === void 0) {
+        throw new CliValidationError(`${token} requires a value.`, { code: "MISSING_OPTION_VALUE" });
+      }
+      if (token === option) value = next;
+      i += 1;
+    } else if (token.startsWith(`${option}=`)) value = token.slice(option.length + 1);
   }
-  return void 0;
+  return value;
 }
 function isRootUpdateCommand(args) {
   for (let i = 0; i < args.length; i += 1) {