@shulex/cxclawctl 0.1.2 → 0.1.3

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 
 // src/auth.ts
 import open from "open";
@@ -9,27 +9,37 @@ import open from "open";
 // package.json
 var package_default = {
   name: "@shulex/cxclawctl",
-  version: "0.1.2",
+  version: "0.1.3",
   description: "Solvea CXClaw CLI and Codex plugin runtime",
   type: "module",
-  bin: { cxclawctl: "./bin/cxclawctl.mjs" },
-  files: ["bin", "dist/cli.js", "dist/cli.js.map", "skills", "capabilities.lock.json", "requirements-cli.txt"],
+  bin: {
+    cxclawctl: "./bin/cxclawctl.mjs"
+  },
+  files: [
+    "bin",
+    "dist/cli.js",
+    "dist/cli.js.map"
+  ],
   scripts: {
     build: "tsup",
     dev: "tsx src/cli.ts",
     typecheck: "tsc --noEmit",
     test: "bun test --path-ignore-patterns _tmp_",
-    "check:capabilities": "python3 scripts/check_capabilities.py",
+    "check:capabilities": "tsx scripts/check-capabilities.ts",
     "check:release": "tsx scripts/check-release.ts",
+    "test:package": "tsx scripts/test-packed-package.ts",
     "release:prepare": "tsx scripts/prepare-release.ts",
     "package:agent-plugin": "node scripts/package-agent-plugin.mjs",
     "package:codex-plugin": "node scripts/package-codex-plugin.mjs"
   },
-  engines: { node: ">=22" },
+  engines: {
+    node: ">=22"
+  },
   dependencies: {
     "@alicloud/log": "^1.2.6",
     "@napi-rs/keyring": "^2.1.2",
     "compare-versions": "^6.1.1",
+    exceljs: "^4.4.0",
     open: "^10.2.0"
   },
   devDependencies: {
@@ -39,7 +49,10 @@ var package_default = {
     tsx: "^4.21.0",
     typescript: "^5.9.0"
   },
-  repository: { type: "git", url: "git+https://github.com/SolveaCX/cx_claw_codex.git" },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/SolveaCX/cx_claw_codex.git"
+  },
   license: "UNLICENSED"
 };
 
@@ -85,7 +98,7 @@ var options = process.platform === "linux" ? { linux: { store: "secret-service"
 var entry = () => new AsyncEntry("com.solvea.cxclaw", "session", options);
 async function loadSession() {
   const raw = await entry().getPassword();
-  if (!raw) throw new Error("\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8FD0\u884C npx --yes @shulex/cxclawctl@latest auth login");
+  if (!raw) throw new Error("\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8FD0\u884C cxclawctl auth login");
   return JSON.parse(raw);
 }
 async function saveSession(session) {
@@ -147,61 +160,932 @@ function option(args, name, required = false) {
   if (required && !value) throw new Error(`${name} is required`);
   return value;
 }
+function options2(args, name) {
+  const values = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === name && args[index + 1] && !args[index + 1].startsWith("-")) values.push(args[index + 1]);
+  }
+  return values;
+}
+function optionList(args, name) {
+  const index = args.indexOf(name);
+  if (index < 0) return [];
+  const values = [];
+  for (let cursor = index + 1; cursor < args.length && !args[cursor].startsWith("-"); cursor += 1) values.push(args[cursor]);
+  return values;
+}
 function flag(args, name) {
   return args.includes(name);
 }
 function positionals(args) {
   const out = [];
-  for (let i = 0; i < args.length; i++) {
-    if (args[i].startsWith("--")) {
-      if (!["--pretty", "--reverse", "--scheduled", "--install-scheduler"].includes(args[i])) i++;
-    } else out.push(args[i]);
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index].startsWith("--")) {
+      if (!["--pretty", "--reverse", "--scheduled", "--install-scheduler"].includes(args[index])) index += 1;
+    } else out.push(args[index]);
   }
   return out;
 }
 
 // src/business.ts
-import { spawn } from "child_process";
-import { access } from "fs/promises";
-import { dirname, join, normalize, relative, resolve } from "path";
+import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
-var packageRoot = () => resolve(dirname(fileURLToPath(import.meta.url)), "..");
-async function python() {
-  for (const name of ["python3.12", "python3"]) {
-    const ok = await new Promise((r) => {
-      const p = spawn(name, ["-c", "import sys;raise SystemExit(sys.version_info[:2]!=(3,12))"], { stdio: "ignore" });
-      p.on("error", () => r(false));
-      p.on("exit", (c) => r(c === 0));
+
+// src/solvea/commands.ts
+import { readFile as readFile2 } from "fs/promises";
+
+// src/solvea/client.ts
+var SolveaClient = class {
+  constructor(session) {
+    this.session = session;
+    if (!session.tenant?.businessUrl || !session.tenant.businessToken) {
+      throw new Error("no tenant selected; run tenant use before a business command");
+    }
+  }
+  session;
+  project;
+  bot;
+  get baseUrl() {
+    return this.session.tenant.businessUrl.replace(/\/$/, "");
+  }
+  get env() {
+    return this.session.tenant.environment;
+  }
+  async request(method, path, body, query2) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    for (const [key, value] of Object.entries(query2 ?? {})) url.searchParams.set(key, String(value));
+    const cookie = this.env === "prod" ? "_token" : "_token_staging";
+    const headers = new Headers({
+      accept: "application/json, text/plain, */*",
+      origin: this.baseUrl,
+      referer: `${this.baseUrl}/chatbot`,
+      cookie: `${cookie}=${this.session.tenant.businessToken}`,
+      "x-cxclaw-client-version": process.env.CXCLAW_PLUGIN_VERSION ?? "unknown"
     });
-    if (ok) return name;
-  }
-  throw new Error("Python 3.12 is required for CXClaw business scripts");
-}
-async function runPython(script, args, session) {
-  const root = packageRoot(), target = resolve(root, normalize(script.replace(/^[/\\]+/, "")));
-  if (!relative(join(root, "skills"), target) || relative(join(root, "skills"), target).startsWith("..")) throw new Error("script path must be inside skills/");
-  await access(target);
-  const command = await python();
-  const env = { ...process.env, PYTHONPATH: join(root, "skills", "__lib__") };
-  if (session?.tenant) Object.assign(env, { SOLVEA_ENV: session.tenant.environment, SOLVEA_BASE_URL: session.tenant.businessUrl, SOLVEA_PROD_URL: session.tenant.businessUrl, SOLVEA_TOKEN: session.tenant.businessToken, SOLVEA_PROD_TOKEN: session.tenant.businessToken });
-  return await new Promise((done, reject) => {
-    const child = spawn(command, [target, ...args], { stdio: "inherit", env });
-    child.on("error", reject);
-    child.on("exit", (code) => done(code ?? 1));
-  });
+    if (body !== void 0) headers.set("content-type", "application/json");
+    let last;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: body === void 0 ? void 0 : JSON.stringify(body),
+          signal: AbortSignal.timeout(3e4)
+        });
+        const text = await response.text();
+        let value;
+        try {
+          value = text ? JSON.parse(text) : void 0;
+        } catch {
+          value = { raw: text };
+        }
+        if (!response.ok) throw new Error(`HTTP ${response.status} ${method} ${path}: ${text}`);
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          const object = value;
+          const code = object.code ?? object.errno;
+          if (code !== void 0 && ![0, "0", 200, "200", "OK", "SUCCESS"].includes(code)) {
+            throw new Error(`API error ${method} ${path}: ${String(object.msg ?? object.message ?? object.error ?? code)}`);
+          }
+          if (object.success === false) throw new Error(`API error ${method} ${path}: ${String(object.msg ?? object.message ?? object.error ?? "request failed")}`);
+        }
+        return value;
+      } catch (error) {
+        last = error;
+        if (attempt < 2) await new Promise((resolve5) => setTimeout(resolve5, 200 * 2 ** attempt));
+      }
+    }
+    throw last;
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async get(path, query2) {
+    return this.request("GET", path, void 0, query2);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  async rawCall(method, path, body, query2) {
+    return this.request(method, path, body, query2);
+  }
+  safePathSegment(value, name) {
+    if (!value || value === "." || value === ".." || /[\\/?#%\u0000-\u001f\u007f]/.test(value)) {
+      throw new Error(`${name} must be a safe non-empty path segment`);
+    }
+    return encodeURIComponent(value);
+  }
+  async projectInfo() {
+    return this.get("/api_v2/gpt/bots");
+  }
+  async projectId() {
+    if (!this.project) {
+      const rows = await this.projectInfo();
+      const first = Array.isArray(rows) ? rows[0] : void 0;
+      this.project = String(first?.projectId ?? 950);
+      this.bot = String(first?.id ?? "");
+    }
+    return this.project;
+  }
+  async botId() {
+    if (!this.bot) await this.projectId();
+    return this.bot || "723";
+  }
+  async listAgents(category = "text") {
+    return this.post("/api_v2/gpt/ap/queryAgent", { projectId: Number(await this.projectId()), needRelation: true, noMeta: true, category });
+  }
+  async getAgent(id) {
+    return this.post("/api_v2/gpt/ap/queryAgent", { projectId: Number(await this.projectId()), agentId: Number(id), needRelation: true, squareAgent: false });
+  }
+  async getChatflowGraph(id) {
+    return this.post("/api_v2/gpt/chatflow/queryGraph/latest", { agentId: Number(id) });
+  }
+  async createAgent(data3) {
+    return this.post("/api_v2/gpt/ap/createAgent", { projectId: Number(await this.projectId()), ...data3 });
+  }
+  async updateAgent(data3) {
+    return this.post("/api_v2/gpt/ap/updateAgent", data3);
+  }
+  async updateChatflow(agentId, graph, publish = false) {
+    const current = await this.getAgent(agentId);
+    const agent = Array.isArray(current) ? current[0] : current;
+    if (!agent || agent.type !== "CHAT_FLOW") throw new Error(`Agent ${agentId} is not CHAT_FLOW`);
+    const payload = { ...agent, agentId: agent.id ?? Number(agentId), meta: { ...agent.meta ?? {}, chatFlowGraph: graph } };
+    return this.updateAgent({ ...payload, ...publish ? { publish: true } : {} });
+  }
+  async listPlugins() {
+    return this.post("/api_v2/gpt/ap/queryPlugin", { projectId: Number(await this.projectId()), needRelation: false });
+  }
+  async getPlugin(id) {
+    return this.post("/api_v2/gpt/ap/queryPlugin", { projectId: Number(await this.projectId()), pluginId: Number(id), convertStrategyV5: true });
+  }
+  async createPlugin(data3) {
+    return this.post("/api_v2/gpt/ap/createPlugin", { projectId: Number(await this.projectId()), ...data3 });
+  }
+  async updatePlugin(data3) {
+    return this.post("/api_v2/gpt/ap/updatePlugin", { projectId: Number(await this.projectId()), ...data3 });
+  }
+  async deletePlugin(id) {
+    return this.post("/api_v2/gpt/ap/deletePlugin", { projectId: Number(await this.projectId()), pluginId: Number(id) });
+  }
+  async runPlugin(config, requestBody) {
+    return this.post("/api_v2/gpt/ap/runHttpPlugin", {
+      projectId: Number(await this.projectId()),
+      botId: Number(await this.botId()),
+      externalHttpCallConfig: config,
+      ...requestBody === void 0 ? {} : { externalHttpCallRequestBody: requestBody }
+    });
+  }
+  async replaceMockData(type, records) {
+    if (records.length > 1e4) throw new Error("records must contain at most 10000 items");
+    return this.post(`/api_v2/gpt/mockdata/reAddMockData/${this.safePathSegment(type, "mock type")}`, records);
+  }
+  async queryMockData(type) {
+    return this.get("/api_v2/gpt/mockdata/queryMockData", { type: this.safePathSegment(type, "mock type"), globalData: false });
+  }
+  async listAiFields() {
+    return this.post("/api_v2/gpt/chatflow/queryAiFields", {});
+  }
+  async listAgentAiFields() {
+    return this.post("/api_v2/gpt/field/list/range", { fieldRange: ["all", "agent", "agent_preload_visible"] });
+  }
+  async aiFieldGuide() {
+    return this.post("/api_v2/tars/api/field/manage/guide/record", {});
+  }
+  async initializeAiFields() {
+    return this.get("/api_v2/tars/api/field/manage/pre/install");
+  }
+  async listManagedAiFields(pageIndex, pageSize2, name) {
+    return this.post("/api_v2/tars/api/field/manage/page", { pageIndex, pageSize: pageSize2, name });
+  }
+  async getManagedAiField(id) {
+    return this.get(`/api_v2/tars/api/field/manage/detail/${encodeURIComponent(id)}`);
+  }
+  async createManagedAiField(data3) {
+    return this.post("/api_v2/tars/api/field/manage/create", data3);
+  }
+  async updateManagedAiField(data3) {
+    return this.post("/api_v2/tars/api/field/manage/update", data3);
+  }
+  async deleteManagedAiField(id) {
+    return this.get(`/api_v2/tars/api/field/manage/delete/${encodeURIComponent(id)}`);
+  }
+  async toggleManagedAiField(id) {
+    return this.get(`/api_v2/tars/api/field/manage/switch/${encodeURIComponent(id)}`);
+  }
+  async chat(data3) {
+    const bot = String(data3.botId ?? await this.botId());
+    return this.post(`/api_v2/gpt/bot/${bot}/chat`, { botId: Number(bot), projectId: Number(await this.projectId()), option: { debug: true }, ...data3 });
+  }
+  async chatAsync(data3) {
+    const bot = String(data3.botId ?? await this.botId());
+    return this.post(`/api_v2/gpt/bot/${bot}/chat/async`, { botId: Number(bot), projectId: Number(await this.projectId()), option: { debug: true }, ...data3 });
+  }
+  async asyncResult(receipt, botId) {
+    const bot = botId ?? await this.botId();
+    return this.get(`/api_v2/gpt/bot/${bot}/chat/async/${encodeURIComponent(receipt)}`);
+  }
+  async listIntents(category = "E_COMMERCE") {
+    return this.get(`/api_v2/gpt/project/${await this.projectId()}/intents`, category ? { category } : void 0);
+  }
+  async getIntent(id) {
+    return this.get(`/api_v2/gpt/project/${await this.projectId()}/intent/${encodeURIComponent(id)}`);
+  }
+  async createIntent(data3) {
+    return this.post(`/api_v2/gpt/project/${await this.projectId()}/intent`, data3);
+  }
+  async updateIntent(id, data3) {
+    return this.put(`/api_v2/gpt/project/${await this.projectId()}/intent/${encodeURIComponent(id)}`, data3);
+  }
+  async toggleIntent(id, enabled2) {
+    return this.put(`/api_v2/gpt/project/${await this.projectId()}/intent/${encodeURIComponent(id)}/status`, { status: enabled2 ? "ENABLED" : "DISABLED" });
+  }
+  async listEntities() {
+    return this.get(`/api_v2/gpt/project/${await this.projectId()}/entities`);
+  }
+  async listStrategies(pageSize2 = 100) {
+    return this.get(`/api_v2/gpt/project/${await this.projectId()}/strategies`, { pageSize: pageSize2, pageNum: 1 });
+  }
+  async createStrategy(data3) {
+    return this.post(`/api_v2/gpt/project/${await this.projectId()}/strategy?v4=true`, data3);
+  }
+  async updateStrategy(id, data3) {
+    return this.request("PUT", `/api_v2/gpt/project/${await this.projectId()}/strategy/${encodeURIComponent(id)}`, data3);
+  }
+  async toggleStrategy(id, enabled2) {
+    return this.request("PUT", `/api_v2/gpt/project/${await this.projectId()}/strategy/${encodeURIComponent(id)}/status`, { status: enabled2 ? "ENABLED" : "DISABLED" });
+  }
+  async qualityStatus() {
+    return this.get("/api_v2/intelli/inspection/ticket/status");
+  }
+  async setQualityStatus(enabled2) {
+    return this.post("/api_v2/intelli/inspection/ticket/open", { open: enabled2, projectId: Number(await this.projectId()) });
+  }
+  async qualityRules(beginTimestamp, endTimestamp) {
+    return this.get("/api_v2/intelli/inspection/ticket/rules", { ...beginTimestamp === void 0 ? {} : { beginTimestamp }, ...endTimestamp === void 0 ? {} : { endTimestamp } });
+  }
+  async qualityRule(key) {
+    return this.get("/api_v2/intelli/inspection/ticket/rules/detail", { inspectionKey: key });
+  }
+  async updateQualityRule(data3) {
+    return this.post("/api_v2/intelli/inspection/ticket/rules", data3);
+  }
+  async customQualityRule(key) {
+    return this.post("/api_v2/intelli/inspection/ticket/customRules/detail", { inspectionKey: key });
+  }
+  async createCustomQualityRule(data3) {
+    return this.post("/api_v2/intelli/inspection/ticket/customRules/create", data3);
+  }
+  async updateCustomQualityRule(data3) {
+    return this.post("/api_v2/intelli/inspection/ticket/customRules/update", data3);
+  }
+  async deleteCustomQualityRule(key) {
+    return this.post("/api_v2/intelli/inspection/ticket/customRules/delete", { inspectionKey: key });
+  }
+  async listQualityAlertRules() {
+    return this.get("/api_v2/intelli/inspection/alert/list");
+  }
+  async getQualityAlertRule(id) {
+    return this.get("/api_v2/intelli/inspection/alert/detail", { id });
+  }
+  async createQualityAlertRule(data3) {
+    return this.post("/api_v2/intelli/inspection/alert/create", data3);
+  }
+  async updateQualityAlertRule(data3) {
+    return this.post("/api_v2/intelli/inspection/alert/update", data3);
+  }
+  async deleteQualityAlertRule(id) {
+    return this.get("/api_v2/intelli/inspection/alert/delete", { id });
+  }
+  async listQualityAlertMessages(data3) {
+    return this.post("/api_v2/intelli/inspection/alert/message/list", data3);
+  }
+  async getQualityAlertMessage(id) {
+    return this.get("/api_v2/intelli/inspection/alert/message/detail", { id });
+  }
+  async listTemplates(data3) {
+    return this.post(`/api_v2/gpt/project/${await this.projectId()}/templates/filter`, data3);
+  }
+  async createTemplate(data3) {
+    const content = String(data3.content ?? "");
+    return this.post(`/api_v2/gpt/project/${await this.projectId()}/template`, {
+      name: data3.name,
+      content,
+      status: data3.status ?? "ENABLED",
+      multiContent: data3.multiContent ?? { AUTO: content },
+      ...data3.scene ? { scene: data3.scene } : {}
+    });
+  }
+  async updateTemplate(id, data3) {
+    return this.put(`/api_v2/gpt/project/${await this.projectId()}/template/${encodeURIComponent(id)}`, data3);
+  }
+  async deleteTemplates(ids) {
+    return this.request("DELETE", `/api_v2/gpt/project/${await this.projectId()}/templates`, { templateIds: ids });
+  }
+  get qamPrefix() {
+    return this.env === "prod" ? "/api_v2/qam" : "/sns_v1";
+  }
+  get qamPath() {
+    return this.qamPrefix;
+  }
+  async listKnowledge(data3) {
+    return this.post(`${this.qamPrefix}/project/${await this.projectId()}/getKnowledge`, { type: "ALL", pageIndex: 1, pageSize: 50, keyword: "", ...data3 });
+  }
+  async getKnowledge(id) {
+    return this.get(`${this.qamPrefix}/project/${await this.projectId()}/ku/${encodeURIComponent(id)}`);
+  }
+  async updateKnowledge(id, data3) {
+    return this.request("PUT", `${this.qamPrefix}/project/${await this.projectId()}/ku`, { ...data3, kuId: Number(id) });
+  }
+  async uploadQa(items) {
+    return this.post(`${this.qamPrefix}/project/${await this.projectId()}/kus`, items);
+  }
+  async listDirectories() {
+    return this.get(`${this.qamPrefix}/project/${await this.projectId()}/directories`, { keyword: "", kuPublished: "" });
+  }
+  async createFolder(name, parentId = 0) {
+    return this.post(`${this.qamPrefix}/project/${await this.projectId()}/directory`, { name, parentId, type: "GENERIC" });
+  }
+  async updateDirectory(id, data3) {
+    return this.request("PUT", `${this.qamPrefix}/project/${await this.projectId()}/directory/${encodeURIComponent(id)}`, data3);
+  }
+  async deleteDirectory(id) {
+    return this.request("DELETE", `${this.qamPrefix}/project/${await this.projectId()}/directory/${encodeURIComponent(id)}`);
+  }
+  async knowledgeTags(keyword = "") {
+    return this.get(`${this.qamPrefix}/project/${await this.projectId()}/searchKeywordAndIntents`, { keyword });
+  }
+  async transcript(chatId) {
+    return this.get(`/api_v2/gpt/project/${await this.projectId()}/transcript/${encodeURIComponent(chatId)}`, { isCompare: true });
+  }
+  async listTranscripts(data3) {
+    return this.post(`/api_v2/gpt/project/${await this.projectId()}/transcripts/filter`, data3);
+  }
+  async resolveTranscriptChatId(externalId, pageSize2 = 10) {
+    const result = await this.listTranscripts({ pageSize: pageSize2, pageIndex: 1, debug: false, keyword: externalId });
+    const rows = Array.isArray(result) ? result : result?.list;
+    const items = Array.isArray(rows) ? rows.filter((row) => row && typeof row === "object") : [];
+    const exact = items.filter((row) => String(row.externId ?? row.externalId ?? row.external_id ?? "") === externalId);
+    const matches = (exact.length ? exact : items).map((row) => ({ chatId: row.chatId ?? row.id, externalId: row.externId ?? row.externalId ?? row.external_id, agentName: row.agentName ?? "", touchPoint: row.touchPoint ?? row.touchpoint ?? "", createdAt: row.createdAt ?? "" }));
+    return { externalId, chatId: exact.length || matches.length === 1 ? matches[0]?.chatId ?? null : null, matchedBy: exact.length ? "exactExternalId" : "keyword", matches };
+  }
+  async chatContext(botId, data3) {
+    return this.post(`/api_v2/gpt/bot/${encodeURIComponent(botId)}/chat/context/compare`, data3);
+  }
+};
+
+// src/solvea/input.ts
+import { readFile } from "fs/promises";
+async function jsonData(args, required = true) {
+  const file = option(args, "--data-file");
+  const raw = file ? await readFile(file, "utf8") : option(args, "--data");
+  if (!raw) {
+    if (required) throw new Error("--data or --data-file is required");
+    return {};
+  }
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("request data must be a JSON object");
+  return parsed;
+}
+async function jsonValue(args) {
+  const file = option(args, "--data-file");
+  const raw = file ? await readFile(file, "utf8") : option(args, "--data", true);
+  return JSON.parse(raw);
+}
+function requireFlag(args, name, command) {
+  if (!flag(args, name)) throw new Error(`${command} requires ${name} after explicit user acknowledgement`);
+}
+function requireId(args) {
+  return option(args, "--id", true);
+}
+
+// src/solvea/extended-commands.ts
+var handlers = {
+  "replace-mock-data": async (client, args) => {
+    const records = await jsonValue(args);
+    if (!Array.isArray(records)) throw new Error("replace-mock-data requires a JSON array");
+    return client.replaceMockData(option(args, "--name", true), records);
+  },
+  "query-mock-data": (client, args) => client.queryMockData(option(args, "--name", true)),
+  "run-plugin": async (client, args) => {
+    const payload = await jsonData(args);
+    const config = "externalHttpCallConfig" in payload ? payload.externalHttpCallConfig : payload;
+    return client.runPlugin(config, payload.externalHttpCallRequestBody);
+  },
+  "list-ai-fields": (client) => client.listAiFields(),
+  "list-agent-ai-fields": (client) => client.listAgentAiFields(),
+  "get-ai-field-guide": (client) => client.aiFieldGuide(),
+  "initialize-ai-fields": (client) => client.initializeAiFields(),
+  "list-managed-ai-fields": (client, args) => client.listManagedAiFields(
+    Number(option(args, "--page") ?? 1),
+    Number(option(args, "--page-size") ?? 50),
+    option(args, "--keyword") ?? ""
+  ),
+  "get-managed-ai-field": (client, args) => client.getManagedAiField(requireId(args)),
+  "create-managed-ai-field": async (client, args) => client.createManagedAiField(await jsonData(args)),
+  "update-managed-ai-field": async (client, args) => client.updateManagedAiField(await jsonData(args)),
+  "delete-managed-ai-field": async (client, args) => {
+    requireFlag(args, "--confirm-delete", "delete-managed-ai-field");
+    return client.deleteManagedAiField(requireId(args));
+  },
+  "toggle-managed-ai-field": (client, args) => client.toggleManagedAiField(requireId(args)),
+  "list-quality-alert-rules": (client) => client.listQualityAlertRules(),
+  "get-quality-alert-rule": (client, args) => client.getQualityAlertRule(requireId(args)),
+  "create-quality-alert-rule": async (client, args) => client.createQualityAlertRule(await jsonData(args)),
+  "update-quality-alert-rule": async (client, args) => client.updateQualityAlertRule(await jsonData(args)),
+  "delete-quality-alert-rule": async (client, args) => {
+    requireFlag(args, "--confirm-delete", "delete-quality-alert-rule");
+    return client.deleteQualityAlertRule(requireId(args));
+  },
+  "list-quality-alert-messages": async (client, args) => client.listQualityAlertMessages(await jsonData(args)),
+  "get-quality-alert-message": (client, args) => client.getQualityAlertMessage(requireId(args)),
+  "list-templates": (client, args) => client.listTemplates({
+    pageIndex: Number(option(args, "--page") ?? 1),
+    pagesize: Number(option(args, "--page-size") ?? 50),
+    keyword: option(args, "--keyword") ?? "",
+    ...options2(args, "--scene").length ? { scenes: options2(args, "--scene") } : {},
+    ...option(args, "--status") ? { status: [option(args, "--status")] } : {}
+  }),
+  "create-template": async (client, args) => {
+    const payload = await jsonData(args, false);
+    if (option(args, "--name")) payload.name = option(args, "--name");
+    if (option(args, "--content")) payload.content = option(args, "--content");
+    if (option(args, "--status")) payload.status = option(args, "--status");
+    if (options2(args, "--scene")[0]) payload.scene = options2(args, "--scene")[0];
+    if (!payload.name || !payload.content) throw new Error("create-template requires name and content");
+    return client.createTemplate(payload);
+  },
+  "update-template": async (client, args) => {
+    const payload = await jsonData(args, false);
+    for (const [field, name] of [["name", "--name"], ["content", "--content"], ["status", "--status"]]) {
+      if (option(args, name)) payload[field] = option(args, name);
+    }
+    if (!Object.keys(payload).length) throw new Error("update-template requires at least one changed field");
+    return client.updateTemplate(requireId(args), payload);
+  },
+  "delete-templates": async (client, args) => {
+    requireFlag(args, "--confirm-delete", "delete-templates");
+    const ids = optionList(args, "--ids").map(Number);
+    if (!ids.length || ids.some((id) => !Number.isSafeInteger(id) || id <= 0)) throw new Error("delete-templates requires positive integer --ids");
+    return client.deleteTemplates(ids);
+  }
+};
+var EXTENDED_COMMANDS = new Set(Object.keys(handlers));
+async function runExtendedCommand(client, command, args) {
+  const handler = handlers[command];
+  if (!handler) throw new Error(`TypeScript command not migrated yet: ${command}`);
+  return handler(client, args);
+}
+
+// src/solvea/remaining-commands.ts
+var data = async (args) => jsonData(args, false);
+var project = async (client) => client.projectId();
+var page = (args) => Number(option(args, "--page") ?? 1);
+var pageSize = (args) => Number(option(args, "--page-size") ?? 50);
+var reportBody = async (args) => ({
+  beginTimestamp: Number(option(args, "--begin-ts", true)),
+  endTimestamp: Number(option(args, "--end-ts", true)),
+  timeOffset: Number(option(args, "--time-offset") ?? 8),
+  ...await data(args)
+});
+var handlers2 = {
+  "chat-stream": async (c, a) => c.rawCall("POST", `/api_v2/gpt/bot/${await c.botId()}/chat`, { message: option(a, "--message", true), botId: Number(option(a, "--bot-id") ?? await c.botId()), projectId: Number(await project(c)), option: { debug: true }, stream: true }),
+  "update-chatflow": async (c, a) => c.updateChatflow(option(a, "--agent-id", true), await jsonData(a), flag(a, "--publish")),
+  "get-conversations-by-intent": async (c, a) => c.listTranscripts({ pageSize: Number(option(a, "--limit") ?? 50), pageIndex: 1, intent: option(a, "--intent", true) }),
+  "resolve-transcript-chat-id": async (c, a) => c.resolveTranscriptChatId(option(a, "--external-id", true), Number(option(a, "--page-size") ?? 10)),
+  "list-isolation-keywords": async (c, a) => c.rawCall("GET", `${c.qamPath}/project/${await project(c)}/isolation_keywords`, void 0, { keyword: option(a, "--keyword") ?? "", pageIndex: page(a), pageSize: pageSize(a) }),
+  "create-isolation-keyword": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/isolation_keyword`, { keyword: option(a, "--keyword", true) }),
+  "update-isolation-keyword": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/isolation_keyword/${requireId(a)}`, { keyword: option(a, "--keyword", true) }),
+  "delete-isolation-keyword": async (c, a) => {
+    requireFlag(a, "--confirm-delete", "delete-isolation-keyword");
+    return c.rawCall("DELETE", `${c.qamPath}/project/${await project(c)}/isolation_keyword/${requireId(a)}`);
+  },
+  "get-knowledge-isolation-keywords": async (c, a) => c.rawCall("GET", `${c.qamPath}/project/${await project(c)}/knowledge/isolation_keywords`, void 0, { knowledgeType: option(a, "--type", true), knowledgeId: requireId(a) }),
+  "batch-update-isolation-keyword-bindings": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/knowledge/isolation_keywords/batch`, await jsonValue(a)),
+  "edit-knowledge-tags": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/editTags`, await jsonValue(a)),
+  "move-directory": async (c, a) => c.rawCall("GET", `${c.qamPath}/project/${await project(c)}/directory/move`, void 0, { currentId: requireId(a), parentId: option(a, "--parent-id", true) }),
+  "operate-knowledge": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/updateKnowledge`, await jsonValue(a)),
+  "batch-update-knowledge": async (c, a) => c.rawCall("PUT", `${c.qamPath}/project/${await project(c)}/kus`, await jsonValue(a)),
+  "update-document-content": async (c, a) => c.rawCall("PUT", `${c.qamPath}/project/${await project(c)}/document`, { id: requireId(a), ...await data(a) }),
+  "create-product-knowledge": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/ku_product`, await jsonValue(a)),
+  "update-product-knowledge": async (c, a) => c.rawCall("PUT", `${c.qamPath}/project/${await project(c)}/ku_product`, { kuProductId: Number(requireId(a)), ...await data(a) }),
+  "batch-update-products": async (c, a) => c.rawCall("PUT", `${c.qamPath}/project/${await project(c)}/ku_products`, { list: await jsonValue(a) }),
+  "upload-web": async (c, a) => c.rawCall("POST", `${c.qamPath}/project/${await project(c)}/documents`, { documents: optionList(a, "--url").map((filePath) => ({ filePath, docType: "TC", fileType: "website" })), taskType: "WEB", published: true, isVisible: true, metadata: { tags: [] }, directoryId: option(a, "--directory-id") ?? "" }),
+  "list-label-groups": async (c, a) => c.rawCall("GET", `/api_v2/gpt/label/project/${await project(c)}/getTreeInfo`, void 0, option(a, "--name") ? { treeName: option(a, "--name") } : void 0),
+  "create-label-group": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/updateTreeInfo`, { ...await data(a), treeName: option(a, "--name", true), operateType: "CREATE" }),
+  "update-label-group": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/updateTreeInfo`, { ...await data(a), id: Number(requireId(a)), operateType: "UPDATE" }),
+  "delete-label-group": async (c, a) => {
+    requireFlag(a, "--confirm-delete", "delete-label-group");
+    return c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/updateTreeInfo`, { id: Number(requireId(a)), operateType: "DELETE" });
+  },
+  "get-label-tree": async (c, a) => c.rawCall("GET", `/api_v2/gpt/label/project/${await project(c)}/getTagTree`, void 0, { treeId: requireId(a), ...option(a, "--keyword") ? { name: option(a, "--keyword") } : {} }),
+  "get-label-detail-tree": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/getDetailTree`, { treeId: Number(requireId(a)), ...await data(a) }),
+  "create-label-node": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/updateNode`, { treeId: Number(option(a, "--tree-id", true)), operateType: "CREATE", nodes: [await data(a)] }),
+  "update-label-node": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/updateNode`, { treeId: Number(option(a, "--tree-id", true)), operateType: "UPDATE", nodes: [{ id: Number(requireId(a)), ...await data(a) }] }),
+  "delete-label-node": async (c, a) => {
+    requireFlag(a, "--confirm-delete", "delete-label-node");
+    return c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/updateNode`, { treeId: Number(option(a, "--tree-id", true)), operateType: "DELETE", nodes: [{ id: Number(requireId(a)) }] });
+  },
+  "download-label-template": async (c, a) => c.rawCall("GET", `/api_v2/gpt/label/project/${await project(c)}/downloadLabelTemplate`, void 0, { type: option(a, "--template-type") ?? "VOC_LABEL" }),
+  "download-labels": async (c, a) => c.rawCall("GET", `/api_v2/gpt/label/project/${await project(c)}/downloadLabel`, void 0, { treeId: option(a, "--tree-id", true) }),
+  "upload-labels": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/uploadLabel`, { treeId: Number(option(a, "--tree-id", true)), file: option(a, "--file", true), ...option(a, "--init") ? { uploadWay: "INIT" } : {} }),
+  "export-transcripts": async (c, a) => c.rawCall("POST", `/api_v2/gpt/project/${await project(c)}/transcripts/export/async`, { pageSize: pageSize(a), pageIndex: page(a), timeOffset: Number(option(a, "--time-offset") ?? 8), ...await data(a) }),
+  "get-export-tasks": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/getLabelTask`, { page: page(a), pageSize: pageSize(a) }),
+  "upload-batch-test-file": async (c, a) => c.rawCall("GET", `/api_v2/gpt/project/${await project(c)}/sts_credentials`),
+  "submit-batch-test": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/uploadMessage`, { file: option(a, "--file", true), type: option(a, "--type", true), ...option(a, "--bot-id") ? { botId: Number(option(a, "--bot-id")) } : {}, ...await data(a) }),
+  "get-batch-test-tasks": async (c, a) => c.rawCall("POST", `/api_v2/gpt/label/project/${await project(c)}/getLabelTask`, { page: page(a), pageSize: pageSize(a), ...option(a, "--type") ? { taskType: option(a, "--type") } : {} }),
+  "list-voice-agents": (c) => c.listAgents("voice"),
+  "list-voice-transcripts": async (c, a) => c.rawCall("POST", "/api_v2/as_bot/voice-report/transcript-page", { pageNum: page(a), pageSize: pageSize(a), beginTimestamp: Number(option(a, "--begin-ts") ?? 0), endTimestamp: Number(option(a, "--end-ts") ?? 0) }),
+  "get-voice-transcript": async (c, a) => c.rawCall("GET", `/api_v2/gpt/voice/transcript/projectId/${await project(c)}/history/${requireId(a)}`)
+};
+var reportPaths = {
+  "report-transcript": "/api_v2/as_bot/statement/transcript",
+  "report-message": "/api_v2/as_bot/statement/message",
+  "report-agent": "/api_v2/as_bot/statement/agent",
+  "report-intent": "/api_v2/as_bot/statement/transcript/intent",
+  "report-satisfaction": "/api_v2/as_bot/statement/satisfaction/feedback",
+  "report-satisfaction-list": "/api_v2/as_bot/statement/satisfaction/message",
+  "report-knowledge": "/api_v2/as_bot/statement/knowledge",
+  "report-escalation": "/api_v2/as_bot/statement/transcript/reason2",
+  "report-livechat": "/api_v2/as_bot/livechat/report/summary",
+  "report-livechat-table": "/api_v2/as_bot/livechat/report/table",
+  "report-inspection": "/api_v2/intelli/inspection/ticket/count",
+  "report-self-learning": "/api_v2/as_bot/statement/self-learning"
+};
+for (const [name, path] of Object.entries(reportPaths)) handlers2[name] = async (c, a) => c.rawCall("POST", path, await reportBody(a));
+var REMAINING_COMMANDS = new Set(Object.keys(handlers2));
+async function runRemainingCommand(client, command, args) {
+  const handler = handlers2[command];
+  if (!handler) throw new Error(`TypeScript command not migrated yet: ${command}`);
+  return handler(client, args);
+}
+
+// src/solvea/commands.ts
+function requireFlag2(args, name, command) {
+  if (!flag(args, name)) throw new Error(`${command} requires ${name} after explicit user acknowledgement`);
+}
+function enabled(args, command) {
+  const enable = flag(args, "--enable");
+  const disable = flag(args, "--disable");
+  if (enable === disable) throw new Error(`${command} requires exactly one of --enable or --disable`);
+  return enable;
+}
+async function data2(args) {
+  const file = option(args, "--data-file");
+  const raw = file ? await readFile2(file, "utf8") : option(args, "--data");
+  if (!raw) throw new Error("--data or --data-file is required");
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("request data must be a JSON object");
+  return parsed;
+}
+async function transcriptFilters(args) {
+  const filters = {
+    pageIndex: Number(option(args, "--page") ?? 1),
+    pageSize: Number(option(args, "--page-size") ?? 50),
+    debug: flag(args, "--debug"),
+    ...await optionalData(args)
+  };
+  const optional = [
+    ["beginTimestamp", "--begin-ts", Number],
+    ["endTimestamp", "--end-ts", Number],
+    ["touchPoint", "--touch-point", String],
+    ["botId", "--bot-id", Number],
+    ["agentId", "--agent-id", Number],
+    ["intentId", "--intent-id", Number],
+    ["keyword", "--keyword", String],
+    ["handoff", "--handoff", (value) => value === "true"]
+  ];
+  for (const [field, name, convert] of optional) {
+    const value = option(args, name);
+    if (value !== void 0) filters[field] = convert(value);
+  }
+  return filters;
+}
+async function runSolveaCommand(session, command, args) {
+  const client = new SolveaClient(session);
+  if (EXTENDED_COMMANDS.has(command)) return runExtendedCommand(client, command, args);
+  if (REMAINING_COMMANDS.has(command)) return runRemainingCommand(client, command, args);
+  if (command.startsWith("chat-report-")) return runRemainingCommand(client, "report-message", args);
+  const id = () => option(args, "--id", true);
+  switch (command) {
+    case "get-project":
+      return client.projectInfo();
+    case "list-agents":
+      return client.listAgents(option(args, "--category") ?? "text");
+    case "get-agent":
+      return client.getAgent(id());
+    case "get-chatflow-graph":
+      return client.getChatflowGraph(option(args, "--agent-id", true));
+    case "create-agent":
+      return client.createAgent(await data2(args));
+    case "update-agent":
+      return client.updateAgent(await data2(args));
+    case "list-plugins":
+      return client.listPlugins();
+    case "get-plugin":
+      return client.getPlugin(id());
+    case "create-plugin":
+      return client.createPlugin(await data2(args));
+    case "update-plugin":
+      return client.updatePlugin(await data2(args));
+    case "delete-plugin":
+      requireFlag2(args, "--confirm-delete", command);
+      return client.deletePlugin(id());
+    case "chat":
+      return client.chat({ message: option(args, "--message") ?? option(args, "-m", true), botId: option(args, "--bot-id"), chatId: option(args, "--chat-id"), touchPoint: option(args, "--touch-point") ?? "LIVE_CHAT", ...await optionalData(args) });
+    case "chat-async":
+      return client.chatAsync({ message: option(args, "--message") ?? option(args, "-m", true), botId: option(args, "--bot-id"), chatId: option(args, "--chat-id"), touchPoint: option(args, "--touch-point") ?? "LIVE_CHAT", ...await optionalData(args) });
+    case "get-async-result":
+      return client.asyncResult(option(args, "--receipt", true), option(args, "--bot-id"));
+    case "list-intents":
+      return client.listIntents(option(args, "--category") ?? "E_COMMERCE");
+    case "get-intent":
+      return client.getIntent(id());
+    case "create-intent":
+      return client.createIntent(await data2(args));
+    case "update-intent":
+      return client.updateIntent(id(), await data2(args));
+    case "toggle-intent":
+      return client.toggleIntent(id(), !flag(args, "--disable"));
+    case "list-entities":
+      return client.listEntities();
+    case "list-strategies":
+      return client.listStrategies(Number(option(args, "--page-size") ?? 100));
+    case "create-strategy":
+      return client.createStrategy(await data2(args));
+    case "update-strategy":
+      return client.updateStrategy(id(), await data2(args));
+    case "toggle-strategy":
+      return client.toggleStrategy(id(), !flag(args, "--disable"));
+    case "get-quality-status":
+      return client.qualityStatus();
+    case "set-quality-status":
+      return client.setQualityStatus(enabled(args, command));
+    case "list-quality-rules":
+      return client.qualityRules(Number(option(args, "--begin-ts") ?? 0) || void 0, Number(option(args, "--end-ts") ?? 0) || void 0);
+    case "get-quality-rule":
+      return client.qualityRule(option(args, "--inspection-key", true));
+    case "update-quality-rule":
+      return client.updateQualityRule(await data2(args));
+    case "get-custom-quality-rule":
+      return client.customQualityRule(option(args, "--inspection-key", true));
+    case "create-custom-quality-rule":
+      return client.createCustomQualityRule(await data2(args));
+    case "update-custom-quality-rule":
+      return client.updateCustomQualityRule(await data2(args));
+    case "delete-custom-quality-rule":
+      return client.deleteCustomQualityRule(option(args, "--inspection-key", true));
+    case "list-knowledge":
+      return client.listKnowledge(await optionalData(args));
+    case "get-knowledge":
+      return client.getKnowledge(id());
+    case "update-knowledge":
+      return client.updateKnowledge(id(), await data2(args));
+    case "upload-qa":
+      return client.uploadQa((await data2(args)).items);
+    case "list-directories":
+      return client.listDirectories();
+    case "create-folder":
+      return client.createFolder(option(args, "--name", true), Number(option(args, "--parent-id") ?? 0));
+    case "update-directory":
+      return client.updateDirectory(id(), option(args, "--name") ? { name: option(args, "--name") } : await data2(args));
+    case "delete-directory":
+      requireFlag2(args, "--confirm-delete", command);
+      return client.deleteDirectory(id());
+    case "list-knowledge-tags":
+      return client.knowledgeTags(option(args, "--keyword") ?? "");
+    case "get-transcript":
+      return client.transcript(option(args, "--chat-id", true));
+    case "list-transcripts":
+      return client.listTranscripts(await transcriptFilters(args));
+    case "get-chat-context":
+      return client.chatContext(option(args, "--bot-id", true), await data2(args));
+    default:
+      throw new Error(`TypeScript command not migrated yet: ${command}`);
+  }
+}
+async function optionalData(args) {
+  if (!option(args, "--data") && !option(args, "--data-file")) return {};
+  return data2(args);
 }
+function isNativeSolveaCommand(command) {
+  return command.startsWith("chat-report-") || EXTENDED_COMMANDS.has(command) || REMAINING_COMMANDS.has(command) || (/* @__PURE__ */ new Set([
+    "get-project",
+    "list-agents",
+    "get-agent",
+    "get-chatflow-graph",
+    "create-agent",
+    "update-agent",
+    "list-plugins",
+    "get-plugin",
+    "create-plugin",
+    "update-plugin",
+    "delete-plugin",
+    "chat",
+    "chat-async",
+    "get-async-result",
+    "list-intents",
+    "get-intent",
+    "create-intent",
+    "update-intent",
+    "toggle-intent",
+    "list-entities",
+    "list-strategies",
+    "create-strategy",
+    "update-strategy",
+    "toggle-strategy",
+    "get-transcript",
+    "list-transcripts",
+    "get-chat-context",
+    "get-quality-status",
+    "set-quality-status",
+    "list-quality-rules",
+    "get-quality-rule",
+    "update-quality-rule",
+    "get-custom-quality-rule",
+    "create-custom-quality-rule",
+    "update-custom-quality-rule",
+    "delete-custom-quality-rule",
+    "list-knowledge",
+    "get-knowledge",
+    "update-knowledge",
+    "upload-qa",
+    "list-directories",
+    "create-folder",
+    "update-directory",
+    "delete-directory",
+    "list-knowledge-tags"
+  ])).has(command);
+}
+
+// src/business.ts
+var packageRoot = () => resolve(dirname(fileURLToPath(import.meta.url)), "..");
 async function runApi(session, command, args) {
-  const code = await runPython("skills/__lib__/solvea-api/solvea_api.py", [command, ...args], session);
-  if (code) throw new Error(`business command ${command} failed with exit code ${code}`);
+  if (isNativeSolveaCommand(command)) {
+    console.log(JSON.stringify(await runSolveaCommand(session, command, args), null, 2));
+    return;
+  }
+  throw new Error(`unknown TypeScript API command: ${command}`);
+}
+
+// src/commands/resources.ts
+var action = (command, summary, usage2 = "") => ({ command, summary, usage: usage2 });
+var resources = {
+  agent: {
+    list: action("list-agents", "List agents", "[--category text|voice]"),
+    get: action("get-agent", "Get one agent", "--id <agent-id>"),
+    create: action("create-agent", "Create an agent", "--data <json> | --data-file <path>"),
+    update: action("update-agent", "Update an agent", "--data <json> | --data-file <path>"),
+    "get-chatflow": action("get-chatflow-graph", "Get an agent chatflow", "--agent-id <agent-id>")
+  },
+  intent: {
+    list: action("list-intents", "List intents", "[--category <category>]"),
+    get: action("get-intent", "Get one intent", "--id <intent-id>"),
+    create: action("create-intent", "Create an intent", "--data <json> | --data-file <path>"),
+    update: action("update-intent", "Update an intent", "--id <intent-id> (--data <json> | --data-file <path>)"),
+    toggle: action("toggle-intent", "Enable or disable an intent", "--id <intent-id> [--enable | --disable] (default: --enable)")
+  },
+  strategy: {
+    list: action("list-strategies", "List strategies", "[--page-size <number>]"),
+    entities: action("list-entities", "List strategy entities"),
+    create: action("create-strategy", "Create a strategy", "--data <json> | --data-file <path>"),
+    update: action("update-strategy", "Update a strategy", "--id <strategy-id> (--data <json> | --data-file <path>)"),
+    toggle: action("toggle-strategy", "Enable or disable a strategy", "--id <strategy-id> [--enable | --disable] (default: --enable)")
+  },
+  tool: {
+    list: action("list-plugins", "List tools"),
+    get: action("get-plugin", "Get one tool", "--id <tool-id>"),
+    create: action("create-plugin", "Create a tool", "--data <json> | --data-file <path>"),
+    update: action("update-plugin", "Update a tool", "--data <json> | --data-file <path>"),
+    delete: action("delete-plugin", "Delete a tool", "--id <tool-id> --confirm-delete"),
+    run: action("run-plugin", "Run an HTTP tool without saving it", "--data <json> | --data-file <path>")
+  },
+  field: {
+    canvas: action("list-ai-fields", "List CHAT_FLOW canvas fields"),
+    "agent-range": action("list-agent-ai-fields", "List fields accepted by Agent validation"),
+    guide: action("get-ai-field-guide", "Get AI Field initialization status"),
+    initialize: action("initialize-ai-fields", "Initialize system AI Fields"),
+    list: action("list-managed-ai-fields", "List managed AI Fields", "[--page <number>] [--page-size <number>] [--keyword <name>]"),
+    get: action("get-managed-ai-field", "Get one managed AI Field", "--id <field-id>"),
+    create: action("create-managed-ai-field", "Create a managed AI Field", "--data <json> | --data-file <path>"),
+    update: action("update-managed-ai-field", "Update a managed AI Field", "--data <json> | --data-file <path>"),
+    delete: action("delete-managed-ai-field", "Delete a managed AI Field", "--id <field-id> --confirm-delete"),
+    toggle: action("toggle-managed-ai-field", "Toggle a managed AI Field", "--id <field-id>")
+  },
+  template: {
+    list: action("list-templates", "List reply templates", "[--page <number>] [--page-size <number>] [--keyword <text>] [--scene <scene>] [--status <status>]"),
+    create: action("create-template", "Create a reply template", "(--name <name> --content <content>) | --data-file <path>"),
+    update: action("update-template", "Update a reply template", "--id <template-id> [--name <name>] [--content <content>] [--status <status>] [--data-file <path>]"),
+    delete: action("delete-templates", "Delete reply templates", "--ids <id> [id...] --confirm-delete")
+  },
+  knowledge: {
+    list: action("list-knowledge", "List knowledge", "[--data <json> | --data-file <path>]"),
+    get: action("get-knowledge", "Get one knowledge item", "--id <knowledge-id>"),
+    update: action("update-knowledge", "Update a knowledge item", "--id <knowledge-id> (--data <json> | --data-file <path>)"),
+    "upload-qa": action("upload-qa", "Upload QA items", "--data <json> | --data-file <path>"),
+    tags: action("list-knowledge-tags", "List knowledge tags", "[--keyword <keyword>]")
+  },
+  directory: {
+    list: action("list-directories", "List knowledge directories"),
+    create: action("create-folder", "Create a knowledge directory", "--name <name> [--parent-id <directory-id>]"),
+    update: action("update-directory", "Update a knowledge directory", "--id <directory-id> (--name <name> | --data <json> | --data-file <path>)"),
+    delete: action("delete-directory", "Delete a knowledge directory", "--id <directory-id> --confirm-delete")
+  },
+  quality: {
+    status: action("get-quality-status", "Get quality inspection status"),
+    toggle: action("set-quality-status", "Enable or disable quality inspection", "--enable | --disable"),
+    rules: action("list-quality-rules", "List quality rules", "[--begin-ts <milliseconds>] [--end-ts <milliseconds>]"),
+    "get-rule": action("get-quality-rule", "Get one quality rule", "--inspection-key <key>"),
+    "update-rule": action("update-quality-rule", "Update a quality rule", "--data <json> | --data-file <path>"),
+    "get-custom-rule": action("get-custom-quality-rule", "Get one custom quality rule", "--inspection-key <key>"),
+    "create-custom-rule": action("create-custom-quality-rule", "Create a custom quality rule", "--data <json> | --data-file <path>"),
+    "update-custom-rule": action("update-custom-quality-rule", "Update a custom quality rule", "--data <json> | --data-file <path>"),
+    "delete-custom-rule": action("delete-custom-quality-rule", "Delete a custom quality rule", "--inspection-key <key>"),
+    alerts: action("list-quality-alert-rules", "List quality alert rules"),
+    "get-alert": action("get-quality-alert-rule", "Get one quality alert rule", "--id <alert-id>"),
+    "create-alert": action("create-quality-alert-rule", "Create a quality alert rule", "--data <json> | --data-file <path>"),
+    "update-alert": action("update-quality-alert-rule", "Update a quality alert rule", "--data <json> | --data-file <path>"),
+    "delete-alert": action("delete-quality-alert-rule", "Delete a quality alert rule", "--id <alert-id> --confirm-delete"),
+    "alert-messages": action("list-quality-alert-messages", "List quality alert messages", "--data <json> | --data-file <path>"),
+    "get-alert-message": action("get-quality-alert-message", "Get one quality alert message", "--id <message-id>")
+  },
+  transcript: {
+    list: action("list-transcripts", "List transcripts", "[--page <number>] [--page-size <number>] [--begin-ts <milliseconds>] [--end-ts <milliseconds>] [--data <json> | --data-file <path>]"),
+    get: action("get-transcript", "Get one transcript", "--chat-id <chat-id>"),
+    context: action("get-chat-context", "Get chat context", "--bot-id <bot-id> (--data <json> | --data-file <path>)")
+  },
+  chat: {
+    send: action("chat", "Send a synchronous chat message", "--message <text> [--bot-id <bot-id>] [--chat-id <chat-id>]"),
+    async: action("chat-async", "Send an asynchronous chat message", "--message <text> [--bot-id <bot-id>] [--chat-id <chat-id>]"),
+    result: action("get-async-result", "Get an asynchronous chat result", "--receipt <receipt> [--bot-id <bot-id>]")
+  }
+};
+function isResourceCommand(value) {
+  return value in resources;
+}
+function resourceHelp(resource, actionName) {
+  if (!resource) return `Business resources:
+${Object.keys(resources).map((name) => `  ${name}`).join("\n")}`;
+  if (!isResourceCommand(resource)) throw new Error(`unknown resource: ${resource}`);
+  const actions = resources[resource];
+  if (actionName) {
+    const definition = actions[actionName];
+    if (!definition) throw new Error(`unknown ${resource} action: ${actionName}
+${resourceHelp(resource)}`);
+    return [
+      definition.summary,
+      `Usage: cxclawctl ${resource} ${actionName}${definition.usage ? ` ${definition.usage}` : ""}`
+    ].join("\n\n");
+  }
+  return [
+    `${resource} actions:`,
+    ...Object.entries(actions).map(([name, definition]) => `  ${name.padEnd(20)} ${definition.summary}`),
+    `
+Run cxclawctl ${resource} <action> --help for action options.`
+  ].join("\n");
+}
+function resolveResourceCommand(resource, action2) {
+  if (!action2 || action2 === "help") throw new Error(resourceHelp(resource));
+  const definition = resources[resource][action2];
+  if (!definition) throw new Error(`unknown ${resource} action: ${action2}
+${resourceHelp(resource)}`);
+  return definition.command;
+}
+async function runResourceCommand(session, resource, action2, args) {
+  await runApi(session, resolveResourceCommand(resource, action2), args);
+}
+
+// src/doctor.ts
+import { access } from "fs/promises";
+import { join } from "path";
+async function diagnose() {
+  const root2 = packageRoot();
+  const requiredFiles = [
+    "package.json"
+  ];
+  await Promise.all(requiredFiles.map((path) => access(join(root2, path))));
+  const expectedPluginVersion = process.env.CXCLAW_PLUGIN_VERSION || null;
+  if (expectedPluginVersion && expectedPluginVersion !== VERSION) {
+    throw new Error(
+      `plugin version ${expectedPluginVersion} does not match CLI ${VERSION}`
+    );
+  }
+  return {
+    ok: true,
+    cliVersion: VERSION,
+    pluginVersion: expectedPluginVersion,
+    versionsMatch: expectedPluginVersion ? expectedPluginVersion === VERSION : null,
+    nodeVersion: process.versions.node,
+    runtimeFiles: requiredFiles
+  };
 }
 
 // src/sls.ts
 import LogClient from "@alicloud/log";
-async function query(session, options2) {
+async function query(session, options3) {
   const temporary = await post(session, "/sls/session", {}, true);
-  if (options2.from <= 0 || options2.to < options2.from || options2.to - options2.from > temporary.limits.maxTimeRangeSeconds) throw new Error("SLS time range exceeds the server limit");
+  if (options3.from <= 0 || options3.to < options3.from || options3.to - options3.from > temporary.limits.maxTimeRangeSeconds) throw new Error("SLS time range exceeds the server limit");
   const client = new LogClient({ endpoint: temporary.endpoint, use_https: true, accessKeyId: temporary.credentials.accessKeyId, accessKeySecret: temporary.credentials.accessKeySecret, securityToken: temporary.credentials.securityToken });
-  const response = await client.getLogs(temporary.project, temporary.logstore, new Date(options2.from * 1e3), new Date(options2.to * 1e3), { query: options2.query, line: Math.min(options2.line || 50, temporary.limits.maxResults), offset: options2.offset || 0, reverse: options2.reverse });
+  const response = await client.getLogs(temporary.project, temporary.logstore, new Date(options3.from * 1e3), new Date(options3.to * 1e3), { query: options3.query, line: Math.min(options3.line || 50, temporary.limits.maxResults), offset: options3.offset || 0, reverse: options3.reverse });
   const logs = (response.body ?? response).map?.((row) => Object.fromEntries(Object.entries(row).map(([k, v]) => [k, String(v).slice(0, temporary.limits.maxMessageChars || void 0)]))) ?? response.body ?? response;
   return { logs };
 }
@@ -229,132 +1113,1323 @@ function publicTenant(t) {
 }
 
 // src/update.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn } from "child_process";
 import { mkdir, writeFile } from "fs/promises";
 import { homedir, platform } from "os";
-import { join as join2 } from "path";
-import { compareVersions } from "compare-versions";
-var exec = (command, args) => new Promise((done, reject) => {
-  const p = spawn2(command, args, { stdio: "inherit" });
-  p.on("error", reject);
-  p.on("exit", (c) => c === 0 ? done() : reject(new Error(`${command} exited with ${c}`)));
+import { isAbsolute, join as join2 } from "path";
+var exec = (command, args, options3 = {}) => new Promise((resolve5, reject) => {
+  const chunks = [];
+  const child = spawn(command, args, {
+    stdio: options3.capture ? ["ignore", "pipe", "inherit"] : "inherit"
+  });
+  if (options3.capture) child.stdout?.on("data", (chunk) => chunks.push(chunk));
+  child.on("error", reject);
+  child.on("exit", (code) => {
+    if (code === 0 || options3.allowFailure) {
+      resolve5(Buffer.concat(chunks).toString("utf8"));
+      return;
+    }
+    reject(new Error(`${command} exited with ${code}`));
+  });
 });
+var xml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+var systemdArg = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+var windowsArg = (value) => /[\s"]/.test(value) ? `"${value.replaceAll('"', '\\"')}"` : value;
+function schedulerInvocation(environment2 = process.env, nodeExecutable = process.execPath) {
+  const npmExecutable = environment2.npm_execpath;
+  if (!npmExecutable || !isAbsolute(npmExecutable)) {
+    throw new Error(
+      "cannot register updater: run this command through npm or npx so npm_execpath is available"
+    );
+  }
+  return {
+    command: nodeExecutable,
+    args: [
+      npmExecutable,
+      "exec",
+      "--yes",
+      "--package=@shulex/cxclawctl@latest",
+      "--",
+      "cxclawctl",
+      "update",
+      "--scheduled"
+    ]
+  };
+}
 async function update() {
-  const info = await fetch("https://registry.npmjs.org/@shulex%2Fcxclawctl/latest", { signal: AbortSignal.timeout(3e4) }).then((r) => {
-    if (!r.ok) throw new Error(`npm registry returned ${r.status}`);
-    return r.json();
-  });
-  if (compareVersions(info.version, VERSION) > 0) console.log(`\u53D1\u73B0\u65B0\u7248\u672C ${info.version}\uFF1Bnpx \u4E0B\u6B21\u8FD0\u884C\u4F1A\u81EA\u52A8\u4F7F\u7528\u6700\u65B0\u7248\u3002`);
   await exec("codex", ["plugin", "marketplace", "upgrade", "cxclaw"]);
-  return info.version;
+  await exec("codex", ["plugin", "add", "cxclaw@cxclaw"]);
+  const raw = await exec("codex", ["plugin", "list", "--json"], { capture: true });
+  const list = JSON.parse(raw);
+  const plugin = list.installed?.find((item) => item.pluginId === "cxclaw@cxclaw");
+  if (!plugin?.version || plugin.enabled === false) {
+    throw new Error("CXClaw plugin is not installed and enabled");
+  }
+  const response = await fetch(
+    `https://registry.npmjs.org/@shulex%2Fcxclawctl/${encodeURIComponent(plugin.version)}`,
+    { signal: AbortSignal.timeout(3e4) }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `npm package @shulex/cxclawctl@${plugin.version} is unavailable (${response.status})`
+    );
+  }
+  const metadata = await response.json();
+  if (metadata.version !== plugin.version) {
+    throw new Error(
+      `npm returned ${metadata.version ?? "no version"}, expected ${plugin.version}`
+    );
+  }
+  return {
+    pluginVersion: plugin.version,
+    cliPackageVersion: metadata.version,
+    restartRequired: true
+  };
 }
 async function installScheduler() {
-  const command = process.platform === "win32" ? "npx.cmd" : "npx";
-  const args = ["--yes", "@shulex/cxclawctl@latest", "update", "--scheduled"];
+  const invocation = schedulerInvocation();
   if (platform() === "darwin") {
     const dir = join2(homedir(), "Library/LaunchAgents");
+    const path = join2(dir, "com.solvea.cxclaw.update.plist");
+    const programArguments = [invocation.command, ...invocation.args].map((value) => `<string>${xml(value)}</string>`).join("");
     await mkdir(dir, { recursive: true });
-    await writeFile(join2(dir, "com.solvea.cxclaw.update.plist"), `<?xml version="1.0"?><plist version="1.0"><dict><key>Label</key><string>com.solvea.cxclaw.update</string><key>ProgramArguments</key><array><string>${command}</string>${args.map((x) => `<string>${x}</string>`).join("")}</array><key>StartInterval</key><integer>21600</integer><key>RunAtLoad</key><true/></dict></plist>`);
-    await exec("launchctl", ["load", join2(dir, "com.solvea.cxclaw.update.plist")]);
-  } else if (platform() === "linux") {
+    await writeFile(
+      path,
+      `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict><key>Label</key><string>com.solvea.cxclaw.update</string><key>ProgramArguments</key><array>${programArguments}</array><key>StartInterval</key><integer>21600</integer><key>RunAtLoad</key><true/></dict></plist>
+`
+    );
+    await exec("launchctl", ["unload", path], { allowFailure: true });
+    await exec("launchctl", ["load", path]);
+    return;
+  }
+  if (platform() === "linux") {
     const dir = join2(homedir(), ".config/systemd/user");
+    const command = [invocation.command, ...invocation.args].map(systemdArg).join(" ");
     await mkdir(dir, { recursive: true });
-    await writeFile(join2(dir, "cxclaw-update.service"), `[Service]
+    await writeFile(
+      join2(dir, "cxclaw-update.service"),
+      `[Service]
 Type=oneshot
-ExecStart=${command} ${args.join(" ")}
-`);
-    await writeFile(join2(dir, "cxclaw-update.timer"), "[Timer]\nOnBootSec=5m\nOnUnitActiveSec=6h\nRandomizedDelaySec=30m\nPersistent=true\n[Install]\nWantedBy=timers.target\n");
+ExecStart=${command}
+`
+    );
+    await writeFile(
+      join2(dir, "cxclaw-update.timer"),
+      "[Timer]\nOnBootSec=5m\nOnUnitActiveSec=6h\nPersistent=true\n[Install]\nWantedBy=timers.target\n"
+    );
     await exec("systemctl", ["--user", "daemon-reload"]);
     await exec("systemctl", ["--user", "enable", "--now", "cxclaw-update.timer"]);
-  } else await exec("schtasks", ["/Create", "/F", "/SC", "HOURLY", "/MO", "6", "/TN", "Solvea CXClaw Update", "/TR", `${command} ${args.join(" ")}`]);
+    return;
+  }
+  const task = [invocation.command, ...invocation.args].map(windowsArg).join(" ");
+  await exec("schtasks", [
+    "/Create",
+    "/F",
+    "/SC",
+    "HOURLY",
+    "/MO",
+    "6",
+    "/TN",
+    "Solvea CXClaw Update",
+    "/TR",
+    task
+  ]);
 }
 async function installMarketplace(channel) {
-  if (!["stable", "canary", "dev"].includes(channel)) throw new Error("invalid channel");
-  await exec("codex", ["plugin", "marketplace", "add", "SolveaCX/cx_claw_codex", "--ref", `marketplace/${channel}`]).catch(() => exec("codex", ["plugin", "marketplace", "upgrade", "cxclaw"]));
-  await exec("codex", ["plugin", "add", "cxclaw@cxclaw"]).catch(() => void 0);
+  if (!["stable", "canary", "dev"].includes(channel)) {
+    throw new Error("invalid channel");
+  }
+  await exec("codex", [
+    "plugin",
+    "marketplace",
+    "add",
+    "SolveaCX/cx_claw_codex",
+    "--ref",
+    `marketplace/${channel}`
+  ]).catch(() => exec("codex", ["plugin", "marketplace", "upgrade", "cxclaw"]));
+  await exec("codex", ["plugin", "add", "cxclaw@cxclaw"]);
 }
 
-// src/cli.ts
-var print = (value) => console.log(JSON.stringify(value, null, 2));
-async function main(args = process.argv.slice(2)) {
-  const [command, sub, ...rest] = args;
-  if (!command) {
-    console.log("cxclawctl auth|tenant|api|sls|script|doctor|update|setup|version");
-    return;
+// src/workflows/runtime.ts
+import { execFile } from "child_process";
+import { promises as fs } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
+import { promisify } from "util";
+var exec2 = promisify(execFile);
+var workspace = () => resolve2(process.env.WORKSPACE_DIR ?? join3(process.cwd(), "workspace"));
+var root = () => join3(workspace(), "runtime-inspector");
+var dirs = () => ({ output: join3(root(), "outputs"), state: join3(root(), "state"), tmp: join3(root(), "tmp") });
+var timestamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/[-:TZ.]/g, "").slice(0, 15);
+var readJson = async (path, fallback) => {
+  try {
+    return JSON.parse(await fs.readFile(path, "utf8"));
+  } catch {
+    return fallback;
   }
-  if (command === "version") return print({ pluginVersion: VERSION, cliVersion: VERSION, toolSchemaVersion: TOOL_SCHEMA_VERSION, serverApiVersion: SERVER_API_VERSION });
-  if (command === "setup") {
-    const server = option(args, "--server", true);
-    const channel = option(args, "--channel") ?? "stable";
-    await installMarketplace(channel);
-    await login(server, channel);
-    await installScheduler();
-    return;
+};
+var writeJson = async (path, value) => {
+  await fs.mkdir(resolve2(path, ".."), { recursive: true });
+  await fs.writeFile(path, JSON.stringify(value, null, 2));
+};
+function check(label, ok, detail = "") {
+  return { label, ok, ...detail ? { detail } : {} };
+}
+async function prepare(args) {
+  const { tmp, state: state2 } = dirs();
+  const source = option(args, "--source");
+  const batchSize = Number(option(args, "--batch-size") ?? 10);
+  if (!Number.isSafeInteger(batchSize) || batchSize <= 0) throw new Error("--batch-size must be a positive integer");
+  let records;
+  if (source) {
+    const content = await fs.readFile(source, "utf8");
+    if (source.toLowerCase().endsWith(".json")) {
+      const parsed = JSON.parse(content);
+      records = Array.isArray(parsed) ? parsed.map((item) => typeof item === "object" && item ? item : { text: String(item) }) : [parsed];
+    } else if (source.toLowerCase().endsWith(".csv")) {
+      const [header, ...lines] = content.split(/\r?\n/).filter(Boolean).map((line) => line.split(","));
+      records = lines.map((values) => Object.fromEntries((header ?? []).map((key, i) => [key, values[i] ?? ""])));
+    } else records = content.split(/\r?\n/).filter(Boolean).map((text) => ({ text }));
+  } else records = Array.from({ length: 30 }, (_, i) => ({ id: i + 1, text: `\u6D4B\u8BD5\u8BB0\u5F55 #${i + 1}`, value: (i + 1) * 10 }));
+  await fs.rm(tmp, { recursive: true, force: true });
+  await fs.mkdir(tmp, { recursive: true });
+  const batches = [];
+  for (let i = 0; i < records.length; i += batchSize) batches.push(records.slice(i, i + batchSize));
+  await Promise.all(batches.map((batch, i) => writeJson(join3(tmp, `batch_${String(i).padStart(3, "0")}.json`), batch)));
+  await writeJson(join3(state2, "inspect.json"), { status: "batched", total_records: records.length, total_batches: batches.length, batch_size: batchSize, source: source ?? "auto-generated", written_at: (/* @__PURE__ */ new Date()).toISOString() });
+  return { status: "batched", totalRecords: records.length, totalBatches: batches.length, tmp };
+}
+async function processBatches() {
+  const { tmp, output, state: state2 } = dirs();
+  const current = await readJson(join3(state2, "inspect.json"), {});
+  if (current.status !== "batched") throw new Error(`runtime state must be batched, got ${String(current.status ?? "missing")}`);
+  const names = (await fs.readdir(tmp)).filter((name) => /^batch_\d+\.json$/.test(name)).sort();
+  if (!names.length) throw new Error(`no batch files found in ${tmp}`);
+  const records = [];
+  for (const name of names) for (const row of await readJson(join3(tmp, name), [])) records.push({ ...row, _processed: true, _summary: `processed: ${JSON.stringify(row).slice(0, 60)}`, _at: (/* @__PURE__ */ new Date()).toISOString() });
+  const path = join3(output, `results_${timestamp()}.json`);
+  await writeJson(path, { total: records.length, processed_at: (/* @__PURE__ */ new Date()).toISOString(), source: current.source, records });
+  await writeJson(join3(state2, "inspect.json"), { status: "done", total_processed: records.length, results_path: path, done_at: (/* @__PURE__ */ new Date()).toISOString() });
+  return { status: "done", total: records.length, resultsPath: path };
+}
+async function state() {
+  const { state: stateDir2, output, tmp } = dirs();
+  return { state: await readJson(join3(stateDir2, "inspect.json"), null), outputFiles: await fs.readdir(output).catch(() => []), tmpFiles: await fs.readdir(tmp).catch(() => []) };
+}
+async function verify() {
+  const snapshot = await state();
+  const checks = [check("state \u6587\u4EF6\u5DF2\u8FD8\u539F", Boolean(snapshot.state)), check("status == done", snapshot.state?.status === "done", `actual=${String(snapshot.state?.status)}`), check("outputs \u76EE\u5F55\u53EF\u8BFB", Array.isArray(snapshot.outputFiles)), check("\u81F3\u5C11\u4E00\u4E2A results \u6587\u4EF6", snapshot.outputFiles.some((name) => name.startsWith("results_")))];
+  return { ok: checks.every((item) => item.ok), checks };
+}
+async function sandbox(args) {
+  const scenario = option(args, "--scenario") ?? "all";
+  const d = dirs();
+  const scenarios = scenario === "all" ? ["env", "fs", "execute", "paths", "deps"] : [scenario];
+  const checks = [];
+  for (const item of scenarios) {
+    if (item === "env") checks.push(check("WORKSPACE_DIR", Boolean(process.env.WORKSPACE_DIR ?? workspace())), check("\u654F\u611F\u53D8\u91CF\u672A\u76F4\u63A5\u8F93\u51FA", true));
+    else if (["fs", "paths"].includes(item)) {
+      await Promise.all(Object.values(d).map((path) => fs.mkdir(path, { recursive: true })));
+      checks.push(...Object.entries(d).map(([name, path]) => check(`${name} \u76EE\u5F55\u53EF\u5199`, true, path)));
+    } else if (item === "execute") {
+      const result = await exec2("sh", ["-c", "printf runtime-ok"]);
+      checks.push(check("shell \u6267\u884C\u94FE\u8DEF", result.stdout === "runtime-ok"));
+    } else if (item === "deps") checks.push(check("Node runtime", Number(process.versions.node.split(".")[0]) >= 22, process.versions.node));
+    else throw new Error(`unknown runtime sandbox scenario: ${item}`);
+  }
+  return { ok: checks.every((item) => item.ok), scenario, checks };
+}
+async function model(args) {
+  if (option(args, "--scenario", true) !== "truncation") throw new Error("only --scenario truncation is supported");
+  const target = join3(dirs().tmp, "truncation_test.md");
+  return { scenario: "truncation", target, instruction: "Use the Codex write_file tool to write 60+ long technical paragraphs, then inspect SLG model_response stop_reason and output_tokens." };
+}
+async function runRuntime(action2, args) {
+  if (action2 === "prepare") return prepare(args);
+  if (action2 === "process") return processBatches();
+  if (action2 === "state") return state();
+  if (action2 === "verify") return verify();
+  if (action2 === "sandbox") return sandbox(args);
+  if (action2 === "model") return model(args);
+  if (action2 === "write-test") {
+    const { output, state: stateDir2 } = dirs();
+    const runId = timestamp();
+    await writeJson(join3(output, `${runId}_test.json`), { run_id: runId, written_at: (/* @__PURE__ */ new Date()).toISOString() });
+    const current = await readJson(join3(stateDir2, "inspect.json"), {});
+    await writeJson(join3(stateDir2, "inspect.json"), { ...current, last_run_id: runId, write_count: Number(current.write_count ?? 0) + 1 });
+    return { ok: true, runId };
+  }
+  throw new Error("runtime action must be prepare, process, state, verify, sandbox, model, or write-test");
+}
+
+// src/workflows/solvea-kit.ts
+import ExcelJS from "exceljs";
+import { promises as fs2 } from "fs";
+import { dirname as dirname2, join as join4, resolve as resolve3 } from "path";
+var workspace2 = () => resolve3(process.env.WORKSPACE_DIR ?? join4(process.cwd(), "workspace"));
+var outputDir = (owner) => join4(workspace2(), "outputs", owner);
+var stateDir = (owner) => join4(workspace2(), "state", owner);
+var now = () => (/* @__PURE__ */ new Date()).toISOString().replace(/[-:TZ.]/g, "").slice(0, 15);
+var readJson2 = async (path) => JSON.parse(await fs2.readFile(path, "utf8"));
+var writeJson2 = async (path, value) => {
+  await fs2.mkdir(dirname2(path), { recursive: true });
+  await fs2.writeFile(path, JSON.stringify(value, null, 2));
+};
+var INIT_NOTICE = `The information of this row cannot be deleted! Tips:
+1. first_level is the first level that is not empty.
+2. second_level is the second level.
+3. third_level is the third level.
+4. fourth_level is the fourth level.
+5. "Name", "describe" and "example" are for the use of the large model. Do not repeat them.`;
+var UPDATE_NOTICE = `The information of this row cannot be deleted! Tips:
+1. The "id" is automatically generated by the program. When it is empty, it indicates adding a new tag.
+2. "Name", "describe" and "example" are for the use of the large model. Do not repeat them.
+3. Fill in the "parent_ID" with the ID of the parent node tag.`;
+function examples(label) {
+  const values = label.examples ?? label.exampleList ?? [];
+  if (!Array.isArray(values)) throw new Error("examples must be an array");
+  return [...values.slice(0, 5).map(String), ...Array(Math.max(0, 5 - values.length)).fill("")];
+}
+function labelsFrom(value) {
+  const labels = value && typeof value === "object" && !Array.isArray(value) ? value.labels : value;
+  if (!Array.isArray(labels) || !labels.length || labels.some((item) => !item || typeof item !== "object")) throw new Error("input requires a non-empty labels array");
+  return labels;
+}
+async function generateLabelImport(args) {
+  const input = option(args, "--input") ?? option(args, "--data-file", true);
+  const init = args.includes("--init");
+  const output = option(args, "--output") ?? join4(stateDir("solvea-kit"), init ? "labels_init.xlsx" : "labels_update.xlsx");
+  const labels = labelsFrom(await readJson2(input));
+  const workbook = new ExcelJS.Workbook();
+  const sheet = workbook.addWorksheet("labels");
+  if (init) {
+    sheet.addRow([INIT_NOTICE]);
+    sheet.addRow(["first_level", "second_level", "third_level", "fourth_level", "describe", "example1", "example2", "example3", "example4", "example5"]);
+    for (const label of labels) {
+      const path = label.path ?? [label.firstLevel ?? label.first_level ?? "", label.secondLevel ?? label.second_level ?? "", label.thirdLevel ?? label.third_level ?? "", label.fourthLevel ?? label.fourth_level ?? ""];
+      if (!String(path[0] ?? "").trim()) throw new Error("init labels require path or first_level/firstLevel");
+      sheet.addRow([...path.slice(0, 4).map((value) => String(value ?? "").trim()), label.describe ?? "", ...examples(label)]);
+    }
+  } else {
+    sheet.addRow([UPDATE_NOTICE]);
+    sheet.addRow(["id", "name", "describe", "example1", "example2", "example3", "example4", "example5", "is_tag", "level", "parent_id", "path"]);
+    for (const label of labels) {
+      const name = label.name ?? label.nodeName;
+      if (!name) throw new Error("update labels require name or nodeName");
+      const isTag = typeof (label.isTag ?? label.is_tag ?? 1) === "boolean" ? label.isTag ?? label.is_tag ? 1 : 0 : label.isTag ?? label.is_tag ?? 1;
+      sheet.addRow([label.id ?? "", name, label.describe ?? label.nodeDescribe ?? "", ...examples(label), isTag, label.level ?? "", label.parentId ?? label.parent_id ?? 0, label.path ?? ""]);
+    }
+  }
+  sheet.getRow(1).font = { bold: true, color: { argb: "FF9C6500" } };
+  sheet.getRow(1).height = 78;
+  sheet.getRow(2).font = { bold: true };
+  sheet.columns.forEach((column) => {
+    column.width = 18;
+  });
+  await fs2.mkdir(dirname2(output), { recursive: true });
+  await workbook.xlsx.writeFile(output);
+  return { file: output, format: init ? "init" : "update", rows: labels.length };
+}
+var TAXONOMY = { "Pre-Sales Inquiry": ["Product Recommendation", "Discount Inquiry", "Price Inquiry", "Stock Availability", "Payment Issues"], Invoices: ["Request Invoice", "Modify Invoice Information"], "Order Issues": ["Modify Order", "Check Order Status", "Cancel Order"], "Logistics Issues": ["Track Shipment", "Shipping Exception"], "Package issues": ["Missing Items", "Wrong Items Received", "Damaged Package"], "Product issues": ["Product Usage", "Physical Damage", "Non-Physical Issues"], "Return and exchange": [] };
+async function classifyIntents(args) {
+  const owner = option(args, "--owner") ?? "solvea-kit";
+  const runId = option(args, "--run-id") ?? now();
+  const noExcel = args.includes("--no-excel");
+  if (!noExcel && !option(args, "--xlsx")) throw new Error("provide --xlsx or --no-excel");
+  const intents = Object.entries(TAXONOMY).map(([name, l2s]) => ({ name, definition: `Customer requests and issues related to ${name}.`, count: 0, pct: 0, sub_intents: l2s.map((l2) => ({ name: l2, definition: "", count: 0, pct: 0, samples: [], is_new: false })), samples: [], is_new: false }));
+  const result = { meta: { run_id: runId, total: 0, classified: 0, n_known: intents.length, n_new: 0, mode: noExcel ? "no-excel" : "structured" }, intents, new_intents: [] };
+  const resultPath = join4(outputDir(owner), `results_${runId}.json`);
+  await writeJson2(resultPath, result);
+  await writeJson2(join4(stateDir(owner), "progress.json"), { status: "ready", run_id: runId, results_path: resultPath, updated_at: (/* @__PURE__ */ new Date()).toISOString() });
+  return { ...result.meta, resultsPath: resultPath };
+}
+async function runSolveaKitWorkflow(action2, args) {
+  if (action2 === "label-import") return generateLabelImport(args);
+  if (action2 === "intent-classify") return classifyIntents(args);
+  throw new Error("workflow action must be label-import or intent-classify");
+}
+
+// src/workflows/support.ts
+import { readFile as readFile3 } from "fs/promises";
+import { basename as basename2 } from "path";
+var safe = (value) => encodeURIComponent(value);
+var docsMcpUrl = process.env.CXCLAW_DOCS_MCP_URL ?? "https://solvea-39f11a36.mintlify.app/mcp";
+var publicDocsPrefix = "https://www.voc.ai/cn/docs/";
+var previewDocsPrefix = "https://solvea-39f11a36.mintlify.app/";
+async function docsTool(tool, arguments_) {
+  const requestId = Date.now();
+  const initialize = await fetch(docsMcpUrl, { method: "POST", headers: { accept: "application/json, text/event-stream", "content-type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: requestId, method: "initialize", params: { protocolVersion: "2025-03-26", capabilities: {}, clientInfo: { name: "cxclawctl", version: "1" } } }), signal: AbortSignal.timeout(3e4) });
+  const sessionId = initialize.headers.get("mcp-session-id");
+  const headers = { accept: "application/json, text/event-stream", "content-type": "application/json", ...sessionId ? { "mcp-session-id": sessionId } : {} };
+  await fetch(docsMcpUrl, { method: "POST", headers, body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }), signal: AbortSignal.timeout(3e4) });
+  const response = await fetch(docsMcpUrl, { method: "POST", headers, body: JSON.stringify({ jsonrpc: "2.0", id: requestId + 1, method: "tools/call", params: { name: tool, arguments: arguments_ } }), signal: AbortSignal.timeout(3e4) });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`product docs request failed: HTTP ${response.status}`);
+  const dataLine = text.split(/\r?\n/).find((line) => line.startsWith("data:"));
+  try {
+    const payload = JSON.parse(dataLine ? dataLine.slice(5).trim() : text);
+    if (payload.error) throw new Error(String(payload.error.message ?? "product docs request failed"));
+    return payload.result ?? payload;
+  } catch {
+    return { content: [{ type: "text", text }] };
+  }
+}
+function normalizeDocUrl(value) {
+  if (!value.startsWith(previewDocsPrefix)) return value;
+  let path = value.slice(previewDocsPrefix.length);
+  const hash = path.indexOf("#");
+  const fragment = hash >= 0 ? path.slice(hash) : "";
+  if (hash >= 0) path = path.slice(0, hash);
+  if (path.startsWith("solvea/bot_cn/")) return `${publicDocsPrefix}bot/${path.split("/").pop()}${fragment}`;
+  return `${publicDocsPrefix}${path}${fragment}`;
+}
+function textBlocks(value) {
+  const content = value && typeof value === "object" ? value.content : void 0;
+  return Array.isArray(content) ? content.flatMap((item) => item && typeof item === "object" && typeof item.text === "string" ? [String(item.text)] : []) : [];
+}
+function parseDocBlock(text) {
+  const result = {};
+  const content = [];
+  let inContent = false;
+  for (const line of text.split(/\r?\n/)) {
+    if (inContent) content.push(line);
+    else if (line.startsWith("Title: ")) result.title = line.slice(7).trim();
+    else if (line.startsWith("Link: ")) result.url = normalizeDocUrl(line.slice(6).trim());
+    else if (line.startsWith("Page: ")) result.page = line.slice(6).trim();
+    else if (line.startsWith("Content:")) {
+      inContent = true;
+      if (line.slice(8).trim()) content.push(line.slice(8).trim());
+    }
+  }
+  if (content.length) result.content = content.join("\n").trim();
+  return Object.keys(result).length ? result : { content: text };
+}
+async function request2(session, method, path, body) {
+  const tenant = session.tenant;
+  const base = tenant?.businessUrl?.replace(/\/$/, "");
+  if (!tenant || !base || !tenant.businessToken) throw new Error("no tenant selected");
+  const cookie = tenant.environment === "prod" ? "_token" : "_token_staging";
+  const response = await fetch(`${base}/api_v2/gpt${path}`, { method, headers: { accept: "application/json", ...body === void 0 ? {} : { "content-type": "application/json" }, cookie: `${cookie}=${tenant.businessToken}` }, body: body === void 0 ? void 0 : JSON.stringify(body), signal: AbortSignal.timeout(3e4) });
+  const value = await response.json().catch(() => ({}));
+  if (!response.ok || value.code !== void 0 && ![0, 200, "0", "200", "OK", "SUCCESS"].includes(value.code)) throw new Error(`support API failed: HTTP ${response.status}`);
+  return value.data ?? value;
+}
+function portal(session) {
+  return session.tenant?.environment === "prod" ? "https://ai.solvea.cx" : "https://ai-staging.solvea.cx";
+}
+async function runSupport(session, action2, args) {
+  if (action2 === "list-tickets") return request2(session, "POST", "/support/tickets", { page: Number(option(args, "--page") ?? 1), pageSize: Number(option(args, "--page-size") ?? 20) });
+  if (action2 === "get-ticket") return request2(session, "GET", `/support/tickets/${safe(option(args, "--ticket-number", true))}`);
+  if (action2 === "append-message") return request2(session, "POST", `/support/tickets/${safe(option(args, "--ticket-number", true))}/messages`, { content: option(args, "--content", true) });
+  if (action2 === "create-ticket") {
+    const attachments = [];
+    for (const file of options2(args, "--attachment")) {
+      const form = new FormData();
+      form.append("file", new Blob([await readFile3(file)]), basename2(file));
+      const tenant = session.tenant;
+      const base = tenant?.businessUrl?.replace(/\/$/, "");
+      if (!tenant || !base || !tenant.businessToken) throw new Error("no tenant selected");
+      const cookie = tenant.environment === "prod" ? "_token" : "_token_staging";
+      const uploaded = await fetch(`${base}/api_v2/gpt/support/tickets/attachments/upload`, { method: "POST", headers: { cookie: `${cookie}=${tenant.businessToken}` }, body: form, signal: AbortSignal.timeout(3e4) });
+      const payload = await uploaded.json();
+      if (!uploaded.ok) throw new Error(`attachment upload failed: HTTP ${uploaded.status}`);
+      attachments.push(payload.data ?? payload);
+    }
+    const sourceId = process.env.CHAT_ID ?? "";
+    if (!sourceId) throw new Error("CHAT_ID is not configured");
+    const ticket = await request2(session, "POST", "/support/tickets/create", { content: option(args, "--content", true), sourceType: "cxclaw", sourceId, brand: option(args, "--brand"), issueType: option(args, "--issue-type") ?? option(args, "--category"), subject: option(args, "--subject"), contactEmail: option(args, "--contact-email"), ...option(args, "--ext") ? { extFields: JSON.parse(option(args, "--ext")) } : {}, ...attachments.length ? { attachments } : {} });
+    const number = ticket.ticketNumber;
+    await request2(session, "POST", "/support/skill-metrics", { chatId: sourceId, ticketNumber: number }).catch(() => void 0);
+    return { ticketNumber: number, ticketDetailUrl: number ? `${portal(session)}/chatbot#/support/tickets/${number}` : void 0, status: ticket.status, subject: ticket.subject, issueType: ticket.issueType, createdAt: ticket.createdAt };
+  }
+  if (action2 === "search-docs") {
+    const query2 = option(args, "--query", true);
+    const result = await docsTool("search_solvea", { query: query2 });
+    return { query: query2, results: textBlocks(result).map(parseDocBlock) };
+  }
+  if (action2 === "query-docs-filesystem") {
+    const command = option(args, "--command", true);
+    const result = await docsTool("query_docs_filesystem_solvea", { command });
+    return { command, output: textBlocks(result) };
+  }
+  throw new Error("support action must be search-docs, list-tickets, get-ticket, create-ticket, or append-message");
+}
+
+// src/workflows/common.ts
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join5, resolve as resolve4 } from "path";
+import { homedir as homedir2 } from "os";
+var workspaceRoot = () => resolve4(process.env.CXCLAW_WORKSPACE ?? join5(homedir2(), ".cxclaw", "workspace"));
+var stateRoot = (domain) => resolve4(process.env.CXCLAW_STATE_DIR ?? join5(workspaceRoot(), "state"), domain);
+var outputRoot = (domain) => resolve4(process.env.CXCLAW_OUTPUT_DIR ?? join5(workspaceRoot(), "outputs"), domain);
+async function ensureParent(file) {
+  await mkdir2(dirname3(file), { recursive: true });
+}
+async function ensureDir(directory) {
+  await mkdir2(directory, { recursive: true });
+}
+async function readJson3(file) {
+  return JSON.parse(await readFile4(file, "utf8"));
+}
+async function writeJson3(file, value) {
+  await ensureParent(file);
+  await writeFile2(file, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function intOption(args, name, fallback) {
+  const raw = option(args, name);
+  if (raw === void 0) return fallback;
+  const value = Number(raw);
+  if (!Number.isFinite(value)) throw new Error(`${name} must be a number`);
+  return value;
+}
+function safeJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+function htmlEscape(value) {
+  return String(value ?? "").replace(/[&<>\"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[char]);
+}
+async function writeHtml(file, title, body) {
+  await ensureParent(file);
+  await writeFile2(file, `<!doctype html><html><head><meta charset="utf-8"><title>${htmlEscape(title)}</title><style>body{font-family:system-ui,sans-serif;margin:2rem;line-height:1.5}pre{white-space:pre-wrap;background:#f6f8fa;padding:1rem;border-radius:8px}.card{border:1px solid #ddd;border-radius:8px;padding:1rem;margin:1rem 0}</style></head><body><h1>${htmlEscape(title)}</h1>${body}</body></html>`, "utf8");
+}
+function asRows(value) {
+  if (Array.isArray(value)) return value.filter((item) => item && typeof item === "object");
+  if (value && typeof value === "object") {
+    const object = value;
+    for (const key of ["list", "rows", "items", "data", "records", "result"]) {
+      if (Array.isArray(object[key])) return object[key].filter((item) => item && typeof item === "object");
+    }
   }
-  if (command === "auth" || command === "login" || command === "logout") {
-    const action = command === "auth" ? sub : command;
-    if (action === "login") {
-      const channel = option(rest, "--channel") ?? "stable";
-      return print(await login(option(rest, "--server", true), channel));
+  return [];
+}
+
+// src/workflows/agent-builder.ts
+function graphNodes(graph) {
+  if (!graph || typeof graph !== "object") return [];
+  const root2 = graph;
+  for (const key of ["nodes", "nodeList", "blocks"]) if (Array.isArray(root2[key])) return root2[key].filter((x) => x && typeof x === "object");
+  return [];
+}
+function graphEdges(graph) {
+  if (!graph || typeof graph !== "object") return [];
+  const root2 = graph;
+  for (const key of ["edges", "connections", "lines"]) if (Array.isArray(root2[key])) return root2[key].filter((x) => x && typeof x === "object");
+  return [];
+}
+function validateGraph(graph) {
+  const errors = [], warnings = [];
+  if (!graph || typeof graph !== "object" || Array.isArray(graph)) errors.push("graph must be a JSON object");
+  const nodes = graphNodes(graph), edges = graphEdges(graph);
+  if (!nodes.length) warnings.push("graph contains no nodes");
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, node] of nodes.entries()) {
+    const id = String(node.id ?? node.nodeId ?? node.key ?? "");
+    if (!id) errors.push(`nodes[${index}] is missing id`);
+    else if (ids.has(id)) errors.push(`duplicate node id: ${id}`);
+    else ids.add(id);
+    if (!node.type && !node.nodeType && !node.kind) warnings.push(`nodes[${index}] is missing type`);
+  }
+  for (const [index, edge] of edges.entries()) {
+    const from = String(edge.source ?? edge.sourceId ?? edge.from ?? edge.start ?? "");
+    const to = String(edge.target ?? edge.targetId ?? edge.to ?? edge.end ?? "");
+    if (!from || !to) errors.push(`edges[${index}] must contain source and target`);
+    else {
+      if (!ids.has(from)) errors.push(`edge ${index} references unknown source ${from}`);
+      if (!ids.has(to)) errors.push(`edge ${index} references unknown target ${to}`);
     }
-    if (action === "logout") {
-      await logout();
-      return print({ ok: true, loggedOut: true });
+  }
+  return { valid: errors.length === 0, errors, warnings, nodeCount: nodes.length, edgeCount: edges.length };
+}
+function mergeDeep(base, patch) {
+  if (Array.isArray(base) && Array.isArray(patch)) return [...base, ...patch];
+  if (base && patch && typeof base === "object" && typeof patch === "object" && !Array.isArray(base) && !Array.isArray(patch)) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(patch)) out[key] = key in out ? mergeDeep(out[key], value) : value;
+    return out;
+  }
+  return patch;
+}
+async function inspect(client, args) {
+  if (!client) throw new Error("inspect requires an authenticated tenant");
+  const agentId = option(args, "--agent-id");
+  const agentName = option(args, "--agent-name");
+  if (!agentId && !agentName) throw new Error("inspect requires --agent-id or --agent-name");
+  let agent;
+  if (agentId) agent = await client.getAgent(agentId);
+  else {
+    const result2 = await client.listAgents("text");
+    const rows = Array.isArray(result2) ? result2 : result2?.list;
+    agent = Array.isArray(rows) ? rows.find((row) => String(row.name ?? row.agentName) === agentName) : void 0;
+    if (!agent) throw new Error(`agent not found: ${agentName}`);
+  }
+  const item = Array.isArray(agent) ? agent[0] : agent;
+  const id = String(item?.id ?? item?.agentId ?? agentId ?? "");
+  const graph = id ? await client.getChatflowGraph(id) : void 0;
+  const result = { agent: item, graph };
+  const out = option(args, "--out");
+  if (out) await writeJson3(out, graph);
+  return result;
+}
+async function chatflow(client, action2, args) {
+  if (action2 === "inspect") return inspect(client, args);
+  if (action2 === "validate") {
+    const file = option(args, "--graph-file") ?? option(args, "--data-file", true);
+    const graph = await readJson3(file);
+    return { ...validateGraph(graph), file };
+  }
+  if (action2 === "compile") {
+    const source = await readJson3(option(args, "--source-file", true));
+    const graph = await readJson3(option(args, "--graph-file", true));
+    const result = mergeDeep(graph, source);
+    const validation = validateGraph(result);
+    if (!validation.valid) throw new Error(`compiled graph is invalid: ${validation.errors.join("; ")}`);
+    await writeJson3(option(args, "--graph-file", true), result);
+    return { ...validation, graph: result };
+  }
+  if (action2 === "merge-source") {
+    const integration = await readJson3(option(args, "--integration-file", true));
+    let result = integration;
+    for (const fragment of options2(args, "--fragment-file")) result = mergeDeep(result, await readJson3(fragment));
+    await writeJson3(option(args, "--out-file", true), result);
+    return { output: option(args, "--out-file"), ...validateGraph(result) };
+  }
+  if (["deploy", "update", "publish"].includes(action2)) {
+    const graph = await readJson3(option(args, "--graph-file", true));
+    const validation = validateGraph(graph);
+    if (!validation.valid) throw new Error(`graph validation failed: ${validation.errors.join("; ")}`);
+    if (!client) throw new Error("this chatflow action requires an authenticated tenant");
+    if (action2 === "deploy") return client.createAgent({ name: option(args, "--agent-name", true), type: "CHAT_FLOW", meta: { chatFlowGraph: graph } });
+    const id = option(args, "--agent-id", true);
+    return client.updateChatflow(id, graph, action2 === "publish");
+  }
+  throw new Error(`unknown chatflow action: ${action2}`);
+}
+async function validateTool(args) {
+  const value = await readJson3(option(args, "--data-file", true));
+  const errors = [], warnings = [];
+  if (!value || typeof value !== "object" || Array.isArray(value)) errors.push("tool payload must be an object");
+  else {
+    const object = value;
+    if (!object.name && !object.pluginName) errors.push("tool name is required");
+    if (!object.config && !object.externalHttpCallConfig && !object.url) warnings.push("tool has no HTTP configuration");
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+async function runAgentBuilder(session, action2, args) {
+  if (!action2) throw new Error("agent-builder action is required");
+  if (action2 === "chatflow") {
+    const operation = options2(args, "--operation")[0] ?? args.find((value) => ["inspect", "validate", "compile", "merge-source", "deploy", "update", "publish"].includes(value)) ?? "inspect";
+    return chatflow(["validate", "compile", "merge-source"].includes(operation) ? void 0 : session ? new SolveaClient(session) : void 0, operation, args);
+  }
+  if (["validate", "compile", "merge-source"].includes(action2)) return chatflow(void 0, action2, args);
+  if (["inspect", "deploy", "update", "publish"].includes(action2)) return chatflow(session ? new SolveaClient(session) : void 0, action2, args);
+  if (action2 === "validate-tool") return validateTool(args);
+  if (action2 === "migration" || action2 === "replay") return runLocalAgentWorkflow(action2, args);
+  if (!session) throw new Error(`${action2} requires an authenticated tenant`);
+  const client = new SolveaClient(session);
+  if (action2 === "copy-marketplace") {
+    const ids = options2(args, "--square-id");
+    if (!ids.length) throw new Error("--square-id is required");
+    if (flag(args, "--dry-run")) return { dryRun: true, squareIds: ids };
+    const results = [];
+    for (const id of ids) results.push(await client.rawCall("POST", "/api_v2/gpt/ap/copySquareAgent", { squareAgentId: Number(id), projectId: Number(await client.projectId()) }));
+    return { squareIds: ids, results };
+  }
+  if (action2 === "patch-tools") {
+    const ids = options2(args, "--agent-id");
+    if (!ids.length) throw new Error("--agent-id is required");
+    const headers = options2(args, "--header").map((value) => {
+      const index = value.indexOf("=");
+      return index < 1 ? { name: value, value: "" } : { name: value.slice(0, index), value: value.slice(index + 1) };
+    });
+    if (flag(args, "--dry-run")) return { dryRun: true, agentIds: ids, headers };
+    const results = [];
+    for (const id of ids) {
+      const agent = await client.getAgent(id);
+      const item = Array.isArray(agent) ? agent[0] : agent;
+      const tools = Array.isArray(item?.tools) ? item.tools : [];
+      const changed = tools.map((tool) => ({ ...tool, headers: [...Array.isArray(tool.headers) ? tool.headers : [], ...headers] }));
+      results.push(await client.updateAgent({ ...item, agentId: Number(id), tools: changed }));
+    }
+    return { agentIds: ids, results };
+  }
+  throw new Error(`unknown agent-builder action: ${action2}`);
+}
+async function runLocalAgentWorkflow(action2, args) {
+  if (action2 === "migration") {
+    const operation = option(args, "--operation") ?? args.find((value2) => ["inspect", "emit-chunk-context", "prepare-batch", "prepare-batches", "merge-batch-plans", "emit-batch-context", "emit-mapping-mermaid", "validate-migration-plan", "validate-prompt-block-rendering", "audit-migration-source", "emit-handoff", "verify-handoff", "coverage-report", "update-progress", "update-batch-progress"].includes(value2)) ?? "inspect";
+    if (operation === "update-progress" || operation === "update-batch-progress") {
+      const file = option(args, "--progress-file", true);
+      const progress = await readJson3(file).catch(() => ({}));
+      const id = option(args, operation === "update-progress" ? "--chunk-id" : "--batch-id", true);
+      const status = option(args, "--status", true);
+      const key = operation === "update-progress" ? "chunks" : "batches";
+      const entries = Array.isArray(progress[key]) ? progress[key] : [];
+      const existing = entries.find((entry2) => String(entry2.id ?? entry2.chunkId ?? entry2.batchId) === id);
+      if (existing) existing.status = status;
+      else entries.push({ id, status, note: option(args, "--note"), artifacts: options2(args, "--artifact") });
+      progress[key] = entries;
+      await writeJson3(file, progress);
+      return { operation, id, status, file };
     }
-    if (action === "status") {
+    const input2 = option(args, "--input") ?? option(args, "--plan-file") ?? option(args, "--source-file") ?? option(args, "--index-file");
+    if (!input2) throw new Error("migration requires --input or a plan/source file");
+    const value = await readJson3(input2);
+    if (["validate", "validate-plan", "validate-migration-plan", "audit", "audit-migration-source", "validate-prompt-block-rendering"].includes(operation)) return { operation, valid: true, validation: validateGraph(value), file: input2 };
+    if (operation === "mermaid" || operation === "emit-mapping-mermaid") {
+      const nodes = graphNodes(value), edges = graphEdges(value);
+      const lines = ["flowchart TD", ...nodes.map((node) => `  ${String(node.id ?? node.nodeId)}[${String(node.name ?? node.type ?? "node")}]`), ...edges.map((edge) => `  ${String(edge.source ?? edge.from)} --> ${String(edge.target ?? edge.to)}`)];
+      const out2 = option(args, "--out-file");
+      if (out2) await writeFileText(out2, lines.join("\n"));
+      return { mermaid: lines.join("\n"), output: out2 };
+    }
+    return { operation, input: input2, nodeCount: graphNodes(value).length, edgeCount: graphEdges(value).length, value };
+  }
+  const input = option(args, "--cases-file") ?? option(args, "--input");
+  const cases = input ? await readJson3(input) : [{ id: option(args, "--synthetic-case-id") ?? "synthetic_smoke", message: "status" }];
+  const rows = Array.isArray(cases) ? cases : [cases];
+  const output = { cases: rows, executed: flag(args, "--execute"), results: [] };
+  const out = option(args, "--out-json");
+  if (out) await writeJson3(out, output);
+  const html = option(args, "--out-html");
+  if (html) await writeHtml(html, "Replay comparison", `<pre>${htmlEscape(safeJson(output))}</pre>`);
+  return output;
+}
+async function writeFileText(file, content) {
+  await ensureParent(file);
+  const { writeFile: writeFile3 } = await import("fs/promises");
+  await writeFile3(file, `${content}
+`, "utf8");
+}
+
+// src/workflows/tester.ts
+import { join as join6 } from "path";
+import ExcelJS2 from "exceljs";
+async function casesFrom(file) {
+  if (file.endsWith(".json")) return asRows(await readJson3(file));
+  const workbook = new ExcelJS2.Workbook();
+  await workbook.xlsx.readFile(file);
+  const sheet = workbook.worksheets[0];
+  if (!sheet) throw new Error("cases workbook has no worksheet");
+  const headers = sheet.getRow(1).values.slice(1).map((v) => String(v ?? ""));
+  const rows = [];
+  sheet.eachRow((row, number) => {
+    if (number === 1) return;
+    const values = row.values.slice(1), item = {};
+    headers.forEach((header, index) => {
+      if (header) item[header] = values[index] ?? "";
+    });
+    rows.push(item);
+  });
+  return rows;
+}
+async function createSheet(args) {
+  const cases = option(args, "--cases-file") ? await casesFrom(option(args, "--cases-file")) : [];
+  const output = option(args, "--output") ?? join6(outputRoot("agent-tester"), `cases_${Date.now()}.xlsx`);
+  await ensureParent(output);
+  const workbook = new ExcelJS2.Workbook();
+  const sheet = workbook.addWorksheet("cases");
+  const headers = cases.length ? [...new Set(cases.flatMap((row) => Object.keys(row)))] : ["question", "expected_answer"];
+  sheet.addRow(headers);
+  cases.forEach((row) => sheet.addRow(headers.map((header) => row[header] ?? "")));
+  await workbook.xlsx.writeFile(output);
+  return { output, count: cases.length, mode: option(args, "--mode") };
+}
+async function submit(client, args) {
+  const file = option(args, "--file", true);
+  const result = await client.rawCall("POST", `/api_v2/gpt/label/project/${await client.projectId()}/uploadMessage`, { file, type: option(args, "--mode", true), ...option(args, "--agent-id") ? { agentId: Number(option(args, "--agent-id")) } : {}, ...option(args, "--flow-version") ? { flowVersion: Number(option(args, "--flow-version")) } : {} });
+  return result;
+}
+async function runAgentTester(session, action2, args) {
+  if (!action2) throw new Error("agent-tester action is required");
+  if (action2 === "create-sheet") return createSheet(args);
+  if (!session) throw new Error(`${action2} requires an authenticated tenant`);
+  const client = new SolveaClient(session);
+  if (action2 === "submit") return submit(client, args);
+  if (action2 === "get-tasks") return client.rawCall("POST", `/api_v2/gpt/label/project/${await client.projectId()}/getLabelTask`, { page: intOption(args, "--page", 1), pageSize: intOption(args, "--page-size", 20), taskType: option(args, "--mode") });
+  throw new Error(`unknown agent-tester action: ${action2}`);
+}
+
+// src/workflows/delivery.ts
+import { join as join7 } from "path";
+import ExcelJS3 from "exceljs";
+var KNOWN_INTENTS = ["Product Recommendation", "Discount Inquiry", "Price Inquiry", "Stock Availability", "Payment Issues", "Request Invoice", "Modify Order", "Check Order Status", "Cancel Order", "Track Shipment", "Shipping Exception", "Missing Items", "Wrong Items Received", "Damaged Package", "Product Usage", "Return and exchange"];
+async function loadRows(file) {
+  if (file.endsWith(".json")) {
+    const value = await readJson3(file);
+    return asRows(value);
+  }
+  const workbook = new ExcelJS3.Workbook();
+  await workbook.xlsx.readFile(file);
+  const sheet = workbook.worksheets[0];
+  if (!sheet) throw new Error("input workbook has no worksheet");
+  const headers = sheet.getRow(1).values.slice(1).map((v) => String(v ?? ""));
+  const rows = [];
+  sheet.eachRow((row, number) => {
+    if (number === 1) return;
+    const values = row.values.slice(1), item = {};
+    headers.forEach((header, index) => {
+      if (header) item[header] = values[index] ?? "";
+    });
+    rows.push(item);
+  });
+  return rows;
+}
+async function writeRows(file, rows) {
+  if (file.endsWith(".json")) {
+    await writeJson3(file, rows);
+    return;
+  }
+  const workbook = new ExcelJS3.Workbook();
+  const sheet = workbook.addWorksheet("results");
+  const keys = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+  sheet.addRow(keys);
+  rows.forEach((row) => sheet.addRow(keys.map((key) => row[key] ?? "")));
+  await ensureDir(join7(file, ".."));
+  await workbook.xlsx.writeFile(file);
+}
+function classify(text) {
+  const lower = text.toLowerCase();
+  return KNOWN_INTENTS.find((intent) => lower.includes(intent.toLowerCase())) ?? (lower.includes("price") ? "Price Inquiry" : lower.includes("order") ? "Order Issues" : "New Intent");
+}
+async function classifyCases(args, domain) {
+  const input = option(args, "--xlsx") ?? option(args, "--input");
+  const noExcel = flag(args, "--no-excel");
+  if (!input && !noExcel) throw new Error("--xlsx/--input or --no-excel is required");
+  const rows = input ? await loadRows(input) : [];
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const text = Object.values(row).join(" ");
+    const intent = classify(text);
+    grouped.set(intent, [...grouped.get(intent) ?? [], { ...row, intent }]);
+  }
+  const intents = [...grouped.entries()].map(([name, items]) => ({ name, definition: `Customer requests and issues related to ${name}.`, count: items.length, pct: rows.length ? items.length / rows.length : 0, samples: items.slice(0, 5), is_new: name === "New Intent" }));
+  const runId = option(args, "--run-id") ?? Date.now().toString();
+  const result = { meta: { run_id: runId, total: rows.length, classified: rows.length, mode: noExcel ? "no-excel" : "structured", domain }, intents, new_intents: intents.filter((item) => item.is_new) };
+  const out = option(args, "--results") ?? join7(outputRoot(domain), `results_${runId}.json`);
+  await writeJson3(out, result);
+  await writeJson3(join7(stateRoot(domain), "progress.json"), { status: "classified", run_id: runId, results_path: out, updated_at: (/* @__PURE__ */ new Date()).toISOString() });
+  return { ...result.meta, resultsPath: out };
+}
+async function plan(domain, args) {
+  const file = join7(stateRoot(domain), "progress.json");
+  let current = {};
+  try {
+    current = await readJson3(file);
+  } catch {
+  }
+  if (flag(args, "--init") || !Object.keys(current).length) current = { status: "initialized", tenant: option(args, "--tenant"), brandName: option(args, "--brand-name"), brandWebsite: option(args, "--brand-website"), updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const status = option(args, "--status");
+  if (status) current.status = status;
+  const assignments = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === "--set" && args[index + 1]) assignments.push(args[++index]);
+    else if (args[index].startsWith("--set=")) assignments.push(args[index].slice(6));
+  }
+  for (const assignment of assignments) {
+    const [key, ...value] = assignment.split("=");
+    if (key) current[key] = value.join("=");
+  }
+  await writeJson3(file, current);
+  return current;
+}
+async function runBatch(client, args, domain) {
+  const input = option(args, "--input") ?? option(args, "--test-file", true);
+  const rows = await loadRows(input);
+  const output = option(args, "--output") ?? join7(outputRoot(domain), `test_results_${Date.now()}.json`);
+  const workers = Math.max(1, Math.min(intOption(args, "--workers", 4), 16));
+  const results = [];
+  let cursor = 0;
+  async function worker() {
+    while (true) {
+      const index = cursor++;
+      if (index >= rows.length) return;
+      const row = rows[index];
+      const message = String(row.message ?? row.question ?? row.input ?? Object.values(row).join(" "));
       try {
-        const s = await loadSession();
-        return print({ ok: true, loggedIn: true, email: s.email, channel: s.channel, accessExpiresAt: s.accessExpiry });
-      } catch {
-        return print({ ok: true, loggedIn: false });
+        const response = await client.chat({ message, botId: option(args, "--bot-id"), touchPoint: option(args, "--touch-point") ?? "LIVE_CHAT", chatId: row.chatId });
+        results[index] = { ...row, index, ok: true, message, response };
+      } catch (error) {
+        results[index] = { ...row, index, ok: false, message, error: error instanceof Error ? error.message : String(error) };
       }
     }
-    if (action === "refresh") {
-      const s = await authenticated();
-      return print({ ok: true, accessExpiresAt: s.accessExpiry });
+  }
+  await Promise.all(Array.from({ length: workers }, () => worker()));
+  await writeJson3(output, { meta: { total: rows.length, workers, domain, generatedAt: (/* @__PURE__ */ new Date()).toISOString() }, results });
+  if (flag(args, "--report")) console.log(`completed ${results.filter((row) => row.ok).length}/${results.length} cases`);
+  return { output, total: results.length, succeeded: results.filter((row) => row.ok).length, failed: results.filter((row) => !row.ok).length };
+}
+async function createAgents(client, args, domain) {
+  const state2 = await readJson3(join7(stateRoot(domain), "progress.json")).catch(() => ({}));
+  const resultsPath = option(args, "--results") ?? (typeof state2.results_path === "string" ? state2.results_path : void 0);
+  if (!resultsPath) throw new Error("classification results are required");
+  const result = await readJson3(resultsPath);
+  const intents = Array.isArray(result.intents) ? result.intents : [];
+  if (flag(args, "--dry-run")) return { dryRun: true, intents: intents.map((item) => item.name) };
+  const created = [];
+  for (const intent of intents.filter((item) => Number(item.count ?? 0) > 0)) created.push(await client.createAgent({ name: `${String(intent.name)} ${domain === "poc" ? "POC" : "Delivery"}`, type: "CHAT_FLOW", meta: { intent: intent.name } }));
+  return { created, count: created.length };
+}
+async function renderReport(args, domain) {
+  const progress = await readJson3(join7(stateRoot(domain), "progress.json")).catch(() => ({}));
+  const resultsFile = option(args, "--results") ?? option(args, "--input") ?? (typeof progress.results_path === "string" ? progress.results_path : void 0);
+  if (!resultsFile) throw new Error("--results/--input is required, or run classify first");
+  const value = await readJson3(resultsFile);
+  const rows = asRows(value.results ?? value.items ?? value);
+  const output = option(args, "--html") ?? option(args, "--output") ?? join7(outputRoot(domain), `${domain}_report.html`);
+  const body = `<p>Total: ${rows.length}</p>${rows.map((row, index) => `<div class="card"><h2>${index + 1}. ${htmlEscape(row.intent ?? row.question ?? row.message ?? "Case")}</h2><pre>${htmlEscape(JSON.stringify(row, null, 2))}</pre></div>`).join("")}`;
+  await writeHtml(output, option(args, "--title") ?? `${domain} report`, body);
+  const md = option(args, "--md");
+  if (md) await import("fs/promises").then((fs3) => fs3.writeFile(md, `# ${domain} report
+
+Total: ${rows.length}
+`, "utf8"));
+  return { output, count: rows.length };
+}
+async function genExcel(args, domain) {
+  const progress = await readJson3(join7(stateRoot(domain), "progress.json")).catch(() => ({}));
+  const input = option(args, "--results") ?? option(args, "--items") ?? (typeof progress.results_path === "string" ? progress.results_path : void 0);
+  if (!input) throw new Error("--results or --items is required, or run classify first");
+  const value = await readJson3(input);
+  const rows = asRows(value);
+  const output = option(args, "--output") ?? join7(outputRoot(domain), `${domain}_results.xlsx`);
+  await writeRows(output, rows);
+  return { output, count: rows.length };
+}
+async function sampleHistory(client, args) {
+  const output = option(args, "--output", true);
+  const result = await client.listTranscripts({ pageIndex: 1, pageSize: intOption(args, "--max-conversations", 50), debug: false });
+  const rows = asRows(result).slice(0, intOption(args, "--total", 100));
+  await writeJson3(output, rows.map((row, index) => ({ id: row.chatId ?? row.id ?? String(index), message: row.message ?? row.lastMessage ?? "", metadata: flag(args, "--with-metadata") ? row : void 0 })));
+  return { output, count: rows.length };
+}
+async function inspectChatflow(client, args) {
+  const ids = args.flatMap((value, index) => value === "--agent-id" ? [args[index + 1]] : []).filter(Boolean);
+  const results = [];
+  for (const id of ids) results.push({ agentId: id, graph: await client.getChatflowGraph(id) });
+  return results;
+}
+async function runDelivery(session, action2, args) {
+  return runDomain(session, "delivery", action2, args);
+}
+async function runPoc(session, action2, args) {
+  return runDomain(session, "poc", action2, args);
+}
+async function runDomain(session, domain, action2, args) {
+  if (!action2) throw new Error(`${domain} action is required`);
+  if (action2 === "classify") return classifyCases(args, domain);
+  if (action2 === "plan") return plan(domain, args);
+  if (action2 === "report" || action2 === "render" || action2 === "render-report" || action2 === "manual") return renderReport(args, domain);
+  if (action2 === "excel" || action2 === "gen-excel") return genExcel(args, domain);
+  if (!session) throw new Error(`${domain} ${action2} requires an authenticated tenant`);
+  const client = new SolveaClient(session);
+  if (action2 === "batch-test" || action2 === "test") return runBatch(client, args, domain);
+  if (action2 === "create-agents") return createAgents(client, args, domain);
+  if (action2 === "sample-history") return sampleHistory(client, args);
+  if (action2 === "inspect-chatflow") return inspectChatflow(client, args);
+  if (action2 === "render-summary") return plan(domain, args);
+  throw new Error(`unknown ${domain} action: ${action2}`);
+}
+
+// src/workflows/kb-builder.ts
+import { join as join8 } from "path";
+import ExcelJS4 from "exceljs";
+var clean = (value) => String(value ?? "").replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+var absolute = (href, base) => {
+  try {
+    return new URL(href, base).toString();
+  } catch {
+    return void 0;
+  }
+};
+async function crawl(args) {
+  const url = option(args, "--url", true);
+  const maxPages = intOption(args, "--max-pages", 50), maxDepth = intOption(args, "--max-depth", 2), timeout = intOption(args, "--timeout", 20) * 1e3;
+  const origin = new URL(url).origin, queue = [{ url, depth: 0 }], seen = /* @__PURE__ */ new Set(), pages = [];
+  while (queue.length && pages.length < maxPages) {
+    const current = queue.shift();
+    if (seen.has(current.url) || current.depth > maxDepth) continue;
+    seen.add(current.url);
+    try {
+      const response = await fetch(current.url, { signal: AbortSignal.timeout(timeout), headers: { accept: "text/html,application/xhtml+xml" } });
+      if (!response.ok) continue;
+      const html = await response.text();
+      const title = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1] ?? "";
+      const text = clean(html);
+      pages.push({ url: current.url, depth: current.depth, title: clean(title), text: text.slice(0, 5e4), status: response.status });
+      if (current.depth < maxDepth) for (const match of html.matchAll(/href\s*=\s*["']([^"']+)["']/gi)) {
+        const next = absolute(match[1], current.url);
+        if (next && next.startsWith(origin) && !seen.has(next)) queue.push({ url: next, depth: current.depth + 1 });
+      }
+    } catch (error) {
+      pages.push({ url: current.url, depth: current.depth, error: error instanceof Error ? error.message : String(error) });
     }
   }
-  if (command === "tenant" || command === "context") {
-    const session = await authenticated();
-    if (sub === "current") return print(publicTenant(session.tenant));
-    if (sub === "clear") {
-      delete session.tenant;
-      await saveSession(session);
-      return print({ ok: true, cleared: true });
+  const result = { url, mode: option(args, "--mode") ?? "auto", pages, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), total: pages.length };
+  const output = option(args, "--output") ?? join8(outputRoot("kb-builder"), "crawl_result.json");
+  await writeJson3(output, result);
+  return { ...result, output };
+}
+async function directoryPlan(args) {
+  const source = await readJson3(option(args, "--crawl-result", true));
+  const rows = asRows(source.pages ?? source);
+  const groups = /* @__PURE__ */ new Map();
+  for (const page2 of rows) {
+    const title = String(page2.title ?? page2.url ?? "Untitled");
+    const key = title.split(/[:|/\\-]/)[0].trim() || "General";
+    groups.set(key, [...groups.get(key) ?? [], page2]);
+  }
+  const tree = [...groups.entries()].map(([name, pages]) => ({ name, children: pages.slice(0, 100).map((page2) => ({ name: String(page2.title ?? page2.url), sourceUrl: page2.url })) }));
+  const result = { source: option(args, "--crawl-result"), generatedAt: (/* @__PURE__ */ new Date()).toISOString(), tree, confirmed: false };
+  const output = option(args, "--output") ?? join8(outputRoot("kb-builder"), "directory_plan.json");
+  await writeJson3(output, result);
+  if (flag(args, "--write-confirmed-tree")) await writeJson3(join8(stateRoot("kb-builder"), "confirmed_tree.json"), { ...result, confirmed: true });
+  return { output, directories: tree.length, pages: rows.length, tree };
+}
+async function createDirectories(client, args) {
+  const file = option(args, "--tree-file") ?? join8(stateRoot("kb-builder"), "confirmed_tree.json");
+  const value = await readJson3(file);
+  const tree = Array.isArray(value.tree) ? value.tree : Array.isArray(value) ? value : [];
+  if (!tree.length) throw new Error("confirmed directory tree is empty");
+  const dryRun = flag(args, "--dry-run"), created = [];
+  async function visit(nodes, parentId = 0, depth = 0) {
+    if (depth > intOption(args, "--max-depth", 3)) throw new Error("directory tree exceeds max depth");
+    for (const node of nodes) {
+      const name = String(node.name ?? "").trim();
+      if (!name) continue;
+      const result = dryRun ? { name, parentId, dryRun: true } : await client.createFolder(name, parentId);
+      created.push(result);
+      const id = Number(result?.id ?? result?.directoryId ?? 0);
+      const children = Array.isArray(node.children) ? node.children : [];
+      if (children.length && id) await visit(children, id, depth + 1);
     }
-    if (sub === "search") return print(await search(session, positionals(rest)[0] ?? "", option(rest, "--env", true)));
-    if (sub === "use") return print(await useTenant(session, Number(positionals(rest)[0]), option(rest, "--env", true), option(rest, "--purpose", true)));
   }
-  if (command === "api") {
+  await visit(tree);
+  return { file, dryRun, created, count: created.length };
+}
+async function extractWebQa(args) {
+  const input = await readJson3(option(args, "--crawl-result", true));
+  const pages = asRows(input.pages ?? input).slice(0, intOption(args, "--max-pages", 80));
+  const outputDir2 = option(args, "--output-dir") ?? join8(outputRoot("kb-builder"), "qa_parts");
+  await ensureDir(outputDir2);
+  const parts = pages.map((page2, index) => ({ question: String(page2.title ?? page2.url), answer: String(page2.text ?? "").slice(0, intOption(args, "--answer-limit", 3500)), sourceUrl: page2.url, sourceTitle: page2.title, index }));
+  const files = [];
+  for (const [index, part] of parts.entries()) {
+    const file = join8(outputDir2, `part_${String(index + 1).padStart(4, "0")}.json`);
+    await writeJson3(file, { items: [part] });
+    files.push(file);
+  }
+  return { outputDir: outputDir2, files, count: files.length };
+}
+async function importQa(client, args) {
+  const qaFile = option(args, "--qa-file");
+  const fromDir = option(args, "--from-dir");
+  if (!qaFile && !fromDir) throw new Error("--qa-file or --from-dir is required");
+  const items = [];
+  if (qaFile) {
+    const value = await readJson3(qaFile);
+    items.push(...Array.isArray(value) ? value : value.items && Array.isArray(value.items) ? value.items : [value]);
+  }
+  if (fromDir) {
+    const { readdir } = await import("fs/promises");
+    for (const file of (await readdir(fromDir)).filter((name) => name.endsWith(".json"))) {
+      const value = await readJson3(join8(fromDir, file));
+      items.push(...Array.isArray(value) ? value : value.items && Array.isArray(value.items) ? value.items : [value]);
+    }
+  }
+  const plan2 = { items, count: items.length, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const planFile = join8(outputRoot("kb-builder"), `qa_import_plan_${Date.now()}.json`);
+  await writeJson3(planFile, plan2);
+  if (flag(args, "--dry-run")) return { dryRun: true, planFile, count: items.length };
+  return { planFile, count: items.length, result: await client.uploadQa(items) };
+}
+async function importSources(client, args) {
+  const plan2 = await readJson3(option(args, "--plan-file", true));
+  const documents = Array.isArray(plan2.documents) ? plan2.documents : Array.isArray(plan2.items) ? plan2.items : [];
+  const payload = { documents, taskType: "WEB", published: true, isVisible: true, metadata: { tags: [] }, directoryId: String(plan2.directoryId ?? "") };
+  if (!flag(args, "--execute")) return { dryRun: true, payload };
+  return client.rawCall("POST", `${client.qamPath}/project/${await client.projectId()}/documents`, payload);
+}
+async function importTemplates(client, args) {
+  const source = option(args, "--plan-file") ?? option(args, "--xlsx");
+  if (!source) throw new Error("--xlsx or --plan-file is required");
+  const rows = [];
+  if (source.endsWith(".json")) rows.push(...asRows(await readJson3(source)));
+  else {
+    const workbook = new ExcelJS4.Workbook();
+    await workbook.xlsx.readFile(source);
+    const sheet = option(args, "--sheet") ? workbook.getWorksheet(option(args, "--sheet")) : workbook.worksheets[0];
+    if (!sheet) throw new Error("workbook has no worksheet");
+    const headers = sheet.getRow(1).values.slice(1).map((v) => String(v ?? ""));
+    sheet.eachRow((row, number) => {
+      if (number === 1) return;
+      const values = row.values.slice(1);
+      const item = {};
+      headers.forEach((header, index) => {
+        if (header) item[header] = values[index] ?? "";
+      });
+      rows.push(item);
+    });
+  }
+  const items = rows.map((row) => ({ name: String(row.name ?? row.Name ?? "").trim(), content: String(row.content ?? row.Content ?? row.template ?? ""), status: row.status ?? row.Status ?? "ENABLED", scene: row.scene ?? row.Scene })).filter((item) => item.name && item.content);
+  const output = option(args, "--output") ?? join8(outputRoot("kb-builder"), `template_import_plan_${Date.now()}.json`);
+  await writeJson3(output, { items, count: items.length });
+  if (flag(args, "--dry-run")) return { dryRun: true, output, count: items.length };
+  const results = [];
+  for (const item of items) results.push(await client.createTemplate(item));
+  return { output, count: results.length, results };
+}
+async function exportKnowledge(client, args) {
+  const directories = asRows(await client.listDirectories());
+  const ids = option(args, "--directory-id") ? [Number(option(args, "--directory-id"))] : directories.map((row) => Number(row.id ?? row.directoryId)).filter(Number.isFinite);
+  const rows = [];
+  for (const id of ids) {
+    const value = await client.listKnowledge({ directoryId: id, keyword: option(args, "--keyword") ?? "", type: option(args, "--type") ?? "ALL", pageSize: intOption(args, "--page-size", 1e3) });
+    rows.push(...asRows(value).map((row) => ({ ...row, directoryId: id, directoryName: directories.find((dir) => Number(dir.id ?? dir.directoryId) === id)?.name ?? "" })));
+  }
+  const output = option(args, "--output") ?? join8(outputRoot("kb-builder"), `knowledge_${Date.now()}.xlsx`);
+  const workbook = new ExcelJS4.Workbook();
+  const sheet = workbook.addWorksheet("knowledge");
+  const keys = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+  sheet.addRow(keys);
+  for (const row of rows) sheet.addRow(keys.map((key) => row[key] ?? ""));
+  await ensureDir(join8(output, ".."));
+  await workbook.xlsx.writeFile(output);
+  return { output, count: rows.length };
+}
+async function runKbBuilder(session, action2, args) {
+  if (!action2) throw new Error("kb-builder action is required");
+  if (action2 === "crawl") return crawl(args);
+  if (action2 === "directory-plan") return directoryPlan(args);
+  if (!session) throw new Error(`${action2} requires an authenticated tenant`);
+  const client = new SolveaClient(session);
+  if (action2 === "create-directories") return createDirectories(client, args);
+  if (action2 === "extract-web-qa") return extractWebQa(args);
+  if (action2 === "import-qa") return importQa(client, args);
+  if (action2 === "import-source-documents") return importSources(client, args);
+  if (action2 === "import-templates") return importTemplates(client, args);
+  if (action2 === "export-knowledge") return exportKnowledge(client, args);
+  if (action2 === "extract-ticket-qa" || action2 === "batch-extract-ticket-qa") return extractTicketQa(args);
+  throw new Error(`unknown kb-builder action: ${action2}`);
+}
+async function extractTicketQa(args) {
+  const file = option(args, "--xlsx", true);
+  const workbook = new ExcelJS4.Workbook();
+  await workbook.xlsx.readFile(file);
+  const sheet = workbook.worksheets[0];
+  if (!sheet) throw new Error("workbook has no worksheet");
+  const headers = sheet.getRow(1).values.slice(1).map((v) => String(v ?? ""));
+  const messageCol = option(args, "--messages-col") ?? headers.find((header) => /message|conversation|content|描述/i.test(header)) ?? headers[0];
+  const titleCol = option(args, "--title-col");
+  const replyCol = option(args, "--reply-col");
+  const brand = option(args, "--brand", true);
+  const items = [];
+  sheet.eachRow((row, number) => {
+    if (number === 1) return;
+    const values = row.values.slice(1), record = {};
+    headers.forEach((header, index) => {
+      record[header] = values[index] ?? "";
+    });
+    const question = `${brand}: ${String(record[titleCol] ?? "").trim()} ${String(record[messageCol] ?? "").trim()}`.trim();
+    const answer = String(record[replyCol] ?? "").trim();
+    if (question && question !== `${brand}:`) items.push({ question, answer, sourceRow: number });
+  });
+  const output = option(args, "--output") ?? join8(outputRoot("kb-builder"), `ticket_qa_${Date.now()}.json`);
+  const result = { brand, count: items.length, items };
+  await writeJson3(output, result);
+  if (flag(args, "--dry-run")) return { dryRun: true, output, count: items.length };
+  return { output, count: items.length, items };
+}
+
+// src/workflows/desk.ts
+import { join as join9 } from "path";
+import ExcelJS5 from "exceljs";
+var taskId = (args) => option(args, "--task-id") ?? (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+var taskDir = (args) => join9(stateRoot("solvea-desk"), taskId(args));
+async function saveDatasource(dir, name, rows) {
+  const file = join9(dir, name);
+  await ensureParent(file);
+  const workbook = new ExcelJS5.Workbook();
+  const sheet = workbook.addWorksheet("data");
+  const keys = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+  sheet.addRow(keys);
+  for (const row of rows) sheet.addRow(keys.map((key) => row[key] ?? ""));
+  await workbook.xlsx.writeFile(file);
+  return file;
+}
+async function fetchTickets(client, args) {
+  const dir = taskDir(args);
+  const pageSize2 = Math.max(1, Math.min(intOption(args, "--page-size", 100), 500));
+  const maxPages = intOption(args, "--max-pages", 100);
+  const maxRows = intOption(args, "--max-rows", 1e4);
+  const rows = [];
+  for (let page2 = 1; page2 <= maxPages && rows.length < maxRows; page2 += 1) {
+    const value = await client.rawCall("POST", "/api_v2/tars/api/ticket/list", { viewId: option(args, "--view-id") ?? "1", page: page2, pageSize: pageSize2, sort: option(args, "--sort") ?? "last_update_time", order: option(args, "--order") ?? "DESC", ...option(args, "--filters-file") ? await readJson3(option(args, "--filters-file")) : {} });
+    const pageRows = asRows(value);
+    rows.push(...pageRows.slice(0, maxRows - rows.length));
+    if (pageRows.length < pageSize2) break;
+  }
+  const output = await saveDatasource(dir, "datasource.xlsx", rows);
+  await writeJson3(join9(dir, "metadata.json"), { taskId: taskId(args), rows: rows.length, output });
+  return { taskId: taskId(args), output, count: rows.length };
+}
+async function fetchSources(client, args) {
+  const dir = taskDir(args);
+  const begin = option(args, "--start", true), end = option(args, "--end", true);
+  const sources = { begin, end, tickets: [] };
+  const value = await client.rawCall("POST", "/api_v2/tars/api/ticket/list", { startTime: begin, endTime: end, page: 1, pageSize: intOption(args, "--max-rows", 1e4) });
+  const rows = asRows(value).slice(0, intOption(args, "--max-rows", 1e4));
+  sources.tickets = rows;
+  const output = await saveDatasource(dir, "datasource.xlsx", rows);
+  await writeJson3(join9(dir, "sources.json"), sources);
+  return { taskId: taskId(args), output, count: rows.length };
+}
+async function tags(client, action2, args) {
+  if (action2 === "list-tags") return client.rawCall("GET", "/api_v2/tars/api/ticket/tag/tree");
+  const ticket = option(args, "--ticket-number", true);
+  if (action2 === "get-ticket-tags") return client.rawCall("GET", `/api_v2/tars/api/ticket/${encodeURIComponent(ticket)}/tags`);
+  if (action2 === "search-tags") {
+    const tree = await client.rawCall("GET", "/api_v2/tars/api/ticket/tag/tree");
+    const needle = option(args, "--name", true).toLowerCase();
+    const flatten = (value) => Array.isArray(value) ? value.flatMap(flatten) : value && typeof value === "object" ? [value, ...flatten(value.children ?? value.nodes ?? [])] : [];
+    return flatten(tree).filter((row) => String(row.name ?? row.label ?? "").toLowerCase().includes(needle));
+  }
+  if (action2 === "batch-get-ticket-tags") {
+    const ids = asRows(await readJson3(option(args, "--ticket-ids-file", true)));
+    const result = [];
+    for (const row of ids) result.push({ ...row, tags: await client.rawCall("GET", `/api_v2/tars/api/ticket/${encodeURIComponent(String(row.ticketNumber ?? row.ticketId ?? row.id))}/tags`) });
+    return result;
+  }
+  if (action2 === "bind-tags" || action2 === "replace-tags") {
+    if (!flag(args, "--confirm")) throw new Error(`${action2} requires --confirm`);
+    const tagsFile = option(args, "--tags-file", true);
+    return client.rawCall("POST", `/api_v2/tars/api/ticket/${encodeURIComponent(ticket)}/tags`, { tags: await readJson3(tagsFile) });
+  }
+  throw new Error(`unknown tag action: ${action2}`);
+}
+async function renderReport2(args) {
+  const dir = taskDir(args), dataFile = option(args, "--report-data") ?? join9(dir, "report_data.json"), notesFile = option(args, "--notes") ?? join9(dir, "calculation_notes.json");
+  const data3 = await readJson3(dataFile);
+  if (flag(args, "--validate-only")) return { valid: true, dataFile };
+  const output = option(args, "--output") ?? join9(outputRoot("solvea-desk"), taskId(args), `${option(args, "--report-slug") ?? "report"}.html`);
+  const body = `<pre>${htmlEscape(JSON.stringify({ data: data3, notes: await readJson3(notesFile).catch(() => ({})) }, null, 2))}</pre>`;
+  await writeHtml(output, option(args, "--report-slug") ?? "Solvea Desk report", body);
+  return { output, valid: true };
+}
+async function runDesk(session, action2, args) {
+  if (!action2) throw new Error("solvea-desk action is required");
+  const client = new SolveaClient(session);
+  if (action2 === "fetch-tickets") return fetchTickets(client, args);
+  if (action2 === "fetch-sources") return fetchSources(client, args);
+  if (action2 === "render-report") return renderReport2(args);
+  if (action2 === "tags") return tags(client, option(args, "--operation") ?? args.find((value) => ["list-tags", "get-ticket-tags", "batch-get-ticket-tags", "search-tags", "bind-tags", "replace-tags"].includes(value)) ?? "list-tags", args);
+  if (["list-tags", "get-ticket-tags", "batch-get-ticket-tags", "search-tags", "bind-tags", "replace-tags"].includes(action2)) return tags(client, action2, args);
+  throw new Error(`unknown solvea-desk action: ${action2}`);
+}
+
+// src/cli.ts
+var print = (value) => console.log(JSON.stringify(value, null, 2));
+var usage = () => [
+  "cxclawctl <resource> <action> [options]",
+  "cxclawctl auth|tenant|sls|runtime|doctor|update|setup|version",
+  "cxclawctl agent-builder|agent-tester|delivery|poc|kb-builder|solvea-desk <action>",
+  resourceHelp(),
+  "Example: cxclawctl intent create --data-file intent.json"
+].join("\n\n");
+async function runAuth(action2, args) {
+  if (action2 === "login") return print(await login(option(args, "--server", true), option(args, "--channel") ?? "stable"));
+  if (action2 === "logout") {
+    await logout();
+    return print({ ok: true, loggedOut: true });
+  }
+  if (action2 === "status") {
+    try {
+      const session = await loadSession();
+      return print({ ok: true, loggedIn: true, email: session.email, channel: session.channel, accessExpiresAt: session.accessExpiry });
+    } catch {
+      return print({ ok: true, loggedIn: false });
+    }
+  }
+  if (action2 === "refresh") {
     const session = await authenticated();
-    if (!sub) throw new Error("api command is required");
-    await runApi(session, sub, rest);
+    return print({ ok: true, accessExpiresAt: session.accessExpiry });
+  }
+  throw new Error("auth action must be login, logout, status, or refresh");
+}
+async function runTenant(action2, args) {
+  const session = await authenticated();
+  if (action2 === "current") return print(publicTenant(session.tenant));
+  if (action2 === "clear") {
+    delete session.tenant;
+    await saveSession(session);
+    return print({ ok: true, cleared: true });
+  }
+  if (action2 === "search") return print(await search(session, positionals(args)[0] ?? "", option(args, "--env", true)));
+  if (action2 === "use") return print(await useTenant(session, Number(positionals(args)[0]), option(args, "--env", true), option(args, "--purpose", true)));
+  throw new Error("tenant action must be search, use, current, or clear");
+}
+async function main(args = process.argv.slice(2)) {
+  const [command, action2, ...rest] = args;
+  if (!command || command === "help" || flag(args, "--help")) {
+    console.log(command && isResourceCommand(command) ? resourceHelp(command, action2 && !["help", "--help"].includes(action2) ? action2 : void 0) : usage());
     return;
   }
-  if (command === "script") {
-    if (!sub) throw new Error("script path is required");
-    process.exitCode = await runPython(sub, rest);
+  if (isResourceCommand(command)) {
+    await runResourceCommand(await authenticated(), command, action2, rest);
     return;
   }
-  if (command === "sls" && sub === "query") {
-    const session = await authenticated();
-    return print(await query(session, { from: Number(option(rest, "--from", true)), to: Number(option(rest, "--to", true)), query: option(rest, "--query", true), line: Number(option(rest, "--line") ?? 50), offset: Number(option(rest, "--offset") ?? 0), reverse: flag(rest, "--reverse") }));
+  if (command === "version") {
+    if (flag(args, "--json")) return print({ pluginVersion: process.env.CXCLAW_PLUGIN_VERSION ?? null, cliVersion: VERSION, toolSchemaVersion: TOOL_SCHEMA_VERSION, serverApiVersion: SERVER_API_VERSION });
+    console.log(`cxclawctl ${VERSION}`);
+    return;
   }
-  if (command === "doctor") {
-    const manifest = JSON.parse(await readFile(new URL("../plugin.json", import.meta.url), "utf8"));
-    if (manifest.version !== VERSION) throw new Error(`plugin version ${manifest.version} does not match CLI ${VERSION}`);
-    return print({ ok: true, node: process.versions.node, cliVersion: VERSION, root: packageRoot() });
+  if (command === "setup") {
+    const channel = option(args, "--channel") ?? "stable";
+    await installMarketplace(channel);
+    await login(option(args, "--server", true), channel);
+    await installScheduler();
+    return;
   }
+  if (command === "auth") return runAuth(action2, rest);
+  if (command === "login" || command === "logout") return runAuth(command, args.slice(1));
+  if (command === "tenant" || command === "context") return runTenant(action2, rest);
+  if (command === "runtime") return print(await runRuntime(action2, rest));
+  if (command === "workflow") return print(await runSolveaKitWorkflow(action2, rest));
+  if (command === "support") return print(await runSupport(await authenticated(), action2, rest));
+  if (command === "agent-builder") return print(await runAgentBuilder(["validate", "compile", "merge-source", "validate-tool", "migration", "replay"].includes(action2 ?? "") ? void 0 : await authenticated(), action2, rest));
+  if (command === "agent-tester") return print(await runAgentTester(action2 === "create-sheet" ? void 0 : await authenticated(), action2, rest));
+  if (command === "delivery") return print(await runDelivery(["classify", "plan", "report", "render", "render-report", "excel", "gen-excel", "render-summary"].includes(action2 ?? "") ? void 0 : await authenticated(), action2, rest));
+  if (command === "poc") return print(await runPoc(["classify", "plan", "report", "render", "render-report", "excel", "gen-excel", "manual", "render-summary"].includes(action2 ?? "") ? void 0 : await authenticated(), action2, rest));
+  if (command === "kb-builder") return print(await runKbBuilder(["crawl", "directory-plan", "extract-web-qa", "extract-ticket-qa", "batch-extract-ticket-qa"].includes(action2 ?? "") ? void 0 : await authenticated(), action2, rest));
+  if (command === "solvea-desk") return print(await runDesk(await authenticated(), action2, rest));
+  if (command === "api") {
+    if (!action2) throw new Error("api command is required");
+    await runApi(await authenticated(), action2, rest);
+    return;
+  }
+  if (command === "sls" && action2 === "query") {
+    return print(await query(await authenticated(), {
+      from: Number(option(rest, "--from", true)),
+      to: Number(option(rest, "--to", true)),
+      query: option(rest, "--query", true),
+      line: Number(option(rest, "--line") ?? 50),
+      offset: Number(option(rest, "--offset") ?? 0),
+      reverse: flag(rest, "--reverse")
+    }));
+  }
+  if (command === "doctor") return print(await diagnose());
   if (command === "update") {
     if (flag(args, "--install-scheduler")) {
       await installScheduler();
-      return;
+      return print({ ok: true, schedulerInstalled: true });
     }
-    if (flag(args, "--scheduled")) await new Promise((r) => setTimeout(r, Math.random() * 18e5));
-    return print({ version: await update() });
+    if (flag(args, "--scheduled")) await new Promise((resolve5) => setTimeout(resolve5, Math.random() * 18e5));
+    return print(await update());
   }
-  if (command === "commands" || command === "capabilities") return console.log(await readFile(new URL("../capabilities.lock.json", import.meta.url), "utf8"));
-  throw new Error(`unknown command: ${command}`);
+  if (command === "commands" || command === "capabilities") console.log(await readFile5(new URL("../capabilities.lock.json", import.meta.url), "utf8"));
+  else throw new Error(`unknown command: ${command}`);
 }
 main().catch((error) => {
   console.error(`cxclawctl: ${error instanceof Error ? error.message : String(error)}`);