@thinkingai/ae-cli 6.0.55 → 6.0.57

package/dist/chunk-TULINOLS.js

@@ -0,0 +1,2283 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  peekCliToken
+} from "./chunk-H3K5UGYC.js";
+import {
+  getActiveHost,
+  getConfigDir,
+  isAeSandboxRuntime,
+  readSandboxCliTokenEntry
+} from "./chunk-JNVVJ273.js";
+import {
+  PermissionError,
+  externalCliTokenRequestOptions,
+  normalizeUrl,
+  readExternalCliToken
+} from "./chunk-Z3Q2AEIN.js";
+
+// src/core/compat-check.ts
+import fs10 from "fs";
+import path10 from "path";
+import { createHash as createHash2 } from "crypto";
+import { Agent } from "undici";
+
+// src/core/update-check.ts
+function shouldSkipUpdateCheck(argv = process.argv) {
+  if (process.env.AE_CLI_NO_UPDATE_CHECK === "1") return true;
+  if (process.env.CI === "true" || process.env.CI === "1") return true;
+  return argv.slice(2).some((arg, index, args) => {
+    if (arg === "--no-update-check") return true;
+    if (arg === "--version") {
+      const value = args[index + 1];
+      return !value || value.startsWith("-");
+    }
+    if (arg === "-V" || arg === "--help" || arg === "-h") return true;
+    return false;
+  });
+}
+function parseVersion(version) {
+  const core = version.trim().split("-")[0];
+  return core.split(".").map((part) => {
+    const n = Number.parseInt(part, 10);
+    return Number.isFinite(n) ? n : 0;
+  });
+}
+function isNewer(latest, current) {
+  const a = parseVersion(latest);
+  const b = parseVersion(current);
+  const len = Math.max(a.length, b.length, 3);
+  for (let i = 0; i < len; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    if (av > bv) return true;
+    if (av < bv) return false;
+  }
+  return false;
+}
+
+// src/core/legacy-cli-version-map.ts
+var HISTORICAL_CLUSTER_TO_PUBLIC_PIN = {
+  "6.0.0": "1.0.15",
+  "6.0.1": "1.0.15",
+  "6.0.2": "1.0.18",
+  "6.0.3": "1.0.18",
+  "6.0.4": "1.0.20",
+  "6.0.5": "1.0.21",
+  "6.0.6": "1.0.22",
+  "6.0.7": "1.0.22",
+  "6.0.8": "1.0.22",
+  "6.0.9": "1.0.22",
+  "6.0.10": "1.0.24",
+  "6.0.11": "1.0.24",
+  "6.0.12": "1.0.27",
+  "6.0.13": "1.0.28",
+  "6.0.14": "1.0.28",
+  "6.0.15": "1.0.30",
+  "6.0.16": "6.0.16",
+  "6.0.17": "6.0.17",
+  "6.0.18": "6.0.18",
+  "6.0.19": "6.0.18",
+  "6.0.20": "6.0.20",
+  "6.0.21": "6.0.20",
+  "6.0.22": "6.0.22",
+  "6.0.23": "6.0.22",
+  "6.0.24": "6.0.24",
+  "6.0.25": "6.0.24",
+  "6.0.26": "6.0.24"
+};
+
+// src/core/install-process.ts
+import spawn from "cross-spawn";
+import fs from "fs";
+import path from "path";
+var INSTALL_TIMEOUT_MS = 12e4;
+var SKILLS_TOOL = "skills@1.5.12";
+var defaultInstallRunner = (command, args, timeoutMs) => {
+  const result2 = spawn.sync(command, args, {
+    encoding: "utf8",
+    maxBuffer: 8 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: timeoutMs,
+    windowsHide: true,
+    env: {
+      ...process.env,
+      DISABLE_TELEMETRY: "1",
+      NO_COLOR: "1",
+      // Select installed clients, not only the AI that launched AE CLI.
+      ...args[1] === SKILLS_TOOL && args[2] === "add" ? { AI_AGENT: "ae-cli" } : {}
+    }
+  });
+  return { ...result2, stdout: result2.stdout || "", stderr: result2.stderr || "" };
+};
+function resolveNodeTool(tool, execPath = process.execPath, platform = process.platform) {
+  const filename = platform === "win32" ? `${tool}.cmd` : tool;
+  const sibling = path.join(path.dirname(execPath), filename);
+  return fs.existsSync(sibling) ? sibling : filename;
+}
+function commandSucceeded(result2) {
+  return !result2.error && !result2.signal && result2.status === 0;
+}
+function exactVersion(raw) {
+  const version = raw.trim().replace(/^v/i, "");
+  if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(version)) {
+    throw new Error("Expected an exact version such as 6.0.49 or 6.1.9.");
+  }
+  return version;
+}
+function installHost(raw) {
+  if (!raw) return null;
+  const normalized = normalizeUrl(raw.trim());
+  try {
+    if (raw.includes("://") && !/^https?:\/\//.test(raw.trim())) throw new Error();
+    const url = new URL(normalized);
+    if (!["https:", "http:"].includes(url.protocol) || !url.hostname || url.username || url.password || url.search || url.hash || /[\s'"`$\\<>]/.test(normalized)) throw new Error();
+    return normalized;
+  } catch {
+    throw new Error("Host must be an HTTP(S) URL without credentials, query parameters, or fragments.");
+  }
+}
+function classifyInstallFailure(result2) {
+  const text = `${result2.error?.message || ""}
+${result2.stderr}
+${result2.stdout}`;
+  if (result2.error?.code === "ETIMEDOUT" || /timed?\s*out|ETIMEDOUT/i.test(text)) return "timeout";
+  if (/EACCES|EPERM|permission denied|access is denied/i.test(text)) return "permission";
+  if (/EAI_AGAIN|ENOTFOUND|ECONNRESET|ECONNREFUSED|network|unable to access|could not resolve|certificate|SSL/i.test(text)) return "network";
+  if (/E404|404 Not Found|no matching version|couldn't find remote ref/i.test(text)) return "package_missing";
+  return "unknown";
+}
+
+// src/core/version-compat.ts
+var OPEN_SOURCE_AE_CLI_PACKAGE = "@thinkingai/ae-cli";
+var PUBLISHED_EXTERNAL_VERSIONS = /* @__PURE__ */ new Set([
+  "1.0.15",
+  "1.0.18",
+  "1.0.20",
+  "1.0.21",
+  "1.0.22",
+  "1.0.24",
+  "1.0.27",
+  "1.0.28",
+  "1.0.30",
+  "6.0.16",
+  "6.0.17",
+  "6.0.18",
+  "6.0.20",
+  "6.0.22",
+  "6.0.24",
+  "6.0.27",
+  "6.0.28",
+  "6.0.29",
+  "6.0.30",
+  "6.0.31"
+]);
+function normalizeCliVersion(version) {
+  return version.trim().replace(/^v/i, "");
+}
+function versionLine(version) {
+  const parts = normalizeCliVersion(version).split(/[.-]/);
+  if (parts.length < 2) return normalizeCliVersion(version);
+  return `${parts[0]}.${parts[1]}`;
+}
+function sameVersionLine(a, b) {
+  return versionLine(a) === versionLine(b);
+}
+function parseVersionParts(version) {
+  const core = normalizeCliVersion(version).split("-")[0];
+  return core.split(".").map((p) => {
+    const n = Number.parseInt(p, 10);
+    return Number.isFinite(n) ? n : 0;
+  });
+}
+function compareNormalized(a, b) {
+  const pa = parseVersionParts(a);
+  const pb = parseVersionParts(b);
+  const len = Math.max(pa.length, pb.length, 3);
+  for (let i = 0; i < len; i += 1) {
+    const av = pa[i] ?? 0;
+    const bv = pb[i] ?? 0;
+    if (av > bv) return 1;
+    if (av < bv) return -1;
+  }
+  return 0;
+}
+function evaluateCompat(localRaw, expectedRaw, clusterLine) {
+  const local = normalizeCliVersion(localRaw);
+  const expected = normalizeCliVersion(expectedRaw);
+  if (!local || !expected) return { kind: "ok" };
+  const line = clusterLine && clusterLine.trim() || versionLine(expected);
+  if (!sameVersionLine(local, expected)) {
+    return { kind: "line_mismatch", local, expected, line };
+  }
+  if (clusterLine && clusterLine.trim()) {
+    const clusterNorm = clusterLine.trim();
+    const localLine = versionLine(local);
+    if (localLine !== clusterNorm && localLine !== versionLine(clusterNorm)) {
+      return { kind: "line_mismatch", local, expected, line: clusterNorm };
+    }
+  }
+  if (local === expected) return { kind: "ok" };
+  if (isNewer(local, expected)) {
+    return { kind: "local_newer", local, expected, line };
+  }
+  if (isNewer(expected, local)) {
+    return { kind: "local_older", local, expected, line };
+  }
+  return { kind: "ok" };
+}
+function resolvePinTarget(expectedVersion) {
+  const expected = expectedVersion.trim().replace(/^v/i, "");
+  if (!expected) return null;
+  if (PUBLISHED_EXTERNAL_VERSIONS.has(expected)) return expected;
+  const historical = HISTORICAL_CLUSTER_TO_PUBLIC_PIN[expected];
+  if (historical && PUBLISHED_EXTERNAL_VERSIONS.has(historical)) {
+    return historical;
+  }
+  const line = versionLine(expected);
+  const candidates = [...PUBLISHED_EXTERNAL_VERSIONS].filter((tag) => {
+    if (versionLine(tag) !== line) return false;
+    return compareNormalized(tag, expected) <= 0;
+  });
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => compareNormalized(a, b));
+  return candidates[candidates.length - 1] ?? null;
+}
+function formatPinCommands(expectedVersion) {
+  const ver = resolvePinTarget(expectedVersion);
+  if (!ver) return [];
+  return [
+    `npx ${OPEN_SOURCE_AE_CLI_PACKAGE}@latest update --target ${ver}`
+  ];
+}
+function formatUpgradeCommands(expectedVersion) {
+  let ver;
+  try {
+    ver = exactVersion(expectedVersion);
+  } catch {
+    return [];
+  }
+  return [
+    `npx ${OPEN_SOURCE_AE_CLI_PACKAGE}@latest update --target ${ver}`
+  ];
+}
+function formatUnifiedUpdateCommand() {
+  return "ae-cli update";
+}
+function formatCompatNotice(verdict) {
+  if (verdict.kind === "ok") return void 0;
+  const canUpdateToHost = formatUpgradeCommands(verdict.expected).length > 0;
+  if (verdict.kind === "local_newer") {
+    if (canUpdateToHost) {
+      return [
+        `[ae-cli] Host compat: local ${verdict.local} > environment ${verdict.expected} (cluster ${verdict.line}).`,
+        `         Run: ${formatUnifiedUpdateCommand()} to sync CLI + skills to this host.`,
+        `         Or update cluster components to the latest version.`
+      ].join("\n");
+    }
+    return [
+      `[ae-cli] Host compat: local ${verdict.local} > environment ${verdict.expected} (cluster ${verdict.line}).`,
+      `         No public GitHub/npm release on this line is \u2264 environment ${verdict.expected}.`,
+      `         Update cluster components to the latest version to match your CLI.`
+    ].join("\n");
+  }
+  if (verdict.kind === "local_older") {
+    if (canUpdateToHost) {
+      return [
+        `[ae-cli] Host compat: local ${verdict.local} < environment ${verdict.expected} (cluster ${verdict.line}).`,
+        `         Run: ${formatUnifiedUpdateCommand()} to sync CLI + skills to this host.`
+      ].join("\n");
+    }
+    return [
+      `[ae-cli] Host compat: local ${verdict.local} < environment ${verdict.expected} (cluster ${verdict.line}).`,
+      `         No installable semver target for environment ${verdict.expected}.`,
+      `         Ask the platform owner for the install package, or wait for a published build.`
+    ].join("\n");
+  }
+  if (canUpdateToHost) {
+    return [
+      `[ae-cli] Host compat: local ${verdict.local} line mismatches environment ${verdict.expected} (cluster ${verdict.line}).`,
+      `         Run: ${formatUnifiedUpdateCommand()} to sync CLI + skills to this host.`,
+      `         Or update cluster components to the latest version to match your CLI line.`
+    ].join("\n");
+  }
+  return [
+    `[ae-cli] Host compat: local ${verdict.local} line mismatches environment ${verdict.expected} (cluster ${verdict.line}).`,
+    `         No public GitHub/npm release for this line; update cluster components to the latest version, or install a published build on the same line.`
+  ].join("\n");
+}
+
+// src/core/version-sync.ts
+import fs8 from "fs";
+import path8 from "path";
+
+// src/core/installation.ts
+import fs7 from "fs";
+import path7 from "path";
+import crypto2 from "crypto";
+
+// src/core/package-info.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function getLocalCliPackageInfo() {
+  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i += 1) {
+    const candidate = path2.join(dir, "package.json");
+    try {
+      if (fs2.existsSync(candidate)) {
+        const pkg = JSON.parse(fs2.readFileSync(candidate, "utf8"));
+        if (pkg.name && pkg.version && String(pkg.name).includes("ae-cli")) {
+          return { name: pkg.name, version: pkg.version, root: dir };
+        }
+      }
+    } catch {
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { name: "@tant/ae-cli", version: "0.0.0", root: "" };
+}
+
+// src/core/skills-install.ts
+import fs3 from "fs";
+import os from "os";
+import path3 from "path";
+import { parseDocument } from "yaml";
+function globalSkillsDirectory() {
+  return path3.join(os.homedir(), ".agents", "skills");
+}
+function skillName(content) {
+  const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!frontmatter) throw new Error("Missing YAML frontmatter.");
+  const parsed = parseDocument(frontmatter[1], { uniqueKeys: true });
+  if (parsed.errors.length) throw new Error("Invalid YAML frontmatter.");
+  const data = parsed.toJS({ maxAliasCount: 100 });
+  if (!data || typeof data.name !== "string" || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(data.name) || typeof data.description !== "string" || !data.description.trim()) throw new Error("Invalid Skill metadata.");
+  return data.name;
+}
+function readFiles(root, prefix = "", files = /* @__PURE__ */ new Map()) {
+  for (const entry of fs3.readdirSync(path3.join(root, prefix), { withFileTypes: true })) {
+    if (entry.name.startsWith(".") || ["metadata.json", "__pycache__", "__pypackages__"].includes(entry.name)) continue;
+    const relative = path3.join(prefix, entry.name);
+    if (entry.isSymbolicLink()) throw new Error("Bundled Skills must contain regular files.");
+    if (entry.isDirectory()) readFiles(root, relative, files);
+    else if (entry.isFile()) files.set(relative, fs3.readFileSync(path3.join(root, relative)));
+  }
+  return files;
+}
+function readBundledSkills(directory) {
+  const skills = fs3.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => {
+    try {
+      const files = readFiles(path3.join(directory, entry.name));
+      return { name: skillName(files.get("SKILL.md").toString("utf8")), files };
+    } catch {
+      const name = /^[a-z0-9-]+$/.test(entry.name) ? entry.name : "(invalid name)";
+      throw new Error(`Invalid bundled Skill ${name}: missing files or YAML/frontmatter error.`);
+    }
+  });
+  if (!skills.length || new Set(skills.map((skill) => skill.name)).size !== skills.length) {
+    throw new Error("Bundled Skills are empty or contain duplicate names.");
+  }
+  return skills;
+}
+function verifyGlobalSkills(skills, directory) {
+  return skills.flatMap((skill) => {
+    let reason = "";
+    try {
+      const target = path3.join(directory, skill.name);
+      if (skillName(fs3.readFileSync(path3.join(target, "SKILL.md"), "utf8")) !== skill.name) {
+        reason = "Installed Skill name does not match the bundled Skill.";
+      } else {
+        for (const [file, expected] of skill.files) {
+          if (!fs3.readFileSync(path3.join(target, file)).equals(expected)) {
+            reason = "Installed files do not match the CLI package version.";
+            break;
+          }
+        }
+      }
+    } catch (error) {
+      reason = error.code === "ENOENT" ? "Expected Skill file is missing." : "Installed Skill has invalid YAML/frontmatter or unreadable files.";
+    }
+    return reason ? [{ skill: skill.name, reason }] : [];
+  });
+}
+
+// src/core/business-config.ts
+import crypto from "crypto";
+import fs4 from "fs";
+import path4 from "path";
+
+// src/core/skill-businesses.json
+var skill_businesses_default = {
+  base: [
+    "ae-capability"
+  ],
+  analysis: [
+    "ae-analysis",
+    "ae-analysis-global",
+    "ae-data-integration",
+    "ae-data-integration-helper",
+    "ae-generate-tracking-code",
+    "ae-generate-tracking-plan",
+    "ae-metadata",
+    "ae-migrate-tracking-code"
+  ],
+  dataops: [
+    "ae-dataops"
+  ],
+  engage: [
+    "ae-engage"
+  ],
+  community: [
+    "ae-community"
+  ],
+  agent: [
+    "ae-agent",
+    "ae-automation",
+    "ae-current-context",
+    "ae-evaluation",
+    "ae-kb",
+    "ae-kb-discovery",
+    "ae-page-context",
+    "ae-system",
+    "ae-team",
+    "ae-things",
+    "ae-things-progress",
+    "ae-things-review",
+    "ae-use-agent",
+    "ae-workspace"
+  ]
+};
+
+// src/core/businesses.ts
+var OPTIONAL_BUSINESSES = ["dataops", "engage", "agent", "community"];
+var COMMAND_BUSINESSES = {
+  dataops_datatable: "dataops",
+  dataops_flow: "dataops",
+  dataops_integration: "dataops",
+  dataops_operations: "dataops",
+  dataops_repo: "dataops",
+  dataops_ide: "dataops",
+  "engage-flow": "engage",
+  "engage-task": "engage",
+  "engage-setting": "engage",
+  "engage-scene": "engage",
+  "engage-activity": "engage",
+  "engage-workbench": "engage",
+  "engage-query": "engage",
+  community: "community",
+  kb: "agent",
+  team: "agent",
+  agent: "agent",
+  memory: "agent",
+  automation: "agent",
+  things: "agent",
+  workspace: "agent",
+  evaluation: "agent",
+  sync: "agent",
+  model: "agent",
+  context: "agent"
+};
+var AGENT_SYSTEM_COMMANDS = /* @__PURE__ */ new Set([
+  "channel",
+  "+bind-feishu-users",
+  "+create-channel",
+  "+list-channels",
+  "+remove-channel",
+  "+update-channel",
+  "+bind-quota-rule-user",
+  "+create-quota-rule",
+  "+get-balance",
+  "+get-balance-alert",
+  "+get-cost-summary",
+  "+list-over-limit-users",
+  "+list-quota-rules",
+  "+remove-quota-rule",
+  "+set-balance-alert",
+  "+update-quota-rule",
+  "+add-members",
+  "+get-member-stats",
+  "+list-member-candidates",
+  "+list-members",
+  "+remove-member",
+  "+set-member-role",
+  "+set-member-status",
+  "+clear-default-model",
+  "+get-default-models",
+  "+get-model-sync-settings",
+  "+get-system-model-price-rules",
+  "+list-company-models",
+  "+list-system-models",
+  "+set-company-model-enabled",
+  "+set-default-model",
+  "+set-model-sync-settings",
+  "+set-system-model-enabled",
+  "+get-sandbox-tool-distribution",
+  "+list-sandbox-tool-operations",
+  "+list-sandbox-tools",
+  "+npm-install",
+  "+remove-sandbox-tool",
+  "+set-sandbox-tool-enabled",
+  "+sync-sandbox-tools",
+  "+upload-sandbox-tool",
+  "+activate-sandbox-tools",
+  "+deactivate-sandbox-tools",
+  "+refresh-sandbox-tool-status",
+  "+batch-create-sandboxes",
+  "+bind-sandbox-user",
+  "+get-sandbox-config",
+  "+list-sandbox-users",
+  "+list-sandboxes",
+  "+remove-sandbox",
+  "+set-sandbox-enabled",
+  "+start-sandbox",
+  "+stop-sandbox",
+  "+unbind-sandbox-user",
+  "+update-sandbox",
+  "+export-usage",
+  "+export-usage-details",
+  "+get-agent-tool-calls",
+  "+get-usage-combinations",
+  "+get-usage-details",
+  "+get-usage-summary"
+]);
+var SKILL_BUSINESSES = Object.fromEntries(
+  OPTIONAL_BUSINESSES.flatMap((business) => skill_businesses_default[business].map((name) => [name, business]))
+);
+function normalizeBusinesses(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const record = value;
+  const result2 = {};
+  for (const business of OPTIONAL_BUSINESSES) {
+    if (typeof record[business] === "boolean") result2[business] = record[business];
+  }
+  return result2;
+}
+function businessForCommand(commandPath) {
+  const [service, resource] = commandPath;
+  if (service === "system") return AGENT_SYSTEM_COMMANDS.has(resource) ? "agent" : void 0;
+  return COMMAND_BUSINESSES[service];
+}
+function businessForCapability(idOrDomain) {
+  const namespace = idOrDomain.trim().toLowerCase().split(".")[0];
+  if (namespace === "dataops" || namespace === "engage") return namespace;
+  return COMMAND_BUSINESSES[namespace];
+}
+function businessForSkill(name) {
+  return SKILL_BUSINESSES[name];
+}
+function getSkillBusinessState(name, states) {
+  const business = businessForSkill(name);
+  return business ? states[business] : true;
+}
+
+// src/core/local-skill-context.ts
+function isSandboxExecutionContext() {
+  return process.env.TE_AGENT_CLI_CONFIG_DIR !== void 0 || isAeSandboxRuntime() || !!readSandboxCliTokenEntry();
+}
+function canManageGlobalSkills() {
+  return !readExternalCliToken() && !isSandboxExecutionContext();
+}
+
+// src/core/business-config.ts
+var BUSINESS_CONFIG_TTL_MS = 10 * 60 * 1e3;
+var UNAVAILABLE_TTL_MS = 5 * 60 * 1e3;
+function cachePath() {
+  return path4.join(getConfigDir(), "business-config.json");
+}
+function cacheKey(host, token) {
+  return `${normalizeUrl(host)}#${crypto.createHash("sha256").update(token).digest("hex")}`;
+}
+function readStore() {
+  try {
+    const value = JSON.parse(fs4.readFileSync(cachePath(), "utf8"));
+    if (value?.entries && typeof value.entries === "object" && !Array.isArray(value.entries)) return value;
+  } catch {
+  }
+  return { entries: {} };
+}
+function remember(host, token, entry) {
+  const store = readStore();
+  store.entries[cacheKey(host, token)] = entry;
+  const target = cachePath();
+  const temporary = `${target}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.tmp`;
+  try {
+    fs4.mkdirSync(path4.dirname(target), { recursive: true });
+    fs4.writeFileSync(temporary, JSON.stringify(store), { encoding: "utf8", mode: 384 });
+    fs4.renameSync(temporary, target);
+    fs4.chmodSync(target, 384);
+  } catch {
+    try {
+      fs4.rmSync(temporary, { force: true });
+    } catch {
+    }
+  }
+}
+function rememberBusinessConfig(host, token, businesses, now = Date.now()) {
+  remember(host, token, { businesses: normalizeBusinesses(businesses), fetchedAt: now });
+}
+function peekBusinessConfig(host, token, now = Date.now()) {
+  const entry = readStore().entries[cacheKey(host, token)];
+  if (entry?.unavailableAt !== void 0 && now >= entry.unavailableAt && now - entry.unavailableAt < UNAVAILABLE_TTL_MS) return {};
+  if (!entry || !Number.isFinite(entry.fetchedAt) || now < entry.fetchedAt || now - entry.fetchedAt >= BUSINESS_CONFIG_TTL_MS) return void 0;
+  return normalizeBusinesses(entry.businesses);
+}
+function readBusinessConfig(host, token) {
+  const entry = readStore().entries[cacheKey(host, token)];
+  return entry && Number.isFinite(entry.fetchedAt) && entry.fetchedAt > 0 ? normalizeBusinesses(entry.businesses) : void 0;
+}
+function readCurrentBusinessConfig(hostOverride) {
+  try {
+    if (isSandboxExecutionContext()) return {};
+    const host = hostOverride || getActiveHost();
+    if (!host) return {};
+    const token = peekCliToken(host);
+    return token ? readBusinessConfig(host, token) ?? {} : {};
+  } catch {
+    return {};
+  }
+}
+async function resolveBusinessConfig(host, token, fetchRemote, now = Date.now()) {
+  const cached = peekBusinessConfig(host, token, now);
+  if (cached !== void 0) return cached;
+  const config = await fetchRemote().catch(() => null);
+  if (!config) {
+    const previous = readStore().entries[cacheKey(host, token)];
+    remember(host, token, {
+      businesses: normalizeBusinesses(previous?.businesses),
+      fetchedAt: previous?.fetchedAt ?? 0,
+      unavailableAt: now
+    });
+    return {};
+  }
+  const businesses = normalizeBusinesses(config.businesses);
+  rememberBusinessConfig(host, token, businesses, now);
+  return businesses;
+}
+var BusinessDisabledError = class extends PermissionError {
+  constructor(business) {
+    super(
+      `The '${business}' business is not enabled for the current environment.`,
+      "BUSINESS_NOT_ENABLED",
+      "Contact your administrator if this business should be enabled, then run: ae-cli config refresh"
+    );
+    this.business = business;
+    this.name = "BusinessDisabledError";
+  }
+  business;
+};
+async function readBusinessConfigForExecution(hostOverride) {
+  try {
+    if (isSandboxExecutionContext()) return {};
+    const host = hostOverride || getActiveHost();
+    if (!host) return {};
+    const token = peekCliToken(host);
+    if (!token) return {};
+    return await resolveBusinessConfig(host, token, async () => {
+      const { fetchCliConfig: fetchCliConfig2 } = await import("./compat-check-PMEGUPZU.js");
+      return fetchCliConfig2(host, token);
+    });
+  } catch {
+    return {};
+  }
+}
+async function assertBusinessEnabled(business, hostOverride) {
+  if (business && (await readBusinessConfigForExecution(hostOverride))[business] === false) {
+    throw new BusinessDisabledError(business);
+  }
+}
+
+// src/core/business-skill-sync.ts
+import fs6 from "fs";
+import path6 from "path";
+import { randomUUID } from "crypto";
+
+// src/core/skills-tool.ts
+import fs5 from "fs";
+import os2 from "os";
+import path5 from "path";
+import { createHash } from "crypto";
+import { createRequire, isBuiltin } from "module";
+import { pathToFileURL } from "url";
+import spawn2 from "cross-spawn";
+var MANAGED_SKILLS_TOOL_VERSION = "1.5.12";
+var TOOL_SOURCE_SHA256 = "5a2c18ddd70886d5367e39a0f88827ffd1024420e4d9db08149742386c088d2d";
+function realSkillPath(file) {
+  try {
+    return fs5.realpathSync(file);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    const parent = path5.dirname(file);
+    if (parent === file) throw error;
+    return path5.join(realSkillPath(parent), path5.basename(file));
+  }
+}
+function skillPathProblem(targetDirectory, skill, sourceRoot) {
+  try {
+    const target = realSkillPath(path5.resolve(targetDirectory, skill));
+    const source = fs5.realpathSync(sourceRoot);
+    const overlaps = (a, b) => a === b || a.startsWith(b + path5.sep);
+    if (overlaps(target, source) || overlaps(source, target)) return "package_source_overlap";
+    let parent = path5.resolve(targetDirectory);
+    while (true) {
+      try {
+        if (fs5.lstatSync(parent).isSymbolicLink()) return "copy_parent_linked";
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      const next = path5.dirname(parent);
+      if (next === parent) return null;
+      parent = next;
+    }
+  } catch {
+    return "copy_parent_unreadable";
+  }
+}
+function skillCopyHash(directory, source = false) {
+  try {
+    if (!fs5.lstatSync(directory).isDirectory()) throw new Error("Not a regular Skill directory.");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  const hash = createHash("sha256");
+  const visit = (relative) => {
+    for (const name of fs5.readdirSync(path5.join(directory, relative)).sort()) {
+      if (name === ".DS_Store") continue;
+      const child = path5.join(relative, name);
+      const absolute = path5.join(directory, child);
+      const stat = fs5.lstatSync(absolute);
+      if (source && (name === "metadata.json" || stat.isDirectory() && [".git", "__pycache__", "__pypackages__"].includes(name))) continue;
+      const normalized = child.split(path5.sep).join("/");
+      if (stat.isSymbolicLink()) throw new Error("Symbolic links are not managed Skill copies.");
+      if (stat.isDirectory()) {
+        hash.update(`directory:${normalized}\0`);
+        visit(child);
+      } else if (stat.isFile()) {
+        hash.update(`file:${normalized}\0${stat.size}\0`);
+        hash.update(fs5.readFileSync(absolute));
+      } else throw new Error("Unsupported Skill file type.");
+    }
+  };
+  visit("");
+  return hash.digest("hex");
+}
+function replaceOnce(source, before, after) {
+  if (source.split(before).length !== 2) throw new Error("Pinned Skills adapter no longer matches its upstream source.");
+  return source.replace(before, after);
+}
+function adaptedToolSource(source, entry) {
+  const removeStart = source.indexOf("async function removeCommand(skillNames, options) {");
+  const removeEnd = source.indexOf("\nfunction parseRemoveOptions(args)", removeStart);
+  if (removeStart < 0 || removeEnd < 0) throw new Error("Pinned Skills removal implementation is missing.");
+  let remove = source.slice(removeStart, removeEnd);
+  remove = replaceOnce(remove, "const agentResult = await detectAgent();", "const agentResult = { isAgent: false };");
+  remove = replaceOnce(remove, "const spinner = Y();", "const spinner = { start() {}, stop() {} };");
+  remove = replaceOnce(
+    remove,
+    "if (pathToCleanup === canonicalPath) continue;",
+    "if (pathToCleanup === canonicalPath || !options.__aeCliAllowedPaths.has(pathToCleanup)) continue;"
+  );
+  remove = replaceOnce(
+    remove,
+    "if (await lstat(pathToCleanup).catch(() => null)) await rm(pathToCleanup, {",
+    "if (await lstat(pathToCleanup).catch(() => null) && await options.__aeCliBeforeMutation(pathToCleanup)) await rm(pathToCleanup, {"
+  );
+  remove = replaceOnce(
+    remove,
+    "if (!isStillUsed) await rm(canonicalPath, {",
+    "if (options.__aeCliAllowedPaths.has(canonicalPath) && await options.__aeCliBeforeMutation(canonicalPath)) await rm(canonicalPath, {"
+  );
+  remove = replaceOnce(
+    remove,
+    "if (isGlobal) await removeSkillFromLock(skillName);",
+    "if (isGlobal && options.__aeCliRemoveLockEntry) await removeSkillFromLock(skillName);"
+  );
+  remove = remove.replace(/\bM\.(?:info|warn|error|message|success)\(/g, "__aeCliQuiet(").replace(/\bconsole\.log\(/g, "__aeCliQuiet(").replace(/\bSe\(/g, "__aeCliQuiet(");
+  source = source.slice(0, removeStart) + remove + source.slice(removeEnd);
+  source = replaceOnce(
+    source,
+    "function getAgentBaseDir(agentType, global, cwd) {",
+    "function getAgentBaseDir(agentType, global, cwd) {\n if (global && __aeCliTargetOverride?.agent === agentType) return __aeCliTargetOverride.directory;"
+  );
+  source = replaceOnce(
+    source,
+    "async function cleanAndCreateDirectory(path) {",
+    'async function cleanAndCreateDirectory(path) {\n if (__aeCliBeforeInstallMutation && !await __aeCliBeforeInstallMutation(path)) throw new Error("Skill copy changed before installation.");'
+  );
+  source = replaceOnce(source, "main().finally(() => flushTelemetry().then(() => process.exit(0)));", "");
+  const require2 = createRequire(entry);
+  const resolveImport = (specifier) => isBuiltin(specifier) ? specifier : pathToFileURL(specifier.startsWith(".") ? path5.resolve(path5.dirname(entry), specifier) : require2.resolve(specifier)).href;
+  source = source.replace(
+    /\bfrom (['"])([^'"]+)\1/g,
+    (_match, quote, specifier) => `from ${quote}${resolveImport(specifier)}${quote}`
+  );
+  source = source.replace(
+    /\bimport (['"])([^'"]+)\1/g,
+    (_match, quote, specifier) => `import ${quote}${resolveImport(specifier)}${quote}`
+  );
+  return source + WORKER_SOURCE;
+}
+var WORKER_SOURCE = String.raw`
+import * as __aeCliFs from 'node:fs';
+import * as __aeCliPath from 'node:path';
+const __aeCliQuiet = () => {};
+let __aeCliTargetOverride = null;
+let __aeCliBeforeInstallMutation = null;
+function __aeCliRealPath(file) {
+  try { return __aeCliFs.realpathSync(file); }
+  catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    const parent = dirname(file);
+    if (parent === file) throw error;
+    return join(__aeCliRealPath(parent), basename(file));
+  }
+}
+function __aeCliPathProblem(targetDirectory, skill, sourceRoot) {
+  try {
+    const target = __aeCliRealPath(resolve(targetDirectory, skill));
+    const source = __aeCliFs.realpathSync(sourceRoot);
+    const overlaps = (a, b) => a === b || a.startsWith(b + sep);
+    if (overlaps(target, source) || overlaps(source, target)) return 'package_source_overlap';
+    let parent = resolve(targetDirectory);
+    while (true) {
+      try { if (__aeCliFs.lstatSync(parent).isSymbolicLink()) return 'copy_parent_linked'; }
+      catch (error) { if (error.code !== 'ENOENT') throw error; }
+      const next = dirname(parent);
+      if (next === parent) return null;
+      parent = next;
+    }
+  } catch { return 'copy_parent_unreadable'; }
+}
+function __aeCliHash(directory, source = false) {
+  try { if (!__aeCliFs.lstatSync(directory).isDirectory()) throw new Error('Unsupported Skill directory.'); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  const hash = createHash('sha256');
+  function visit(relativePath) {
+    for (const name of __aeCliFs.readdirSync(join(directory, relativePath)).sort()) {
+      if (name === '.DS_Store') continue;
+      const child = join(relativePath, name), absolute = join(directory, child);
+      const info = __aeCliFs.lstatSync(absolute);
+      if (source && (name === 'metadata.json' || (info.isDirectory() && ['.git', '__pycache__', '__pypackages__'].includes(name)))) continue;
+      const normalized = child.split(sep).join('/');
+      if (info.isSymbolicLink()) throw new Error('Symbolic links are not managed Skill copies.');
+      if (info.isDirectory()) { hash.update('directory:' + normalized + '\0'); visit(child); }
+      else if (info.isFile()) { hash.update('file:' + normalized + '\0' + info.size + '\0'); hash.update(__aeCliFs.readFileSync(absolute)); }
+      else throw new Error('Unsupported Skill file type.');
+    }
+  }
+  visit('');
+  return hash.digest('hex');
+}
+function __aeCliLegacyLinkProblem(operation, targetPath, targets, guard) {
+  try {
+    const canonical = resolve(getCanonicalSkillsDir(true));
+    const canonicalTarget = targets.find(target => target.agent === 'universal' && target.directory === canonical);
+    const link = operation.legacy_link;
+    if (!canonicalTarget || link.target !== join(canonical, operation.skill) || targetPath === link.target
+      || !guard.ledger_file || operation.expected_hash !== operation.source_hash) return 'legacy_link_not_managed';
+    const pathProblem = __aeCliPathProblem(canonical, operation.skill, operation.source_root);
+    if (pathProblem) return pathProblem;
+    const ledger = JSON.parse(__aeCliFs.readFileSync(guard.ledger_file, 'utf8'));
+    const owned = ledger.schema_version === 1 && ledger.copies?.[link.target];
+    if (!owned || owned.skill !== operation.skill || owned.agent !== canonicalTarget.agent
+      || owned.hash !== operation.source_hash) return 'legacy_link_not_managed';
+    if (!__aeCliFs.lstatSync(targetPath).isSymbolicLink() || __aeCliFs.readlinkSync(targetPath) !== link.text
+      || resolve(dirname(targetPath), link.text) !== link.target
+      || __aeCliFs.realpathSync(targetPath) !== __aeCliFs.realpathSync(link.target)) return 'legacy_link_changed';
+    if (__aeCliHash(link.target) !== operation.source_hash) return 'legacy_link_target_modified';
+    return null;
+  } catch { return 'legacy_link_unreadable'; }
+}
+function __aeCliLinkDependsOn(file, dependency) {
+  const absolute = resolve(file);
+  let cursor = __aeCliPath.parse(absolute).root;
+  const pending = absolute.slice(cursor.length).split(sep);
+  let links = 0;
+  while (pending.length) {
+    const part = pending.shift();
+    if (!part || part === '.') continue;
+    if (part === '..') { cursor = dirname(cursor); continue; }
+    cursor = join(cursor, part);
+    if (cursor === dependency || cursor.startsWith(dependency + sep)) return true;
+    if (!__aeCliFs.lstatSync(cursor).isSymbolicLink()) continue;
+    if (++links > 64) throw new Error('Skill link chain is too deep.');
+    const text = __aeCliFs.readlinkSync(cursor);
+    const root = __aeCliPath.parse(text).root;
+    cursor = root || dirname(cursor);
+    // Expand a link before applying subsequent '..' components, matching filesystem lookup.
+    pending.unshift(...text.slice(root.length).split(sep));
+  }
+  return false;
+}
+async function __aeCliTargets() {
+  const detected = new Set(await detectInstalledAgents());
+  const targets = new Map();
+  // Prefer the canonical registry entry when several agents share its global directory.
+  // Keep raw registry paths for legacy migration, but create copies only at installer destinations.
+  const entries = Object.entries(agents).sort(([a], [b]) => a === 'universal' ? -1 : b === 'universal' ? 1 : a.localeCompare(b));
+  for (const [agent, config] of entries) {
+    if (config.globalSkillsDir === undefined) continue;
+    const installDirectory = resolve(getAgentBaseDir(agent, true));
+    for (const directory of new Set([installDirectory, config.globalSkillsDir])) {
+      const key = __aeCliRealPath(resolve(directory));
+      const installable = resolve(directory) === installDirectory;
+      const target = targets.get(key);
+      if (target) { target.detected ||= detected.has(agent); target.installable ||= installable; }
+      else targets.set(key, { agent, directory: resolve(directory), installable,
+        detected: detected.has(agent) || key === __aeCliRealPath(resolve(getCanonicalSkillsDir(true))) });
+    }
+  }
+  return Array.from(targets.values());
+}
+async function __aeCliMain() {
+  // spawnSync pipes may be nonblocking; a full synchronization can exceed their buffer.
+  process.stdin.setEncoding('utf8');
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+  const request = JSON.parse(input);
+  const targets = await __aeCliTargets();
+  if (request.action === 'targets') return targets;
+  const receipts = [];
+  for (const operation of request.operations) {
+    const target = targets.find(item => item.agent === operation.target.agent && item.directory === operation.target.directory);
+    if (!target || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(operation.skill)) throw new Error('Invalid Skills operation target.');
+    const targetPath = join(target.directory, operation.skill);
+    const receipt = { action: operation.action, skill: operation.skill, agent: target.agent, path: targetPath, status: 'failed' };
+    let blockedReason = null;
+    const beforeMutation = async (candidate) => {
+      try {
+        const active = JSON.parse(__aeCliFs.readFileSync(request.guard.file, 'utf8'));
+        if (active.generation !== request.guard.generation) { blockedReason = 'context_changed'; return false; }
+        const pathProblem = __aeCliPathProblem(target.directory, operation.skill, operation.source_root);
+        if (pathProblem) { blockedReason = pathProblem; return false; }
+        // Registry compatibility paths remain available for existing copies only.
+        if (operation.action === 'install' && operation.expected_hash === null && !target.installable) {
+          blockedReason = 'legacy_target_missing'; return false;
+        }
+        if (candidate !== targetPath) { blockedReason = 'copy_changed'; return false; }
+        if (__aeCliHash(operation.source, true) !== operation.source_hash) { blockedReason = 'package_changed'; return false; }
+        if (operation.legacy_link) {
+          const problem = __aeCliLegacyLinkProblem(operation, targetPath, targets, request.guard);
+          if (problem) { blockedReason = problem; return false; }
+        } else if (__aeCliHash(targetPath) !== operation.expected_hash) { blockedReason = 'copy_changed'; return false; }
+        if (operation.action === 'remove') for (const other of targets) {
+          try {
+            // Preserve custom aliases too; only exact same-name installer links are migrated.
+            for (const name of __aeCliFs.readdirSync(other.directory)) {
+              const otherPath = join(other.directory, name);
+              if (otherPath === targetPath) continue;
+              try {
+                if (__aeCliFs.lstatSync(otherPath).isSymbolicLink() && __aeCliLinkDependsOn(otherPath, targetPath)) {
+                  blockedReason = 'dependent_unmanaged_link'; return false;
+                }
+              } catch (error) { if (error.code !== 'ENOENT') throw error; }
+            }
+          } catch (error) { if (error.code !== 'ENOENT') { blockedReason = 'dependent_copy_unreadable'; return false; } }
+        }
+        return true;
+      } catch { blockedReason = 'copy_unreadable'; return false; }
+    };
+    try {
+      if (!await beforeMutation(targetPath)) {
+        receipt.status = 'skipped'; receipt.reason = blockedReason;
+      } else {
+        __aeCliTargetOverride = target;
+        if (operation.action === 'install') {
+          const skill = await parseSkillMd(join(operation.source, 'SKILL.md'), { includeInternal: true });
+          if (!skill || skill.name !== operation.skill) throw new Error('Invalid package Skill.');
+          if (!await beforeMutation(targetPath)) { receipt.status = 'skipped'; receipt.reason = blockedReason; }
+          else {
+            __aeCliBeforeInstallMutation = beforeMutation;
+            const result = await installSkillForAgent(skill, target.agent, { global: true, mode: 'copy' });
+            if (blockedReason) { receipt.status = 'skipped'; receipt.reason = blockedReason; }
+            else {
+              const actualHash = __aeCliHash(targetPath);
+              if (!result.success || actualHash !== operation.source_hash) throw new Error('Skills installation verification failed.');
+              receipt.status = 'success'; receipt.hash = actualHash;
+            }
+          }
+        } else {
+          await removeCommand([operation.skill], { global: true, yes: true, agent: [target.agent],
+            __aeCliAllowedPaths: new Set([targetPath]), __aeCliBeforeMutation: beforeMutation });
+          if (blockedReason) { receipt.status = 'skipped'; receipt.reason = blockedReason; }
+          else {
+            let exists = true;
+            try { __aeCliFs.lstatSync(targetPath); }
+            catch (error) { if (error.code !== 'ENOENT') throw error; exists = false; }
+            if (exists) throw new Error('Skills removal verification failed.');
+            receipt.status = 'success';
+          }
+        }
+      }
+    } catch { receipt.status = blockedReason ? 'skipped' : 'failed'; receipt.reason = blockedReason || 'tool_operation_failed'; }
+    finally { __aeCliTargetOverride = null; __aeCliBeforeInstallMutation = null; }
+    if (receipt.status === 'success' && operation.legacy_link) receipt.reason = operation.action === 'install'
+      ? 'legacy_link_materialized' : 'legacy_link_removed';
+    receipts.push(receipt);
+  }
+  return receipts;
+}
+try { process.stdout.write(JSON.stringify({ ok: true, data: await __aeCliMain() })); }
+catch { process.stdout.write(JSON.stringify({ ok: false })); process.exitCode = 1; }
+`;
+function createPinnedSkillsTool(options = {}) {
+  const require2 = createRequire(import.meta.url);
+  const packageFile = options.entry ? path5.join(path5.dirname(options.entry), "..", "package.json") : require2.resolve("skills/package.json");
+  const entry = options.entry ?? path5.join(path5.dirname(packageFile), "dist", "cli.mjs");
+  const metadata = JSON.parse(fs5.readFileSync(packageFile, "utf8"));
+  const source = fs5.readFileSync(entry, "utf8");
+  if (metadata.version !== MANAGED_SKILLS_TOOL_VERSION || createHash("sha256").update(source).digest("hex") !== TOOL_SOURCE_SHA256) {
+    throw new Error("Managed Skill synchronization requires the verified skills@1.5.12 package.");
+  }
+  const script = adaptedToolSource(source, entry);
+  const run = (request) => {
+    const directory = fs5.mkdtempSync(path5.join(os2.tmpdir(), "ae-cli-skills-tool-"));
+    const worker = path5.join(directory, "adapter.mjs");
+    try {
+      fs5.writeFileSync(worker, script, { mode: 384 });
+      const result2 = spawn2.sync(process.execPath, [worker], {
+        input: JSON.stringify(request),
+        encoding: "utf8",
+        maxBuffer: 8 * 1024 * 1024,
+        timeout: options.timeoutMs ?? 12e4,
+        windowsHide: true,
+        cwd: options.cwd ?? directory,
+        env: { ...process.env, ...options.env, DISABLE_TELEMETRY: "1", NO_COLOR: "1", AI_AGENT: "ae-cli" }
+      });
+      if (result2.error || result2.signal || result2.status !== 0) throw new Error("Skills adapter process failed.");
+      const response = JSON.parse(result2.stdout);
+      if (response.ok !== true) throw new Error("Skills adapter returned an invalid response.");
+      return response.data;
+    } catch {
+      throw new Error("Skills adapter failed. Check the pinned package and directory permissions.");
+    } finally {
+      fs5.rmSync(directory, { recursive: true, force: true });
+    }
+  };
+  return {
+    targets: () => run({ action: "targets" }),
+    apply: (operations, guard) => run({ action: "apply", operations, guard })
+  };
+}
+
+// src/core/business-skill-sync.ts
+var CONTEXT_FILE = "business-skill-context.json";
+var LEDGER_FILE = "business-skills.json";
+var LOCK_FILE = "business-skills.lock";
+function writeJson(file, value) {
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    fs6.writeFileSync(temporary, JSON.stringify(value, null, 2) + "\n", { mode: 384, flag: "wx" });
+    fs6.renameSync(temporary, file);
+  } finally {
+    try {
+      fs6.unlinkSync(temporary);
+    } catch {
+    }
+  }
+}
+function contextIdentity(options) {
+  const fingerprint = options.tokenFingerprint ?? "";
+  if (fingerprint && !/^[a-f0-9]{64}$/.test(fingerprint)) throw new Error("Expected a SHA-256 token fingerprint.");
+  let host = "";
+  if (options.host) {
+    const url = new URL(options.host);
+    if (!["https:", "http:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+      throw new Error("Invalid active host.");
+    }
+    host = url.href.replace(/\/+$/, "");
+  }
+  return { host, token_fingerprint: fingerprint };
+}
+function reserveBusinessSkillContext(options) {
+  const directory = options.stateDirectory ?? getConfigDir();
+  fs6.mkdirSync(directory, { recursive: true, mode: 448 });
+  const generation = randomUUID();
+  writeJson(path6.join(directory, CONTEXT_FILE), { ...contextIdentity(options), generation });
+  return generation;
+}
+function currentContext(options, file, generation) {
+  try {
+    if (options.isCurrentContext && !options.isCurrentContext()) return false;
+    const active = JSON.parse(fs6.readFileSync(file, "utf8"));
+    const identity = contextIdentity(options);
+    return active.generation === generation && active.host === identity.host && active.token_fingerprint === identity.token_fingerprint;
+  } catch {
+    return false;
+  }
+}
+function isBusinessSkillContextCurrent(options) {
+  return currentContext(options, path6.join(options.stateDirectory ?? getConfigDir(), CONTEXT_FILE), options.generation);
+}
+function takeLock(file) {
+  const owner = randomUUID();
+  const ownerName = `owner-${process.pid}-${owner}.json`;
+  const candidate = fs6.mkdtempSync(`${file}.candidate-`);
+  const alive = (pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error.code !== "ESRCH";
+    }
+  };
+  try {
+    fs6.chmodSync(candidate, 448);
+    fs6.writeFileSync(path6.join(candidate, ownerName), JSON.stringify({ pid: process.pid, owner }), { mode: 384 });
+    for (let attempt = 0; attempt < 4; attempt++) {
+      try {
+        fs6.renameSync(candidate, file);
+        try {
+          fs6.unlinkSync(`${file}.reclaim`);
+        } catch {
+        }
+        return () => {
+          try {
+            fs6.unlinkSync(path6.join(file, ownerName));
+          } catch {
+          }
+          try {
+            fs6.rmdirSync(file);
+          } catch {
+          }
+        };
+      } catch (error) {
+        let stat;
+        try {
+          stat = fs6.lstatSync(file);
+        } catch (cause) {
+          if (cause.code === "ENOENT") continue;
+          throw error;
+        }
+        if (stat.isSymbolicLink()) return null;
+        if (stat.isFile()) {
+          let pid;
+          try {
+            pid = JSON.parse(fs6.readFileSync(file, "utf8")).pid;
+          } catch {
+          }
+          if (typeof pid === "number" && Number.isInteger(pid) && pid > 0 && alive(pid)) return null;
+          try {
+            fs6.unlinkSync(file);
+          } catch (cause) {
+            if (!["ENOENT", "EISDIR", "EPERM"].includes(cause.code ?? "")) throw cause;
+          }
+          continue;
+        }
+        if (!stat.isDirectory()) return null;
+        let names;
+        try {
+          names = fs6.readdirSync(file);
+        } catch (cause) {
+          if (cause.code === "ENOENT") continue;
+          throw cause;
+        }
+        for (const name of names) {
+          const match = /^owner-(\d+)-[a-f0-9-]{36}\.json$/.exec(name);
+          if (!match || alive(Number(match[1]))) return null;
+        }
+        for (const name of names) {
+          try {
+            fs6.unlinkSync(path6.join(file, name));
+          } catch (cause) {
+            if (cause.code !== "ENOENT") throw cause;
+          }
+        }
+        try {
+          fs6.rmdirSync(file);
+        } catch (cause) {
+          if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(cause.code ?? "")) throw cause;
+        }
+      }
+    }
+    return null;
+  } finally {
+    fs6.rmSync(candidate, { recursive: true, force: true });
+  }
+}
+function readLedger(file) {
+  let value;
+  try {
+    value = JSON.parse(fs6.readFileSync(file, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return { schema_version: 1, copies: {} };
+    throw new Error("Managed Skill ledger is unreadable.");
+  }
+  if (value.schema_version !== 1 || !value.copies || typeof value.copies !== "object" || Array.isArray(value.copies)) {
+    throw new Error("Managed Skill ledger has an unsupported format.");
+  }
+  for (const [filePath, copy] of Object.entries(value.copies)) {
+    if (!path6.isAbsolute(filePath) || !copy || typeof copy.skill !== "string" || typeof copy.agent !== "string" || !/^[a-f0-9]{64}$/.test(copy.hash) || typeof copy.package_version !== "string") throw new Error("Managed Skill ledger has an invalid copy.");
+  }
+  return value;
+}
+function result(skill, target, reason) {
+  return { skill, agent: target.agent, path: path6.join(target.directory, skill), ...reason ? { reason } : {} };
+}
+function legacySkillLink(file, skill, sourceRoot, sourceHash, targets, ledger) {
+  const canonical = targets.find((target2) => target2.agent === "universal");
+  if (!canonical) return;
+  const target = path6.join(canonical.directory, skill);
+  const managed = ledger.copies[target];
+  if (!managed || managed.skill !== skill || managed.agent !== canonical.agent || managed.hash !== sourceHash || skillPathProblem(canonical.directory, skill, sourceRoot)) return;
+  try {
+    if (!fs6.lstatSync(file).isSymbolicLink() || skillCopyHash(target) !== sourceHash) return;
+    const text = fs6.readlinkSync(file);
+    if (path6.resolve(path6.dirname(file), text) !== target || fs6.realpathSync(file) !== fs6.realpathSync(target)) return;
+    return { target, text };
+  } catch {
+    return;
+  }
+}
+function syncBusinessSkills(options) {
+  const report = {
+    status: "failed",
+    adopted: [],
+    installed: [],
+    removed: [],
+    skipped: [],
+    failed: [],
+    managed_count: 0
+  };
+  const directory = options.stateDirectory ?? getConfigDir();
+  const contextFile = path6.join(directory, CONTEXT_FILE);
+  let unlock = null;
+  try {
+    if (options.isCurrentContext && !options.isCurrentContext()) {
+      report.status = "stale";
+      return report;
+    }
+    fs6.mkdirSync(directory, { recursive: true, mode: 448 });
+    const generation = options.generation ?? reserveBusinessSkillContext(options);
+    if (!currentContext(options, contextFile, generation)) {
+      report.status = "stale";
+      return report;
+    }
+    unlock = takeLock(path6.join(directory, LOCK_FILE));
+    if (!unlock) {
+      report.status = "busy";
+      return report;
+    }
+    if (!currentContext(options, contextFile, generation)) {
+      report.status = "stale";
+      return report;
+    }
+    const ledgerFile = path6.join(directory, LEDGER_FILE);
+    const ledger = readLedger(ledgerFile);
+    const tool = options.tool ?? createPinnedSkillsTool({ env: options.env });
+    const targets = tool.targets();
+    const skills = readBundledSkills(options.skillsDirectory);
+    const packageVersion = options.packageVersion ?? "unknown";
+    const operations = [];
+    for (const skill of skills) {
+      const source = path6.join(options.skillsDirectory, skill.name);
+      const sourceHash = skillCopyHash(source, true);
+      if (!sourceHash) throw new Error("Complete package Skill source is missing.");
+      const state = getSkillBusinessState(skill.name, options.businesses);
+      if (options.mode !== "adopt" && state === void 0) continue;
+      for (const target of targets) {
+        const item = result(skill.name, target);
+        const pathProblem = skillPathProblem(target.directory, skill.name, options.skillsDirectory);
+        if (pathProblem) {
+          report.skipped.push({ ...item, reason: pathProblem });
+          continue;
+        }
+        let actualHash;
+        let legacyLink;
+        try {
+          actualHash = skillCopyHash(item.path);
+        } catch {
+          if (options.mode !== "adopt") legacyLink = legacySkillLink(
+            item.path,
+            skill.name,
+            options.skillsDirectory,
+            sourceHash,
+            targets,
+            ledger
+          );
+          if (!legacyLink) {
+            report.skipped.push({ ...item, reason: "copy_unreadable_or_linked" });
+            continue;
+          }
+          actualHash = sourceHash;
+        }
+        const managed = ledger.copies[item.path];
+        if (options.mode === "adopt") {
+          if (actualHash === null) {
+            if (managed) delete ledger.copies[item.path];
+            continue;
+          }
+          if (actualHash !== sourceHash) {
+            report.skipped.push({ ...item, reason: "copy_does_not_match_package" });
+            continue;
+          }
+          ledger.copies[item.path] = { skill: skill.name, agent: target.agent, hash: actualHash, package_version: packageVersion };
+          report.adopted.push(item);
+          continue;
+        }
+        if (!legacyLink && actualHash !== null && (!managed || managed.skill !== skill.name || actualHash !== managed.hash)) {
+          report.skipped.push({ ...item, reason: managed ? "copy_modified" : "copy_not_managed" });
+          continue;
+        }
+        if (actualHash === null && state === false) {
+          if (managed) delete ledger.copies[item.path];
+          continue;
+        }
+        if (state === true && actualHash === sourceHash && !legacyLink) continue;
+        if (state === true && actualHash === null && !target.installable) {
+          if (managed) delete ledger.copies[item.path];
+          continue;
+        }
+        if (state === true && actualHash === null && !target.detected && !managed && !fs6.existsSync(target.directory)) continue;
+        operations.push({
+          action: state ? "install" : "remove",
+          skill: skill.name,
+          source,
+          source_root: options.skillsDirectory,
+          target,
+          expected_hash: actualHash,
+          source_hash: sourceHash,
+          ...legacyLink ? { legacy_link: legacyLink } : {}
+        });
+      }
+    }
+    if (!currentContext(options, contextFile, generation)) {
+      report.status = "stale";
+      return report;
+    }
+    if (options.mode === "adopt") {
+      writeJson(ledgerFile, ledger);
+    } else if (operations.length) {
+      operations.sort((a, b) => Number(Boolean(b.legacy_link)) - Number(Boolean(a.legacy_link)));
+      const receipts = tool.apply(operations, { file: contextFile, generation, ledger_file: ledgerFile });
+      if (receipts.length !== operations.length) throw new Error("Skills adapter returned incomplete receipts.");
+      for (let index = 0; index < operations.length; index++) {
+        const operation = operations[index];
+        const receipt = receipts[index];
+        const item = result(operation.skill, operation.target, receipt.reason);
+        if (receipt.path !== item.path || receipt.agent !== item.agent || receipt.skill !== item.skill || receipt.action !== operation.action) throw new Error("Skills adapter returned mismatched receipts.");
+        if (receipt.status === "skipped") report.skipped.push(item);
+        else if (receipt.status !== "success") report.failed.push(item);
+        else if (operation.action === "remove") {
+          if (skillCopyHash(item.path) !== null) {
+            report.failed.push({ ...item, reason: "removal_not_verified" });
+            continue;
+          }
+          delete ledger.copies[item.path];
+          report.removed.push(item);
+        } else {
+          const actualHash = skillCopyHash(item.path);
+          if (actualHash !== operation.source_hash || receipt.hash !== actualHash) {
+            report.failed.push({ ...item, reason: "installation_not_verified" });
+            continue;
+          }
+          ledger.copies[item.path] = { skill: operation.skill, agent: operation.target.agent, hash: actualHash, package_version: packageVersion };
+          report.installed.push(item);
+        }
+      }
+      writeJson(ledgerFile, ledger);
+    } else writeJson(ledgerFile, ledger);
+    report.managed_count = Object.keys(ledger.copies).length;
+    report.status = !currentContext(options, contextFile, generation) ? "stale" : report.skipped.length || report.failed.length ? "partial" : "success";
+    return report;
+  } catch {
+    report.status = report.installed.length || report.removed.length || report.adopted.length ? "partial" : "failed";
+    return report;
+  } finally {
+    unlock?.();
+  }
+}
+
+// src/core/installation.ts
+function distribution(packageName) {
+  if (packageName === "@thinkingai/ae-cli") return { registry: "https://registry.npmjs.org", repository: "ThinkingAIAgenticEngine/ae-cli" };
+  if (packageName === "@tant/ae-cli") return { registry: "https://npm.thinkingdata.cn:3443", repository: "http://10.27.249.150:8888/te-ai/te-cli.git" };
+  throw new Error("Unsupported CLI package. Use an official AE CLI distribution.");
+}
+function newInstallationReport(packageName, version, dryRun = false) {
+  return {
+    ok: false,
+    dry_run: dryRun,
+    cli: { package: packageName, version, path: null, entrypoint: null, verified: false, action: "pending", warnings: [] },
+    skills: {
+      directory: globalSkillsDirectory(),
+      expected_count: 0,
+      installed_count: 0,
+      missing: [],
+      source: null,
+      version,
+      status: "pending",
+      failures: [],
+      attempts: []
+    },
+    auth: { host: null, authenticated: null, warnings: [] },
+    next_steps: []
+  };
+}
+function failInstallation(report, stage, message, cause = "validation") {
+  report.ok = false;
+  report.error = { type: "config", code: "AE_CLI_INSTALL_FAILED", message, stage, cause };
+  if (!report.next_steps.length) report.next_steps.push("Fix the reported problem and rerun the same install or update command.");
+  return report;
+}
+function installPlan(packageName, version, root = "<npm-root>") {
+  const config = distribution(packageName);
+  const target = exactVersion(version);
+  const executable = path7.join(root, packageName, "bin", "ae-cli.js");
+  return [
+    `npm install -g ${packageName}@${target} --registry=${config.registry}`,
+    `node ${JSON.stringify(executable)} install`
+  ];
+}
+function currentSkillIdentity() {
+  const host = getActiveHost();
+  const token = host ? peekCliToken(host) : void 0;
+  return { host, tokenFingerprint: token ? crypto2.createHash("sha256").update(token).digest("hex") : "" };
+}
+function skipGlobalSkillReason() {
+  try {
+    if (canManageGlobalSkills()) return void 0;
+  } catch {
+  }
+  return "An external-token or AE sandbox execution context is selected; global Skills were left unchanged.";
+}
+function readPackage(root) {
+  try {
+    return JSON.parse(fs7.readFileSync(path7.join(root, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function linked(root) {
+  try {
+    return fs7.lstatSync(root).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function cliBinBelongsToPackage(bin, packageRoot, platform) {
+  const entry = fs7.realpathSync(path7.join(packageRoot, "bin", "ae-cli.js"));
+  if (platform !== "win32") return fs7.realpathSync(bin) === entry;
+  const shim = fs7.readFileSync(bin, "utf8");
+  const targets = [...shim.matchAll(/"%(?:dp0%|~dp0)[\\/]([^"\r\n]+)"/gi)];
+  return targets.some(([, relative]) => {
+    try {
+      const target = path7.resolve(path7.dirname(bin), relative.replace(/\\/g, path7.sep));
+      return fs7.realpathSync(target).toLowerCase() === entry.toLowerCase();
+    } catch {
+      return false;
+    }
+  });
+}
+function runInstallation(options = {}) {
+  const local = getLocalCliPackageInfo();
+  const packageName = options.packageName ?? local.name;
+  const report = newInstallationReport(packageName, "", Boolean(options.dryRun));
+  const runner = options.runner ?? defaultInstallRunner;
+  const progress = options.progress ?? (() => {
+  });
+  const platform = options.platform ?? process.platform;
+  report.skills.directory = options.skillsDirectory ?? globalSkillsDirectory();
+  let stage = "environment";
+  try {
+    const target = exactVersion(options.target ?? local.version);
+    report.cli.version = target;
+    report.skills.version = target;
+    const config = distribution(packageName);
+    report.auth.host = installHost(options.host);
+    const major = Number((options.nodeVersion ?? process.versions.node).split(".")[0]);
+    if (!Number.isInteger(major) || major < 20) return failInstallation(report, stage, "AE CLI requires Node.js 20 or later. Select an existing supported Node runtime and rerun.");
+    if (options.dryRun) {
+      report.ok = true;
+      report.commands = installPlan(packageName, target);
+      report.next_steps.push("Dry run only; CLI, global Skills, and authentication have not been verified.");
+      return report;
+    }
+    const npm = resolveNodeTool("npm", process.execPath, platform);
+    progress("[ae-cli] [1/4] Checking Node.js, npm, and npx...");
+    for (const tool of [npm, resolveNodeTool("npx", process.execPath, platform)]) {
+      const result2 = runner(tool, ["--version"], 15e3);
+      if (!commandSucceeded(result2)) return failInstallation(report, stage, "npm and npx must be available alongside the selected Node.js runtime.", classifyInstallFailure(result2));
+    }
+    stage = "package_validation";
+    const rootResult = runner(npm, ["root", "-g"], 15e3);
+    const prefixResult = runner(npm, ["prefix", "-g"], 15e3);
+    const globalRoot = rootResult.stdout.trim();
+    const prefix = prefixResult.stdout.trim();
+    if (!commandSucceeded(rootResult) || !commandSucceeded(prefixResult) || !path7.isAbsolute(globalRoot) || !path7.isAbsolute(prefix) || /[\r\n]/.test(globalRoot + prefix)) return failInstallation(report, stage, "Cannot resolve npm global root and prefix. Check npm configuration.");
+    const packageRoot = path7.join(globalRoot, packageName);
+    const bin = platform === "win32" ? path7.join(prefix, "ae-cli.cmd") : path7.join(prefix, "bin", "ae-cli");
+    report.cli.path = bin;
+    const env = options.env ?? process.env;
+    const installedBefore = readPackage(packageRoot);
+    if (linked(packageRoot) && !options.skipCliInstall) return failInstallation(report, stage, "The global CLI is npm-linked to source. Preserve the link; use a separate npm prefix for a packaged installation.");
+    const syncSkills = options.syncSkills ?? syncBusinessSkills;
+    const skipSkills = skipGlobalSkillReason();
+    let context;
+    if (!skipSkills) {
+      const stateDirectory = options.skillStateDirectory ?? getConfigDir();
+      const identity = options.skillContext ?? currentSkillIdentity();
+      const isCurrentContext = () => {
+        if (skipGlobalSkillReason()) return false;
+        if (options.skillContext) return options.skillContext.isCurrentContext?.() ?? true;
+        try {
+          const current = currentSkillIdentity();
+          return current.host === identity.host && current.tokenFingerprint === identity.tokenFingerprint;
+        } catch {
+          return false;
+        }
+      };
+      const generation = reserveBusinessSkillContext({ ...identity, stateDirectory });
+      context = { ...identity, stateDirectory, generation, isCurrentContext };
+      if (!fs7.existsSync(path7.join(stateDirectory, "business-skills.json")) && installedBefore?.name === packageName) {
+        const previousSkills = path7.join(packageRoot, "skills");
+        try {
+          readBundledSkills(previousSkills);
+          syncSkills({ ...context, skillsDirectory: previousSkills, businesses: {}, mode: "adopt", packageVersion: installedBefore.version });
+        } catch {
+          report.next_steps.push("Existing Skills could not be adopted from the previous package; unmatched copies will be preserved.");
+        }
+      }
+      if (!isBusinessSkillContextCurrent(context)) {
+        return failInstallation(report, "skills_local", "The active environment changed before installation. Re-run install or update for the current environment.");
+      }
+    }
+    if (options.skipCliInstall || installedBefore?.name === packageName && installedBefore.version === target && fs7.existsSync(bin)) {
+      report.cli.action = "skipped";
+      progress("[ae-cli] [2/4] Verifying the existing CLI...");
+    } else {
+      stage = "npm_install";
+      progress(`[ae-cli] [2/4] Installing ${packageName}@${target}...`);
+      const result2 = runner(npm, ["install", "-g", `${packageName}@${target}`, "--registry", config.registry], INSTALL_TIMEOUT_MS);
+      if (!commandSucceeded(result2)) return failInstallation(report, stage, "npm installation failed. Check network access and a user-writable npm prefix; do not use sudo.", classifyInstallFailure(result2));
+      report.cli.action = "installed";
+    }
+    stage = "package_validation";
+    const installed = readPackage(packageRoot);
+    if (installed?.name !== packageName || installed.version !== target) return failInstallation(report, stage, "Installed CLI package identity or version does not match the requested distribution.");
+    if (!fs7.existsSync(bin)) return failInstallation(report, stage, "npm did not create the global ae-cli executable. Enable npm bin-links, reinstall, and add the global executable directory to PATH.");
+    if (!cliBinBelongsToPackage(bin, packageRoot, platform)) return failInstallation(report, stage, "The global executable does not belong to the installed CLI package.");
+    const versionResult = runner(bin, ["--version"], 15e3);
+    if (!commandSucceeded(versionResult) || versionResult.stdout.trim() !== target) return failInstallation(report, stage, "ae-cli --version did not return the requested version. Refresh the shell command cache and check npm bin links.");
+    report.cli.entrypoint = fs7.realpathSync(path7.join(packageRoot, "bin", "ae-cli.js"));
+    report.cli.verified = true;
+    const pathKey = platform === "win32" ? Object.keys(env).find((key) => key.toLowerCase() === "path") : "PATH";
+    const installedPathBin = (env[pathKey ?? "PATH"] ?? "").split(platform === "win32" ? ";" : path7.delimiter).filter(Boolean).map((dir) => path7.join(dir.replace(/^"(.*)"$/, "$1"), platform === "win32" ? "ae-cli.cmd" : "ae-cli")).find((file) => fs7.existsSync(file) && !file.includes(`${path7.sep}_npx${path7.sep}`));
+    if (!installedPathBin || fs7.realpathSync(installedPathBin) !== fs7.realpathSync(bin)) {
+      report.cli.warnings.push(`Add ${path7.dirname(bin)} to the front of PATH and refresh the shell command cache. The absolute executable was verified.`);
+      report.next_steps.push(`Use the verified executable at ${bin}, or correct PATH before invoking ae-cli.`);
+    }
+    if (skipSkills) {
+      report.skills.status = "skipped";
+      report.next_steps.push(skipSkills);
+      progress(`[ae-cli] [3/4] ${skipSkills}`);
+    } else if (context) {
+      stage = "skills_local";
+      const skillsPath = path7.join(packageRoot, "skills");
+      const skills = readBundledSkills(skillsPath);
+      if (!isBusinessSkillContextCurrent(context)) {
+        return failInstallation(report, stage, "The active environment changed during CLI installation. Re-run install or update to synchronize its Skills.");
+      }
+      const token = context.host ? peekCliToken(context.host) : void 0;
+      const knownBusinesses = options.businesses ?? (token ? readBusinessConfig(context.host, token) : void 0);
+      const businesses = knownBusinesses ?? Object.fromEntries(OPTIONAL_BUSINESSES.map((business) => [business, true]));
+      const expected = skills.filter((skill) => getSkillBusinessState(skill.name, businesses) === true);
+      report.skills.expected_count = expected.length;
+      report.skills.source = "installed-package";
+      progress("[ae-cli] [3/4] Synchronizing managed Skills for the current environment...");
+      const synchronized = syncSkills({ ...context, skillsDirectory: skillsPath, businesses, packageVersion: target });
+      report.skills.synchronization = synchronized;
+      report.skills.failures = verifyGlobalSkills(expected, report.skills.directory);
+      report.skills.missing = report.skills.failures.map((failure) => failure.skill);
+      report.skills.installed_count = expected.length - report.skills.missing.length;
+      for (const item of [...synchronized.failed, ...synchronized.skipped]) {
+        if (!report.skills.failures.some((failure) => failure.skill === item.skill)) {
+          report.skills.failures.push({ skill: item.skill, reason: item.reason ?? "Managed Skill synchronization did not complete." });
+        }
+      }
+      report.skills.status = synchronized.status === "success" && !report.skills.failures.length ? "success" : report.skills.installed_count || synchronized.installed.length || synchronized.removed.length ? "partial" : "failed";
+      report.skills.attempts.push({ source: "installed-package", stage, cause: report.skills.status === "success" ? null : "validation", failures: [...report.skills.failures] });
+      if (report.skills.status !== "success") {
+        return failInstallation(
+          report,
+          stage,
+          "Managed Skill synchronization is incomplete. User-modified and unowned copies were preserved; see skills.synchronization for details.",
+          synchronized.status === "busy" ? "busy" : "validation"
+        );
+      }
+    }
+    progress("[ae-cli] [4/4] Checking authentication guidance...");
+    if (report.auth.host) {
+      const result2 = runner(bin, ["--no-update-check", "--format", "json", "auth", "status", "--host", report.auth.host], INSTALL_TIMEOUT_MS);
+      try {
+        const body = JSON.parse(result2.stdout);
+        if (!commandSucceeded(result2) || !body.ok || typeof body.data?.authenticated !== "boolean") throw new Error();
+        report.auth.authenticated = body.data.authenticated;
+      } catch {
+        report.auth.warnings.push("Authentication status could not be verified. Run auth status for this host.");
+      }
+    }
+    if (report.auth.authenticated !== true) {
+      report.next_steps.push(`ae-cli auth login --host ${report.auth.host ?? "<AE_HOST>"} --no-wait`);
+      report.next_steps.push("Complete browser authorization, then run ae-cli auth login --host <AE_HOST> --device-code <DEVICE_CODE>.");
+    }
+    report.ok = true;
+    return report;
+  } catch (error) {
+    const safe = error instanceof Error && /^(Expected an exact|Unsupported CLI package|Host must|Invalid bundled Skill|Bundled Skills are empty)/.test(error.message);
+    return failInstallation(report, stage, safe ? error.message : "Installation could not complete at this stage. Check file permissions, package contents, and global Skills directory.");
+  }
+}
+
+// src/core/version-sync.ts
+var AUTO_ATTEMPT_INTERVAL_MS = 60 * 60 * 1e3;
+var MAX_AUTO_ATTEMPTS_PER_DAY = 3;
+var LOCK_STALE_MS = 10 * 60 * 1e3;
+var SYNC_STATE_FILE = "version-sync.json";
+var SYNC_LOCK_FILE = "version-sync.lock";
+function syncStatePath() {
+  return path8.join(getConfigDir(), SYNC_STATE_FILE);
+}
+function syncLockPath() {
+  return path8.join(getConfigDir(), SYNC_LOCK_FILE);
+}
+function readSyncStore() {
+  try {
+    const raw = JSON.parse(fs8.readFileSync(syncStatePath(), "utf8"));
+    if (raw && typeof raw === "object" && raw.hosts && typeof raw.hosts === "object") {
+      return raw;
+    }
+  } catch {
+  }
+  return { hosts: {} };
+}
+function writeSyncStore(store) {
+  try {
+    fs8.mkdirSync(getConfigDir(), { recursive: true });
+    fs8.writeFileSync(syncStatePath(), JSON.stringify(store, null, 2));
+  } catch {
+  }
+}
+function localDay(now) {
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function freshAttemptEntry(target, now) {
+  return {
+    target,
+    attemptDay: localDay(now),
+    attemptsToday: 0
+  };
+}
+function evaluateAutoAttempt(existing, target, now = /* @__PURE__ */ new Date()) {
+  const today = localDay(now);
+  const entry = !existing || existing.target !== target ? freshAttemptEntry(target, now) : existing.attemptDay !== today ? { ...freshAttemptEntry(target, now), pendingSkills: existing.pendingSkills, lastFailureStage: existing.lastFailureStage } : { ...existing };
+  if (entry.attemptsToday >= MAX_AUTO_ATTEMPTS_PER_DAY) {
+    return { allowed: false, reason: "daily_limit", entry };
+  }
+  if (entry.lastAttemptAt) {
+    const elapsed = now.getTime() - new Date(entry.lastAttemptAt).getTime();
+    if (Number.isFinite(elapsed) && elapsed < AUTO_ATTEMPT_INTERVAL_MS) {
+      return { allowed: false, reason: "hourly_limit", entry };
+    }
+  }
+  return { allowed: true, entry };
+}
+function reserveAutoAttempt(host, target, now = /* @__PURE__ */ new Date()) {
+  const store = readSyncStore();
+  const key = normalizeUrl(host);
+  const decision = evaluateAutoAttempt(store.hosts[key], target, now);
+  if (!decision.allowed) return decision;
+  decision.entry.attemptsToday += 1;
+  decision.entry.lastAttemptAt = now.toISOString();
+  store.hosts[key] = decision.entry;
+  writeSyncStore(store);
+  return decision;
+}
+function getPendingSkillsTarget(host) {
+  const entry = readSyncStore().hosts[normalizeUrl(host)];
+  return entry?.pendingSkills ? entry.target : void 0;
+}
+function recordVersionSyncResult(host, target, result2) {
+  const store = readSyncStore();
+  const key = normalizeUrl(host);
+  const existing = store.hosts[key] ?? freshAttemptEntry(target, /* @__PURE__ */ new Date());
+  const entry = existing.target === target ? existing : freshAttemptEntry(target, /* @__PURE__ */ new Date());
+  if (result2.ok) {
+    entry.pendingSkills = false;
+    delete entry.lastFailureStage;
+  } else {
+    entry.pendingSkills = result2.skillsPending;
+    entry.lastFailureStage = result2.stage;
+  }
+  store.hosts[key] = entry;
+  writeSyncStore(store);
+}
+function isRegularCliVersion(version) {
+  const normalized = normalizeCliVersion(version);
+  return /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(normalized) && normalized.split(".").every((part) => Number.isSafeInteger(Number(part)));
+}
+function isAutoSyncTargetEligible(version) {
+  if (!isRegularCliVersion(version)) return false;
+  const [major, minor, patch] = normalizeCliVersion(version).split(".").map(Number);
+  if (major > 6) return true;
+  if (major !== 6) return false;
+  if (minor > 1) return true;
+  if (minor === 1) return patch >= 5;
+  if (minor === 0) return patch >= 33;
+  return false;
+}
+function isPublicAeCliPackage(packageName) {
+  return packageName === OPEN_SOURCE_AE_CLI_PACKAGE;
+}
+function buildVersionInstallPlan(targetRaw, globalRoot = "<npm-root>", packageName = OPEN_SOURCE_AE_CLI_PACKAGE) {
+  const target = normalizeCliVersion(targetRaw);
+  return { target, commands: installPlan(packageName, target, globalRoot), skillsSources: ["installed-package"] };
+}
+function friendlyVersionSyncFailure(result2) {
+  if (result2.cause === "busy") {
+    return "Another ae-cli process is synchronizing the global installation.";
+  }
+  if (result2.cause === "permission") {
+    return "The global npm installation directory is not writable.";
+  }
+  if (result2.cause === "timeout") {
+    return "The npm or Skills download timed out.";
+  }
+  if (result2.cause === "network") {
+    return "The npm registry or Skills source could not be reached.";
+  }
+  if (result2.cause === "package_missing") {
+    return "The required CLI package or Skills tag is not available.";
+  }
+  if (result2.cause === "validation") {
+    return "The installed package could not be validated.";
+  }
+  return `Version synchronization failed at ${result2.stage}.`;
+}
+function acquireInstallLock(now) {
+  fs8.mkdirSync(getConfigDir(), { recursive: true });
+  const file = syncLockPath();
+  try {
+    return fs8.openSync(file, "wx");
+  } catch {
+    try {
+      const age = now.getTime() - fs8.statSync(file).mtimeMs;
+      if (age >= LOCK_STALE_MS) {
+        fs8.unlinkSync(file);
+        return fs8.openSync(file, "wx");
+      }
+    } catch {
+      try {
+        return fs8.openSync(file, "wx");
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+function releaseInstallLock(fd) {
+  try {
+    fs8.closeSync(fd);
+  } catch {
+  }
+  try {
+    fs8.unlinkSync(syncLockPath());
+  } catch {
+  }
+}
+function installVersion(targetRaw, options = {}) {
+  const run = () => {
+    const report = runInstallation({ ...options, target: targetRaw });
+    const cliInstalled = report.cli.verified || report.cli.action === "installed";
+    if (report.ok) return { ok: true, cliInstalled, skillsSource: "local", report };
+    return {
+      ok: false,
+      stage: report.error?.stage ?? "environment",
+      cliInstalled,
+      skillsPending: cliInstalled,
+      cause: report.error?.cause ?? "validation",
+      message: report.error?.message ?? "Installation failed.",
+      report
+    };
+  };
+  if (options.dryRun) return run();
+  let lock;
+  try {
+    lock = acquireInstallLock(options.now ?? /* @__PURE__ */ new Date());
+  } catch {
+    return {
+      ok: false,
+      stage: "lock",
+      cliInstalled: false,
+      skillsPending: Boolean(options.skipCliInstall),
+      cause: "permission",
+      message: "The installation lock directory is not writable."
+    };
+  }
+  if (lock === null) return {
+    ok: false,
+    stage: "lock",
+    cliInstalled: false,
+    skillsPending: Boolean(options.skipCliInstall),
+    cause: "busy",
+    message: "Another ae-cli process is already synchronizing the global installation."
+  };
+  try {
+    return run();
+  } finally {
+    releaseInstallLock(lock);
+  }
+}
+function autoSyncDirection(current, expected) {
+  if (versionLine(current) !== versionLine(expected)) return "switch";
+  const currentParts = normalizeCliVersion(current).split("-")[0].split(".").map(Number);
+  const expectedParts = normalizeCliVersion(expected).split("-")[0].split(".").map(Number);
+  for (let i = 0; i < Math.max(currentParts.length, expectedParts.length, 3); i += 1) {
+    const local = currentParts[i] ?? 0;
+    const target = expectedParts[i] ?? 0;
+    if (local < target) return "upgrade";
+    if (local > target) return "downgrade";
+  }
+  return "switch";
+}
+
+// src/core/feature-config.ts
+import crypto3 from "crypto";
+import fs9 from "fs";
+import path9 from "path";
+var FEATURE_TTL_MS = 24 * 60 * 60 * 1e3;
+var UNAVAILABLE_TTL_MS2 = 5 * 60 * 1e3;
+function cachePath2() {
+  return path9.join(getConfigDir(), "feature-config.json");
+}
+function cacheKey2(host, token) {
+  const fingerprint = crypto3.createHash("sha256").update(token).digest("hex");
+  return `${normalizeUrl(host)}#${fingerprint}`;
+}
+function readStore2() {
+  try {
+    const value = JSON.parse(fs9.readFileSync(cachePath2(), "utf8"));
+    return value?.entries && typeof value.entries === "object" ? value : { entries: {} };
+  } catch {
+    return { entries: {} };
+  }
+}
+function writeStore(store) {
+  const target = cachePath2();
+  const temp = `${target}.${process.pid}.${crypto3.randomBytes(6).toString("hex")}.tmp`;
+  try {
+    fs9.mkdirSync(path9.dirname(target), { recursive: true });
+    fs9.writeFileSync(temp, JSON.stringify(store), { encoding: "utf8", mode: 384 });
+    fs9.renameSync(temp, target);
+    fs9.chmodSync(target, 384);
+  } catch {
+    try {
+      fs9.rmSync(temp, { force: true });
+    } catch {
+    }
+  }
+}
+function remember2(host, token, entry) {
+  const store = readStore2();
+  store.entries[cacheKey2(host, token)] = entry;
+  writeStore(store);
+}
+function rememberKbAutoDiscoveryFeature(host, token, enabled) {
+  remember2(host, token, { enabled, available: true, fetchedAt: Date.now() });
+}
+async function resolveKbAutoDiscoveryFeature(host, token, fetchRemote) {
+  const entry = readStore2().entries[cacheKey2(host, token)];
+  const ttl = entry?.available ? FEATURE_TTL_MS : UNAVAILABLE_TTL_MS2;
+  if (entry && Date.now() >= entry.fetchedAt && Date.now() - entry.fetchedAt < ttl) {
+    return { enabled: entry.enabled, source: entry.available ? "cache" : "unavailable" };
+  }
+  const remote = await fetchRemote().catch(() => null);
+  if (!remote) {
+    remember2(host, token, { enabled: false, available: false, fetchedAt: Date.now() });
+    return { enabled: false, source: "unavailable" };
+  }
+  const enabled = remote.projectSemanticKbAutoDiscovery === true;
+  remember2(host, token, { enabled, available: true, fetchedAt: Date.now() });
+  return { enabled, source: "remote" };
+}
+
+// src/core/compat-check.ts
+var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+var NOTIFY_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+var CLI_CONFIG_PATH = "/v1/ta/cli/config";
+function cacheFilePath() {
+  return path10.join(getConfigDir(), "compat-check.json");
+}
+function readStore3() {
+  try {
+    const file = cacheFilePath();
+    if (!fs10.existsSync(file)) return { hosts: {} };
+    const raw = JSON.parse(fs10.readFileSync(file, "utf8"));
+    if (!raw || typeof raw !== "object" || !raw.hosts) return { hosts: {} };
+    return raw;
+  } catch {
+    return { hosts: {} };
+  }
+}
+function writeStore2(store) {
+  try {
+    const dir = getConfigDir();
+    if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
+    fs10.writeFileSync(cacheFilePath(), JSON.stringify(store, null, 2));
+  } catch {
+  }
+}
+function hostKey(host) {
+  return normalizeUrl(host);
+}
+function isCompatCacheStale(entry, now = Date.now()) {
+  if (!entry?.lastFetchedAt) return true;
+  const age = now - new Date(entry.lastFetchedAt).getTime();
+  return age >= CHECK_INTERVAL_MS;
+}
+function shouldNotifyCompat(entry, now = Date.now()) {
+  if (!entry?.lastNotifiedAt) return true;
+  const age = now - new Date(entry.lastNotifiedAt).getTime();
+  return age >= NOTIFY_INTERVAL_MS;
+}
+function shouldSkipCompatCheck(argv = process.argv) {
+  if (process.env.AE_CLI_NO_COMPAT_CHECK === "1") return true;
+  if (isAeSandboxRuntime()) return true;
+  return shouldSkipUpdateCheck(argv);
+}
+function rootCommand(argv) {
+  const args = argv.slice(2);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (token === "--") return void 0;
+    if (token.startsWith("-")) {
+      if (!token.includes("=") && ["--host", "--cli-token-file", "--mcp-url", "--format", "--jq"].includes(token)) {
+        i += 1;
+      }
+      continue;
+    }
+    return token;
+  }
+  return void 0;
+}
+function shouldSkipAutoSync(argv = process.argv) {
+  const command = rootCommand(argv);
+  return command === "update" || command === "install" || command === "auth" || command === "config";
+}
+async function fetchCliConfig(host, cliToken) {
+  const url = new URL(CLI_CONFIG_PATH, host.endsWith("/") ? host : `${host}/`);
+  const external = readExternalCliToken(host)?.token === cliToken;
+  if (!external) url.searchParams.set("cli-token", cliToken);
+  const controller = new AbortController();
+  const dispatcher = new Agent({ connect: { timeout: FETCH_TIMEOUT_MS } });
+  let cleanup;
+  const destroy = () => cleanup ??= dispatcher.destroy().catch(() => {
+  });
+  const timer = setTimeout(() => {
+    controller.abort();
+    void destroy();
+  }, FETCH_TIMEOUT_MS);
+  let resp;
+  try {
+    const options = {
+      dispatcher,
+      signal: controller.signal,
+      headers: { Accept: "application/json", ...external ? { "cli-token": cliToken } : {} },
+      ...externalCliTokenRequestOptions(url.toString())
+    };
+    resp = await fetch(url.toString(), options);
+    if (!resp.ok) return null;
+    const body = await resp.json();
+    const data = body.data ?? body;
+    const versions = data.versions;
+    if (!versions) return null;
+    const clusterVersion = versions.clusterVersion ?? versions.cluster_version ?? null;
+    const aeCliVersion = versions.aeCliVersion ?? versions.ae_cli_version ?? null;
+    return {
+      clusterVersion: clusterVersion?.trim() || null,
+      aeCliVersion: aeCliVersion?.trim() || null,
+      ...data.businesses && typeof data.businesses === "object" && !Array.isArray(data.businesses) ? { businesses: normalizeBusinesses(data.businesses) } : {},
+      ...typeof data.features?.projectSemanticKbAutoDiscovery === "boolean" ? { projectSemanticKbAutoDiscovery: data.features.projectSemanticKbAutoDiscovery } : {}
+    };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+    const destroyed = destroy();
+    if (resp?.body && !resp.bodyUsed) await Promise.allSettled([resp.body.cancel(), destroyed]);
+    else await destroyed;
+  }
+}
+function printNotice(text) {
+  process.stderr.write(`${text}
+`);
+}
+function isNonInteractiveOutput() {
+  return !process.stdout.isTTY || !process.stderr.isTTY;
+}
+var pendingHostCompatNotice;
+var pendingUpdateNotice;
+function getPendingHostCompatNotice() {
+  return pendingHostCompatNotice;
+}
+function getPendingUpdateNotice() {
+  return pendingUpdateNotice;
+}
+function getCachedCompatForHost(host) {
+  return readStore3().hosts[hostKey(host)];
+}
+function formatCapabilityMissCompatHint(host) {
+  if (shouldSkipCompatCheck()) return void 0;
+  const active = host || getActiveHost();
+  if (!active) {
+    return "This capability may be missing on the current private cluster. Update cluster components to the latest version, or pin this machine to the environment ae-cli version.";
+  }
+  const cached = getCachedCompatForHost(active);
+  if (cached?.expectedVersion) {
+    const pins = formatPinCommands(cached.expectedVersion);
+    if (pins.length > 0) {
+      return [
+        `Host may be older than this CLI (environment ae-cli ${cached.expectedVersion}, cluster ${cached.clusterVersion || "?"}).`,
+        `Update cluster components to the latest version, or pin locally:`,
+        ...pins.map((c) => `  ${c}`)
+      ].join("\n");
+    }
+    return [
+      `Host may be older than this CLI (environment ae-cli ${cached.expectedVersion}, cluster ${cached.clusterVersion || "?"}).`,
+      `No public GitHub/npm release matches that environment version; update cluster components to the latest version instead of pinning.`
+    ].join("\n");
+  }
+  return "This capability may be missing on the current private cluster. Update cluster components to the latest version, or pin this machine CLI + skills to the environment version (see ae-cli host compat notices after auth login).";
+}
+function setUpdateNotice(pkg, expected, cluster, verdict, state, stage, message) {
+  pendingHostCompatNotice = void 0;
+  pendingUpdateNotice = {
+    command: "ae-cli update",
+    current: pkg.version,
+    expected,
+    cluster,
+    reason: verdict.kind === "ok" && state === "skills_pending" ? "skills_pending" : verdict.kind,
+    state,
+    ...stage ? { stage } : {},
+    message: message ?? `Current ae-cli is ${pkg.version}; this host requires ${expected}. Run: ae-cli update`
+  };
+}
+async function refreshAndMaybeNotify(host, pkg, allowAutoSync) {
+  const token = peekCliToken(host);
+  if (!token) return { status: "continue" };
+  const store = readStore3();
+  const key = hostKey(host);
+  const existing = store.hosts[key];
+  let expected = existing?.expectedVersion;
+  let cluster = existing?.clusterVersion;
+  let fetchedAt = existing?.lastFetchedAt;
+  if (isCompatCacheStale(existing)) {
+    const remote = await fetchCliConfig(host, token);
+    if (remote) {
+      rememberKbAutoDiscoveryFeature(host, token, remote.projectSemanticKbAutoDiscovery ?? false);
+      rememberBusinessConfig(host, token, remote.businesses);
+    }
+    if (!remote?.aeCliVersion) {
+      return { status: "continue" };
+    }
+    expected = remote.aeCliVersion;
+    cluster = remote.clusterVersion ?? "";
+    fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+    store.hosts[key] = {
+      host: key,
+      localVersion: pkg.version,
+      expectedVersion: expected,
+      clusterVersion: cluster,
+      lastFetchedAt: fetchedAt,
+      lastNotifiedAt: existing?.lastNotifiedAt
+    };
+    writeStore2(store);
+  }
+  if (!expected) return { status: "continue" };
+  let verdict = evaluateCompat(pkg.version, expected, cluster);
+  let pendingSkills = getPendingSkillsTarget(host) === expected;
+  if (verdict.kind === "ok" && !pendingSkills) {
+    pendingHostCompatNotice = void 0;
+    pendingUpdateNotice = void 0;
+    return { status: "continue" };
+  }
+  let entry = store.hosts[key] ?? {
+    host: key,
+    localVersion: pkg.version,
+    expectedVersion: expected,
+    clusterVersion: cluster || "",
+    lastFetchedAt: fetchedAt || (/* @__PURE__ */ new Date()).toISOString()
+  };
+  entry.localVersion = pkg.version;
+  entry.expectedVersion = expected;
+  entry.clusterVersion = cluster || entry.clusterVersion;
+  const canAutoSync = allowAutoSync && isPublicAeCliPackage(pkg.name) && isRegularCliVersion(pkg.version) && isAutoSyncTargetEligible(expected);
+  if (canAutoSync) {
+    const isCurrentLocalIdentity = () => {
+      try {
+        return canManageGlobalSkills() && normalizeUrl(getActiveHost()) === key && peekCliToken(host) === token;
+      } catch {
+        return false;
+      }
+    };
+    const context = isCurrentLocalIdentity() ? { host, tokenFingerprint: createHash2("sha256").update(token).digest("hex") } : void 0;
+    const generation = context ? reserveBusinessSkillContext(context) : void 0;
+    const confirmed = await fetchCliConfig(host, token);
+    if (context && generation && !isBusinessSkillContextCurrent({
+      ...context,
+      generation,
+      isCurrentContext: isCurrentLocalIdentity
+    })) return { status: "continue" };
+    if (confirmed) {
+      rememberKbAutoDiscoveryFeature(host, token, confirmed.projectSemanticKbAutoDiscovery ?? false);
+      rememberBusinessConfig(host, token, confirmed.businesses);
+    }
+    if (confirmed?.aeCliVersion) {
+      expected = confirmed.aeCliVersion;
+      cluster = confirmed.clusterVersion ?? cluster ?? "";
+      verdict = evaluateCompat(pkg.version, expected, cluster);
+      pendingSkills = getPendingSkillsTarget(host) === expected;
+      entry = {
+        ...entry,
+        localVersion: pkg.version,
+        expectedVersion: expected,
+        clusterVersion: cluster || "",
+        lastFetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      store.hosts[key] = entry;
+      writeStore2(store);
+      if (verdict.kind === "ok" && !pendingSkills) {
+        pendingHostCompatNotice = void 0;
+        pendingUpdateNotice = void 0;
+        return { status: "continue" };
+      }
+      if (isAutoSyncTargetEligible(expected)) {
+        const attempt = reserveAutoAttempt(host, expected);
+        if (attempt.allowed) {
+          const direction = verdict.kind === "ok" && pendingSkills ? "skills" : autoSyncDirection(pkg.version, expected);
+          const verb = direction === "upgrade" ? "upgrading" : direction === "downgrade" ? "downgrading" : direction === "skills" ? "repairing" : "switching";
+          printNotice(
+            `[ae-cli] Current version ${pkg.version}; this host requires ${expected}. Automatically ${verb} the CLI installation; global Skills will be synchronized when this local context allows it. Please wait...`
+          );
+          const result2 = installVersion(expected, {
+            skipCliInstall: verdict.kind === "ok" && pendingSkills,
+            progress: printNotice
+          });
+          const globalSkillsSkipped = result2.ok && result2.report?.skills.status === "skipped";
+          if (globalSkillsSkipped && direction === "skills") {
+            printNotice("[ae-cli] Global Skills were not changed for this external-token or sandbox context. This command will continue; refresh Skills from a local signed-in environment.");
+            pendingHostCompatNotice = void 0;
+            pendingUpdateNotice = void 0;
+            return { status: "continue" };
+          }
+          recordVersionSyncResult(host, expected, result2);
+          if (result2.ok) {
+            printNotice(globalSkillsSkipped ? `[ae-cli] CLI changed from ${pkg.version} to ${expected}; global Skills were preserved. Starting the original command with the synchronized CLI...` : `[ae-cli] Synchronized to ${expected}. Starting the original command with the synchronized CLI...`);
+            pendingHostCompatNotice = void 0;
+            pendingUpdateNotice = void 0;
+            return {
+              status: "synced",
+              current: pkg.version,
+              expected,
+              cluster: cluster || "",
+              direction,
+              entrypoint: result2.report?.cli.verified ? result2.report.cli.entrypoint ?? void 0 : void 0
+            };
+          }
+          const state = result2.skillsPending ? "skills_pending" : "auto_sync_failed";
+          const friendlyCause = friendlyVersionSyncFailure(result2);
+          const failure = result2.skillsPending ? `CLI switched to ${expected}, but Skills synchronization failed. ${friendlyCause} This command will continue; run ae-cli update after access is restored.` : `${friendlyCause} This command will continue; run ae-cli update after fixing access.`;
+          printNotice(`[ae-cli] ${failure}`);
+          setUpdateNotice(pkg, expected, cluster || "", verdict, state, result2.stage, failure);
+          entry.lastNotifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+          store.hosts[key] = entry;
+          writeStore2(store);
+          return { status: "continue" };
+        }
+      }
+    }
+  }
+  const notice = verdict.kind === "ok" && pendingSkills ? `[ae-cli] CLI ${expected} is installed, but its Skills are not synchronized.
+         Run: ae-cli update` : formatCompatNotice(verdict);
+  if (!notice) return { status: "continue" };
+  const dueForTip = shouldNotifyCompat(entry);
+  if (!dueForTip) {
+    pendingHostCompatNotice = void 0;
+    pendingUpdateNotice = void 0;
+    store.hosts[key] = entry;
+    writeStore2(store);
+    return { status: "continue" };
+  }
+  setUpdateNotice(
+    pkg,
+    expected,
+    cluster || "",
+    verdict,
+    pendingSkills ? "skills_pending" : "prompt_only",
+    void 0,
+    pendingSkills ? `Skills for ae-cli ${expected} are not synchronized. Run: ae-cli update` : void 0
+  );
+  printNotice(notice);
+  entry.lastNotifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+  store.hosts[key] = entry;
+  writeStore2(store);
+  return { status: "continue" };
+}
+async function runHostCompatCheck(pkg, hostOverride, argv = process.argv) {
+  pendingHostCompatNotice = void 0;
+  pendingUpdateNotice = void 0;
+  if (shouldSkipCompatCheck(argv)) return { status: "continue" };
+  const host = hostOverride || getActiveHost();
+  if (!host) return { status: "continue" };
+  try {
+    return await refreshAndMaybeNotify(host, pkg, !shouldSkipAutoSync(argv));
+  } catch {
+    return { status: "continue" };
+  }
+}
+function notifyIfHostCompat(pkg, hostOverride) {
+  void runHostCompatCheck(pkg, hostOverride);
+}
+
+export {
+  exactVersion,
+  installHost,
+  getLocalCliPackageInfo,
+  businessForCommand,
+  businessForCapability,
+  canManageGlobalSkills,
+  rememberBusinessConfig,
+  readCurrentBusinessConfig,
+  BusinessDisabledError,
+  readBusinessConfigForExecution,
+  assertBusinessEnabled,
+  reserveBusinessSkillContext,
+  isBusinessSkillContextCurrent,
+  syncBusinessSkills,
+  newInstallationReport,
+  failInstallation,
+  recordVersionSyncResult,
+  buildVersionInstallPlan,
+  friendlyVersionSyncFailure,
+  installVersion,
+  resolveKbAutoDiscoveryFeature,
+  isCompatCacheStale,
+  shouldNotifyCompat,
+  shouldSkipCompatCheck,
+  shouldSkipAutoSync,
+  fetchCliConfig,
+  isNonInteractiveOutput,
+  getPendingHostCompatNotice,
+  getPendingUpdateNotice,
+  getCachedCompatForHost,
+  formatCapabilityMissCompatHint,
+  runHostCompatCheck,
+  notifyIfHostCompat
+};