@openclaw/plugin-inspector 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.3.0 - 2026-04-27
+
+### Added
+
+- Add `--allow-execute` as a cross-platform runtime capture opt-in flag.
+- Add `plugin-inspector init --dry-run` for setup previews.
+- Add `plugin-inspector init --json` for machine-readable setup summaries.
+- Add `plugin-inspector init --scripts` for `plugin:check` and `plugin:ci` package scripts.
+- Add public fixture-set report helpers and synthetic probe suite helpers for Crabpot and downstream compatibility suites.
+- Add a Crabpot follow-through release checklist for source refs, package pins, and smoke commands.
+
+### Changed
+
+- Make generated runtime CI commands use `--allow-execute` instead of shell-specific inline environment syntax.
+- Make `plugin-inspector init --ci` detect `packageManager` and common lockfiles before generating CI install/run commands.
+- Make `plugin-inspector init` output repo-relative file paths and preflight generated files before writing.
+- Make `plugin-inspector init` infer `sourceRoot: "src"` from package export maps like `"./src/index.js"`.
+- Improve CLI failure summaries with report artifact paths and top blocking findings.
+- Harden mock SDK capture by keeping generated loader fixtures available until subprocess exit.
+
 ## 0.2.0 - 2026-04-27
 
 ### Added

package/README.md

@@ -24,6 +24,11 @@ Add a local config and GitHub Actions workflow:
 npx @openclaw/plugin-inspector init --ci
 ```
 
+`init --ci` detects `packageManager` and common lockfiles. Pass
+`--package-manager pnpm`, `npm`, `yarn`, or `bun` when you want to override it.
+Add `--scripts` to write `plugin:check` and `plugin:ci` package scripts.
+Use `--dry-run` to preview the files first.
+
 Or install it as a dev dependency:
 
 ```bash
@@ -40,6 +45,8 @@ npx @openclaw/plugin-inspector ci --no-openclaw
 npx @openclaw/plugin-inspector config
 npx @openclaw/plugin-inspector check --plugin-root ./plugins/weather
 npx @openclaw/plugin-inspector init --ci --package-manager pnpm
+npx @openclaw/plugin-inspector init --ci --scripts --dry-run
+npx @openclaw/plugin-inspector init --ci --scripts --dry-run --json
 ```
 
 `check` and `inspect` read the current directory as one plugin unless
@@ -132,7 +139,8 @@ For a single plugin package, the same config can live in `package.json`:
 `.github/workflows/plugin-inspector.yml`. Copy-ready examples also live in
 `examples/plugin-inspector.config.json` and
 `examples/package-json-plugin-inspector.json` and
-`examples/github-actions-plugin-inspector.yml`.
+`examples/github-actions-plugin-inspector.yml`. SARIF/JUnit CI consumption
+examples live alongside them.
 
 ## Runtime Capture
 
@@ -141,9 +149,13 @@ the registrations made during `register(api)`. It is opt-in because it executes
 plugin code:
 
 ```bash
-PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 npx @openclaw/plugin-inspector check --runtime --mock-sdk
+npx @openclaw/plugin-inspector check --runtime --mock-sdk --allow-execute
 ```
 
+`--allow-execute` is the explicit guard for modes that import plugin code. The
+older `PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1` environment guard still works for
+custom harnesses.
+
 By default, runtime capture uses a generated mock for `openclaw/plugin-sdk` and
 common external packages so plugin code can load in clean CI without OpenClaw
 installed. Use `--real-sdk` only when the plugin workspace already has real SDK
@@ -157,7 +169,7 @@ Runtime capture writes:
 You can also capture one entrypoint directly:
 
 ```bash
-PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 plugin-inspector capture ./dist/index.js --mock-sdk
+plugin-inspector capture ./dist/index.js --mock-sdk --allow-execute
 ```
 
 ## CI
@@ -168,7 +180,7 @@ Minimal package scripts:
 {
   "scripts": {
     "plugin:check": "plugin-inspector inspect --no-openclaw",
-    "plugin:ci": "PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 plugin-inspector ci --no-openclaw --runtime --mock-sdk"
+    "plugin:ci": "plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute"
   }
 }
 ```
@@ -193,7 +205,7 @@ jobs:
           node-version: 24
           cache: npm
       - run: npm ci
-      - run: PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 npx @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk
+      - run: npx @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute
       - uses: actions/upload-artifact@v5
         if: always()
         with:
@@ -204,6 +216,15 @@ jobs:
 `ci` writes the normal report, CI summary, SARIF, and JUnit files by default.
 Pass `--no-sarif` or `--no-junit` only if your CI surface cannot consume them.
 
+For GitHub code scanning, use
+`examples/github-actions-code-scanning.yml`; it uploads
+`reports/plugin-inspector.sarif` through CodeQL's SARIF upload action.
+
+For CI test-summary UIs, point JUnit ingestion at
+`reports/plugin-inspector.junit.xml`. Copy-ready GitLab and CircleCI examples
+live in `examples/gitlab-ci-plugin-inspector.yml` and
+`examples/circleci-plugin-inspector.yml`.
+
 ## Fixture Suites
 
 Fixture-set configs are still supported for crabpot-style compatibility suites:

package/examples/circleci-plugin-inspector.yml

@@ -0,0 +1,19 @@
+version: 2.1
+
+jobs:
+  plugin-inspector:
+    docker:
+      - image: cimg/node:24.0
+    steps:
+      - checkout
+      - run: npm ci
+      - run: npx @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute
+      - store_test_results:
+          path: reports
+      - store_artifacts:
+          path: reports
+
+workflows:
+  plugin-inspector:
+    jobs:
+      - plugin-inspector

package/examples/github-actions-code-scanning.yml

@@ -0,0 +1,31 @@
+name: plugin-inspector
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+  security-events: write
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: npm
+      - run: npm ci
+      - run: npx @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute
+      - uses: github/codeql-action/upload-sarif@v3
+        if: always()
+        with:
+          sarif_file: reports/plugin-inspector.sarif
+      - uses: actions/upload-artifact@v5
+        if: always()
+        with:
+          name: plugin-inspector-reports
+          path: reports/plugin-inspector-*

package/examples/github-actions-plugin-inspector.yml

@@ -15,7 +15,7 @@ jobs:
           node-version: 24
           cache: npm
       - run: npm ci
-      - run: PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 npx @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk
+      - run: npx @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute
       - uses: actions/upload-artifact@v5
         if: always()
         with:

package/examples/gitlab-ci-plugin-inspector.yml

@@ -0,0 +1,11 @@
+plugin_inspector:
+  image: node:24
+  script:
+    - npm ci
+    - npx @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute
+  artifacts:
+    when: always
+    paths:
+      - reports/plugin-inspector-*
+    reports:
+      junit: reports/plugin-inspector.junit.xml

package/examples/package-json-plugin-inspector.json

@@ -1,7 +1,7 @@
 {
   "scripts": {
     "plugin:check": "plugin-inspector inspect --no-openclaw",
-    "plugin:ci": "PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 plugin-inspector ci --no-openclaw --runtime --mock-sdk"
+    "plugin:ci": "plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute"
   },
   "pluginInspector": {
     "version": 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/plugin-inspector",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": false,
   "description": "Offline compatibility inspector for OpenClaw plugins.",
   "type": "module",
@@ -36,6 +36,8 @@
     "./ref-diff": "./src/ref-diff.js",
     "./runtime-capture-report": "./src/runtime-capture-report.js",
     "./runtime-profile": "./src/runtime-profile.js",
+    "./synthetic-probe-suite": "./src/synthetic-probe-suite.js",
+    "./synthetic-probes": "./src/synthetic-probes.js",
     "./workspace-plan": "./src/workspace-plan.js"
   },
   "files": [
@@ -47,6 +49,7 @@
   ],
   "scripts": {
     "check": "npm test && npm pack --dry-run",
+    "release:crabpot": "node scripts/check-crabpot-followthrough.mjs",
     "release:local": "npm run check",
     "test": "node --test test/*.test.js"
   },

package/src/advanced.js

@@ -136,8 +136,10 @@ export {
 } from "./config.js";
 export {
   buildPluginInspectorConfig,
+  defaultInitPackageScripts,
   defaultInitConfigPath,
   defaultInitWorkflowPath,
+  detectPackageManager,
   renderGithubActionsWorkflow,
   writePluginInspectorInit,
 } from "./init.js";
@@ -196,6 +198,7 @@ export {
   validateSyntheticProbePlan,
   writeSyntheticProbePlan,
 } from "./synthetic-probes.js";
+export { buildSyntheticProbePlanFromReport } from "./synthetic-probe-suite.js";
 export {
   buildWorkspacePlan,
   defaultWorkspacePlanOptions,
@@ -203,3 +206,10 @@ export {
   validateWorkspacePlan,
   writeWorkspacePlan,
 } from "./workspace-plan.js";
+export {
+  inspectCompatibilityFixtureSetConfig,
+  renderFixtureSetIssuesReport,
+  renderFixtureSetMarkdownReport,
+  runFixtureSetReport,
+  writeFixtureSetReports,
+} from "./api.js";

package/src/api.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { createCaptureApi } from "./capture-api.js";
 import { loadInspectorConfig, loadPluginRootConfig } from "./config.js";
+import { renderCompatibilityIssuesReport, renderCompatibilityMarkdownReport } from "./compatibility-report.js";
 import { writePluginInspectorInit } from "./init.js";
 import { captureEntrypoint } from "./inspector.js";
 import { renderTextSummary, writeCompatibilityReport } from "./report.js";
@@ -35,6 +36,15 @@ export async function inspectFixtureSetConfig(options = {}) {
   return inspectFixtureSet(config, { generatedAt: options.generatedAt });
 }
 
+export async function inspectCompatibilityFixtureSetConfig(options = {}) {
+  const config = await loadFixtureSetConfig(options);
+  return inspectCompatibilityFixtureSet(config, {
+    generatedAt: options.generatedAt,
+    openclawPath: options.openclawPath,
+    targetOpenClaw: options.targetOpenClaw,
+  });
+}
+
 export async function writePluginReports(report, options = {}) {
   return writeCompatibilityReport(report, {
     basename: options.basename,
@@ -45,6 +55,38 @@ export async function writePluginReports(report, options = {}) {
   });
 }
 
+export async function writeFixtureSetReports(report, options = {}) {
+  return writeCompatibilityReport(report, {
+    basename: options.basename,
+    check: options.check,
+    cwd: options.cwd,
+    formatEvidence: options.formatEvidence,
+    issuesBasename: options.issuesBasename,
+    issuesPath: options.issuesPath,
+    issuesTitle: options.issuesTitle,
+    jsonPath: options.jsonPath,
+    markdownPath: options.markdownPath,
+    markdownTitle: options.markdownTitle,
+    outDir: options.outDir,
+    severityLabels: options.severityLabels,
+    title: options.title,
+  });
+}
+
+export function renderFixtureSetMarkdownReport(report, options = {}) {
+  return renderCompatibilityMarkdownReport(report, options);
+}
+
+export function renderFixtureSetIssuesReport(report, options = {}) {
+  return renderCompatibilityIssuesReport(report, options);
+}
+
+export async function runFixtureSetReport(options = {}) {
+  const report = await inspectCompatibilityFixtureSetConfig(options);
+  const paths = options.write === false ? null : await writeFixtureSetReports(report, options);
+  return { report, paths };
+}
+
 export async function runPluginCheck(options = {}) {
   const outDir = options.outDir ?? "reports";
   const config = await loadPluginConfig(options);
@@ -55,8 +97,8 @@ export async function runPluginCheck(options = {}) {
   const mockSdk = options.mockSdk ?? config.capture?.mockSdk ?? true;
 
   if (capture === true) {
-    if (process.env.PLUGIN_INSPECTOR_EXECUTE_ISOLATED !== "1") {
-      throw new Error("runtime capture imports plugin code; rerun with PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 in an isolated workspace");
+    if (!executionAllowed(options)) {
+      throw new Error("runtime capture imports plugin code; rerun with PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 or --allow-execute in an isolated workspace");
     }
     const runtimeCapture = await buildRuntimeCaptureReport({
       mockSdk,
@@ -90,3 +132,17 @@ export async function setupPluginInspector(options = {}) {
 }
 
 export { createCaptureApi, renderTextSummary, writeCiOutputArtifacts };
+
+function executionAllowed(options) {
+  return options.allowExecution === true || process.env.PLUGIN_INSPECTOR_EXECUTE_ISOLATED === "1";
+}
+
+async function loadFixtureSetConfig(options) {
+  if (options.config) {
+    return {
+      ...options.config,
+      rootDir: options.config.rootDir ?? options.rootDir ?? options.cwd ?? process.cwd(),
+    };
+  }
+  return loadInspectorConfig(options.configPath, { cwd: options.cwd ?? options.rootDir });
+}

package/src/capture-api.js

@@ -1,6 +1,6 @@
 export const defaultCaptureApiRegistrarProfiles = {
   registerChannel: {
-    returnValue: ({ args }) => registrationObject(args, { id: "channel" }),
+    returnValue: ({ args }) => channelRegistrationObject(args),
   },
   registerCli: {
     returnValue: ({ args }) => registrationObject(args, { name: "cli" }),
@@ -12,7 +12,7 @@ export const defaultCaptureApiRegistrarProfiles = {
     returnValue: ({ args }) => registrationObject(args, { id: "context-engine" }),
   },
   registerGatewayMethod: {
-    returnValue: ({ args }) => registrationObject(args, { name: "gateway.method" }),
+    returnValue: ({ args }) => gatewayMethodRegistrationObject(args),
   },
   registerHook: {
     returnValue: ({ api }) => api,
@@ -37,9 +37,10 @@ export const defaultCaptureApiRegistrarProfiles = {
   },
   registerService: {
     returnValue: ({ args }) => ({
-      ...registrationObject(args, { name: "service" }),
+      ...registrationObject(args, { id: "service", name: "service" }),
       start: async () => undefined,
       stop: async () => undefined,
+      dispose: async () => undefined,
     }),
   },
   registerSpeechProvider: {
@@ -125,6 +126,7 @@ export function createCaptureApi(options = {}) {
 
 export function createCaptureContext(options = {}) {
   return {
+    registrationMode: options.registrationMode ?? "full",
     config: options.config ?? {},
     logger: options.logger ?? console,
     pluginConfig: options.pluginConfig ?? {},
@@ -142,6 +144,12 @@ export function createCaptureContext(options = {}) {
     },
     gateway: options.gateway ?? {
       baseUrl: "http://127.0.0.1:0",
+      async call(method, params) {
+        return { ok: true, method, params };
+      },
+      respond(ok, result, error) {
+        return { ok, result, ...(error ? { error } : {}) };
+      },
       registerRoute(route) {
         return {
           ...route,
@@ -242,6 +250,36 @@ function registrationObject(args, defaults) {
   return withCallableDefaults({ ...defaults }, callable);
 }
 
+function channelRegistrationObject(args) {
+  const first = args[0];
+  const registration = registrationObject(args, { id: "channel" });
+  if (first?.plugin && typeof first.plugin === "object") {
+    return {
+      ...registration,
+      id: objectId(first.plugin) ?? registration.id,
+      plugin: first.plugin,
+    };
+  }
+  return registration;
+}
+
+function gatewayMethodRegistrationObject(args) {
+  const [method, handler, options] = args;
+  const registration = registrationObject(args, { name: "gateway.method" });
+  if (typeof method !== "string") {
+    return registration;
+  }
+  return {
+    ...registration,
+    name: method,
+    method,
+    handler: typeof handler === "function" ? handler : registration.handler,
+    run: typeof handler === "function" ? handler : registration.run,
+    execute: typeof handler === "function" ? handler : registration.execute,
+    scope: options?.scope ?? registration.scope,
+  };
+}
+
 function firstCallable(args) {
   return args.find((arg) => typeof arg === "function");
 }

package/src/cli.js

@@ -72,8 +72,17 @@ async function runCheck(commandArgs) {
   const json = commandArgs.includes("--json");
   const capture = readRuntimeFlag(commandArgs);
   const mockSdk = readMockSdkFlag(commandArgs);
+  const allowExecution = readAllowExecutionFlag(commandArgs);
   const ciOutputs = readCiOutputFlags(commandArgs);
-  const { report, paths } = await runPluginCheck({ configPath, pluginRoot, outDir, openclawPath, capture, mockSdk });
+  const { report, paths } = await runPluginCheck({
+    allowExecution,
+    capture,
+    configPath,
+    mockSdk,
+    openclawPath,
+    outDir,
+    pluginRoot,
+  });
   await writeCiOutputArtifacts(report, {
     ...ciOutputs,
     cwd: path.dirname(paths.jsonPath),
@@ -83,7 +92,7 @@ async function runCheck(commandArgs) {
   if (json) {
     console.log(JSON.stringify(report, null, 2));
   } else {
-    console.log(renderTextSummary(report));
+    console.log(renderTextSummary(report, { artifacts: paths }));
   }
 
   if (report.status !== "pass") {
@@ -95,19 +104,27 @@ 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 packageManager = readFlag(commandArgs, "--package-manager") ?? undefined;
   const result = await writePluginInspectorInit({
     pluginRoot,
     configPath,
     workflowPath,
     packageManager,
     ci: commandArgs.includes("--ci"),
+    dryRun: commandArgs.includes("--dry-run"),
+    scripts: commandArgs.includes("--scripts"),
     force: commandArgs.includes("--force"),
   });
 
+  if (commandArgs.includes("--json")) {
+    console.log(JSON.stringify(initCommandSummary(result), null, 2));
+    return;
+  }
+
   for (const filePath of result.written) {
-    console.log(`wrote ${filePath}`);
+    console.log(`${result.dryRun ? "would write" : "wrote"} ${path.relative(result.pluginRoot, filePath)}`);
   }
+  console.log(`package manager: ${result.packageManager}`);
 }
 
 async function runReport(command, commandArgs) {
@@ -128,7 +145,7 @@ async function runReport(command, commandArgs) {
   if (json) {
     console.log(JSON.stringify(report, null, 2));
   } else {
-    console.log(renderTextSummary(report));
+    console.log(renderTextSummary(report, { artifacts: paths }));
   }
 
   if (check && report.status !== "pass") {
@@ -144,8 +161,10 @@ async function runCi(commandArgs) {
   const json = commandArgs.includes("--json");
   const capture = readRuntimeFlag(commandArgs);
   const mockSdk = readMockSdkFlag(commandArgs);
+  const allowExecution = readAllowExecutionFlag(commandArgs);
   const ciOutputs = readCiOutputFlags(commandArgs, { defaultEnabled: true });
   const { report, reportDir } = await runCiCompatibilityReport({
+    allowExecution,
     capture,
     configPath,
     mockSdk,
@@ -184,7 +203,7 @@ async function runCi(commandArgs) {
   }
 }
 
-async function runCiCompatibilityReport({ capture, configPath, mockSdk, openclawPath, outDir, pluginRoot }) {
+async function runCiCompatibilityReport({ allowExecution, capture, configPath, mockSdk, openclawPath, outDir, pluginRoot }) {
   if (configPath) {
     const config = await loadInspectorConfig(configPath, { cwd: pluginRoot });
     const report = await inspectCompatibilityFixtureSet(config, { openclawPath });
@@ -195,7 +214,7 @@ async function runCiCompatibilityReport({ capture, configPath, mockSdk, openclaw
     };
   }
 
-  const { report } = await runPluginCheck({ pluginRoot, outDir, openclawPath, capture, mockSdk });
+  const { report } = await runPluginCheck({ allowExecution, capture, mockSdk, openclawPath, outDir, pluginRoot });
   return {
     report,
     reportDir: path.resolve(pluginRoot ?? process.cwd(), outDir),
@@ -207,11 +226,12 @@ async function runCapture(commandArgs) {
   const outputPath = readFlag(commandArgs, "--output");
   const pluginRoot = readFlag(commandArgs, "--plugin-root");
   const mockSdk = readMockSdkFlag(commandArgs) ?? commandArgs.includes("--mock-sdk");
+  const allowExecution = readAllowExecutionFlag(commandArgs);
   if (!entrypoint) {
     throw new Error("capture requires an entrypoint path");
   }
-  if (process.env.PLUGIN_INSPECTOR_EXECUTE_ISOLATED !== "1") {
-    throw new Error("capture imports plugin code; rerun with PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 in an isolated workspace");
+  if (!allowExecution && process.env.PLUGIN_INSPECTOR_EXECUTE_ISOLATED !== "1") {
+    throw new Error("capture imports plugin code; rerun with PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 or --allow-execute in an isolated workspace");
   }
 
   const result = await captureEntrypoint(entrypoint, { mockSdk, pluginRoot });
@@ -281,6 +301,10 @@ function readMockSdkFlag(commandArgs) {
   return undefined;
 }
 
+function readAllowExecutionFlag(commandArgs) {
+  return commandArgs.includes("--allow-execute");
+}
+
 function renderCiTextSummary(summary) {
   return [
     `Status: ${summary.status.toUpperCase()}`,
@@ -290,6 +314,15 @@ function renderCiTextSummary(summary) {
   ].join("\n");
 }
 
+function initCommandSummary(result) {
+  return {
+    dryRun: result.dryRun,
+    packageManager: result.packageManager,
+    pluginRoot: result.pluginRoot,
+    files: result.written.map((filePath) => path.relative(result.pluginRoot, filePath)),
+  };
+}
+
 function renderConfigTextSummary(config) {
   const fixture = config.fixtures[0];
   return [
@@ -308,16 +341,16 @@ function printHelp() {
 
 Usage:
   plugin-inspector
-  plugin-inspector check [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--json]
+  plugin-inspector check [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--allow-execute] [--json]
   plugin-inspector config [--plugin-root <path>] [--config <path>] [--json]
-  plugin-inspector init [--plugin-root <path>] [--config <path>] [--ci] [--package-manager npm|pnpm|yarn|bun] [--force]
+  plugin-inspector init [--plugin-root <path>] [--config <path>] [--ci] [--scripts] [--package-manager npm|pnpm|yarn|bun] [--dry-run] [--json] [--force]
   plugin-inspector report --config <path> [--out <dir>] [--check] [--json]
-  plugin-inspector inspect [--plugin-root <path>] [--config <path>] [--out <dir>] [--check] [--json] [--sarif [path]] [--junit [path]]
-  plugin-inspector ci [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--json] [--no-sarif] [--no-junit]
-  PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 plugin-inspector capture <entrypoint> [--mock-sdk|--real-sdk] [--plugin-root <path>] [--output <path>]
+  plugin-inspector inspect [--plugin-root <path>] [--config <path>] [--out <dir>] [--check] [--json] [--sarif [path]] [--junit [path]] [--allow-execute]
+  plugin-inspector ci [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--allow-execute] [--json] [--no-sarif] [--no-junit]
+  plugin-inspector capture <entrypoint> [--mock-sdk|--real-sdk] [--allow-execute] [--plugin-root <path>] [--output <path>]
 
 Default check runs from the current plugin root and writes reports/ unless --out is set.
 CI writes SARIF and JUnit artifacts by default; check/inspect can write them with --sarif and --junit.
-Runtime capture is opt-in because it imports plugin code; use --runtime with PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1.
+Runtime capture is opt-in because it imports plugin code; use --runtime with --allow-execute or PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1.
 `);
 }

package/src/index.js

@@ -1,12 +1,17 @@
 export {
   capturePluginEntrypoint,
   createCaptureApi,
+  inspectCompatibilityFixtureSetConfig,
   inspectFixtureSetConfig,
   inspectPluginRoot,
   loadPluginConfig,
+  renderFixtureSetIssuesReport,
+  renderFixtureSetMarkdownReport,
   renderTextSummary,
+  runFixtureSetReport,
   runPluginCheck,
   setupPluginInspector,
   writeCiOutputArtifacts,
+  writeFixtureSetReports,
   writePluginReports,
 } from "./api.js";

package/src/init.js

@@ -5,32 +5,66 @@ import { inferPluginSeams, packageId } from "./config.js";
 
 export const defaultInitConfigPath = "plugin-inspector.config.json";
 export const defaultInitWorkflowPath = ".github/workflows/plugin-inspector.yml";
+export const defaultInitPackageScripts = {
+  "plugin:check": "plugin-inspector inspect --no-openclaw",
+  "plugin:ci": "plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute",
+};
 
 export async function writePluginInspectorInit(options = {}) {
   const pluginRoot = path.resolve(options.pluginRoot ?? options.cwd ?? process.cwd());
   const configPath = path.resolve(pluginRoot, options.configPath ?? defaultInitConfigPath);
+  const workflowPath = options.ci === true ? path.resolve(pluginRoot, options.workflowPath ?? defaultInitWorkflowPath) : null;
+  const packageManager = options.packageManager ?? (await detectPackageManager(pluginRoot));
+  const dryRun = options.dryRun === true;
   const written = [];
 
-  if (existsSync(configPath) && options.force !== true) {
+  if (!dryRun && existsSync(configPath) && options.force !== true) {
     throw new Error(`${path.relative(pluginRoot, configPath)} already exists; pass --force to overwrite it`);
   }
+  if (!dryRun && workflowPath && existsSync(workflowPath) && options.force !== true) {
+    throw new Error(`${path.relative(pluginRoot, workflowPath)} already exists; pass --force to overwrite it`);
+  }
+  const packageJsonPath = path.join(pluginRoot, "package.json");
+  const packageJson = options.scripts === true ? await readJsonIfExists(packageJsonPath) : null;
+  if (options.scripts === true) {
+    if (!packageJson) {
+      throw new Error("package.json is required to write plugin-inspector package scripts");
+    }
+    for (const name of Object.keys(defaultInitPackageScripts)) {
+      if (!dryRun && packageJson.scripts?.[name] && options.force !== true) {
+        throw new Error(`package.json scripts.${name} 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");
+  if (!dryRun) {
+    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`);
+  if (workflowPath) {
+    if (!dryRun) {
+      await mkdir(path.dirname(workflowPath), { recursive: true });
+      await writeFile(workflowPath, renderGithubActionsWorkflow({ packageManager }), "utf8");
     }
-    await mkdir(path.dirname(workflowPath), { recursive: true });
-    await writeFile(workflowPath, renderGithubActionsWorkflow({ packageManager: options.packageManager }), "utf8");
     written.push(workflowPath);
   }
 
-  return { pluginRoot, configPath, written };
+  if (options.scripts === true) {
+    const existingScripts = packageJson.scripts ?? {};
+    packageJson.scripts = {
+      ...existingScripts,
+      ...defaultInitPackageScripts,
+    };
+    if (!dryRun) {
+      await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
+    }
+    written.push(packageJsonPath);
+  }
+
+  return { pluginRoot, configPath, dryRun, packageManager, written };
 }
 
 export async function buildPluginInspectorConfig(options = {}) {
@@ -79,7 +113,7 @@ jobs:
           node-version: 24
           cache: ${setup.cache}
 ${setup.corepack ? "      - run: corepack enable\n" : ""}      - run: ${setup.install}
-      - run: PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 ${setup.exec} @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk
+      - run: ${setup.exec} @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute
       - uses: actions/upload-artifact@v5
         if: always()
         with:
@@ -88,19 +122,62 @@ ${setup.corepack ? "      - run: corepack enable\n" : ""}      - run: ${setup.in
 `;
 }
 
+export async function detectPackageManager(pluginRoot) {
+  const root = path.resolve(pluginRoot ?? process.cwd());
+  const packageJson = await readJsonIfExists(path.join(root, "package.json"));
+  const packageManager = packageJson?.packageManager;
+  if (typeof packageManager === "string") {
+    const [name] = packageManager.split("@");
+    if (["npm", "pnpm", "yarn", "bun"].includes(name)) {
+      return name;
+    }
+  }
+
+  if (existsSync(path.join(root, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(path.join(root, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync(path.join(root, "bun.lockb")) || existsSync(path.join(root, "bun.lock"))) {
+    return "bun";
+  }
+  return "npm";
+}
+
 function inferSourceRoot(packageJson) {
   const entrypoints = [
     packageJson?.openclaw?.entrypoint,
     ...(packageJson?.openclaw?.extensions ?? []),
     ...(packageJson?.openclaw?.runtimeExtensions ?? []),
+    ...entrypointStrings(packageJson?.exports?.["."]),
+    ...entrypointStrings(packageJson?.exports),
+    packageJson?.module,
+    packageJson?.main,
   ].filter((value) => typeof value === "string");
-  const entrypoint = entrypoints[0] ?? packageJson?.exports?.["."] ?? packageJson?.main ?? "src/index.js";
-  if (typeof entrypoint === "string" && entrypoint.startsWith("src/")) {
+  const entrypoint = entrypoints[0] ?? "src/index.js";
+  if (stripRelativePrefix(entrypoint).startsWith("src/")) {
     return "src";
   }
   return ".";
 }
 
+function entrypointStrings(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return [];
+  }
+  return ["import", "default", "require", "node", "module"]
+    .map((key) => value[key])
+    .filter((item) => typeof item === "string");
+}
+
+function stripRelativePrefix(filePath) {
+  return filePath.replace(/^\.\//, "");
+}
+
 async function readJsonIfExists(filePath) {
   if (!existsSync(filePath)) {
     return null;

package/src/mock-sdk-capture-runner.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { mkdtemp, rm } from "node:fs/promises";
+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";
@@ -26,13 +27,16 @@ async function run(options) {
   const pluginRoot = path.resolve(options.cwd ?? process.cwd(), options.pluginRoot ?? path.dirname(entrypoint));
   const workspace = await mkdtemp(path.join(os.tmpdir(), "plugin-inspector-mock-sdk-"));
 
-  try {
-    const { loaderPath } = await createMockSdkPackage(workspace, { pluginRoot });
-    register(pathToFileURL(loaderPath));
-    return await captureLinkedEntrypoint(entrypoint, options);
-  } finally {
-    await rm(workspace, { force: true, recursive: true });
-  }
+  cleanupTempDirOnExit(workspace);
+  const { loaderPath } = await createMockSdkPackage(workspace, { pluginRoot });
+  register(pathToFileURL(loaderPath));
+  return await captureLinkedEntrypoint(entrypoint, options);
+}
+
+function cleanupTempDirOnExit(dir) {
+  process.once("exit", () => {
+    rmSync(dir, { force: true, recursive: true });
+  });
 }
 
 async function captureLinkedEntrypoint(entrypoint, options) {

package/src/report.js

@@ -246,27 +246,79 @@ export async function writeReport(report, options = {}) {
 export async function writeCompatibilityReport(report, options = {}) {
   const outDir = path.resolve(options.cwd ?? process.cwd(), options.outDir ?? "reports");
   const basename = options.basename ?? "plugin-inspector-report";
-  const jsonPath = path.join(outDir, `${basename}.json`);
-  const markdownPath = path.join(outDir, `${basename}.md`);
-  const issuesPath = path.join(outDir, options.issuesBasename ?? "plugin-inspector-issues.md");
+  const jsonPath = options.jsonPath ?? path.join(outDir, `${basename}.json`);
+  const markdownPath = options.markdownPath ?? path.join(outDir, `${basename}.md`);
+  const issuesPath = options.issuesPath ?? path.join(outDir, options.issuesBasename ?? "plugin-inspector-issues.md");
+  const markdownOptions = compatibilityRenderOptions(options, {
+    title: options.markdownTitle ?? options.title,
+    ...options.markdownOptions,
+  });
+  const issuesOptions = compatibilityRenderOptions(options, {
+    title: options.issuesTitle ?? options.title,
+    ...options.issuesOptions,
+  });
 
   return writeArtifacts(
     [
       { name: "jsonPath", path: jsonPath, json: report },
-      { name: "markdownPath", path: markdownPath, markdown: renderCompatibilityMarkdownReport(report) },
-      { name: "issuesPath", path: issuesPath, markdown: renderCompatibilityIssuesReport(report) },
+      { name: "markdownPath", path: markdownPath, markdown: renderCompatibilityMarkdownReport(report, markdownOptions) },
+      { name: "issuesPath", path: issuesPath, markdown: renderCompatibilityIssuesReport(report, issuesOptions) },
     ],
     { check: options.check },
   );
 }
 
-export function renderTextSummary(report) {
-  return [
+function compatibilityRenderOptions(options, overrides) {
+  const renderOptions = {
+    formatEvidence: options.formatEvidence,
+    severityLabels: options.severityLabels,
+    ...overrides,
+  };
+  return Object.fromEntries(Object.entries(renderOptions).filter(([, value]) => value !== undefined));
+}
+
+export function renderTextSummary(report, options = {}) {
+  const lines = [
     `Status: ${report.status.toUpperCase()}`,
     `Fixtures: ${report.summary.fixtureCount}`,
     `Breakages: ${report.summary.breakageCount}`,
+    ...(typeof report.summary.issueCount === "number" ? [`Issues: ${report.summary.issueCount}`] : []),
     `Logs: ${report.summary.logCount}`,
-  ].join("\n");
+  ];
+  const artifacts = Object.entries(options.artifacts ?? {}).filter(([, filePath]) => Boolean(filePath));
+  if (artifacts.length > 0) {
+    lines.push("", "Reports:", ...artifacts.map(([name, filePath]) => `- ${artifactLabel(name)}: ${filePath}`));
+  }
+  const findings = topTextFindings(report, options.topFindings ?? 3);
+  if (findings.length > 0) {
+    lines.push("", "Top findings:", ...findings.map((finding) => `- ${finding}`));
+  }
+  return lines.join("\n");
+}
+
+function topTextFindings(report, limit) {
+  if (report.status === "pass" || limit <= 0) {
+    return [];
+  }
+  return [
+    ...(report.breakages ?? []).map((finding) => formatTextFinding(finding, "breakage")),
+    ...(report.issues ?? [])
+      .filter((issue) => issue.status === "blocking" || issue.severity === "P0" || issue.severity === "P1")
+      .map((issue) => formatTextFinding(issue, issue.severity ?? "issue")),
+    ...(report.warnings ?? []).map((finding) => formatTextFinding(finding, "warning")),
+  ].slice(0, limit);
+}
+
+function formatTextFinding(finding, fallbackLevel) {
+  const level = finding.level ?? finding.severity ?? fallbackLevel;
+  const code = finding.code ? ` ${finding.code}` : "";
+  const message = finding.message ?? finding.title ?? "see report";
+  const evidence = Array.isArray(finding.evidence) && finding.evidence.length > 0 ? ` (${finding.evidence[0]})` : "";
+  return `${String(level).toUpperCase()} ${finding.fixture ?? "unknown"}${code}: ${message}${evidence}`;
+}
+
+function artifactLabel(name) {
+  return String(name).replace(/Path$/u, "");
 }
 
 export function renderMarkdownReport(report) {

package/src/sdk-mock.js

@@ -11,8 +11,11 @@ export const mockSdkSubpathExports = {
     "emptyPluginConfigSchema",
   ],
   core: [
+    "buildChannelOutboundSessionRoute",
     "buildChannelConfigSchema",
     "buildPluginConfigSchema",
+    "createActionGate",
+    "createChannelPluginBase",
     "createChatChannelPlugin",
     "createDedupeCache",
     "defineChannelPluginEntry",
@@ -22,12 +25,24 @@ export const mockSdkSubpathExports = {
     "emptyPluginConfigSchema",
     "jsonResult",
     "readNumberParam",
+    "readReactionParams",
+    "readStringArrayParam",
+    "readStringParam",
+  ],
+  "channel-actions": [
+    "createActionGate",
+    "jsonResult",
+    "readNumberParam",
+    "readReactionParams",
+    "readStringArrayParam",
     "readStringParam",
   ],
   "channel-core": [
     "buildChannelConfigSchema",
+    "buildChannelOutboundSessionRoute",
     "buildThreadAwareOutboundSessionRoute",
     "clearAccountEntryFields",
+    "createChannelPluginBase",
     "createChatChannelPlugin",
     "defineChannelPluginEntry",
     "defineSetupPluginEntry",
@@ -718,6 +733,10 @@ function mockSdkSource() {
   return typeof entry === "function" ? { register: entry } : entry;
 }
 
+function normalizeRegistrationMode(api) {
+  return api?.registrationMode ?? "full";
+}
+
 function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -754,15 +773,139 @@ export function definePluginEntry(entry) {
 }
 
 export function defineChannelPluginEntry(entry) {
-  return normalizeEntry(entry);
+  if (!isPlainObject(entry) || !entry.plugin) {
+    return normalizeEntry(entry);
+  }
+  const resolved = {
+    id: entry.id,
+    name: entry.name,
+    description: entry.description,
+    configSchema: createConfigSchema(entry.configSchema),
+    channelPlugin: entry.plugin,
+    register(api) {
+      const mode = normalizeRegistrationMode(api);
+      if (mode === "cli-metadata") {
+        entry.registerCliMetadata?.(api);
+        return;
+      }
+      api.registerChannel?.({ plugin: entry.plugin });
+      entry.setRuntime?.(api.runtime);
+      if (mode === "discovery") {
+        entry.registerCliMetadata?.(api);
+        return;
+      }
+      if (mode !== "full") {
+        return;
+      }
+      entry.registerCliMetadata?.(api);
+      entry.registerFull?.(api);
+    },
+  };
+  if (entry.setRuntime) {
+    resolved.setChannelRuntime = entry.setRuntime;
+  }
+  return resolved;
 }
 
 export function defineSetupPluginEntry(entry) {
-  return normalizeEntry(entry);
+  return isPlainObject(entry) && entry.plugin ? entry : { plugin: entry };
 }
 
 export function createChatChannelPlugin(entry) {
-  return normalizeEntry(entry);
+  if (!isPlainObject(entry) || !entry.base) {
+    return normalizeEntry(entry);
+  }
+  return {
+    ...entry.base,
+    conversationBindings: {
+      supportsCurrentConversationBinding: true,
+      ...(entry.base.conversationBindings ?? {}),
+    },
+    ...(entry.security ? { security: resolveChannelSecurity(entry.security) } : {}),
+    ...(entry.pairing ? { pairing: resolveChannelPairing(entry.pairing) } : {}),
+    ...(entry.threading ? { threading: resolveChannelThreading(entry.threading) } : {}),
+    ...(entry.outbound ? { outbound: resolveChannelOutbound(entry.outbound) } : {}),
+  };
+}
+
+export function createChannelPluginBase(params = {}) {
+  return {
+    id: params.id ?? "fixture-channel",
+    meta: { id: params.id ?? "fixture-channel", ...(params.meta ?? {}) },
+    ...(params.setupWizard ? { setupWizard: params.setupWizard } : {}),
+    ...(params.capabilities ? { capabilities: params.capabilities } : {}),
+    ...(params.commands ? { commands: params.commands } : {}),
+    ...(params.doctor ? { doctor: params.doctor } : {}),
+    ...(params.agentPrompt ? { agentPrompt: params.agentPrompt } : {}),
+    ...(params.streaming ? { streaming: params.streaming } : {}),
+    ...(params.reload ? { reload: params.reload } : {}),
+    ...(params.gatewayMethods ? { gatewayMethods: params.gatewayMethods } : {}),
+    ...(params.configSchema ? { configSchema: createConfigSchema(params.configSchema) } : {}),
+    ...(params.config ? { config: params.config } : {}),
+    ...(params.security ? { security: params.security } : {}),
+    ...(params.groups ? { groups: params.groups } : {}),
+    setup: params.setup ?? (() => ({})),
+  };
+}
+
+function resolveChannelSecurity(security) {
+  if (!isPlainObject(security) || !security.dm) {
+    return security;
+  }
+  return {
+    resolveDmPolicy: ({ account } = {}) => ({
+      policy: security.dm.resolvePolicy?.(account ?? {}) ?? security.dm.defaultPolicy ?? "allow",
+      allowFrom: security.dm.resolveAllowFrom?.(account ?? {}) ?? [],
+    }),
+    ...(security.collectWarnings ? { collectWarnings: security.collectWarnings } : {}),
+    ...(security.collectAuditFindings ? { collectAuditFindings: security.collectAuditFindings } : {}),
+  };
+}
+
+function resolveChannelPairing(pairing) {
+  if (!isPlainObject(pairing) || !pairing.text) {
+    return pairing;
+  }
+  return {
+    idLabel: pairing.text.idLabel,
+    normalizeAllowEntry: pairing.text.normalizeAllowEntry,
+    notifyApproval: (ctx) => pairing.text.notify?.({ ...ctx, message: pairing.text.message }),
+  };
+}
+
+function resolveChannelThreading(threading) {
+  if (!isPlainObject(threading)) {
+    return threading;
+  }
+  if (threading.resolveReplyToMode) {
+    return threading;
+  }
+  return {
+    ...threading,
+    resolveReplyToMode: () =>
+      threading.topLevelReplyToMode ??
+      threading.scopedAccountReplyToMode?.fallback ??
+      "thread",
+  };
+}
+
+function resolveChannelOutbound(outbound) {
+  if (!isPlainObject(outbound) || !outbound.attachedResults) {
+    return outbound;
+  }
+  const { base = {}, attachedResults } = outbound;
+  return {
+    ...base,
+    ...(attachedResults.sendText
+      ? { sendText: async (ctx) => ({ channel: attachedResults.channel, ...(await attachedResults.sendText(ctx)) }) }
+      : {}),
+    ...(attachedResults.sendMedia
+      ? { sendMedia: async (ctx) => ({ channel: attachedResults.channel, ...(await attachedResults.sendMedia(ctx)) }) }
+      : {}),
+    ...(attachedResults.sendPoll
+      ? { sendPoll: async (ctx) => ({ channel: attachedResults.channel, ...(await attachedResults.sendPoll(ctx)) }) }
+      : {}),
+  };
 }
 
 export function definePlugin(entry) {
@@ -805,13 +948,63 @@ export function jsonResult(value) {
   return { content: [{ type: "text", text: JSON.stringify(value) }] };
 }
 
-export function readNumberParam(value, fallback = 0) {
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : fallback;
+export function readNumberParam(value, keyOrFallback = 0, options = {}) {
+  const raw = isPlainObject(value) ? value[keyOrFallback] : value;
+  const parsed = Number(raw);
+  if (Number.isFinite(parsed)) {
+    return options.integer ? Math.trunc(parsed) : parsed;
+  }
+  return isPlainObject(value) ? undefined : keyOrFallback;
 }
 
-export function readStringParam(value, fallback = "") {
-  return typeof value === "string" ? value : fallback;
+export function readStringParam(value, keyOrFallback = "") {
+  if (isPlainObject(value)) {
+    const raw = value[keyOrFallback];
+    return typeof raw === "string" ? raw : undefined;
+  }
+  return typeof value === "string" ? value : keyOrFallback;
+}
+
+export function readStringArrayParam(value, key) {
+  const raw = isPlainObject(value) ? value[key] : value;
+  if (Array.isArray(raw)) {
+    return raw.map((entry) => String(entry));
+  }
+  return typeof raw === "string" && raw ? [raw] : [];
+}
+
+export function readReactionParams(value = {}) {
+  return {
+    messageId: value.messageId ?? value.id ?? "",
+    reaction: value.reaction ?? value.emoji ?? "",
+  };
+}
+
+export function createActionGate(actions = {}) {
+  return (key, defaultValue = true) => {
+    const value = actions?.[key];
+    return value === undefined ? defaultValue : value !== false;
+  };
+}
+
+export function buildChannelOutboundSessionRoute(params = {}) {
+  const peer = params.peer ?? { kind: params.chatType ?? "direct", id: params.to ?? "fixture-peer" };
+  const baseSessionKey = [
+    params.agentId ?? "agent",
+    params.channel ?? "channel",
+    params.accountId ?? "default",
+    peer.kind,
+    peer.id,
+  ].filter(Boolean).join(":");
+  return {
+    sessionKey: baseSessionKey,
+    baseSessionKey,
+    peer,
+    chatType: params.chatType ?? peer.kind ?? "direct",
+    from: params.from ?? "fixture-source",
+    to: params.to ?? peer.id,
+    ...(params.threadId !== undefined ? { threadId: params.threadId } : {}),
+  };
 }
 
 export function createDedupeCache() {
@@ -1129,7 +1322,7 @@ export function createSubsystemLogger() {
 }
 
 export function buildThreadAwareOutboundSessionRoute(route = {}) {
-  return route;
+  return route.route ?? route;
 }
 
 export function clearAccountEntryFields(entry = {}) {

package/src/synthetic-probe-suite.js

@@ -0,0 +1,19 @@
+import { buildContractCapture } from "./contract-capture.js";
+import { buildSyntheticProbePlan } from "./synthetic-probes.js";
+
+export function buildSyntheticProbePlanFromReport(report, options = {}) {
+  const capture = options.capture ?? buildContractCapture({
+    report,
+    hookAssertions: options.hookAssertions,
+    hookContexts: options.hookContexts,
+    hookEvents: options.hookEvents,
+    registrationArguments: options.registrationArguments,
+    registrationAssertions: options.registrationAssertions,
+  });
+  return buildSyntheticProbePlan({
+    capture,
+    hookContexts: options.hookContexts,
+    hookEvents: options.hookEvents,
+    registrationArguments: options.registrationArguments,
+  });
+}

package/src/synthetic-probes-cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { mkdtemp, rm } from "node:fs/promises";
+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";
@@ -59,17 +60,20 @@ async function captureForSyntheticProbes(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-"));
-  try {
-    const { loaderPath } = await createMockSdkPackage(workspace, { pluginRoot });
-    register(pathToFileURL(loaderPath));
-    return captureEntrypoint(entrypoint, {
-      ...options,
-      mockSdk: false,
-      pluginRoot,
-    });
-  } finally {
-    await rm(workspace, { force: true, recursive: true });
-  }
+  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) {

package/src/synthetic-probes.js

@@ -214,6 +214,12 @@ export const defaultSyntheticRegistrationProbeInputs = {
     handler: commandProbeArgs,
     run: commandProbeArgs,
   },
+  registerChannel: {
+    handleMessage: channelReceiveProbeArgs,
+    receive: channelReceiveProbeArgs,
+    send: channelSendProbeArgs,
+    sendMessage: channelSendProbeArgs,
+  },
   registerGatewayMethod: {
     execute: gatewayProbeArgs,
     handler: gatewayProbeArgs,
@@ -523,6 +529,9 @@ function syntheticRegistrationEvent(registrar, property, options) {
       id: beforeToolCall.toolCallId,
       name: beforeToolCall.toolName,
     },
+    respond(ok, result, error) {
+      return { ok, result, ...(error ? { error } : {}) };
+    },
   };
 }
 
@@ -576,9 +585,11 @@ function commandProbeArgs(event) {
 function gatewayProbeArgs(event) {
   return [
     {
+      ...event,
       params: event.params,
       body: event.body,
       headers: event.headers,
+      respond: event.respond,
     },
     {
       source: event.source,
@@ -587,6 +598,47 @@ function gatewayProbeArgs(event) {
   ];
 }
 
+function channelSendProbeArgs(event) {
+  return [
+    {
+      source: event.source,
+      channelId: "fixture-channel",
+      accountId: "fixture-account",
+      to: "fixture-recipient",
+      text: "fixture message",
+      replyToId: "fixture-reply",
+      threadId: "fixture-thread",
+      logger: console,
+      signal: new AbortController().signal,
+    },
+  ];
+}
+
+function channelReceiveProbeArgs(event) {
+  return [
+    {
+      source: event.source,
+      channelId: "fixture-channel",
+      accountId: "fixture-account",
+      message: {
+        id: "message-fixture",
+        text: "fixture inbound message",
+        sender: { id: "sender-fixture", displayName: "Fixture Sender" },
+      },
+      route: {
+        sessionKey: "fixture-session",
+        baseSessionKey: "fixture-base-session",
+        peer: { kind: "direct", id: "sender-fixture" },
+        chatType: "direct",
+        from: "sender-fixture",
+        to: "fixture-channel",
+      },
+      logger: console,
+      signal: new AbortController().signal,
+    },
+  ];
+}
+
 function interactiveProbeArgs(event) {
   return [
     {
@@ -604,7 +656,10 @@ function lifecycleProbeArgs(event) {
   return [
     {
       source: event.source,
+      config: {},
       logger: console,
+      runtime: { env: {}, logger: console },
+      secrets: { get: async () => null, has: async () => false },
       signal: new AbortController().signal,
     },
   ];