@zltquant/zlt-mcp 0.5.0 → 0.6.0-beta.1

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)}
@@ -27547,54 +27705,98 @@ if (process.argv.length <= 2) {
   startMcpServer();
 } else {
   const program2 = new Command();
-  program2.name(CLI_NAME).description("MCP proxy for ZLTHost IPC service").version(resolveCliVersion());
+  program2.name(CLI_NAME).description("MCP proxy for ZLTHost IPC service").version(resolveCliVersion()).addHelpText("after", "\nDiscovery: list for names; list --tool <name> --json for one complete input schema.\nUse call --help for input, output and diagnostic handling.");
   program2.command("__keepalive <kind> <id> [codePath]", { hidden: true }).action(async (kind, id, codePath) => {
     if (kind !== "backtest") throw new Error(`Unsupported keepalive kind: ${kind}`);
     await keepMcpBacktestAlive(id, codePath);
   });
-  program2.command("call <tool>").description("Call any MCP tool through the bundled MCP server").option("--args-json <json>", "JSON object containing tool arguments").option("--args-file <path>", "Read the JSON argument object from a file").option("--output-json <path>", "Save the complete result to a new JSON file and print a compact receipt").option("--timeout-ms <ms>", "MCP request inactivity timeout in milliseconds").option("--max-total-timeout-ms <ms>", "Optional hard upper bound for the request").option("--no-progress", "Suppress progress diagnostics on stderr").action(async (tool, options) => {
+  program2.command("call <tool>").description("Call any MCP tool through the bundled MCP server").option("--args-json <json>", "JSON object containing tool arguments").option("--args-file <path>", "Read the JSON argument object from a file").option("--output-json <path>", "Save the complete result to a new JSON file and print a compact receipt").option("--timeout-ms <ms>", "MCP request inactivity timeout in milliseconds").option("--max-total-timeout-ms <ms>", "Optional hard upper bound for the request").option("--no-progress", "Suppress progress diagnostics on stderr").addHelpText("after", `
+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/....
+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
+envelope and prints only a compact receipt. The parent directory must exist and the
+file must be new. A receipt is not the full business response.
+Diagnostics: preserve stderr separately and check this process's exit code before
+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").action(async (options) => {
+  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) => {
     try {
-      const result = await listMcpTools();
+      let result = await listMcpTools();
+      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 };
+      }
       if (options.json) {
         process.stdout.write(JSON.stringify(withCliProvenance(result)) + "\n");
         return;
@@ -27664,17 +27866,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;
   }