@zltquant/zlt-mcp 0.6.0-beta.0 → 0.6.0-beta.2

package/README.md

@@ -25,6 +25,12 @@ npx -y @zltquant/zlt-mcp call zlt-runtime-doctor --args-json '{}'
 stderr 保留诊断，失败返回非零退出码。工具执行后若写文件失败，完整结果会输出到 stdout；先核对结果，不要自动重复执行。
 不传该参数时保持原有完整 stdout。
 
+回测可按当前工具 schema 传基线路径与覆盖：新建用 `strategyPath`（策略根 localPath），
+重跑用 `codePath`（所选 runId 的运行目录）。MCP 先读配置并校验身份，再合并覆盖、补默认值，
+沿原有 IPC 链提交完整参数。策略根是工作区/调试配置，正式 RUN 不保证更新根目录；运行目录用于该次结果对账。
+无覆盖时省略 runParams，由 ZLTAF 读取库中参数；部分覆盖需合并完整基线。版本管理开启时已执行的正式 RUN 必须新建记录，不自动绕过拒绝。
+`configurationEvidence` 标明基线来源/哈希与 `persistenceVerified=false`；提交回显不代表文件和数据库已回读一致。
+
 其他支持原生 MCP 的客户端（Trae / Claude Code / Cursor 等）可以使用下面的配置：
 
 ```json

package/config.json

@@ -507,7 +507,7 @@
     },
     {
       "name": "mcp-create-and-run-backtest",
-      "description": "创建并启动回测。strategyId 必须来自 mcp-create-strategy 返回的策略ID；runType 固定为 2；已有配置基线时必须把本次 schema 支持的配置字段显式放入 runParams，再叠加用户明确要求；不要只传 strategyId 丢掉已有日期、资金、账户或费用。只有用户和配置都未提供周期时，才让 MCP 默认 end 为自然日 T-1、start 从 end 往前推半年；ZLTAF 按实际交易日执行，非交易日不产生行情或策略调用。run/create 失败直接报错，不要去复用策略里自动生成的 debug runId（建策略时已回显为 debugRunId，跑它等于跑创建那一刻的模板快照）。run/create 生成快照后，MCP 会在真正启动前拒绝 get_current_data().get(...) 这种当前对象不支持的访问。\n\n**返回 runId、codePath 和 attemptFence 后立即调用 mcp-wait（kind=backtest，id=runId）阻塞等待回测结束，不要用 mcp-get-backtest-state 轮询。CLI 创建命令启动的隐藏 guardian 会自行携带 attemptFence；任何后续显式 CLI call 或 MCP 重启后的调用，都必须把 codePath 和 attemptFence 一起传回 mcp-wait，避免把上一轮残留的 result.json 当成本轮错误；同一 MCP 会话内可省略。**\n\n日线类频率只可见到 context.previous_date：要用交易日 T 的收盘，end 必须设成 T 的下一个交易日；end 落在未来不报错但结果为空。展开见返回的 dailyVisibilityNote / endWarning。\n\n返回 Data 回显 resolvedStart/resolvedEnd/resolvedCapital——向用户汇报区间和初始资金时一律以这些字段为准，不要自行推算或臆测。evidence 给出 backtestId、实际 runDir、完整 effectiveRunParams 和代码快照 sourceSha256，后续结果必须与它对账。**基准不在此列**：回显的 requestedBenchmark 只是请求值，策略 initialize 里的 set_benchmark() 会覆盖它，收益产物里的「基准收益」按策略实际用的基准算。说基准是什么之前先读策略代码里的 set_benchmark，否则会把一只个股的涨跌报成指数的。\n\n**期货回测要同时改三处，少一处引擎就按股票跑**：runParams.marketIds 加上对应期货交易所（zj 中金所、zs 郑商所、ds 大商所、sq 上期所、gq 广期所），account_list 的 account_type 改成 2（实测用 6 直接废单），费率用 ratio_tpl_obj.future。合约代码形如 zjIM2605。基准保持默认 sz399300 即可，它对期货策略只是业绩比较基准。数据前置见 mcp-download-data：除行情外还必须有市场规则 mr。",
+      "description": "创建并启动回测。strategyId 必须来自 mcp-create-strategy 返回的策略ID；runType 固定为 2；推荐传 strategyPath（策略 localPath）和 runParams 中本次要改的字段；MCP 读取策略根目录当前配置，合并覆盖后形成完整提交参数，再走原有 run/create → run/run 同步链，不由 Agent 直接改文件或写库。策略根目录是工作区/调试配置，正式 RUN 模式不会保证更新它；只有 DEBUG 路径显式双写根目录和运行目录。不要称根目录为最近正式回测参数，运行身份以返回 runId 为准。没有 strategyPath 时保持旧式完整参数调用；仅真正缺失的字段补默认值。run/create 失败直接报错，不要去复用策略里自动生成的 debug runId（建策略时已回显为 debugRunId，跑它等于跑创建那一刻的模板快照）。run/create 生成快照后，MCP 会在真正启动前拒绝 get_current_data().get(...) 这种当前对象不支持的访问。\n\n**返回 runId、codePath 和 attemptFence 后立即调用 mcp-wait（kind=backtest，id=runId）阻塞等待回测结束，不要用 mcp-get-backtest-state 轮询。CLI 创建命令启动的隐藏 guardian 会自行携带 attemptFence；任何后续显式 CLI call 或 MCP 重启后的调用，都必须把 codePath 和 attemptFence 一起传回 mcp-wait，避免把上一轮残留的 result.json 当成本轮错误；同一 MCP 会话内可省略。**\n\n日线类频率只可见到 context.previous_date：要用交易日 T 的收盘，end 必须设成 T 的下一个交易日；end 落在未来不报错但结果为空。展开见返回的 dailyVisibilityNote / endWarning。\n\n返回 Data 的 resolvedStart/resolvedEnd/resolvedCapital、runParams 和 evidence.effectiveRunParams 是 MCP 补全后的提交参数，不是文件/数据库回读确认。configurationEvidence 标明提交证据及基线来源/哈希，persistenceVerified=false；运行目录 tradesetting.json 和库中对应运行记录是落盘对账依据。evidence 同时给出 backtestId、runDir 和代码快照 sourceSha256。**基准不在此列**：回显的 requestedBenchmark 只是请求值，策略 initialize 里的 set_benchmark() 会覆盖它，收益产物里的「基准收益」按策略实际用的基准算。说基准是什么之前先读策略代码里的 set_benchmark，否则会把一只个股的涨跌报成指数的。\n\n**期货回测要同时改三处，少一处引擎就按股票跑**：runParams.marketIds 加上对应期货交易所（zj 中金所、zs 郑商所、ds 大商所、sq 上期所、gq 广期所），account_list 的 account_type 改成 2（实测用 6 直接废单），费率用 ratio_tpl_obj.future。合约代码形如 zjIM2605。基准保持默认 sz399300 即可，它对期货策略只是业绩比较基准。数据前置见 mcp-download-data：除行情外还必须有市场规则 mr。",
       "inputSchema": {
         "type": "object",
         "properties": {
@@ -529,7 +529,7 @@
           },
           "runParams": {
             "type": "object",
-            "description": "回测参数。有 tradesetting.json 配置基线时显式传入 schema 支持的已有字段（日期、资金、账户、频率、市场、预加载、参数/费率模板），用户本次要求覆盖对应字段；账户现金与初始资金保持一致。仅无用户要求且无配置基线的字段采用 MCP 默认值。",
+            "description": "本次参数覆盖。提供 strategyPath 时先读策略当前配置，再递归合并对象覆盖（数组整体替换），最后补系统默认值；不需要复述整套费率。只改 initial_capital 时同步单账户现金；多账户须明确分配。未提供 strategyPath 时必须自行携带已有配置基线，省略值会使用系统默认值。",
             "properties": {
               "account_list": {
                 "type": "array",
@@ -651,6 +651,10 @@
               }
             },
             "additionalProperties": false
+          },
+          "strategyPath": {
+            "type": "string",
+            "description": "策略根目录绝对路径，使用策略创建/详情返回的 localPath；不是 backtest 下的运行副本。提供时 MCP 读取该目录 .vscode/tradesetting.json 作为当前配置基线，runParams 只传本次覆盖；路径或 strategy_id 不匹配时在执行前拒绝。不提供时保持完整参数/系统默认值的兼容调用，不自动定位磁盘配置。"
           }
         },
         "required": [
@@ -742,7 +746,7 @@
     },
     {
       "name": "mcp-re-backtest",
-      "description": "重新运行会话中最新的回测：用同一个 runId 重跑**该次回测已生成的代码快照**（策略工程 backtest/ 目录下那份副本）。\n\n**它不会把你在策略源工程里刚改过的 main.py 拷进去**——刚编辑过源代码就必须改用 mcp-create-and-run-backtest 生成新的代码快照，否则会重复运行修改前的旧代码，表现为「源码已修复却仍报同样的错误」。所以本工具只适合调整 runParams（回测区间、资金等）后重跑。\n\nstrategyId、strategyName、runId、runType、runParams 从当前会话最近一次 mcp-create-and-run-backtest 的成功结果里取得并传入本工具，不需要用户手动输入；会话中没有运行结果就提示无回测，无法重新回测。runParams 默认沿用最近一次创建回测的条件，允许用户修改部分回测参数；MCP 重启后这份上下文会丢失，届时必须传完整 runParams。返回的 resolved* 是本次实际生效的区间、资金与基准，向用户报告时以它为准。\n\n重跑启动后同样立即调用 mcp-wait（kind=backtest，id=runId）阻塞等待结束，不要轮询状态；隐藏 guardian 会自行携带 attemptFence；任何后续显式 CLI call 或 MCP 重启后的调用，还要复用最初创建结果的 codePath，并传回本次重跑响应里的 attemptFence。",
+      "description": "运行指定 runId 的代码副本，不会把你在策略源工程里刚改过的 main.py 拷进去。ZLTAF 启用回测版本管理时，正式 RUN 记录一旦执行过就不能同 runId 重跑，会返回“请先创建新的回测记录”；这时报告限制，不自动重试、改 DEBUG 或绕过版本管理。需要新一轮实验时按用户授权使用 mcp-create-and-run-backtest。\n\n不改变参数时省略 runParams 或传空对象，MCP 不补旧缓存参数，由 ZLTAF 读取数据库 run_params。改变部分参数时传所选 runId 的 codePath，MCP 校验运行配置并递归合并覆盖，形成完整参数；无路径时只兼容有缓存基线或完整参数的调用。ZLTAF 对非空参数整体采用，不自行合并。返回 configurationEvidence 区分 mcp_submission 与 zltaf_stored_parameters；两者均不证明文件/数据库已回读一致。后者不回显猜测的 effectiveRunParams。\n\n成功启动后按 runId、codePath、attemptFence 调用 mcp-wait，再由收尾读取该次运行文件和终态。根目录不作为历史配置，策略实际基准也不由请求值证明。",
       "inputSchema": {
         "type": "object",
         "properties": {
@@ -760,7 +764,7 @@
           },
           "codePath": {
             "type": "string",
-            "description": "可选的回测运行目录。CLI 独立命令或 MCP 重启后必须传最初创建回测返回的绝对 codePath；仅用于 result.json 新旧轮次对账，不发送给 IPC。"
+            "description": "所选 runId 的运行目录绝对路径，用于身份校验、部分覆盖的配置基线和后续等待定位，不发送给 IPC。无参数覆盖时不把文件内容作为 runParams 重发；数据库配置由 ZLTAF 读取。"
           },
           "runType": {
             "type": "integer",
@@ -772,7 +776,7 @@
           },
           "runParams": {
             "type": "object",
-            "description": "回测参数，与 mcp-create-and-run-backtest 的 runParams 同构，字段说明见该工具。默认沿用最近一次创建回测的条件，用户只需要说明想修改的字段，没传的字段（含基准、撮合模式、滑点、费率模板）都按上一次原样继承；MCP 重启会丢掉这份上下文，之后必须传完整参数，否则会以「缺少必填字段」失败。改用期货市场（marketIds 含 zj/zs/ds/sq/gq）时，account_list 的 account_type 要一并改为 2（期货）。",
+            "description": "省略或空对象表示使用 ZLTAF 数据库存储参数，不依赖 MCP 缓存。非空对象表示本次覆盖：提供 codePath 时读取所选运行配置并递归合并；数组整体替换，多账户资金须明确分配。无 codePath 时需要缓存基线或完整参数，禁止把部分参数直接发送给会整体替换的后端。",
             "properties": {
               "marketIds": {
                 "type": "array",
@@ -795,10 +799,7 @@
         },
         "required": [
           "strategyId",
-          "strategyName",
-          "runId",
-          "runType",
-          "runParams"
+          "runId"
         ],
         "additionalProperties": false
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zltquant/zlt-mcp",
-  "version": "0.6.0-beta.0",
+  "version": "0.6.0-beta.2",
   "description": "智量通 ZLT Quant MCP server（Windows x64；量化策略创建与本地回测）",
   "bin": {
     "zlt-mcp": "./zlt-mcp-proxy.bundle.cjs"

package/zlt-mcp-proxy.bundle.cjs

@@ -1147,8 +1147,8 @@ var require_command = __commonJS({
   "../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path15 = require("node:path");
-    var fs14 = require("node:fs");
+    var path16 = require("node:path");
+    var fs15 = require("node:fs");
     var process4 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2129,7 +2129,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs14.existsSync(executableFile)) return;
+        if (fs15.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2147,11 +2147,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path15.resolve(baseDir, baseName);
-          if (fs14.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path15.extname(baseName))) return void 0;
+          const localBin = path16.resolve(baseDir, baseName);
+          if (fs15.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path16.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs14.existsSync(`${localBin}${ext}`)
+            (ext) => fs15.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2163,21 +2163,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs14.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs15.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path15.resolve(
-            path15.dirname(resolvedScriptPath),
+          executableDir = path16.resolve(
+            path16.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path15.basename(
+            const legacyName = path16.basename(
               this._scriptPath,
-              path15.extname(this._scriptPath)
+              path16.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2188,7 +2188,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path15.extname(executableFile));
+        launchWithNode = sourceExt.includes(path16.extname(executableFile));
         let proc;
         if (process4.platform !== "win32") {
           if (launchWithNode) {
@@ -3035,7 +3035,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path15.basename(filename, path15.extname(filename));
+        this._name = path16.basename(filename, path16.extname(filename));
         return this;
       }
       /**
@@ -3049,9 +3049,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path16) {
-        if (path16 === void 0) return this._executableDir;
-        this._executableDir = path16;
+      executableDir(path17) {
+        if (path17 === void 0) return this._executableDir;
+        this._executableDir = path17;
         return this;
       }
       /**
@@ -6516,8 +6516,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path15) {
-      let input = path15;
+    function removeDotSegments(path16) {
+      let input = path16;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -6716,8 +6716,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path15, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path15 && path15 !== "/" ? path15 : void 0;
+        const [path16, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path16 && path16 !== "/" ? path16 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -10079,12 +10079,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs14, exportName) {
+    function addFormats(ajv, list, fs15, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs14[f]);
+        ajv.addFormat(f, fs15[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -10097,8 +10097,8 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs14 = require("fs");
-    function checkPathExt(path15, options) {
+    var fs15 = require("fs");
+    function checkPathExt(path16, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -10109,25 +10109,25 @@ var require_windows = __commonJS({
       }
       for (var i = 0; i < pathext.length; i++) {
         var p = pathext[i].toLowerCase();
-        if (p && path15.substr(-p.length).toLowerCase() === p) {
+        if (p && path16.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path15, options) {
+    function checkStat(stat, path16, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path15, options);
+      return checkPathExt(path16, options);
     }
-    function isexe(path15, options, cb) {
-      fs14.stat(path15, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path15, options));
+    function isexe(path16, options, cb) {
+      fs15.stat(path16, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path16, options));
       });
     }
-    function sync(path15, options) {
-      return checkStat(fs14.statSync(path15), path15, options);
+    function sync(path16, options) {
+      return checkStat(fs15.statSync(path16), path16, options);
     }
   }
 });
@@ -10137,14 +10137,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs14 = require("fs");
-    function isexe(path15, options, cb) {
-      fs14.stat(path15, function(er, stat) {
+    var fs15 = require("fs");
+    function isexe(path16, options, cb) {
+      fs15.stat(path16, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path15, options) {
-      return checkStat(fs14.statSync(path15), options);
+    function sync(path16, options) {
+      return checkStat(fs15.statSync(path16), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -10168,7 +10168,7 @@ var require_mode = __commonJS({
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports2, module2) {
-    var fs14 = require("fs");
+    var fs15 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -10177,7 +10177,7 @@ var require_isexe = __commonJS({
     }
     module2.exports = isexe;
     isexe.sync = sync;
-    function isexe(path15, options, cb) {
+    function isexe(path16, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -10187,7 +10187,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve8, reject) {
-          isexe(path15, options || {}, function(er, is) {
+          isexe(path16, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -10196,7 +10196,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path15, options || {}, function(er, is) {
+      core(path16, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -10206,9 +10206,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path15, options) {
+    function sync(path16, options) {
       try {
-        return core.sync(path15, options || {});
+        return core.sync(path16, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -10224,7 +10224,7 @@ var require_isexe = __commonJS({
 var require_which = __commonJS({
   "../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports2, module2) {
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path15 = require("path");
+    var path16 = require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -10262,7 +10262,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve8(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path15.join(pathPart, cmd);
+        const pCmd = path16.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve8(subStep(p, i, 0));
       });
@@ -10289,7 +10289,7 @@ var require_which = __commonJS({
       for (let i = 0; i < pathEnv.length; i++) {
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path15.join(pathPart, cmd);
+        const pCmd = path16.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j = 0; j < pathExt.length; j++) {
           const cur = p + pathExt[j];
@@ -10337,7 +10337,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
     "use strict";
-    var path15 = require("path");
+    var path16 = require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -10355,7 +10355,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path15.delimiter : void 0
+          pathExt: withoutPathExt ? path16.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -10364,7 +10364,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path15.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path16.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -10418,8 +10418,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path15, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path15.split("/").pop();
+      const [path16, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path16.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -10432,16 +10432,16 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
     "use strict";
-    var fs14 = require("fs");
+    var fs15 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs14.openSync(command, "r");
-        fs14.readSync(fd, buffer, 0, size, 0);
-        fs14.closeSync(fd);
+        fd = fs15.openSync(command, "r");
+        fs15.readSync(fd, buffer, 0, size, 0);
+        fs15.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -10454,7 +10454,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
     "use strict";
-    var path15 = require("path");
+    var path16 = require("path");
     var resolveCommand = require_resolveCommand();
     var escape2 = require_escape();
     var readShebang = require_readShebang();
@@ -10479,7 +10479,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path15.normalize(parsed.command);
+        parsed.command = path16.normalize(parsed.command);
         parsed.command = escape2.command(parsed.command);
         parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -10607,8 +10607,8 @@ var {
 } = import_index.default;
 
 // src/index.ts
-var fs13 = __toESM(require("node:fs"), 1);
-var path14 = __toESM(require("node:path"), 1);
+var fs14 = __toESM(require("node:fs"), 1);
+var path15 = __toESM(require("node:path"), 1);
 
 // src/cli.ts
 var fs9 = __toESM(require("fs"), 1);
@@ -10812,10 +10812,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path15) {
-  if (!path15)
+function getElementAtPath(obj, path16) {
+  if (!path16)
     return obj;
-  return path15.reduce((acc, key) => acc?.[key], obj);
+  return path16.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11135,11 +11135,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path15, issues) {
+function prefixIssues(path16, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path15);
+    iss.path.unshift(path16);
     return iss;
   });
 }
@@ -19166,18 +19166,18 @@ async function waitForPipe(workRoot, pipePrefix, timeout) {
   throw new Error(`\u7B49\u5F85 ${pipePrefix} \u7BA1\u9053\u8D85\u65F6`);
 }
 async function readZltContent(workRoot, temporaryZltFile) {
-  const fs14 = await import("fs");
-  const path15 = await import("path");
-  const zltFile = path15.join(workRoot, temporaryZltFile || "Temporary/zlt");
-  return fs14.existsSync(zltFile) ? fs14.readFileSync(zltFile, "utf-8").trim() : "";
+  const fs15 = await import("fs");
+  const path16 = await import("path");
+  const zltFile = path16.join(workRoot, temporaryZltFile || "Temporary/zlt");
+  return fs15.existsSync(zltFile) ? fs15.readFileSync(zltFile, "utf-8").trim() : "";
 }
 async function pipeExists2(pipeName) {
-  const fs14 = await import("fs");
+  const fs15 = await import("fs");
   try {
     if (process.platform === "win32") {
-      return fs14.readdirSync("\\\\.\\pipe\\").includes(pipeName);
+      return fs15.readdirSync("\\\\.\\pipe\\").includes(pipeName);
     }
-    return fs14.existsSync(`/tmp/${pipeName}`);
+    return fs15.existsSync(`/tmp/${pipeName}`);
   } catch {
     return false;
   }
@@ -19387,8 +19387,8 @@ async function updateRuntimeLeaseActiveJob(handle, runId, active, options = {})
 async function releaseRuntimeLease(handle, options = {}) {
   const deps = options.deps ?? defaultRuntimeLifecycleDeps;
   return withLifecycleLock(handle.workRoot, deps, async (stateDir) => {
-    const record2 = readJson(leasePath(stateDir, handle.token));
-    if (record2 && sameIdentity(record2.holder, handle.holder)) {
+    const record3 = readJson(leasePath(stateDir, handle.token));
+    if (record3 && sameIdentity(record3.holder, handle.holder)) {
       fs3.rmSync(leasePath(stateDir, handle.token), { force: true });
     }
     const recordedOwner = readJson(ownerPath(stateDir));
@@ -19591,13 +19591,13 @@ function readAndPruneStore(stateDir, deps) {
     if (!entry.isFile() || !entry.name.endsWith(".json"))
       continue;
     const filePath = path3.join(leasesDir, entry.name);
-    const record2 = readJson(filePath);
-    const current = record2 ? deps.inspectProcess(record2.holder.pid) : null;
-    if (!record2 || !current || !sameIdentity(current, record2.holder)) {
+    const record3 = readJson(filePath);
+    const current = record3 ? deps.inspectProcess(record3.holder.pid) : null;
+    if (!record3 || !current || !sameIdentity(current, record3.holder)) {
       fs3.rmSync(filePath, { force: true });
       continue;
     }
-    leases.push(record2);
+    leases.push(record3);
   }
   let owner = normalizeRuntimeOwnerRecord(readJson(ownerPath(stateDir)));
   if (owner) {
@@ -19609,21 +19609,21 @@ function readAndPruneStore(stateDir, deps) {
   }
   return { owner, leases };
 }
-function normalizeRuntimeOwnerRecord(record2) {
-  if (!record2)
+function normalizeRuntimeOwnerRecord(record3) {
+  if (!record3)
     return null;
-  const activeJobIds = new Set(normalizeRunIds(record2.activeJobIds));
-  const legacyBoundJobIds = normalizeRunIds(record2.legacyBoundJobIds);
-  const legacyResolvedJobIds = new Set(normalizeRunIds(record2.legacyResolvedJobIds));
+  const activeJobIds = new Set(normalizeRunIds(record3.activeJobIds));
+  const legacyBoundJobIds = normalizeRunIds(record3.legacyBoundJobIds);
+  const legacyResolvedJobIds = new Set(normalizeRunIds(record3.legacyResolvedJobIds));
   for (const runId of legacyBoundJobIds) {
     activeJobIds.add(runId);
     legacyResolvedJobIds.delete(runId);
   }
   return {
-    process: record2.process,
-    startedAt: record2.startedAt,
+    process: record3.process,
+    startedAt: record3.startedAt,
     activeJobIds: [...activeJobIds].sort(),
-    legacyActiveJobs: record2.legacyActiveJobs === void 0 ? normalizeLegacyActiveJobs(record2.activeJobs) : normalizeLegacyActiveJobs(record2.legacyActiveJobs),
+    legacyActiveJobs: record3.legacyActiveJobs === void 0 ? normalizeLegacyActiveJobs(record3.activeJobs) : normalizeLegacyActiveJobs(record3.legacyActiveJobs),
     legacyBoundJobIds,
     legacyResolvedJobIds: [...legacyResolvedJobIds].sort()
   };
@@ -21715,14 +21715,14 @@ function appendHistory(outputDir, uri, statusCode, contentSize, respFile) {
       fs9.writeFileSync(historyPath, kept.join("\n") + "\n", "utf-8");
     }
   }
-  const record2 = {
+  const record3 = {
     time: getTimestampISO(),
     uri,
     status: statusCode,
     size: contentSize
   };
-  if (respFile) record2.file = respFile;
-  fs9.appendFileSync(historyPath, JSON.stringify(record2) + "\n", "utf-8");
+  if (respFile) record3.file = respFile;
+  fs9.appendFileSync(historyPath, JSON.stringify(record3) + "\n", "utf-8");
 }
 function cleanOutput(clientRootDir, maxDays = 1) {
   const outputDir = getOutputDir(clientRootDir);
@@ -21895,13 +21895,13 @@ function backtestHandoff(result) {
   const payload = parseMcpResult(result);
   const data = payload?.Data;
   if (!data || typeof data !== "object" || Array.isArray(data)) return null;
-  const record2 = data;
-  const status = Number(record2.status);
+  const record3 = data;
+  const status = Number(record3.status);
   if (Number.isFinite(status) && status !== 0 && status !== 1) return null;
-  const runId = typeof record2.runId === "string" ? record2.runId.trim() : "";
+  const runId = typeof record3.runId === "string" ? record3.runId.trim() : "";
   if (!runId) return null;
-  const evidence = record2.evidence && typeof record2.evidence === "object" && !Array.isArray(record2.evidence) ? record2.evidence : void 0;
-  const rawCodePath = typeof record2.codePath === "string" ? record2.codePath.trim() : typeof evidence?.runDir === "string" ? evidence.runDir.trim() : "";
+  const evidence = record3.evidence && typeof record3.evidence === "object" && !Array.isArray(record3.evidence) ? record3.evidence : void 0;
+  const rawCodePath = typeof record3.codePath === "string" ? record3.codePath.trim() : typeof evidence?.runDir === "string" ? evidence.runDir.trim() : "";
   return {
     runId,
     ...rawCodePath && path9.isAbsolute(rawCodePath) ? { codePath: rawCodePath } : {}
@@ -21915,13 +21915,13 @@ function parseKeepaliveLockRecord(raw) {
   try {
     const parsed = JSON.parse(raw.toString("utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-    const record2 = parsed;
-    const processIdentity = parseRuntimeProcessIdentity(record2.processIdentity);
-    return typeof record2.token === "string" && record2.token.length > 0 && Number.isSafeInteger(record2.pid) && Number(record2.pid) > 0 && processIdentity?.pid === Number(record2.pid) && Number.isSafeInteger(record2.heartbeatAt) && Number(record2.heartbeatAt) > 0 ? {
-      token: record2.token,
-      pid: Number(record2.pid),
+    const record3 = parsed;
+    const processIdentity = parseRuntimeProcessIdentity(record3.processIdentity);
+    return typeof record3.token === "string" && record3.token.length > 0 && Number.isSafeInteger(record3.pid) && Number(record3.pid) > 0 && processIdentity?.pid === Number(record3.pid) && Number.isSafeInteger(record3.heartbeatAt) && Number(record3.heartbeatAt) > 0 ? {
+      token: record3.token,
+      pid: Number(record3.pid),
       processIdentity,
-      heartbeatAt: Number(record2.heartbeatAt)
+      heartbeatAt: Number(record3.heartbeatAt)
     } : null;
   } catch {
     return null;
@@ -21929,11 +21929,11 @@ function parseKeepaliveLockRecord(raw) {
 }
 function parseRuntimeProcessIdentity(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const record2 = value;
-  return Number.isSafeInteger(record2.pid) && Number(record2.pid) > 0 && typeof record2.executablePath === "string" && record2.executablePath.length > 0 && typeof record2.creationTime === "string" && record2.creationTime.length > 0 ? {
-    pid: Number(record2.pid),
-    executablePath: record2.executablePath,
-    creationTime: record2.creationTime
+  const record3 = value;
+  return Number.isSafeInteger(record3.pid) && Number(record3.pid) > 0 && typeof record3.executablePath === "string" && record3.executablePath.length > 0 && typeof record3.creationTime === "string" && record3.creationTime.length > 0 ? {
+    pid: Number(record3.pid),
+    executablePath: record3.executablePath,
+    creationTime: record3.creationTime
   } : null;
 }
 function readKeepaliveLock(lockPath) {
@@ -21975,15 +21975,15 @@ function currentKeepaliveProcessIdentity() {
   if (!identity) throw new Error(`Unable to identify keepalive process pid=${process.pid}`);
   return identity;
 }
-function keepaliveProcessIsCurrent(record2) {
-  if (!processIsAlive(record2.pid)) return false;
-  const current = inspectRuntimeProcess(record2.pid);
-  return current ? sameProcessIdentity(current, record2.processIdentity) : true;
+function keepaliveProcessIsCurrent(record3) {
+  if (!processIsAlive(record3.pid)) return false;
+  const current = inspectRuntimeProcess(record3.pid);
+  return current ? sameProcessIdentity(current, record3.processIdentity) : true;
 }
-function writeNewKeepaliveLock(lockPath, record2) {
+function writeNewKeepaliveLock(lockPath, record3) {
   const descriptor = fs9.openSync(lockPath, "wx", 384);
   try {
-    fs9.writeFileSync(descriptor, JSON.stringify(record2), "utf-8");
+    fs9.writeFileSync(descriptor, JSON.stringify(record3), "utf-8");
   } finally {
     fs9.closeSync(descriptor);
   }
@@ -22054,8 +22054,8 @@ function releaseKeepaliveLock(ownership) {
     retireKeepaliveLockIfUnchanged(ownership.lockPath, current.identity);
   }
 }
-function keepaliveLeaseIsFresh(record2) {
-  return keepaliveTimestampIsFresh(record2.heartbeatAt);
+function keepaliveLeaseIsFresh(record3) {
+  return keepaliveTimestampIsFresh(record3.heartbeatAt);
 }
 function keepaliveTimestampIsFresh(timestamp) {
   const age = Date.now() - timestamp;
@@ -23123,9 +23123,9 @@ var StdioServerTransport = class {
 };
 
 // src/mcp-server.ts
-var fs12 = __toESM(require("node:fs"), 1);
+var fs13 = __toESM(require("node:fs"), 1);
 var os5 = __toESM(require("node:os"), 1);
-var path13 = __toESM(require("node:path"), 1);
+var path14 = __toESM(require("node:path"), 1);
 
 // src/tool-profile-contract.mjs
 var UNIVERSAL_AGENT_RUNTIME_TOOL_NAMES = Object.freeze([
@@ -23188,9 +23188,9 @@ var NPM_PACKAGE_CONFIG_TOOL_NAMES = Object.freeze([
 ]);
 
 // src/tool-pipeline.ts
-var fs11 = __toESM(require("node:fs"), 1);
-var path11 = __toESM(require("node:path"), 1);
-var import_node_crypto2 = require("node:crypto");
+var fs12 = __toESM(require("node:fs"), 1);
+var path12 = __toESM(require("node:path"), 1);
+var import_node_crypto3 = require("node:crypto");
 
 // src/feature-set.ts
 function resolveFeatureSet() {
@@ -23199,6 +23199,119 @@ function resolveFeatureSet() {
 var MASKED_FACTOR_MESSAGE = "\u56E0\u5B50\u7814\u7A76\u529F\u80FD\u5728\u5F53\u524D\u7248\u672C\u672A\u5F00\u653E\u3002";
 var MASKED_FUTURES_MESSAGE = "\u671F\u8D27\u56DE\u6D4B\u5728\u5F53\u524D\u7248\u672C\u672A\u5F00\u653E\uFF1ArunParams.marketIds \u542B\u671F\u8D27\u4EA4\u6613\u6240\uFF08zj/zs/ds/sq/gq\uFF09\u6216 account_list \u7684 account_type \u4E3A\u671F\u8D27\u3002\u8BF7\u4F7F\u7528\u80A1\u7968\u5E02\u573A\uFF08sh/sz\uFF09\u4E0E account_type=1\u3002";
 
+// src/backtest-config.ts
+var fs11 = __toESM(require("node:fs"), 1);
+var path11 = __toESM(require("node:path"), 1);
+var import_node_crypto2 = require("node:crypto");
+var BACKTEST_CONFIG_KEYS = [
+  "start",
+  "end",
+  "freq",
+  "kcount",
+  "marketIds",
+  "trade_type",
+  "initial_capital",
+  "account_list",
+  "base_tpl_obj",
+  "ratio_tpl_obj"
+];
+var INTERNAL_CONFIG_KEYS = ["btmode", "st_parmas", "mode", "class_type", "base_tpl_id", "ratio_tpl_id"];
+var BASE_KEYS = [
+  "name",
+  "zhCnName",
+  "benchmark",
+  "matching_mode",
+  "slippage",
+  "avoid_future",
+  "open_cache",
+  "match_with_order_book",
+  "max_trade_ratio",
+  "order_volume_ratio",
+  "take_fee_type",
+  "adjust_aqty_by_avail",
+  "jv_kuan_open_avg_cost_switch"
+];
+var FEE_KEYS = [
+  "open_commission",
+  "close_commission",
+  "close_today_commission",
+  "min_commission",
+  "open_tax",
+  "close_tax",
+  "margin_ratio"
+];
+var record2 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var pick2 = (v, keys) => Object.fromEntries(keys.filter((k) => Object.prototype.hasOwnProperty.call(v, k)).map((k) => [k, v[k]]));
+function readBacktestBaseline(tool, args) {
+  const create = tool === "mcp-create-and-run-backtest";
+  if (!create && tool !== "mcp-re-backtest") return void 0;
+  const directory = args[create ? "strategyPath" : "codePath"];
+  if (directory === void 0) return void 0;
+  if (typeof directory !== "string" || !path11.isAbsolute(directory)) throw new Error("Configuration baseline requires an absolute directory path");
+  const root = fs11.realpathSync(directory);
+  if (create && path11.basename(path11.dirname(root)).toLowerCase() === "backtest") {
+    throw new Error("strategyPath must identify the strategy root, not a historical backtest directory");
+  }
+  const file = path11.join(root, ".vscode", "tradesetting.json");
+  const raw = fs11.readFileSync(file);
+  let config2;
+  try {
+    config2 = JSON.parse(raw.toString("utf8").replace(/^\uFEFF/, ""));
+  } catch {
+    throw new Error("Configuration baseline is not valid JSON");
+  }
+  if (!record2(config2) || config2.strategy_id !== args.strategyId) throw new Error("Configuration baseline strategy_id is missing or mismatched");
+  if (!create && (typeof args.runId !== "string" || config2.backtest_id !== args.runId)) {
+    throw new Error("Configuration baseline backtest_id does not match the requested runId");
+  }
+  const params = pick2(config2, [...BACKTEST_CONFIG_KEYS, ...INTERNAL_CONFIG_KEYS]);
+  for (const key of ["base_tpl_obj", "ratio_tpl_obj"]) {
+    if (params[key] !== void 0 && !record2(params[key])) throw new Error(`Configuration baseline ${key} must be an object`);
+  }
+  if (record2(params.base_tpl_obj)) params.base_tpl_obj = pick2(params.base_tpl_obj, BASE_KEYS);
+  if (record2(params.ratio_tpl_obj)) {
+    const fees = params.ratio_tpl_obj;
+    for (const asset of ["stock", "future", "fund", "bond"]) {
+      if (fees[asset] !== void 0 && !record2(fees[asset])) throw new Error(`Configuration baseline fee section ${asset} must be an object`);
+    }
+    params.ratio_tpl_obj = {
+      ...pick2(fees, ["name", "zhCnName"]),
+      ...Object.fromEntries(["stock", "future", "fund", "bond"].filter((k) => record2(fees[k])).map((k) => [k, pick2(fees[k], FEE_KEYS)]))
+    };
+  }
+  if (Array.isArray(params.account_list)) {
+    params.account_list = params.account_list.map((account) => {
+      if (!record2(account)) throw new Error("Configuration baseline account_list contains a non-object");
+      const result = pick2(account, ["pindex", "account_id", "cash", "account_type"]);
+      if (create && typeof result.account_id === "string" && /^RN-[A-Za-z0-9-]+_\d+$/.test(result.account_id)) result.account_id = "";
+      return result;
+    });
+  }
+  return { params, evidence: {
+    kind: create ? "strategy_current" : "selected_run",
+    path: file,
+    sha256: (0, import_node_crypto2.createHash)("sha256").update(raw).digest("hex")
+  } };
+}
+function reconcileBaselineCapital(params, overrides) {
+  const accounts = params.account_list;
+  if (!Array.isArray(accounts) || !accounts.length || accounts.some((a) => !record2(a) || typeof a.cash !== "number" || !Number.isFinite(a.cash) || a.cash < 0)) {
+    throw new Error("Configuration baseline requires accounts with finite nonnegative cash");
+  }
+  const explicitCapital = Object.prototype.hasOwnProperty.call(overrides, "initial_capital");
+  const explicitAccounts = Object.prototype.hasOwnProperty.call(overrides, "account_list");
+  if (explicitCapital && !explicitAccounts) {
+    if (accounts.length !== 1) throw new Error("Changing capital for multiple accounts requires an explicit account_list allocation");
+    if (typeof params.initial_capital !== "number" || !Number.isFinite(params.initial_capital) || params.initial_capital <= 0) throw new Error("initial_capital must be positive and finite");
+    accounts[0] = { ...accounts[0], cash: params.initial_capital };
+  }
+  const total = accounts.reduce((sum, a) => sum + a.cash, 0);
+  if (explicitAccounts && !explicitCapital || params.initial_capital === void 0) params.initial_capital = total;
+  if (typeof params.initial_capital !== "number" || !Number.isFinite(params.initial_capital) || params.initial_capital <= 0 || Math.abs(params.initial_capital - total) > 5e-3) {
+    throw new Error("initial_capital must match the sum of account cash; supply a consistent allocation");
+  }
+}
+
 // src/tool-pipeline.ts
 function finitePositiveNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
@@ -23228,6 +23341,44 @@ function isFuturesRun(marketIds) {
   return marketIds.some((id) => FUTURES_MARKET_IDS.has(String(id).trim().toLowerCase()));
 }
 var identityRepairHint = (data) => data;
+function prepareToolCallArgs(tool, args, contexts) {
+  const clean = { ...args };
+  delete clean.__configBaseline;
+  delete clean.__storedRunParams;
+  try {
+    if (tool.name === "mcp-re-backtest" && (clean.runParams === void 0 || isRecord2(clean.runParams) && Object.keys(clean.runParams).length === 0)) {
+      readBacktestBaseline(tool.name, clean);
+      const prior = typeof clean.runId === "string" ? contexts.get(clean.runId) : void 0;
+      if (prior && prior.strategyId !== clean.strategyId) throw new Error("Cached run belongs to another strategy");
+      delete clean.runParams;
+      return prepareToolArgs(tool, applyToolArgDefaults(tool, { ...clean, __storedRunParams: true }), contexts);
+    }
+    const baseline = readBacktestBaseline(tool.name, clean);
+    if (!baseline) {
+      if (tool.name === "mcp-re-backtest") {
+        const prior = typeof clean.runId === "string" ? contexts.get(clean.runId) : void 0;
+        if (prior && prior.strategyId !== clean.strategyId) throw new Error("Cached run belongs to another strategy");
+        const supplied = isRecord2(clean.runParams) ? clean.runParams : {};
+        if (!prior?.runParams && BACKTEST_CONFIG_KEYS.some((key) => supplied[key] === void 0 || supplied[key] === null)) {
+          throw new Error("Rerun has no persistent or cached baseline; supply codePath or complete runParams");
+        }
+      }
+      return prepareToolArgs(tool, applyToolArgDefaults(tool, clean), contexts);
+    }
+    if (clean.runParams !== void 0 && !isRecord2(clean.runParams)) throw new Error("runParams overrides must be an object");
+    const overrides = clean.runParams ?? {};
+    const runParams = applyBodyDefaults(baseline.params, overrides);
+    const merged = applyToolArgDefaults(tool, { ...clean, runParams, __configBaseline: baseline.evidence });
+    reconcileBaselineCapital(merged.runParams, overrides);
+    return prepareToolArgs(tool, merged, contexts);
+  } catch (error2) {
+    return jsonToolResult(10063, "\u56DE\u6D4B\u914D\u7F6E\u57FA\u7EBF\u4E0D\u53EF\u7528\u6216\u8986\u76D6\u53C2\u6570\u51B2\u7A81", {
+      reason: error2 instanceof Error ? error2.message : String(error2),
+      toolExecution: "not_started",
+      action: "Check the supplied strategyPath/codePath, configuration identity and account allocation, then retry."
+    }, true);
+  }
+}
 function prepareToolArgs(tool, args, contexts) {
   const inherited = inheritReBacktestRunParams(tool, args, contexts);
   const dated = applyBacktestDateDefaults(tool, inherited);
@@ -23362,7 +23513,7 @@ function readSlaveProperties(filePath) {
   const entries = /* @__PURE__ */ new Map();
   let raw;
   try {
-    raw = fs11.readFileSync(filePath, "utf-8");
+    raw = fs12.readFileSync(filePath, "utf-8");
   } catch {
     return entries;
   }
@@ -23386,18 +23537,18 @@ function resolveFactorProjectRoot(clientRootDir) {
   if (cached2) return cached2;
   const root = clientRootDir.replace(/[\\/]+$/, "");
   const configured = expandSlaveValue(
-    readSlaveProperties(path11.join(root, ...ZLTAF_CONFIG_SEGMENTS)),
+    readSlaveProperties(path12.join(root, ...ZLTAF_CONFIG_SEGMENTS)),
     "slave.factor.project-path",
     root
   );
-  const resolved = configured ? path11.normalize(configured) : path11.join(root, ...FALLBACK_FACTOR_PROJECT_PATH);
+  const resolved = configured ? path12.normalize(configured) : path12.join(root, ...FALLBACK_FACTOR_PROJECT_PATH);
   factorProjectRootCache.set(clientRootDir, resolved);
   return resolved;
 }
 function resolveFactorWorkspacePath(clientRootDir, factorId) {
   if (!clientRootDir || !factorId) return void 0;
   const projectRoot = resolveFactorProjectRoot(clientRootDir);
-  return projectRoot ? path11.join(projectRoot, factorId) : void 0;
+  return projectRoot ? path12.join(projectRoot, factorId) : void 0;
 }
 var MODULE_LEVEL_FACTOR_EXPORT = /^(?:(?:async\s+)?def\s+get_factor\s*\(|get_factor\s*=(?!=)|Factor\s*=(?!=))/m;
 function checkFactorSourceLoadable(clientRootDir, factorId) {
@@ -23405,7 +23556,7 @@ function checkFactorSourceLoadable(clientRootDir, factorId) {
   if (!workspacePath) return null;
   let source;
   try {
-    source = fs11.readFileSync(path11.join(workspacePath, "main.py"), "utf8");
+    source = fs12.readFileSync(path12.join(workspacePath, "main.py"), "utf8");
   } catch {
     return null;
   }
@@ -23504,6 +23655,9 @@ var CONTROL_PARAMS = [
   "timeout",
   "confirm",
   "codePath",
+  "strategyPath",
+  "__configBaseline",
+  "__storedRunParams",
   "attemptFence",
   "__attemptStartedAtMs",
   "__resultBaseline"
@@ -23524,12 +23678,12 @@ function normalizeBacktestRunName(tool, args) {
   };
 }
 function inheritReBacktestRunParams(tool, args, contexts) {
-  if (tool.name !== "mcp-re-backtest") return args;
+  if (tool.name !== "mcp-re-backtest" || args.__configBaseline || args.__storedRunParams) return args;
   const runId = typeof args.runId === "string" ? args.runId.trim() : "";
   const prior = runId ? contexts.get(runId)?.runParams : void 0;
   if (!prior) return args;
   const runParams = isRecord2(args.runParams) ? args.runParams : {};
-  return { ...args, runParams: { ...prior, ...runParams } };
+  return { ...args, runParams: applyBodyDefaults(prior, runParams) };
 }
 function applyBacktestDateDefaults(tool, args) {
   if (tool.name !== "mcp-create-and-run-backtest") return args;
@@ -23645,18 +23799,18 @@ function backtestWindowPreflightError(tool, reason, message, details) {
   }, true);
 }
 function isExistingAbsoluteDirectory(value) {
-  if (!value || !path11.isAbsolute(value)) return false;
+  if (!value || !path12.isAbsolute(value)) return false;
   try {
-    return fs11.statSync(value).isDirectory();
+    return fs12.statSync(value).isDirectory();
   } catch {
     return false;
   }
 }
 function readBacktestIdFromCodePath(codePath) {
   try {
-    const tradesettingPath = path11.join(codePath, ".vscode", "tradesetting.json");
-    if (!fs11.existsSync(tradesettingPath)) return void 0;
-    const parsed = JSON.parse(fs11.readFileSync(tradesettingPath, "utf-8"));
+    const tradesettingPath = path12.join(codePath, ".vscode", "tradesetting.json");
+    if (!fs12.existsSync(tradesettingPath)) return void 0;
+    const parsed = JSON.parse(fs12.readFileSync(tradesettingPath, "utf-8"));
     if (!isRecord2(parsed)) return void 0;
     const value = parsed.backtest_id ?? parsed.backtestId;
     return typeof value === "string" && value.trim() ? value.trim() : void 0;
@@ -23680,7 +23834,7 @@ function capturePendingBacktestAttempt(tool, args, contexts) {
   if (tool.name !== "mcp-create-and-run-backtest" && tool.name !== "mcp-re-backtest") return;
   const runId = typeof args.runId === "string" ? args.runId.trim() : "";
   const suppliedCodePath = typeof args.codePath === "string" ? args.codePath.trim() : "";
-  const codePath = (runId ? contexts.get(runId)?.codePath : void 0) || suppliedCodePath;
+  const codePath = args.__configBaseline ? suppliedCodePath : (runId ? contexts.get(runId)?.codePath : void 0) || suppliedCodePath;
   const resultFile = codePath ? readRunResultFile(codePath) : null;
   pendingBacktestAttempts.set(args, {
     ...resultFile ? { resultBaseline: resultFile.identity } : {},
@@ -24352,9 +24506,9 @@ var FACTOR_FAILURE_SIGNATURES = [
 function factorFailureMessage(data) {
   if (typeof data.errorMessage === "string" && data.errorMessage) return data.errorMessage;
   for (const key of ["calculateRecord", "detectRecord"]) {
-    const record2 = data[key];
-    if (isRecord2(record2) && typeof record2.errorMessage === "string" && record2.errorMessage) {
-      return record2.errorMessage;
+    const record3 = data[key];
+    if (isRecord2(record3) && typeof record3.errorMessage === "string" && record3.errorMessage) {
+      return record3.errorMessage;
     }
   }
   return "";
@@ -24798,18 +24952,18 @@ function applyBacktestResultGuards(tool, args, result, states, contexts, activeR
 }
 function readRunResultFile(codePath) {
   try {
-    const resultPath = path11.join(codePath, "log", "result.json");
-    if (!fs11.existsSync(resultPath)) return null;
-    const before = fs11.statSync(resultPath);
-    const raw = fs11.readFileSync(resultPath);
-    const after = fs11.statSync(resultPath);
+    const resultPath = path12.join(codePath, "log", "result.json");
+    if (!fs12.existsSync(resultPath)) return null;
+    const before = fs12.statSync(resultPath);
+    const raw = fs12.readFileSync(resultPath);
+    const after = fs12.statSync(resultPath);
     if (before.mtimeMs !== after.mtimeMs || before.size !== after.size) return null;
     const parsed = JSON.parse(raw.toString("utf-8"));
     if (!isRecord2(parsed)) return null;
     return {
       data: parsed,
       identity: {
-        sha256: (0, import_node_crypto2.createHash)("sha256").update(raw).digest("hex"),
+        sha256: (0, import_node_crypto3.createHash)("sha256").update(raw).digest("hex"),
         mtimeMs: after.mtimeMs,
         size: after.size
       }
@@ -24918,7 +25072,7 @@ function captureBacktestRunContext(tool, args, result, contexts, activeRunIds) {
   const strategyId = typeof args.strategyId === "string" ? args.strategyId : "";
   const start = typeof runParams.start === "string" ? runParams.start : "";
   const end = typeof runParams.end === "string" ? runParams.end : "";
-  if (!strategyId || !start || !end) return;
+  if (!strategyId || (!start || !end) && !args.__storedRunParams) return;
   try {
     const parsed = JSON.parse(result.content[0].text);
     if (!isRecord2(parsed) || !isRecord2(parsed.Data)) return;
@@ -24926,7 +25080,7 @@ function captureBacktestRunContext(tool, args, result, contexts, activeRunIds) {
     const runId = echoedRunId || (isRerun && typeof args.runId === "string" ? args.runId.trim() : "");
     const prior = runId ? contexts.get(runId) : void 0;
     const suppliedCodePath = typeof args.codePath === "string" ? args.codePath.trim() : "";
-    const codePath = typeof parsed.Data.codePath === "string" && parsed.Data.codePath.trim() ? parsed.Data.codePath.trim() : prior?.codePath || suppliedCodePath;
+    const codePath = typeof parsed.Data.codePath === "string" && parsed.Data.codePath.trim() ? parsed.Data.codePath.trim() : args.__configBaseline ? suppliedCodePath : prior?.codePath || suppliedCodePath;
     if (runId) {
       const marketIds = Array.isArray(runParams.marketIds) ? runParams.marketIds.filter((id) => typeof id === "string") : prior?.marketIds;
       const sourceSha256 = hashBacktestSource(codePath) ?? prior?.sourceSha256;
@@ -24955,6 +25109,11 @@ function echoResolvedBacktestConfig(tool, args, result, contexts) {
   const resolvedCapital = resolveBacktestCapital(runParams);
   const resolvedBenchmark = resolveBacktestBenchmark(runParams);
   const echo = {};
+  echo.configurationEvidence = {
+    source: args.__storedRunParams ? "zltaf_stored_parameters" : "mcp_submission",
+    persistenceVerified: false,
+    ...args.__configBaseline ? { baseline: args.__configBaseline } : {}
+  };
   if (resolvedStart) echo.resolvedStart = resolvedStart;
   if (resolvedEnd) echo.resolvedEnd = resolvedEnd;
   if (resolvedCapital !== null) echo.resolvedCapital = resolvedCapital;
@@ -24976,7 +25135,7 @@ function echoResolvedBacktestConfig(tool, args, result, contexts) {
       echo.codePath = context.codePath;
       echo.runDir = context.codePath;
     }
-    if (context?.runParams) echo.runParams = { ...context.runParams };
+    if (context?.runParams && !args.__storedRunParams) echo.runParams = { ...context.runParams };
     if (context?.attemptStartedAtMs) {
       echo.attemptFence = {
         attemptStartedAtMs: context.attemptStartedAtMs,
@@ -24989,7 +25148,7 @@ function echoResolvedBacktestConfig(tool, args, result, contexts) {
         backtestId: runId,
         ...context?.codePath ? { runDir: context.codePath } : {},
         ...context?.strategyId ? { strategyId: context.strategyId } : {},
-        ...context?.runParams ? { effectiveRunParams: { ...context.runParams } } : {},
+        ...context?.runParams && !args.__storedRunParams ? { effectiveRunParams: { ...context.runParams } } : {},
         ...context?.sourceSha256 ? { sourceSha256: context.sourceSha256 } : {}
       };
     }
@@ -25011,9 +25170,9 @@ function echoResolvedBacktestConfig(tool, args, result, contexts) {
 function hashBacktestSource(codePath) {
   if (!codePath) return void 0;
   try {
-    const sourcePath = path11.join(codePath, "main.py");
-    if (!fs11.statSync(sourcePath).isFile()) return void 0;
-    return (0, import_node_crypto2.createHash)("sha256").update(fs11.readFileSync(sourcePath)).digest("hex");
+    const sourcePath = path12.join(codePath, "main.py");
+    if (!fs12.statSync(sourcePath).isFile()) return void 0;
+    return (0, import_node_crypto3.createHash)("sha256").update(fs12.readFileSync(sourcePath)).digest("hex");
   } catch {
     return void 0;
   }
@@ -25059,7 +25218,7 @@ function resolveBacktestBenchmark(runParams) {
 var STRATEGY_DOCS_TOOLS = /* @__PURE__ */ new Set(["mcp-create-strategy", "mcp-create-strategy-with-template"]);
 function resolveStrategyDocsPath(clientRootDir) {
   if (!clientRootDir) return void 0;
-  const docsPath = path11.join(
+  const docsPath = path12.join(
     clientRootDir,
     "python",
     "Lib",
@@ -25069,7 +25228,7 @@ function resolveStrategyDocsPath(clientRootDir) {
     "docs"
   );
   try {
-    if (!fs11.existsSync(docsPath)) return void 0;
+    if (!fs12.existsSync(docsPath)) return void 0;
   } catch {
     return void 0;
   }
@@ -25086,7 +25245,7 @@ function injectDebugRunId(tool, result) {
     const localPath = typeof parsed.Data.localPath === "string" ? parsed.Data.localPath.trim() : "";
     if (!localPath) return result;
     const settings = JSON.parse(
-      fs11.readFileSync(path11.join(localPath, ".vscode", "tradesetting.json"), "utf8")
+      fs12.readFileSync(path12.join(localPath, ".vscode", "tradesetting.json"), "utf8")
     );
     const debugRunId = isRecord2(settings) && typeof settings.backtest_id === "string" ? settings.backtest_id.trim() : "";
     if (!debugRunId) return result;
@@ -25582,12 +25741,12 @@ function preflightCreatedBacktestSource(toolName, body) {
   if (toolName !== "mcp-create-and-run-backtest") return null;
   const runId = typeof body.runId === "string" ? body.runId.trim() : "";
   const codePath = typeof body.codePath === "string" ? body.codePath.trim() : "";
-  if (!codePath || !fs11.existsSync(codePath)) return null;
-  const sourcePath = path11.join(codePath, "main.py");
-  if (!fs11.existsSync(sourcePath)) return null;
+  if (!codePath || !fs12.existsSync(codePath)) return null;
+  const sourcePath = path12.join(codePath, "main.py");
+  if (!fs12.existsSync(sourcePath)) return null;
   let source;
   try {
-    source = fs11.readFileSync(sourcePath, "utf8");
+    source = fs12.readFileSync(sourcePath, "utf8");
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : String(error2);
     return jsonToolResult(10061, "\u56DE\u6D4B\u4EE3\u7801\u5FEB\u7167\u65E0\u6CD5\u8BFB\u53D6\uFF0C\u672A\u542F\u52A8\u7B56\u7565\u5F15\u64CE\u3002", {
@@ -25607,7 +25766,7 @@ function preflightCreatedBacktestSource(toolName, body) {
     codePath,
     sourcePath,
     sourcePreflight: "blocked",
-    sourceSha256: (0, import_node_crypto2.createHash)("sha256").update(source).digest("hex"),
+    sourceSha256: (0, import_node_crypto3.createHash)("sha256").update(source).digest("hex"),
     violations,
     userAction: "\u628A current_data.get(security) \u6539\u4E3A current_data[security]\uFF0C\u5E76\u7528 KeyError \u5904\u7406\u7F3A\u5931\u8BC1\u5238\uFF1B\u7136\u540E\u91CD\u65B0\u521B\u5EFA\u5E76\u8FD0\u884C\u56DE\u6D4B\u3002"
   }, true);
@@ -25827,7 +25986,7 @@ function normalizeDataRoot(raw, clientRootDir) {
 }
 function readJsonFile(filePath) {
   try {
-    const parsed = JSON.parse(fs11.readFileSync(filePath, "utf-8"));
+    const parsed = JSON.parse(fs12.readFileSync(filePath, "utf-8"));
     return isRecord2(parsed) ? parsed : void 0;
   } catch {
     return void 0;
@@ -25841,8 +26000,8 @@ function resolveDataRoots(clientRootDir) {
   const cached2 = Date.now() - readAt < DATA_ROOTS_TTL_MS ? dataRootsCache.get(clientRootDir) : void 0;
   if (cached2) return cached2;
   const root = clientRootDir.replace(/[\\/]+$/, "");
-  const dcSdk = readJsonFile(path11.join(root, ...DC_SDK_CONFIG_SEGMENTS));
-  const dcm = readJsonFile(path11.join(root, ...DCM_CONFIG_SEGMENTS));
+  const dcSdk = readJsonFile(path12.join(root, ...DC_SDK_CONFIG_SEGMENTS));
+  const dcm = readJsonFile(path12.join(root, ...DCM_CONFIG_SEGMENTS));
   const engineRoot = normalizeDataRoot(isRecord2(dcSdk?.mdf) ? dcSdk.mdf.path : void 0, root);
   const downloadRoot = normalizeDataRoot(dcm?.download_home, root);
   const resolved = Boolean(engineRoot && downloadRoot);
@@ -25872,9 +26031,9 @@ function hqSeriesFromResults(resultItems) {
 function engineHasAnyHqSeries(engineRoot, series) {
   if (!engineRoot || series.length === 0) return void 0;
   for (const { exchangeId, dataType } of series) {
-    const dir = path11.join(engineRoot, "hqdata", "his", exchangeId, dataType);
+    const dir = path12.join(engineRoot, "hqdata", "his", exchangeId, dataType);
     try {
-      if (fs11.existsSync(dir) && fs11.readdirSync(dir).length > 0) return true;
+      if (fs12.existsSync(dir) && fs12.readdirSync(dir).length > 0) return true;
     } catch {
       return void 0;
     }
@@ -26869,8 +27028,7 @@ async function startMcpServer() {
         isError: true
       };
     }
-    const defaultedToolArgs = applyToolArgDefaults(tool, args ?? {});
-    const preparedArgs = prepareToolArgs(tool, defaultedToolArgs, backtestRunContexts);
+    const preparedArgs = prepareToolCallArgs(tool, args ?? {}, backtestRunContexts);
     if ("content" in preparedArgs) return preparedArgs;
     const toolArgs = preparedArgs;
     if (tool.localHandler === "currentUser") {
@@ -27444,13 +27602,13 @@ function syncCredentialsFromEnvAtStartup() {
 function signalCliKeepaliveReady() {
   const raw = process.env.ZLT_MCP_KEEPALIVE_READY_FILE?.trim();
   if (process.env.ZLT_MCP_CLI !== "1" || !raw) return;
-  const readyFile = path13.resolve(raw);
-  if (path13.dirname(readyFile) !== path13.resolve(os5.tmpdir()) || !path13.basename(readyFile).startsWith("zlt-mcp-keepalive-")) {
+  const readyFile = path14.resolve(raw);
+  if (path14.dirname(readyFile) !== path14.resolve(os5.tmpdir()) || !path14.basename(readyFile).startsWith("zlt-mcp-keepalive-")) {
     return;
   }
   try {
-    const fd = fs12.openSync(readyFile, "wx", 384);
-    fs12.closeSync(fd);
+    const fd = fs13.openSync(readyFile, "wx", 384);
+    fs13.closeSync(fd);
   } catch (error2) {
     if (error2.code !== "EEXIST") {
       process.stderr.write(`[zlt-mcp-cli] keepalive readiness signal failed: ${error2 instanceof Error ? error2.message : String(error2)}
@@ -27556,6 +27714,8 @@ if (process.argv.length <= 2) {
 Input: omitted arguments mean {}; use --args-json for small objects and --args-file
 for nested configuration or shell-sensitive text. Follow the selected tool schema
 from list --tool <name> --json. Windows paths must be native paths (C:/...), not /c/....
+Tool schema properties are JSON keys, NOT CLI flags: use --args-json '{"params": [...]}'
+for a tool's params property, not --params. Pass the complete argument object.
 Output: by default stdout contains the complete MCP JSON envelope plus cliProvenance.
 JSON business responses are inside content[].text (or structuredContent when present).
 Use --output-json for large results or downstream evidence: it saves the complete
@@ -27566,45 +27726,69 @@ parsing output. Do not discard stderr, merge it into JSON, or pipe calls through
 head/tail/parsers that can hide the CLI exit code. --no-progress only disables progress.
 If saving fails after execution, the complete response is on stdout; preserve it
 and inspect the returned state before retrying any operation that may have run.
+Thrown call failures emit Error: followed by JSON on stderr with stage, message,
+toolExecution and retry. not_started means the CLI did not call the tool; correct
+the input/path before retrying. unknown means execution may have occurred (including
+transport or keepalive failure); inspect state first. response_received means a
+response was received, not that the business succeeded; inspect that result first.
 Credentials belong in the configured local credential store, never in arguments.
 `).action(async (tool, options) => {
     let outputFd;
+    let stage = "arguments";
+    let toolExecution = "not_started";
     try {
       const args = parseMcpArgs(options.argsJson, options.argsFile);
       const timeoutMs = parseTimeoutOption(options.timeoutMs, "--timeout-ms");
       const maxTotalTimeoutMs = parseTimeoutOption(options.maxTotalTimeoutMs, "--max-total-timeout-ms");
-      const resultFile = options.outputJson === void 0 ? void 0 : path14.resolve(options.outputJson);
-      if (resultFile !== void 0) outputFd = fs13.openSync(resultFile, "wx");
+      const resultFile = options.outputJson === void 0 ? void 0 : path15.resolve(options.outputJson);
+      stage = "output_prepare";
+      if (resultFile !== void 0) outputFd = fs14.openSync(resultFile, "wx");
+      stage = "tool_call";
+      toolExecution = "unknown";
       const result = await callMcpTool(tool, args, {
         timeoutMs,
         maxTotalTimeoutMs,
         showProgress: options.progress !== false
       });
+      toolExecution = "response_received";
+      stage = "output_serialize";
       const complete = withCliProvenance(result);
       const serialized = JSON.stringify(complete) + "\n";
       if (outputFd !== void 0 && resultFile !== void 0) {
+        stage = "output_write";
         try {
-          fs13.writeFileSync(outputFd, serialized, "utf-8");
-          fs13.closeSync(outputFd);
+          fs14.writeFileSync(outputFd, serialized, "utf-8");
+          fs14.closeSync(outputFd);
           outputFd = void 0;
         } catch (error2) {
           process.stdout.write(serialized);
           throw new Error(`Tool returned a result, but saving ${resultFile} failed; complete result is on stdout. Do not repeat the tool automatically. ${String(error2)}`);
         }
+        stage = "output_emit";
         const receipt = compactCliReceipt(tool, complete, resultFile);
         process.stdout.write(JSON.stringify(receipt) + "\n");
         if (!receipt.ok) process.exitCode = 1;
       } else {
+        stage = "output_emit";
         process.stdout.write(serialized);
       }
       if (result.isError === true) process.exitCode = 1;
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : String(error2);
-      process.stderr.write(`Error: ${message}
+      const code = error2?.code;
+      const retry = toolExecution === "not_started" ? "fix_input_then_retry" : toolExecution === "response_received" ? "inspect_result_before_retry" : "inspect_state_before_retry";
+      process.stderr.write(`Error: ${JSON.stringify({
+        tool,
+        stage,
+        toolExecution,
+        retry,
+        ...typeof code === "string" ? { code } : {},
+        message
+      })}
 `);
       process.exitCode = 1;
     } finally {
-      if (outputFd !== void 0) fs13.closeSync(outputFd);
+      if (outputFd !== void 0) fs14.closeSync(outputFd);
     }
   });
   program2.command("list").description("List MCP tools exposed by the bundled server").option("--json", "Emit the complete tools/list response as JSON").option("--tool <name>", "Select one exact tool name; combine with --json for its complete schema").addHelpText("after", "\nReuse discovery within a task. Query one schema with list --tool <name> --json.\nUnknown names fail with exit code 1. Preserve stderr separately from JSON stdout.").action(async (options) => {
@@ -27613,7 +27797,12 @@ Credentials belong in the configured local credential store, never in arguments.
       if (options.tool !== void 0) {
         const tools2 = Array.isArray(result.tools) ? result.tools.filter((tool) => tool.name === options.tool) : [];
         if (tools2.length === 0) throw new Error(`Unknown tool: ${options.tool}. Use list to discover available names.`);
-        result = { ...result, tools: tools2 };
+        result = { ...result, tools: tools2, cliUsage: {
+          command: `call ${options.tool}`,
+          argumentsOption: "--args-json",
+          argumentsAreCliFlags: false,
+          instruction: "Put tool schema properties inside one JSON object passed to --args-json (or use --args-file). Do not turn properties into --flags."
+        } };
       }
       if (options.json) {
         process.stdout.write(JSON.stringify(withCliProvenance(result)) + "\n");
@@ -27684,17 +27873,17 @@ function resolveCliVersion() {
   return resolveCliPackageProvenance().packageVersion;
 }
 function resolveCliPackageProvenance() {
-  let current = path14.dirname(path14.resolve(process.argv[1] || process.cwd()));
+  let current = path15.dirname(path15.resolve(process.argv[1] || process.cwd()));
   for (let depth = 0; depth < 6; depth += 1) {
-    const manifestPath = path14.join(current, "package.json");
+    const manifestPath = path15.join(current, "package.json");
     try {
-      const manifest = JSON.parse(fs13.readFileSync(manifestPath, "utf-8"));
+      const manifest = JSON.parse(fs14.readFileSync(manifestPath, "utf-8"));
       if ((manifest.name === "@zltquant/zlt-mcp" || manifest.name === "zlt-mcp-proxy") && typeof manifest.version === "string") {
         return { packageName: manifest.name, packageVersion: manifest.version };
       }
     } catch {
     }
-    const parent = path14.dirname(current);
+    const parent = path15.dirname(current);
     if (parent === current) break;
     current = parent;
   }