@zltquant/zlt-mcp 0.7.2-beta.0 → 0.7.3

package/package.json

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

package/zlt-mcp-proxy.bundle.cjs

@@ -10609,11 +10609,59 @@ var {
 // src/cli-evidence.ts
 var fs = __toESM(require("node:fs"), 1);
 var path = __toESM(require("node:path"), 1);
+var READABLE_LINE_LIMIT = 1e3;
+function readableValue(value) {
+  if (Array.isArray(value)) return value.map(readableValue);
+  if (!value || typeof value !== "object") return value;
+  const source = value;
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const [key, entry] of Object.entries(source)) result[key] = readableValue(entry);
+  if (source.type === "text" && typeof source.text === "string") {
+    try {
+      result.text = {
+        displayNote: "Parsed from content[].text JSON. Exact original text remains in result.json.",
+        parsedJson: readableValue(JSON.parse(source.text))
+      };
+    } catch {
+      result.text = source.text;
+    }
+  }
+  return result;
+}
+function takeChunk(value, limit) {
+  let end = Math.min(limit, value.length);
+  if (end < value.length && end > 0) {
+    const code = value.charCodeAt(end - 1);
+    if (code >= 55296 && code <= 56319) end -= 1;
+  }
+  return [value.slice(0, end), value.slice(end)];
+}
+function buildReadableEvidence(value) {
+  const header = [
+    "ZLT CLI readable evidence v1 - DISPLAY ONLY; result.json is the authoritative complete saved result.",
+    "WRAPPING: | starts a rendered logical line; + continues the preceding line. Strip the first character and join + lines before interpretation.",
+    "Embedded content[].text that is valid JSON is expanded under parsedJson; non-JSON text is preserved as text."
+  ];
+  const rendered = JSON.stringify(readableValue(value), null, 2).split("\n");
+  const lines = [...header];
+  for (const logical of rendered) {
+    let remaining = logical;
+    let marker = "|";
+    do {
+      const [chunk, rest] = takeChunk(remaining, READABLE_LINE_LIMIT - 1);
+      lines.push(marker + chunk);
+      marker = "+";
+      remaining = rest;
+    } while (remaining.length > 0);
+  }
+  return lines.join("\n") + "\n";
+}
 function evidenceDirectoryArg(args) {
-  if (!["call", "list"].includes(args[0])) return void 0;
+  const authCommand = args[0] === "auth" && ["login", "status", "wait"].includes(args[1]);
+  if (!["call", "list"].includes(args[0]) && !authCommand) return void 0;
   let directory;
-  const valueOptions = /* @__PURE__ */ new Set(["--args-json", "--args-file", "--output-json", "--tool", "--timeout-ms", "--max-total-timeout-ms"]);
-  for (let i = 1; i < args.length && args[i] !== "--"; i++) {
+  const valueOptions = /* @__PURE__ */ new Set(["--args-json", "--args-file", "--output-json", "--tool", "--timeout-ms", "--max-total-timeout-ms", "--session"]);
+  for (let i = authCommand ? 2 : 1; i < args.length && args[i] !== "--"; i++) {
     const arg = args[i];
     if (valueOptions.has(arg)) {
       i++;
@@ -10629,6 +10677,7 @@ function evidenceDirectoryArg(args) {
 }
 var CliEvidence = class {
   resultFile;
+  readableFile;
   diagnosticsFile;
   executionFile;
   state;
@@ -10640,6 +10689,7 @@ var CliEvidence = class {
     const root2 = path.resolve(directory);
     fs.mkdirSync(root2);
     this.resultFile = path.join(root2, "result.json");
+    this.readableFile = path.join(root2, "result.readable.txt");
     this.diagnosticsFile = path.join(root2, "diagnostics.log");
     this.executionFile = path.join(root2, "execution.json");
     this.state = {
@@ -10653,6 +10703,7 @@ var CliEvidence = class {
       business: "not_reported",
       exitCode: null,
       resultFile: this.resultFile,
+      readableFile: this.readableFile,
       diagnosticsFile: this.diagnosticsFile,
       retry: "inspect_state_before_retry"
     };
@@ -10682,6 +10733,13 @@ var CliEvidence = class {
   checkDiagnostics() {
     if (this.diagnosticFailure) throw new Error(`Saving diagnostics failed: ${this.diagnosticFailure.message}`);
   }
+  writeReadable(value) {
+    fs.writeFileSync(this.readableFile, buildReadableEvidence(value), { encoding: "utf8", flag: "wx" });
+  }
+  writeResult(value) {
+    fs.writeFileSync(this.resultFile, JSON.stringify(value) + "\n", { encoding: "utf8", flag: "wx" });
+    this.writeReadable(value);
+  }
   started(tool) {
     this.checkDiagnostics();
     this.state = { ...this.state, ...tool ? { tool } : {}, stage: "tool_call", toolExecution: "unknown" };
@@ -10730,7 +10788,7 @@ var CliEvidence = class {
     this.failed(stage, this.state.toolExecution, this.state.business);
   }
   receiptFields() {
-    return { executionFile: this.executionFile, diagnosticsFile: this.diagnosticsFile };
+    return { executionFile: this.executionFile, diagnosticsFile: this.diagnosticsFile, readableFile: this.readableFile };
   }
   close() {
     if (process.stderr.write === this.teeWrite) process.stderr.write = this.originalWrite;
@@ -10766,9 +10824,12 @@ same MCP connection through mcp-wait. Progress can remain unchanged while data i
 prepared; read stderr and do not restart from a progress warning. If isTerminal=true,
 finalize that run without waiting again. Interrupted waits identify the runId,
 codePath, and attemptFence for inspection; never restart automatically.`;
-var REFERENCING_TOOLS = /* @__PURE__ */ new Set(["mcp-get-cache-diff", "mcp-get-cloud-data-list"]);
 var REFERENCE_SOURCE_TOOL = "mcp-download-data";
-var REFERENCE_PROPERTY = "exchange_id";
+var REFERENCED_PROPERTIES_BY_TOOL = /* @__PURE__ */ new Map([
+  ["mcp-get-cache-diff", ["exchange_id"]],
+  ["mcp-get-cloud-data-list", ["exchange_id"]],
+  ["mcp-get-data-range", ["exchange_id", "data_type"]]
+]);
 function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
@@ -10884,17 +10945,22 @@ function buildArgumentExample(tool) {
 }
 function relatedParameterHelp(tool, tools) {
   const name = typeof tool.name === "string" ? tool.name : "";
-  if (!REFERENCING_TOOLS.has(name)) return void 0;
-  const referenced = schemaProperty(tool, REFERENCE_PROPERTY);
-  if (typeof referenced?.description !== "string" || !referenced.description.includes(REFERENCE_SOURCE_TOOL)) return void 0;
+  const properties = REFERENCED_PROPERTIES_BY_TOOL.get(name);
+  if (!properties) return void 0;
   const source = tools.find((candidate) => candidate.name === REFERENCE_SOURCE_TOOL);
-  const sourceProperty = source && schemaProperty(source, REFERENCE_PROPERTY);
-  if (typeof sourceProperty?.description !== "string" || sourceProperty.description.length === 0) return void 0;
-  return [{
-    sourceTool: REFERENCE_SOURCE_TOOL,
-    property: REFERENCE_PROPERTY,
-    description: sourceProperty.description
-  }];
+  if (!source) return void 0;
+  const related = [];
+  for (const property of properties) {
+    const referenced = schemaProperty(tool, property);
+    const sourceProperty = schemaProperty(source, property);
+    if (typeof referenced?.description !== "string" || !referenced.description.includes(REFERENCE_SOURCE_TOOL) || typeof sourceProperty?.description !== "string" || sourceProperty.description.length === 0) return void 0;
+    related.push({
+      sourceTool: REFERENCE_SOURCE_TOOL,
+      property,
+      description: sourceProperty.description
+    });
+  }
+  return related;
 }
 function buildCliUsage(tool, tools) {
   const name = typeof tool.name === "string" ? tool.name : "";
@@ -10919,6 +10985,7 @@ function buildCliUsage(tool, tools) {
         mutuallyExclusiveWith: "--output-json",
         files: {
           resultJson: "result.json is exclusively reserved before execution. It is parseable only after a complete response is saved; existence alone does not prove a response was received, and disconnects or write failures can leave it empty or partial.",
+          resultReadableTxt: "result.readable.txt is a display-only, line-bounded view that expands JSON inside content[].text without truncating content. result.json remains authoritative.",
           diagnosticsLog: "diagnostics.log captures CLI and child-MCP diagnostics while stderr remains live.",
           executionJson: "execution.json records state, toolExecution, business outcome, and the CLI exitCode."
         },
@@ -24893,6 +24960,17 @@ var MARKET_CODE_TO_NAME = {
   sj: "\u4E0A\u91D1\u6240(sj)",
   bs: "\u6E24\u5546(bs)"
 };
+var LEGACY_MARKET_ID_TO_CODE = {
+  29544: "sh",
+  29562: "sz",
+  31338: "zj",
+  31347: "zs",
+  25715: "ds",
+  29553: "sq",
+  26481: "gq",
+  29546: "sj",
+  25203: "bs"
+};
 var DC_SDK_CONFIG_SEGMENTS = ["python", "Lib", "site-packages", "zltsdk", "moudles", "dc_sdk.json"];
 var DCM_CONFIG_SEGMENTS = ["zltHost", "moudles", "dcm.json"];
 var dataRootsCache = /* @__PURE__ */ new Map();
@@ -24933,6 +25011,36 @@ function resolveDataRoots(clientRootDir) {
   return status;
 }
 var HQ_DATA_FAMILIES = /* @__PURE__ */ new Set(["dk", "mk", "tk"]);
+function requestedSeriesKey(series) {
+  return JSON.stringify([series.exchangeId, series.dataType]);
+}
+function seriesIdentity(value) {
+  if (!isRecord4(value)) return void 0;
+  const exchangeRaw = value.exchange_id ?? value.exchangeid ?? value.exchange;
+  const legacyExchange = finiteDataRangeNumber(exchangeRaw);
+  const exchangeId = LEGACY_MARKET_ID_TO_CODE[legacyExchange] ?? String(exchangeRaw ?? "").trim().toLowerCase();
+  let dataType = String(value.data_type ?? value.datatype ?? "").trim().toLowerCase();
+  if (/^(dk|mk|tk)$/.test(dataType)) {
+    const securityType = finiteDataRangeNumber(value.securitytype ?? value.sectype);
+    if (securityType > 0 && securityType % 16 === 0) dataType += (securityType / 16).toString(16);
+  }
+  if (!dataType) return void 0;
+  return { exchangeId, dataType };
+}
+function requestedSeriesFromParams(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const series = [];
+  for (const item of value) {
+    const identity = seriesIdentity(item);
+    if (!identity) continue;
+    const key = requestedSeriesKey(identity);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    series.push(identity);
+  }
+  return series;
+}
 function hqSeriesFromResults(resultItems) {
   const series = [];
   for (const item of resultItems) {
@@ -24947,17 +25055,25 @@ function hqSeriesFromResults(resultItems) {
 }
 function engineHasAnyHqSeries(engineRoot, series) {
   if (!engineRoot || series.length === 0) return void 0;
-  for (const { exchangeId, dataType } of series) {
-    const dir = path19.join(engineRoot, "hqdata", "his", exchangeId, dataType);
-    try {
-      if (fs20.existsSync(dir) && fs20.readdirSync(dir).length > 0) return true;
-    } catch {
-      return void 0;
-    }
+  for (const requested of series) {
+    const present = engineHasHqSeries(engineRoot, requested);
+    if (present === true) return true;
+    if (present === void 0) return void 0;
   }
   return false;
 }
-function formatDataRangeResult(rawResult, dataRoots) {
+function engineHasHqSeries(engineRoot, series) {
+  if (!engineRoot || !series.exchangeId || !HQ_DATA_FAMILIES.has(splitDataTypeToken(series.dataType).family)) {
+    return void 0;
+  }
+  const dir = path19.join(engineRoot, "hqdata", "his", series.exchangeId, series.dataType);
+  try {
+    return fs20.readdirSync(dir).length > 0;
+  } catch (error2) {
+    return isRecord4(error2) && error2.code === "ENOENT" ? false : void 0;
+  }
+}
+function formatDataRangeResult(rawResult, dataRoots, requestedParams) {
   if (!isRecord4(rawResult)) return rawResult;
   const nestedStatus = isRecord4(rawResult.Data) ? rawResult.Data.coverageStatus : void 0;
   if (isDataRangeCoverageStatus(nestedStatus) || isDataRangeCoverageStatus(rawResult.coverageStatus)) {
@@ -24968,8 +25084,27 @@ function formatDataRangeResult(rawResult, dataRoots) {
   const resultItems = Array.isArray(data) ? data : isRecord4(data) && Array.isArray(data.results) ? data.results : [];
   const seriesOrder = [];
   const seriesByKey = /* @__PURE__ */ new Map();
+  const returnedSeriesOrder = [];
+  const returnedSeriesByKey = /* @__PURE__ */ new Map();
   for (const item of resultItems) {
     if (!isRecord4(item)) continue;
+    const identity = seriesIdentity(item);
+    let returnedEvidence;
+    if (identity) {
+      const identityKey = requestedSeriesKey(identity);
+      returnedEvidence = returnedSeriesByKey.get(identityKey);
+      if (!returnedEvidence) {
+        returnedEvidence = {
+          ...identity,
+          hasIntervals: false,
+          explicitMissing: hasExplicitMissingMarker(item)
+        };
+        returnedSeriesByKey.set(identityKey, returnedEvidence);
+        returnedSeriesOrder.push(identityKey);
+      } else if (hasExplicitMissingMarker(item)) {
+        returnedEvidence.explicitMissing = true;
+      }
+    }
     const exchangeRaw = item.exchange_id ?? item.exchangeid ?? item.exchange;
     const datatypeRaw = item.data_type ?? item.datatype;
     const sectypeRaw = item.securitytype ?? item.sectype;
@@ -24992,6 +25127,7 @@ function formatDataRangeResult(rawResult, dataRoots) {
       const endDate = compactDataRangeDate(time3.end);
       if (!startDate || !endDate) continue;
       series.intervals.push([startDate, endDate]);
+      if (returnedEvidence) returnedEvidence.hasIntervals = true;
     }
   }
   const ranges = [];
@@ -25003,8 +25139,58 @@ function formatDataRangeResult(rawResult, dataRoots) {
     }
   }
   const errNo = Number(rawResult.ErrNo);
-  if (Number.isFinite(errNo) && errNo !== 0) {
-    return withDataRangeInterpretation(rawResult, "unknown", true, "upstream-error", [], "report-error");
+  const upstreamFailed = Number.isFinite(errNo) && errNo !== 0;
+  const rootSplit = Boolean(dataRoots?.resolved && !dataRoots.agree);
+  const explicitGlobalMissing = hasExplicitMissingMarker(data);
+  const requestedSeries = requestedSeriesFromParams(requestedParams);
+  const coverageOrder = [...requestedSeries.map(requestedSeriesKey)];
+  const coverageByKey = new Map(requestedSeries.map((series) => [requestedSeriesKey(series), series]));
+  for (const key of returnedSeriesOrder) {
+    if (coverageByKey.has(key)) continue;
+    const returned = returnedSeriesByKey.get(key);
+    if (!returned) continue;
+    coverageByKey.set(key, returned);
+    coverageOrder.push(key);
+  }
+  const seriesCoverage = coverageOrder.map((key) => {
+    const series = coverageByKey.get(key);
+    const returned = returnedSeriesByKey.get(key);
+    const identity = {
+      ...series.exchangeId ? { exchange_id: series.exchangeId } : {},
+      data_type: series.dataType
+    };
+    if (upstreamFailed) {
+      return { ...identity, coverageStatus: "unknown", blocksBacktest: true, reasonCode: "upstream-error", nextAction: "report-error" };
+    }
+    if (rootSplit) {
+      return { ...identity, coverageStatus: "unknown", blocksBacktest: true, reasonCode: "data-root-split", nextAction: "resolve-data-root-split" };
+    }
+    if (!returned) {
+      if (explicitGlobalMissing) {
+        return { ...identity, coverageStatus: "unknown", blocksBacktest: true, reasonCode: "explicit-missing", nextAction: "report-missing-data" };
+      }
+      return { ...identity, coverageStatus: "unknown", blocksBacktest: false, reasonCode: "upstream-omitted", nextAction: "recheck-coverage" };
+    }
+    if (returned.explicitMissing) {
+      return { ...identity, coverageStatus: "missing", blocksBacktest: true, reasonCode: "explicit-missing", nextAction: "report-missing-data" };
+    }
+    if (explicitGlobalMissing) {
+      return { ...identity, coverageStatus: "unknown", blocksBacktest: true, reasonCode: "explicit-missing", nextAction: "report-missing-data" };
+    }
+    if (returned.hasIntervals) {
+      return { ...identity, coverageStatus: "available", blocksBacktest: false, reasonCode: "explicit-ranges", nextAction: "run-backtest" };
+    }
+    const family = splitDataTypeToken(series.dataType).family;
+    if (dataRoots?.resolved && dataRoots.agree && HQ_DATA_FAMILIES.has(family)) {
+      const present = engineHasHqSeries(dataRoots.engineRoot, series);
+      if (present === false) {
+        return { ...identity, coverageStatus: "missing", blocksBacktest: true, reasonCode: "no-local-files", nextAction: "download-and-recheck" };
+      }
+    }
+    return { ...identity, coverageStatus: "unknown", blocksBacktest: false, reasonCode: "no-local-coverage", nextAction: "run-backtest" };
+  });
+  if (upstreamFailed) {
+    return withDataRangeInterpretation(rawResult, "unknown", true, "upstream-error", [], "report-error", seriesCoverage);
   }
   if (dataRoots?.resolved && !dataRoots.agree) {
     return withDataRangeInterpretation(
@@ -25013,15 +25199,44 @@ function formatDataRangeResult(rawResult, dataRoots) {
       true,
       "data-root-split",
       ranges,
-      `\u6570\u636E\u6839\u4E0D\u4E00\u81F4\uFF1A\u4E0B\u8F7D\u5668\u5199\u5165 ${dataRoots.downloadRoot}\uFF0C\u800C\u7B56\u7565\u5F15\u64CE\u8BFB\u53D6 ${dataRoots.engineRoot}\u3002\u672C\u5730\u6587\u4EF6\u5373\u4F7F\u5B58\u5728\uFF0C\u56DE\u6D4B\u4E5F\u8BFB\u4E0D\u5230\uFF0C\u4F1A\u62A5\u300C\u672C\u5730\u6570\u636E\u4E0D\u8DB3\u300D\u3002\u4E0D\u8981\u636E\u6B64\u5F00\u59CB\u56DE\u6D4B\uFF1B\u8BF7\u5411\u7528\u6237\u62A5\u544A\u8FD9\u4E24\u4E2A\u8DEF\u5F84\uFF0C\u5E76\u8BF4\u660E\u9700\u8981\u4FEE\u590D\u6295\u7814\u6A21\u5757\u7684\u6570\u636E\u6839\u914D\u7F6E\uFF08dc_sdk.json \u7684 mdf.path \u4E0E dcm.json \u7684 download_home\uFF09\u3002`
+      `\u6570\u636E\u6839\u4E0D\u4E00\u81F4\uFF1A\u4E0B\u8F7D\u5668\u5199\u5165 ${dataRoots.downloadRoot}\uFF0C\u800C\u7B56\u7565\u5F15\u64CE\u8BFB\u53D6 ${dataRoots.engineRoot}\u3002\u672C\u5730\u6587\u4EF6\u5373\u4F7F\u5B58\u5728\uFF0C\u56DE\u6D4B\u4E5F\u8BFB\u4E0D\u5230\uFF0C\u4F1A\u62A5\u300C\u672C\u5730\u6570\u636E\u4E0D\u8DB3\u300D\u3002\u4E0D\u8981\u636E\u6B64\u5F00\u59CB\u56DE\u6D4B\uFF1B\u8BF7\u5411\u7528\u6237\u62A5\u544A\u8FD9\u4E24\u4E2A\u8DEF\u5F84\uFF0C\u5E76\u8BF4\u660E\u9700\u8981\u4FEE\u590D\u6295\u7814\u6A21\u5757\u7684\u6570\u636E\u6839\u914D\u7F6E\uFF08dc_sdk.json \u7684 mdf.path \u4E0E dcm.json \u7684 download_home\uFF09\u3002`,
+      seriesCoverage
+    );
+  }
+  if (explicitGlobalMissing) {
+    return withDataRangeInterpretation(rawResult, "missing", true, "explicit-missing", ranges, "report-missing-data", seriesCoverage);
+  }
+  const missingSeries = seriesCoverage.filter((series) => series.coverageStatus === "missing");
+  if (missingSeries.length > 0) {
+    const wanted = missingSeries.map((series) => `${series.exchange_id ? `${series.exchange_id}/` : ""}${series.data_type}`).join("\u3001");
+    const { Data: _rawData, ...envelope } = rawResult;
+    const source = ranges.length > 0 ? envelope : rawResult;
+    return withDataRangeInterpretation(
+      source,
+      "missing",
+      true,
+      missingSeries.every((series) => series.reasonCode === "no-local-files") ? "no-local-files" : "series-missing",
+      ranges,
+      `\u672C\u5730\u7F3A\u5C11 ${wanted}\u3002\u5148\u7528 mcp-download-data \u4E0B\u8F7D\uFF0C\u518D\u7528 mcp-wait kind=download \u7B49\u5F85\u7EC8\u6001\uFF0C\u7136\u540E\u91CD\u65B0\u67E5\u8BE2\u8986\u76D6\u3002`,
+      seriesCoverage
     );
   }
-  if (hasExplicitMissingMarker(data)) {
-    return withDataRangeInterpretation(rawResult, "missing", true, "explicit-missing", ranges, "report-missing-data");
+  const incompleteSeries = seriesCoverage.some((series) => series.coverageStatus === "unknown");
+  if (ranges.length > 0 && incompleteSeries) {
+    const { Data: _rawData, ...withoutRawData } = rawResult;
+    return withDataRangeInterpretation(
+      withoutRawData,
+      "unknown",
+      false,
+      "incomplete-series-coverage",
+      ranges,
+      "recheck-coverage",
+      seriesCoverage
+    );
   }
   if (ranges.length > 0) {
     const { Data: _rawData, ...withoutRawData } = rawResult;
-    return withDataRangeInterpretation(withoutRawData, "available", false, "explicit-ranges", ranges, "run-backtest");
+    return withDataRangeInterpretation(withoutRawData, "available", false, "explicit-ranges", ranges, "run-backtest", seriesCoverage);
   }
   const reasonCode = isEmptyRecord(data) || hasResultCollection && resultItems.length === 0 ? "empty-summary" : hasResultCollection && resultItems.length > 0 ? "no-local-coverage" : "unrecognized-shape";
   if (reasonCode === "no-local-coverage" && dataRoots?.resolved) {
@@ -25034,11 +25249,13 @@ function formatDataRangeResult(rawResult, dataRoots) {
         true,
         "no-local-files",
         [],
-        `\u7B56\u7565\u5F15\u64CE\u7684\u6570\u636E\u6839 ${dataRoots.engineRoot} \u4E0B\u6CA1\u6709 ${wanted} \u7684\u4EFB\u4F55\u6587\u4EF6\uFF0C\u672C\u5730\u786E\u5B9E\u6CA1\u6709\u8FD9\u6279\u884C\u60C5\u3002\u5148\u7528 mcp-download-data \u4E0B\u8F7D\uFF0C\u7528 mcp-get-download-progress \u8F6E\u8BE2\u5230\u7EC8\u6001\uFF0C\u518D\u91CD\u65B0\u67E5\u8986\u76D6\uFF1B\u4E0D\u8981\u76F4\u63A5\u5F00\u59CB\u56DE\u6D4B\u3002`
+        `\u7B56\u7565\u5F15\u64CE\u7684\u6570\u636E\u6839 ${dataRoots.engineRoot} \u4E0B\u6CA1\u6709 ${wanted} \u7684\u4EFB\u4F55\u6587\u4EF6\uFF0C\u672C\u5730\u786E\u5B9E\u6CA1\u6709\u8FD9\u6279\u884C\u60C5\u3002\u5148\u7528 mcp-download-data \u4E0B\u8F7D\uFF0C\u518D\u7528 mcp-wait kind=download \u7B49\u5F85\u7EC8\u6001\uFF0C\u7136\u540E\u91CD\u65B0\u67E5\u8986\u76D6\uFF1B\u4E0D\u8981\u76F4\u63A5\u5F00\u59CB\u56DE\u6D4B\u3002`,
+        seriesCoverage
       );
     }
   }
-  return withDataRangeInterpretation(rawResult, "unknown", false, reasonCode, [], "run-backtest");
+  const finalReasonCode = requestedSeries.length > 0 && seriesCoverage.some((series) => series.reasonCode === "upstream-omitted") ? "incomplete-series-coverage" : reasonCode;
+  return withDataRangeInterpretation(rawResult, "unknown", false, finalReasonCode, [], "run-backtest", seriesCoverage);
 }
 function unionDataRangeIntervals(intervals) {
   const sorted = [...intervals].sort((a, b) => a[0] === b[0] ? a[1].localeCompare(b[1]) : a[0].localeCompare(b[0]));
@@ -25053,9 +25270,9 @@ function unionDataRangeIntervals(intervals) {
   }
   return merged;
 }
-function withDataRangeInterpretation(rawResult, coverageStatus, blocksBacktest, reasonCode, ranges, nextAction) {
+function withDataRangeInterpretation(rawResult, coverageStatus, blocksBacktest, reasonCode, ranges, nextAction, seriesCoverage) {
   const { Data: upstreamData, ...envelope } = rawResult;
-  const data = { coverageStatus, blocksBacktest, reasonCode, nextAction, ranges };
+  const data = { coverageStatus, blocksBacktest, reasonCode, nextAction, ranges, seriesCoverage };
   if (isRecord4(upstreamData)) {
     for (const [key, value] of Object.entries(upstreamData)) {
       if (!(key in data)) data[key] = value;
@@ -25358,7 +25575,7 @@ function compactDataRangeDate(value) {
 
 // src/tool-response.ts
 var identityRepairHint = (data) => data;
-function handleIpcResponse(response, tool, repairHint = identityRepairHint, dataRoots) {
+function handleIpcResponse(response, tool, repairHint = identityRepairHint, dataRoots, requestedDataRanges) {
   const parsed = parseIpcRawResponse(response);
   if (!parsed.isSuccess) {
     return {
@@ -25367,18 +25584,18 @@ function handleIpcResponse(response, tool, repairHint = identityRepairHint, data
     };
   }
   const data = repairHint(parsed.data);
-  const text2 = typeof data === "string" ? applyResponseTransform(data, tool, dataRoots) : applyResponseTransform(JSON.stringify(data), tool, dataRoots);
+  const text2 = typeof data === "string" ? applyResponseTransform(data, tool, dataRoots, requestedDataRanges) : applyResponseTransform(JSON.stringify(data), tool, dataRoots, requestedDataRanges);
   return {
     content: [{ type: "text", text: text2 }],
     isError: isIpcBusinessError(data) || void 0
   };
 }
-function applyResponseTransform(text2, tool, dataRoots) {
+function applyResponseTransform(text2, tool, dataRoots, requestedDataRanges) {
   if (!tool?.responseTransform || !text2) return text2;
   try {
     const parsed = JSON.parse(text2);
     if (tool.responseTransform === "dataRange") {
-      return JSON.stringify(formatDataRangeResult(parsed, dataRoots));
+      return JSON.stringify(formatDataRangeResult(parsed, dataRoots, requestedDataRanges));
     }
     if (tool.responseTransform === "downloadProgress") {
       return JSON.stringify(formatDownloadProgressResult(parsed));
@@ -28537,7 +28754,7 @@ async function startMcpServer() {
     }
     try {
       const response = await ipcClient.invoke(ipcUri, params, body, timeout);
-      const result = shapeToolResult(tool, toolArgs, handleIpcResponse(response, tool, withRuntimeRepairHint, dataRoots), session);
+      const result = shapeToolResult(tool, toolArgs, handleIpcResponse(response, tool, withRuntimeRepairHint, dataRoots, toolArgs.params), session);
       if (name === "mcp-download-data") recordActiveDownload(result);
       return result;
     } catch (err) {
@@ -28545,7 +28762,7 @@ async function startMcpServer() {
       if (reconnectedClient) {
         try {
           const response = await reconnectedClient.invoke(ipcUri, params, body, timeout);
-          const result = shapeToolResult(tool, toolArgs, handleIpcResponse(response, tool, withRuntimeRepairHint, dataRoots), session);
+          const result = shapeToolResult(tool, toolArgs, handleIpcResponse(response, tool, withRuntimeRepairHint, dataRoots, toolArgs.params), session);
           if (name === "mcp-download-data") recordActiveDownload(result);
           return result;
         } catch (retryErr) {
@@ -29220,6 +29437,7 @@ var path25 = __toESM(require("node:path"), 1);
 var import_node_crypto5 = require("node:crypto");
 var SOURCE = "zlt-mcp-device-login";
 var IGNORED_API_ENV = /* @__PURE__ */ new Set(["ZLTQUANT_API_KEY", "ZLTQUANT_API_BASE"]);
+var SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function authCliEnv(env) {
   return Object.fromEntries(
     Object.entries(env).filter(([key]) => !IGNORED_API_ENV.has(key.toUpperCase()))
@@ -29289,9 +29507,12 @@ function authErrorMessage(error2) {
   return "Authentication operation failed; check local credential configuration and storage permissions. No credential was returned.";
 }
 function sessionPath(id, e = process.env) {
-  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id)) throw Error("Invalid authentication session");
+  if (!SESSION_ID.test(id)) throw Error("Invalid authentication session");
   return path25.join(root(e), id + ".json");
 }
+function validateAuthSessionId(id) {
+  if (!SESSION_ID.test(id)) throw Error("Invalid authentication session");
+}
 function drop(id, e = process.env) {
   fs26.rmSync(sessionPath(id, e), { force: true });
 }
@@ -29299,7 +29520,7 @@ function preflight(e) {
   if (e.ZLTQUANT_CREDENTIALS || readCredentials(e))
     throw Error("Authentication is already configured");
 }
-async function finish(s, e, c, json) {
+async function finish(s, e, c, json, emit = true) {
   const grant = await c.poll(s, {
     maxDurationMs: s.expiresIn * 1e3
   });
@@ -29314,7 +29535,7 @@ async function finish(s, e, c, json) {
     apiKeyMask: a.apiKeyMask,
     apiBase: a.apiBase
   };
-  process.stdout.write(json ? JSON.stringify(o) + "\n" : `Signed in (${a.apiKeyMask}).
+  if (emit) process.stdout.write(json ? JSON.stringify(o) + "\n" : `Signed in (${a.apiKeyMask}).
 `);
   return o;
 }
@@ -29332,10 +29553,10 @@ async function runAuthLogin(o = {}) {
       expiresIn: s.expiresIn,
       widget: buildShowWidgetPayload(s)
     };
-    process.stdout.write(JSON.stringify(out) + "\n");
+    if (o.emit !== false) process.stdout.write(JSON.stringify(out) + "\n");
     return out;
   }
-  process.stdout.write(
+  if (o.emit !== false) process.stdout.write(
     o.json ? JSON.stringify({
       status: "pending",
       verificationUri: s.verificationUri,
@@ -29343,7 +29564,7 @@ async function runAuthLogin(o = {}) {
     }) + "\n" : `Open ${s.verificationUri} and enter code ${s.userCode}.
 `
   );
-  return finish(s, e, c, o.json);
+  return finish(s, e, c, o.json, o.emit !== false);
 }
 async function runAuthWait(id, o = {}) {
   const e = authCliEnv(o.env || process.env);
@@ -29357,7 +29578,7 @@ async function runAuthWait(id, o = {}) {
   }
   try {
     const x = load(id, e);
-    const result = await finish(x.authorization, e, o.client || client, o.json);
+    const result = await finish(x.authorization, e, o.client || client, o.json, o.emit !== false);
     drop(id, e);
     return result;
   } catch (error2) {
@@ -29401,7 +29622,10 @@ if (process.argv.length <= 2) {
   let evidenceSetupError;
   try {
     const directory = evidenceDirectoryArg(process.argv.slice(2));
-    if (directory !== void 0) evidence = new CliEvidence(directory, resolveCliPackageProvenance(), process.argv[2]);
+    if (directory !== void 0) {
+      const command = process.argv[2] === "auth" ? `auth ${process.argv[3] ?? ""}`.trim() : process.argv[2];
+      evidence = new CliEvidence(directory, resolveCliPackageProvenance(), command);
+    }
   } catch (error2) {
     evidenceSetupError = error2;
   }
@@ -29422,34 +29646,127 @@ if (process.argv.length <= 2) {
   });
   program2.name(CLI_NAME).description("MCP proxy for ZLTHost IPC service").version(resolveCliVersion()).configureOutput({ outputError: writeCliArgumentError }).addHelpText("after", "\nDiscovery: list for names; list --tool <name> --json for one complete input schema.\nUse call --help for input, output and diagnostic handling.\nFor npx registry selection, put --registry before the package name; it is not a zlt-mcp option.");
   const auth = program2.command("auth").description("Manage local ZLT Quant authentication");
-  auth.command("login").description("Sign in with a device code").option("--json", "Emit a JSON descriptor and status").option("--widget", "Return a login card immediately; render it before running auth wait").addHelpText("after", "\nAgent flow: auth login --widget --json returns a local session ID and widget descriptor.\nInvoke the host show_widget tool with widget.arguments, or show the login URL/code.\nThen run auth wait --session <returned-id> --json. The descriptor alone does not render a widget.\nWithout --widget this command waits in the foreground. Never paste keys or private session files into chat.").action(async (options) => {
+  auth.command("login").description("Sign in with a device code").option("--json", "Emit a JSON descriptor and status").option("--widget", "Return a login card immediately; render it before running auth wait").option("--evidence-dir <path>", "Create a new directory for the display-safe login descriptor and execution status; requires --widget").addHelpText("after", "\nAgent flow: auth login --widget --json returns a local session ID and widget descriptor.\nInvoke the host show_widget tool with widget.arguments, or show the login URL/code.\nThen run auth wait --session <returned-id> --json. The descriptor alone does not render a widget.\nWithout --widget this command waits in the foreground. Never paste keys or private session files into chat.").action(async (options) => {
+    let toolExecution = "not_started";
+    let stage = "arguments";
+    let response;
     try {
-      await runAuthLogin(options);
+      if (evidence && !options.widget) throw new Error("--evidence-dir requires --widget for auth login");
+      evidence?.started();
+      toolExecution = evidence ? "unknown" : "not_started";
+      stage = "auth_login";
+      const result = await runAuthLogin({ ...options, emit: !evidence });
+      response = result;
+      if (!evidence) return;
+      toolExecution = "response_received";
+      stage = "output_write";
+      evidence.writeResult(result);
+      stage = "output_emit";
+      evidence.completed("not_reported", 0);
+      process.stdout.write(JSON.stringify({
+        ok: true,
+        command: "auth login",
+        resultFile: evidence.resultFile,
+        cliProvenance: resolveCliPackageProvenance(),
+        ...evidence.receiptFields()
+      }) + "\n");
     } catch (error2) {
-      process.stderr.write(`Error: ${authErrorMessage(error2)}
+      if (toolExecution === "response_received" && response !== void 0) {
+        process.stdout.write(JSON.stringify(response) + "\n");
+      }
+      const message = error2 instanceof Error && error2.message === "--evidence-dir requires --widget for auth login" ? error2.message : authErrorMessage(error2);
+      process.stderr.write(`Error: ${message}
 `);
       process.exitCode = 1;
+      try {
+        evidence?.failed(stage, toolExecution);
+      } catch (saveError) {
+        process.stderr.write(`Error: execution evidence could not be finalized: ${String(saveError)}
+`);
+      }
     }
   });
-  auth.command("status").description("Show masked local authentication status").option("--json", "Emit JSON").action((options) => {
+  auth.command("status").description("Show masked local authentication status").option("--json", "Emit JSON").option("--evidence-dir <path>", "Create a new directory for the masked status and execution state").action((options) => {
+    let toolExecution = "not_started";
+    let stage = "status_query";
+    let response;
     try {
+      evidence?.started();
+      toolExecution = evidence ? "unknown" : "not_started";
       const status = authStatus();
-      process.stdout.write(options.json ? `${JSON.stringify(status)}
+      response = status;
+      if (!evidence) {
+        process.stdout.write(options.json ? `${JSON.stringify(status)}
 ` : `${status.configured ? `Configured (${status.apiKeyMask})` : "Not configured"}
 `);
+        return;
+      }
+      toolExecution = "response_received";
+      stage = "output_write";
+      evidence.writeResult(status);
+      stage = "output_emit";
+      evidence.completed("not_reported", 0);
+      process.stdout.write(JSON.stringify({
+        ok: true,
+        command: "auth status",
+        resultFile: evidence.resultFile,
+        cliProvenance: resolveCliPackageProvenance(),
+        ...evidence.receiptFields()
+      }) + "\n");
     } catch (error2) {
+      if (toolExecution === "response_received" && response !== void 0) {
+        process.stdout.write(JSON.stringify(response) + "\n");
+      }
       process.stderr.write(`Error: ${authErrorMessage(error2)}
 `);
       process.exitCode = 1;
+      try {
+        evidence?.failed(stage, toolExecution);
+      } catch (saveError) {
+        process.stderr.write(`Error: execution evidence could not be finalized: ${String(saveError)}
+`);
+      }
     }
   });
-  auth.command("wait").description("Complete a saved device-code sign in").requiredOption("--session <id>", "Opaque local session ID from auth login --widget").option("--json", "Emit JSON").action(async (options) => {
+  auth.command("wait").description("Complete a saved device-code sign in").requiredOption("--session <id>", "Opaque local session ID from auth login --widget").option("--json", "Emit JSON").option("--evidence-dir <path>", "Create a new directory for the display-safe wait receipt and execution state").action(async (options) => {
+    let toolExecution = "not_started";
+    let stage = "arguments";
+    let business = "not_reported";
+    let response;
     try {
-      await runAuthWait(options.session, options);
+      if (evidence) validateAuthSessionId(options.session);
+      evidence?.started();
+      toolExecution = evidence ? "unknown" : "not_started";
+      stage = "auth_wait";
+      const result = await runAuthWait(options.session, { ...options, emit: !evidence });
+      response = result;
+      if (!evidence) return;
+      toolExecution = "response_received";
+      business = "success";
+      stage = "output_write";
+      evidence.writeResult(result);
+      stage = "output_emit";
+      evidence.completed("success", 0);
+      process.stdout.write(JSON.stringify({
+        ok: true,
+        command: "auth wait",
+        resultFile: evidence.resultFile,
+        cliProvenance: resolveCliPackageProvenance(),
+        ...evidence.receiptFields()
+      }) + "\n");
     } catch (error2) {
+      if (toolExecution === "response_received" && response !== void 0) {
+        process.stdout.write(JSON.stringify(response) + "\n");
+      }
       process.stderr.write(`Error: ${authErrorMessage(error2)}
 `);
       process.exitCode = 1;
+      try {
+        evidence?.failed(stage, toolExecution, business);
+      } catch (saveError) {
+        process.stderr.write(`Error: execution evidence could not be finalized: ${String(saveError)}
+`);
+      }
     }
   });
   auth.command("logout").description("Remove only CLI-login-owned credentials locally; does not revoke the gateway key").option("--json", "Emit JSON").action((options) => {
@@ -29504,9 +29821,13 @@ if (process.argv.length <= 2) {
           const fd = outputFd;
           outputFd = void 0;
           fs27.closeSync(fd);
+          if (evidence) {
+            stage = "readable_write";
+            evidence.writeReadable(complete);
+          }
         } 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)}`);
+          throw new Error(`Tool returned a result, but saving its evidence failed; complete result is on stdout and any saved result.json remains authoritative. Do not repeat the tool automatically. ${String(error2)}`);
         }
         stage = "output_emit";
         evidence?.completed(business, exitCode);
@@ -29563,6 +29884,7 @@ if (process.argv.length <= 2) {
   });
   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").option("--evidence-dir <path>", "Create a new directory for discovery, diagnostics and execution status").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) => {
     let toolExecution = "not_started";
+    let stage = "discovery";
     try {
       evidence?.started();
       toolExecution = "unknown";
@@ -29577,7 +29899,8 @@ if (process.argv.length <= 2) {
         const complete = withCliProvenance(result);
         const serialized = JSON.stringify(complete) + "\n";
         try {
-          fs27.writeFileSync(evidence.resultFile, serialized, { encoding: "utf8", flag: "wx" });
+          stage = "output_write";
+          evidence.writeResult(complete);
           evidence.completed("not_reported", 0);
         } catch (error2) {
           process.stdout.write(serialized);
@@ -29609,7 +29932,7 @@ if (process.argv.length <= 2) {
 `);
       process.exitCode = 1;
       try {
-        evidence?.failed("discovery", toolExecution);
+        evidence?.failed(stage, toolExecution);
       } catch (saveError) {
         process.stderr.write(`Error: execution evidence could not be finalized: ${String(saveError)}
 `);