@kb-labs/cli-commands 2.89.0 → 2.94.0

package/dist/index.js

@@ -185,7 +185,7 @@ function ensureManifestLoader(manifest) {
   }
 }
 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 ['"]([^'"]+)['"]/);
@@ -206,9 +206,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;
 }
 function resetInProcCache() {
@@ -294,7 +298,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;
 }
@@ -305,7 +309,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 [];
     }
@@ -325,10 +329,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 = path.dirname(manifestPath);
   const baseRoot = pkgRoot || manifestDir;
@@ -390,8 +396,9 @@ async function loadConfig(cwd) {
   }
 }
 async function findManifestPath(pkgRoot, pkg) {
-  if (pkg.kb?.manifest) {
-    const manifestPath = path.join(pkgRoot, pkg.kb.manifest);
+  const kb = pkg.kb;
+  if (kb?.manifest) {
+    const manifestPath = path.join(pkgRoot, kb.manifest);
     try {
       await promises.access(manifestPath);
       return { path: manifestPath, deprecated: false };
@@ -399,8 +406,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 = path.resolve(pkgRoot, manifestPath);
@@ -504,20 +512,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)
         };
@@ -525,21 +534,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)
       };
@@ -560,29 +571,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;
 }
@@ -599,7 +611,7 @@ async function discoverNodeModules(cwd) {
       }
       const scanEntry = async () => {
         let pkgRoot;
-        let pkg;
+        let pkg = null;
         if (entry.name.startsWith("@")) {
           const scopeDir = path.join(nmDir, entry.name);
           try {
@@ -610,29 +622,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 });
                 }
               }
@@ -645,24 +658,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 });
             }
           }
@@ -672,10 +686,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",
@@ -683,27 +698,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)
         };
@@ -718,7 +735,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 [];
   }
 }
@@ -742,14 +759,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;
@@ -842,7 +859,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;
@@ -853,7 +870,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) {
@@ -864,7 +881,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;
     }
   }
@@ -910,7 +927,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);
@@ -953,7 +970,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 = {}) {
@@ -1046,8 +1063,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);
@@ -1773,11 +1803,12 @@ var diag = defineSystemCommand({
         }
       });
     } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
       diagnostics.push({
         category: "marketplace",
         status: "error",
-        message: `Discovery failed: ${err.message}`,
-        details: { error: err.message }
+        message: `Discovery failed: ${errMsg}`,
+        details: { error: errMsg }
       });
     }
     try {
@@ -1806,11 +1837,12 @@ var diag = defineSystemCommand({
         });
       }
     } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
       diagnostics.push({
         category: "cache",
         status: "warning",
-        message: `Cache check failed: ${err.message}`,
-        details: { error: err.message }
+        message: `Cache check failed: ${errMsg}`,
+        details: { error: errMsg }
       });
     }
     try {
@@ -1833,11 +1865,12 @@ var diag = defineSystemCommand({
         });
       }
     } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
       diagnostics.push({
         category: "marketplace-lock",
         status: "error",
-        message: `Marketplace lock check failed: ${err.message}`,
-        details: { error: err.message }
+        message: `Marketplace lock check failed: ${errMsg}`,
+        details: { error: errMsg }
       });
     }
     const versionIssues = [];
@@ -1877,11 +1910,12 @@ var diag = defineSystemCommand({
         });
       }
     } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
       diagnostics.push({
         category: "versions",
         status: "error",
-        message: `Version check failed: ${err.message}`,
-        details: { error: err.message }
+        message: `Version check failed: ${errMsg}`,
+        details: { error: errMsg }
       });
     }
     const summary = {
@@ -1915,7 +1949,7 @@ var diag = defineSystemCommand({
         const icon = diag2.status === "ok" ? safeSymbols.success : diag2.status === "warning" ? safeSymbols.warning : safeSymbols.error;
         const colorize = diag2.status === "ok" ? safeColors.success : diag2.status === "warning" ? safeColors.warning : safeColors.error;
         diagItems.push(`${icon} ${colorize(safeColors.bold(diag2.category))}: ${diag2.message}`);
-        if (diag2.status === "warning" && diag2.details?.issues) {
+        if (diag2.status === "warning" && Array.isArray(diag2.details?.issues)) {
           for (const issue of diag2.details.issues) {
             diagItems.push(
               `   ${safeColors.warning(`\u2192 ${issue.plugin}: requires ${issue.required}, found ${issue.current}`)}`
@@ -2492,44 +2526,42 @@ var logsDiagnose = defineSystemCommand({
       ctx.ui.error("Log Diagnose", { sections: [{ header: "Error", items: [result.error ?? "Unknown"] }] });
       return;
     }
-    const data = result;
-    const { summary, topErrors, bySource, period } = data;
+    const { summary, topErrors, bySource, period } = result;
     const summaryItems = [
-      `Period: ${period.from} to ${period.to}`,
-      `Total logs: ${summary.total}`,
-      `Errors: ${summary.errors}`,
-      `Warnings: ${summary.warnings}`,
-      `Sources: ${summary.sources.join(", ") || "none"}`
+      `Period: ${period?.from ?? "?"} to ${period?.to ?? "?"}`,
+      `Total logs: ${summary?.total ?? 0}`,
+      `Errors: ${summary?.errors ?? 0}`,
+      `Warnings: ${summary?.warnings ?? 0}`,
+      `Sources: ${summary?.sources.join(", ") || "none"}`
     ];
     const sections = [
       { header: "Summary", items: summaryItems }
     ];
-    if (topErrors.length > 0) {
+    if ((topErrors?.length ?? 0) > 0) {
       sections.push({
         header: "Top Errors",
-        items: topErrors.slice(0, 5).map(
+        items: (topErrors ?? []).slice(0, 5).map(
           (e, i) => `${i + 1}. "${e.message}" (${e.count}x) [${e.source}]`
         )
       });
     }
     const sourceItems = [];
-    for (const [src, breakdown] of Object.entries(bySource)) {
-      const b = breakdown;
-      if (b.errors > 0 || b.warnings > 0) {
-        sourceItems.push(`${src}: ${b.errors} errors, ${b.warnings} warnings`);
+    for (const [src, breakdown] of Object.entries(bySource ?? {})) {
+      if (breakdown.errors > 0 || breakdown.warnings > 0) {
+        sourceItems.push(`${src}: ${breakdown.errors} errors, ${breakdown.warnings} warnings`);
       }
     }
     if (sourceItems.length > 0) {
       sections.push({ header: "By Source", items: sourceItems });
     }
-    if (summary.errors === 0 && summary.warnings === 0) {
+    if ((summary?.errors ?? 0) === 0 && (summary?.warnings ?? 0) === 0) {
       ctx.ui.success("Log Diagnosis", { sections });
-    } else if (summary.errors > 0) {
+    } else if ((summary?.errors ?? 0) > 0) {
       ctx.ui.error("Log Diagnosis", { sections });
     } else {
       ctx.ui.warn("Log Diagnosis", { sections });
     }
-    const raw = data._raw;
+    const raw = result._raw ?? [];
     const errorLogs = raw.filter((l) => l.level === "error" || l.level === "fatal").slice(0, 5);
     if (errorLogs.length > 0) {
       ctx.ui.write("\nRecent Errors:\n");
@@ -2610,8 +2642,9 @@ var logsContext = defineSystemCommand({
     };
   },
   formatter(result, ctx, flags) {
+    const data = result;
     if (flags.json) {
-      const { _raw, ...jsonResult } = result;
+      const { _raw: _ignored, ...jsonResult } = data;
       ctx.ui.json(jsonResult);
       return;
     }
@@ -2619,19 +2652,18 @@ var logsContext = defineSystemCommand({
       ctx.ui.error("Log Context", { sections: [{ header: "Error", items: [result.error ?? "Unknown"] }] });
       return;
     }
-    const data = result;
     const { timeline, correlationKey, byLevel } = data;
-    const raw = data._raw;
-    const keyStr = Object.entries(correlationKey).map(([k, v]) => `${k}=${v}`).join(", ");
-    const durationStr = timeline.durationMs > 0 ? `${timeline.durationMs}ms` : "instant";
+    const raw = data._raw ?? [];
+    const keyStr = correlationKey ? Object.entries(correlationKey).map(([k, v]) => `${k}=${v}`).join(", ") : "";
+    const durationStr = timeline && timeline.durationMs > 0 ? `${timeline.durationMs}ms` : "instant";
     ctx.ui.success("Execution Context", {
       sections: [{
         header: `${keyStr}`,
         items: [
-          `Total events: ${timeline.total}`,
+          `Total events: ${timeline?.total ?? 0}`,
           `Duration: ${durationStr}`,
-          `Time: ${timeline.from ?? "N/A"} \u2192 ${timeline.to ?? "N/A"}`,
-          `Levels: ${Object.entries(byLevel).map(([k, v]) => `${k}=${v}`).join(", ")}`
+          `Time: ${timeline?.from ?? "N/A"} \u2192 ${timeline?.to ?? "N/A"}`,
+          `Levels: ${byLevel ? Object.entries(byLevel).map(([k, v]) => `${k}=${v}`).join(", ") : ""}`
         ]
       }]
     });
@@ -2801,13 +2833,12 @@ var logsSummarize = defineSystemCommand({
       ctx.ui.error("Log Summarize", { sections: [{ header: "Error", items: [result.error ?? "Unknown"] }] });
       return;
     }
-    const data = result;
-    ctx.ui.write(`Question: ${data.question}
+    ctx.ui.write(`Question: ${result.question}
 `);
-    ctx.ui.write(`${data.llmUsed ? "(AI-powered)" : "(Statistical fallback)"}
+    ctx.ui.write(`${result.llmUsed ? "(AI-powered)" : "(Statistical fallback)"}
 
 `);
-    ctx.ui.write(data.summary + "\n");
+    ctx.ui.write((result.summary ?? "") + "\n");
   }
 });
 var logsQuery = defineSystemCommand({
@@ -3002,12 +3033,15 @@ var logsGet = defineSystemCommand({
     const rawLog = result._rawLog;
     const logJson = result.log;
     const keys = result.correlationKeys;
+    if (!rawLog || !logJson || !keys) {
+      return;
+    }
     ctx.ui.write(formatLogLine(rawLog) + "\n\n");
     const details = [
-      `ID: ${logJson.id}`,
-      `Time: ${logJson.time}`,
-      `Level: ${logJson.level}`,
-      `Source: ${logJson.source}`
+      `ID: ${logJson["id"]}`,
+      `Time: ${logJson["time"]}`,
+      `Level: ${logJson["level"]}`,
+      `Source: ${logJson["source"]}`
     ];
     if (keys.traceId) {
       details.push(`Trace ID: ${keys.traceId}`);
@@ -3022,18 +3056,18 @@ var logsGet = defineSystemCommand({
       details.push(`Session ID: ${keys.sessionId}`);
     }
     const fieldsToShow = { ...rawLog.fields };
-    delete fieldsToShow.level;
-    delete fieldsToShow.time;
-    delete fieldsToShow.traceId;
-    delete fieldsToShow.executionId;
-    delete fieldsToShow.requestId;
-    delete fieldsToShow.reqId;
-    delete fieldsToShow.sessionId;
+    delete fieldsToShow["level"];
+    delete fieldsToShow["time"];
+    delete fieldsToShow["traceId"];
+    delete fieldsToShow["executionId"];
+    delete fieldsToShow["requestId"];
+    delete fieldsToShow["reqId"];
+    delete fieldsToShow["sessionId"];
     if (Object.keys(fieldsToShow).length > 0) {
       details.push(`Fields: ${JSON.stringify(fieldsToShow, null, 2)}`);
     }
     ctx.ui.success("Log Detail", { sections: [{ header: "Info", items: details }] });
-    const related = result.related;
+    const { related } = result;
     if (related && related.length > 0) {
       ctx.ui.write(`
 Related Logs (${related.length}):
@@ -3606,7 +3640,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];
@@ -3783,7 +3817,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,
@@ -3828,7 +3862,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) {
@@ -3875,7 +3909,8 @@ async function registerManifests(discoveryResults, registry2, options = {}) {
             cmd._disposeHook = manifestModule.dispose;
           }
         } catch (hookError) {
-          log3.debug(`Lifecycle hooks unavailable for ${manifest.id}: ${hookError.message}`);
+          const hookMsg = hookError instanceof Error ? hookError.message : String(hookError);
+          log3.debug(`Lifecycle hooks unavailable for ${manifest.id}: ${hookMsg}`);
         }
         const canonicalKey = manifest.group ? `${manifest.group}:${manifest.id}` : manifest.id;
         const existing = globalIds.get(canonicalKey);
@@ -3945,7 +3980,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,
@@ -3977,11 +4012,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) => {
-          log3.warn(`Dispose hook failed for ${cmd.manifest.id}: ${err.message}`);
+        Promise.resolve(disposeHook()).catch((err) => {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          log3.warn(`Dispose hook failed for ${cmd.manifest.id}: ${errMsg}`);
         })
       );
     }
@@ -4086,7 +4119,7 @@ async function registerBuiltinCommands(input = {}) {
       registry.markPartial(false);
     }
   } catch (err) {
-    log3.warn(`Discovery failed: ${err.message}`);
+    log3.warn(`Discovery failed: ${err instanceof Error ? err.message : String(err)}`);
     registry.markPartial(true);
     _registered = false;
     return;