@openclaw/plugin-inspector 0.3.4 → 0.3.6

package/src/import-loop-profile.js

@@ -1,4 +1,4 @@
-import { mkdir } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { renderPaddedMarkdownTable, writeJsonMarkdownArtifacts } from "./artifacts.js";
@@ -24,22 +24,48 @@ export async function buildImportLoopProfile(options = {}) {
   const entrypoint = options.entrypoint ?? defaultImportLoopProfileOptions.entrypoint;
   assertRunCount(runs, 20);
 
+  const baseline = await buildBaselineProfile({ ...options, rootDir, runs });
   const samples = [];
   for (let index = 0; index < runs; index += 1) {
-    samples.push(await runCaptureSample({ ...options, entrypoint, index, rootDir }));
+    const sample = await runCaptureSample({ ...options, entrypoint, index, rootDir });
+    samples.push(applyBaselineAdjustment(sample, baseline));
   }
 
   const wallMs = samples.map((sample) => sample.wallMs).sort((left, right) => left - right);
+  const pluginWallDeltaMs = samples.map((sample) => sample.pluginWallDeltaMs).sort((left, right) => left - right);
+  const openClawImportMs = openClawLifecycleMetric(samples, "importMs");
+  const openClawActivationMs = openClawLifecycleMetric(samples, "activationMs");
+  const rssSampleCount = samples.reduce((sum, sample) => sum + (sample.rssSampleCount ?? (sample.peakRssMb > 0 ? 1 : 0)), 0);
+  const cpuSampleCount = samples.reduce((sum, sample) => sum + (sample.cpuSampleCount ?? 0), 0);
+  const statSampleCount = samples.reduce((sum, sample) => sum + (sample.statSampleCount ?? 0), 0);
   return {
     generatedAt: options.generatedAt ?? defaultImportLoopProfileOptions.generatedAt,
-    mode: options.mode ?? "subprocess-cold-import-loop",
+    mode: options.mode ?? "baseline-adjusted-cold-capture-loop",
     entrypoint,
+    baseline,
     summary: {
       runs,
+      baselineRuns: baseline.runs,
+      baselineFailCount: baseline.failCount,
       p50WallMs: percentile(wallMs, 0.5),
       p95WallMs: percentile(wallMs, 0.95),
+      p50PluginWallDeltaMs: percentile(pluginWallDeltaMs, 0.5),
+      p95PluginWallDeltaMs: percentile(pluginWallDeltaMs, 0.95),
+      openClawLifecycleCount: openClawImportMs.length,
+      p50OpenClawImportMs: percentile(openClawImportMs, 0.5),
+      p95OpenClawImportMs: percentile(openClawImportMs, 0.95),
+      p50OpenClawActivationMs: percentile(openClawActivationMs, 0.5),
+      p95OpenClawActivationMs: percentile(openClawActivationMs, 0.95),
       maxPeakRssMb: Math.max(0, ...samples.map((sample) => sample.peakRssMb)),
       maxCpuMsEstimate: Math.max(0, ...samples.map((sample) => sample.cpuMsEstimate)),
+      maxPluginPeakRssDeltaMb: Math.max(0, ...samples.map((sample) => sample.pluginPeakRssDeltaMb)),
+      maxPluginCpuDeltaMsEstimate: Math.max(0, ...samples.map((sample) => sample.pluginCpuDeltaMsEstimate)),
+      baselineReferenceWallMs: baseline.reference.wallMs,
+      baselineReferencePeakRssMb: baseline.reference.peakRssMb,
+      baselineReferenceCpuMsEstimate: baseline.reference.cpuMsEstimate,
+      statSampleCount,
+      rssSampleCount,
+      cpuSampleCount,
       capturedCount: samples.reduce((sum, sample) => sum + sample.capturedCount, 0),
       failCount: samples.filter((sample) => sample.exitCode !== 0 || sample.status !== "captured").length,
     },
@@ -52,6 +78,9 @@ export function validateImportLoopProfile(report) {
   if (report.summary.failCount > 0) {
     errors.push(`import loop has ${report.summary.failCount} failed sample(s)`);
   }
+  if ((report.summary.baselineFailCount ?? report.baseline?.failCount ?? 0) > 0) {
+    errors.push("import loop baseline capture failed");
+  }
   if (report.summary.capturedCount < report.summary.runs) {
     errors.push("import loop did not capture at least one contract per run");
   }
@@ -85,7 +114,11 @@ export function renderImportLoopProfileMarkdown(report, options = {}) {
     "",
     "## Summary",
     "",
-    markdownTable(Object.entries(report.summary).map(([key, value]) => [key, value]), ["Metric", "Value"]),
+    markdownTable(summaryRows(report), ["Metric", "Value"]),
+    "",
+    "## Harness Baseline",
+    "",
+    markdownTable(baselineRows(report), ["Metric", "Value"]),
     "",
     "## Samples",
     "",
@@ -94,22 +127,132 @@ export function renderImportLoopProfileMarkdown(report, options = {}) {
         sample.index,
         sample.status,
         sample.capturedCount,
+        formatOpenClawLifecycleMetric(sample.openClawLifecycle?.importMs),
+        formatOpenClawLifecycleMetric(sample.openClawLifecycle?.activationMs),
+        formatOptionalMetric(sample.pluginWallDeltaMs, "ms"),
+        formatSampledMetric(sample.pluginPeakRssDeltaMb, sample.rssSampleCount),
+        formatSampledMetric(sample.pluginCpuDeltaMsEstimate, sample.cpuSampleCount, "ms"),
         `${sample.wallMs} ms`,
-        `${sample.peakRssMb} MB`,
-        `${sample.cpuMsEstimate} ms`,
+        formatSampledMetric(sample.peakRssMb, sample.rssSampleCount),
+        formatSampledMetric(sample.cpuMsEstimate, sample.cpuSampleCount, "ms"),
+        `${sample.rssSampleCount ?? 0}/${sample.cpuSampleCount ?? 0}`,
         sample.exitCode,
       ]),
-      ["Run", "Status", "Captured", "Wall", "Peak RSS", "CPU Estimate", "Exit"],
+      [
+        "Run",
+        "Status",
+        "Captured",
+        "OpenClaw Import",
+        "OpenClaw Activate",
+        "Plugin Wall Delta",
+        "Plugin RSS Delta",
+        "Plugin CPU Delta",
+        "Raw Wall",
+        "Raw Peak RSS",
+        "Raw CPU Estimate",
+        "RSS/CPU samples",
+        "Exit",
+      ],
     ),
   ].join("\n");
 }
 
+async function buildBaselineProfile(options) {
+  const baselineRuns = options.baseline === false ? 0 : options.baselineRuns ?? Math.min(options.runs, 3);
+  if (baselineRuns <= 0) {
+    return emptyBaseline();
+  }
+
+  const entrypoint = await writeBaselineEntrypoint(options);
+  const samples = [];
+  for (let index = 0; index < baselineRuns; index += 1) {
+    samples.push(
+      await runCaptureSample({
+        ...options,
+        entrypoint,
+        index,
+        sampleName: "baseline",
+        rootDir: options.rootDir,
+      }),
+    );
+  }
+
+  const wallMs = sortedMetric(samples, "wallMs");
+  const peakRssMb = sortedMetric(samples, "peakRssMb");
+  const cpuMsEstimate = sortedMetric(samples, "cpuMsEstimate");
+  return {
+    mode: "minimal-plugin-capture",
+    runs: baselineRuns,
+    entrypoint: path.relative(options.rootDir, entrypoint),
+    reference: {
+      wallMs: percentile(wallMs, 0.5),
+      peakRssMb: percentile(peakRssMb, 0.5),
+      cpuMsEstimate: percentile(cpuMsEstimate, 0.5),
+    },
+    max: {
+      wallMs: wallMs.at(-1) ?? 0,
+      peakRssMb: peakRssMb.at(-1) ?? 0,
+      cpuMsEstimate: cpuMsEstimate.at(-1) ?? 0,
+    },
+    statSampleCount: samples.reduce((sum, sample) => sum + (sample.statSampleCount ?? 0), 0),
+    rssSampleCount: samples.reduce((sum, sample) => sum + (sample.rssSampleCount ?? 0), 0),
+    cpuSampleCount: samples.reduce((sum, sample) => sum + (sample.cpuSampleCount ?? 0), 0),
+    failCount: samples.filter((sample) => sample.exitCode !== 0 || sample.status !== "captured").length,
+    samples,
+  };
+}
+
+function emptyBaseline() {
+  return {
+    mode: "disabled",
+    runs: 0,
+    entrypoint: null,
+    reference: {
+      wallMs: 0,
+      peakRssMb: 0,
+      cpuMsEstimate: 0,
+    },
+    max: {
+      wallMs: 0,
+      peakRssMb: 0,
+      cpuMsEstimate: 0,
+    },
+    statSampleCount: 0,
+    rssSampleCount: 0,
+    cpuSampleCount: 0,
+    failCount: 0,
+    samples: [],
+  };
+}
+
+async function writeBaselineEntrypoint(options) {
+  const outputDir = resolveFromRoot(
+    options.rootDir,
+    options.outputDir ?? defaultImportLoopProfileOptions.outputDir,
+  );
+  const baselinePath = path.join(outputDir, "baseline-plugin.mjs");
+  await mkdir(path.dirname(baselinePath), { recursive: true });
+  await writeFile(
+    baselinePath,
+    [
+      "export default {",
+      "  register(api) {",
+      "    api.registerTool({ name: 'baseline_tool', inputSchema: { type: 'object' }, run() {} });",
+      "  },",
+      "};",
+      "",
+    ].join("\n"),
+    "utf8",
+  );
+  return baselinePath;
+}
+
 async function runCaptureSample(options) {
   const outputDir = resolveFromRoot(
     options.rootDir,
     options.outputDir ?? defaultImportLoopProfileOptions.outputDir,
   );
-  const outputPath = path.join(outputDir, `capture-${options.index}.json`);
+  const outputPath = path.join(outputDir, `${options.sampleName ?? "capture"}-${options.index}.json`);
   await mkdir(path.dirname(outputPath), { recursive: true });
 
   const command = buildCaptureCommand({ ...options, outputPath });
@@ -126,14 +269,125 @@ async function runCaptureSample(options) {
     exitCode: profile.exitCode,
     status: output?.status ?? "failed",
     capturedCount: output?.captured?.length ?? 0,
+    openClawLifecycle: output?.openClawLifecycle ?? null,
     wallMs: profile.wallMs,
     peakRssMb: profile.peakRssMb,
     peakCpuPercent: profile.peakCpuPercent,
     cpuMsEstimate: profile.cpuMsEstimate,
+    statSampleCount: profile.statSampleCount,
+    rssSampleCount: profile.rssSampleCount,
+    cpuSampleCount: profile.cpuSampleCount,
     stderrPreview: profile.stderrPreview,
   };
 }
 
+function summaryRows(report) {
+  return [
+    ["runs", report.summary.runs],
+    ["baselineRuns", report.summary.baselineRuns ?? report.baseline?.runs ?? 0],
+    ["baselineFailCount", report.summary.baselineFailCount ?? report.baseline?.failCount ?? 0],
+    ["p50WallMs", report.summary.p50WallMs],
+    ["p95WallMs", report.summary.p95WallMs],
+    ...(Number.isFinite(report.summary.p50PluginWallDeltaMs)
+      ? [
+          ["p50PluginWallDeltaMs", report.summary.p50PluginWallDeltaMs],
+          ["p95PluginWallDeltaMs", report.summary.p95PluginWallDeltaMs],
+          ["maxPluginPeakRssDeltaMb", formatSampledMetric(report.summary.maxPluginPeakRssDeltaMb, report.summary.rssSampleCount)],
+          [
+            "maxPluginCpuDeltaMsEstimate",
+            formatSampledMetric(report.summary.maxPluginCpuDeltaMsEstimate, report.summary.cpuSampleCount, "ms"),
+          ],
+        ]
+      : []),
+    ...((report.summary.openClawLifecycleCount ?? 0) > 0
+      ? [
+          ["openClawLifecycleCount", report.summary.openClawLifecycleCount],
+          ["p50OpenClawImportMs", `${report.summary.p50OpenClawImportMs} ms`],
+          ["p95OpenClawImportMs", `${report.summary.p95OpenClawImportMs} ms`],
+          ["p50OpenClawActivationMs", `${report.summary.p50OpenClawActivationMs} ms`],
+          ["p95OpenClawActivationMs", `${report.summary.p95OpenClawActivationMs} ms`],
+        ]
+      : []),
+    ["maxPeakRssMb", formatSampledMetric(report.summary.maxPeakRssMb, report.summary.rssSampleCount)],
+    ["maxCpuMsEstimate", formatSampledMetric(report.summary.maxCpuMsEstimate, report.summary.cpuSampleCount, "ms")],
+    ...(Number.isFinite(report.summary.baselineReferenceWallMs)
+      ? [
+          ["baselineReferenceWallMs", `${report.summary.baselineReferenceWallMs} ms`],
+          ["baselineReferencePeakRssMb", formatSampledMetric(report.summary.baselineReferencePeakRssMb, report.baseline?.rssSampleCount ?? 0)],
+          [
+            "baselineReferenceCpuMsEstimate",
+            formatSampledMetric(report.summary.baselineReferenceCpuMsEstimate, report.baseline?.cpuSampleCount ?? 0, "ms"),
+          ],
+        ]
+      : []),
+    ["statSampleCount", report.summary.statSampleCount ?? 0],
+    ["rssSampleCount", report.summary.rssSampleCount ?? 0],
+    ["cpuSampleCount", report.summary.cpuSampleCount ?? 0],
+    ["capturedCount", report.summary.capturedCount],
+    ["failCount", report.summary.failCount],
+  ];
+}
+
+function baselineRows(report) {
+  const baseline = report.baseline ?? emptyBaseline();
+  return [
+    ["mode", baseline.mode],
+    ["runs", baseline.runs],
+    ["entrypoint", baseline.entrypoint ?? "-"],
+    ["referenceWallMs", `${baseline.reference?.wallMs ?? 0} ms`],
+    ["referencePeakRssMb", formatSampledMetric(baseline.reference?.peakRssMb ?? 0, baseline.rssSampleCount)],
+    ["referenceCpuMsEstimate", formatSampledMetric(baseline.reference?.cpuMsEstimate ?? 0, baseline.cpuSampleCount, "ms")],
+    ["maxWallMs", `${baseline.max?.wallMs ?? 0} ms`],
+    ["maxPeakRssMb", formatSampledMetric(baseline.max?.peakRssMb ?? 0, baseline.rssSampleCount)],
+    ["maxCpuMsEstimate", formatSampledMetric(baseline.max?.cpuMsEstimate ?? 0, baseline.cpuSampleCount, "ms")],
+    ["statSampleCount", baseline.statSampleCount ?? 0],
+    ["failCount", baseline.failCount ?? 0],
+  ];
+}
+
+function formatSampledMetric(value, count, unit = "MB") {
+  if ((count ?? 0) <= 0) {
+    return "n/a";
+  }
+  return `${value} ${unit}`;
+}
+
+function formatOptionalMetric(value, unit) {
+  if (!Number.isFinite(value)) {
+    return "n/a";
+  }
+  return `${value} ${unit}`;
+}
+
+function formatOpenClawLifecycleMetric(value) {
+  return Number.isFinite(value) ? `${value} ms` : "n/a";
+}
+
+function openClawLifecycleMetric(samples, field) {
+  return samples
+    .map((sample) => sample.openClawLifecycle?.[field])
+    .filter((value) => Number.isFinite(value))
+    .sort((left, right) => left - right);
+}
+
+function applyBaselineAdjustment(sample, baseline) {
+  return {
+    ...sample,
+    pluginWallDeltaMs: roundNonNegative(sample.wallMs - baseline.reference.wallMs, 0),
+    pluginPeakRssDeltaMb: roundNonNegative(sample.peakRssMb - baseline.reference.peakRssMb, 1),
+    pluginCpuDeltaMsEstimate: roundNonNegative(sample.cpuMsEstimate - baseline.reference.cpuMsEstimate, 0),
+  };
+}
+
+function sortedMetric(samples, field) {
+  return samples.map((sample) => sample[field]).sort((left, right) => left - right);
+}
+
+function roundNonNegative(value, digits) {
+  const scale = 10 ** digits;
+  return Math.max(0, Math.round(value * scale) / scale);
+}
+
 function buildCaptureCommand(options) {
   if (typeof options.captureCommand === "function") {
     return options.captureCommand({

package/src/index.js

@@ -13,6 +13,7 @@ import * as profileDiffApi from "./profile-diff.js";
 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 syntheticProbeSuiteApi from "./synthetic-probe-suite.js";
 import * as syntheticProbesApi from "./synthetic-probes.js";
 
@@ -111,6 +112,8 @@ export const runtime = Object.freeze({
   writeImportLoopProfile: importLoopProfileApi.writeImportLoopProfile,
   renderImportLoopProfile: importLoopProfileApi.renderImportLoopProfileMarkdown,
   validateImportLoopProfile: importLoopProfileApi.validateImportLoopProfile,
+  applyExecutionCoverage: runtimeReconciliationApi.applyRuntimeExecutionCoverage,
+  buildExecutionCoverage: runtimeReconciliationApi.buildRuntimeExecutionCoverage,
 });
 
 export const synthetic = Object.freeze({
@@ -227,6 +230,10 @@ export {
   validateRuntimeProfile,
   writeRuntimeProfile,
 } from "./runtime-profile.js";
+export {
+  applyRuntimeExecutionCoverage,
+  buildRuntimeExecutionCoverage,
+} from "./runtime-reconciliation.js";
 export { buildSyntheticProbePlanFromReport } from "./synthetic-probe-suite.js";
 export {
   buildSyntheticProbePlan,

package/src/inspector.js

@@ -11,6 +11,9 @@ import { readOpenClawTargetSurface } from "./openclaw-target.js";
 import { buildCompatibilityReport, buildReport } from "./report.js";
 
 const execFileAsync = promisify(execFile);
+const registrationEquivalents = new Map([
+  ["registerChannel", new Set(["createChatChannelPlugin", "defineBundledChannelEntry", "defineChannelPluginEntry", "registerChannel"])],
+]);
 
 export async function inspectFixtureSet(config, options = {}) {
   const { inspections, failures } = await inspectConfiguredFixtures(config, options);
@@ -32,6 +35,7 @@ export async function inspectCompatibilityFixtureSet(config, options = {}) {
     inspections,
     failures,
     generatedAt: options.generatedAt,
+    executionResults: options.executionResults,
     targetOpenClaw,
     buildFixtureReport: ({ fixture, inspection }) =>
       buildCompatibilityFixtureReport({
@@ -58,7 +62,7 @@ async function inspectConfiguredFixtures(config, options = {}) {
       ["manifestContracts", inspection.manifestContracts],
     ]) {
       const expected = fixture.expect?.[key] ?? [];
-      const missing = expected.filter((value) => !observed.includes(value));
+      const missing = expected.filter((value) => !satisfiesExpectedSeam(key, value, observed));
       if (missing.length > 0) {
         failures.push(`${fixture.id}: missing ${key}: ${missing.join(", ")}`);
       }
@@ -68,6 +72,17 @@ async function inspectConfiguredFixtures(config, options = {}) {
   return { inspections, failures };
 }
 
+function satisfiesExpectedSeam(key, expected, observed) {
+  if (observed.includes(expected)) {
+    return true;
+  }
+  if (key !== "registrations") {
+    return false;
+  }
+  const equivalents = registrationEquivalents.get(expected);
+  return Boolean(equivalents && observed.some((value) => equivalents.has(value)));
+}
+
 export async function inspectPlugin(fixture, options = {}) {
   const config = options.config ?? { rootDir: options.rootDir ?? process.cwd() };
   const checkoutPath = fixtureCheckoutPath(config, fixture);
@@ -132,6 +147,7 @@ export function inspectSourceText(text, filePath = "source.js") {
   const hooks = collectDetailedMatches(searchableText, /\bapi\.on\(\s*["'`]([^"'`]+)["'`]/g, filePath, "name");
   const registrations = [
     ...collectDetailedMatches(searchableText, /\bapi\.(register[A-Za-z0-9]+)\s*\(/g, filePath, "name"),
+    ...collectDetailedMatches(searchableText, /\b(defineBundledChannelEntry)\s*\(/g, filePath, "name"),
     ...collectDetailedMatches(searchableText, /\b(defineChannelPluginEntry)\s*\(/g, filePath, "name"),
     ...collectDetailedMatches(searchableText, /\b(createChatChannelPlugin)\s*\(/g, filePath, "name"),
     ...collectDetailedMatches(searchableText, /\b(definePluginEntry)\s*\(/g, filePath, "name"),
@@ -457,9 +473,38 @@ function lineForOffset(text, offset) {
 }
 
 function stripComments(text) {
-  return text
-    .replace(/\/\*[\s\S]*?\*\//g, (comment) => comment.replace(/[^\n]/g, " "))
-    .replace(/\/\/.*$/gm, (comment) => " ".repeat(comment.length));
+  let result = "";
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (char === "/" && next === "*") {
+      result += "  ";
+      index += 2;
+      while (index < text.length && !(text[index] === "*" && text[index + 1] === "/")) {
+        result += blankCommentChar(text[index]);
+        index += 1;
+      }
+      if (index < text.length) {
+        result += "  ";
+        index += 1;
+      }
+    } else if (char === "/" && next === "/") {
+      result += "  ";
+      index += 2;
+      while (index < text.length && text[index] !== "\n" && text[index] !== "\r") {
+        result += " ";
+        index += 1;
+      }
+      index -= 1;
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+
+function blankCommentChar(char) {
+  return char === "\n" || char === "\r" ? char : " ";
 }
 
 function sortDetails(details) {

package/src/issues.js

@@ -23,17 +23,25 @@ export const knownIssueCodes = new Set([
   "package-build-artifact-entrypoint",
   "package-dependency-install-required",
   "package-entrypoint-missing",
+  "package-install-metadata-incomplete",
   "package-json-missing",
   "package-manifest-version-drift",
+  "package-min-host-version-drift",
+  "package-npm-pack-entrypoint-missing",
+  "package-npm-pack-metadata-missing",
+  "package-npm-pack-unavailable",
   "package-openclaw-entry-missing",
   "package-openclaw-metadata-missing",
+  "package-openclaw-unsupported-metadata",
   "package-plugin-api-compat-missing",
   "package-typescript-source-entrypoint",
   "provider-auth-env-vars",
   "registration-capture-gap",
   "runtime-tool-capture",
   "reserved-sdk-import",
+  "security-manifest-schema-unavailable",
   "sdk-export-missing",
+  "unrecognized-security-manifest",
 ]);
 
 export const issueMetadataByCode = {
@@ -85,6 +93,12 @@ export const issueMetadataByCode = {
     decision: "plugin-upstream-fix",
     title: "plugin imports reserved bundled-plugin SDK compatibility subpaths",
   },
+  "security-manifest-schema-unavailable": {
+    severity: "P3",
+    owner: "plugin",
+    decision: "plugin-upstream-fix",
+    title: "plugin security manifest references an unavailable schema",
+  },
   "missing-compat-record": {
     severity: "P1",
     owner: "core",
@@ -127,6 +141,12 @@ export const issueMetadataByCode = {
     decision: "plugin-upstream-fix",
     title: "OpenClaw package entrypoint is missing",
   },
+  "package-install-metadata-incomplete": {
+    severity: "P2",
+    owner: "plugin",
+    decision: "plugin-upstream-fix",
+    title: "OpenClaw package install metadata is incomplete",
+  },
   "package-json-missing": {
     severity: "P2",
     owner: "plugin",
@@ -139,6 +159,30 @@ export const issueMetadataByCode = {
     decision: "plugin-upstream-fix",
     title: "package and manifest versions drift",
   },
+  "package-min-host-version-drift": {
+    severity: "P2",
+    owner: "plugin",
+    decision: "plugin-upstream-fix",
+    title: "OpenClaw package minimum host version drifts from build target",
+  },
+  "package-npm-pack-entrypoint-missing": {
+    severity: "P1",
+    owner: "plugin",
+    decision: "plugin-upstream-fix",
+    title: "advertised npm artifact is missing OpenClaw entrypoints",
+  },
+  "package-npm-pack-metadata-missing": {
+    severity: "P2",
+    owner: "plugin",
+    decision: "plugin-upstream-fix",
+    title: "advertised npm artifact is missing OpenClaw metadata",
+  },
+  "package-npm-pack-unavailable": {
+    severity: "P1",
+    owner: "plugin",
+    decision: "plugin-upstream-fix",
+    title: "advertised npm artifact cannot be packed",
+  },
   "package-openclaw-entry-missing": {
     severity: "P2",
     owner: "plugin",
@@ -151,6 +195,12 @@ export const issueMetadataByCode = {
     decision: "plugin-upstream-fix",
     title: "OpenClaw package metadata is missing",
   },
+  "package-openclaw-unsupported-metadata": {
+    severity: "P2",
+    owner: "plugin",
+    decision: "plugin-upstream-fix",
+    title: "package declares unsupported OpenClaw metadata",
+  },
   "package-plugin-api-compat-missing": {
     severity: "P2",
     owner: "plugin",
@@ -193,6 +243,12 @@ export const issueMetadataByCode = {
     decision: "core-compat-adapter",
     title: "fixture calls a registrar missing from target OpenClaw",
   },
+  "unrecognized-security-manifest": {
+    severity: "P3",
+    owner: "plugin",
+    decision: "plugin-upstream-fix",
+    title: "plugin ships an unsupported security manifest",
+  },
 };
 
 export function buildIssues({ breakages = [], warnings = [], suggestions = [], targetOpenClaw, idPrefix = "CRABPOT" }) {
@@ -212,7 +268,7 @@ export function buildIssues({ breakages = [], warnings = [], suggestions = [], t
       owner: finding.owner,
       code: finding.code,
       decision: finding.decision,
-      status: finding.severity === "P0" || finding.level === "breakage" ? "blocking" : "open",
+      status: finding.status ?? (finding.severity === "P0" || finding.level === "breakage" ? "blocking" : "open"),
       issueClass: finding.issueClass,
       live: finding.live,
       deprecated: finding.deprecated,
@@ -220,6 +276,7 @@ export function buildIssues({ breakages = [], warnings = [], suggestions = [], t
       title: issueTitle(finding),
       evidence: finding.evidence ?? [],
       compatRecord: finding.compatRecord ?? null,
+      runtimeCoverage: finding.runtimeCoverage ?? null,
     }));
 }
 
@@ -314,10 +371,18 @@ function issueClassFor(code, options) {
       "manifest-unknown-fields",
       "package-json-missing",
       "package-manifest-version-drift",
+      "package-min-host-version-drift",
+      "package-npm-pack-entrypoint-missing",
+      "package-npm-pack-metadata-missing",
+      "package-npm-pack-unavailable",
       "package-openclaw-entry-missing",
       "package-openclaw-metadata-missing",
+      "package-openclaw-unsupported-metadata",
       "package-plugin-api-compat-missing",
+      "package-install-metadata-incomplete",
       "reserved-sdk-import",
+      "security-manifest-schema-unavailable",
+      "unrecognized-security-manifest",
     ].includes(code)
   ) {
     return "upstream-metadata";