@openclaw/plugin-inspector 0.1.1 → 0.1.3

package/src/cli.js

@@ -1,12 +1,18 @@
 #!/usr/bin/env node
+import path from "node:path";
 import {
   renderTextSummary,
   runPluginCheck,
 } from "./index.js";
 import {
+  buildCiSummary,
   captureEntrypoint,
+  inspectCompatibilityFixtureSet,
   inspectFixtureSet,
   loadInspectorConfig,
+  writeCiSummary,
+  writeCompatibilityReport,
+  writePluginInspectorInit,
   writeArtifacts,
   writeReport,
 } from "./advanced.js";
@@ -20,8 +26,12 @@ try {
     printHelp();
   } else if (command === "check") {
     await runCheck(commandArgs);
-  } else if (command === "inspect" || command === "report" || command === "ci") {
+  } else if (command === "init") {
+    await runInit(commandArgs);
+  } else if (command === "inspect" || command === "report") {
     await runReport(command, commandArgs);
+  } else if (command === "ci") {
+    await runCi(commandArgs);
   } else if (command === "capture") {
     await runCapture(commandArgs);
   } else {
@@ -34,11 +44,13 @@ try {
 
 async function runCheck(commandArgs) {
   const configPath = readFlag(commandArgs, "--config");
+  const pluginRoot = readFlag(commandArgs, "--plugin-root") ?? readFlag(commandArgs, "--root");
   const outDir = readFlag(commandArgs, "--out") ?? "reports";
   const openclawPath = commandArgs.includes("--no-openclaw") ? false : readFlag(commandArgs, "--openclaw");
   const json = commandArgs.includes("--json");
-  const capture = commandArgs.includes("--capture");
-  const { report } = await runPluginCheck({ configPath, outDir, openclawPath, capture });
+  const capture = readRuntimeFlag(commandArgs);
+  const mockSdk = readMockSdkFlag(commandArgs);
+  const { report } = await runPluginCheck({ configPath, pluginRoot, outDir, openclawPath, capture, mockSdk });
 
   if (json) {
     console.log(JSON.stringify(report, null, 2));
@@ -51,6 +63,25 @@ async function runCheck(commandArgs) {
   }
 }
 
+async function runInit(commandArgs) {
+  const pluginRoot = readFlag(commandArgs, "--plugin-root") ?? readFlag(commandArgs, "--root");
+  const configPath = readFlag(commandArgs, "--config") ?? undefined;
+  const workflowPath = readFlag(commandArgs, "--workflow") ?? undefined;
+  const packageManager = readFlag(commandArgs, "--package-manager") ?? "npm";
+  const result = await writePluginInspectorInit({
+    pluginRoot,
+    configPath,
+    workflowPath,
+    packageManager,
+    ci: commandArgs.includes("--ci"),
+    force: commandArgs.includes("--force"),
+  });
+
+  for (const filePath of result.written) {
+    console.log(`wrote ${filePath}`);
+  }
+}
+
 async function runReport(command, commandArgs) {
   const configPath = readFlag(commandArgs, "--config");
   const outDir = readFlag(commandArgs, "--out") ?? "reports";
@@ -71,11 +102,67 @@ async function runReport(command, commandArgs) {
   }
 }
 
+async function runCi(commandArgs) {
+  const configPath = readFlag(commandArgs, "--config");
+  const pluginRoot = readFlag(commandArgs, "--plugin-root") ?? readFlag(commandArgs, "--root");
+  const outDir = readFlag(commandArgs, "--out") ?? "reports";
+  const openclawPath = commandArgs.includes("--no-openclaw") ? false : readFlag(commandArgs, "--openclaw");
+  const json = commandArgs.includes("--json");
+  const { report, reportDir } = await runCiCompatibilityReport({
+    configPath,
+    openclawPath,
+    outDir,
+    pluginRoot,
+  });
+
+  const summary = await buildCiSummary({
+    artifactBaseDir: reportDir,
+    reportPaths: {
+      compatibility: "plugin-inspector-report.json",
+    },
+    reports: {
+      compatibility: report,
+    },
+  });
+  await writeCiSummary(summary, {
+    jsonPath: path.join(reportDir, "plugin-inspector-ci-summary.json"),
+    markdownPath: path.join(reportDir, "plugin-inspector-ci-summary.md"),
+  });
+
+  if (json) {
+    console.log(JSON.stringify(summary, null, 2));
+  } else {
+    console.log(renderCiTextSummary(summary));
+  }
+
+  if (summary.status !== "pass") {
+    throw new Error("plugin-inspector ci summary failed");
+  }
+}
+
+async function runCiCompatibilityReport({ configPath, openclawPath, outDir, pluginRoot }) {
+  if (configPath) {
+    const config = await loadInspectorConfig(configPath, { cwd: pluginRoot });
+    const report = await inspectCompatibilityFixtureSet(config, { openclawPath });
+    await writeCompatibilityReport(report, { cwd: config.rootDir, outDir });
+    return {
+      report,
+      reportDir: path.resolve(config.rootDir, outDir),
+    };
+  }
+
+  const { report } = await runPluginCheck({ pluginRoot, outDir, openclawPath });
+  return {
+    report,
+    reportDir: path.resolve(pluginRoot ?? process.cwd(), outDir),
+  };
+}
+
 async function runCapture(commandArgs) {
   const entrypoint = commandArgs.find((arg) => !arg.startsWith("-"));
   const outputPath = readFlag(commandArgs, "--output");
   const pluginRoot = readFlag(commandArgs, "--plugin-root");
-  const mockSdk = commandArgs.includes("--mock-sdk");
+  const mockSdk = readMockSdkFlag(commandArgs) ?? commandArgs.includes("--mock-sdk");
   if (!entrypoint) {
     throw new Error("capture requires an entrypoint path");
   }
@@ -100,14 +187,58 @@ function readFlag(commandArgs, name) {
   return commandArgs[index + 1] ?? null;
 }
 
+function readRuntimeFlag(commandArgs) {
+  if (commandArgs.includes("--runtime") || commandArgs.includes("--capture")) {
+    return true;
+  }
+  if (commandArgs.includes("--no-runtime") || commandArgs.includes("--no-capture")) {
+    return false;
+  }
+  return undefined;
+}
+
+function readMockSdkFlag(commandArgs) {
+  const sdk = readFlag(commandArgs, "--sdk");
+  if (sdk === "mock") {
+    return true;
+  }
+  if (sdk === "real") {
+    return false;
+  }
+  if (sdk && !["mock", "real"].includes(sdk)) {
+    throw new Error("--sdk must be mock or real");
+  }
+  if (commandArgs.includes("--mock-sdk")) {
+    return true;
+  }
+  if (commandArgs.includes("--real-sdk")) {
+    return false;
+  }
+  return undefined;
+}
+
+function renderCiTextSummary(summary) {
+  return [
+    `Status: ${summary.status.toUpperCase()}`,
+    `Breakages: ${summary.summary.breakages}`,
+    `Issues: ${summary.summary.issues}`,
+    `Artifacts: ${Object.values(summary.artifacts).filter(Boolean).length}`,
+  ].join("\n");
+}
+
 function printHelp() {
   console.log(`plugin-inspector
 
 Usage:
-  plugin-inspector check [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--capture] [--json]
+  plugin-inspector
+  plugin-inspector check [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--json]
+  plugin-inspector init [--plugin-root <path>] [--config <path>] [--ci] [--package-manager npm|pnpm|yarn|bun] [--force]
   plugin-inspector report --config <path> [--out <dir>] [--check] [--json]
   plugin-inspector inspect --config <path> [--out <dir>] [--check] [--json]
-  plugin-inspector ci --config <path> [--out <dir>]
-  PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 plugin-inspector capture <entrypoint> [--mock-sdk] [--plugin-root <path>] [--output <path>]
+  plugin-inspector ci [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--json]
+  PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 plugin-inspector capture <entrypoint> [--mock-sdk|--real-sdk] [--plugin-root <path>] [--output <path>]
+
+Default check runs from the current plugin root and writes reports/ unless --out is set.
+Runtime capture is opt-in because it imports plugin code; use --runtime with PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1.
 `);
 }

package/src/config.js

@@ -52,6 +52,19 @@ export function validateInspectorConfig(config) {
     errors.push("config.fixtures must be a non-empty array");
   }
 
+  if (config.capture !== undefined) {
+    if (!config.capture || typeof config.capture !== "object" || Array.isArray(config.capture)) {
+      errors.push("config.capture must be an object when present");
+    } else {
+      if (config.capture.runtime !== undefined && typeof config.capture.runtime !== "boolean") {
+        errors.push("config.capture.runtime must be a boolean when present");
+      }
+      if (config.capture.mockSdk !== undefined && typeof config.capture.mockSdk !== "boolean") {
+        errors.push("config.capture.mockSdk must be a boolean when present");
+      }
+    }
+  }
+
   const ids = new Set();
   const paths = new Set();
   for (const fixture of config.fixtures ?? []) {
@@ -134,6 +147,7 @@ export async function normalizePluginRootConfig(config, options = {}) {
   return {
     version: 1,
     submoduleRoot: ".",
+    capture: config.capture,
     openclaw: config.openclaw,
     fixtures: [fixture],
   };
@@ -157,7 +171,7 @@ async function readJsonIfExists(filePath) {
   return JSON.parse(await readFile(filePath, "utf8"));
 }
 
-function packageId(packageName) {
+export function packageId(packageName) {
   if (!packageName) {
     return null;
   }
@@ -170,7 +184,7 @@ function packageId(packageName) {
     .toLowerCase();
 }
 
-function inferPluginSeams(pluginManifest, packageJson) {
+export function inferPluginSeams(pluginManifest, packageJson) {
   const contracts = Object.keys(pluginManifest?.contracts ?? {});
   if (contracts.includes("tools")) {
     return ["dynamic-tool"];

package/src/contract-probes.js

@@ -29,6 +29,11 @@ export const contractProbeRules = {
     contract: "Every observed OpenClaw plugin SDK import remains exported by the target OpenClaw package.",
     target: "sdk-alias",
   },
+  "reserved-sdk-import": {
+    id: "sdk.import.reserved-bundled-plugin-boundary",
+    contract: "External plugins use documented public SDK subpaths instead of reserved bundled-plugin compatibility shims.",
+    target: "sdk-import",
+  },
   "provider-auth-env-vars": {
     id: "manifest.compat.provider-auth-env-vars",
     contract: "Legacy provider auth env metadata continues to map into config/help surfaces.",

package/src/fixture-summary.js

@@ -626,7 +626,12 @@ function classifySdkImportCoverage({ fixture, fixtureReport, targetOpenClaw, war
 
   const sdkExports = new Set(targetOpenClaw.sdkExports);
   const unknownImports = fixtureReport.sdkImportDetails.filter((sdkImport) => !sdkExports.has(sdkImport.specifier));
-  if (unknownImports.length === 0) {
+  const reservedSdkExports = new Set(targetOpenClaw.reservedSdkExports ?? []);
+  const reservedImports = fixtureReport.sdkImportDetails.filter((sdkImport) =>
+    reservedSdkExports.has(sdkImport.specifier),
+  );
+
+  if (reservedImports.length === 0 && unknownImports.length === 0) {
     logs.push({
       fixture: fixture.id,
       code: "sdk-exports-present",
@@ -637,21 +642,40 @@ function classifySdkImportCoverage({ fixture, fixtureReport, targetOpenClaw, war
     return;
   }
 
-  warnings.push({
-    fixture: fixture.id,
-    code: "sdk-export-missing",
-    level: "warning",
-    message: "fixture imports plugin SDK aliases that are not exported by the target OpenClaw package",
-    evidence: detailEvidence(unknownImports, "specifier"),
-    compatRecord: "plugin-sdk-export-aliases",
-  });
-  decisions.push({
-    fixture: fixture.id,
-    decision: "core-compat-adapter",
-    seam: "sdk-alias",
-    action: "Restore the package export alias or publish a versioned migration map before cold-importing old plugins.",
-    evidence: unique(unknownImports.map((sdkImport) => sdkImport.specifier)).join(", "),
-  });
+  if (unknownImports.length > 0) {
+    warnings.push({
+      fixture: fixture.id,
+      code: "sdk-export-missing",
+      level: "warning",
+      message: "fixture imports plugin SDK aliases that are not exported by the target OpenClaw package",
+      evidence: detailEvidence(unknownImports, "specifier"),
+      compatRecord: "plugin-sdk-export-aliases",
+    });
+    decisions.push({
+      fixture: fixture.id,
+      decision: "core-compat-adapter",
+      seam: "sdk-alias",
+      action: "Restore the package export alias or publish a versioned migration map before cold-importing old plugins.",
+      evidence: unique(unknownImports.map((sdkImport) => sdkImport.specifier)).join(", "),
+    });
+  }
+
+  if (reservedImports.length > 0) {
+    warnings.push({
+      fixture: fixture.id,
+      code: "reserved-sdk-import",
+      level: "warning",
+      message: "fixture imports reserved bundled-plugin SDK compatibility subpaths",
+      evidence: detailEvidence(reservedImports, "specifier"),
+    });
+    decisions.push({
+      fixture: fixture.id,
+      decision: "plugin-upstream-fix",
+      seam: "sdk-import",
+      action: "Move the plugin to documented public SDK subpaths or plugin-local helpers before relying on this compatibility shim.",
+      evidence: unique(reservedImports.map((sdkImport) => sdkImport.specifier)).join(", "),
+    });
+  }
 }
 
 function classifyManifestFieldCoverage({ fixture, fixtureReport, targetOpenClaw, warnings, logs, decisions }) {

package/src/index.js

@@ -6,5 +6,6 @@ export {
   loadPluginConfig,
   renderTextSummary,
   runPluginCheck,
+  setupPluginInspector,
   writePluginReports,
 } from "./api.js";

package/src/init.js

@@ -0,0 +1,150 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { inferPluginSeams, packageId } from "./config.js";
+
+export const defaultInitConfigPath = "plugin-inspector.config.json";
+export const defaultInitWorkflowPath = ".github/workflows/plugin-inspector.yml";
+
+export async function writePluginInspectorInit(options = {}) {
+  const pluginRoot = path.resolve(options.pluginRoot ?? options.cwd ?? process.cwd());
+  const configPath = path.resolve(pluginRoot, options.configPath ?? defaultInitConfigPath);
+  const written = [];
+
+  if (existsSync(configPath) && options.force !== true) {
+    throw new Error(`${path.relative(pluginRoot, configPath)} already exists; pass --force to overwrite it`);
+  }
+
+  const config = await buildPluginInspectorConfig({ pluginRoot });
+  await mkdir(path.dirname(configPath), { recursive: true });
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  written.push(configPath);
+
+  if (options.ci === true) {
+    const workflowPath = path.resolve(pluginRoot, options.workflowPath ?? defaultInitWorkflowPath);
+    if (existsSync(workflowPath) && options.force !== true) {
+      throw new Error(`${path.relative(pluginRoot, workflowPath)} already exists; pass --force to overwrite it`);
+    }
+    await mkdir(path.dirname(workflowPath), { recursive: true });
+    await writeFile(workflowPath, renderGithubActionsWorkflow({ packageManager: options.packageManager }), "utf8");
+    written.push(workflowPath);
+  }
+
+  return { pluginRoot, configPath, written };
+}
+
+export async function buildPluginInspectorConfig(options = {}) {
+  const pluginRoot = path.resolve(options.pluginRoot ?? options.cwd ?? process.cwd());
+  const packageJson = await readJsonIfExists(path.join(pluginRoot, "package.json"));
+  const pluginManifest = await readJsonIfExists(path.join(pluginRoot, "openclaw.plugin.json"));
+  const sourceRoot = inferSourceRoot(packageJson);
+
+  const plugin = {
+    id: pluginManifest?.id ?? packageId(packageJson?.name) ?? "plugin",
+    priority: "high",
+    seams: inferPluginSeams(pluginManifest, packageJson),
+  };
+
+  if (sourceRoot !== ".") {
+    plugin.sourceRoot = sourceRoot;
+  }
+
+  return {
+    version: 1,
+    plugin,
+    capture: {
+      mockSdk: true,
+    },
+  };
+}
+
+export function renderGithubActionsWorkflow(options = {}) {
+  const packageManager = normalizePackageManager(options.packageManager);
+  const setup = packageManagerSetup(packageManager);
+
+  return `name: plugin-inspector
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: ${setup.cache}
+${setup.corepack ? "      - run: corepack enable\n" : ""}      - run: ${setup.install}
+      - run: ${setup.exec} @openclaw/plugin-inspector check --no-openclaw
+      - run: PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 ${setup.exec} @openclaw/plugin-inspector check --no-openclaw --runtime --mock-sdk
+      - uses: actions/upload-artifact@v5
+        if: always()
+        with:
+          name: plugin-inspector-reports
+          path: reports/plugin-inspector-*
+`;
+}
+
+function inferSourceRoot(packageJson) {
+  const entrypoints = [
+    packageJson?.openclaw?.entrypoint,
+    ...(packageJson?.openclaw?.extensions ?? []),
+    ...(packageJson?.openclaw?.runtimeExtensions ?? []),
+  ].filter((value) => typeof value === "string");
+  const entrypoint = entrypoints[0] ?? packageJson?.exports?.["."] ?? packageJson?.main ?? "src/index.js";
+  if (typeof entrypoint === "string" && entrypoint.startsWith("src/")) {
+    return "src";
+  }
+  return ".";
+}
+
+async function readJsonIfExists(filePath) {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  return JSON.parse(await readFile(filePath, "utf8"));
+}
+
+function normalizePackageManager(packageManager = "npm") {
+  if (["npm", "pnpm", "yarn", "bun"].includes(packageManager)) {
+    return packageManager;
+  }
+  throw new Error("--package-manager must be npm, pnpm, yarn, or bun");
+}
+
+function packageManagerSetup(packageManager) {
+  if (packageManager === "pnpm") {
+    return {
+      cache: "pnpm",
+      corepack: true,
+      install: "pnpm install --frozen-lockfile",
+      exec: "pnpm dlx",
+    };
+  }
+  if (packageManager === "yarn") {
+    return {
+      cache: "yarn",
+      corepack: true,
+      install: "yarn install --immutable",
+      exec: "yarn dlx",
+    };
+  }
+  if (packageManager === "bun") {
+    return {
+      cache: "npm",
+      corepack: false,
+      install: "bun install --frozen-lockfile",
+      exec: "bunx",
+    };
+  }
+  return {
+    cache: "npm",
+    corepack: false,
+    install: "npm ci",
+    exec: "npx",
+  };
+}

package/src/inspector.js

@@ -156,7 +156,12 @@ export async function captureEntrypoint(entrypoint, options = {}) {
   }
 
   const resolvedEntrypoint = path.resolve(options.cwd ?? process.cwd(), entrypoint);
-  const module = await import(pathToFileURL(resolvedEntrypoint).href);
+  let module;
+  try {
+    module = await import(pathToFileURL(resolvedEntrypoint).href);
+  } catch (error) {
+    throw classifyCapturePhaseError(error, "entrypoint-import-error");
+  }
   const register = findRegisterExport(module);
 
   if (!register) {
@@ -168,7 +173,11 @@ export async function captureEntrypoint(entrypoint, options = {}) {
   }
 
   const api = createCaptureApi(options.apiOptions);
-  await register(api);
+  try {
+    await register(api);
+  } catch (error) {
+    throw classifyCapturePhaseError(error, "registration-execution-error");
+  }
   const result = {
     status: "captured",
     entrypoint: resolvedEntrypoint,
@@ -188,19 +197,85 @@ export async function captureEntrypointWithMockSdk(entrypoint, options = {}) {
     pluginRoot: options.pluginRoot,
     apiOptions: options.apiOptions,
   };
-  const { stdout } = await execFileAsync(
-    process.execPath,
-    ["--preserve-symlinks", runnerPath, JSON.stringify(payload)],
-    {
-      cwd: options.cwd ?? process.cwd(),
-      env: {
-        ...process.env,
-        ...(options.env ?? {}),
+  try {
+    const { stdout } = await execFileAsync(
+      process.execPath,
+      ["--no-warnings", "--preserve-symlinks", runnerPath, JSON.stringify(payload)],
+      {
+        cwd: options.cwd ?? process.cwd(),
+        env: {
+          ...process.env,
+          ...(options.env ?? {}),
+        },
+        maxBuffer: 1024 * 1024 * 10,
       },
-      maxBuffer: 1024 * 1024 * 10,
-    },
-  );
-  return JSON.parse(stdout);
+    );
+    return JSON.parse(stdout);
+  } catch (error) {
+    throw classifyMockSdkCaptureError(error);
+  }
+}
+
+export function classifyMockSdkCaptureError(error) {
+  const rawMessage = [error?.stderr, error?.stdout, error?.message].filter(Boolean).join("\n");
+  const missingExport = rawMessage.match(/does not provide an export named ['"]([^'"]+)['"]/)?.[1];
+  if (missingExport) {
+    return enrichCaptureError(error, {
+      message: `Mock SDK import failed: openclaw/plugin-sdk is missing export ${missingExport}`,
+      failureClass: "missing-sdk-export",
+      missingExport,
+    });
+  }
+
+  const missingModule =
+    rawMessage.match(/Cannot find (?:package|module) ['"]([^'"]*openclaw\/plugin-sdk[^'"]*)['"]/)?.[1] ??
+    rawMessage.match(/Package subpath ['"](\.\/plugin-sdk\/[^'"]+)['"]/)?.[1];
+  if (missingModule || rawMessage.includes("openclaw/plugin-sdk")) {
+    return enrichCaptureError(error, {
+      message: `Mock SDK import failed: ${missingModule ?? "openclaw/plugin-sdk module could not be resolved"}`,
+      failureClass: "missing-sdk-module",
+      missingModule,
+    });
+  }
+
+  const failureClass = rawMessage.match(/\[plugin-inspector:([^\]]+)\]/)?.[1];
+  if (failureClass) {
+    return enrichCaptureError(error, {
+      message: firstMeaningfulErrorLine(rawMessage.replace(/\[plugin-inspector:[^\]]+\]/, "")) ?? "Mock SDK capture failed",
+      failureClass,
+    });
+  }
+
+  return enrichCaptureError(error, {
+    message: firstMeaningfulErrorLine(rawMessage) ?? "Mock SDK capture failed",
+    failureClass: "mock-sdk-capture-error",
+  });
+}
+
+export function classifyCapturePhaseError(error, failureClass) {
+  return enrichCaptureError(error, {
+    message: error instanceof Error ? error.message : String(error),
+    failureClass,
+  });
+}
+
+function enrichCaptureError(error, details) {
+  const wrapped = new Error(details.message, { cause: error });
+  wrapped.failureClass = details.failureClass;
+  if (details.missingExport) {
+    wrapped.missingExport = details.missingExport;
+  }
+  if (details.missingModule) {
+    wrapped.missingModule = details.missingModule;
+  }
+  return wrapped;
+}
+
+function firstMeaningfulErrorLine(message) {
+  return String(message)
+    .split("\n")
+    .map((line) => line.trim())
+    .find((line) => line && !line.startsWith("Command failed:"));
 }
 
 function findRegisterExport(module) {

package/src/issues.js

@@ -32,6 +32,7 @@ export const knownIssueCodes = new Set([
   "provider-auth-env-vars",
   "registration-capture-gap",
   "runtime-tool-capture",
+  "reserved-sdk-import",
   "sdk-export-missing",
 ]);
 
@@ -78,6 +79,12 @@ export const issueMetadataByCode = {
     decision: "core-compat-adapter",
     title: "plugin SDK import aliases are missing from target package exports",
   },
+  "reserved-sdk-import": {
+    severity: "P1",
+    owner: "plugin",
+    decision: "plugin-upstream-fix",
+    title: "plugin imports reserved bundled-plugin SDK compatibility subpaths",
+  },
   "missing-compat-record": {
     severity: "P1",
     owner: "core",
@@ -310,6 +317,7 @@ function issueClassFor(code, options) {
       "package-openclaw-entry-missing",
       "package-openclaw-metadata-missing",
       "package-plugin-api-compat-missing",
+      "reserved-sdk-import",
     ].includes(code)
   ) {
     return "upstream-metadata";