@openclaw/plugin-inspector 0.3.16 → 0.3.18

package/CHANGELOG.md

@@ -1,6 +1,24 @@
 # Changelog
 
-## Unreleased
+## 0.3.18 - 2026-07-21
+
+### Highlights
+
+- Keep compatibility capture current with OpenClaw's evolving hook, gateway, workspace-linking, blob-store, and Zod runtime surfaces.
+
+### Fixed
+
+- Mock the current plugin blob-store runtime so Diffs and other trusted plugins can be captured without persistent state.
+- Parse OpenClaw hook names after their source declaration became private and added a TypeScript `satisfies` constraint.
+- Run synthetic gateway lifecycle hooks around ordinary probes while preserving capture indexes and report order, so `gateway_stop` teardown cannot invalidate later compatibility checks.
+- Link isolated plugin workspaces to the OpenClaw checkout without npm normalizing duplicated dependency and peer declarations back to registry ranges.
+- Keep mocked Zod schemas chainable through unsupported methods such as `pipe()` and `catch()`.
+
+## 0.3.17 - 2026-06-29
+
+### Fixed
+
+- Detect deprecated session SDK read/write, file-path, and transcript helpers across source files, packaged `dist`/`build` artifacts, runtime session APIs, and dynamic SDK imports.
 
 ## 0.3.16 - 2026-06-23
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/plugin-inspector",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "private": false,
   "description": "Offline compatibility inspector for OpenClaw plugins.",
   "type": "module",

package/src/capture-api.js

@@ -194,6 +194,8 @@ function registrationReturnValue(name, args, context) {
 
 function createRuntimeContext(options) {
   const runtime = options.runtime ?? {};
+  const blobStores = new Map();
+  const syncKeyedStores = new Map();
   return {
     ...runtime,
     agent: runtime.agent ?? {},
@@ -203,11 +205,149 @@ function createRuntimeContext(options) {
     tts: runtime.tts ?? {},
     state: {
       resolveStateDir: () => options.stateDir ?? process.cwd(),
+      openBlobStore(storeOptions) {
+        const existing = blobStores.get(storeOptions.namespace);
+        if (existing) {
+          return existing;
+        }
+        const store = createBlobStoreContext(storeOptions);
+        blobStores.set(storeOptions.namespace, store);
+        return store;
+      },
+      openSyncKeyedStore({ namespace }) {
+        const existing = syncKeyedStores.get(namespace);
+        if (existing) {
+          return existing;
+        }
+        const store = createSyncKeyedStoreContext();
+        syncKeyedStores.set(namespace, store);
+        return store;
+      },
       ...(runtime.state ?? {}),
     },
   };
 }
 
+function createBlobStoreContext(options) {
+  const values = new Map();
+  const entryInfo = (key, entry) => ({
+    key,
+    metadata: entry.metadata,
+    sizeBytes: entry.bytes.byteLength,
+    createdAt: entry.createdAt,
+    ...(entry.expiresAt === undefined ? {} : { expiresAt: entry.expiresAt }),
+  });
+  const read = (key) => {
+    const entry = values.get(key);
+    if (!entry) {
+      return undefined;
+    }
+    if (entry.expiresAt !== undefined && entry.expiresAt <= Date.now()) {
+      return undefined;
+    }
+    return { ...entryInfo(key, entry), bytes: Uint8Array.from(entry.bytes) };
+  };
+  const register = async (key, bytes, metadata, registerOptions) => {
+    const createdAt = Date.now();
+    const ttlMs = registerOptions?.ttlMs ?? options.defaultTtlMs;
+    values.set(key, {
+      bytes: Uint8Array.from(bytes),
+      metadata,
+      createdAt,
+      ...(ttlMs === undefined ? {} : { expiresAt: createdAt + ttlMs }),
+    });
+  };
+  return {
+    register,
+    async registerIfAbsent(key, bytes, metadata, registerOptions) {
+      if (values.has(key)) {
+        return false;
+      }
+      await register(key, bytes, metadata, registerOptions);
+      return true;
+    },
+    async lookup(key) {
+      return read(key);
+    },
+    async entries() {
+      return [...values.keys()].flatMap((key) => {
+        const entry = read(key);
+        if (!entry) {
+          return [];
+        }
+        const { bytes: _bytes, ...info } = entry;
+        return [info];
+      });
+    },
+    async delete(key) {
+      return values.delete(key);
+    },
+    async deleteExpiredKey(key) {
+      const entry = values.get(key);
+      if (!entry || entry.expiresAt === undefined || entry.expiresAt > Date.now()) {
+        return undefined;
+      }
+      values.delete(key);
+      return entryInfo(key, entry);
+    },
+    async deleteExpired() {
+      const expired = [];
+      for (const [key, entry] of values) {
+        if (entry.expiresAt === undefined || entry.expiresAt > Date.now()) {
+          continue;
+        }
+        values.delete(key);
+        expired.push(entryInfo(key, entry));
+      }
+      return expired;
+    },
+    async clear() {
+      values.clear();
+    },
+  };
+}
+
+function createSyncKeyedStoreContext() {
+  const values = new Map();
+  return {
+    register(key, value) {
+      values.set(key, value);
+    },
+    registerIfAbsent(key, value) {
+      if (values.has(key)) {
+        return false;
+      }
+      values.set(key, value);
+      return true;
+    },
+    update(key, updateValue) {
+      const next = updateValue(values.get(key));
+      if (next === undefined) {
+        return false;
+      }
+      values.set(key, next);
+      return true;
+    },
+    lookup(key) {
+      return values.get(key);
+    },
+    consume(key) {
+      const value = values.get(key);
+      values.delete(key);
+      return value;
+    },
+    delete(key) {
+      return values.delete(key);
+    },
+    entries() {
+      return [...values].map(([key, value]) => ({ key, value, createdAt: 0 }));
+    },
+    clear() {
+      values.clear();
+    },
+  };
+}
+
 function createSecretContext(options) {
   const secrets = new Map(Object.entries(options.secretValues ?? {}));
   return {

package/src/fixture-summary.js

@@ -724,14 +724,39 @@ function classifySdkDeprecations({ fixture, inspection, fixtureReport, warnings,
     decisions.push({
       fixture: fixture.id,
       decision: "core-compat-adapter",
-      seam: "session-store",
-      action:
-        "Keep loadSessionStore compatibility active while plugin authors migrate to row-scoped session helpers.",
+      seam: sdkDeprecationSeamForCode(code),
+      action: sdkDeprecationActionForCode(code),
       evidence: findings.map((finding) => finding.ref).join(", "),
     });
   }
 }
 
+function sdkDeprecationSeamForCode(code) {
+  if (code === "sdk-session-file-helper") {
+    return "session-file";
+  }
+  if (code === "sdk-session-transcript-file-target" || code === "sdk-session-transcript-low-level") {
+    return "session-transcript";
+  }
+  return "session-store";
+}
+
+function sdkDeprecationActionForCode(code) {
+  if (code === "sdk-session-store-write") {
+    return "Keep whole-store session write compatibility active while plugin authors migrate to row-scoped session write helpers.";
+  }
+  if (code === "sdk-session-file-helper") {
+    return "Keep session file-path compatibility active while plugin authors migrate to session entry and transcript identity helpers.";
+  }
+  if (code === "sdk-session-transcript-file-target") {
+    return "Keep legacy transcript file target compatibility active while plugin authors migrate to structured transcript targets.";
+  }
+  if (code === "sdk-session-transcript-low-level") {
+    return "Keep low-level transcript write compatibility active while plugin authors migrate to structured transcript runtime helpers.";
+  }
+  return "Keep loadSessionStore compatibility active while plugin authors migrate to row-scoped session helpers.";
+}
+
 function classifySecurityManifestCoverage({ fixture, fixtureReport, warnings, decisions }) {
   for (const securityManifest of fixtureReport.securityManifests ?? []) {
     warnings.push({

package/src/inspector.js

@@ -95,10 +95,17 @@ export async function inspectPlugin(fixture, options = {}) {
     return emptyInspection(fixture, "missing");
   }
 
-  const files = await listSourceFiles(sourceRoot, { includeDist: Boolean(fixture.package) });
+  const packageInspection = await readPackageMetadata(config, checkoutPath, sourceRoot);
+  const includeBuildArtifacts = shouldScanBuildArtifacts(fixture, packageInspection);
+  const files = await listSourceFiles(sourceRoot, {
+    includeBuild: includeBuildArtifacts,
+    includeDist: includeBuildArtifacts,
+  });
   if (sourceRoot !== checkoutPath) {
     files.push(...(await listSourceFiles(checkoutPath, { shallowRootOnly: true })));
   }
+  files.push(...packageInspection.entrypointFiles);
+  const sourceFiles = uniquePaths(files);
 
   const hooks = new Set();
   const registrations = new Set();
@@ -107,7 +114,7 @@ export async function inspectPlugin(fixture, options = {}) {
   const sdkImportDetails = [];
   const sdkDeprecationDetails = [];
 
-  for (const filePath of files) {
+  for (const filePath of sourceFiles) {
     const text = await readFile(filePath, "utf8");
     const relativePath = path.relative(config.rootDir ?? process.cwd(), filePath);
     const sourceInspection = inspectSourceText(text, relativePath);
@@ -129,8 +136,6 @@ export async function inspectPlugin(fixture, options = {}) {
   }
 
   const manifestInspection = await readManifestContracts(config, checkoutPath, sourceRoot);
-  const packageInspection = await readPackageMetadata(config, checkoutPath, sourceRoot);
-
   return {
     id: fixture.id,
     status: "ok",
@@ -146,7 +151,7 @@ export async function inspectPlugin(fixture, options = {}) {
     packageEntrypoints: packageInspection.entrypoints,
     sdkImports: uniqueDetails(sdkImportDetails),
     sdkDeprecations: uniqueSdkDeprecations(sdkDeprecationDetails),
-    sourceFiles: files.map((filePath) => path.relative(config.rootDir ?? process.cwd(), filePath)).sort(),
+    sourceFiles: sourceFiles.map((filePath) => path.relative(config.rootDir ?? process.cwd(), filePath)).sort(),
   };
 }
 
@@ -418,18 +423,23 @@ async function readPackageMetadata(config, checkoutPath, sourceRoot) {
   const files = [];
   const errors = [];
   const entrypoints = new Set();
+  const entrypointFiles = new Set();
 
   for (const packageFile of packageFiles) {
     const relativePath = path.relative(config.rootDir ?? process.cwd(), packageFile);
     files.push(relativePath);
     try {
       const packageJson = JSON.parse(await readFile(packageFile, "utf8"));
-      collectEntrypoint(entrypoints, packageJson.main);
-      collectEntrypoint(entrypoints, packageJson.module);
-      collectEntrypoint(entrypoints, packageJson.openclaw?.entry);
-      collectEntrypoint(entrypoints, packageJson.openclaw?.entrypoint);
-      collectEntrypoint(entrypoints, packageJson.exports?.["."]?.import);
-      collectEntrypoint(entrypoints, packageJson.exports?.["."]?.default);
+      const packageDir = path.dirname(packageFile);
+      collectEntrypoint(entrypoints, entrypointFiles, packageDir, packageJson.main);
+      collectEntrypoint(entrypoints, entrypointFiles, packageDir, packageJson.module);
+      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.exports?.["."]?.import);
+      collectEntrypoint(entrypoints, entrypointFiles, packageDir, packageJson.exports?.["."]?.default);
+      collectEntrypoints(entrypoints, entrypointFiles, packageDir, packageJson.openclaw?.extensions);
+      collectEntrypoints(entrypoints, entrypointFiles, packageDir, packageJson.openclaw?.runtimeExtensions);
     } catch {
       errors.push(`${relativePath}: invalid JSON`);
     }
@@ -439,13 +449,58 @@ async function readPackageMetadata(config, checkoutPath, sourceRoot) {
     files: files.sort(),
     errors,
     entrypoints: [...entrypoints].sort(),
+    entrypointFiles: [...entrypointFiles].sort(),
   };
 }
 
-function collectEntrypoint(entrypoints, value) {
+function collectEntrypoints(entrypoints, entrypointFiles, packageDir, values) {
+  if (!Array.isArray(values)) {
+    return;
+  }
+  for (const value of values) {
+    collectEntrypoint(entrypoints, entrypointFiles, packageDir, value);
+  }
+}
+
+function collectEntrypoint(entrypoints, entrypointFiles, packageDir, value) {
   if (typeof value === "string" && value.length > 0) {
     entrypoints.add(value);
+    for (const candidate of entrypointCandidates(packageDir, value)) {
+      if (existsSync(candidate) && isSourceFile(path.basename(candidate), candidate.split(path.sep).join("/"))) {
+        entrypointFiles.add(candidate);
+        return;
+      }
+    }
+  }
+}
+
+function entrypointCandidates(packageDir, specifier) {
+  const resolved = path.resolve(packageDir, specifier);
+  if (path.extname(resolved)) {
+    return [resolved];
+  }
+  return [
+    resolved,
+    `${resolved}.js`,
+    `${resolved}.mjs`,
+    `${resolved}.cjs`,
+    `${resolved}.ts`,
+    path.join(resolved, "index.js"),
+    path.join(resolved, "index.mjs"),
+    path.join(resolved, "index.cjs"),
+    path.join(resolved, "index.ts"),
+  ];
+}
+
+function uniquePaths(paths) {
+  return [...new Set(paths)];
+}
+
+function shouldScanBuildArtifacts(fixture, packageInspection) {
+  if (fixture.package) {
+    return true;
   }
+  return packageInspection.entrypoints.some((entrypoint) => /(^|\/)(?:dist|build)\//.test(entrypoint));
 }
 
 async function listSourceFiles(root, options = {}) {
@@ -484,7 +539,7 @@ function shouldSkipDir(name, normalizedPath, options = {}) {
   return (
     name === "node_modules" ||
     (!options.includeDist && name === "dist") ||
-    name === "build" ||
+    (!options.includeBuild && name === "build") ||
     name === "coverage" ||
     name === ".git" ||
     name === "test" ||

package/src/issues.js

@@ -42,6 +42,10 @@ export const knownIssueCodes = new Set([
   "reserved-sdk-import",
   "security-manifest-schema-unavailable",
   "sdk-load-session-store",
+  "sdk-session-file-helper",
+  "sdk-session-store-write",
+  "sdk-session-transcript-file-target",
+  "sdk-session-transcript-low-level",
   "sdk-export-missing",
   "unrecognized-security-manifest",
 ]);
@@ -124,6 +128,58 @@ export const issueMetadataByCode = {
       ],
     ),
   },
+  "sdk-session-store-write": {
+    severity: "P2",
+    owner: "core",
+    decision: "core-compat-adapter",
+    title: "deprecated whole-store session write helper is still used",
+    authorRemediation: migrationRemediation(
+      "Replace deprecated whole-store session writes with row-scoped session helpers.",
+      [
+        "Use patchSessionEntry(...) when updating fields on an existing session entry.",
+        "Use upsertSessionEntry(...) when replacing or creating a session entry.",
+      ],
+    ),
+  },
+  "sdk-session-file-helper": {
+    severity: "P2",
+    owner: "core",
+    decision: "core-compat-adapter",
+    title: "deprecated session file-path helper is still used",
+    authorRemediation: migrationRemediation(
+      "Replace deprecated session file-path helpers with session entry and transcript identity APIs.",
+      [
+        "Use getSessionEntry(...) to read session metadata by agent/session identity.",
+        "Use patchSessionEntry(...) or upsertSessionEntry(...) to persist session metadata.",
+      ],
+    ),
+  },
+  "sdk-session-transcript-file-target": {
+    severity: "P2",
+    owner: "core",
+    decision: "core-compat-adapter",
+    title: "deprecated transcript file target helper is still used",
+    authorRemediation: migrationRemediation(
+      "Replace legacy transcript file targets with public transcript identity or target helpers.",
+      [
+        "Use resolveSessionTranscriptIdentity(...) when you only need public session identity.",
+        "Use resolveSessionTranscriptTarget(...) when you need a structured transcript operation target.",
+      ],
+    ),
+  },
+  "sdk-session-transcript-low-level": {
+    severity: "P2",
+    owner: "core",
+    decision: "core-compat-adapter",
+    title: "deprecated low-level transcript helper is still used",
+    authorRemediation: migrationRemediation(
+      "Replace low-level transcript writes with the structured transcript runtime helpers.",
+      [
+        "Use appendSessionTranscriptMessageByIdentity(...) for transcript appends.",
+        "Use publishSessionTranscriptUpdateByIdentity(...) for transcript update notifications.",
+      ],
+    ),
+  },
   "sdk-export-missing": {
     severity: "P1",
     owner: "core",
@@ -568,6 +624,10 @@ function issueClassFor(code, options) {
       "legacy-root-sdk-import",
       "provider-auth-env-vars",
       "sdk-load-session-store",
+      "sdk-session-file-helper",
+      "sdk-session-store-write",
+      "sdk-session-transcript-file-target",
+      "sdk-session-transcript-low-level",
     ].includes(code)
   ) {
     return "deprecation-warning";

package/src/link-openclaw-workspace-cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { writeJsonFileAtomic } from "./json-file.js";
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const specifier = process.argv[2];
+  await linkOpenClawWorkspace(path.resolve(process.cwd(), "package.json"), specifier);
+}
+
+export async function linkOpenClawWorkspace(packageJsonPath, specifier) {
+  if (typeof specifier !== "string" || !specifier.startsWith("file:")) {
+    throw new TypeError("link-openclaw-workspace requires a file: dependency specifier");
+  }
+
+  const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+  let linked = false;
+  for (const section of ["dependencies", "optionalDependencies"]) {
+    if (Object.hasOwn(packageJson[section] ?? {}, "openclaw")) {
+      packageJson[section].openclaw = specifier;
+      linked = true;
+    }
+  }
+
+  if (!linked) {
+    packageJson.dependencies ??= {};
+    packageJson.dependencies.openclaw = specifier;
+  }
+
+  await writeJsonFileAtomic(packageJsonPath, packageJson);
+}

package/src/openclaw-target.js

@@ -37,7 +37,7 @@ export async function readOpenClawTargetSurface(options = {}) {
   const registrySource = await readFile(registryPath, "utf8");
   const compatRecordEntries = parseCompatRecordEntries(registrySource);
   const hookTypesSource = existsSync(hookTypesPath) ? await readFile(hookTypesPath, "utf8") : "";
-  const hookNames = hookTypesSource ? parseExportedStringArray(hookTypesSource, "PLUGIN_HOOK_NAMES") : [];
+  const hookNames = hookTypesSource ? parseConstStringArray(hookTypesSource, "PLUGIN_HOOK_NAMES") : [];
   const apiBuilderSource = existsSync(apiBuilderPath) ? await readFile(apiBuilderPath, "utf8") : "";
   const apiRegistrars = apiBuilderSource ? parseApiRegistrars(apiBuilderSource) : [];
   const manifestTypesSource = existsSync(manifestTypesPath) ? await readFile(manifestTypesPath, "utf8") : "";
@@ -198,6 +198,15 @@ export function parsePluginSdkExports(packageJson) {
 
 export function parseExportedStringArray(source, exportName) {
   const match = source.match(new RegExp(`export\\s+const\\s+${exportName}\\s*=\\s*\\[([\\s\\S]*?)\\]\\s+as\\s+const`));
+  return parseStringArrayMatch(match);
+}
+
+function parseConstStringArray(source, constName) {
+  const match = source.match(new RegExp(`(?:export\\s+)?const\\s+${constName}\\s*=\\s*\\[([\\s\\S]*?)\\]\\s+as\\s+const`));
+  return parseStringArrayMatch(match);
+}
+
+function parseStringArrayMatch(match) {
   if (!match) {
     return [];
   }

package/src/sdk-deprecation-rules.js

@@ -1,16 +1,53 @@
-const loadSessionStoreReplacement =
+const sessionStoreReadReplacement =
   "getSessionEntry(...) / listSessionEntries(...) for reads and patchSessionEntry(...) / upsertSessionEntry(...) for writes";
+const sessionStoreWriteReplacement = "patchSessionEntry(...) / upsertSessionEntry(...) for row-scoped writes";
+const sessionFileReplacement = "session entries and transcript identity helpers instead of persisted file paths";
+const sessionTranscriptReplacement =
+  "resolveSessionTranscriptTarget(...), appendSessionTranscriptMessageByIdentity(...), and publishSessionTranscriptUpdateByIdentity(...)";
 
-const loadSessionStoreSpecifiers = new Set([
+const sdkSessionSpecifiers = new Set([
   "openclaw/plugin-sdk/config-runtime",
+  "openclaw/plugin-sdk/mattermost",
+  "openclaw/plugin-sdk/agent-harness-runtime",
   "openclaw/plugin-sdk/session-store-runtime",
+  "openclaw/plugin-sdk/session-transcript-runtime",
 ]);
 
 export const pluginSdkDeprecationRules = [
   {
     code: "sdk-load-session-store",
+    symbols: new Set(["loadSessionStore"]),
     title: "deprecated whole-store session helper is still used",
-    replacement: loadSessionStoreReplacement,
+    replacement: sessionStoreReadReplacement,
+    message: (symbol, replacement) => `${symbol} keeps the legacy whole-store session shape; use ${replacement}.`,
+  },
+  {
+    code: "sdk-session-store-write",
+    symbols: new Set(["saveSessionStore", "updateSessionStore"]),
+    title: "deprecated whole-store session write helper is still used",
+    replacement: sessionStoreWriteReplacement,
+    message: (symbol, replacement) => `${symbol} writes the legacy whole-store session shape; use ${replacement}.`,
+  },
+  {
+    code: "sdk-session-file-helper",
+    symbols: new Set(["resolveSessionFilePath", "resolveAndPersistSessionFile"]),
+    title: "deprecated session file-path helper is still used",
+    replacement: sessionFileReplacement,
+    message: (symbol, replacement) => `${symbol} depends on legacy session transcript file paths; use ${replacement}.`,
+  },
+  {
+    code: "sdk-session-transcript-file-target",
+    symbols: new Set(["resolveSessionTranscriptLegacyFileTarget"]),
+    title: "deprecated transcript file target helper is still used",
+    replacement: "resolveSessionTranscriptTarget(...) or resolveSessionTranscriptIdentity(...)",
+    message: (symbol, replacement) => `${symbol} exposes legacy transcript file targets; use ${replacement}.`,
+  },
+  {
+    code: "sdk-session-transcript-low-level",
+    symbols: new Set(["appendSessionTranscriptMessage", "emitSessionTranscriptUpdate"]),
+    title: "deprecated low-level transcript helper is still used",
+    replacement: sessionTranscriptReplacement,
+    message: (symbol, replacement) => `${symbol} bypasses the structured transcript runtime surface; use ${replacement}.`,
   },
 ];
 
@@ -18,9 +55,7 @@ export function inspectSdkDeprecations(text, filePath = "source.js", rules = plu
   const findings = [];
 
   for (const rule of rules) {
-    if (rule.code === "sdk-load-session-store") {
-      collectLoadSessionStoreDeprecations(findings, { text, filePath, rule });
-    }
+    collectSdkHelperDeprecations(findings, { text, filePath, rule });
   }
 
   return uniqueFindings(findings)
@@ -28,12 +63,13 @@ export function inspectSdkDeprecations(text, filePath = "source.js", rules = plu
     .map(({ offset, ...finding }) => finding);
 }
 
-function collectLoadSessionStoreDeprecations(findings, context) {
+function collectSdkHelperDeprecations(findings, context) {
   collectNamedImportDeprecations(findings, context);
   collectNamedReexportDeprecations(findings, context);
   collectNamedRequireDeprecations(findings, context);
   collectNamespaceUsageDeprecations(findings, context);
   collectNamespaceRequireDeprecations(findings, context);
+  collectDynamicImportNamespaceDeprecations(findings, context);
   collectRuntimeUsageDeprecations(findings, context);
   collectRuntimeAliasUsageDeprecations(findings, context);
 }
@@ -43,16 +79,17 @@ function collectNamedImportDeprecations(findings, context) {
     /\bimport\s+(?:type\s+)?(?:[A-Za-z_$][\w$]*\s*,\s*)?{([^}]+)}\s*from\s*["'`]([^"'`]+)["'`]/g;
   for (const match of context.text.matchAll(regex)) {
     const specifier = match[2];
-    if (!loadSessionStoreSpecifiers.has(specifier)) {
+    if (!sdkSessionSpecifiers.has(specifier)) {
       continue;
     }
     for (const binding of parseNamedBindings(match[1])) {
-      if (binding.exported !== "loadSessionStore") {
+      if (!context.rule.symbols.has(binding.exported)) {
         continue;
       }
       findings.push(
         buildFinding(context.rule, {
-          surface: `${specifier} import`,
+          surface: `${specifier} ${binding.exported} import`,
+          symbol: binding.exported,
           sourceText: context.text,
           filePath: context.filePath,
           offset: (match.index ?? 0) + match[0].lastIndexOf(binding.local),
@@ -66,16 +103,17 @@ function collectNamedReexportDeprecations(findings, context) {
   const regex = /\bexport\s*{([^}]+)}\s*from\s*["'`]([^"'`]+)["'`]/g;
   for (const match of context.text.matchAll(regex)) {
     const specifier = match[2];
-    if (!loadSessionStoreSpecifiers.has(specifier)) {
+    if (!sdkSessionSpecifiers.has(specifier)) {
       continue;
     }
     for (const binding of parseNamedBindings(match[1])) {
-      if (binding.exported !== "loadSessionStore") {
+      if (!context.rule.symbols.has(binding.exported)) {
         continue;
       }
       findings.push(
         buildFinding(context.rule, {
-          surface: `${specifier} re-export`,
+          surface: `${specifier} ${binding.exported} re-export`,
+          symbol: binding.exported,
           sourceText: context.text,
           filePath: context.filePath,
           offset: (match.index ?? 0) + match[0].lastIndexOf(binding.local),
@@ -89,16 +127,17 @@ function collectNamedRequireDeprecations(findings, context) {
   const regex = /\b(?:const|let|var)\s+{([^}]+)}\s*=\s*require\(\s*["'`]([^"'`]+)["'`]\s*\)/g;
   for (const match of context.text.matchAll(regex)) {
     const specifier = match[2];
-    if (!loadSessionStoreSpecifiers.has(specifier)) {
+    if (!sdkSessionSpecifiers.has(specifier)) {
       continue;
     }
     for (const binding of parseNamedBindings(match[1], { aliasSeparator: ":" })) {
-      if (binding.exported !== "loadSessionStore") {
+      if (!context.rule.symbols.has(binding.exported)) {
         continue;
       }
       findings.push(
         buildFinding(context.rule, {
-          surface: `${specifier} require`,
+          surface: `${specifier} ${binding.exported} require`,
+          symbol: binding.exported,
           sourceText: context.text,
           filePath: context.filePath,
           offset: (match.index ?? 0) + match[0].lastIndexOf(binding.local),
@@ -109,21 +148,24 @@ function collectNamedRequireDeprecations(findings, context) {
 }
 
 function collectMemberCallDeprecations(findings, context, options) {
-  forEachMethodCall(context.text, "loadSessionStore", (offset) => {
-    // Normalize transparent parentheses and optional-chained member links before matching.
-    const receiver = readNormalizedCallReceiver(context.text, offset);
-    if (!receiver || !options.receiverMatcher(receiver)) {
-      return;
-    }
-    findings.push(
-      buildFinding(context.rule, {
-        surface: options.surface,
-        sourceText: context.text,
-        filePath: context.filePath,
-        offset,
-      }),
-    );
-  });
+  for (const symbol of context.rule.symbols) {
+    forEachMethodCall(context.text, symbol, (offset) => {
+      // Normalize transparent parentheses and optional-chained member links before matching.
+      const receiver = readNormalizedCallReceiver(context.text, offset);
+      if (!receiver || !options.receiverMatcher(receiver)) {
+        return;
+      }
+      findings.push(
+        buildFinding(context.rule, {
+          surface: `${options.surface} ${symbol}`,
+          symbol,
+          sourceText: context.text,
+          filePath: context.filePath,
+          offset,
+        }),
+      );
+    });
+  }
 }
 
 function forEachMethodCall(text, methodName, visit) {
@@ -259,7 +301,11 @@ function isIdentifierBoundary(text, offset) {
 }
 
 function isRuntimeSessionReceiver(receiver) {
-  return /^(?:[A-Za-z_$][A-Za-z0-9_$]*|this)\.runtime\.agent\.session$/.test(receiver);
+  return (
+    /(?:^|\.)(?:[A-Za-z_$][A-Za-z0-9_$]*|this)\.runtime\.agent\.session$/.test(receiver) ||
+    /^(?:runtime|[A-Za-z_$][A-Za-z0-9_$]*Runtime)\.agent\.session$/.test(receiver) ||
+    /^(?:agentRuntime|[A-Za-z_$][A-Za-z0-9_$]*AgentRuntime)\.session$/.test(receiver)
+  );
 }
 
 function collectNamespaceUsageDeprecations(findings, context) {
@@ -267,7 +313,7 @@ function collectNamespaceUsageDeprecations(findings, context) {
   for (const match of context.text.matchAll(regex)) {
     const local = match[1];
     const specifier = match[2];
-    if (!loadSessionStoreSpecifiers.has(specifier)) {
+    if (!sdkSessionSpecifiers.has(specifier)) {
       continue;
     }
     collectMemberCallDeprecations(findings, context, {
@@ -282,7 +328,7 @@ function collectNamespaceRequireDeprecations(findings, context) {
   for (const match of context.text.matchAll(regex)) {
     const local = match[1];
     const specifier = match[2];
-    if (!loadSessionStoreSpecifiers.has(specifier)) {
+    if (!sdkSessionSpecifiers.has(specifier)) {
       continue;
     }
     collectMemberCallDeprecations(findings, context, {
@@ -292,6 +338,22 @@ function collectNamespaceRequireDeprecations(findings, context) {
   }
 }
 
+function collectDynamicImportNamespaceDeprecations(findings, context) {
+  const regex =
+    /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:await\s+)?import\(\s*["'`]([^"'`]+)["'`]\s*\)/g;
+  for (const match of context.text.matchAll(regex)) {
+    const local = match[1];
+    const specifier = match[2];
+    if (!sdkSessionSpecifiers.has(specifier)) {
+      continue;
+    }
+    collectMemberCallDeprecations(findings, context, {
+      receiverMatcher: (receiver) => receiver === local,
+      surface: `${specifier} dynamic import namespace access`,
+    });
+  }
+}
+
 function collectRuntimeUsageDeprecations(findings, context) {
   collectMemberCallDeprecations(findings, context, {
     receiverMatcher: isRuntimeSessionReceiver,
@@ -509,10 +571,11 @@ function buildFinding(rule, details) {
   const refLine = lineForOffset(details.sourceText, details.offset);
   return {
     code: rule.code,
+    symbol: details.symbol,
     surface: details.surface,
     replacement: rule.replacement,
     ref: `${details.filePath}:${refLine}`,
-    message: `loadSessionStore keeps the legacy whole-store session shape; use ${rule.replacement}.`,
+    message: rule.message(details.symbol, rule.replacement),
     offset: details.offset,
   };
 }
@@ -520,7 +583,7 @@ function buildFinding(rule, details) {
 function uniqueFindings(findings) {
   const byKey = new Map();
   for (const finding of findings) {
-    byKey.set(`${finding.code}:${finding.surface}:${finding.ref}`, finding);
+    byKey.set(`${finding.code}:${finding.symbol}:${finding.surface}:${finding.ref}`, finding);
   }
   return [...byKey.values()];
 }

package/src/sdk-mock.js

@@ -968,11 +968,11 @@ function createSchema(defaultValue, shape) {
     },
   };
   return new Proxy(schema, {
-    get(target, property) {
+    get(target, property, receiver) {
       if (property in target) {
         return target[property];
       }
-      return () => target;
+      return () => receiver;
     },
   });
 }

package/src/synthetic-probes.js

@@ -236,6 +236,11 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "session actions are captured as registration metadata before session runtime execution",
   },
+  registerSessionCatalog: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "session catalogs are captured as registration metadata before catalog runtime execution",
+  },
   registerService: {
     mode: "lifecycle-opt-in",
     callableProperties: ["start", "stop", "dispose"],
@@ -591,23 +596,37 @@ export async function runCapturedSyntheticProbes(capture, options = {}) {
   const hookContexts = options.hookContexts ?? defaultSyntheticHookContexts;
   const captured = capture.captured ?? [];
   const retained = new Map((capture.retained ?? []).map((item) => [item.captureIndex, item]));
-  const results = [];
+  const resultsByCaptureIndex = new Map();
+  const executionEntries = captured
+    .map((entry, captureIndex) => ({ entry, captureIndex }))
+    .sort(
+      (left, right) =>
+        syntheticLifecyclePhase(left.entry) - syntheticLifecyclePhase(right.entry) ||
+        left.captureIndex - right.captureIndex,
+    );
 
-  for (let index = 0; index < captured.length; index += 1) {
-    const entry = captured[index];
-    const retainedEntry = retained.get(index);
+  for (const { entry, captureIndex } of executionEntries) {
+    const retainedEntry = retained.get(captureIndex);
     if (!retainedEntry) {
-      results.push(blockedResult(entry, index, "handler retention was not enabled"));
+      resultsByCaptureIndex.set(captureIndex, [blockedResult(entry, captureIndex, "handler retention was not enabled")]);
       continue;
     }
     if (entry.kind === "hook") {
-      results.push(await runHookProbe(entry, retainedEntry, index, { hookEvents, hookContexts }));
+      resultsByCaptureIndex.set(captureIndex, [
+        await runHookProbe(entry, retainedEntry, captureIndex, { hookEvents, hookContexts }),
+      ]);
       continue;
     }
     if (entry.kind === "registration") {
-      results.push(...(await runRegistrationProbes(entry, retainedEntry, index, options)));
+      resultsByCaptureIndex.set(
+        captureIndex,
+        await runRegistrationProbes(entry, retainedEntry, captureIndex, options),
+      );
     }
   }
+  // Execute in lifecycle order, but keep report rows and captureIndex values
+  // stable for downstream consumers that compare artifacts across runs.
+  const results = captured.flatMap((_, captureIndex) => resultsByCaptureIndex.get(captureIndex) ?? []);
 
   return {
     entrypoint: capture.entrypoint,
@@ -622,6 +641,19 @@ export async function runCapturedSyntheticProbes(capture, options = {}) {
   };
 }
 
+function syntheticLifecyclePhase(entry) {
+  if (entry.kind !== "hook") {
+    return 1;
+  }
+  if (entry.name === "gateway_start") {
+    return 0;
+  }
+  if (entry.name === "gateway_stop") {
+    return 2;
+  }
+  return 1;
+}
+
 export function renderSyntheticProbeMarkdown(plan, options = {}) {
   return [
     `# ${options.title ?? "Plugin Inspector Synthetic Probes"}`,

package/src/workspace-plan.js

@@ -241,9 +241,10 @@ async function buildEntrypointPlan({ fixtureId, entrypoint, packageSummary, pack
   });
 
   if (requiredCapabilities.includes("target-openclaw-link")) {
+    const targetSpecifier = `file:${targetOpenClawWorkspacePath(settings, fixtureId, targetOpenClawPath)}`;
     steps.push({
       kind: "link-openclaw",
-      command: `${shellQuote(packageManager)} pkg set ${shellQuote(`dependencies.openclaw=file:${targetOpenClawWorkspacePath(settings, fixtureId, targetOpenClawPath)}`)}`,
+      command: `node ${shellQuote(helperScript(settings, workspacePath, settings.linkOpenClawWorkspaceScript, "link-openclaw-workspace-cli.js"))} ${shellQuote(targetSpecifier)}`,
       cwd: workspacePath,
       reason: "link the plugin's openclaw peer dependency to the target checkout under test",
     });
@@ -325,6 +326,7 @@ function workspaceSettings(options) {
   return {
     captureScript: options.captureScript ?? defaultWorkspacePlanOptions.captureScript,
     defaultTargetOpenClawWorkspacePath: options.defaultTargetOpenClawWorkspacePath ?? "../../../openclaw",
+    linkOpenClawWorkspaceScript: options.linkOpenClawWorkspaceScript,
     optInEnv: options.optInEnv ?? defaultWorkspacePlanOptions.optInEnv,
     resultsRoot: repoRelative(options.resultsRoot ?? defaultWorkspacePlanOptions.resultsRoot),
     rootDir: path.resolve(options.rootDir ?? process.cwd()),