@openclaw/plugin-inspector 0.3.9 → 0.3.11

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## Unreleased
 
+## 0.3.11 - 2026-05-26
+
+### Fixed
+
+- Classify the latest generated kitchen-sink registrars for meeting notes, node CLI features, hosted media, model catalogs, embedding providers, and session actions.
+- Stop classifying package source entrypoints as missing when the published package provides built runtime entrypoints, and collapse SDK alias findings into a single compat-gap row.
+- Treat compat-gap issues as reconciled contract coverage for their own compatibility record.
+- Count passed synthetic hook probes as runtime coverage so conversation-access and `before_tool_call` inspector gaps close when probe artifacts prove them.
+- Keep mock-SDK synthetic probes in-process so retained hook and registration handlers remain callable, and harden dynamic root SDK mock exports.
+- Synthesize nested manifest config samples for optional object settings with required inner shape.
+- Populate message and agent lifecycle synthetic hook payloads with the fields telemetry plugins commonly read.
+- Resolve plugin manifests from parent directories when runtime capture starts from built `dist` entrypoints.
+- Capture CLIs no longer treat `--output`, `--plugin-root`, or `--sdk` flag values as the positional entrypoint. Thanks @KrasimirKralev.
+- Mock-SDK TypeScript capture now falls back to Node's strip-only parser on Node 26.
+
+## 0.3.10 - 2026-05-03
+
+### Fixed
+
+- Accept valid mocked capture output when plugin code leaves `process.exitCode` dirty.
+
 ## 0.3.9 - 2026-05-03
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/plugin-inspector",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "private": false,
   "description": "Offline compatibility inspector for OpenClaw plugins.",
   "type": "module",
@@ -56,7 +56,13 @@
     "release:readiness": "npm run release:local && npm run release:crabpot",
     "release:local": "npm run check",
     "release:notes": "node scripts/release-notes.mjs --unreleased",
-    "test": "node --test test/*.test.js"
+    "test": "node --test test/*.test.js",
+    "check:changed": "npm run check",
+    "test:changed": "npm test",
+    "crabbox:hydrate": "crabbox actions hydrate",
+    "crabbox:run": "crabbox run",
+    "crabbox:stop": "crabbox stop",
+    "crabbox:warmup": "crabbox warmup"
   },
   "keywords": [
     "openclaw",

package/src/advanced.js

@@ -194,6 +194,7 @@ export {
   writeRuntimeCaptureReport,
 } from "./runtime-capture-report.js";
 export { createMockSdkPackage } from "./sdk-mock.js";
+export { runEntrypointSyntheticProbes } from "./synthetic-entrypoint.js";
 export {
   buildSyntheticProbePlan,
   defaultSyntheticHookContexts,

package/src/capture-cli.js

@@ -11,7 +11,7 @@ try {
 }
 
 async function run(commandArgs) {
-  const entrypoint = commandArgs.find((arg) => !arg.startsWith("-"));
+  const entrypoint = findEntrypoint(commandArgs);
   const outputPath = readFlag(commandArgs, "--output");
   const pluginRoot = readFlag(commandArgs, "--plugin-root");
   const mockSdk = readMockSdkFlag(commandArgs) ?? true;
@@ -40,6 +40,17 @@ function readFlag(commandArgs, name) {
   return commandArgs[index + 1] ?? null;
 }
 
+function findEntrypoint(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 readMockSdkFlag(commandArgs) {
   const sdk = readFlag(commandArgs, "--sdk");
   if (sdk === "mock") {

package/src/capture-config.js

@@ -17,7 +17,10 @@ export async function captureApiOptionsForPlugin(apiOptions = {}, options = {})
 }
 
 async function readSamplePluginConfig(pluginRoot) {
-  const manifestPath = path.join(pluginRoot, "openclaw.plugin.json");
+  const manifestPath = await findNearestManifestPath(pluginRoot);
+  if (!manifestPath) {
+    return undefined;
+  }
   let manifest;
   try {
     manifest = JSON.parse(await readFile(manifestPath, "utf8"));
@@ -29,6 +32,23 @@ async function readSamplePluginConfig(pluginRoot) {
   return isPlainObject(sample) && Object.keys(sample).length > 0 ? sample : undefined;
 }
 
+async function findNearestManifestPath(pluginRoot) {
+  let current = path.resolve(pluginRoot);
+  while (true) {
+    const manifestPath = path.join(current, "openclaw.plugin.json");
+    try {
+      await readFile(manifestPath, "utf8");
+      return manifestPath;
+    } catch {}
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
 function sampleJsonSchema(schema, context = {}) {
   if (!isPlainObject(schema)) {
     return undefined;
@@ -83,6 +103,16 @@ function sampleObjectSchema(schema) {
     }
   }
 
+  if (!hasNonBooleanSample(output, properties)) {
+    const key = preferredNestedConfigKey(properties);
+    if (key) {
+      const value = sampleJsonSchema(properties[key], { key });
+      if (value !== undefined) {
+        output[key] = value;
+      }
+    }
+  }
+
   if (Object.keys(output).length === 0 && Number(schema.minProperties ?? 0) > 0) {
     const key = preferredSamplePropertyKey(properties);
     if (key) {
@@ -96,6 +126,24 @@ function sampleObjectSchema(schema) {
   return output;
 }
 
+function hasNonBooleanSample(output, properties) {
+  return Object.keys(output).some((key) => properties[key]?.type !== "boolean");
+}
+
+function preferredNestedConfigKey(properties) {
+  for (const key of ["embedding", "credentials", "auth", "provider", ...Object.keys(properties)]) {
+    const schema = properties[key];
+    if (!isPlainObject(schema)) {
+      continue;
+    }
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    if ((schema.type === "object" || schema.properties) && (Number(schema.minProperties ?? 0) > 0 || required.length > 0)) {
+      return key;
+    }
+  }
+  return null;
+}
+
 function preferredSamplePropertyKey(properties) {
   for (const key of ["provider", "model", "apiKey", "id", "name", ...Object.keys(properties)]) {
     if (Object.prototype.hasOwnProperty.call(properties, key)) {

package/src/cli.js

@@ -223,7 +223,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 +252,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) {

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,6 +14,7 @@ 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";
 
@@ -123,6 +124,7 @@ 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,
@@ -234,6 +236,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

@@ -234,10 +234,34 @@ export async function captureEntrypointWithMockSdk(entrypoint, options = {}) {
     );
     return JSON.parse(stdout);
   } catch (error) {
+    const captured = parseCaptureResultFromStdout(error?.stdout);
+    if (captured) {
+      return captured;
+    }
     throw classifyMockSdkCaptureError(error);
   }
 }
 
+function parseCaptureResultFromStdout(stdout) {
+  if (!stdout) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(stdout);
+    if (
+      parsed &&
+      typeof parsed === "object" &&
+      typeof parsed.status === "string" &&
+      Array.isArray(parsed.captured)
+    ) {
+      return parsed;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
 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];

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",
@@ -342,7 +349,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 +379,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 +408,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

@@ -225,6 +225,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 [];
 }
 

package/src/sdk-mock.js

@@ -377,6 +377,9 @@ function parseModuleImports(text) {
   ];
   for (const pattern of patterns) {
     for (const match of text.matchAll(pattern)) {
+      if (isTypeOnlyImportOrExport(match[0], match[1] ?? "")) {
+        continue;
+      }
       const specifier = match[2];
       if (specifier) {
         entries.push({ specifier, names: parseNamedImports(match[1] ?? "") });
@@ -389,6 +392,10 @@ function parseModuleImports(text) {
   return entries;
 }
 
+function isTypeOnlyImportOrExport(statement, clause) {
+  return /^\s*import\s+type\b/u.test(statement) || /^\s*export\s+type\b/u.test(statement) || /^\s*type\b/u.test(clause);
+}
+
 function parseNamedImports(clause) {
   const names = new Set();
   const named = /\{([\s\S]*?)\}/.exec(clause)?.[1] ?? clause;
@@ -459,11 +466,22 @@ export async function resolve(specifier, context, nextResolve) {
 export async function load(url, context, nextLoad) {
   if (url.startsWith("file:") && /\\.[cm]?ts$/u.test(fileURLToPath(url))) {
     const rawSource = await readFile(fileURLToPath(url), "utf8");
-    return { format: "module", source: stripTypeScriptTypes(rawSource, { mode: "transform" }), shortCircuit: true };
+    return { format: "module", source: stripPluginTypeScript(rawSource), shortCircuit: true };
   }
   return nextLoad(url, context);
 }
 
+function stripPluginTypeScript(source) {
+  try {
+    return stripTypeScriptTypes(source, { mode: "transform" });
+  } catch (error) {
+    if (error?.code !== "ERR_INVALID_ARG_VALUE") {
+      throw error;
+    }
+    return stripTypeScriptTypes(source, { mode: "strip" });
+  }
+}
+
 function moduleUrl(filePath) {
   return { url: pathToFileURL(filePath).href, shortCircuit: true };
 }
@@ -1665,11 +1683,53 @@ export const OPENAI_RESPONSES_STREAM_HOOKS = buildProviderStreamFamilyHooks("ope
 export const OPENROUTER_THINKING_STREAM_HOOKS = buildProviderStreamFamilyHooks("openrouter-thinking");
 export const TOOL_STREAM_DEFAULT_ON_HOOKS = buildProviderStreamFamilyHooks("tool-stream-default");
 export const pluginSdkMock = true;
+${dynamicExportNames.length > 0 ? mockValueRuntimeSource() : ""}
 ${dynamicExportNames.map(genericExportStatement).join("\n")}
 
 export default {
 ${[...exportNames].map((name) => `  ${name},`).join("\n")}
 };
+  `;
+}
+
+function mockValueRuntimeSource() {
+  return `function createMockValue(name) {
+  function fn(...args) {
+    if (name === "resolvePreferredOpenClawTmpDir") {
+      return process.env.TMPDIR || "/tmp";
+    }
+    if (name.startsWith("normalize")) {
+      return typeof args[0] === "string" ? args[0] : "";
+    }
+    if (name === "jsonResult") {
+      return { type: "json", value: args[0] };
+    }
+    if (name === "readStringParam") {
+      return typeof args[0] === "string" ? args[0] : "";
+    }
+    return createMockValue(name);
+  }
+  return new Proxy(fn, {
+    get(_target, property) {
+      if (property === "then") {
+        return undefined;
+      }
+      if (property === Symbol.toPrimitive) {
+        return () => name;
+      }
+      if (property === "toString") {
+        return () => name;
+      }
+      if (property === "valueOf") {
+        return () => name;
+      }
+      return createMockValue(\`\${name}.\${String(property)}\`);
+    },
+    construct() {
+      return createMockValue(name);
+    },
+  });
+}
 `;
 }
 

package/src/synthetic-entrypoint.js

@@ -0,0 +1,47 @@
+import { rmSync } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import { register } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { captureEntrypoint } from "./inspector.js";
+import { createMockSdkPackage } from "./sdk-mock.js";
+import { runCapturedSyntheticProbes } from "./synthetic-probes.js";
+
+export async function runEntrypointSyntheticProbes(entrypoint, options = {}) {
+  const capture = await captureEntrypointForSyntheticProbes(entrypoint, {
+    ...options,
+    apiOptions: {
+      ...(options.apiOptions ?? {}),
+      retainHandlers: true,
+    },
+  });
+  return runCapturedSyntheticProbes(capture, options);
+}
+
+async function captureEntrypointForSyntheticProbes(entrypoint, options) {
+  if (options.mockSdk !== true) {
+    return captureEntrypoint(entrypoint, options);
+  }
+
+  const cwd = options.cwd ?? process.cwd();
+  const resolvedEntrypoint = path.resolve(cwd, entrypoint);
+  const pluginRoot = path.resolve(cwd, options.pluginRoot ?? path.dirname(resolvedEntrypoint));
+  const workspace = await mkdtemp(path.join(os.tmpdir(), "plugin-inspector-synthetic-mock-sdk-"));
+  cleanupTempDirOnExit(workspace);
+  const { loaderPath } = await createMockSdkPackage(workspace, { pluginRoot });
+  register(pathToFileURL(loaderPath));
+
+  return captureEntrypoint(entrypoint, {
+    ...options,
+    cwd,
+    mockSdk: false,
+    pluginRoot,
+  });
+}
+
+function cleanupTempDirOnExit(dir) {
+  process.once("exit", () => {
+    rmSync(dir, { force: true, recursive: true });
+  });
+}

package/src/synthetic-probes-cli.js

@@ -1,12 +1,5 @@
 #!/usr/bin/env node
-import { rmSync } from "node:fs";
-import { mkdtemp } from "node:fs/promises";
-import { register } from "node:module";
-import os from "node:os";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { captureEntrypoint, runCapturedSyntheticProbes, writeArtifacts } from "./advanced.js";
-import { createMockSdkPackage } from "./sdk-mock.js";
+import { runEntrypointSyntheticProbes, writeArtifacts } from "./advanced.js";
 
 const args = process.argv.slice(2);
 
@@ -33,12 +26,10 @@ async function run(commandArgs) {
     throw new Error("synthetic probes import plugin code; rerun with PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 in an isolated workspace");
   }
 
-  const capture = await captureForSyntheticProbes(entrypoint, {
+  const results = await runEntrypointSyntheticProbes(entrypoint, {
     mockSdk,
     pluginRoot,
     apiOptions: { retainHandlers: true },
-  });
-  const results = await runCapturedSyntheticProbes(capture, {
     includeLifecycle,
     includeChannelRuntime,
     includeProviderCapabilities,
@@ -52,30 +43,6 @@ async function run(commandArgs) {
   }
 }
 
-async function captureForSyntheticProbes(entrypoint, options) {
-  if (options.mockSdk !== true) {
-    return captureEntrypoint(entrypoint, options);
-  }
-
-  const resolvedEntrypoint = path.resolve(process.cwd(), entrypoint);
-  const pluginRoot = path.resolve(process.cwd(), options.pluginRoot ?? path.dirname(resolvedEntrypoint));
-  const workspace = await mkdtemp(path.join(os.tmpdir(), "plugin-inspector-synthetic-mock-sdk-"));
-  cleanupTempDirOnExit(workspace);
-  const { loaderPath } = await createMockSdkPackage(workspace, { pluginRoot });
-  register(pathToFileURL(loaderPath));
-  return captureEntrypoint(entrypoint, {
-    ...options,
-    mockSdk: false,
-    pluginRoot,
-  });
-}
-
-function cleanupTempDirOnExit(dir) {
-  process.once("exit", () => {
-    rmSync(dir, { force: true, recursive: true });
-  });
-}
-
 function readFlag(commandArgs, name) {
   const index = commandArgs.indexOf(name);
   if (index === -1) {

package/src/synthetic-probes.js

@@ -89,6 +89,11 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "detached task runtimes are captured as registration metadata before async task execution",
   },
+  registerEmbeddingProvider: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "embedding providers are captured as registration metadata before provider runtime execution",
+  },
   registerGatewayDiscoveryService: {
     mode: "metadata-only",
     callableProperties: [],
@@ -116,11 +121,21 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "image generation providers are captured as registration metadata before provider runtime execution",
   },
+  registerHostedMediaResolver: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "hosted media resolvers are captured as registration metadata before media URL resolution",
+  },
   registerMemoryPromptSection: {
     mode: "metadata-only",
     callableProperties: [],
     reason: "memory prompt section renderers are captured as metadata before prompt-runtime execution",
   },
+  registerMeetingNotesSourceProvider: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "meeting notes source providers are captured as registration metadata before source discovery",
+  },
   registerMediaUnderstandingProvider: {
     mode: "metadata-only",
     callableProperties: [],
@@ -161,11 +176,21 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "migration providers are captured as registration metadata before migration runtime execution",
   },
+  registerModelCatalogProvider: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "model catalog providers are captured as registration metadata before catalog runtime execution",
+  },
   registerMusicGenerationProvider: {
     mode: "metadata-only",
     callableProperties: [],
     reason: "music generation providers are captured as registration metadata before provider runtime execution",
   },
+  registerNodeCliFeature: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "node CLI features are captured as registration metadata before host CLI integration",
+  },
   registerNodeHostCommand: {
     mode: "metadata-only",
     callableProperties: [],
@@ -206,6 +231,11 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "security audit collectors are captured as registration metadata before filesystem or policy scans",
   },
+  registerSessionAction: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "session actions are captured as registration metadata before session runtime execution",
+  },
   registerService: {
     mode: "lifecycle-opt-in",
     callableProperties: ["start", "stop", "dispose"],
@@ -267,12 +297,17 @@ export const defaultSyntheticHookEvents = {
     runId: "run-fixture",
     agentId: "agent-fixture",
     conversationId: "conversation-fixture",
+    success: true,
+    durationMs: 1,
+    error: null,
+    messages: [{ role: "assistant", content: "[redacted fixture output]" }],
     status: "completed",
     transcript: [{ role: "assistant", content: "[redacted fixture output]" }],
   },
   before_agent_start: {
     agentId: "agent-fixture",
     runId: "run-fixture",
+    prompt: "fixture prompt",
     config: { source: "plugin-inspector" },
   },
   before_prompt_build: {
@@ -303,6 +338,18 @@ export const defaultSyntheticHookEvents = {
     model: "gpt-5.4",
     output: { role: "assistant", content: "[redacted fixture output]" },
   },
+  message_received: {
+    from: "fixture-user",
+    content: "fixture inbound message",
+    messageId: "message-fixture",
+  },
+  message_sent: {
+    to: "fixture-user",
+    content: "fixture outbound message",
+    success: true,
+    error: null,
+    messageId: "message-fixture-reply",
+  },
   subagent_delivery_target: {
     childSessionKey: "child-session",
     agentId: "agent-child",
@@ -361,6 +408,18 @@ export const defaultSyntheticHookContexts = {
     agentId: "agent-fixture",
     sessionId: "session-fixture",
   },
+  message_received: {
+    runId: "run-fixture",
+    agentId: "agent-fixture",
+    sessionId: "session-fixture",
+    channelId: "fixture-channel",
+  },
+  message_sent: {
+    runId: "run-fixture",
+    agentId: "agent-fixture",
+    sessionId: "session-fixture",
+    channelId: "fixture-channel",
+  },
   subagent_delivery_target: {
     runId: "run-fixture",
     parentAgentId: "agent-parent",