@openclaw/plugin-inspector 0.3.4 → 0.3.6

package/src/openclaw-target.js

@@ -106,12 +106,89 @@ export function openClawTargetPathCandidates(manifest, configuredPath) {
 
 export function parseCompatRecordEntries(source) {
   const entries = [];
-  for (const match of source.matchAll(/\{[\s\S]*?\bcode:\s*["'`]([^"'`]+)["'`][\s\S]*?\bstatus:\s*["'`]([^"'`]+)["'`][\s\S]*?\}/g)) {
-    entries.push({ code: match[1], status: match[2] });
+  let cursor = 0;
+  while (cursor < source.length) {
+    const codeProperty = readStringProperty(source, "code", cursor);
+    if (!codeProperty) {
+      break;
+    }
+
+    const statusProperty = readStringProperty(source, "status", codeProperty.end);
+    if (statusProperty) {
+      entries.push({ code: codeProperty.value, status: statusProperty.value });
+      cursor = statusProperty.end;
+    } else {
+      cursor = codeProperty.end;
+    }
   }
   return dedupeBy(entries, (entry) => entry.code).sort((left, right) => left.code.localeCompare(right.code));
 }
 
+function readStringProperty(source, property, fromIndex) {
+  const propertyIndex = findProperty(source, property, fromIndex);
+  if (propertyIndex === -1) {
+    return null;
+  }
+  const colonIndex = source.indexOf(":", propertyIndex + property.length);
+  if (colonIndex === -1) {
+    return null;
+  }
+  let quoteIndex = colonIndex + 1;
+  while (quoteIndex < source.length && isWhitespace(source[quoteIndex])) {
+    quoteIndex += 1;
+  }
+  if (!isQuote(source[quoteIndex])) {
+    return null;
+  }
+  return readQuotedValue(source, quoteIndex);
+}
+
+function findProperty(source, property, fromIndex) {
+  let index = source.indexOf(property, fromIndex);
+  while (index !== -1) {
+    const previous = index === 0 ? "" : source[index - 1];
+    const next = source[index + property.length] ?? "";
+    if (!isIdentifierChar(previous) && !isIdentifierChar(next)) {
+      return index;
+    }
+    index = source.indexOf(property, index + property.length);
+  }
+  return -1;
+}
+
+function readQuotedValue(source, quoteIndex) {
+  const quote = source[quoteIndex];
+  let value = "";
+  for (let index = quoteIndex + 1; index < source.length; index += 1) {
+    const char = source[index];
+    if (char === "\\") {
+      value += source[index + 1] ?? "";
+      index += 1;
+    } else if (char === quote) {
+      return { value, end: index + 1 };
+    } else {
+      value += char;
+    }
+  }
+  return null;
+}
+
+function isQuote(char) {
+  return char === '"' || char === "'" || char === "`";
+}
+
+function isIdentifierChar(char) {
+  if (char === "_" || char === "$") {
+    return true;
+  }
+  const code = char.charCodeAt(0);
+  return (code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+}
+
+function isWhitespace(char) {
+  return char === " " || char === "\n" || char === "\r" || char === "\t";
+}
+
 export function parsePluginSdkExports(packageJson) {
   return Object.keys(packageJson.exports ?? {})
     .filter((specifier) => specifier === "./plugin-sdk" || specifier.startsWith("./plugin-sdk/"))

package/src/platform-probes.js

@@ -55,8 +55,11 @@ export function validatePlatformProbes(report, options = {}) {
     errors.push("all TypeScript loader entrypoints must track a Jiti fallback candidate");
   }
   for (const entrypoint of report.entrypoints) {
-    if (entrypoint.loaderPrimary === "tsx" && (!entrypoint.captureUsesTsx || !entrypoint.syntheticUsesTsx)) {
-      errors.push(`${entrypoint.id}: tsx loader strategy is not reflected in capture and synthetic commands`);
+    if (
+      entrypoint.loaderPrimary === "tsx" &&
+      (!entrypoint.captureUsesTypeScriptLoader || !entrypoint.syntheticUsesTypeScriptLoader)
+    ) {
+      errors.push(`${entrypoint.id}: TypeScript loader strategy is not reflected in capture and synthetic commands`);
     }
   }
   return errors;
@@ -94,9 +97,21 @@ export function renderPlatformProbesMarkdown(report, options = {}) {
         entrypoint.loaderAlternatives.join(", ") || "-",
         entrypoint.captureUsesTsx ? "yes" : "no",
         entrypoint.syntheticUsesTsx ? "yes" : "no",
+        entrypoint.captureUsesMockSdk ? "yes" : "no",
+        entrypoint.syntheticUsesMockSdk ? "yes" : "no",
         entrypoint.entrypoint,
       ]),
-      ["Fixture", "Status", "Primary", "Alternatives", "Capture TSX", "Synthetic TSX", "Entrypoint"],
+      [
+        "Fixture",
+        "Status",
+        "Primary",
+        "Alternatives",
+        "Capture TSX",
+        "Synthetic TSX",
+        "Capture Mock SDK",
+        "Synthetic Mock SDK",
+        "Entrypoint",
+      ],
     ),
     "",
     "## Portability Findings",
@@ -137,6 +152,10 @@ export function renderPlatformProbesMarkdown(report, options = {}) {
 function summarizeEntrypoint(fixtureId, entrypoint) {
   const captureStep = entrypoint.steps.find((step) => step.kind === "capture");
   const syntheticStep = entrypoint.steps.find((step) => step.kind === "synthetic-probe");
+  const captureUsesTsx = Boolean(captureStep?.command.includes("--import tsx"));
+  const syntheticUsesTsx = Boolean(syntheticStep?.command.includes("--import tsx"));
+  const captureUsesMockSdk = Boolean(captureStep?.command.includes("--mock-sdk"));
+  const syntheticUsesMockSdk = Boolean(syntheticStep?.command.includes("--mock-sdk"));
   return {
     fixture: fixtureId,
     id: entrypoint.id,
@@ -148,8 +167,12 @@ function summarizeEntrypoint(fixtureId, entrypoint) {
     loaderAlternatives: entrypoint.loaderStrategy.alternatives,
     capturePlanned: Boolean(captureStep),
     syntheticProbePlanned: Boolean(syntheticStep),
-    captureUsesTsx: Boolean(captureStep?.command.includes("--import tsx")),
-    syntheticUsesTsx: Boolean(syntheticStep?.command.includes("--import tsx")),
+    captureUsesTsx,
+    syntheticUsesTsx,
+    captureUsesMockSdk,
+    syntheticUsesMockSdk,
+    captureUsesTypeScriptLoader: captureUsesTsx || captureUsesMockSdk,
+    syntheticUsesTypeScriptLoader: syntheticUsesTsx || syntheticUsesMockSdk,
   };
 }
 
@@ -260,7 +283,7 @@ function buildRecommendations(portabilityFindings, entrypoints) {
   if (entrypoints.some((entrypoint) => entrypoint.loaderPrimary === "tsx")) {
     recommendations.push({
       area: "loader",
-      action: "keep tsx as the source-entrypoint smoke path, add a Jiti execution lane before treating TS plugin source compatibility as covered",
+      action: "keep mock-SDK TypeScript capture green, add a real host-loader/Jiti lane before treating TS plugin source compatibility as covered",
     });
   }
   if (portabilityFindings.some((finding) => finding.riskCodes.includes("rsync-required"))) {

package/src/process-profile.js

@@ -7,8 +7,12 @@ export async function runProfiledProcess(options) {
   let firstRssKb = 0;
   let peakRssKb = 0;
   let peakCpuPercent = 0;
+  let statSampleCount = 0;
+  let rssSampleCount = 0;
+  let cpuSampleCount = 0;
   const cpuSamples = [];
   let pollInFlight = false;
+  const pendingStats = new Set();
 
   const child = spawn(options.command, options.args ?? [], {
     cwd: options.cwd,
@@ -21,27 +25,43 @@ export async function runProfiledProcess(options) {
   child.stderr?.on("data", (chunk) => stderr.push(chunk));
 
   const recordStats = (stats) => {
-    if (stats.rssKb > 0 && firstRssKb === 0) {
+    if (stats.rssAvailable || stats.cpuAvailable) {
+      statSampleCount += 1;
+    }
+    if (stats.rssAvailable) {
+      rssSampleCount += 1;
+    }
+    if (stats.cpuAvailable) {
+      cpuSampleCount += 1;
+    }
+    if (stats.rssAvailable && stats.rssKb > 0 && firstRssKb === 0) {
       firstRssKb = stats.rssKb;
     }
-    peakRssKb = Math.max(peakRssKb, stats.rssKb);
-    peakCpuPercent = Math.max(peakCpuPercent, stats.cpuPercent);
-    if (stats.cpuPercent > 0) {
+    if (stats.rssAvailable) {
+      peakRssKb = Math.max(peakRssKb, stats.rssKb);
+    }
+    if (stats.cpuAvailable) {
+      peakCpuPercent = Math.max(peakCpuPercent, stats.cpuPercent);
       cpuSamples.push(stats.cpuPercent);
     }
   };
 
-  const poll = setInterval(() => {
+  const sampleStats = () => {
     if (pollInFlight) {
       return;
     }
     pollInFlight = true;
-    readProcessStats(child.pid)
+    const pending = readProcessStats(child.pid)
       .then(recordStats)
       .finally(() => {
         pollInFlight = false;
+        pendingStats.delete(pending);
       });
-  }, options.pollMs ?? 100);
+    pendingStats.add(pending);
+  };
+
+  sampleStats();
+  const poll = setInterval(sampleStats, options.pollMs ?? 25);
 
   const exitCode = await new Promise((resolve, reject) => {
     child.on("error", (error) => {
@@ -51,16 +71,10 @@ export async function runProfiledProcess(options) {
     child.on("exit", (code) => resolve(code ?? 1));
   });
   clearInterval(poll);
+  await Promise.allSettled([...pendingStats]);
 
   const finalStats = await readProcessStats(child.pid);
-  if (finalStats.rssKb > 0 && firstRssKb === 0) {
-    firstRssKb = finalStats.rssKb;
-  }
-  peakRssKb = Math.max(peakRssKb, finalStats.rssKb);
-  peakCpuPercent = Math.max(peakCpuPercent, finalStats.cpuPercent);
-  if (finalStats.cpuPercent > 0) {
-    cpuSamples.push(finalStats.cpuPercent);
-  }
+  recordStats(finalStats);
 
   const wallMs = Math.round(performance.now() - start);
   const averageCpuPercent =
@@ -79,6 +93,9 @@ export async function runProfiledProcess(options) {
     peakCpuPercent: Math.round(peakCpuPercent * 10) / 10,
     cpuMsEstimate: Math.round((wallMs * cpuPercentForEstimate) / 100),
     harnessHeapDeltaMb: Math.round((heapUsedMb() - heapStartMb) * 10) / 10,
+    statSampleCount,
+    rssSampleCount,
+    cpuSampleCount,
     exitCode,
     stdoutPreview: previewLines(stdout),
     stderrPreview: previewLines(stderr),
@@ -87,7 +104,7 @@ export async function runProfiledProcess(options) {
 
 async function readProcessStats(pid) {
   if (!pid || process.platform === "win32") {
-    return { rssKb: 0, cpuPercent: 0 };
+    return { rssAvailable: false, rssKb: 0, cpuAvailable: false, cpuPercent: 0 };
   }
   return new Promise((resolve) => {
     const ps = spawn("ps", ["-o", "rss=", "-o", "%cpu=", "-p", String(pid)], {
@@ -95,14 +112,18 @@ async function readProcessStats(pid) {
     });
     const chunks = [];
     ps.stdout.on("data", (chunk) => chunks.push(chunk));
-    ps.on("error", () => resolve({ rssKb: 0, cpuPercent: 0 }));
+    ps.on("error", () => resolve({ rssAvailable: false, rssKb: 0, cpuAvailable: false, cpuPercent: 0 }));
     ps.on("exit", () => {
       const [rssRaw, cpuRaw] = Buffer.concat(chunks).toString("utf8").trim().split(/\s+/);
       const rssKb = Number.parseInt(rssRaw, 10);
       const cpuPercent = Number.parseFloat(cpuRaw);
+      const rssAvailable = Number.isFinite(rssKb);
+      const cpuAvailable = Number.isFinite(cpuPercent);
       resolve({
-        rssKb: Number.isFinite(rssKb) ? rssKb : 0,
-        cpuPercent: Number.isFinite(cpuPercent) ? cpuPercent : 0,
+        rssAvailable,
+        rssKb: rssAvailable ? rssKb : 0,
+        cpuAvailable,
+        cpuPercent: cpuAvailable ? cpuPercent : 0,
       });
     });
   });

package/src/prune-workspace-dev-deps-cli.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+const packageJsonPath = path.resolve(process.cwd(), "package.json");
+const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+let changed = false;
+
+for (const [name, specifier] of Object.entries(packageJson.devDependencies ?? {})) {
+  if (typeof specifier === "string" && specifier.startsWith("workspace:")) {
+    delete packageJson.devDependencies[name];
+    changed = true;
+  }
+}
+
+if (packageJson.devDependencies && Object.keys(packageJson.devDependencies).length === 0) {
+  delete packageJson.devDependencies;
+  changed = true;
+}
+
+if (changed) {
+  await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
+}

package/src/report.js

@@ -5,6 +5,7 @@ import { buildContractProbes } from "./contract-probes.js";
 import { classifyCompatibilityFixture } from "./fixture-summary.js";
 import { buildIssues, summarizeIssueClasses } from "./issues.js";
 import { sanitizeReportArtifact } from "./report-sanitizer.js";
+import { applyRuntimeExecutionCoverage } from "./runtime-reconciliation.js";
 
 export function buildReport({ config, inspections, failures = [], generatedAt = "deterministic" }) {
   const inspectionById = new Map(inspections.map((inspection) => [inspection.id, inspection]));
@@ -140,6 +141,10 @@ export async function buildCompatibilityReport(options = {}) {
     decisions,
   });
 
+  const runtimeCoverage = applyRuntimeExecutionCoverage({
+    findings: [...warnings, ...suggestions],
+    executionResults: options.executionResults,
+  });
   const issues = buildIssues({
     breakages,
     warnings,
@@ -149,6 +154,8 @@ export async function buildCompatibilityReport(options = {}) {
   });
   const contractProbes = buildContractProbes({ warnings, suggestions, fixtures: fixtureReports });
   const issueSummary = summarizeIssueClasses(issues);
+  const openIssues = issues.filter((issue) => issue.status !== "runtime-covered");
+  const openIssueSummary = summarizeIssueClasses(openIssues);
 
   return {
     generatedAt: options.generatedAt ?? "deterministic",
@@ -163,8 +170,11 @@ export async function buildCompatibilityReport(options = {}) {
       decisionCount: decisions.length,
       logCount: logs.length,
       issueCount: issues.length,
+      openIssueCount: openIssues.length,
       p0IssueCount: issues.filter((issue) => issue.severity === "P0").length,
       p1IssueCount: issues.filter((issue) => issue.severity === "P1").length,
+      openP0IssueCount: openIssues.filter((issue) => issue.severity === "P0").length,
+      openP1IssueCount: openIssues.filter((issue) => issue.severity === "P1").length,
       liveIssueCount: issueSummary["live-issue"],
       liveP0IssueCount: issues.filter((issue) => issue.issueClass === "live-issue" && issue.severity === "P0").length,
       compatGapCount: issueSummary["compat-gap"],
@@ -172,6 +182,10 @@ export async function buildCompatibilityReport(options = {}) {
       inspectorGapCount: issueSummary["inspector-gap"],
       upstreamIssueCount: issueSummary["upstream-metadata"],
       fixtureRegressionCount: issueSummary["fixture-regression"],
+      openInspectorGapCount: openIssueSummary["inspector-gap"],
+      runtimeCoveredIssueCount: runtimeCoverage.coveredFindingCount,
+      runtimePartiallyCoveredIssueCount: runtimeCoverage.partiallyCoveredFindingCount,
+      runtimeCoverageArtifactCount: runtimeCoverage.coverage.artifactCount,
       contractProbeCount: contractProbes.length,
     },
     fixtures: fixtureReports,
@@ -308,7 +322,11 @@ function topTextFindings(report, limit) {
   return [
     ...(report.breakages ?? []).map((finding) => formatTextFinding(finding, "breakage")),
     ...(report.issues ?? [])
-      .filter((issue) => issue.status === "blocking" || issue.severity === "P0" || issue.severity === "P1")
+      .filter(
+        (issue) =>
+          issue.status !== "runtime-covered" &&
+          (issue.status === "blocking" || issue.severity === "P0" || issue.severity === "P1"),
+      )
       .map((issue) => formatTextFinding(issue, issue.severity ?? "issue")),
     ...(report.warnings ?? []).map((finding) => formatTextFinding(finding, "warning")),
   ].slice(0, limit);

package/src/runtime-profile.js

@@ -46,8 +46,8 @@ export async function buildRuntimeProfile(options = {}) {
       os: process.platform,
       arch: process.arch,
       node: process.version,
-      rssSampler: process.platform === "win32" ? "unavailable" : "ps",
-      cpuSampler: process.platform === "win32" ? "unavailable" : "ps-percent",
+      rssSampler: process.platform === "win32" ? "unavailable" : "ps-immediate-25ms",
+      cpuSampler: process.platform === "win32" ? "unavailable" : "ps-percent-immediate-25ms",
     },
     summary: summarizeProfile(commands),
     groups: summarizeCommandGroups(commands),
@@ -65,8 +65,8 @@ export function validateRuntimeProfile(profile) {
       errors.push(`${command.id}: missing wall time`);
     }
   }
-  if (profile.platform?.rssSampler !== "unavailable" && profile.commands.every((command) => command.peakRssMb.max <= 0)) {
-    errors.push("all commands are missing peak RSS");
+  if (profile.platform?.rssSampler !== "unavailable" && profile.commands.every((command) => !hasRssSample(command))) {
+    errors.push("all commands are missing peak RSS samples");
   }
   return errors;
 }
@@ -98,10 +98,17 @@ export function renderRuntimeProfileMarkdown(profile, options = {}) {
       [
         ["Commands", profile.summary.commandCount],
         ["P50 wall time", `${profile.summary.p50WallMs} ms`],
-        ["P95 wall time", `${profile.summary.p95WallMs} ms`],
-        ["Max peak RSS", `${profile.summary.maxPeakRssMb} MB`],
-        ["Max RSS delta", `${profile.summary.maxRssDeltaMb} MB`],
-        ["Max CPU estimate", `${profile.summary.maxCpuMsEstimate} ms`],
+        ["Command P95 wall time", `${profile.summary.p95WallMs} ms`],
+        ["Wall time basis", profile.summary.wallTimeBasis ?? "command-median-p95"],
+        ["Profile samples", profile.summary.sampleCount ?? sampleCount(profile.commands)],
+        ["RSS samples", profile.summary.rssSampleCount ?? rssSampleCount(profile.commands)],
+        ["CPU samples", profile.summary.cpuSampleCount ?? cpuSampleCount(profile.commands)],
+        ["Max peak RSS", formatSampledMetric(profile.summary.maxPeakRssMb, profile.summary.rssSampleCount ?? rssSampleCount(profile.commands))],
+        ["Max RSS delta", formatSampledMetric(profile.summary.maxRssDeltaMb, profile.summary.rssSampleCount ?? rssSampleCount(profile.commands))],
+        [
+          "Max CPU estimate",
+          formatSampledMetric(profile.summary.maxCpuMsEstimate, profile.summary.cpuSampleCount ?? cpuSampleCount(profile.commands), "ms"),
+        ],
         ["Max harness heap delta", `${profile.summary.maxHarnessHeapDeltaMb} MB`],
       ],
       ["Metric", "Value"],
@@ -129,13 +136,14 @@ export function renderRuntimeProfileMarkdown(profile, options = {}) {
         command.label,
         `${command.wallMs.median} ms`,
         `${command.wallMs.max} ms`,
-        `${command.peakRssMb.max} MB`,
-        `${command.rssDeltaMb.max} MB`,
-        `${command.cpuMsEstimate.max} ms`,
+        formatSampledMetric(command.peakRssMb.max, command.rssSampleCount),
+        formatSampledMetric(command.rssDeltaMb.max, command.rssSampleCount),
+        formatSampledMetric(command.cpuMsEstimate.max, command.cpuSampleCount, "ms"),
         `${command.harnessHeapDeltaMb.max} MB`,
+        `${command.rssSampleCount ?? 0}/${command.cpuSampleCount ?? 0}`,
         command.exitCodes.join(", "),
       ]),
-      ["ID", "Label", "Median wall", "Max wall", "Max peak RSS", "Max RSS delta", "CPU estimate", "Heap delta", "Exit codes"],
+      ["ID", "Label", "Median wall", "Max wall", "Max peak RSS", "Max RSS delta", "CPU estimate", "Heap delta", "RSS/CPU samples", "Exit codes"],
     ),
     "",
     "## Category Rollups",
@@ -146,11 +154,12 @@ export function renderRuntimeProfileMarkdown(profile, options = {}) {
         group.commandCount,
         `${group.p50WallMs} ms`,
         `${group.p95WallMs} ms`,
-        `${group.maxPeakRssMb} MB`,
-        `${group.maxCpuMsEstimate} ms`,
+        formatSampledMetric(group.maxPeakRssMb, group.rssSampleCount),
+        formatSampledMetric(group.maxCpuMsEstimate, group.cpuSampleCount, "ms"),
+        `${group.rssSampleCount ?? 0}/${group.cpuSampleCount ?? 0}`,
         group.commands.join(", "),
       ]),
-      ["Category", "Commands", "P50 wall", "P95 wall", "Max peak RSS", "CPU estimate", "Command IDs"],
+      ["Category", "Commands", "P50 wall", "P95 wall", "Max peak RSS", "CPU estimate", "RSS/CPU samples", "Command IDs"],
     ),
   ].join("\n");
 }
@@ -189,8 +198,15 @@ function summarizeProfile(commands) {
   const maxRssDeltaMb = Math.max(0, ...commands.map((command) => command.rssDeltaMb.max));
   const maxCpuMsEstimate = Math.max(0, ...commands.map((command) => command.cpuMsEstimate.max));
   const maxHarnessHeapDeltaMb = Math.max(0, ...commands.map((command) => command.harnessHeapDeltaMb.max));
+  const totalSampleCount = sampleCount(commands);
+  const totalRssSampleCount = rssSampleCount(commands);
+  const totalCpuSampleCount = cpuSampleCount(commands);
   return {
     commandCount: commands.length,
+    sampleCount: totalSampleCount,
+    rssSampleCount: totalRssSampleCount,
+    cpuSampleCount: totalCpuSampleCount,
+    wallTimeBasis: "command-median-p95",
     p50WallMs: percentile(wallTimes, 0.5),
     p95WallMs: percentile(wallTimes, 0.95),
     maxPeakRssMb,
@@ -206,6 +222,12 @@ function summarizeCommand(command, samples) {
   const rssDeltaMb = samples.map((sample) => sample.rssDeltaMb).sort((left, right) => left - right);
   const peakCpuPercent = samples.map((sample) => sample.peakCpuPercent).sort((left, right) => left - right);
   const cpuMsEstimate = samples.map((sample) => sample.cpuMsEstimate).sort((left, right) => left - right);
+  const statSampleCount = samples.reduce((sum, sample) => sum + (sample.statSampleCount ?? 0), 0);
+  const rssSampleTotal = samples.reduce(
+    (sum, sample) => sum + (sample.rssSampleCount ?? (sample.peakRssMb > 0 ? 1 : 0)),
+    0,
+  );
+  const cpuSampleTotal = samples.reduce((sum, sample) => sum + (sample.cpuSampleCount ?? 0), 0);
   const harnessHeapDeltaMb = samples
     .map((sample) => sample.harnessHeapDeltaMb)
     .sort((left, right) => left - right);
@@ -222,6 +244,9 @@ function summarizeCommand(command, samples) {
     peakCpuPercent: summarizeNumbers(peakCpuPercent),
     cpuMsEstimate: summarizeNumbers(cpuMsEstimate),
     harnessHeapDeltaMb: summarizeNumbers(harnessHeapDeltaMb),
+    statSampleCount,
+    rssSampleCount: rssSampleTotal,
+    cpuSampleCount: cpuSampleTotal,
     exitCodes: [...new Set(samples.map((sample) => sample.exitCode))].sort(),
   };
 }
@@ -244,6 +269,8 @@ function summarizeCommandGroups(commands) {
     const cpuMs = categoryCommands
       .flatMap((command) => command.samples.map((sample) => sample.cpuMsEstimate))
       .sort((left, right) => left - right);
+    const groupRssSampleCount = rssSampleCount(categoryCommands);
+    const groupCpuSampleCount = cpuSampleCount(categoryCommands);
     return {
       category,
       commandCount: categoryCommands.length,
@@ -251,11 +278,36 @@ function summarizeCommandGroups(commands) {
       p95WallMs: percentile(wallTimes, 0.95),
       maxPeakRssMb: peakRss.at(-1) ?? 0,
       maxCpuMsEstimate: cpuMs.at(-1) ?? 0,
+      rssSampleCount: groupRssSampleCount,
+      cpuSampleCount: groupCpuSampleCount,
       commands: categoryCommands.map((command) => command.id),
     };
   });
 }
 
+function hasRssSample(command) {
+  return (command.rssSampleCount ?? (command.peakRssMb?.max > 0 ? 1 : 0)) > 0;
+}
+
+function sampleCount(commands) {
+  return commands.reduce((sum, command) => sum + (command.samples?.length ?? 0), 0);
+}
+
+function rssSampleCount(commands) {
+  return commands.reduce((sum, command) => sum + (command.rssSampleCount ?? (command.peakRssMb?.max > 0 ? 1 : 0)), 0);
+}
+
+function cpuSampleCount(commands) {
+  return commands.reduce((sum, command) => sum + (command.cpuSampleCount ?? 0), 0);
+}
+
+function formatSampledMetric(value, count, unit = "MB") {
+  if ((count ?? 0) <= 0) {
+    return "n/a";
+  }
+  return `${value} ${unit}`;
+}
+
 function summarizeNumbers(values) {
   return {
     min: values[0],

package/src/runtime-reconciliation.js

@@ -0,0 +1,124 @@
+export function applyRuntimeExecutionCoverage({ findings = [], executionResults } = {}) {
+  const coverage = buildRuntimeExecutionCoverage(executionResults);
+  let coveredFindingCount = 0;
+  let partiallyCoveredFindingCount = 0;
+
+  for (const finding of findings) {
+    const findingCoverage = runtimeCoverageForFinding(finding, coverage);
+    if (!findingCoverage) {
+      continue;
+    }
+
+    finding.runtimeCoverage = findingCoverage;
+    if (findingCoverage.status === "covered") {
+      finding.status = "runtime-covered";
+      coveredFindingCount += 1;
+    } else {
+      partiallyCoveredFindingCount += 1;
+    }
+  }
+
+  return {
+    coverage,
+    coveredFindingCount,
+    partiallyCoveredFindingCount,
+  };
+}
+
+export function buildRuntimeExecutionCoverage(executionResults) {
+  const fixtures = new Map();
+  for (const artifact of executionResults?.artifacts ?? []) {
+    if (artifact.kind !== "capture") {
+      continue;
+    }
+
+    const fixture = String(artifact.fixture ?? "unknown");
+    const fixtureCoverage = ensureFixtureCoverage(fixtures, fixture);
+    if (artifact.artifactPath) {
+      fixtureCoverage.artifacts.add(artifact.artifactPath);
+    }
+
+    for (const captured of normalizeCaptured(artifact.captured)) {
+      fixtureCoverage.captured.add(captured);
+    }
+  }
+
+  return {
+    fixtures,
+    artifactCount: [...fixtures.values()].reduce((sum, fixture) => sum + fixture.artifacts.size, 0),
+  };
+}
+
+function runtimeCoverageForFinding(finding, coverage) {
+  const fixtureCoverage = coverage.fixtures.get(finding.fixture);
+  if (!fixtureCoverage || fixtureCoverage.captured.size === 0) {
+    return null;
+  }
+
+  const expected = expectedRuntimeCaptureKeys(finding);
+  if (expected.length === 0) {
+    return null;
+  }
+
+  const captured = expected.filter((item) => fixtureCoverage.captured.has(item));
+  if (captured.length === 0) {
+    return null;
+  }
+
+  return {
+    status: captured.length === expected.length ? "covered" : "partial",
+    captured,
+    expected,
+    artifacts: [...fixtureCoverage.artifacts].sort(),
+  };
+}
+
+function expectedRuntimeCaptureKeys(finding) {
+  const names = evidenceNames(finding.evidence);
+  if (finding.code === "registration-capture-gap") {
+    return names.map((name) => `registration:${name}`);
+  }
+  if (finding.code === "runtime-tool-capture") {
+    return ["registration:registerTool"];
+  }
+  if (finding.code === "conversation-access-hook") {
+    return names.map((name) => `hook:${name}`);
+  }
+  return [];
+}
+
+function normalizeCaptured(captured) {
+  return (captured ?? [])
+    .map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+      if (item && typeof item === "object" && item.kind && item.name) {
+        return `${item.kind}:${item.name}`;
+      }
+      return "";
+    })
+    .filter(Boolean);
+}
+
+function evidenceNames(evidence) {
+  return [
+    ...new Set(
+      (evidence ?? [])
+        .map((item) => String(item).split(" @ ")[0]?.trim())
+        .filter(Boolean),
+    ),
+  ];
+}
+
+function ensureFixtureCoverage(fixtures, fixture) {
+  let fixtureCoverage = fixtures.get(fixture);
+  if (!fixtureCoverage) {
+    fixtureCoverage = {
+      artifacts: new Set(),
+      captured: new Set(),
+    };
+    fixtures.set(fixture, fixtureCoverage);
+  }
+  return fixtureCoverage;
+}