@dazitech/cli 3.0.0 → 3.0.1

package/dist/clis/dazi-flow.js

@@ -959,8 +959,8 @@ var require_command = __commonJS({
   "node_modules/.pnpm/commander@12.1.0/node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path20 = require("node:path");
-    var fs16 = require("node:fs");
+    var path21 = require("node:path");
+    var fs17 = require("node:fs");
     var process2 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1892,11 +1892,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path20.resolve(baseDir, baseName);
-          if (fs16.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path20.extname(baseName))) return void 0;
+          const localBin = path21.resolve(baseDir, baseName);
+          if (fs17.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path21.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs16.existsSync(`${localBin}${ext}`)
+            (ext) => fs17.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1908,21 +1908,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs16.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs17.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path20.resolve(
-            path20.dirname(resolvedScriptPath),
+          executableDir = path21.resolve(
+            path21.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path20.basename(
+            const legacyName = path21.basename(
               this._scriptPath,
-              path20.extname(this._scriptPath)
+              path21.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1933,7 +1933,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path20.extname(executableFile));
+        launchWithNode = sourceExt.includes(path21.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -2773,7 +2773,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path20.basename(filename, path20.extname(filename));
+        this._name = path21.basename(filename, path21.extname(filename));
         return this;
       }
       /**
@@ -2787,9 +2787,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path21) {
-        if (path21 === void 0) return this._executableDir;
-        this._executableDir = path21;
+      executableDir(path22) {
+        if (path22 === void 0) return this._executableDir;
+        this._executableDir = path22;
         return this;
       }
       /**
@@ -3084,9 +3084,9 @@ function loadAuth() {
 }
 
 // cli/shared/src/httpClient.js
-async function apiRequest(path20, opts = {}) {
+async function apiRequest(path21, opts = {}) {
   const auth = opts.token || opts.serverUrl ? { token: opts.token ?? "", serverUrl: opts.serverUrl ?? "" } : loadAuth();
-  const url = `${auth.serverUrl.replace(/\/$/, "")}${path20}`;
+  const url = `${auth.serverUrl.replace(/\/$/, "")}${path21}`;
   const headers = {
     "Content-Type": "application/json",
     Authorization: `Bearer ${auth.token}`,
@@ -3583,11 +3583,11 @@ function makeSnapshotCommand() {
 }
 
 // cli/dazi-flow/src/commands/project.ts
-var import_path9 = __toESM(require("path"), 1);
-var import_fs7 = __toESM(require("fs"), 1);
+var import_path10 = __toESM(require("path"), 1);
+var import_fs8 = __toESM(require("fs"), 1);
 
 // src/shared/flowScaffoldDocs.ts
-var import_path7 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 
 // src/shared/flowNodeCatalog.ts
 var FLOW_NODE_CATALOG = [
@@ -3773,9 +3773,339 @@ function shortVar(s) {
 }
 
 // src/shared/flowCliText.ts
-var DAZI_PS1 = ".\\\\scripts\\\\dazi.ps1";
+var DAZI_CLI = "dazi";
+function psFlowLine(subcommand) {
+  return `${DAZI_CLI} flow ${subcommand}`;
+}
+function psDaziLine(args) {
+  return `${DAZI_CLI} ${args}`;
+}
 function mdFlowCmd(subcommand) {
-  return `\`${DAZI_PS1} flow ${subcommand}\``;
+  return `\`${DAZI_CLI} flow ${subcommand}\``;
+}
+
+// src/shared/flowWorkspaceAudit.ts
+var import_crypto2 = __toESM(require("crypto"));
+var import_fs6 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var NODES_DIR2 = "\u8282\u70B9";
+var FLOW_JSON2 = "flow.json";
+var FLOW_META_JSON2 = "flow.meta.json";
+var NODE_INFO_JSON2 = "node.info.json";
+var NODE_TYPE_CODE_DATA_KEY2 = {
+  "database-source": "sql",
+  "dataspace-source": "sql",
+  "python-script": "pythonCode",
+  "excel-python": "pythonCode",
+  "sql-query": "sql",
+  condition: "pythonCode",
+  "data-quality-check": "dqPythonCode"
+};
+function sha12(text) {
+  return import_crypto2.default.createHash("sha1").update(text, "utf8").digest("hex");
+}
+function resolveNodeType2(node) {
+  if (node.type === "custom") {
+    return String(node.data?.type ?? "custom");
+  }
+  return String(node.type ?? "custom");
+}
+function codeLanguageForNodeType2(nodeType) {
+  if (["python-script", "excel-python", "condition", "data-quality-check"].includes(nodeType)) {
+    return "python";
+  }
+  if (["database-source", "dataspace-source", "sql-query"].includes(nodeType)) {
+    return "sql";
+  }
+  return void 0;
+}
+function codeFileExt2(language) {
+  if (language === "python") return "py";
+  if (language === "sql") return "sql";
+  return "txt";
+}
+function sanitizeName2(name) {
+  const cleaned = (name || "").replace(/[<>:"/\\|?*\x00-\x1f]/g, "_").trim().replace(/\s+/g, "_");
+  return cleaned || "node";
+}
+function readFlowJson2(flowDir) {
+  const raw = JSON.parse(import_fs6.default.readFileSync(import_path7.default.join(flowDir, FLOW_JSON2), "utf8"));
+  return {
+    nodes: Array.isArray(raw.nodes) ? raw.nodes : [],
+    edges: Array.isArray(raw.edges) ? raw.edges : []
+  };
+}
+function readMeta2(flowDir) {
+  const p = import_path7.default.join(flowDir, FLOW_META_JSON2);
+  if (!import_fs6.default.existsSync(p)) return void 0;
+  try {
+    return JSON.parse(import_fs6.default.readFileSync(p, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function isCodeNodeType(nodeType) {
+  return Boolean(NODE_TYPE_CODE_DATA_KEY2[nodeType]);
+}
+function listNodeDirs(flowDir) {
+  const nodesRoot = import_path7.default.join(flowDir, NODES_DIR2);
+  if (!import_fs6.default.existsSync(nodesRoot)) return [];
+  return import_fs6.default.readdirSync(nodesRoot).filter((n) => {
+    try {
+      return import_fs6.default.statSync(import_path7.default.join(nodesRoot, n)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+function findCodeFileInDir(dirAbs) {
+  if (!import_fs6.default.existsSync(dirAbs)) return void 0;
+  for (const f of import_fs6.default.readdirSync(dirAbs)) {
+    if (/^code\.(py|sql|txt)$/i.test(f)) return f;
+  }
+  return void 0;
+}
+function findDirForUuid(flowDir, uuid) {
+  const nodesRoot = import_path7.default.join(flowDir, NODES_DIR2);
+  for (const dirName of listNodeDirs(flowDir)) {
+    const infoPath = import_path7.default.join(nodesRoot, dirName, NODE_INFO_JSON2);
+    if (import_fs6.default.existsSync(infoPath)) {
+      try {
+        const info = JSON.parse(import_fs6.default.readFileSync(infoPath, "utf8"));
+        if (String(info.node_uuid ?? "") === uuid) return import_path7.default.posix.join(NODES_DIR2, dirName);
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function auditFlowWorkspace(flowDir) {
+  const warnings = [];
+  const doc = readFlowJson2(flowDir);
+  const meta = readMeta2(flowDir) ?? { nodes: {} };
+  const canvasNodeCount = doc.nodes.length;
+  let canvasCodeNodeCount = 0;
+  const missingInMeta = [];
+  const missingCodeFiles = [];
+  const flowUuids = /* @__PURE__ */ new Set();
+  for (const node of doc.nodes) {
+    const uuid = String(node.node_uuid ?? "").trim();
+    if (!uuid) continue;
+    flowUuids.add(uuid);
+    const nodeType = resolveNodeType2(node);
+    if (!isCodeNodeType(nodeType)) continue;
+    canvasCodeNodeCount++;
+    const label = String(node.data?.label ?? node.id ?? "");
+    const m = meta.nodes[uuid];
+    if (!m?.dir || !m.codeFile) {
+      missingInMeta.push({ uuid, nodeId: String(node.id ?? ""), nodeType, label });
+      continue;
+    }
+    const codePath = import_path7.default.join(flowDir, m.dir, m.codeFile);
+    if (!import_fs6.default.existsSync(codePath)) {
+      missingCodeFiles.push({ uuid, dir: m.dir, codeFile: m.codeFile });
+    }
+  }
+  const orphanInMeta = Object.keys(meta.nodes).filter((u) => !flowUuids.has(u));
+  let metaCodeIndexedCount = 0;
+  for (const m of Object.values(meta.nodes)) {
+    if (m.dir && m.codeFile) metaCodeIndexedCount++;
+  }
+  const unindexedDirs = [];
+  for (const dirName of listNodeDirs(flowDir)) {
+    const dirAbs = import_path7.default.join(flowDir, NODES_DIR2, dirName);
+    if (!findCodeFileInDir(dirAbs)) continue;
+    const rel = import_path7.default.posix.join(NODES_DIR2, dirName);
+    const indexed = Object.values(meta.nodes).some((m) => m.dir?.replace(/\\/g, "/") === rel);
+    if (!indexed) unindexedDirs.push(rel);
+  }
+  if (canvasCodeNodeCount !== metaCodeIndexedCount) {
+    warnings.push(
+      `\u753B\u5E03\u4EE3\u7801\u8282\u70B9 ${canvasCodeNodeCount} \u4E2A\uFF0Cmeta \u5DF2\u7D22\u5F15 ${metaCodeIndexedCount} \u4E2A\uFF08\u4E0D\u4E00\u81F4\u4F1A\u5BFC\u81F4 node push / \u8BBE\u8BA1\u5668\u6253\u5F00\u4EE3\u7801\u5931\u8D25\uFF09`
+    );
+  }
+  if (missingInMeta.length) {
+    warnings.push("\u90E8\u5206 flow.json \u4EE3\u7801\u8282\u70B9\u672A\u5199\u5165 flow.meta.json\uFF0C\u8BF7\u6267\u884C project repair-meta");
+  }
+  if (unindexedDirs.length) {
+    warnings.push(`\u5B58\u5728\u672A\u7D22\u5F15\u7684\u8282\u70B9\u76EE\u5F55\uFF1A${unindexedDirs.join(", ")}`);
+  }
+  const ok3 = missingInMeta.length === 0 && orphanInMeta.length === 0 && missingCodeFiles.length === 0 && unindexedDirs.length === 0 && canvasCodeNodeCount === metaCodeIndexedCount;
+  return {
+    ok: ok3,
+    canvasNodeCount,
+    canvasCodeNodeCount,
+    metaIndexedCount: Object.keys(meta.nodes).length,
+    metaCodeIndexedCount,
+    missingInMeta,
+    orphanInMeta,
+    missingCodeFiles,
+    unindexedDirs,
+    warnings
+  };
+}
+function writeNodeInfo(flowDir, node, uuid, nodeType, relDir, codeFile, language, strippedData) {
+  const abs = import_path7.default.join(flowDir, relDir);
+  import_fs6.default.writeFileSync(
+    import_path7.default.join(abs, NODE_INFO_JSON2),
+    JSON.stringify(
+      {
+        _readonly: `\u6B64\u6587\u4EF6\u7531 dazi-flow \u751F\u6210\uFF0C\u4EC5\u4F9B\u67E5\u770B\uFF1B\u7F16\u8F91\u4EE3\u7801\u8BF7\u6539 ${codeFile}\uFF0C\u914D\u7F6E\u6539 flow.json`,
+        node_uuid: uuid,
+        nodeId: String(node.id ?? ""),
+        nodeType,
+        label: String(node.data?.label ?? ""),
+        codeFile,
+        codeLanguage: language,
+        position: node.position,
+        data: strippedData
+      },
+      null,
+      2
+    ),
+    "utf8"
+  );
+}
+function repairFlowMeta(flowDir) {
+  const warnings = [];
+  const repairedUuids = [];
+  const wroteNodeInfo = [];
+  const doc = readFlowJson2(flowDir);
+  const meta = readMeta2(flowDir) ?? { flowId: null, flowName: import_path7.default.basename(flowDir), nodes: {} };
+  if (!meta.nodes) meta.nodes = {};
+  const usedDirNames = new Set(
+    Object.values(meta.nodes).map((m) => m.dir?.split("/").pop()).filter(Boolean)
+  );
+  for (const node of doc.nodes) {
+    const uuid = String(node.node_uuid ?? "").trim();
+    if (!uuid) continue;
+    const nodeType = resolveNodeType2(node);
+    const codeKey = NODE_TYPE_CODE_DATA_KEY2[nodeType];
+    const semanticId = String(node.id ?? "");
+    const label = String(node.data?.label ?? semanticId ?? nodeType);
+    let entry = meta.nodes[uuid];
+    if (!entry) {
+      entry = { nodeId: semanticId, nodeType };
+      meta.nodes[uuid] = entry;
+      repairedUuids.push(uuid);
+    } else {
+      entry.nodeId = semanticId || entry.nodeId;
+      entry.nodeType = nodeType;
+    }
+    if (!codeKey) continue;
+    let relDir = entry.dir?.replace(/\\/g, "/");
+    if (relDir && findCodeFileInDir(import_path7.default.join(flowDir, relDir))) {
+    } else {
+      relDir = findDirForUuid(flowDir, uuid);
+    }
+    if (!relDir) {
+      const byLabel = import_path7.default.posix.join(NODES_DIR2, sanitizeName2(label));
+      if (import_fs6.default.existsSync(import_path7.default.join(flowDir, byLabel)) && findCodeFileInDir(import_path7.default.join(flowDir, byLabel))) {
+        relDir = byLabel;
+      }
+    }
+    if (!relDir) {
+      let dirName = sanitizeName2(label);
+      if (usedDirNames.has(dirName)) dirName = `${dirName}_${uuid.slice(0, 6)}`;
+      usedDirNames.add(dirName);
+      relDir = import_path7.default.posix.join(NODES_DIR2, dirName);
+      import_fs6.default.mkdirSync(import_path7.default.join(flowDir, relDir), { recursive: true });
+      const lang = codeLanguageForNodeType2(nodeType);
+      const codeFile2 = `code.${codeFileExt2(lang)}`;
+      const template = nodeType === "excel-python" ? "# -*- coding: utf-8 -*-\n# Excel \u8282\u70B9\uFF1A\u753B\u5E03\u914D\u7F6E managed_file_id\uFF1B\u4EE3\u7801\u4F7F\u7528 excel_source_path\n" : lang === "sql" ? "-- \u8282\u70B9 SQL\nSELECT 1;\n" : "# -*- coding: utf-8 -*-\n";
+      if (!findCodeFileInDir(import_path7.default.join(flowDir, relDir))) {
+        import_fs6.default.writeFileSync(import_path7.default.join(flowDir, relDir, codeFile2), template, "utf8");
+        warnings.push(`\u5DF2\u4E3A ${uuid} \u521B\u5EFA\u7A7A\u4EE3\u7801\u6A21\u677F ${relDir}/${codeFile2}`);
+      }
+    }
+    const dirAbs = import_path7.default.join(flowDir, relDir);
+    const codeFile = findCodeFileInDir(dirAbs);
+    if (!codeFile) {
+      warnings.push(`\u8282\u70B9 ${uuid} \u76EE\u5F55 ${relDir} \u65E0 code.*\uFF0C\u8DF3\u8FC7\u4EE3\u7801\u7D22\u5F15`);
+      continue;
+    }
+    const language = codeLanguageForNodeType2(nodeType);
+    const code = import_fs6.default.readFileSync(import_path7.default.join(dirAbs, codeFile), "utf8");
+    entry.dir = relDir;
+    entry.codeFile = codeFile;
+    entry.codeLanguage = language;
+    entry.codeHash = sha12(code);
+    const strippedData = { ...node.data ?? {} };
+    delete strippedData[codeKey];
+    const infoPath = import_path7.default.join(dirAbs, NODE_INFO_JSON2);
+    if (!import_fs6.default.existsSync(infoPath)) {
+      writeNodeInfo(flowDir, node, uuid, nodeType, relDir, codeFile, language, strippedData);
+      wroteNodeInfo.push(relDir);
+    }
+    if (!repairedUuids.includes(uuid)) repairedUuids.push(uuid);
+  }
+  meta.graphFingerprint = "sha1:" + sha12(JSON.stringify({ nodes: doc.nodes, edges: doc.edges }));
+  import_fs6.default.writeFileSync(import_path7.default.join(flowDir, FLOW_META_JSON2), JSON.stringify(meta, null, 2), "utf8");
+  const okAfter = auditFlowWorkspace(flowDir).ok;
+  return {
+    ok: okAfter,
+    repairedUuids: [...new Set(repairedUuids)],
+    wroteNodeInfo,
+    warnings
+  };
+}
+function buildFlowConsistencyMarkdown(audit, localFilesSpecLink = "../../\u8D44\u6E90/docs/flow/local-files-spec.md") {
+  const lines = [
+    "## \u672C\u5730\u6587\u4EF6\u4E00\u81F4\u6027",
+    "",
+    "| \u6307\u6807 | \u6570\u91CF |",
+    "|------|------|",
+    `| \u753B\u5E03\u8282\u70B9\uFF08flow.json\uFF09 | ${audit.canvasNodeCount} |`,
+    `| \u753B\u5E03\u4EE3\u7801\u8282\u70B9\uFF08flow.json\uFF09 | ${audit.canvasCodeNodeCount} |`,
+    `| meta \u5DF2\u767B\u8BB0\u8282\u70B9 | ${audit.metaIndexedCount} |`,
+    `| meta \u5DF2\u7D22\u5F15\u4EE3\u7801\uFF08dir+codeFile\uFF09 | ${audit.metaCodeIndexedCount} |`,
+    ""
+  ];
+  if (audit.ok) {
+    lines.push("\u2705 **flow.json / flow.meta.json / \u8282\u70B9/ \u4E00\u81F4**\u3002\u8BBE\u8BA1\u5668\u53EF\u6B63\u5E38\u300C\u6253\u5F00\u4EE3\u7801\u300D\uFF0C`node push` \u53EF\u8BC6\u522B\u810F\u8282\u70B9\u3002", "");
+  } else {
+    lines.push("\u26A0\uFE0F **\u76EE\u5F55\u4E0D\u4E00\u81F4**\uFF08\u4F1A\u5BFC\u81F4\u8BBE\u8BA1\u5668\u627E\u4E0D\u5230\u4EE3\u7801\u3001\u6216 `node push` \u8DF3\u8FC7\uFF09\uFF1A", "");
+    if (audit.missingInMeta.length) {
+      lines.push("| uuid | \u8282\u70B9 | \u7C7B\u578B |");
+      lines.push("|------|------|------|");
+      for (const m of audit.missingInMeta) {
+        lines.push(`| \`${m.uuid.slice(0, 8)}\u2026\` | ${m.label || m.nodeId} | ${m.nodeType} |`);
+      }
+      lines.push("");
+    }
+    if (audit.unindexedDirs.length) {
+      lines.push(`- \u672A\u7D22\u5F15\u76EE\u5F55\uFF1A${audit.unindexedDirs.map((d) => `\`${d}\``).join(" ")}`);
+    }
+    if (audit.orphanInMeta.length) {
+      lines.push(`- meta \u591A\u4F59 uuid\uFF1A${audit.orphanInMeta.length} \u4E2A\uFF08flow.json \u4E2D\u5DF2\u4E0D\u5B58\u5728\uFF09`);
+    }
+    for (const w of audit.warnings) lines.push(`- ${w}`);
+    lines.push(
+      "",
+      "\u4FEE\u590D\uFF08\u5728\u6D41\u7A0B\u76EE\u5F55\uFF09\uFF1A",
+      "",
+      "```powershell",
+      "dazi flow project repair-meta --dir .",
+      "dazi flow project doctor --dir .",
+      "```",
+      "",
+      `\u8BE6\u89C1 [\u6D41\u7A0B\u672C\u5730\u6587\u4EF6\u89C4\u8303](${localFilesSpecLink})\u3002`,
+      ""
+    );
+  }
+  lines.push(
+    "## \u53D8\u66F4\u63D0\u4EA4\u547D\u4EE4\u77E9\u9635",
+    "",
+    "| \u6539\u4E86\u4EC0\u4E48 | \u547D\u4EE4 |",
+    "|----------|------|",
+    "| `managed_file_id`\u3001`output_variable_name`\u3001\u8FDE\u7EBF\u3001\u589E\u5220\u8282\u70B9 | `dazi flow project push --dir . --canvas` |",
+    "| `\u8282\u70B9/<\u540D>/code.py` \u6216 `code.sql` | `dazi flow node push --node <uuid> --dir .` |",
+    '| **\u65B0\u589E\u4EE3\u7801\u8282\u70B9** | `dazi flow node new --type <type> --dir . --label "<\u540D>"` \u2192 \u6539\u914D\u7F6E \u2192 `push --canvas` \u2192 \u5199 code \u2192 `node push` |',
+    "",
+    "> \u7981\u6B62\u53EA\u6539 `flow.json` \u800C\u4E0D\u66F4\u65B0 `flow.meta.json`\uFF08\u987B `node new` / `pull` / `repair-meta`\uFF09\u3002",
+    ""
+  );
+  return lines;
 }
 
 // src/shared/flowScaffoldDocs.ts
@@ -3812,7 +4142,9 @@ function buildDocsTable(anchor) {
     ["\u8282\u70B9\u4EE3\u7801\u7F16\u5199\u6307\u5357\uFF08\u542B SQL/Python \u793A\u4F8B\uFF09", "flow/node-code-guide.md"],
     ["Flow \u8FD0\u884C\u4E0E\u6D4B\u8BD5", "flow/run-guide.md"],
     ["\u6570\u636E\u6E90\u4E0E connectionId", "flow/source-guide.md"],
-    ["CLI \u8C03\u7528\u7EA6\u5B9A\uFF08`dazi.ps1`\uFF09", "guides/cli-invocation.md"]
+    ["**\u6D41\u7A0B\u672C\u5730\u6587\u4EF6\u89C4\u8303\uFF08AI \u5FC5\u8BFB\uFF09**", "flow/local-files-spec.md"],
+    ["\u6D41\u7A0B AI \u5DE5\u4F5C\u624B\u518C", "flow/ai-workflow-playbook.md"],
+    ["CLI \u8C03\u7528\u7EA6\u5B9A\uFF08`dazi` / `dazi.ps1`\uFF09", "guides/cli-invocation.md"]
   ];
   return [
     "## \u5E2E\u52A9\u6587\u6863",
@@ -3823,13 +4155,13 @@ function buildDocsTable(anchor) {
     "|------|------|",
     ...rows.map(([title, p]) => `| ${title} | [${p.split("/").pop()}](${flowDocsRel(anchor, p)}) |`),
     "",
-    "\u7EC8\u7AEF\u6253\u5F00\u6587\u6863\uFF08\u5728 **dazi-work \u6839**\uFF09\uFF1A",
+    "\u7EC8\u7AEF\u6253\u5F00\u6587\u6863\uFF08**dazi-work \u6839**\u6216\u5DF2 `cd` \u5230\u6D41\u7A0B\u76EE\u5F55\uFF09\uFF1A",
     "",
     "```powershell",
-    ".\\scripts\\dazi.ps1 docs open flow/flow-project-guide",
-    ".\\scripts\\dazi.ps1 docs open flow/variables-guide",
-    ".\\scripts\\dazi.ps1 docs open flow/node-code-guide",
-    ".\\scripts\\dazi.ps1 docs open flow/flows-guide",
+    psDaziLine("docs open flow/flow-project-guide"),
+    psDaziLine("docs open flow/variables-guide"),
+    psDaziLine("docs open flow/node-code-guide"),
+    psDaziLine("docs open flow/flows-guide"),
     "```",
     "",
     "**\u4EE3\u7801\u793A\u4F8B**\uFF1A\u53D8\u91CF\u8BFB\u5199\u3001`python-script` / `sql-query` \u6A21\u677F\u89C1 [\u8282\u70B9\u4EE3\u7801\u7F16\u5199\u6307\u5357](" + flowDocsRel(anchor, "flow/node-code-guide.md") + ") \u4E0E [\u6D41\u7A0B\u53D8\u91CF\u7CFB\u7EDF\u6307\u5357](" + flowDocsRel(anchor, "flow/variables-guide.md") + ")\u3002",
@@ -3837,7 +4169,7 @@ function buildDocsTable(anchor) {
   ];
 }
 function cliPrefix() {
-  return `\`${DAZI_PS1} flow\`\uFF08\u5728 **dazi-work \u6839**\uFF1B\u8FDB\u5165\u6D41\u7A0B\u76EE\u5F55\u540E\u53EF\u7528 \`flow\` \u5B50\u547D\u4EE4\u7701\u7565 \`--dir\`\uFF09`;
+  return `\`${DAZI_CLI} flow\`\uFF08\u5168\u5C40 CLI\uFF1B\u5728 **dazi-work \u6839** \u6216\u6D41\u7A0B\u76EE\u5F55\u52A0 \`--dir .\`\uFF1B\u672A\u88C5\u5168\u5C40\u65F6\u53EF\u7528 \`.scriptsdazi.ps1 flow\`\uFF09`;
 }
 function buildFlowQuickStartMarkdown(opts) {
   const folder = opts.projectFolder;
@@ -3875,7 +4207,7 @@ function buildFlowQuickStartMarkdown(opts) {
     "\u547D\u4EE4\u884C\uFF08`dazi-work` \u6839\uFF09\uFF1A",
     "",
     "```powershell",
-    `.\\scripts\\dazi.ps1 flow project pull --flow <flowId> --dir "\u9879\u76EE\\${folder}\\\u6D41\u7A0B\\<\u6D41\u7A0B\u540D>"`,
+    psFlowLine(`project pull --flow <flowId> --dir "\u9879\u76EE\\${folder}\\\u6D41\u7A0B\\<\u6D41\u7A0B\u540D>"`),
     "```",
     "",
     "\u62C9\u53D6\u540E\u6BCF\u4E2A\u6D41\u7A0B\u76EE\u5F55\u4F1A\u751F\u6210 **`\u5FEB\u901F\u542F\u52A8_<\u6D41\u7A0B\u540D>.md`**\uFF08\u542B flowId \u4E0E\u672C\u6D41\u7A0B\u5E38\u7528\u547D\u4EE4\uFF0C\u4FBF\u4E8E @ \u9644\u52A0\u7ED9 AI\uFF09\u3002",
@@ -3924,7 +4256,7 @@ function buildFlowsDirReadmeMarkdown(opts) {
     "",
     "```powershell",
     "# \u547D\u4EE4\u884C\u62C9\u53D6\uFF08dazi-work \u6839\uFF09",
-    `.\\scripts\\dazi.ps1 flow project pull --flow <id> --dir "\u9879\u76EE\\${opts.projectFolder}\\\u6D41\u7A0B\\<\u6D41\u7A0B\u540D>"`,
+    psFlowLine(`project pull --flow <id> --dir "\u9879\u76EE\\${opts.projectFolder}\\\u6D41\u7A0B\\<\u6D41\u7A0B\u540D>"`),
     "```",
     "",
     "\u62C9\u53D6\u5B8C\u6210\u540E\u8BF7\u9605\u8BFB\u5404\u6D41\u7A0B\u5B50\u76EE\u5F55\u4E0B\u7684 **`\u5FEB\u901F\u542F\u52A8_<\u6D41\u7A0B\u540D>.md`**\u3002",
@@ -3934,10 +4266,34 @@ function buildFlowsDirReadmeMarkdown(opts) {
 }
 function buildFlowDirQuickStartMarkdown(opts) {
   const name = opts.flowName;
-  const stats = opts.nodeCount != null ? `
-| \u8282\u70B9\u6570 | ${opts.nodeCount}${opts.codeNodeCount != null ? `\uFF08\u4EE3\u7801\u8282\u70B9 ${opts.codeNodeCount}\uFF09` : ""} |` : "";
+  let audit;
+  if (opts.flowDir) {
+    try {
+      audit = auditFlowWorkspace(opts.flowDir);
+    } catch {
+    }
+  }
+  const canvasN = audit?.canvasNodeCount ?? opts.nodeCount;
+  const codeN = audit?.canvasCodeNodeCount ?? opts.codeNodeCount;
+  const metaCodeN = audit?.metaCodeIndexedCount;
+  const statsParts = [];
+  if (canvasN != null) {
+    let line = `
+| \u753B\u5E03\u8282\u70B9\uFF08flow.json\uFF09 | ${canvasN}`;
+    if (codeN != null) line += `\uFF0C\u5176\u4E2D\u4EE3\u7801\u8282\u70B9 ${codeN}`;
+    line += " |";
+    statsParts.push(line);
+  }
+  if (metaCodeN != null && codeN != null && metaCodeN !== codeN) {
+    statsParts.push(`
+| meta \u5DF2\u7D22\u5F15\u4EE3\u7801 | ${metaCodeN} \u26A0\uFE0F \u4E0E\u753B\u5E03\u4E0D\u4E00\u81F4 |`);
+  } else if (metaCodeN != null) {
+    statsParts.push(`
+| meta \u5DF2\u7D22\u5F15\u4EE3\u7801 | ${metaCodeN} |`);
+  }
   const pulled = opts.pulledAt ? `
 | \u4E0A\u6B21\u62C9\u53D6 | ${opts.pulledAt} |` : "";
+  const consistencySection = audit ? buildFlowConsistencyMarkdown(audit, flowDocsRel("flow-dir", "flow/local-files-spec.md")) : [];
   return [
     SCAFFOLD_MARKER,
     "# \u5FEB\u901F\u542F\u52A8",
@@ -3949,27 +4305,28 @@ function buildFlowDirQuickStartMarkdown(opts) {
     "| \u5B57\u6BB5 | \u503C |",
     "|------|-----|",
     `| flowId | \`${opts.flowId}\` |`,
-    `| \u672C\u5730\u76EE\u5F55 | \`\u6D41\u7A0B/${name}/\` |${stats}${pulled}`,
+    `| \u672C\u5730\u76EE\u5F55 | \`\u6D41\u7A0B/${name}/\` |${statsParts.join("")}${pulled}`,
     "",
+    ...consistencySection,
     "## \u5E38\u7528\u547D\u4EE4",
     "",
-    "\u5728 **dazi-work \u6839**\uFF08\u6216\u5C06 `--dir` \u6307\u5411\u672C\u76EE\u5F55\uFF09\uFF1A",
+    "\u5728 **dazi-work \u6839**\uFF08\u6216\u5C06 `--dir` \u6307\u5411\u672C\u76EE\u5F55\uFF09\uFF1B\u9700\u5DF2\u5B89\u88C5\u5168\u5C40 CLI\uFF08`pnpm add -g @dazitech/cli`\uFF09\uFF1A",
     "",
     "```powershell",
     `cd "\u9879\u76EE\\${opts.projectFolder ?? "flow_<\u9879\u76EE\u540D>"}\\\u6D41\u7A0B\\${name}"`,
     "",
     "# \u72B6\u6001 / \u62C9\u53D6 / \u63D0\u4EA4",
-    `${DAZI_PS1} flow project status --dir .`,
-    `${DAZI_PS1} flow project pull --flow ${opts.flowId} --dir .`,
-    `${DAZI_PS1} flow project push --dir . --canvas`,
+    psFlowLine("project status --dir ."),
+    psFlowLine(`project pull --flow ${opts.flowId} --dir .`),
+    psFlowLine("project push --dir . --canvas"),
     "",
     "# \u5355\u8282\u70B9\u6D4B\u8BD5\uFF08uuid \u89C1 flow.meta.json \u6216 node.info.json\uFF09",
-    `${DAZI_PS1} flow run node-exec --node <node_uuid> --dir .`,
+    psFlowLine("run node-exec --node <node_uuid> --dir ."),
     "",
     "# \u6574\u6D41\u7A0B\u8C03\u8BD5 + \u53D8\u91CF",
-    `${DAZI_PS1} flow run flow-exec --dir . --type debug`,
-    `${DAZI_PS1} flow variable sync --dir .`,
-    `${DAZI_PS1} flow variable pull --name <output_variable_name> --dir .`,
+    psFlowLine("run flow-exec --dir . --type debug"),
+    psFlowLine("variable sync --dir ."),
+    psFlowLine("variable pull --name <output_variable_name> --dir ."),
     "```",
     "",
     ...buildFlowNodeCatalogQuickStartSection(flowDocsRel("flow-dir", "flow/flows-guide.md")),
@@ -3979,10 +4336,10 @@ function buildFlowDirQuickStartMarkdown(opts) {
     "",
     "### \u573A\u666F A\uFF1A\u65B0\u589E\u8282\u70B9\uFF08\u5DF2\u6709\u6D41\u7A0B\u7EE7\u7EED\u6539\uFF09",
     "",
-    "1. \u5148\u8BFB `flow.json` \u4E0E `flow.meta.json`\uFF0C\u786E\u8BA4\u5F53\u524D\u8282\u70B9\u4E0E\u8FDE\u7EBF",
-    `2. \u65B0\u5EFA\u8282\u70B9\uFF08\u907F\u514D\u4F2A\u9020 uuid\uFF09\uFF1A${mdFlowCmd('node new --type <node_type> --dir . --label "<\u8282\u70B9\u540D>"')}`,
+    "1. \u5148\u8BFB `flow.json` \u4E0E `flow.meta.json`\uFF0C\u6267\u884C `dazi flow project doctor --dir .`",
+    `2. **\u5FC5\u987B**\u7528 CLI \u65B0\u5EFA\u8282\u70B9\uFF08\u7981\u6B62\u624B\u6413 uuid\uFF09\uFF1A${mdFlowCmd('node new --type <node_type> --dir . --label "<\u8282\u70B9\u540D>"')}`,
     "3. \u5728 `flow.json` \u91CC\u8865 `nodes/edges`\uFF08\u9075\u5B88\u951A\u70B9\uFF1A`sourceHandle` \u4EC5 `r/b/true/false`\uFF0C`targetHandle` \u4EC5 `l/t`\uFF09",
-    "4. \u82E5\u662F\u4EE3\u7801\u8282\u70B9\uFF0C\u8865 `\u8282\u70B9/<\u540D>/code.sql|py`\uFF08type \u89C1\u4E0A\u6587 **\u53EF\u7528\u6D41\u7A0B\u8282\u70B9**\uFF09",
+    "4. \u7F16\u8F91 `\u8282\u70B9/<\u540D>/code.sql|py`\uFF08`node new` \u4F1A\u521B\u5EFA\u76EE\u5F55\u4E0E meta \u7D22\u5F15\uFF09",
     `5. \u5355\u8282\u70B9\u6D4B\u8BD5\uFF1A${mdFlowCmd("run node-exec --node <node_uuid> --dir .")}`,
     `6. \u63D0\u4EA4\u753B\u5E03\uFF08\u542B\u8FDE\u7EBF/\u914D\u7F6E\uFF09\uFF1A${mdFlowCmd("project push --dir . --canvas")}`,
     "",
@@ -4011,7 +4368,7 @@ function buildFlowDirQuickStartMarkdown(opts) {
     "",
     "| \u73B0\u8C61 | \u5E38\u89C1\u539F\u56E0 | \u4FEE\u590D |",
     "|------|----------|------|",
-    `| \u547D\u4EE4\u627E\u4E0D\u5230 | \u5728 dazi-work \u5916\u6267\u884C\uFF0C\u6216\u7528\u4E86\u65E7\u524D\u7F00 | \u5207\u5230 dazi-work \u6839\uFF0C\u4F7F\u7528 ${mdFlowCmd("...")} |`,
+    `| \u547D\u4EE4\u627E\u4E0D\u5230 | \u672A\u88C5\u5168\u5C40 CLI \u6216\u4E0D\u5728 dazi-work | \`pnpm add -g @dazitech/cli\` \u6216 ${mdFlowCmd("...")} / \`.scriptsdazi.ps1 flow ...\` |`,
     "| \u8282\u70B9\u6D4B\u8BD5\u62A5\u4E0A\u6E38\u53D8\u91CF\u4E0D\u5B58\u5728 | \u672A\u5148\u8FD0\u884C\u4E0A\u6E38\u8282\u70B9\u4EA7\u51FA\u53D8\u91CF | \u5148\u8DD1\u4E0A\u6E38\uFF0C\u6216\u6574\u6D41\u7A0B `flow run flow-exec --type debug` \u540E\u518D\u6D4B |",
     "| excel-python \u627E\u4E0D\u5230\u6587\u4EF6 | code.py \u5199\u4E86\u6587\u4EF6\u540D/\u672C\u5730\u8DEF\u5F84 | \u753B\u5E03\u914D `managed_file_id`\uFF08UUID\uFF09\uFF1B\u4EE3\u7801\u7528 `excel_source_path` |",
     "| Excel \u7528\u4E86 file-source | file-source \u4E0D\u89E3\u6790 xlsx | \u6539\u4E3A **`excel-python`** + `managed_file_id` |",
@@ -4078,7 +4435,7 @@ function buildFlowDirQuickStartMarkdown(opts) {
   ].join("\n");
 }
 function removeLegacyFlowDirQuickStartFiles(flowDir, currentFilename, fsImpl) {
-  const legacy = import_path7.default.join(flowDir, LEGACY_FLOW_DIR_QUICKSTART_FILENAME);
+  const legacy = import_path8.default.join(flowDir, LEGACY_FLOW_DIR_QUICKSTART_FILENAME);
   if (fsImpl.existsSync(legacy)) {
     try {
       if (isFlowScaffoldFile(fsImpl.readFileSync(legacy, "utf8"))) {
@@ -4090,7 +4447,7 @@ function removeLegacyFlowDirQuickStartFiles(flowDir, currentFilename, fsImpl) {
   for (const entry of fsImpl.readdirSync(flowDir)) {
     if (entry === currentFilename) continue;
     if (!/^快速启动_.+\.md$/.test(entry)) continue;
-    const full = import_path7.default.join(flowDir, entry);
+    const full = import_path8.default.join(flowDir, entry);
     try {
       if (isFlowScaffoldFile(fsImpl.readFileSync(full, "utf8"))) {
         fsImpl.unlinkSync(full);
@@ -4101,12 +4458,12 @@ function removeLegacyFlowDirQuickStartFiles(flowDir, currentFilename, fsImpl) {
 }
 function writeFlowDirQuickStartScaffold(flowDir, flowName, content, fsImpl) {
   const filename = flowDirQuickStartFilename(flowName);
-  writeScaffoldIfAllowed(import_path7.default.join(flowDir, filename), content, fsImpl);
+  writeScaffoldIfAllowed(import_path8.default.join(flowDir, filename), content, fsImpl);
   removeLegacyFlowDirQuickStartFiles(flowDir, filename, fsImpl);
   return filename;
 }
 function removeLegacyFlowDirScaffoldReadme(flowDir, fsImpl) {
-  const legacy = import_path7.default.join(flowDir, "README.md");
+  const legacy = import_path8.default.join(flowDir, "README.md");
   if (!fsImpl.existsSync(legacy)) return;
   try {
     if (isFlowScaffoldFile(fsImpl.readFileSync(legacy, "utf8"))) {
@@ -4127,17 +4484,17 @@ function writeScaffoldIfAllowed(filePath, content, fsImpl, opts) {
 }
 
 // cli/dazi-flow/src/lib/flowVariables.ts
-var import_fs6 = __toESM(require("fs"), 1);
-var import_path8 = __toESM(require("path"), 1);
+var import_fs7 = __toESM(require("fs"), 1);
+var import_path9 = __toESM(require("path"), 1);
 async function ensureFlowDebugRun(flowId) {
   return apiRequest(`${FLOW_API}/${flowId}/debug-run`);
 }
 function variablesDir(flowDir) {
-  return import_path8.default.join(flowDir, VARIABLES_DIR);
+  return import_path9.default.join(flowDir, VARIABLES_DIR);
 }
 function variableFilePath(flowDir, varName) {
   const safe = sanitizeName(varName) || "variable";
-  return import_path8.default.join(variablesDir(flowDir), `${safe}.json`);
+  return import_path9.default.join(variablesDir(flowDir), `${safe}.json`);
 }
 function collectDesignTimeVariableNames(flowDir) {
   const doc = readFlowJson(flowDir);
@@ -4151,9 +4508,9 @@ function collectDesignTimeVariableNames(flowDir) {
 }
 function writeVariableFile(flowDir, payload) {
   const dir = variablesDir(flowDir);
-  import_fs6.default.mkdirSync(dir, { recursive: true });
+  import_fs7.default.mkdirSync(dir, { recursive: true });
   const file = variableFilePath(flowDir, payload.name);
-  import_fs6.default.writeFileSync(file, JSON.stringify(payload, null, 2), "utf8");
+  import_fs7.default.writeFileSync(file, JSON.stringify(payload, null, 2), "utf8");
   return file;
 }
 async function fetchVariableDetail(variableId, previewLimit) {
@@ -4277,7 +4634,17 @@ async function syncAllVariables(flowId, flowDir, previewLimit = 10) {
 
 // cli/dazi-flow/src/commands/project.ts
 function resolveFlowDir(dir) {
-  return import_path9.default.resolve(dir ?? process.cwd());
+  return import_path10.default.resolve(dir ?? process.cwd());
+}
+function readLocalCanvasNodeCount(flowDir) {
+  const p = import_path10.default.join(flowDir, "flow.json");
+  if (!import_fs8.default.existsSync(p)) return 0;
+  try {
+    const doc = JSON.parse(import_fs8.default.readFileSync(p, "utf8"));
+    return Array.isArray(doc.nodes) ? doc.nodes.length : 0;
+  } catch {
+    return 0;
+  }
 }
 function inferProjectFolder(flowDir) {
   const norm = flowDir.replace(/\\/g, "/");
@@ -4286,41 +4653,42 @@ function inferProjectFolder(flowDir) {
 }
 function writeFlowPullScaffold(flowDir, meta) {
   const projectFolder = inferProjectFolder(flowDir) ?? "flow_<\u9879\u76EE\u540D>";
-  const flowName = meta.flowName || import_path9.default.basename(flowDir);
+  const flowName = meta.flowName || import_path10.default.basename(flowDir);
   const quickStart = buildFlowDirQuickStartMarkdown({
     flowName,
     flowId: meta.flowId,
     projectFolder,
     nodeCount: meta.nodeCount,
     codeNodeCount: meta.codeNodeCount,
-    pulledAt: (/* @__PURE__ */ new Date()).toISOString()
+    pulledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    flowDir
   });
-  writeFlowDirQuickStartScaffold(flowDir, flowName, quickStart, import_fs7.default);
-  removeLegacyFlowDirScaffoldReadme(flowDir, import_fs7.default);
-  const flowsDir = import_path9.default.dirname(flowDir);
-  if (import_path9.default.basename(flowsDir) === "\u6D41\u7A0B") {
+  writeFlowDirQuickStartScaffold(flowDir, flowName, quickStart, import_fs8.default);
+  removeLegacyFlowDirScaffoldReadme(flowDir, import_fs8.default);
+  const flowsDir = import_path10.default.dirname(flowDir);
+  if (import_path10.default.basename(flowsDir) === "\u6D41\u7A0B") {
     const flowsReadme = buildFlowsDirReadmeMarkdown({ projectFolder });
-    writeScaffoldIfAllowed(import_path9.default.join(flowsDir, "README.md"), flowsReadme, import_fs7.default, { upgradeLegacy: true });
-    const projectRoot = import_path9.default.dirname(flowsDir);
+    writeScaffoldIfAllowed(import_path10.default.join(flowsDir, "README.md"), flowsReadme, import_fs8.default, { upgradeLegacy: true });
+    const projectRoot = import_path10.default.dirname(flowsDir);
     const quickStart2 = buildFlowQuickStartMarkdown({ projectFolder });
-    writeScaffoldIfAllowed(import_path9.default.join(projectRoot, "\u5FEB\u901F\u542F\u52A8.md"), quickStart2, import_fs7.default, { upgradeLegacy: true });
+    writeScaffoldIfAllowed(import_path10.default.join(projectRoot, "\u5FEB\u901F\u542F\u52A8.md"), quickStart2, import_fs8.default, { upgradeLegacy: true });
   }
 }
 function makeProjectCommand() {
   const cmd = new Command("project").description("\u6D41\u7A0B\u9879\u76EE\u672C\u5730\u6587\u4EF6\u5316\uFF08\u62C9\u53D6/\u63D0\u4EA4/\u72B6\u6001\uFF09");
   cmd.command("init <name>").description("\u5728 \u9879\u76EE/flow_<name>/ \u521D\u59CB\u5316\u6D41\u7A0B\u9879\u76EE\u9AA8\u67B6").option("--root <dir>", "\u5DE5\u4F5C\u533A\u6839\uFF08\u9ED8\u8BA4 cwd\uFF09").option("--json", "\u8F93\u51FA JSON").action((name, opts) => {
     try {
-      const root = import_path9.default.resolve(opts.root ?? process.cwd());
+      const root = import_path10.default.resolve(opts.root ?? process.cwd());
       const folder = name.startsWith("flow_") ? name : `flow_${name}`;
-      const projectRoot = import_path9.default.join(root, "\u9879\u76EE", folder);
-      if (import_fs7.default.existsSync(projectRoot)) {
+      const projectRoot = import_path10.default.join(root, "\u9879\u76EE", folder);
+      if (import_fs8.default.existsSync(projectRoot)) {
         console.error(`\u9519\u8BEF: \u9879\u76EE\u76EE\u5F55\u5DF2\u5B58\u5728: ${projectRoot}`);
         process.exit(1);
       }
-      import_fs7.default.mkdirSync(import_path9.default.join(projectRoot, "\u6D41\u7A0B"), { recursive: true });
-      import_fs7.default.mkdirSync(import_path9.default.join(projectRoot, "\u89C4\u5212"), { recursive: true });
-      import_fs7.default.writeFileSync(
-        import_path9.default.join(projectRoot, "README.md"),
+      import_fs8.default.mkdirSync(import_path10.default.join(projectRoot, "\u6D41\u7A0B"), { recursive: true });
+      import_fs8.default.mkdirSync(import_path10.default.join(projectRoot, "\u89C4\u5212"), { recursive: true });
+      import_fs8.default.writeFileSync(
+        import_path10.default.join(projectRoot, "README.md"),
         `# ${name}
 
 \u6570\u636E\u6D41\u7A0B\u9879\u76EE\uFF08\u4E0D\u7ED1\u5B9A\u6570\u636E\u7A7A\u95F4/\u8FDE\u63A5\uFF09\u3002\u6D41\u7A0B\u4F4D\u4E8E \`\u6D41\u7A0B/\` \u76EE\u5F55\u3002
@@ -4330,14 +4698,14 @@ function makeProjectCommand() {
         "utf8"
       );
       writeScaffoldIfAllowed(
-        import_path9.default.join(projectRoot, "\u5FEB\u901F\u542F\u52A8.md"),
+        import_path10.default.join(projectRoot, "\u5FEB\u901F\u542F\u52A8.md"),
         buildFlowQuickStartMarkdown({ projectFolder: folder }),
-        import_fs7.default
+        import_fs8.default
       );
       writeScaffoldIfAllowed(
-        import_path9.default.join(projectRoot, "\u6D41\u7A0B", "README.md"),
+        import_path10.default.join(projectRoot, "\u6D41\u7A0B", "README.md"),
         buildFlowsDirReadmeMarkdown({ projectFolder: folder }),
-        import_fs7.default
+        import_fs8.default
       );
       console.log(`\u2705 \u6D41\u7A0B\u9879\u76EE\u5DF2\u521D\u59CB\u5316: ${projectRoot}`);
       ok({ projectRoot, folder });
@@ -4348,11 +4716,21 @@ function makeProjectCommand() {
   cmd.command("pull").description("\u4ECE\u5E73\u53F0\u62C9\u53D6\u6D41\u7A0B\u5FEB\u7167\u5E76\u62C6\u5206\u4E3A\u672C\u5730\u6587\u4EF6\uFF08flow.json + \u8282\u70B9/<\u540D>/code.*\uFF09").requiredOption("--flow <flowId>", "Flow ID").option("--dir <dir>", "\u6D41\u7A0B\u76EE\u5F55\uFF08\u9ED8\u8BA4 cwd\uFF09").option("--json", "\u8F93\u51FA JSON").action(async (opts) => {
     try {
       const flowDir = resolveFlowDir(opts.dir);
-      import_fs7.default.mkdirSync(flowDir, { recursive: true });
+      import_fs8.default.mkdirSync(flowDir, { recursive: true });
+      const localCount = readLocalCanvasNodeCount(flowDir);
+      const preAudit = localCount > 0 ? auditFlowWorkspace(flowDir) : null;
+      if (preAudit && !preAudit.ok) {
+        console.warn("\u26A0\uFE0F  flow.json \u4E0E flow.meta.json \u4E0D\u4E00\u81F4\uFF1Bpull \u5C06\u7528\u5E73\u53F0\u5FEB\u7167\u8986\u76D6 flow.json\u3002\u624B\u6539\u753B\u5E03\u672A push \u65F6\u53EF\u80FD\u4E22\u5931\uFF0C\u53EF\u5148 repair-meta \u6216 push --canvas\u3002");
+      }
       console.log(`\u6B63\u5728\u62C9\u53D6\u6D41\u7A0B\u5FEB\u7167: ${opts.flow} ...`);
       const snapshot = await apiRequest(`${FLOW_API}/${opts.flow}/snapshot`);
       const doc = extractDocument(snapshot);
       const { strippedDoc, nodeMetas } = splitDocumentToFiles(flowDir, doc);
+      if (localCount > strippedDoc.nodes.length) {
+        console.warn(
+          `\u26A0\uFE0F  \u672C\u5730\u753B\u5E03 ${localCount} \u4E2A\u8282\u70B9\uFF0C\u5E73\u53F0\u5FEB\u7167 ${strippedDoc.nodes.length} \u4E2A\uFF1Bpull \u5DF2\u8986\u76D6\u672C\u5730 flow.json\u3002\u82E5\u672C\u5730\u66F4\u65B0\u5C1A\u672A\u63D0\u4EA4\uFF0C\u8BF7\u52FF\u518D pull\uFF0C\u5E94\u5148 project push --canvas\u3002`
+        );
+      }
       const flowMeta = snapshot.flow_meta ?? {};
       const meta = {
         flowId: opts.flow,
@@ -4365,7 +4743,7 @@ function makeProjectCommand() {
       const codeNodes = Object.values(nodeMetas).filter((m) => m.codeFile).length;
       writeFlowPullScaffold(flowDir, {
         flowId: opts.flow,
-        flowName: String(flowMeta.name ?? import_path9.default.basename(flowDir)),
+        flowName: String(flowMeta.name ?? import_path10.default.basename(flowDir)),
         nodeCount: strippedDoc.nodes.length,
         codeNodeCount: codeNodes
       });
@@ -4461,12 +4839,64 @@ function makeProjectCommand() {
       handleError(err);
     }
   });
+  cmd.command("doctor").description("\u68C0\u67E5 flow.json / flow.meta.json / \u8282\u70B9/ \u4E00\u81F4\u6027").option("--dir <dir>", "\u6D41\u7A0B\u76EE\u5F55\uFF08\u9ED8\u8BA4 cwd\uFF09").option("--json", "\u8F93\u51FA JSON").action((opts) => {
+    try {
+      const flowDir = resolveFlowDir(opts.dir);
+      const audit = auditFlowWorkspace(flowDir);
+      if (!opts.json) {
+        console.log(`\u6D41\u7A0B\u76EE\u5F55: ${flowDir}`);
+        console.log(audit.ok ? "\u2705 \u672C\u5730\u6587\u4EF6\u4E00\u81F4" : "\u26A0\uFE0F  \u5B58\u5728\u4E0D\u4E00\u81F4\u9879");
+        for (const w of audit.warnings) console.log(`  - ${w}`);
+        if (!audit.ok) {
+          console.log("\n\u4FEE\u590D: dazi flow project repair-meta --dir .");
+          console.log("\u8BF4\u660E: \u8D44\u6E90/docs/flow/local-files-spec.md");
+        }
+      }
+      ok(audit);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("repair-meta").description("\u6839\u636E flow.json \u4E0E \u8282\u70B9/ \u76EE\u5F55\u4FEE\u590D flow.meta.json\uFF08\u53CA node.info.json\uFF09").option("--dir <dir>", "\u6D41\u7A0B\u76EE\u5F55\uFF08\u9ED8\u8BA4 cwd\uFF09").option("--json", "\u8F93\u51FA JSON").action((opts) => {
+    try {
+      const flowDir = resolveFlowDir(opts.dir);
+      const result = repairFlowMeta(flowDir);
+      const meta = readMeta(flowDir);
+      if (meta?.flowId) {
+        const audit = auditFlowWorkspace(flowDir);
+        writeFlowPullScaffold(flowDir, {
+          flowId: String(meta.flowId),
+          flowName: meta.flowName || import_path10.default.basename(flowDir),
+          nodeCount: audit.canvasNodeCount,
+          codeNodeCount: audit.canvasCodeNodeCount,
+          pulledAt: meta.lastPulledAt,
+          flowDir
+        });
+        if (!opts.json) console.log("   \u5DF2\u66F4\u65B0 \u5FEB\u901F\u542F\u52A8_*.md\uFF08\u542B\u4E00\u81F4\u6027\u7EDF\u8BA1\uFF09");
+      }
+      if (!opts.json) {
+        console.log(`\u6D41\u7A0B\u76EE\u5F55: ${flowDir}`);
+        if (result.repairedUuids.length) {
+          console.log(`\u2705 \u5DF2\u4FEE\u590D meta \u7D22\u5F15: ${result.repairedUuids.join(", ")}`);
+        } else {
+          console.log("\uFF08meta \u65E0\u9700\u53D8\u66F4\uFF09");
+        }
+        for (const p of result.wroteNodeInfo) console.log(`  + node.info.json \u2192 ${p}`);
+        for (const w of result.warnings) console.log(`  \u26A0 ${w}`);
+        const audit = auditFlowWorkspace(flowDir);
+        console.log(audit.ok ? "\u2705 doctor \u68C0\u67E5\u901A\u8FC7" : "\u26A0\uFE0F  \u4ECD\u6709\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u67E5\u770B doctor \u8F93\u51FA");
+      }
+      ok(result);
+    } catch (err) {
+      handleError(err);
+    }
+  });
   return cmd;
 }
 
 // cli/dazi-flow/src/commands/node.ts
-var import_path10 = __toESM(require("path"), 1);
-var import_fs8 = __toESM(require("fs"), 1);
+var import_path11 = __toESM(require("path"), 1);
+var import_fs9 = __toESM(require("fs"), 1);
 var NODE_TYPE_REQUIRED = {
   "database-source": ["connectionId", "sql"],
   "database-sink": ["connectionId", "tableName"],
@@ -4498,7 +4928,7 @@ var NODE_TYPE_LABELS = {
   "folder-resource-register": "\u8D44\u6E90\u6CE8\u518C"
 };
 function resolveFlowDir2(dir) {
-  return import_path10.default.resolve(dir ?? process.cwd());
+  return import_path11.default.resolve(dir ?? process.cwd());
 }
 function requireMeta(flowDir) {
   const meta = readMeta(flowDir);
@@ -4584,19 +5014,19 @@ function makeNodeCommand() {
         data: created.data ?? {}
       };
       doc.nodes.push(stripped);
-      import_fs8.default.writeFileSync(import_path10.default.join(flowDir, FLOW_JSON), JSON.stringify(doc, null, 2), "utf8");
+      import_fs9.default.writeFileSync(import_path11.default.join(flowDir, FLOW_JSON), JSON.stringify(doc, null, 2), "utf8");
       const nodeMeta = { nodeId: String(created.id ?? ""), nodeType: opts.type };
       const codeKey = NODE_TYPE_CODE_DATA_KEY[opts.type];
       if (codeKey) {
         const language = codeLanguageForNodeType(opts.type);
         const ext = codeFileExt(language);
         const dirName = sanitizeName(opts.label || String(created.id ?? "") || opts.type);
-        const nodeDirAbs = import_path10.default.join(flowDir, NODES_DIR, dirName);
-        import_fs8.default.mkdirSync(nodeDirAbs, { recursive: true });
+        const nodeDirAbs = import_path11.default.join(flowDir, NODES_DIR, dirName);
+        import_fs9.default.mkdirSync(nodeDirAbs, { recursive: true });
         const codeFile = `code.${ext}`;
         const template = CODE_TEMPLATES[language ?? ""] ?? "";
-        import_fs8.default.writeFileSync(import_path10.default.join(nodeDirAbs, codeFile), template, "utf8");
-        nodeMeta.dir = import_path10.default.posix.join(NODES_DIR, dirName);
+        import_fs9.default.writeFileSync(import_path11.default.join(nodeDirAbs, codeFile), template, "utf8");
+        nodeMeta.dir = import_path11.default.posix.join(NODES_DIR, dirName);
         nodeMeta.codeFile = codeFile;
         nodeMeta.codeLanguage = language;
         nodeMeta.codeHash = sha1(template);
@@ -4616,11 +5046,11 @@ function makeNodeCommand() {
 }
 
 // cli/dazi-flow/src/commands/run.ts
-var import_path12 = __toESM(require("path"), 1);
+var import_path13 = __toESM(require("path"), 1);
 
 // cli/dazi-flow/src/lib/flowRun.ts
-var import_fs9 = __toESM(require("fs"), 1);
-var import_path11 = __toESM(require("path"), 1);
+var import_fs10 = __toESM(require("fs"), 1);
+var import_path12 = __toESM(require("path"), 1);
 function classifyError(text) {
   const t = (text || "").toLowerCase();
   if (/(变量|variable).*(不存在|未找到|missing|not found|undefined)|缺少.*输入|no.*input|上游/.test(t)) {
@@ -4650,16 +5080,16 @@ function classifyError(text) {
   return { category: "\u672A\u77E5", hint: "\u8BF7\u67E5\u770B\u5B8C\u6574 traceback \u4E0E\u65E5\u5FD7\u3002" };
 }
 function runDir(flowDir) {
-  const d = import_path11.default.join(flowDir, RUN_DIR);
-  import_fs9.default.mkdirSync(d, { recursive: true });
+  const d = import_path12.default.join(flowDir, RUN_DIR);
+  import_fs10.default.mkdirSync(d, { recursive: true });
   return d;
 }
 function safeBase(name) {
   return (name || "run").replace(/[<>:"/\\|?*\x00-\x1f]/g, "_").trim() || "run";
 }
 function writeLastRun(flowDir, base, payload) {
-  const p = import_path11.default.join(runDir(flowDir), `${safeBase(base)}.last-run.json`);
-  import_fs9.default.writeFileSync(p, JSON.stringify(payload, null, 2), "utf8");
+  const p = import_path12.default.join(runDir(flowDir), `${safeBase(base)}.last-run.json`);
+  import_fs10.default.writeFileSync(p, JSON.stringify(payload, null, 2), "utf8");
   return p;
 }
 function writeErrorMarkdown(flowDir, base, input) {
@@ -4696,8 +5126,8 @@ function writeErrorMarkdown(flowDir, base, input) {
   if (input.failureBundle != null) {
     lines.push("## FailureBundle", "", "```json", JSON.stringify(input.failureBundle, null, 2), "```", "");
   }
-  const p = import_path11.default.join(runDir(flowDir), `${safeBase(base)}.last-error.md`);
-  import_fs9.default.writeFileSync(p, lines.join("\n"), "utf8");
+  const p = import_path12.default.join(runDir(flowDir), `${safeBase(base)}.last-error.md`);
+  import_fs10.default.writeFileSync(p, lines.join("\n"), "utf8");
   return p;
 }
 var RUNNING_STATES = /* @__PURE__ */ new Set(["running", "pending", "queued", "debugging", "created", "init"]);
@@ -4830,15 +5260,15 @@ function writeRunProgressMarkdown(flowDir, base, snap, runId) {
       }
     }
   }
-  const p = import_path11.default.join(runDir(flowDir), `${safeBase(base)}.last-run.md`);
-  import_fs9.default.writeFileSync(p, lines.join("\n"), "utf8");
+  const p = import_path12.default.join(runDir(flowDir), `${safeBase(base)}.last-run.md`);
+  import_fs10.default.writeFileSync(p, lines.join("\n"), "utf8");
   return p;
 }
 
 // cli/dazi-flow/src/commands/run.ts
 var FLOW_API2 = "/api/data-pipelines/v1/flows";
 function resolveFlowDir3(dir) {
-  return import_path12.default.resolve(dir ?? process.cwd());
+  return import_path13.default.resolve(dir ?? process.cwd());
 }
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
@@ -5013,7 +5443,7 @@ function makeRunCommand() {
         console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u8282\u70B9 ${opts.node} \u7684\u8BED\u4E49 id\uFF08meta.nodeId\uFF09`);
         process.exit(1);
       }
-      const base = nodeMeta?.dir ? import_path12.default.basename(nodeMeta.dir) : nodeId;
+      const base = nodeMeta?.dir ? import_path13.default.basename(nodeMeta.dir) : nodeId;
       await apiRequest(`${FLOW_API2}/${flowId}/debug-run`);
       const result = await apiRequest(
         `${FLOW_API2}/${flowId}/nodes/${encodeURIComponent(nodeId)}/run`,
@@ -5178,8 +5608,8 @@ function makeRunCommand() {
 }
 
 // cli/dazi-flow/src/commands/source.ts
-var import_path13 = __toESM(require("path"), 1);
-var import_fs10 = __toESM(require("fs"), 1);
+var import_path14 = __toESM(require("path"), 1);
+var import_fs11 = __toESM(require("fs"), 1);
 function makeSourceCommand() {
   const cmd = new Command("source").description("\u6570\u636E\u6E90\u7BA1\u7406");
   cmd.command("list").description("\u5217\u51FA\u6570\u636E\u6E90").option("--space <spaceId>", "\u7A7A\u95F4 ID").option("--json", "\u8F93\u51FA JSON").action(async (opts) => {
@@ -5253,10 +5683,10 @@ function makeSourceCommand() {
         `/api/connections/${sourceId}/tables${qs}`
       );
       const ws = resolveWorkspace();
-      const dataDir = import_path13.default.join(ws.flows, opts.flow, "data");
-      if (!import_fs10.default.existsSync(dataDir)) import_fs10.default.mkdirSync(dataDir, { recursive: true });
-      const outFile = import_path13.default.join(dataDir, `${tableName}.schema.json`);
-      import_fs10.default.writeFileSync(outFile, JSON.stringify({
+      const dataDir = import_path14.default.join(ws.flows, opts.flow, "data");
+      if (!import_fs11.default.existsSync(dataDir)) import_fs11.default.mkdirSync(dataDir, { recursive: true });
+      const outFile = import_path14.default.join(dataDir, `${tableName}.schema.json`);
+      import_fs11.default.writeFileSync(outFile, JSON.stringify({
         sourceId,
         tableName,
         schema: opts.schema,
@@ -5330,8 +5760,8 @@ function makeDataspaceCommand() {
 }
 
 // cli/dazi-flow/src/commands/plan.ts
-var import_path14 = __toESM(require("path"), 1);
-var import_fs11 = __toESM(require("fs"), 1);
+var import_path15 = __toESM(require("path"), 1);
+var import_fs12 = __toESM(require("fs"), 1);
 function makePlanCommand() {
   const cmd = new Command("plan").description("Flow \u6267\u884C\u8BA1\u5212");
   cmd.command("compile <flowId>").alias("generate").description("\u7F16\u8BD1/\u751F\u6210 Flow \u6267\u884C\u8BA1\u5212").option("--out <file>", "\u8F93\u51FA\u6587\u4EF6\uFF08\u9ED8\u8BA4 flows/<flowId>/plans/plan.json\uFF09").option("--input <json>", "\u8F93\u5165\u53C2\u6570 JSON", "{}").option("--json", "\u8F93\u51FA JSON").action(async (flowId, opts) => {
@@ -5342,10 +5772,10 @@ function makePlanCommand() {
         { method: "POST", body: { input } }
       );
       const ws = resolveWorkspace();
-      const outFile = opts.out ?? import_path14.default.join(ws.flows, flowId, "plans", "plan.json");
-      const outDir = import_path14.default.dirname(outFile);
-      if (!import_fs11.default.existsSync(outDir)) import_fs11.default.mkdirSync(outDir, { recursive: true });
-      import_fs11.default.writeFileSync(outFile, JSON.stringify(plan, null, 2), "utf-8");
+      const outFile = opts.out ?? import_path15.default.join(ws.flows, flowId, "plans", "plan.json");
+      const outDir = import_path15.default.dirname(outFile);
+      if (!import_fs12.default.existsSync(outDir)) import_fs12.default.mkdirSync(outDir, { recursive: true });
+      import_fs12.default.writeFileSync(outFile, JSON.stringify(plan, null, 2), "utf-8");
       if (opts.json) {
         console.log(JSON.stringify(plan, null, 2));
       } else {
@@ -5359,12 +5789,12 @@ function makePlanCommand() {
   cmd.command("apply <flowId>").description("\u5C06\u672C\u5730\u8BA1\u5212\u6587\u4EF6\u63A8\u9001\u5230\u5E73\u53F0\u5E76\u5E94\u7528").option("--file <path>", "\u8BA1\u5212\u6587\u4EF6\uFF08\u9ED8\u8BA4 flows/<flowId>/plans/plan.json\uFF09").option("--dry-run", "\u4EC5\u9A8C\u8BC1\uFF0C\u4E0D\u5B9E\u9645\u5E94\u7528").action(async (flowId, opts) => {
     try {
       const ws = resolveWorkspace();
-      const planFile = opts.file ?? import_path14.default.join(ws.flows, flowId, "plans", "plan.json");
-      if (!import_fs11.default.existsSync(planFile)) {
+      const planFile = opts.file ?? import_path15.default.join(ws.flows, flowId, "plans", "plan.json");
+      if (!import_fs12.default.existsSync(planFile)) {
         console.error(`\u8BA1\u5212\u6587\u4EF6\u4E0D\u5B58\u5728: ${planFile}\uFF0C\u8BF7\u5148\u6267\u884C plan compile`);
         process.exit(1);
       }
-      const plan = JSON.parse(import_fs11.default.readFileSync(planFile, "utf-8"));
+      const plan = JSON.parse(import_fs12.default.readFileSync(planFile, "utf-8"));
       const endpoint = opts.dryRun ? `/api/data-pipelines/v1/flows/${flowId}/validate` : `/api/data-pipelines/v1/apply-plan`;
       const result = await apiRequest(endpoint, { method: "POST", body: plan });
       console.log(`\u2705 ${opts.dryRun ? "\u8BA1\u5212\u9A8C\u8BC1\u901A\u8FC7" : "\u8BA1\u5212\u5DF2\u5E94\u7528"}`);
@@ -5379,10 +5809,10 @@ function makePlanCommand() {
         `/api/data-pipelines/v1/flows/${flowId}/snapshot`
       );
       const ws = resolveWorkspace();
-      const outFile = opts.out ?? import_path14.default.join(ws.flows, flowId, "plans", `plan-${opts.type}.md`);
-      const outDir = import_path14.default.dirname(outFile);
-      if (!import_fs11.default.existsSync(outDir)) import_fs11.default.mkdirSync(outDir, { recursive: true });
-      import_fs11.default.writeFileSync(outFile, doc.content, "utf-8");
+      const outFile = opts.out ?? import_path15.default.join(ws.flows, flowId, "plans", `plan-${opts.type}.md`);
+      const outDir = import_path15.default.dirname(outFile);
+      if (!import_fs12.default.existsSync(outDir)) import_fs12.default.mkdirSync(outDir, { recursive: true });
+      import_fs12.default.writeFileSync(outFile, doc.content, "utf-8");
       console.log(`\u2705 Markdown \u6587\u6863\u5DF2\u4FDD\u5B58: ${outFile}`);
       ok({ flowId, file: outFile });
     } catch (err) {
@@ -5395,10 +5825,10 @@ function makePlanCommand() {
         `/api/data-pipelines/v1/dq-ai-code-prompt`
       );
       const ws = resolveWorkspace();
-      const outFile = opts.out ?? import_path14.default.join(ws.flows, flowId, "plans", "llm-guide.md");
-      const outDir = import_path14.default.dirname(outFile);
-      if (!import_fs11.default.existsSync(outDir)) import_fs11.default.mkdirSync(outDir, { recursive: true });
-      import_fs11.default.writeFileSync(outFile, guide.content, "utf-8");
+      const outFile = opts.out ?? import_path15.default.join(ws.flows, flowId, "plans", "llm-guide.md");
+      const outDir = import_path15.default.dirname(outFile);
+      if (!import_fs12.default.existsSync(outDir)) import_fs12.default.mkdirSync(outDir, { recursive: true });
+      import_fs12.default.writeFileSync(outFile, guide.content, "utf-8");
       console.log(`\u2705 LLM \u5F15\u5BFC\u6587\u6863\u5DF2\u4FDD\u5B58: ${outFile}`);
       ok({ flowId, file: outFile });
     } catch (err) {
@@ -5411,11 +5841,11 @@ function makePlanCommand() {
         `/api/data-pipelines/v1/compile-plan`
       );
       const ws = resolveWorkspace();
-      const outDir = opts.out ?? import_path14.default.join(ws.flows, flowId, "plans", "db");
-      if (!import_fs11.default.existsSync(outDir)) import_fs11.default.mkdirSync(outDir, { recursive: true });
+      const outDir = opts.out ?? import_path15.default.join(ws.flows, flowId, "plans", "db");
+      if (!import_fs12.default.existsSync(outDir)) import_fs12.default.mkdirSync(outDir, { recursive: true });
       for (const f of scaffold.files ?? []) {
-        const outFile = import_path14.default.join(outDir, f.name);
-        import_fs11.default.writeFileSync(outFile, f.content, "utf-8");
+        const outFile = import_path15.default.join(outDir, f.name);
+        import_fs12.default.writeFileSync(outFile, f.content, "utf-8");
         console.log(`  \u2192 ${outFile}`);
       }
       console.log(`\u2705 \u6570\u636E\u5E93\u811A\u624B\u67B6\u5DF2\u751F\u6210\uFF08${scaffold.files?.length ?? 0} \u4E2A\u6587\u4EF6\uFF09`);
@@ -5428,8 +5858,8 @@ function makePlanCommand() {
 }
 
 // cli/dazi-flow/src/commands/file.ts
-var import_path15 = __toESM(require("path"), 1);
-var import_fs12 = __toESM(require("fs"), 1);
+var import_path16 = __toESM(require("path"), 1);
+var import_fs13 = __toESM(require("fs"), 1);
 function makeFileCommand() {
   const cmd = new Command("file").description("\u5E73\u53F0\u6258\u7BA1\u6587\u4EF6\u7BA1\u7406");
   cmd.command("list").description("\u5217\u51FA\u5E73\u53F0\u6587\u4EF6").option("--space <spaceId>", "\u7A7A\u95F4 ID").option("--dir <dir>", "\u76EE\u5F55\u8DEF\u5F84\u524D\u7F00").option("--json", "\u8F93\u51FA JSON").action(async (opts) => {
@@ -5474,13 +5904,13 @@ function makeFileCommand() {
   });
   cmd.command("upload <localFile>").description("\u4E0A\u4F20\u672C\u5730\u6587\u4EF6\u5230\u5E73\u53F0").option("--space <spaceId>", "\u7A7A\u95F4 ID").option("--remote-path <path>", "\u8FDC\u7AEF\u8DEF\u5F84\uFF08\u9ED8\u8BA4\u4E0E\u6587\u4EF6\u540D\u76F8\u540C\uFF09").option("--overwrite", "\u8986\u76D6\u5DF2\u5B58\u5728\u6587\u4EF6").action(async (localFile, opts) => {
     try {
-      const filePath = import_path15.default.resolve(localFile);
-      if (!import_fs12.default.existsSync(filePath)) {
+      const filePath = import_path16.default.resolve(localFile);
+      if (!import_fs13.default.existsSync(filePath)) {
         console.error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`);
         process.exit(1);
       }
-      const content = import_fs12.default.readFileSync(filePath);
-      const remotePath = opts.remotePath ?? import_path15.default.basename(filePath);
+      const content = import_fs13.default.readFileSync(filePath);
+      const remotePath = opts.remotePath ?? import_path16.default.basename(filePath);
       const endpoint = opts.space ? `/api/v1/spaces/${opts.space}/files/upload` : "/api/v1/files/upload";
       const result = await apiRequest(endpoint, {
         method: "POST",
@@ -5506,16 +5936,16 @@ function makeFileCommand() {
       const content = data.encoding === "base64" ? Buffer.from(data.content, "base64") : Buffer.from(data.content, "utf-8");
       let outFile;
       if (opts.out) {
-        outFile = import_path15.default.resolve(opts.out);
+        outFile = import_path16.default.resolve(opts.out);
       } else if (opts.flow) {
         const ws = resolveWorkspace();
-        const dataDir = import_path15.default.join(ws.flows, opts.flow, "data");
-        if (!import_fs12.default.existsSync(dataDir)) import_fs12.default.mkdirSync(dataDir, { recursive: true });
-        outFile = import_path15.default.join(dataDir, import_path15.default.basename(remotePath));
+        const dataDir = import_path16.default.join(ws.flows, opts.flow, "data");
+        if (!import_fs13.default.existsSync(dataDir)) import_fs13.default.mkdirSync(dataDir, { recursive: true });
+        outFile = import_path16.default.join(dataDir, import_path16.default.basename(remotePath));
       } else {
-        outFile = import_path15.default.join(process.cwd(), import_path15.default.basename(remotePath));
+        outFile = import_path16.default.join(process.cwd(), import_path16.default.basename(remotePath));
       }
-      import_fs12.default.writeFileSync(outFile, content);
+      import_fs13.default.writeFileSync(outFile, content);
       console.log(`\u2705 \u5DF2\u4E0B\u8F7D: ${outFile}`);
       ok({ remotePath, localFile: outFile });
     } catch (err) {
@@ -5526,28 +5956,28 @@ function makeFileCommand() {
 }
 
 // cli/dazi-flow/src/commands/data.ts
-var import_path16 = __toESM(require("path"), 1);
-var import_fs13 = __toESM(require("fs"), 1);
+var import_path17 = __toESM(require("path"), 1);
+var import_fs14 = __toESM(require("fs"), 1);
 function makeDataCommand() {
   const cmd = new Command("data").description("Flow \u6570\u636E\u4E0A\u4F20");
   cmd.command("upload <localFile>").description("\u5C06\u672C\u5730\u6570\u636E\u6587\u4EF6\u4E0A\u4F20\u5230\u5E73\u53F0\uFF08CSV / JSON / Parquet\uFF09").option("--space <spaceId>", "\u76EE\u6807\u7A7A\u95F4 ID").option("--flow <flowId>", "\u5173\u8054 Flow ID\uFF08\u5199\u5165 flows/<flowId> \u5143\u6570\u636E\uFF09").option("--table <name>", "\u76EE\u6807\u8868\u540D\uFF08\u82E5\u5E73\u53F0\u652F\u6301\u76F4\u63A5\u5199\u8868\uFF09").option("--overwrite", "\u8986\u76D6\u5DF2\u6709\u6570\u636E").option("--json", "\u8F93\u51FA JSON").action(async (localFile, opts) => {
     try {
-      const filePath = import_path16.default.resolve(localFile);
-      if (!import_fs13.default.existsSync(filePath)) {
+      const filePath = import_path17.default.resolve(localFile);
+      if (!import_fs14.default.existsSync(filePath)) {
         console.error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`);
         process.exit(1);
       }
-      const ext = import_path16.default.extname(filePath).toLowerCase();
+      const ext = import_path17.default.extname(filePath).toLowerCase();
       const supportedExts = [".csv", ".json", ".jsonl", ".parquet", ".tsv"];
       if (!supportedExts.includes(ext)) {
         console.error(`\u4E0D\u652F\u6301\u7684\u6587\u4EF6\u683C\u5F0F: ${ext}\uFF08\u652F\u6301: ${supportedExts.join(", ")}\uFF09`);
         process.exit(1);
       }
-      const content = import_fs13.default.readFileSync(filePath);
+      const content = import_fs14.default.readFileSync(filePath);
       const body = {
         content: content.toString("base64"),
         encoding: "base64",
-        fileName: import_path16.default.basename(filePath),
+        fileName: import_path17.default.basename(filePath),
         format: ext.slice(1),
         overwrite: opts.overwrite ?? false
       };
@@ -5575,9 +6005,9 @@ function makeDataCommand() {
 }
 
 // cli/dazi-flow/src/commands/variable.ts
-var import_path17 = __toESM(require("path"), 1);
+var import_path18 = __toESM(require("path"), 1);
 function resolveFlowDir4(dir) {
-  return import_path17.default.resolve(dir ?? process.cwd());
+  return import_path18.default.resolve(dir ?? process.cwd());
 }
 function requireFlowId(flowDir) {
   const meta = readMeta(flowDir);
@@ -5596,7 +6026,7 @@ function makeVariableCommand() {
       const previewLimit = Math.max(1, Math.min(100, parseInt(opts.limit, 10) || 10));
       if (!opts.json) console.log(`\u6B63\u5728\u540C\u6B65\u53D8\u91CF\uFF08flowId=${flowId}\uFF09\u2026`);
       const result = await syncAllVariables(flowId, flowDir, previewLimit);
-      if (!opts.json) console.log(`\u2705 \u5DF2\u540C\u6B65 ${result.count} \u4E2A\u53D8\u91CF \u2192 ${import_path17.default.join(flowDir, "\u53D8\u91CF")}`);
+      if (!opts.json) console.log(`\u2705 \u5DF2\u540C\u6B65 ${result.count} \u4E2A\u53D8\u91CF \u2192 ${import_path18.default.join(flowDir, "\u53D8\u91CF")}`);
       ok({ flowId, flowDir, ...result });
     } catch (err) {
       handleError(err);
@@ -5811,12 +6241,12 @@ function makeMcpCommand() {
 }
 
 // cli/dazi-flow/src/commands/managedFiles.ts
-var import_path19 = __toESM(require("path"), 1);
-var import_fs15 = __toESM(require("fs"), 1);
+var import_path20 = __toESM(require("path"), 1);
+var import_fs16 = __toESM(require("fs"), 1);
 
 // src/shared/managedFilesBundle.ts
-var import_fs14 = __toESM(require("fs"));
-var import_path18 = __toESM(require("path"));
+var import_fs15 = __toESM(require("fs"));
+var import_path19 = __toESM(require("path"));
 
 // src/shared/managedFilesTypes.ts
 var MANAGED_FILES_API = "/api/data-pipelines/v1/managed-files";
@@ -5842,10 +6272,10 @@ function managedFileLocalFolderName(meta) {
   return `${base}_${shortId}`;
 }
 function managedFileLocalDir(filesRoot, meta) {
-  return import_path18.default.join(filesRoot, managedFileLocalFolderName(meta));
+  return import_path19.default.join(filesRoot, managedFileLocalFolderName(meta));
 }
 function isExcelManagedFile(meta) {
-  const ext = (meta.file_ext ?? import_path18.default.extname(meta.display_name ?? "")).toLowerCase();
+  const ext = (meta.file_ext ?? import_path19.default.extname(meta.display_name ?? "")).toLowerCase();
   if (ext === ".xlsx" || ext === ".xls") return true;
   const mime = (meta.mime_type ?? "").toLowerCase();
   return mime.includes("spreadsheet") || mime.endsWith(".sheet");
@@ -5874,8 +6304,8 @@ async function downloadBinary(auth, urlPath, destPath) {
     throw new Error(`\u4E0B\u8F7D\u5931\u8D25 HTTP ${res.status}: ${text || res.statusText}`);
   }
   const buf = Buffer.from(await res.arrayBuffer());
-  import_fs14.default.mkdirSync(import_path18.default.dirname(destPath), { recursive: true });
-  import_fs14.default.writeFileSync(destPath, buf);
+  import_fs15.default.mkdirSync(import_path19.default.dirname(destPath), { recursive: true });
+  import_fs15.default.writeFileSync(destPath, buf);
 }
 async function resolveNativeDigest(auth, fileId, parseIfMissing) {
   if (!parseIfMissing) {
@@ -5931,13 +6361,13 @@ async function pullManagedFileBundle(opts) {
   const fileId = meta.file_id?.trim();
   if (!fileId) throw new Error("\u7F3A\u5C11 file_id\uFF0C\u4EC5\u652F\u6301\u5DF2\u767B\u8BB0\u6587\u4EF6");
   const dir = managedFileLocalDir(opts.filesRootDir, meta);
-  import_fs14.default.mkdirSync(dir, { recursive: true });
+  import_fs15.default.mkdirSync(dir, { recursive: true });
   const written = [];
   const notes = [];
   const pulledAt = (/* @__PURE__ */ new Date()).toISOString();
-  const ext = (meta.file_ext && meta.file_ext.startsWith(".") ? meta.file_ext : meta.file_ext ? `.${meta.file_ext}` : "") || import_path18.default.extname(meta.display_name ?? meta.stored_filename ?? "") || "";
+  const ext = (meta.file_ext && meta.file_ext.startsWith(".") ? meta.file_ext : meta.file_ext ? `.${meta.file_ext}` : "") || import_path19.default.extname(meta.display_name ?? meta.stored_filename ?? "") || "";
   const originalName = `${MANAGED_BUNDLE_FILES.originalPrefix}${ext || ""}`;
-  const originalPath = import_path18.default.join(dir, originalName);
+  const originalPath = import_path19.default.join(dir, originalName);
   await downloadBinary(
     auth,
     `${MANAGED_FILES_API}/${encodeURIComponent(fileId)}/content`,
@@ -5947,15 +6377,15 @@ async function pullManagedFileBundle(opts) {
   if (isExcelManagedFile(meta)) {
     const digest = await resolveNativeDigest(auth, fileId, opts.parseNativeIfMissing !== false);
     if (digest?.markdown) {
-      import_fs14.default.writeFileSync(import_path18.default.join(dir, MANAGED_BUNDLE_FILES.nativeDigest), digest.markdown, "utf8");
+      import_fs15.default.writeFileSync(import_path19.default.join(dir, MANAGED_BUNDLE_FILES.nativeDigest), digest.markdown, "utf8");
       written.push(MANAGED_BUNDLE_FILES.nativeDigest);
     } else {
       notes.push("\u539F\u751F\u89E3\u6790\u672A\u751F\u6210\uFF1A\u8BF7\u5728\u5E73\u53F0\u300C\u6587\u4EF6\u4E0A\u4F20\u7BA1\u7406\u300D\u4E2D\u5BF9 Excel \u6267\u884C\u300C\u539F\u751F\u89E3\u6790\u300D\u540E\u91CD\u8BD5\u62C9\u53D6");
     }
     const structureResp = await resolveAiStructure(auth, fileId);
     if (structureResp?.structure) {
-      import_fs14.default.writeFileSync(
-        import_path18.default.join(dir, MANAGED_BUNDLE_FILES.aiStructure),
+      import_fs15.default.writeFileSync(
+        import_path19.default.join(dir, MANAGED_BUNDLE_FILES.aiStructure),
         JSON.stringify(structureResp.structure, null, 2),
         "utf8"
       );
@@ -5965,8 +6395,8 @@ async function pullManagedFileBundle(opts) {
     }
     const layoutResp = await resolveReportLayout(auth, fileId);
     if (layoutResp?.layout) {
-      import_fs14.default.writeFileSync(
-        import_path18.default.join(dir, MANAGED_BUNDLE_FILES.reportLayout),
+      import_fs15.default.writeFileSync(
+        import_path19.default.join(dir, MANAGED_BUNDLE_FILES.reportLayout),
         JSON.stringify(layoutResp.layout, null, 2),
         "utf8"
       );
@@ -5987,8 +6417,8 @@ async function pullManagedFileBundle(opts) {
     notes: notes.length ? notes : void 0
   };
   manifest.files = [...written, MANAGED_BUNDLE_FILES.manifest];
-  import_fs14.default.writeFileSync(
-    import_path18.default.join(dir, MANAGED_BUNDLE_FILES.manifest),
+  import_fs15.default.writeFileSync(
+    import_path19.default.join(dir, MANAGED_BUNDLE_FILES.manifest),
     JSON.stringify({ ...meta, ...manifest }, null, 2),
     "utf8"
   );
@@ -6048,8 +6478,8 @@ function makeManagedFilesCommand() {
         process.exit(1);
       }
       const ws = resolveWorkspace();
-      const filesRoot = import_path19.default.resolve(opts.filesRoot ?? ws.files);
-      import_fs15.default.mkdirSync(filesRoot, { recursive: true });
+      const filesRoot = import_path20.default.resolve(opts.filesRoot ?? ws.files);
+      import_fs16.default.mkdirSync(filesRoot, { recursive: true });
       const result = await pullManagedFileBundle({
         auth: { serverUrl: auth.serverUrl, token: auth.token },
         meta,