@openclaw/plugin-inspector 0.3.18 → 0.3.20

package/src/fixture-summary.js

@@ -3,6 +3,7 @@ import { readdir } from "node:fs/promises";
 import path from "node:path";
 import { compatRecordForIssueCode } from "./contract-probes.js";
 import { readJsonFile } from "./json-file.js";
+import { satisfiesOpenClawCompatibilityRange } from "./openclaw-version.js";
 
 const conversationAccessHooks = new Set(["agent_end", "llm_input", "llm_output"]);
 const captureGapRegistrations = new Set([
@@ -143,6 +144,8 @@ export function summarizePackage(packagePath, packageJson, options = {}) {
         extensions: arrayValues(packageJson.openclaw.extensions),
         runtimeExtensions: arrayValues(packageJson.openclaw.runtimeExtensions),
         setupEntry: typeof packageJson.openclaw.setupEntry === "string" ? packageJson.openclaw.setupEntry : null,
+        runtimeSetupEntry:
+          typeof packageJson.openclaw.runtimeSetupEntry === "string" ? packageJson.openclaw.runtimeSetupEntry : null,
         compatPluginApi:
           typeof packageJson.openclaw.compat?.pluginApi === "string" ? packageJson.openclaw.compat.pluginApi : null,
         buildOpenClawVersion:
@@ -464,30 +467,36 @@ export function classifyPackageContracts({ fixture, inspection, fixtureReport })
 }
 
 export function classifyTargetOpenClawCoverage({ fixture, inspection, fixtureReport, targetOpenClaw }) {
+  const breakages = [];
   const warnings = [];
+  const suggestions = [];
   const logs = [];
   const decisions = [];
+  const findingContext = { breakages, warnings, suggestions, fixtureReport, targetOpenClaw };
 
-  classifyHookNameCoverage({ fixture, inspection, targetOpenClaw, warnings, logs });
-  classifyRegistrationNameCoverage({ fixture, inspection, targetOpenClaw, warnings, logs });
-  classifySdkImportCoverage({ fixture, fixtureReport, targetOpenClaw, warnings, logs, decisions });
+  classifyHookNameCoverage({ fixture, inspection, targetOpenClaw, logs, findingContext });
+  classifyRegistrationNameCoverage({ fixture, inspection, targetOpenClaw, logs, findingContext });
+  classifySdkImportCoverage({ fixture, fixtureReport, targetOpenClaw, warnings, logs, decisions, findingContext });
   classifyManifestFieldCoverage({ fixture, fixtureReport, targetOpenClaw, warnings, logs, decisions });
 
-  return { warnings, logs, decisions };
+  return { breakages, warnings, suggestions, logs, decisions };
 }
 
 export function classifyCompatibilityFixture({ fixture, inspection, fixtureReport, targetOpenClaw }) {
+  const breakages = [];
   const warnings = [];
   const suggestions = [];
   const logs = [];
   const decisions = [];
 
   if (inspection.status !== "ok") {
-    return { warnings, suggestions, logs, decisions };
+    return { breakages, warnings, suggestions, logs, decisions };
   }
 
   const targetCoverage = classifyTargetOpenClawCoverage({ fixture, inspection, fixtureReport, targetOpenClaw });
+  breakages.push(...targetCoverage.breakages);
   warnings.push(...targetCoverage.warnings);
+  suggestions.push(...targetCoverage.suggestions);
   logs.push(...targetCoverage.logs);
   decisions.push(...targetCoverage.decisions);
 
@@ -701,7 +710,7 @@ export function classifyCompatibilityFixture({ fixture, inspection, fixtureRepor
     });
   }
 
-  return { warnings, suggestions, logs, decisions };
+  return { breakages, warnings, suggestions, logs, decisions };
 }
 
 function classifySdkDeprecations({ fixture, inspection, fixtureReport, warnings, decisions }) {
@@ -807,7 +816,7 @@ function registrationCaptureGapDetails(inspection, targetOpenClaw) {
   return apiRegistrationDetails.filter((registration) => captureGapRegistrations.has(registration.name));
 }
 
-function classifyHookNameCoverage({ fixture, inspection, targetOpenClaw, warnings, logs }) {
+function classifyHookNameCoverage({ fixture, inspection, targetOpenClaw, logs, findingContext }) {
   if (targetOpenClaw.status !== "ok" || targetOpenClaw.hookNames.length === 0) {
     return;
   }
@@ -825,16 +834,18 @@ function classifyHookNameCoverage({ fixture, inspection, targetOpenClaw, warning
     return;
   }
 
-  warnings.push({
+  addVersionDerivedFinding({
+    ...findingContext,
+    finding: {
     fixture: fixture.id,
     code: "unknown-hook-name",
-    level: "warning",
     message: "fixture registers hooks that are not present in the target OpenClaw hook registry",
     evidence: detailEvidence(unknownHooks),
+    },
   });
 }
 
-function classifyRegistrationNameCoverage({ fixture, inspection, targetOpenClaw, warnings, logs }) {
+function classifyRegistrationNameCoverage({ fixture, inspection, targetOpenClaw, logs, findingContext }) {
   if (targetOpenClaw.status !== "ok" || targetOpenClaw.apiRegistrars.length === 0) {
     return;
   }
@@ -855,16 +866,18 @@ function classifyRegistrationNameCoverage({ fixture, inspection, targetOpenClaw,
     return;
   }
 
-  warnings.push({
+  addVersionDerivedFinding({
+    ...findingContext,
+    finding: {
     fixture: fixture.id,
     code: "unknown-registration-name",
-    level: "warning",
     message: "fixture calls api.register* methods that are not present in the target OpenClaw plugin API builder",
     evidence: detailEvidence(unknownRegistrations),
+    },
   });
 }
 
-function classifySdkImportCoverage({ fixture, fixtureReport, targetOpenClaw, warnings, logs, decisions }) {
+function classifySdkImportCoverage({ fixture, fixtureReport, targetOpenClaw, warnings, logs, decisions, findingContext }) {
   if (targetOpenClaw.status !== "ok" || targetOpenClaw.sdkExports.length === 0 || fixtureReport.sdkImports.length === 0) {
     return;
   }
@@ -888,13 +901,15 @@ function classifySdkImportCoverage({ fixture, fixtureReport, targetOpenClaw, war
   }
 
   if (unknownImports.length > 0) {
-    warnings.push({
+    addVersionDerivedFinding({
+      ...findingContext,
+      finding: {
       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,
@@ -923,6 +938,52 @@ function classifySdkImportCoverage({ fixture, fixtureReport, targetOpenClaw, war
   }
 }
 
+function addVersionDerivedFinding({ finding, fixtureReport, targetOpenClaw, breakages, warnings, suggestions }) {
+  const compatibility = targetCompatibility(fixtureReport, targetOpenClaw);
+  if (!compatibility) {
+    warnings.push({ ...finding, level: "warning" });
+    return;
+  }
+
+  if (compatibility.inDeclaredRange) {
+    breakages.push({
+      ...finding,
+      level: "breakage",
+      compatibility,
+      authorRemediation: {
+        summary:
+          "Update the plugin to use APIs available in the target OpenClaw version, or narrow its declared compatibility range.",
+      },
+      authorRemediationDocs: false,
+    });
+    return;
+  }
+
+  suggestions.push({
+    ...finding,
+    level: "information",
+    message: `${finding.message}; the resolved target is outside the plugin's declared compatibility range`,
+    compatibility,
+  });
+}
+
+function targetCompatibility(fixtureReport, targetOpenClaw) {
+  const declaredRange = fixtureReport.package?.openclaw?.compatPluginApi;
+  const targetVersion = targetOpenClaw.version;
+  const evaluatedVersion = targetOpenClaw.eligibilityVersion ?? targetOpenClaw.version;
+  if (!declaredRange || !targetVersion || !evaluatedVersion || !targetOpenClaw.requestedVersion) return null;
+  return {
+    declaredRange,
+    targetVersion,
+    evaluatedVersion,
+    inDeclaredRange: satisfiesOpenClawCompatibilityRange({
+      targetVersion,
+      eligibilityVersion: evaluatedVersion,
+      range: declaredRange,
+    }),
+  };
+}
+
 function classifyManifestFieldCoverage({ fixture, fixtureReport, targetOpenClaw, warnings, logs, decisions }) {
   if (targetOpenClaw.status !== "ok" || targetOpenClaw.manifestFields.length === 0) {
     return;
@@ -984,6 +1045,9 @@ function collectOpenClawEntrypoints(packageDir, openclaw, options) {
     ...openclaw.extensions.map((specifier) => ({ kind: "extension", specifier })),
     ...openclaw.runtimeExtensions.map((specifier) => ({ kind: "runtimeExtension", specifier })),
     ...(openclaw.setupEntry ? [{ kind: "setupEntry", specifier: openclaw.setupEntry }] : []),
+    ...(openclaw.runtimeSetupEntry
+      ? [{ kind: "runtimeSetupEntry", specifier: openclaw.runtimeSetupEntry }]
+      : []),
   ];
 
   return entrypoints.map((entrypoint) => {
@@ -1015,7 +1079,7 @@ function hasUsablePackageRuntimeEntrypoint(entrypoint, packageSummary, entrypoin
     return true;
   }
 
-  if (entrypoint.kind === "extension" && entrypoints.some((candidate) => candidate.kind === "runtimeExtension" && candidate.exists)) {
+  if (entrypoints.some((candidate) => candidate.exists && isPairedRuntimeEntrypoint(entrypoint, candidate))) {
     return true;
   }
 
@@ -1038,6 +1102,13 @@ function normalizeEntrypointSpecifier(specifier) {
   return normalized.startsWith("./") ? normalized : `./${normalized}`;
 }
 
+function isPairedRuntimeEntrypoint(entrypoint, candidate) {
+  return (
+    (entrypoint.kind === "extension" && candidate.kind === "runtimeExtension") ||
+    (entrypoint.kind === "setupEntry" && candidate.kind === "runtimeSetupEntry")
+  );
+}
+
 async function findPackageFiles(root, options, depth = 0) {
   if (!existsSync(root) || depth > options.maxDepth) {
     return [];
@@ -1227,9 +1298,10 @@ function hasPackagedRuntimeEntrypoint(entrypoint, packageSummary, entrypoints) {
   }
 
   if (
-    entrypoint.kind === "extension" &&
     entrypoints.some(
-      (candidate) => candidate.kind === "runtimeExtension" && repoPathIncludedInNpmPack(packageSummary, candidate.relativePath),
+      (candidate) =>
+        isPairedRuntimeEntrypoint(entrypoint, candidate) &&
+        repoPathIncludedInNpmPack(packageSummary, candidate.relativePath),
     )
   ) {
     return true;
@@ -1245,12 +1317,82 @@ function packageMinHostVersionDrift(packageSummary) {
   if (!nonEmptyString(openclaw?.install?.minHostVersion) || !nonEmptyString(openclaw?.buildOpenClawVersion)) {
     return false;
   }
-  return parseMinHostVersionFloor(openclaw.install.minHostVersion) !== openclaw.buildOpenClawVersion;
+  const minimumHostVersion = parseMinHostVersionFloor(openclaw.install.minHostVersion);
+  const buildOpenClawVersion = parseSemver(openclaw.buildOpenClawVersion);
+  if (!minimumHostVersion || !buildOpenClawVersion) {
+    return true;
+  }
+  return compareSemver(minimumHostVersion, buildOpenClawVersion) > 0;
 }
 
 function parseMinHostVersionFloor(value) {
   const match = /^>=([0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)$/.exec(value);
-  return match?.[1] ?? null;
+  return match ? parseSemver(match[1]) : null;
+}
+
+function parseSemver(value) {
+  const match =
+    /^([0-9]+)\.([0-9]+)\.([0-9]+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(
+      value,
+    );
+  if (!match) {
+    return null;
+  }
+  const coreParts = match.slice(1, 4);
+  if (coreParts.some((part) => part.length > 1 && part.startsWith("0"))) {
+    return null;
+  }
+  const prerelease = match[4]?.split(".") ?? [];
+  if (prerelease.some((part) => /^[0-9]+$/.test(part) && part.length > 1 && part.startsWith("0"))) {
+    return null;
+  }
+  return { core: coreParts, prerelease };
+}
+
+function compareNumericIdentifier(left, right) {
+  if (left.length !== right.length) {
+    return left.length < right.length ? -1 : 1;
+  }
+  if (left === right) {
+    return 0;
+  }
+  return left < right ? -1 : 1;
+}
+
+function compareSemver(left, right) {
+  for (let index = 0; index < left.core.length; index += 1) {
+    const comparison = compareNumericIdentifier(left.core[index], right.core[index]);
+    if (comparison !== 0) {
+      return comparison;
+    }
+  }
+  if (left.prerelease.length === 0 || right.prerelease.length === 0) {
+    if (left.prerelease.length === right.prerelease.length) {
+      return 0;
+    }
+    return left.prerelease.length === 0 ? 1 : -1;
+  }
+  const count = Math.max(left.prerelease.length, right.prerelease.length);
+  for (let index = 0; index < count; index += 1) {
+    const leftPart = left.prerelease[index];
+    const rightPart = right.prerelease[index];
+    if (leftPart === undefined || rightPart === undefined) {
+      return leftPart === undefined ? -1 : 1;
+    }
+    if (leftPart === rightPart) {
+      continue;
+    }
+    const leftNumeric = /^[0-9]+$/.test(leftPart);
+    const rightNumeric = /^[0-9]+$/.test(rightPart);
+    if (leftNumeric && rightNumeric) {
+      return compareNumericIdentifier(leftPart, rightPart);
+    }
+    if (leftNumeric !== rightNumeric) {
+      return leftNumeric ? -1 : 1;
+    }
+    return leftPart < rightPart ? -1 : 1;
+  }
+  return 0;
 }
 
 function repoPathIncludedInNpmPack(packageSummary, repoPath) {

package/src/index.js

@@ -8,7 +8,8 @@ import * as executionResultsApi from "./execution-results.js";
 import * as importLoopProfileApi from "./import-loop-profile.js";
 import * as inspectorApi from "./inspector.js";
 import * as issuesApi from "./issues.js";
-import * as openClawTargetApi from "./openclaw-target.js";
+import * as openClawTargetApi from "./openclaw-version.js";
+import * as openClawTargetSurfaceApi from "./openclaw-target.js";
 import * as profileDiffApi from "./profile-diff.js";
 import * as refDiffApi from "./ref-diff.js";
 import * as reportApi from "./report.js";
@@ -67,8 +68,16 @@ export const reports = Object.freeze({
   issueId: issuesApi.issueId,
   classifyIssueFinding: issuesApi.classifyIssueFinding,
   knownIssueCodes: issuesApi.knownIssueCodes,
-  openClawTargetPathCandidates: openClawTargetApi.openClawTargetPathCandidates,
-  readOpenClawTargetSurface: openClawTargetApi.readOpenClawTargetSurface,
+  openClawTargetPathCandidates: openClawTargetSurfaceApi.openClawTargetPathCandidates,
+  readOpenClawTargetSurface: openClawTargetSurfaceApi.readOpenClawTargetSurface,
+});
+
+export const openClawTargets = Object.freeze({
+  resolveVersion: openClawTargetApi.resolveOpenClawTargetVersion,
+  prepare: openClawTargetApi.prepareOpenClawTarget,
+  eligibilityVersion: openClawTargetApi.openClawEligibilityVersion,
+  satisfiesCompatibilityRange: openClawTargetApi.satisfiesOpenClawCompatibilityRange,
+  satisfiesRange: openClawTargetApi.satisfiesOpenClawVersionRange,
 });
 
 export const contracts = Object.freeze({

package/src/init.js

@@ -108,14 +108,14 @@ jobs:
   check:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
-      - uses: actions/setup-node@v5
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
         with:
           node-version: 24
           cache: ${setup.cache}
 ${setup.corepack ? "      - run: corepack enable\n" : ""}      - run: ${setup.install}
       - run: ${setup.exec} @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute
-      - uses: actions/upload-artifact@v5
+      - uses: actions/upload-artifact@v7
         if: always()
         with:
           name: plugin-inspector-reports

package/src/inspector.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { execFile } from "node:child_process";
 import { readdir, readFile } from "node:fs/promises";
+import * as nodeModule from "node:module";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { promisify } from "node:util";
@@ -9,6 +10,7 @@ import { captureApiOptionsForPlugin } from "./capture-config.js";
 import { fixtureCheckoutPath, fixtureSourceRoot } from "./config.js";
 import { buildCompatibilityFixtureReport } from "./fixture-summary.js";
 import { readOpenClawTargetSurface } from "./openclaw-target.js";
+import { prepareOpenClawTarget, resolveOpenClawTargetVersion } from "./openclaw-version.js";
 import { buildCompatibilityReport, buildReport } from "./report.js";
 import { inspectSdkDeprecations } from "./sdk-deprecation-rules.js";
 
@@ -26,11 +28,13 @@ export async function inspectCompatibilityFixtureSet(config, options = {}) {
   const { inspections, failures } = await inspectConfiguredFixtures(config, options);
   const targetOpenClaw =
     options.targetOpenClaw ??
-    (await readOpenClawTargetSurface({
-      configuredPath: options.openclawPath,
-      manifest: config,
-      rootDir: config.rootDir,
-    }));
+    (options.openclawVersion
+      ? await prepareOpenClawTarget(await resolveOpenClawTargetVersion(options.openclawVersion, options), options)
+      : await readOpenClawTargetSurface({
+          configuredPath: options.openclawPath,
+          manifest: config,
+          rootDir: config.rootDir,
+        }));
 
   return buildCompatibilityReport({
     config,
@@ -165,12 +169,7 @@ export function inspectSourceText(text, filePath = "source.js") {
     ...collectDetailedMatches(searchableText, /\b(createChatChannelPlugin)\s*\(/g, filePath, "name"),
     ...collectDetailedMatches(searchableText, /\b(definePluginEntry)\s*\(/g, filePath, "name"),
   ];
-  const sdkImports = collectDetailedMatches(
-    searchableText,
-    /(?:from\s*["'`]|import\(\s*["'`])([^"'`]*openclaw\/plugin-sdk[^"'`]*)/g,
-    filePath,
-    "specifier",
-  );
+  const sdkImports = collectSdkImports(searchableText, filePath);
   const sdkDeprecations = inspectSdkDeprecations(searchableText, filePath);
 
   return {
@@ -385,6 +384,165 @@ function collectDetailedMatches(text, regex, filePath, key) {
   return details;
 }
 
+function collectSdkImports(text, filePath) {
+  const details = [];
+  for (const candidate of text.matchAll(/(?:^|;)[\t ]*(import|export)\b/gm)) {
+    const keyword = candidate[1];
+    const keywordIndex = (candidate.index ?? 0) + candidate[0].lastIndexOf(keyword);
+    const declaration = parseStaticModuleDeclaration(text, keywordIndex, keyword);
+    if (!declaration?.specifier.includes("openclaw/plugin-sdk")) continue;
+    if (isTypeOnlyStaticImportClause(declaration.clause)) continue;
+    const line = lineForOffset(text, keywordIndex);
+    details.push({
+      specifier: declaration.specifier,
+      file: filePath,
+      line,
+      ref: `${filePath}:${line}`,
+    });
+  }
+
+  const dynamicMatches = [...text.matchAll(/\bimport\(\s*["'`]([^"'`]*openclaw\/plugin-sdk[^"'`]*)/g)];
+  const runtimeDynamicImports = runtimeDynamicImportIndexes(text, dynamicMatches);
+  for (const [index, match] of dynamicMatches.entries()) {
+    if (!runtimeDynamicImports.has(index)) continue;
+    const line = lineForOffset(text, match.index ?? 0);
+    details.push({
+      specifier: match[1],
+      file: filePath,
+      line,
+      ref: `${filePath}:${line}`,
+    });
+  }
+  return details.sort((left, right) => left.line - right.line || left.specifier.localeCompare(right.specifier));
+}
+
+function parseStaticModuleDeclaration(text, keywordIndex, keyword) {
+  const clauseStart = keywordIndex + keyword.length;
+  let cursor = skipWhitespace(text, clauseStart);
+  if (text[cursor] === "(") return null;
+  if (keyword === "export" && text[cursor] !== "{" && text[cursor] !== "*" && !hasWordAt(text, cursor, "type")) {
+    return null;
+  }
+
+  let braceDepth = 0;
+  while (cursor < text.length) {
+    const char = text[cursor];
+    if (char === '"' || char === "'" || char === "`") {
+      cursor = skipQuotedText(text, cursor, char);
+      continue;
+    }
+    if (char === "{") braceDepth += 1;
+    if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+    if (char === ";" && braceDepth === 0) return null;
+    if (braceDepth === 0 && hasWordAt(text, cursor, "from")) {
+      const clause = text.slice(clauseStart, cursor).trim();
+      cursor = skipWhitespace(text, cursor + "from".length);
+      const quote = text[cursor];
+      if (quote !== '"' && quote !== "'" && quote !== "`") return null;
+      const specifierStart = cursor + 1;
+      const specifierEnd = skipQuotedText(text, cursor, quote) - 1;
+      return { clause, specifier: text.slice(specifierStart, specifierEnd) };
+    }
+    cursor += 1;
+  }
+  return null;
+}
+
+function skipWhitespace(text, index) {
+  while (index < text.length && /\s/.test(text[index])) index += 1;
+  return index;
+}
+
+function hasWordAt(text, index, word) {
+  return (
+    text.startsWith(word, index) &&
+    !/[A-Za-z0-9_$]/.test(text[index - 1] ?? "") &&
+    !/[A-Za-z0-9_$]/.test(text[index + word.length] ?? "")
+  );
+}
+
+function skipQuotedText(text, quoteIndex, quote) {
+  let cursor = quoteIndex + 1;
+  while (cursor < text.length) {
+    if (text[cursor] === "\\") {
+      cursor += 2;
+      continue;
+    }
+    cursor += 1;
+    if (text[cursor - 1] === quote) break;
+  }
+  return cursor;
+}
+
+function runtimeDynamicImportIndexes(text, matches) {
+  if (matches.length === 0) return new Set();
+  const markedImports = matches.map((match, index) => {
+    const specifier = match[1];
+    const specifierStart = (match.index ?? 0) + match[0].indexOf(specifier);
+    return {
+      index,
+      specifierStart,
+      specifierEnd: specifierStart + specifier.length,
+      marker: `${specifier}/__plugin_inspector_runtime_import_${index}__`,
+    };
+  });
+  let markedText = text;
+  for (const markedImport of markedImports.toReversed()) {
+    markedText =
+      markedText.slice(0, markedImport.specifierStart) +
+      markedImport.marker +
+      markedText.slice(markedImport.specifierEnd);
+  }
+
+  try {
+    const runtimeText = eraseTypeScript(markedText);
+    if (runtimeText === null) {
+      return new Set(markedImports.map((markedImport) => markedImport.index));
+    }
+    return new Set(
+      markedImports.filter((markedImport) => runtimeText.includes(markedImport.marker)).map((markedImport) => markedImport.index),
+    );
+  } catch {
+    return new Set(markedImports.map((markedImport) => markedImport.index));
+  }
+}
+
+function eraseTypeScript(text) {
+  if (typeof nodeModule.stripTypeScriptTypes === "function") {
+    return nodeModule.stripTypeScriptTypes(text, { mode: "transform" });
+  }
+  if (typeof globalThis.Bun?.Transpiler === "function") {
+    const transpiler = new globalThis.Bun.Transpiler({ loader: "ts", target: "bun" });
+    return transpiler.transformSync(text);
+  }
+  return null;
+}
+
+function isTypeOnlyStaticImportClause(clause) {
+  clause = clause.trim();
+  if (/^type\b/.test(clause)) {
+    const typeOnlyClause = clause.slice("type".length).trimStart();
+    return typeOnlyClause.length > 0 && !typeOnlyClause.startsWith(",");
+  }
+  if (!clause.startsWith("{") || !clause.endsWith("}")) {
+    return false;
+  }
+
+  const namedImports = clause
+    .slice(1, -1)
+    .split(",")
+    .map((specifier) => specifier.trim())
+    .filter(Boolean);
+  return namedImports.length > 0 && namedImports.every(isTypeOnlyNamedImport);
+}
+
+function isTypeOnlyNamedImport(specifier) {
+  const typeModifier = /^type\b/.exec(specifier);
+  if (!typeModifier) return false;
+  const importedName = specifier.slice(typeModifier[0].length).trimStart();
+  return importedName.length > 0 && !/^as\b/.test(importedName);
+}
+
 async function readManifestContracts(config, checkoutPath, sourceRoot) {
   const manifests = new Set(
     [path.join(sourceRoot, "openclaw.plugin.json"), path.join(checkoutPath, "openclaw.plugin.json")].filter(
@@ -436,6 +594,7 @@ async function readPackageMetadata(config, checkoutPath, sourceRoot) {
       collectEntrypoint(entrypoints, entrypointFiles, packageDir, packageJson.openclaw?.entry);
       collectEntrypoint(entrypoints, entrypointFiles, packageDir, packageJson.openclaw?.entrypoint);
       collectEntrypoint(entrypoints, entrypointFiles, packageDir, packageJson.openclaw?.setupEntry);
+      collectEntrypoint(entrypoints, entrypointFiles, packageDir, packageJson.openclaw?.runtimeSetupEntry);
       collectEntrypoint(entrypoints, entrypointFiles, packageDir, packageJson.exports?.["."]?.import);
       collectEntrypoint(entrypoints, entrypointFiles, packageDir, packageJson.exports?.["."]?.default);
       collectEntrypoints(entrypoints, entrypointFiles, packageDir, packageJson.openclaw?.extensions);

package/src/issues.js

@@ -518,7 +518,10 @@ export function buildIssues({ breakages = [], warnings = [], suggestions = [], t
       runtimeCoverage: finding.runtimeCoverage ?? null,
       ...(finding.authorRemediation
         ? {
-            authorRemediation: withAuthorRemediationDocs(finding.code, finding.authorRemediation),
+            authorRemediation:
+              finding.authorRemediationDocs === false
+                ? finding.authorRemediation
+                : withAuthorRemediationDocs(finding.code, finding.authorRemediation),
           }
         : {}),
     }));
@@ -583,10 +586,6 @@ export function classifyIssueFinding(finding, targetOpenClaw, metadata = {}) {
   };
 }
 
-export function isInspectorGapFinding(finding, targetOpenClaw) {
-  return issueMetadata(finding, targetOpenClaw).issueClass === "inspector-gap";
-}
-
 export function isAuthorFacingFinding(finding, targetOpenClaw) {
   return Boolean(issueMetadata(finding, targetOpenClaw).authorRemediation);
 }