@agent-inspect/mcp-server 6.10.0 → 6.11.0

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 var readline = require('readline');
 var fs = require('fs');
-var path = require('path');
+var path14 = require('path');
 var url = require('url');
 var async_hooks = require('async_hooks');
 var crypto = require('crypto');
@@ -15,7 +15,7 @@ var _documentCurrentScript = typeof document !== 'undefined' ? document.currentS
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var readline__default = /*#__PURE__*/_interopDefault(readline);
-var path__default = /*#__PURE__*/_interopDefault(path);
+var path14__default = /*#__PURE__*/_interopDefault(path14);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var os__default = /*#__PURE__*/_interopDefault(os);
 
@@ -757,7 +757,7 @@ function formatDuration(ms) {
 // packages/core/src/utils.ts
 var DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
 var RUNS_DIR_NAME = "runs";
-var FALLBACK_TRACE_DIR = path__default.default.join(
+var FALLBACK_TRACE_DIR = path14__default.default.join(
   os__default.default.tmpdir(),
   "agent-inspect",
   RUNS_DIR_NAME
@@ -775,7 +775,7 @@ function getDefaultTraceDir() {
     if (typeof home !== "string" || home.trim() === "") {
       return FALLBACK_TRACE_DIR;
     }
-    return path__default.default.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
+    return path14__default.default.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
   } catch {
     return FALLBACK_TRACE_DIR;
   }
@@ -1033,7 +1033,7 @@ var TraceDirectory = class {
     this.#dir = resolveTraceDir(options);
   }
   getPath(filename) {
-    return filename ? path__default.default.join(this.#dir, filename) : this.#dir;
+    return filename ? path14__default.default.join(this.#dir, filename) : this.#dir;
   }
   async list() {
     try {
@@ -1060,7 +1060,7 @@ function parseIsoToMs2(value) {
 }
 async function extractMetadata(filePath, _quickScan) {
   const stats = await promises.stat(filePath);
-  let runIdFromFile = path__default.default.basename(filePath);
+  let runIdFromFile = path14__default.default.basename(filePath);
   if (runIdFromFile.endsWith(".jsonl")) {
     runIdFromFile = runIdFromFile.slice(0, -".jsonl".length);
   }
@@ -1580,6 +1580,148 @@ function renderRunWhat(summary, options = {}) {
   return lines.join("\n");
 }
 
+// packages/core/src/causal-failure.ts
+function runIdFromEvents(events) {
+  for (const event of events) {
+    if ("runId" in event && typeof event.runId === "string") return event.runId;
+  }
+  return void 0;
+}
+function noneResult(runId, rationale) {
+  return {
+    kind: "none",
+    evidenceIds: [],
+    rationale,
+    orderIndex: 0,
+    runId,
+    engine: "conservative-causal-v1"
+  };
+}
+function findFirstCausalFailure(events, options = {}) {
+  const runId = runIdFromEvents(events);
+  const timeline = buildRunTimeline(events);
+  const firstError = timeline.entries.find((entry) => entry.isError);
+  if (firstError) {
+    return {
+      kind: "explicit_error_event",
+      evidenceIds: [firstError.stepId],
+      rationale: "First timeline step with status error (explicit failure; no timing-only inference).",
+      orderIndex: 1,
+      runId: timeline.runId || runId,
+      primary: {
+        stepId: firstError.stepId,
+        name: firstError.name
+      },
+      relationship: { role: "self", relatedIds: [] },
+      engine: "conservative-causal-v1"
+    };
+  }
+  const runCompletedError = events.find(
+    (event) => event.event === "run_completed" && event.status === "error"
+  );
+  if (runCompletedError) {
+    return {
+      kind: "explicit_error_event",
+      evidenceIds: [runCompletedError.runId],
+      rationale: "Run completed with status error and no earlier errored step.",
+      orderIndex: 1,
+      runId: runCompletedError.runId,
+      primary: { name: "run", stepId: runCompletedError.runId },
+      relationship: { role: "self", relatedIds: [] },
+      engine: "conservative-causal-v1"
+    };
+  }
+  const outcomes = extractOutcomesFromTraceEvents(events);
+  const failedOutcome = outcomes.find((outcome) => outcome.status === "failed");
+  if (failedOutcome) {
+    const evidenceIds = [failedOutcome.outcomeId];
+    if (failedOutcome.parentId) evidenceIds.push(failedOutcome.parentId);
+    return {
+      kind: "failed_observed_outcome",
+      evidenceIds,
+      rationale: "First observed outcome with status failed.",
+      orderIndex: 2,
+      runId: failedOutcome.runId || runId,
+      primary: {
+        outcomeId: failedOutcome.outcomeId,
+        stepId: failedOutcome.parentId,
+        name: failedOutcome.name
+      },
+      relationship: failedOutcome.parentId ? { role: "child", relatedIds: [failedOutcome.parentId] } : { role: "self", relatedIds: [] },
+      engine: "conservative-causal-v1"
+    };
+  }
+  const contractFail = (options.contractFindings ?? []).find(
+    (finding) => finding.status === "fail" && (finding.evidenceIds?.length ?? 0) > 0
+  );
+  if (contractFail) {
+    const evidenceIds = [...contractFail.evidenceIds ?? []];
+    return {
+      kind: "contract_failure",
+      evidenceIds,
+      rationale: contractFail.message ?? `Contract rule ${contractFail.ruleId} failed with linked evidence ids.`,
+      orderIndex: 3,
+      runId,
+      primary: {
+        ruleId: contractFail.ruleId,
+        stepId: evidenceIds[0],
+        name: contractFail.ruleId
+      },
+      relationship: { role: "self", relatedIds: [] },
+      engine: "conservative-causal-v1"
+    };
+  }
+  const completed = events.filter(
+    (event) => event.event === "step_completed"
+  );
+  const started = events.filter(
+    (event) => event.event === "step_started"
+  );
+  const parentByStep = /* @__PURE__ */ new Map();
+  for (const start of started) {
+    parentByStep.set(start.stepId, start.parentId);
+  }
+  const errorSteps = completed.filter((event) => event.status === "error");
+  if (errorSteps.length > 0) {
+    const sorted = [...errorSteps].sort((a, b) => {
+      const depth = (id) => {
+        let d = 0;
+        let cur = id;
+        const seen = /* @__PURE__ */ new Set();
+        while (cur && parentByStep.has(cur) && !seen.has(cur)) {
+          seen.add(cur);
+          const parent = parentByStep.get(cur);
+          if (!parent) break;
+          d += 1;
+          cur = parent;
+        }
+        return d;
+      };
+      return depth(b.stepId) - depth(a.stepId);
+    });
+    const tip = sorted[0];
+    const parentId = parentByStep.get(tip.stepId);
+    const relatedIds = parentId ? [parentId] : [];
+    return {
+      kind: "failed_ancestor_or_child",
+      evidenceIds: [tip.stepId, ...relatedIds],
+      rationale: parentId ? "Deepest explicit error step with parent link (nearest ancestor relationship)." : "Explicit error step used as structural tip (no parent id).",
+      orderIndex: 4,
+      runId: tip.runId || runId,
+      primary: { stepId: tip.stepId, name: started.find((s) => s.stepId === tip.stepId)?.name },
+      relationship: {
+        role: parentId ? "child" : "self",
+        relatedIds
+      },
+      engine: "conservative-causal-v1"
+    };
+  }
+  return noneResult(
+    runId,
+    "No explicit error event, failed outcome, or linked contract failure; refusing timing-only inference."
+  );
+}
+
 // packages/core/src/search.ts
 function parseDurationFilter(expr) {
   const raw = expr.trim();
@@ -1841,6 +1983,133 @@ function buildBundleMetadata(parts) {
   };
 }
 
+// packages/core/src/evidence/types.ts
+var EVIDENCE_FORMAT_VERSION = "1.0";
+var EVIDENCE_ASSESSMENT_NOTE = "Best-effort local safety verification only; not a compliance certification.";
+var EVIDENCE_MANIFEST_FILENAME = "evidence.json";
+function sha256Hex(data) {
+  const hash = crypto.createHash("sha256");
+  if (typeof data === "string") {
+    hash.update(data, "utf8");
+  } else {
+    hash.update(data);
+  }
+  return hash.digest("hex");
+}
+function assertEvidenceRelativePath(relativePath) {
+  if (typeof relativePath !== "string" || relativePath.trim() === "") {
+    throw new Error("Evidence file path must be a non-empty relative path.");
+  }
+  const trimmed = relativePath.trim().replaceAll("\\", "/");
+  if (path14__default.default.isAbsolute(trimmed) || trimmed.startsWith("/")) {
+    throw new Error(`Evidence file path must be relative: ${relativePath}`);
+  }
+  const parts = trimmed.split("/").filter((part) => part !== "");
+  if (parts.length === 0) {
+    throw new Error(`Evidence file path must be relative: ${relativePath}`);
+  }
+  for (const part of parts) {
+    if (part === "." || part === "..") {
+      throw new Error(`Evidence file path must not contain "." or "..": ${relativePath}`);
+    }
+  }
+  return parts.join("/");
+}
+
+// packages/core/src/evidence/manifest.ts
+function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (value === null || typeof value !== "object") return value;
+  const record = value;
+  return Object.fromEntries(
+    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable(record[key])])
+  );
+}
+function serializeEvidenceManifest(manifest) {
+  return `${JSON.stringify(stable(manifest), null, 2)}
+`;
+}
+function inferEvidenceFileRole(relativePath) {
+  const normalized = assertEvidenceRelativePath(relativePath);
+  const base = normalized.includes("/") ? normalized.slice(normalized.lastIndexOf("/") + 1) : normalized;
+  if (base === "evidence.html" || base === "trace.html" || base.endsWith(".html")) {
+    return "report";
+  }
+  if (base === "trace.jsonl" || base.endsWith(".jsonl")) {
+    return "redacted-trace";
+  }
+  if (base === "check-results.json") {
+    return "checks";
+  }
+  if (base === "redaction-report.json") {
+    return "redaction-report";
+  }
+  if (base === "summary.md") {
+    return "summary";
+  }
+  return "other";
+}
+function buildEvidenceFileEntries(files) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const relativePath = assertEvidenceRelativePath(file.path);
+    if (relativePath === EVIDENCE_MANIFEST_FILENAME) {
+      throw new Error(
+        `Do not include ${EVIDENCE_MANIFEST_FILENAME} in packaged file hashes (self-hash is undefined).`
+      );
+    }
+    if (byPath.has(relativePath)) {
+      throw new Error(`Duplicate evidence file path: ${relativePath}`);
+    }
+    byPath.set(relativePath, {
+      path: relativePath,
+      sha256: sha256Hex(file.content),
+      role: file.role ?? inferEvidenceFileRole(relativePath)
+    });
+  }
+  return [...byPath.values()].sort((a, b) => a.path.localeCompare(b.path));
+}
+function buildEvidenceManifest(parts) {
+  const runIds = [...parts.runIds];
+  if (runIds.length === 0) {
+    throw new Error("Evidence manifest requires at least one run id.");
+  }
+  for (const item of parts.sourceHashes) {
+    if (!runIds.includes(item.runId)) {
+      throw new Error(`sourceHashes runId "${item.runId}" is not listed in source.runIds.`);
+    }
+    if (item.algorithm !== "sha256") {
+      throw new Error(`Unsupported source hash algorithm: ${item.algorithm}`);
+    }
+  }
+  const assessment = {
+    status: parts.assessmentStatus,
+    note: parts.note ?? EVIDENCE_ASSESSMENT_NOTE
+  };
+  if (parts.sourceStatus !== void 0) {
+    assessment.sourceStatus = parts.sourceStatus;
+  }
+  return {
+    evidenceFormatVersion: EVIDENCE_FORMAT_VERSION,
+    generator: {
+      name: parts.generatorName ?? "agent-inspect",
+      version: parts.generatorVersion
+    },
+    createdAt: parts.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    source: {
+      runIds,
+      traceSchemaVersions: [...parts.traceSchemaVersions].sort((a, b) => a.localeCompare(b)),
+      sourceHashes: [...parts.sourceHashes].sort((a, b) => a.runId.localeCompare(b.runId))
+    },
+    policy: {
+      redactionProfile: parts.redactionProfile,
+      verificationPolicy: parts.verificationPolicy ?? parts.redactionProfile
+    },
+    assessment,
+    files: buildEvidenceFileEntries(parts.files)
+  };
+}
+
 // packages/core/src/exporters/helpers.ts
 var REDACT_SUBSTRINGS = [
   "authorization",
@@ -3601,7 +3870,7 @@ function findReaderByFormat(format, readers) {
 }
 async function jsonlFilesInDirectory(dirPath) {
   const entries = await promises.readdir(dirPath, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path__default.default.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path14__default.default.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
 }
 async function resolveInput(input) {
   const cached = resolvedInputCache.get(input);
@@ -6302,7 +6571,76 @@ function prepareMcpToolResult(payload, options = {}) {
 }
 
 // packages/mcp-server/src/tools.ts
-var READ_ONLY_TOOLS = [
+var RUN_ID_SCHEMA = {
+  type: "object",
+  properties: { runId: { type: "string" } },
+  required: ["runId"]
+};
+var FLAGSHIP_TOOLS = [
+  {
+    name: "list_recent_runs",
+    description: "List recent local trace runs in the configured trace directory.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "list_recent_failures",
+    description: "List recent failed runs in the configured trace directory.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_run_summary",
+    description: "Bounded summary for one run (status, failures, correlation).",
+    inputSchema: RUN_ID_SCHEMA
+  },
+  {
+    name: "get_execution_tree",
+    description: "Bounded execution/event projection for one run.",
+    inputSchema: RUN_ID_SCHEMA
+  },
+  {
+    name: "get_first_causal_failure",
+    description: "First causal failure evidence for one run (conservative ordered engine).",
+    inputSchema: RUN_ID_SCHEMA
+  },
+  {
+    name: "get_slowest_path",
+    description: "Summarize the slowest steps in one run.",
+    inputSchema: RUN_ID_SCHEMA
+  },
+  {
+    name: "get_contract_failures",
+    description: "Deterministic contract/check failures for one run.",
+    inputSchema: RUN_ID_SCHEMA
+  },
+  {
+    name: "get_failed_observations",
+    description: "Failed observed outcomes in one run.",
+    inputSchema: RUN_ID_SCHEMA
+  },
+  {
+    name: "compare_runs",
+    description: "Compare two runs and return a bounded structural diff summary.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        leftRunId: { type: "string" },
+        rightRunId: { type: "string" }
+      },
+      required: ["leftRunId", "rightRunId"]
+    }
+  },
+  {
+    name: "create_share_checked_evidence",
+    description: "Create in-memory share-checked evidence (artifact-gated).",
+    inputSchema: RUN_ID_SCHEMA
+  },
+  {
+    name: "get_adapter_diagnostics",
+    description: "Bounded adapter/source diagnostics for one run.",
+    inputSchema: RUN_ID_SCHEMA
+  }
+];
+var LEGACY_TOOLS = [
   {
     name: "list_traces",
     description: "List local trace runs in the configured trace directory.",
@@ -6311,11 +6649,7 @@ var READ_ONLY_TOOLS = [
   {
     name: "read_trace",
     description: "Read a bounded trace projection for one run id.",
-    inputSchema: {
-      type: "object",
-      properties: { runId: { type: "string" } },
-      required: ["runId"]
-    }
+    inputSchema: RUN_ID_SCHEMA
   },
   {
     name: "search_traces",
@@ -6329,88 +6663,54 @@ var READ_ONLY_TOOLS = [
   {
     name: "find_first_error",
     description: "Find the first error step in one run timeline.",
-    inputSchema: {
-      type: "object",
-      properties: { runId: { type: "string" } },
-      required: ["runId"]
-    }
+    inputSchema: RUN_ID_SCHEMA
   },
   {
     name: "find_slowest_path",
     description: "Summarize the slowest steps in one run.",
-    inputSchema: {
-      type: "object",
-      properties: { runId: { type: "string" } },
-      required: ["runId"]
-    }
-  },
-  {
-    name: "compare_runs",
-    description: "Compare two runs and return a bounded structural diff summary.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        leftRunId: { type: "string" },
-        rightRunId: { type: "string" }
-      },
-      required: ["leftRunId", "rightRunId"]
-    }
+    inputSchema: RUN_ID_SCHEMA
   },
   {
     name: "run_checks",
     description: "Run deterministic run.status check for one run.",
-    inputSchema: {
-      type: "object",
-      properties: { runId: { type: "string" } },
-      required: ["runId"]
-    }
+    inputSchema: RUN_ID_SCHEMA
   },
   {
     name: "create_share_safe_report",
     description: "Create a share-profile markdown report for one run.",
-    inputSchema: {
-      type: "object",
-      properties: { runId: { type: "string" } },
-      required: ["runId"]
-    }
+    inputSchema: RUN_ID_SCHEMA
   },
   {
     name: "summarize_failed_run",
     description: "Summarize a failed run with step errors and correlation metadata.",
-    inputSchema: {
-      type: "object",
-      properties: { runId: { type: "string" } },
-      required: ["runId"]
-    }
+    inputSchema: RUN_ID_SCHEMA
   },
   {
     name: "retrieve_decision_notes",
     description: "List decision steps and decision metadata for one run.",
-    inputSchema: {
-      type: "object",
-      properties: { runId: { type: "string" } },
-      required: ["runId"]
-    }
+    inputSchema: RUN_ID_SCHEMA
   },
   {
     name: "find_failed_observation",
     description: "Find failed observed outcomes in one run.",
-    inputSchema: {
-      type: "object",
-      properties: { runId: { type: "string" } },
-      required: ["runId"]
-    }
+    inputSchema: RUN_ID_SCHEMA
   },
   {
     name: "create_share_safe_bundle",
     description: "Create an in-memory share-safe bundle manifest and redacted exports.",
-    inputSchema: {
-      type: "object",
-      properties: { runId: { type: "string" } },
-      required: ["runId"]
-    }
+    inputSchema: RUN_ID_SCHEMA
   }
 ];
+var READ_ONLY_TOOLS = [...FLAGSHIP_TOOLS, ...LEGACY_TOOLS];
+var FLAGSHIP_HANDLER_ALIAS = {
+  list_recent_runs: "list_traces",
+  get_run_summary: "summarize_failed_run",
+  get_execution_tree: "read_trace",
+  get_slowest_path: "find_slowest_path",
+  get_contract_failures: "run_checks",
+  get_failed_observations: "find_failed_observation",
+  create_share_checked_evidence: "create_share_safe_bundle"
+};
 function textResult(payload) {
   return {
     content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
@@ -6470,8 +6770,65 @@ function decisionNotes(events) {
     decisionId: typeof event.attributes?.decisionId === "string" ? event.attributes.decisionId : void 0
   }));
 }
+function isFailedStatus(status) {
+  if (!status) return false;
+  const normalized = status.toLowerCase();
+  return normalized === "error" || normalized === "failed" || normalized === "fail" || normalized.includes("error");
+}
 async function callReadOnlyTool(context, name, args = {}) {
-  switch (name) {
+  if (name === "list_recent_failures") {
+    const td = new TraceDirectory({ dir: context.traceDir });
+    const files = await td.list();
+    const metas = await loadTraceMetadataList(
+      context.traceDir,
+      files,
+      (fileName) => td.getPath(fileName)
+    );
+    const failed = metas.filter((meta) => isFailedStatus(meta.status)).map((meta) => ({
+      runId: meta.runId,
+      name: meta.name,
+      status: meta.status,
+      file: path14__default.default.basename(meta.filePath)
+    }));
+    return deliverMcpPayload(failed, context);
+  }
+  if (name === "get_adapter_diagnostics") {
+    const runId = String(args.runId ?? "");
+    const { meta, read } = await openRunTrace(context, runId);
+    return deliverMcpPayload(
+      {
+        runId,
+        format: read.format,
+        eventCount: read.events.length,
+        runCount: read.runs.length,
+        sourceFile: path14__default.default.basename(meta.filePath),
+        warnings: read.warnings.slice(0, 20),
+        unsupportedFields: read.unsupportedFields.slice(0, 20),
+        note: "Bounded local diagnostics only; not a network health check."
+      },
+      context
+    );
+  }
+  if (name === "get_first_causal_failure") {
+    const runId = String(args.runId ?? "");
+    const { read } = await openRunTrace(context, runId);
+    const check = runTraceChecks(
+      { read },
+      { rules: [createRunStatusRule()], select: ["run.status"], runId }
+    );
+    const contractFindings = check.findings.filter((finding) => finding.status === "fail").map((finding) => ({
+      ruleId: finding.ruleId,
+      status: finding.status,
+      evidenceIds: finding.evidence.map((item) => item.eventId ?? item.parentId).filter((id) => typeof id === "string" && id.length > 0),
+      message: finding.message
+    }));
+    const failure = findFirstCausalFailure(legacyTraceEvents(read.events), {
+      contractFindings
+    });
+    return deliverMcpPayload({ runId, ...failure }, context);
+  }
+  const handlerName = FLAGSHIP_HANDLER_ALIAS[name] ?? name;
+  switch (handlerName) {
     case "list_traces": {
       const td = new TraceDirectory({ dir: context.traceDir });
       const files = await td.list();
@@ -6485,7 +6842,7 @@ async function callReadOnlyTool(context, name, args = {}) {
           runId: meta.runId,
           name: meta.name,
           status: meta.status,
-          file: path__default.default.basename(meta.filePath)
+          file: path14__default.default.basename(meta.filePath)
         })),
         context
       );
@@ -6576,6 +6933,20 @@ async function callReadOnlyTool(context, name, args = {}) {
         { read },
         { rules: [createRunStatusRule()], select: ["run.status"], runId }
       );
+      if (name === "get_contract_failures") {
+        const failures = result.findings.filter((finding) => finding.status === "fail");
+        return deliverMcpPayload(
+          {
+            runId,
+            ok: result.ok,
+            status: result.status,
+            failures,
+            count: failures.length,
+            diagnostics: result.diagnostics
+          },
+          context
+        );
+      }
       return deliverMcpPayload(result, context);
     }
     case "create_share_safe_report": {
@@ -6667,15 +7038,56 @@ async function callReadOnlyTool(context, name, args = {}) {
         },
         files: ["report.md", "tree.json"]
       });
+      const files = {
+        "report.md": markdown.content,
+        "tree.json": tree.content
+      };
+      let evidenceJson;
+      if (name === "create_share_checked_evidence") {
+        const toEvidenceStatus = (value) => {
+          if (value === "SAFE") return "SAFE";
+          if (value === "SAFE_WITH_WARNINGS" || value === "SAFE WITH WARNINGS") {
+            return "SAFE WITH WARNINGS";
+          }
+          if (value === "UNSAFE") return "UNSAFE";
+          return "UNKNOWN";
+        };
+        const packaged = [
+          { path: "report.md", content: Buffer.from(markdown.content, "utf8") },
+          { path: "tree.json", content: Buffer.from(tree.content, "utf8") }
+        ];
+        const manifest = buildEvidenceManifest({
+          generatorName: "@agent-inspect/mcp-server",
+          generatorVersion: "6.11.0-dev",
+          createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+          runIds: [runId],
+          traceSchemaVersions: [],
+          sourceHashes: [
+            {
+              runId,
+              algorithm: "sha256",
+              hash: sha256Hex(Buffer.from(meta.filePath, "utf8"))
+            }
+          ],
+          redactionProfile: profile,
+          verificationPolicy: "share",
+          assessmentStatus: toEvidenceStatus(safety.status),
+          sourceStatus: toEvidenceStatus(safety.sourceStatus),
+          files: packaged
+        });
+        evidenceJson = serializeEvidenceManifest(manifest);
+        files["evidence.json"] = evidenceJson;
+      }
       return deliverMcpPayload(
         {
           runId,
           profile,
           metadata,
-          files: {
-            "report.md": markdown.content,
-            "tree.json": tree.content
-          }
+          ...evidenceJson ? {
+            evidenceFormatVersion: "1.0",
+            shareChecked: true
+          } : {},
+          files
         },
         context
       );
@@ -6684,18 +7096,132 @@ async function callReadOnlyTool(context, name, args = {}) {
       return errorResult2(`Unknown tool: ${name}`);
   }
 }
+function resolveRedactionProfile2(explicit) {
+  if (explicit) return explicit;
+  const fromEnv = process.env.AGENT_INSPECT_MCP_REDACTION_PROFILE;
+  if (fromEnv === "local" || fromEnv === "share" || fromEnv === "strict") {
+    return fromEnv;
+  }
+  return "share";
+}
 function createMcpServerContext(options = {}) {
   return {
     traceDir: resolveTraceDir({ dir: options.traceDir }),
     maxEvents: options.maxEvents ?? 500,
-    redactionProfile: options.redactionProfile ?? "share"
+    redactionProfile: resolveRedactionProfile2(options.redactionProfile)
   };
 }
 
+// packages/mcp-server/src/protocol.ts
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+var MCP_MAX_REQUEST_BYTES = 1048576;
+function idKey(id) {
+  if (id === void 0 || id === null) return void 0;
+  return String(id);
+}
+function replyError(write, id, code, message) {
+  write(
+    JSON.stringify({
+      jsonrpc: "2.0",
+      id: id ?? null,
+      error: { code, message }
+    })
+  );
+}
+function replyResult(write, id, result) {
+  write(JSON.stringify({ jsonrpc: "2.0", id: id ?? null, result }));
+}
+async function handleMcpProtocolLine(session, line) {
+  const { write } = session;
+  const byteLength = Buffer.byteLength(line, "utf8");
+  if (byteLength > MCP_MAX_REQUEST_BYTES) {
+    replyError(
+      write,
+      null,
+      -32600,
+      `Request exceeds ${MCP_MAX_REQUEST_BYTES} byte limit`
+    );
+    return;
+  }
+  let request;
+  try {
+    request = JSON.parse(line);
+  } catch {
+    replyError(write, null, -32700, "Parse error");
+    return;
+  }
+  const { id, method, params } = request;
+  if (!method) {
+    replyError(write, id, -32600, "Invalid Request: missing method");
+    return;
+  }
+  try {
+    if (method === "initialize") {
+      const clientVersion = typeof params?.protocolVersion === "string" ? params.protocolVersion : void 0;
+      replyResult(write, id, {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        serverInfo: { name: session.serverName, version: session.serverVersion },
+        capabilities: {
+          tools: { listChanged: false }
+        },
+        ...clientVersion && clientVersion !== MCP_PROTOCOL_VERSION ? {
+          _meta: {
+            negotiatedFromClient: clientVersion,
+            note: `Server speaks ${MCP_PROTOCOL_VERSION}; client offered ${clientVersion}`
+          }
+        } : {}
+      });
+      return;
+    }
+    if (method === "notifications/initialized" || method === "initialized") {
+      return;
+    }
+    if (method === "ping") {
+      replyResult(write, id, {});
+      return;
+    }
+    if (method === "notifications/cancelled") {
+      const requestId = params?.requestId;
+      const key = idKey(requestId);
+      if (key) session.inflight.get(key)?.abort();
+      return;
+    }
+    if (method === "tools/list") {
+      replyResult(write, id, { tools: READ_ONLY_TOOLS });
+      return;
+    }
+    if (method === "tools/call") {
+      const key = idKey(id);
+      const ac = new AbortController();
+      if (key) session.inflight.set(key, ac);
+      try {
+        const toolParams = params ?? {};
+        const result = await callReadOnlyTool(
+          session.context,
+          String(toolParams.name ?? ""),
+          toolParams.arguments ?? {}
+        );
+        if (ac.signal.aborted) {
+          replyError(write, id, -32800, "Request cancelled");
+          return;
+        }
+        replyResult(write, id, result);
+      } finally {
+        if (key) session.inflight.delete(key);
+      }
+      return;
+    }
+    replyError(write, id, -32601, `Method not found: ${method}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    replyError(write, id, -32e3, message);
+  }
+}
+
 // packages/mcp-server/src/index.ts
 var packageVersion = JSON.parse(
   fs.readFileSync(
-    path__default.default.join(path__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))), "..", "package.json"),
+    path14__default.default.join(path14__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))), "..", "package.json"),
     "utf8"
   )
 ).version;
@@ -6704,84 +7230,28 @@ async function runReadOnlyMcpServer(options = {}) {
   const input = options.input ?? process.stdin;
   const output = options.output ?? process.stdout;
   const rl = readline__default.default.createInterface({ input, crlfDelay: Infinity });
-  const write = (line) => {
-    output.write(`${line}
+  const session = {
+    context,
+    serverName: "@agent-inspect/mcp-server",
+    serverVersion: packageVersion,
+    write: (line) => {
+      output.write(`${line}
 `);
-  };
-  const replyError = (id, code, message) => {
-    write(
-      JSON.stringify({
-        jsonrpc: "2.0",
-        id: id ?? null,
-        error: { code, message }
-      })
-    );
+    },
+    inflight: /* @__PURE__ */ new Map()
   };
   for await (const line of rl) {
     if (!line.trim()) continue;
-    let request;
-    try {
-      request = JSON.parse(line);
-    } catch {
-      write(
-        JSON.stringify({
-          jsonrpc: "2.0",
-          id: null,
-          error: { code: -32700, message: "Parse error" }
-        })
-      );
-      continue;
-    }
-    const { id, method, params } = request;
-    try {
-      if (method === "initialize") {
-        write(
-          JSON.stringify({
-            jsonrpc: "2.0",
-            id,
-            result: {
-              protocolVersion: "2024-11-05",
-              serverInfo: { name: "@agent-inspect/mcp-server", version: packageVersion },
-              capabilities: { tools: {} }
-            }
-          })
-        );
-        continue;
-      }
-      if (method === "notifications/initialized") {
-        continue;
-      }
-      if (method === "tools/list") {
-        write(
-          JSON.stringify({
-            jsonrpc: "2.0",
-            id,
-            result: { tools: READ_ONLY_TOOLS }
-          })
-        );
-        continue;
-      }
-      if (method === "tools/call") {
-        const toolParams = params ?? {};
-        const result = await callReadOnlyTool(
-          context,
-          String(toolParams.name ?? ""),
-          toolParams.arguments ?? {}
-        );
-        write(JSON.stringify({ jsonrpc: "2.0", id, result }));
-        continue;
-      }
-      replyError(id, -32601, `Method not found: ${method}`);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      replyError(id, -32e3, message);
-    }
+    await handleMcpProtocolLine(session, line);
   }
 }
 
+exports.MCP_MAX_REQUEST_BYTES = MCP_MAX_REQUEST_BYTES;
+exports.MCP_PROTOCOL_VERSION = MCP_PROTOCOL_VERSION;
 exports.READ_ONLY_TOOLS = READ_ONLY_TOOLS;
 exports.callReadOnlyTool = callReadOnlyTool;
 exports.createMcpServerContext = createMcpServerContext;
+exports.handleMcpProtocolLine = handleMcpProtocolLine;
 exports.runReadOnlyMcpServer = runReadOnlyMcpServer;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map