@kb-labs/cli-commands 2.89.0 → 2.94.0

package/dist/registry/index.d.ts

@@ -1,5 +1,5 @@
-import { d as CommandManifest, A as AvailabilityCheck, R as RegisteredCommand, D as DiscoveryResult } from '../discover-Cz7X5bQp.js';
-export { b as CacheFile, c as CommandLookupResult, e as CommandModule, f as CommandType, F as FlagDefinition, G as GlobalFlags, g as PackageCacheEntry, P as ProductGroup, _ as __test, h as discoverManifests, i as discoverManifestsByNamespace, j as findCommand, k as findCommandWithType, r as registry, l as resetInProcCache } from '../discover-Cz7X5bQp.js';
+import { d as CommandManifest, A as AvailabilityCheck, R as RegisteredCommand, l as CommandRegistry, D as DiscoveryResult } from '../discover-CCE84_5E.js';
+export { b as CacheFile, c as CommandLookupResult, e as CommandModule, f as CommandType, F as FlagDefinition, G as GlobalFlags, g as PackageCacheEntry, P as ProductGroup, _ as __test, h as discoverManifests, i as discoverManifestsByNamespace, j as findCommand, k as findCommandWithType, r as registry, m as resetInProcCache } from '../discover-CCE84_5E.js';
 import { ILogger } from '@kb-labs/core-platform';
 import '@kb-labs/plugin-contracts';
 
@@ -47,14 +47,13 @@ declare function preflightManifests(discoveryResults: DiscoveryResult[], logger?
 /**
  * Register manifests with shadowing and collision detection
  */
-declare function registerManifests(discoveryResults: DiscoveryResult[], registry: any, // CommandRegistry interface
-options?: RegisterManifestsOptions & {
+declare function registerManifests(discoveryResults: DiscoveryResult[], registry: CommandRegistry, options?: RegisterManifestsOptions & {
     logger?: ILogger;
 }): Promise<ManifestRegistrationResult>;
 /**
  * Dispose all plugins by calling their dispose hooks
  */
-declare function disposeAllPlugins(registry: any, logger?: ILogger): Promise<void>;
+declare function disposeAllPlugins(registry: CommandRegistry, logger?: ILogger): Promise<void>;
 
 /**
  * Execute a registered command.
@@ -62,6 +61,6 @@ declare function disposeAllPlugins(registry: any, logger?: ILogger): Promise<voi
  * - Unavailable commands return exit code 2.
  * - Available commands are executed via manifest.loader().
  */
-declare function runCommand(cmd: RegisteredCommand, ctx: any, argv: string[], flags: Record<string, any>): Promise<number>;
+declare function runCommand(cmd: RegisteredCommand, ctx: Record<string, unknown>, argv: string[], flags: Record<string, unknown>): Promise<number>;
 
 export { AvailabilityCheck, type CheckRequiresOptions, CommandManifest, DiscoveryResult, type ManifestRegistrationResult, type RegisterManifestsOptions, RegisteredCommand, type SkippedManifest, checkRequires, disposeAllPlugins, preflightManifests, registerManifests, runCommand };

package/dist/registry/index.js

@@ -68,7 +68,7 @@ function checkRequires(manifest, options = {}) {
       if (isInMonorepo) {
         continue;
       }
-      const errorMessage = err.message || "";
+      const errorMessage = (err instanceof Error ? err.message : "") || "";
       const hasExportsError = errorMessage.includes("exports") || errorMessage.includes("main");
       if (hasExportsError || errorMessage.includes("Cannot resolve")) {
         const parts = dep.startsWith("@") ? dep.slice(1).split("/") : [dep];
@@ -251,7 +251,7 @@ var __test = {
   // resetInProcCache is exported directly (not via __test) since it's part of the public API
 };
 function createUnavailableManifest(pkgName, error) {
-  const rawMsg = (error?.message || String(error) || "").toString();
+  const rawMsg = (error instanceof Error ? error.message : String(error) || "").toString();
   let missing = null;
   const m1 = rawMsg.match(/Cannot find (?:module|package) '([^']+)'/);
   const m2 = rawMsg.match(/from ['"]([^'"]+)['"]/);
@@ -272,9 +272,13 @@ function createUnavailableManifest(pkgName, error) {
     requires,
     loader: async () => {
       throw new Error(`Cannot load ${pkgName} CLI manifest. ${rawMsg}`);
-    }
+    },
+    // Mark as synthetic so saveCache can skip it — synthetic manifests must never
+    // be persisted to disk because they represent transient load failures.
+    // Caching them would make the error "stick" until the TTL expires even after
+    // the underlying problem (missing build artifact, broken dep) is resolved.
+    _synthetic: true
   };
-  manifest._synthetic = true;
   return manifest;
 }
 var PACKAGE_JSON = "package.json";
@@ -365,7 +369,7 @@ async function detectNewWorkspacePackages(cwd, cachedPackages) {
       }
     }
   } catch (error) {
-    log("debug", `[plugins][cache] Workspace scan skipped: ${error?.message || "unknown error"}`);
+    log("debug", `[plugins][cache] Workspace scan skipped: ${error instanceof Error ? error.message : "unknown error"}`);
   }
   return false;
 }
@@ -376,7 +380,7 @@ async function loadManifestWithTimeout(manifestPath, pkgName, pkgRoot) {
   try {
     return await Promise.race([loadManifest(manifestPath, pkgName, pkgRoot), timeout]);
   } catch (err) {
-    if (err.message === "Timeout") {
+    if (err instanceof Error && err.message === "Timeout") {
       log("warn", `Timeout loading manifest from ${pkgName}`);
       return [];
     }
@@ -396,10 +400,12 @@ function getNamespaceFromManifest(manifestV2, packageName) {
 async function loadManifest(manifestPath, pkgName, pkgRoot) {
   const fileUrl = pathToFileURL(manifestPath).href;
   const mod = await import(fileUrl);
-  const manifest = mod.manifest || mod.default;
-  if (!manifest || typeof manifest !== "object" || manifest.schema !== "kb.plugin/3") {
+  const modTyped = mod;
+  const rawManifest = modTyped.manifest || modTyped.default;
+  if (!rawManifest || typeof rawManifest !== "object" || rawManifest.schema !== "kb.plugin/3") {
     throw new Error(`Unsupported manifest format in ${pkgName}. Only kb.plugin/3 schema is supported.`);
   }
+  const manifest = rawManifest;
   const namespace = getNamespaceFromManifest(manifest, pkgName);
   const manifestDir = path2.dirname(manifestPath);
   const baseRoot = pkgRoot || manifestDir;
@@ -461,8 +467,9 @@ async function loadConfig(cwd) {
   }
 }
 async function findManifestPath(pkgRoot, pkg) {
-  if (pkg.kb?.manifest) {
-    const manifestPath = path2.join(pkgRoot, pkg.kb.manifest);
+  const kb = pkg.kb;
+  if (kb?.manifest) {
+    const manifestPath = path2.join(pkgRoot, kb.manifest);
     try {
       await promises.access(manifestPath);
       return { path: manifestPath, deprecated: false };
@@ -470,8 +477,9 @@ async function findManifestPath(pkgRoot, pkg) {
       return { path: null, deprecated: false };
     }
   }
-  if (pkg.exports?.["./kb/commands"]) {
-    const exportPath = pkg.exports["./kb/commands"];
+  const exports$1 = pkg.exports;
+  if (exports$1?.["./kb/commands"]) {
+    const exportPath = exports$1["./kb/commands"];
     const manifestPath = typeof exportPath === "string" ? exportPath : exportPath.default || exportPath.import;
     if (manifestPath) {
       const resolved = path2.resolve(pkgRoot, manifestPath);
@@ -575,20 +583,21 @@ async function discoverProjectLocalPlugins(projectRoot) {
 }
 async function loadManifestsForPackages(packageInfos, source, scope) {
   const loadPromises = packageInfos.map(async ({ pkgRoot, pkg, manifestPath }) => {
+    const pkgName = pkg.name;
     const pkgStart = Date.now();
     try {
-      const manifests = await loadManifestWithTimeout(manifestPath, pkg.name, pkgRoot);
+      const manifests = await loadManifestWithTimeout(manifestPath, pkgName, pkgRoot);
       const pkgTime = Date.now() - pkgStart;
       if (pkgTime > 30) {
-        log("debug", `[plugins][perf] ${pkg.name} manifest parse: ${pkgTime}ms (budget: 30ms)`);
+        log("debug", `[plugins][perf] ${pkgName} manifest parse: ${pkgTime}ms (budget: 30ms)`);
       }
       if (manifests.length > 0) {
-        validateUniqueIds(manifests, pkg.name);
+        validateUniqueIds(manifests, pkgName);
         return {
           manifests,
           source,
           scope,
-          packageName: pkg.name,
+          packageName: pkgName,
           manifestPath: toPosixPath(manifestPath),
           pkgRoot: toPosixPath(pkgRoot)
         };
@@ -596,21 +605,23 @@ async function loadManifestsForPackages(packageInfos, source, scope) {
       return null;
     } catch (err) {
       const pkgTime = Date.now() - pkgStart;
-      log("debug", `[plugins][perf] ${pkg.name} failed after ${pkgTime}ms`);
+      log("debug", `[plugins][perf] ${pkgName} failed after ${pkgTime}ms`);
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const errCode = err.code ?? "UNKNOWN";
       log("warn", JSON.stringify({
         code: "DISCOVERY_MANIFEST_LOAD_FAIL",
-        packageName: pkg.name,
+        packageName: pkgName,
         manifestPath: toPosixPath(manifestPath),
-        errorCode: err.code || "UNKNOWN",
-        errorMessage: err.message,
-        hint: err.message.includes("Cannot find package") ? "Run: kb devlink apply && pnpm -w build" : "Check manifest syntax and dependencies"
+        errorCode: errCode,
+        errorMessage: errMsg,
+        hint: errMsg.includes("Cannot find package") ? "Run: kb devlink apply && pnpm -w build" : "Check manifest syntax and dependencies"
       }));
-      const synthetic = createUnavailableManifest(pkg.name, err);
+      const synthetic = createUnavailableManifest(pkgName, err);
       return {
         manifests: [synthetic],
         source,
         scope,
-        packageName: pkg.name,
+        packageName: pkgName,
         manifestPath: toPosixPath(manifestPath),
         pkgRoot: toPosixPath(pkgRoot)
       };
@@ -631,29 +642,30 @@ async function discoverCurrentPackage(cwd) {
     if (!pkg) {
       return null;
     }
+    const pkgName = pkg.name;
     const manifestInfo = await findManifestPath(cwd, pkg);
     if (manifestInfo.path) {
       if (manifestInfo.deprecated) {
-        log("warn", `[DEPRECATED] ${pkg.name} uses legacy manifest path: ${manifestInfo.path}`);
+        log("warn", `[DEPRECATED] ${pkgName} uses legacy manifest path: ${manifestInfo.path}`);
         log("warn", `  \u2192 Migrate to exports["./kb/commands"] or set kb.commandsManifest in package.json`);
       }
-      const manifests = await loadManifestWithTimeout(manifestInfo.path, pkg.name, cwd);
+      const manifests = await loadManifestWithTimeout(manifestInfo.path, pkgName, cwd);
       if (manifests.length > 0) {
-        validateUniqueIds(manifests, pkg.name);
+        validateUniqueIds(manifests, pkgName);
         return {
           manifests,
           source: "workspace",
           // Current-package fallback fires in installed mode when the user's
           // project itself exposes a manifest. That maps to the project scope.
           scope: "project",
-          packageName: pkg.name,
+          packageName: pkgName,
           manifestPath: toPosixPath(manifestInfo.path),
           pkgRoot: toPosixPath(cwd)
         };
       }
     }
   } catch (err) {
-    log("debug", `No CLI manifest in current package: ${err.message}`);
+    log("debug", `No CLI manifest in current package: ${err instanceof Error ? err.message : String(err)}`);
   }
   return null;
 }
@@ -670,7 +682,7 @@ async function discoverNodeModules(cwd) {
       }
       const scanEntry = async () => {
         let pkgRoot;
-        let pkg;
+        let pkg = null;
         if (entry.name.startsWith("@")) {
           const scopeDir = path2.join(nmDir, entry.name);
           try {
@@ -681,29 +693,30 @@ async function discoverNodeModules(cwd) {
               if (!pkg) {
                 continue;
               }
+              const scopedPkgName = pkg.name;
               const isPlugin = isPluginPackage(pkg);
-              if (pkg.name?.startsWith("@kb-labs/")) {
+              if (scopedPkgName?.startsWith("@kb-labs/")) {
                 const manifestInfo = await findManifestPath(pkgRoot, pkg);
                 if (manifestInfo.path) {
                   packageInfos.push({ pkgRoot, pkg, manifestPath: manifestInfo.path });
                 }
               } else if (isPlugin) {
-                if (config.block?.includes(pkg.name)) {
-                  log("debug", `Plugin ${pkg.name} blocked by config`);
+                if (config.block?.includes(scopedPkgName ?? "")) {
+                  log("debug", `Plugin ${scopedPkgName} blocked by config`);
                   return;
                 }
-                const isAllowlisted = config.allow?.includes(pkg.name) || config.linked?.includes(pkg.name);
+                const isAllowlisted = config.allow?.includes(scopedPkgName ?? "") || config.linked?.includes(scopedPkgName ?? "");
                 if (!isAllowlisted) {
-                  log("debug", `Plugin ${pkg.name} skipped (not allowlisted). Add to kb-labs.config.json plugins.allow or enable via 'kb marketplace enable'`);
+                  log("debug", `Plugin ${scopedPkgName} skipped (not allowlisted). Add to kb-labs.config.json plugins.allow or enable via 'kb marketplace enable'`);
                   return;
                 }
                 const manifestInfo = await findManifestPath(pkgRoot, pkg);
                 if (manifestInfo.path) {
                   if (manifestInfo.deprecated) {
-                    log("warn", `[DEPRECATED] ${pkg.name} uses legacy manifest path: ${manifestInfo.path}`);
+                    log("warn", `[DEPRECATED] ${scopedPkgName} uses legacy manifest path: ${manifestInfo.path}`);
                     log("warn", `  \u2192 Migrate to exports["./kb/commands"] or set kb.commandsManifest in package.json`);
                   }
-                  const isLinked = config.linked?.includes(pkg.name);
+                  const isLinked = config.linked?.includes(scopedPkgName ?? "");
                   packageInfos.push({ pkgRoot, pkg, manifestPath: manifestInfo.path, isLinked });
                 }
               }
@@ -716,24 +729,25 @@ async function discoverNodeModules(cwd) {
           if (!pkg) {
             return;
           }
+          const unscopedPkgName = pkg.name;
           const isPlugin = isPluginPackage(pkg);
           if (isPlugin) {
-            if (config.block?.includes(pkg.name)) {
-              log("debug", `Plugin ${pkg.name} blocked by config`);
+            if (config.block?.includes(unscopedPkgName ?? "")) {
+              log("debug", `Plugin ${unscopedPkgName} blocked by config`);
               return;
             }
-            const isAllowlisted = config.allow?.includes(pkg.name) || config.linked?.includes(pkg.name);
+            const isAllowlisted = config.allow?.includes(unscopedPkgName ?? "") || config.linked?.includes(unscopedPkgName ?? "");
             if (!isAllowlisted) {
-              log("debug", `Plugin ${pkg.name} skipped (not allowlisted). Add to kb-labs.config.json plugins.allow or enable via 'kb marketplace enable'`);
+              log("debug", `Plugin ${unscopedPkgName} skipped (not allowlisted). Add to kb-labs.config.json plugins.allow or enable via 'kb marketplace enable'`);
               return;
             }
             const manifestInfo = await findManifestPath(pkgRoot, pkg);
             if (manifestInfo.path) {
               if (manifestInfo.deprecated) {
-                log("warn", `[DEPRECATED] ${pkg.name} uses legacy manifest path: ${manifestInfo.path}`);
+                log("warn", `[DEPRECATED] ${unscopedPkgName} uses legacy manifest path: ${manifestInfo.path}`);
                 log("warn", `  \u2192 Migrate to exports["./kb/commands"] or set kb.commandsManifest in package.json`);
               }
-              const isLinked = config.linked?.includes(pkg.name);
+              const isLinked = config.linked?.includes(unscopedPkgName ?? "");
               packageInfos.push({ pkgRoot, pkg, manifestPath: manifestInfo.path, isLinked });
             }
           }
@@ -743,10 +757,11 @@ async function discoverNodeModules(cwd) {
     }
     await Promise.allSettled(scanPromises);
     const loadPromises = packageInfos.map(async ({ pkgRoot, pkg, manifestPath, isLinked }) => {
+      const pkgName = pkg.name;
       try {
-        const manifests = await loadManifestWithTimeout(manifestPath, pkg.name, pkgRoot);
+        const manifests = await loadManifestWithTimeout(manifestPath, pkgName, pkgRoot);
         if (manifests.length > 0) {
-          validateUniqueIds(manifests, pkg.name);
+          validateUniqueIds(manifests, pkgName);
           return {
             manifests,
             source: isLinked ? "linked" : "node_modules",
@@ -754,27 +769,29 @@ async function discoverNodeModules(cwd) {
             // platformRoot === projectRoot so either label is correct; we use
             // platform to reflect where the manifest physically lives.
             scope: "platform",
-            packageName: pkg.name,
+            packageName: pkgName,
             manifestPath: toPosixPath(manifestPath),
             pkgRoot: toPosixPath(pkgRoot)
           };
         }
         return null;
       } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        const errCode = err.code ?? "UNKNOWN";
         log("warn", JSON.stringify({
           code: "DISCOVERY_MANIFEST_LOAD_FAIL",
-          packageName: pkg.name,
+          packageName: pkgName,
           manifestPath: toPosixPath(manifestPath),
-          errorCode: err.code || "UNKNOWN",
-          errorMessage: err.message,
-          hint: err.message.includes("Cannot find package") ? "Run: kb devlink apply && pnpm -w build" : "Check manifest syntax and dependencies"
+          errorCode: errCode,
+          errorMessage: errMsg,
+          hint: errMsg.includes("Cannot find package") ? "Run: kb devlink apply && pnpm -w build" : "Check manifest syntax and dependencies"
         }));
-        const synthetic = createUnavailableManifest(pkg.name, err);
+        const synthetic = createUnavailableManifest(pkgName, err);
         return {
           manifests: [synthetic],
           source: isLinked ? "linked" : "node_modules",
           scope: "platform",
-          packageName: pkg.name,
+          packageName: pkgName,
           manifestPath: toPosixPath(manifestPath),
           pkgRoot: toPosixPath(pkgRoot)
         };
@@ -789,7 +806,7 @@ async function discoverNodeModules(cwd) {
     }
     return results;
   } catch (err) {
-    log("debug", `Could not scan node_modules: ${err.message}`);
+    log("debug", `Could not scan node_modules: ${err instanceof Error ? err.message : String(err)}`);
     return [];
   }
 }
@@ -813,14 +830,14 @@ function deduplicateManifests(all) {
         byPackageName.set(result.packageName, projectEntry);
         continue;
       }
-      const winner = existing.scope === "platform" ? existing : result;
-      const loser = existing.scope === "platform" ? result : existing;
-      log("warn", JSON.stringify({
-        code: "DISCOVERY_SCOPE_COLLISION",
+      const winner = existing.scope === "project" ? existing : result;
+      const loser = existing.scope === "project" ? result : existing;
+      log("debug", JSON.stringify({
+        code: "DISCOVERY_SCOPE_OVERRIDE",
         packageName: result.packageName,
-        platformPath: winner.pkgRoot,
-        projectPath: loser.pkgRoot,
-        message: "Package exists in both platform and project scopes \u2014 platform wins."
+        projectPath: winner.pkgRoot,
+        platformPath: loser.pkgRoot,
+        message: "Package exists in both platform and project scopes \u2014 project wins."
       }));
       byPackageName.set(result.packageName, winner);
       continue;
@@ -913,7 +930,7 @@ async function isPackageCacheStale(entry, options) {
       return true;
     }
   } catch (error) {
-    log("debug", `Package cache invalidated: missing package.json for ${entry.result.packageName} (${error?.message || "unknown"})`);
+    log("debug", `Package cache invalidated: missing package.json for ${entry.result.packageName} (${error instanceof Error ? error.message : "unknown"})`);
     return true;
   }
   let manifestStat;
@@ -924,7 +941,7 @@ async function isPackageCacheStale(entry, options) {
       return true;
     }
   } catch (error) {
-    log("debug", `Package cache invalidated: manifest deleted for ${entry.result.packageName} (${error?.message || "unknown"})`);
+    log("debug", `Package cache invalidated: manifest deleted for ${entry.result.packageName} (${error instanceof Error ? error.message : "unknown"})`);
     return true;
   }
   if (options.validateHash) {
@@ -935,7 +952,7 @@ async function isPackageCacheStale(entry, options) {
         return true;
       }
     } catch (error) {
-      log("debug", `Package cache hash validation failed for ${entry.result.packageName}: ${error?.message || "unknown"}`);
+      log("debug", `Package cache hash validation failed for ${entry.result.packageName}: ${error instanceof Error ? error.message : "unknown"}`);
       return true;
     }
   }
@@ -981,7 +998,7 @@ async function saveCache(cwd, results, roots) {
       stateHasher.update(result.packageName);
       stateHasher.update(manifestHash);
     } catch (err) {
-      log("debug", `Failed to cache package ${result.packageName}: ${err.message}`);
+      log("debug", `Failed to cache package ${result.packageName}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   const lockfileHash = await computeLockfileHash(cwd);
@@ -1024,7 +1041,7 @@ async function saveCache(cwd, results, roots) {
   try {
     await promises.writeFile(cachePath, JSON.stringify(cache), "utf8");
   } catch (err) {
-    log("debug", `Failed to save cache: ${err.message}`);
+    log("debug", `Failed to save cache: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 async function discoverManifests(cwd, noCache = false, options = {}) {
@@ -1117,8 +1134,21 @@ async function discoverManifests(cwd, noCache = false, options = {}) {
   if (projectLocal.length > 0) {
     log("info", `Discovered ${projectLocal.length} project-local plugins`);
   }
+  let projectWorkspace = [];
+  if (roots.projectRoot !== roots.platformRoot) {
+    try {
+      const pwStart = Date.now();
+      const raw = await discoverWorkspace(roots.projectRoot);
+      projectWorkspace = raw.map((r) => ({ ...r, scope: "project" }));
+      timings.projectWorkspace = Date.now() - pwStart;
+      if (projectWorkspace.length > 0) {
+        log("info", `Discovered ${projectWorkspace.length} project workspace packages with CLI manifests`);
+      }
+    } catch {
+    }
+  }
   const dedupStart = Date.now();
-  const results = deduplicateManifests([...workspace, ...installed, ...projectLocal]);
+  const results = deduplicateManifests([...workspace, ...installed, ...projectLocal, ...projectWorkspace]);
   timings.deduplicate = Date.now() - dedupStart;
   const saveStart = Date.now();
   await saveCache(cwd, results, roots);
@@ -1293,7 +1323,7 @@ function preflightManifests(discoveryResults, logger) {
         validateManifestStructure(manifest);
         allowed.push(manifest);
       } catch (error) {
-        const reason = error?.message ? String(error.message) : "Validation failed";
+        const reason = error instanceof Error ? error.message : "Validation failed";
         const manifestId = manifest?.id || manifest?.group || result.packageName || "unknown";
         skipped.push({
           id: manifestId,
@@ -1338,7 +1368,7 @@ async function registerManifests(discoveryResults, registry2, options = {}) {
         try {
           validateManifestStructure(manifest);
         } catch (err) {
-          throw new Error(`Validation failed: ${err.message}`);
+          throw new Error(`Validation failed: ${err instanceof Error ? err.message : String(err)}`);
         }
         const normalizedId = normalizeCommandId(manifest.id, namespace);
         if (normalizedId !== manifest.id) {
@@ -1385,7 +1415,8 @@ async function registerManifests(discoveryResults, registry2, options = {}) {
             cmd._disposeHook = manifestModule.dispose;
           }
         } catch (hookError) {
-          log2.debug(`Lifecycle hooks unavailable for ${manifest.id}: ${hookError.message}`);
+          const hookMsg = hookError instanceof Error ? hookError.message : String(hookError);
+          log2.debug(`Lifecycle hooks unavailable for ${manifest.id}: ${hookMsg}`);
         }
         const canonicalKey = manifest.group ? `${manifest.group}:${manifest.id}` : manifest.id;
         const existing = globalIds.get(canonicalKey);
@@ -1455,7 +1486,7 @@ async function registerManifests(discoveryResults, registry2, options = {}) {
         registered.push(cmd);
       } catch (error) {
         errors++;
-        const reason = error?.message ? String(error.message) : String(error);
+        const reason = error instanceof Error ? error.message : String(error);
         skipped.push({
           id: manifestId,
           source: result.source,
@@ -1487,11 +1518,9 @@ async function disposeAllPlugins(registry2, logger) {
     const disposeHook = cmd._disposeHook;
     if (disposeHook && typeof disposeHook === "function") {
       disposePromises.push(
-        Promise.resolve(disposeHook({
-          registry: registry2,
-          command: cmd
-        })).catch((err) => {
-          log2.warn(`Dispose hook failed for ${cmd.manifest.id}: ${err.message}`);
+        Promise.resolve(disposeHook()).catch((err) => {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          log2.warn(`Dispose hook failed for ${cmd.manifest.id}: ${errMsg}`);
         })
       );
     }
@@ -1502,8 +1531,9 @@ async function disposeAllPlugins(registry2, logger) {
 // src/registry/run.ts
 async function runCommand(cmd, ctx, argv, flags) {
   if (!cmd.available) {
-    if (ctx.presenter?.json) {
-      ctx.presenter.json({
+    const presenter = ctx.presenter;
+    if (presenter?.json) {
+      presenter.json({
         ok: false,
         available: false,
         command: cmd.manifest.id,