@openclaw/plugin-inspector 0.3.10 → 0.3.12

package/src/cli.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import {
   loadPluginConfig,
   renderTextSummary,
+  runBatchAnalysis,
   sanitizeReportArtifact,
   runPluginCheck,
 } from "./index.js";
@@ -43,6 +44,8 @@ try {
     }
   } else if (command === "ci") {
     await runCi(commandArgs);
+  } else if (command === "batch") {
+    await runBatch(commandArgs);
   } else if (command === "capture") {
     await runCapture(commandArgs);
   } else {
@@ -53,6 +56,38 @@ try {
   process.exitCode = 1;
 }
 
+async function runBatch(commandArgs) {
+  const inputDir = readFirstPositional(commandArgs, new Set(["--out", "--openclaw", "--concurrency"]));
+  const outDir = readFlag(commandArgs, "--out") ?? "reports";
+  const openclawPath = commandArgs.includes("--no-openclaw") ? false : readFlag(commandArgs, "--openclaw");
+  const concurrency = Number(readFlag(commandArgs, "--concurrency") ?? "4");
+  const json = commandArgs.includes("--json");
+  const check = commandArgs.includes("--check");
+  const keepPluginReports = commandArgs.includes("--keep-plugin-reports");
+  const includeInspectorGaps = commandArgs.includes("--include-inspector-gaps");
+  if (!inputDir) {
+    throw new Error("batch requires a folder of plugin roots");
+  }
+  const { report, paths } = await runBatchAnalysis({
+    rootDir: inputDir,
+    outDir,
+    openclawPath,
+    concurrency,
+    includeInspectorGaps,
+    keepPluginReports,
+  });
+
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(renderBatchTextSummary(report, paths));
+  }
+
+  if (check && report.summary.pluginsWithErrors > 0) {
+    throw new Error(`plugin-inspector batch found ${report.summary.pluginsWithErrors} plugin(s) with errors`);
+  }
+}
+
 async function runConfig(commandArgs) {
   const configPath = readFlag(commandArgs, "--config");
   const pluginRoot = readFlag(commandArgs, "--plugin-root") ?? readFlag(commandArgs, "--root");
@@ -75,10 +110,12 @@ async function runCheck(commandArgs) {
   const mockSdk = readMockSdkFlag(commandArgs);
   const allowExecution = readAllowExecutionFlag(commandArgs);
   const ciOutputs = readCiOutputFlags(commandArgs);
+  const includeInspectorGaps = commandArgs.includes("--include-inspector-gaps");
   const { report, paths } = await runPluginCheck({
     allowExecution,
     capture,
     configPath,
+    includeInspectorGaps,
     mockSdk,
     openclawPath,
     outDir,
@@ -164,10 +201,12 @@ async function runCi(commandArgs) {
   const mockSdk = readMockSdkFlag(commandArgs);
   const allowExecution = readAllowExecutionFlag(commandArgs);
   const ciOutputs = readCiOutputFlags(commandArgs, { defaultEnabled: true });
+  const includeInspectorGaps = commandArgs.includes("--include-inspector-gaps");
   const { report, reportDir } = await runCiCompatibilityReport({
     allowExecution,
     capture,
     configPath,
+    includeInspectorGaps,
     mockSdk,
     openclawPath,
     outDir,
@@ -204,10 +243,19 @@ async function runCi(commandArgs) {
   }
 }
 
-async function runCiCompatibilityReport({ allowExecution, capture, configPath, mockSdk, openclawPath, outDir, pluginRoot }) {
+async function runCiCompatibilityReport({
+  allowExecution,
+  capture,
+  configPath,
+  includeInspectorGaps,
+  mockSdk,
+  openclawPath,
+  outDir,
+  pluginRoot,
+}) {
   if (configPath) {
     const config = await loadInspectorConfig(configPath, { cwd: pluginRoot });
-    const report = await inspectCompatibilityFixtureSet(config, { openclawPath });
+    const report = await inspectCompatibilityFixtureSet(config, { includeInspectorGaps, openclawPath });
     await writeCompatibilityReport(report, { cwd: config.rootDir, outDir });
     return {
       report,
@@ -215,7 +263,15 @@ async function runCiCompatibilityReport({ allowExecution, capture, configPath, m
     };
   }
 
-  const { report } = await runPluginCheck({ allowExecution, capture, mockSdk, openclawPath, outDir, pluginRoot });
+  const { report } = await runPluginCheck({
+    allowExecution,
+    capture,
+    includeInspectorGaps,
+    mockSdk,
+    openclawPath,
+    outDir,
+    pluginRoot,
+  });
   return {
     report,
     reportDir: path.resolve(pluginRoot ?? process.cwd(), outDir),
@@ -223,7 +279,7 @@ async function runCiCompatibilityReport({ allowExecution, capture, configPath, m
 }
 
 async function runCapture(commandArgs) {
-  const entrypoint = commandArgs.find((arg) => !arg.startsWith("-"));
+  const entrypoint = findCaptureEntrypoint(commandArgs);
   const outputPath = readFlag(commandArgs, "--output");
   const pluginRoot = readFlag(commandArgs, "--plugin-root");
   const mockSdk = readMockSdkFlag(commandArgs) ?? commandArgs.includes("--mock-sdk");
@@ -252,6 +308,17 @@ function readFlag(commandArgs, name) {
   return commandArgs[index + 1] ?? null;
 }
 
+function findCaptureEntrypoint(commandArgs) {
+  const flagsWithValues = new Set(["--output", "--plugin-root", "--sdk"]);
+  const consumedIndexes = new Set();
+  for (const [index, arg] of commandArgs.entries()) {
+    if (flagsWithValues.has(arg)) {
+      consumedIndexes.add(index + 1);
+    }
+  }
+  return commandArgs.find((arg, index) => !arg.startsWith("-") && !consumedIndexes.has(index)) ?? null;
+}
+
 function readOptionalPathFlag(commandArgs, name, defaultPath) {
   const index = commandArgs.indexOf(name);
   if (index === -1) {
@@ -315,6 +382,34 @@ function renderCiTextSummary(summary) {
   ].join("\n");
 }
 
+function renderBatchTextSummary(report, paths) {
+  const lines = [
+    "Plugin Inspector Batch",
+    `Plugins: ${report.summary.pluginCount}`,
+    `Plugins with errors: ${report.summary.pluginsWithErrors}`,
+    `Plugins with warnings: ${report.summary.pluginsWithWarnings}`,
+    `Finding codes: ${report.summary.findingCodeCount}`,
+    "",
+    "Reports:",
+    `- JSON: ${paths.jsonPath}`,
+    `- Markdown: ${paths.markdownPath}`,
+  ];
+  const topFinding = report.findingFrequency[0];
+  if (topFinding) {
+    lines.push("", `Top finding: ${topFinding.code} (${topFinding.plugins} plugin(s))`);
+  }
+  return lines.join("\n");
+}
+
+function readFirstPositional(args, valueFlags = new Set()) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg.startsWith("-")) return arg;
+    if (valueFlags.has(arg)) index += 1;
+  }
+  return undefined;
+}
+
 function initCommandSummary(result) {
   return {
     dryRun: result.dryRun,
@@ -342,16 +437,18 @@ function printHelp() {
 
 Usage:
   plugin-inspector
-  plugin-inspector check [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--allow-execute] [--json]
+  plugin-inspector check [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--allow-execute] [--include-inspector-gaps] [--json]
   plugin-inspector config [--plugin-root <path>] [--config <path>] [--json]
   plugin-inspector init [--plugin-root <path>] [--config <path>] [--ci] [--scripts] [--package-manager npm|pnpm|yarn|bun] [--dry-run] [--json] [--force]
   plugin-inspector report --config <path> [--out <dir>] [--check] [--json]
+  plugin-inspector batch <folder> [--out <dir>] [--openclaw <path>] [--no-openclaw] [--concurrency <n>] [--keep-plugin-reports] [--include-inspector-gaps] [--check] [--json]
   plugin-inspector inspect [--plugin-root <path>] [--config <path>] [--out <dir>] [--check] [--json] [--sarif [path]] [--junit [path]] [--allow-execute]
-  plugin-inspector ci [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--allow-execute] [--json] [--no-sarif] [--no-junit]
+  plugin-inspector ci [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--allow-execute] [--include-inspector-gaps] [--json] [--no-sarif] [--no-junit]
   plugin-inspector capture <entrypoint> [--mock-sdk|--real-sdk] [--allow-execute] [--plugin-root <path>] [--output <path>]
 
 Default check runs from the current plugin root and writes reports/ unless --out is set.
 CI writes SARIF and JUnit artifacts by default; check/inspect can write them with --sarif and --junit.
 Runtime capture is opt-in because it imports plugin code; use --runtime with --allow-execute or PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1.
+Inspector coverage gaps are hidden by default; pass --include-inspector-gaps for maintainer coverage reports.
 `);
 }

package/src/compatibility-report.js

@@ -58,9 +58,9 @@ export function renderCompatibilityMarkdownReport(report, options = {}) {
       options,
     ),
     "",
-    "## Live Issues",
+    "## Other Live Issues",
     "",
-    issuesTable(report.issues.filter((issue) => issue.issueClass === "live-issue"), options),
+    issuesTable(report.issues.filter((issue) => issue.issueClass === "live-issue" && issue.severity !== "P0"), options),
     "",
     "## Compat Gaps",
     "",
@@ -183,9 +183,9 @@ export function renderCompatibilityIssuesReport(report, options = {}) {
       options,
     ),
     "",
-    "## Live Issues",
+    "## Other Live Issues",
     "",
-    issuesTable(report.issues.filter((issue) => issue.issueClass === "live-issue"), options),
+    issuesTable(report.issues.filter((issue) => issue.issueClass === "live-issue" && issue.severity !== "P0"), options),
     "",
     "## Compat Gaps",
     "",

package/src/contract-coverage.js

@@ -157,10 +157,15 @@ function requireCompatRecordReconciliation(report, errors) {
       .filter((finding) => finding.code === "missing-compat-record")
       .map((finding) => `${finding.fixture}:${finding.compatRecord}`),
   );
+  const compatGapRecords = new Set(
+    report.issues
+      .filter((issue) => issue.issueClass === "compat-gap" && issue.compatRecord)
+      .map((issue) => `${issue.fixture}:${issue.compatRecord}`),
+  );
 
   for (const finding of [...report.warnings, ...report.suggestions].filter((item) => item.compatRecord)) {
     const key = `${finding.fixture}:${finding.compatRecord}`;
-    if (!presentRecords.has(key) && !missingRecords.has(key)) {
+    if (!presentRecords.has(key) && !missingRecords.has(key) && !compatGapRecords.has(key)) {
       errors.push(`${finding.fixture}: compat record ${finding.compatRecord} was not reconciled`);
     }
   }

package/src/contract-probes.js

@@ -114,6 +114,11 @@ export const contractProbeRules = {
     contract: "Package and OpenClaw manifest versions stay aligned for release compatibility reporting.",
     target: "package-loader",
   },
+  "manifest-name-missing": {
+    id: "manifest.metadata.name",
+    contract: "OpenClaw plugin manifests declare a human-readable display name for registry and tooling metadata.",
+    target: "manifest-loader",
+  },
   "package-plugin-api-compat-missing": {
     id: "package.compat.plugin-api-range",
     contract: "Package metadata declares the OpenClaw plugin API range used by the plugin.",

package/src/execution-results.js

@@ -204,6 +204,7 @@ function summarizeArtifact({ artifactPath, parsed, rootDir }) {
         : "capture";
   const fixture = normalizedArtifactPath.split("/").at(-2) ?? "unknown";
   if (kind === "synthetic") {
+    const passed = (parsed.results ?? []).filter((result) => result.status === "pass");
     return {
       artifactPath: normalizedArtifactPath,
       fixture,
@@ -211,6 +212,8 @@ function summarizeArtifact({ artifactPath, parsed, rootDir }) {
       entrypoint: scrubPath(parsed.entrypoint, { rootDir }),
       status: parsed.status,
       summary: parsed.summary,
+      captured: passed.map(syntheticRuntimeCaptureKey).filter(Boolean),
+      passed,
       failures: (parsed.results ?? []).filter((result) => result.status === "fail"),
       blocked: (parsed.results ?? []).filter((result) => result.status === "blocked"),
     };
@@ -261,6 +264,13 @@ function summarizeArtifactResult(artifact) {
   return `${artifact.capturedCount} captured`;
 }
 
+function syntheticRuntimeCaptureKey(result) {
+  if (!result.kind || !result.seam) {
+    return null;
+  }
+  return `${result.kind}:${result.seam}`;
+}
+
 function auditFindingCount(parsed) {
   const vulnerabilities = parsed.metadata?.vulnerabilities;
   if (vulnerabilities && typeof vulnerabilities === "object") {

package/src/fixture-summary.js

@@ -233,6 +233,26 @@ export function classifyPackageContracts({ fixture, inspection, fixtureReport })
     });
   }
 
+  const missingManifestNames = fixtureReport.pluginManifests.filter(
+    (manifest) => typeof manifest.name !== "string" || manifest.name.trim().length === 0,
+  );
+  if (missingManifestNames.length > 0) {
+    warnings.push({
+      fixture: fixture.id,
+      code: "manifest-name-missing",
+      level: "warning",
+      message: "openclaw.plugin.json does not declare a display name",
+      evidence: missingManifestNames.map((manifest) => manifest.path ?? "openclaw.plugin.json"),
+    });
+    decisions.push({
+      fixture: fixture.id,
+      decision: "plugin-upstream-fix",
+      seam: "manifest-metadata",
+      action: "Ask the plugin to declare openclaw.plugin.json name so registries and tools can derive a human-readable title.",
+      evidence: missingManifestNames.map((manifest) => manifest.path ?? "openclaw.plugin.json").join(", "),
+    });
+  }
+
   if (packageSummary.openclaw && !packageSummary.openclaw.compatPluginApi) {
     warnings.push({
       fixture: fixture.id,
@@ -340,9 +360,12 @@ export function classifyPackageContracts({ fixture, inspection, fixtureReport })
     });
   }
 
-  const missingEntrypoints = packageSummary.openclaw?.entrypoints.filter((entrypoint) => !entrypoint.exists) ?? [];
+  const entrypoints = packageSummary.openclaw?.entrypoints ?? [];
+  const missingEntrypoints = entrypoints.filter((entrypoint) => !entrypoint.exists);
   const buildEntrypoints = missingEntrypoints.filter((entrypoint) => entrypoint.requiresBuild);
-  const plainMissingEntrypoints = missingEntrypoints.filter((entrypoint) => !entrypoint.requiresBuild);
+  const plainMissingEntrypoints = missingEntrypoints.filter(
+    (entrypoint) => !entrypoint.requiresBuild && !hasUsablePackageRuntimeEntrypoint(entrypoint, packageSummary, entrypoints),
+  );
 
   if (buildEntrypoints.length > 0) {
     suggestions.push({
@@ -920,6 +943,46 @@ function collectOpenClawEntrypoints(packageDir, openclaw, options) {
   });
 }
 
+function hasUsablePackageRuntimeEntrypoint(entrypoint, packageSummary, entrypoints) {
+  if (!isSourceEntrypoint(entrypoint.specifier)) {
+    return false;
+  }
+
+  const runtimeBuildSpecifier = runtimeBuildSpecifierFor(entrypoint.specifier);
+  if (
+    entrypoints.some(
+      (candidate) =>
+        candidate.exists &&
+        candidate.requiresBuild &&
+        normalizeEntrypointSpecifier(candidate.specifier) === normalizeEntrypointSpecifier(runtimeBuildSpecifier),
+    )
+  ) {
+    return true;
+  }
+
+  if (entrypoint.kind === "extension" && entrypoints.some((candidate) => candidate.kind === "runtimeExtension" && candidate.exists)) {
+    return true;
+  }
+
+  const packageDir = path.dirname(packageSummary.path);
+  return existsSync(path.resolve(packageDir, runtimeBuildSpecifier));
+}
+
+function isSourceEntrypoint(specifier) {
+  return /\.(?:ts|tsx)$/.test(specifier);
+}
+
+function runtimeBuildSpecifierFor(specifier) {
+  const normalized = normalizeEntrypointSpecifier(specifier);
+  const basename = path.posix.basename(normalized).replace(/\.(?:ts|tsx)$/, ".js");
+  return `./dist/${basename}`;
+}
+
+function normalizeEntrypointSpecifier(specifier) {
+  const normalized = specifier.replaceAll("\\", "/");
+  return normalized.startsWith("./") ? normalized : `./${normalized}`;
+}
+
 async function findPackageFiles(root, options, depth = 0) {
   if (!existsSync(root) || depth > options.maxDepth) {
     return [];
@@ -1059,8 +1122,13 @@ function packageNpmPackIssues(packageSummary, fixtureReport) {
     });
   }
 
-  const missingEntrypoints = packageSummary.openclaw?.entrypoints
-    .filter((entrypoint) => !repoPathIncludedInNpmPack(packageSummary, entrypoint.relativePath))
+  const entrypoints = packageSummary.openclaw?.entrypoints ?? [];
+  const missingEntrypoints = entrypoints
+    .filter(
+      (entrypoint) =>
+        !repoPathIncludedInNpmPack(packageSummary, entrypoint.relativePath) &&
+        !hasPackagedRuntimeEntrypoint(entrypoint, packageSummary, entrypoints),
+    )
     .map((entrypoint) => `${entrypoint.kind}:${entrypoint.specifier} -> ${entrypoint.relativePath}`) ?? [];
   if (missingEntrypoints.length > 0) {
     findings.push({
@@ -1088,6 +1156,35 @@ function packageNpmPackMissingMetadata(packageSummary, fixtureReport) {
   return missing;
 }
 
+function hasPackagedRuntimeEntrypoint(entrypoint, packageSummary, entrypoints) {
+  if (!isSourceEntrypoint(entrypoint.specifier)) {
+    return false;
+  }
+
+  const runtimeBuildSpecifier = runtimeBuildSpecifierFor(entrypoint.specifier);
+  const matchingRuntimeEntrypoint = entrypoints.find(
+    (candidate) =>
+      candidate.requiresBuild &&
+      normalizeEntrypointSpecifier(candidate.specifier) === normalizeEntrypointSpecifier(runtimeBuildSpecifier),
+  );
+  if (matchingRuntimeEntrypoint && repoPathIncludedInNpmPack(packageSummary, matchingRuntimeEntrypoint.relativePath)) {
+    return true;
+  }
+
+  if (
+    entrypoint.kind === "extension" &&
+    entrypoints.some(
+      (candidate) => candidate.kind === "runtimeExtension" && repoPathIncludedInNpmPack(packageSummary, candidate.relativePath),
+    )
+  ) {
+    return true;
+  }
+
+  const packageDir = path.posix.dirname(normalizeRepoPath(packageSummary.path));
+  const runtimeBuildPath = path.posix.join(packageDir === "." ? "" : packageDir, normalizeEntrypointSpecifier(runtimeBuildSpecifier));
+  return repoPathIncludedInNpmPack(packageSummary, runtimeBuildPath);
+}
+
 function packageMinHostVersionDrift(packageSummary) {
   const openclaw = packageSummary.openclaw;
   if (!nonEmptyString(openclaw?.install?.minHostVersion) || !nonEmptyString(openclaw?.buildOpenClawVersion)) {

package/src/index.js

@@ -14,8 +14,10 @@ import * as refDiffApi from "./ref-diff.js";
 import * as reportApi from "./report.js";
 import * as runtimeProfileApi from "./runtime-profile.js";
 import * as runtimeReconciliationApi from "./runtime-reconciliation.js";
+import * as syntheticEntrypointApi from "./synthetic-entrypoint.js";
 import * as syntheticProbeSuiteApi from "./synthetic-probe-suite.js";
 import * as syntheticProbesApi from "./synthetic-probes.js";
+import * as batchApi from "./batch.js";
 
 export const pluginRoot = Object.freeze({
   loadConfig: pluginApi.loadPluginConfig,
@@ -25,6 +27,12 @@ export const pluginRoot = Object.freeze({
   setup: pluginApi.setupPluginInspector,
 });
 
+export const batch = Object.freeze({
+  discoverPluginRoots: batchApi.discoverPluginRoots,
+  run: batchApi.runBatchAnalysis,
+  writeReport: batchApi.writeBatchReport,
+});
+
 export const fixtureSuites = Object.freeze({
   loadConfig: configApi.loadInspectorConfig,
   inspect: pluginApi.inspectCompatibilityFixtureSetConfig,
@@ -123,12 +131,18 @@ export const synthetic = Object.freeze({
   renderPlan: syntheticProbesApi.renderSyntheticProbeMarkdown,
   validatePlan: syntheticProbesApi.validateSyntheticProbePlan,
   runCaptured: syntheticProbesApi.runCapturedSyntheticProbes,
+  runEntrypoint: syntheticEntrypointApi.runEntrypointSyntheticProbes,
   registrationExecutionProfiles: syntheticProbesApi.syntheticRegistrationExecutionProfiles,
   defaultHookEvents: syntheticProbesApi.defaultSyntheticHookEvents,
   defaultHookContexts: syntheticProbesApi.defaultSyntheticHookContexts,
   defaultRegistrationArguments: syntheticProbesApi.defaultSyntheticRegistrationArguments,
 });
 
+export {
+  discoverPluginRoots,
+  runBatchAnalysis,
+  writeBatchReport,
+} from "./batch.js";
 export {
   capturePluginEntrypoint,
   buildFixtureSetColdImportReadiness,
@@ -234,6 +248,7 @@ export {
   applyRuntimeExecutionCoverage,
   buildRuntimeExecutionCoverage,
 } from "./runtime-reconciliation.js";
+export { runEntrypointSyntheticProbes } from "./synthetic-entrypoint.js";
 export { buildSyntheticProbePlanFromReport } from "./synthetic-probe-suite.js";
 export {
   buildSyntheticProbePlan,

package/src/inspector.js

@@ -37,6 +37,7 @@ export async function inspectCompatibilityFixtureSet(config, options = {}) {
     failures,
     generatedAt: options.generatedAt,
     executionResults: options.executionResults,
+    includeInspectorGaps: options.includeInspectorGaps,
     targetOpenClaw,
     buildFixtureReport: ({ fixture, inspection }) =>
       buildCompatibilityFixtureReport({

package/src/issues.js

@@ -14,6 +14,7 @@ export const knownIssueCodes = new Set([
   "conversation-access-hook",
   "legacy-before-agent-start",
   "legacy-root-sdk-import",
+  "manifest-name-missing",
   "manifest-unknown-contracts",
   "manifest-unknown-fields",
   "missing-expected-seam",
@@ -111,6 +112,12 @@ export const issueMetadataByCode = {
     decision: "inspector-follow-up",
     title: "fixture no longer exposes an expected seam",
   },
+  "manifest-name-missing": {
+    severity: "P2",
+    owner: "plugin",
+    decision: "plugin-upstream-fix",
+    title: "manifest display name is missing",
+  },
   "manifest-unknown-contracts": {
     severity: "P1",
     owner: "plugin",
@@ -326,6 +333,10 @@ export function classifyIssueFinding(finding, targetOpenClaw, metadata = {}) {
   };
 }
 
+export function isInspectorGapFinding(finding, targetOpenClaw) {
+  return issueMetadata(finding, targetOpenClaw).issueClass === "inspector-gap";
+}
+
 export function summarizeIssueClasses(issues) {
   const summary = {
     "compat-gap": 0,
@@ -342,7 +353,10 @@ export function summarizeIssueClasses(issues) {
 }
 
 function issueClassFor(code, options) {
-  if (["unknown-hook-name", "unknown-registration-name", "package-entrypoint-missing", "sdk-export-missing"].includes(code)) {
+  if (code === "sdk-export-missing" && options.compatRecord) {
+    return "compat-gap";
+  }
+  if (["unknown-hook-name", "unknown-registration-name", "package-entrypoint-missing"].includes(code)) {
     return "live-issue";
   }
   if (code === "missing-compat-record") {
@@ -369,6 +383,7 @@ function issueClassFor(code, options) {
     [
       "manifest-unknown-contracts",
       "manifest-unknown-fields",
+      "manifest-name-missing",
       "package-json-missing",
       "package-manifest-version-drift",
       "package-min-host-version-drift",
@@ -397,7 +412,7 @@ function severityForClass(code, defaultSeverity, options) {
   if (
     options.issueClass === "live-issue" &&
     ["none", "untracked"].includes(options.compatStatus) &&
-    ["unknown-hook-name", "unknown-registration-name", "package-entrypoint-missing", "sdk-export-missing"].includes(code)
+    ["unknown-hook-name", "unknown-registration-name", "package-entrypoint-missing"].includes(code)
   ) {
     return "P0";
   }

package/src/report.js

@@ -3,7 +3,7 @@ import { renderMarkdownTable, writeArtifacts, writeJsonMarkdownArtifacts } from
 import { renderCompatibilityIssuesReport, renderCompatibilityMarkdownReport } from "./compatibility-report.js";
 import { buildContractProbes } from "./contract-probes.js";
 import { classifyCompatibilityFixture } from "./fixture-summary.js";
-import { buildIssues, summarizeIssueClasses } from "./issues.js";
+import { buildIssues, isInspectorGapFinding, summarizeIssueClasses } from "./issues.js";
 import { sanitizeReportArtifact } from "./report-sanitizer.js";
 import { applyRuntimeExecutionCoverage } from "./runtime-reconciliation.js";
 
@@ -141,18 +141,24 @@ export async function buildCompatibilityReport(options = {}) {
     decisions,
   });
 
+  const visibleWarnings = filterVisibleFindings(warnings, targetOpenClaw, options);
+  const visibleSuggestions = filterVisibleFindings(suggestions, targetOpenClaw, options);
   const runtimeCoverage = applyRuntimeExecutionCoverage({
-    findings: [...warnings, ...suggestions],
+    findings: [...visibleWarnings, ...visibleSuggestions],
     executionResults: options.executionResults,
   });
   const issues = buildIssues({
     breakages,
-    warnings,
-    suggestions,
+    warnings: visibleWarnings,
+    suggestions: visibleSuggestions,
     targetOpenClaw,
     idPrefix: options.issueIdPrefix,
   });
-  const contractProbes = buildContractProbes({ warnings, suggestions, fixtures: fixtureReports });
+  const contractProbes = buildContractProbes({
+    warnings: visibleWarnings,
+    suggestions: visibleSuggestions,
+    fixtures: fixtureReports,
+  });
   const issueSummary = summarizeIssueClasses(issues);
   const openIssues = issues.filter((issue) => issue.status !== "runtime-covered");
   const openIssueSummary = summarizeIssueClasses(openIssues);
@@ -165,8 +171,8 @@ export async function buildCompatibilityReport(options = {}) {
       fixtureCount: fixtureReports.length,
       highPriorityFixtures: fixtureReports.filter((fixture) => fixture.priority === "high").length,
       breakageCount: breakages.length,
-      warningCount: warnings.length,
-      suggestionCount: suggestions.length,
+      warningCount: visibleWarnings.length,
+      suggestionCount: visibleSuggestions.length,
       decisionCount: decisions.length,
       logCount: logs.length,
       issueCount: issues.length,
@@ -190,8 +196,8 @@ export async function buildCompatibilityReport(options = {}) {
     },
     fixtures: fixtureReports,
     breakages,
-    warnings,
-    suggestions,
+    warnings: visibleWarnings,
+    suggestions: visibleSuggestions,
     issues,
     contractProbes,
     logs,
@@ -199,6 +205,13 @@ export async function buildCompatibilityReport(options = {}) {
   };
 }
 
+function filterVisibleFindings(findings, targetOpenClaw, options) {
+  if (options.includeInspectorGaps === true) {
+    return findings;
+  }
+  return findings.filter((finding) => !isInspectorGapFinding(finding, targetOpenClaw));
+}
+
 export function classifyCompatRecordCoverage({ targetOpenClaw, findings, suggestions, logs, decisions }) {
   if (targetOpenClaw.status !== "ok") {
     logs.push({
@@ -225,6 +238,10 @@ export function classifyCompatRecordCoverage({ targetOpenClaw, findings, suggest
       continue;
     }
 
+    if (finding.code === "sdk-export-missing") {
+      continue;
+    }
+
     suggestions.push({
       fixture: finding.fixture,
       code: "missing-compat-record",

package/src/runtime-reconciliation.js

@@ -28,7 +28,7 @@ export function applyRuntimeExecutionCoverage({ findings = [], executionResults
 export function buildRuntimeExecutionCoverage(executionResults) {
   const fixtures = new Map();
   for (const artifact of executionResults?.artifacts ?? []) {
-    if (artifact.kind !== "capture") {
+    if (!["capture", "synthetic"].includes(artifact.kind)) {
       continue;
     }
 
@@ -84,6 +84,9 @@ function expectedRuntimeCaptureKeys(finding) {
   if (finding.code === "conversation-access-hook") {
     return names.map((name) => `hook:${name}`);
   }
+  if (finding.code === "before-tool-call-probe") {
+    return ["hook:before_tool_call"];
+  }
   return [];
 }