@eslint-config-snapshot/cli 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @eslint-config-snapshot/cli
 
+## 1.1.0
+
+### Minor Changes
+
+- Minor release: improve skipped workspace messaging and OSS compatibility documentation.
+
+### Patch Changes
+
+- Updated dependencies
+  - @eslint-config-snapshot/api@1.1.0
+
 ## 1.0.0
 
 ### Major Changes

package/dist/index.cjs

@@ -38,7 +38,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_commander = require("commander");
 var import_debug2 = __toESM(require("debug"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 
 // src/commands/check.ts
 var import_api3 = require("@eslint-config-snapshot/api");
@@ -216,6 +216,12 @@ function formatStoredSnapshotSummary(storedSnapshots) {
   const summary = summarizeSnapshots(storedSnapshots);
   return `${summary.groups} groups, ${summary.rules} rules (severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off)`;
 }
+function formatBaselineSummaryLines(summary, workspaceCount) {
+  return `- \u{1F4E6} baseline: ${summary.groups} groups, ${summary.rules} rules
+- \u{1F5C2}\uFE0F workspaces scanned: ${workspaceCount}
+- \u{1F39A}\uFE0F severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off
+`;
+}
 function countRuleSeverities(ruleObjects) {
   let rules = 0;
   let error = 0;
@@ -395,19 +401,24 @@ var import_node_path2 = __toESM(require("path"), 1);
 var debugWorkspace = (0, import_debug.default)("eslint-config-snapshot:workspace");
 var debugDiff = (0, import_debug.default)("eslint-config-snapshot:diff");
 var debugTiming = (0, import_debug.default)("eslint-config-snapshot:timing");
-async function computeCurrentSnapshots(cwd) {
+async function computeCurrentSnapshots(cwd, options) {
+  const allowWorkspaceExtractionFailure = options?.allowWorkspaceExtractionFailure ?? false;
+  const onWorkspacesDiscovered = options?.onWorkspacesDiscovered;
+  const onWorkspaceSkipped = options?.onWorkspaceSkipped;
   const computeStartedAt = Date.now();
   const configStartedAt = Date.now();
   const config = await (0, import_api2.loadConfig)(cwd);
   debugTiming("phase=loadConfig elapsedMs=%d", Date.now() - configStartedAt);
   const assignmentStartedAt = Date.now();
   const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config);
+  onWorkspacesDiscovered?.(discovery.workspacesRel);
   debugTiming("phase=resolveWorkspaceAssignments elapsedMs=%d", Date.now() - assignmentStartedAt);
   debugWorkspace("root=%s groups=%d workspaces=%d", discovery.rootAbs, assignments.length, discovery.workspacesRel.length);
   const snapshots = /* @__PURE__ */ new Map();
   for (const group of assignments) {
     const groupStartedAt = Date.now();
     const extractedForGroup = [];
+    const extractedWorkspaces = [];
     debugWorkspace("group=%s workspaces=%o", group.name, group.workspaces);
     for (const workspaceRel of group.workspaces) {
       const workspaceAbs = import_node_path2.default.resolve(discovery.rootAbs, workspaceRel);
@@ -440,7 +451,7 @@ async function computeCurrentSnapshots(cwd) {
           continue;
         }
         const message = result.error instanceof Error ? result.error.message : String(result.error);
-        if (isRecoverableExtractionError(message)) {
+        if (isRecoverableExtractionError(message) || allowWorkspaceExtractionFailure) {
           lastExtractionError = message;
           continue;
         }
@@ -448,10 +459,23 @@ async function computeCurrentSnapshots(cwd) {
       }
       if (extractedCount === 0) {
         const context = lastExtractionError ? ` Last error: ${lastExtractionError}` : "";
-        throw new Error(
-          `Unable to extract ESLint config for workspace ${workspaceRel}. All sampled files were ignored or produced non-JSON output.${context}`
-        );
+        if (allowWorkspaceExtractionFailure && isSkippableWorkspaceExtractionFailure(lastExtractionError)) {
+          onWorkspaceSkipped?.({
+            groupId: group.name,
+            workspaceRel,
+            reason: lastExtractionError ?? "unknown extraction failure"
+          });
+          debugWorkspace(
+            "group=%s workspace=%s skipped=true reason=%s",
+            group.name,
+            workspaceRel,
+            lastExtractionError ?? "unknown extraction failure"
+          );
+          continue;
+        }
+        throw new Error(`Unable to extract ESLint config for workspace ${workspaceRel}.${context}`);
       }
+      extractedWorkspaces.push(workspaceRel);
       debugWorkspace(
         "group=%s workspace=%s extracted=%d failed=%d",
         group.name,
@@ -460,8 +484,15 @@ async function computeCurrentSnapshots(cwd) {
         results.length - extractedCount
       );
     }
+    if (extractedForGroup.length === 0) {
+      if (allowWorkspaceExtractionFailure) {
+        debugWorkspace("group=%s skipped=true reason=no-extracted-workspaces", group.name);
+        continue;
+      }
+      throw new Error(`Unable to extract ESLint config for group ${group.name}: no workspace produced a valid config`);
+    }
     const aggregated = (0, import_api2.aggregateRules)(extractedForGroup);
-    snapshots.set(group.name, (0, import_api2.buildSnapshot)(group.name, group.workspaces, aggregated));
+    snapshots.set(group.name, (0, import_api2.buildSnapshot)(group.name, extractedWorkspaces, aggregated));
     debugWorkspace(
       "group=%s aggregatedRules=%d groupElapsedMs=%d",
       group.name,
@@ -470,11 +501,20 @@ async function computeCurrentSnapshots(cwd) {
     );
   }
   debugTiming("phase=computeCurrentSnapshots elapsedMs=%d", Date.now() - computeStartedAt);
+  if (snapshots.size === 0) {
+    throw new Error("Unable to extract ESLint config from discovered workspaces in zero-config mode");
+  }
   return snapshots;
 }
 function isRecoverableExtractionError(message) {
   return message.startsWith("Invalid JSON from eslint --print-config") || message.startsWith("Empty ESLint print-config output") || message.includes("File ignored because of a matching ignore pattern") || message.includes("File ignored by default");
 }
+function isSkippableWorkspaceExtractionFailure(message) {
+  if (!message) {
+    return true;
+  }
+  return isRecoverableExtractionError(message) || message.startsWith("Failed to load config") || message.startsWith("Failed to run eslint --print-config") || message.startsWith("Unable to resolve eslint from workspace");
+}
 async function resolveWorkspaceAssignments(cwd, config) {
   const discovery = await (0, import_api2.discoverWorkspaces)({ cwd, workspaceInput: config.workspaceInput });
   const assignments = config.grouping.mode === "standalone" ? discovery.workspacesRel.map((workspace) => ({ name: workspace, workspaces: [workspace] })) : (0, import_api2.assignGroupsByMatch)(discovery.workspacesRel, config.grouping.groups ?? [{ name: "default", match: ["**/*"] }]);
@@ -544,6 +584,63 @@ async function resolveGroupEslintVersions(cwd) {
   return result;
 }
 
+// src/commands/skipped-workspaces.ts
+var import_node_path3 = __toESM(require("path"), 1);
+function writeSkippedWorkspaceSummary(terminal, cwd, configPath, skippedWorkspaces) {
+  if (skippedWorkspaces.length === 0) {
+    return;
+  }
+  const workspacePaths = collectSkippedWorkspacePaths(skippedWorkspaces);
+  terminal.warning(
+    `Heads up: ${workspacePaths.length} workspace(s) were skipped because ESLint auto-discovery could not extract an effective config for them.
+`
+  );
+  terminal.warning(`Skipped workspaces: ${workspacePaths.join(", ")}
+`);
+  terminal.subtle(formatScopedConfigHint(cwd, configPath, workspacePaths));
+}
+function collectSkippedWorkspacePaths(skippedWorkspaces) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const skipped of skippedWorkspaces) {
+    unique.add(skipped.workspaceRel);
+  }
+  return [...unique].sort();
+}
+function toExcludeGlobs(workspacePaths) {
+  return workspacePaths.map((workspacePath) => `${workspacePath}/**`);
+}
+function formatScopedConfigHint(cwd, configPath, workspacePaths) {
+  const excludeGlobs = toExcludeGlobs(workspacePaths);
+  if (configPath && import_node_path3.default.basename(configPath) === "package.json") {
+    return `Tip: if these workspaces are intentionally out of scope, add this under "eslint-config-snapshot" in package.json:
+${JSON.stringify(
+      {
+        sampling: {
+          excludeGlobs
+        }
+      },
+      null,
+      2
+    )}
+`;
+  }
+  const objectLiteral = `{
+  sampling: {
+    excludeGlobs: [
+${excludeGlobs.map((value) => `      '${value}'`).join(",\n")}
+    ]
+  }
+}
+`;
+  if (configPath) {
+    const relConfigPath = import_node_path3.default.relative(cwd, configPath) || import_node_path3.default.basename(configPath);
+    return `Tip: if these workspaces are intentionally out of scope, add this in ${relConfigPath}:
+${objectLiteral}`;
+  }
+  return `Tip: if these workspaces are intentionally out of scope, run \`eslint-config-snapshot init\` and add this config:
+${objectLiteral}`;
+}
+
 // src/commands/check.ts
 var UPDATE_HINT = "Tip: when you intentionally accept changes, run `eslint-config-snapshot --update` to refresh the baseline.\n";
 async function executeCheck(cwd, format, terminal, snapshotDir, defaultInvocation = false) {
@@ -561,10 +658,20 @@ async function executeCheck(cwd, format, terminal, snapshotDir, defaultInvocatio
     );
   }
   let currentSnapshots;
+  const skippedWorkspaces = [];
+  let discoveredWorkspaces = [];
   try {
-    currentSnapshots = await computeCurrentSnapshots(cwd);
+    currentSnapshots = await computeCurrentSnapshots(cwd, {
+      allowWorkspaceExtractionFailure: !foundConfig,
+      onWorkspacesDiscovered: (workspacesRel) => {
+        discoveredWorkspaces = workspacesRel;
+      },
+      onWorkspaceSkipped: (skipped) => {
+        skippedWorkspaces.push(skipped);
+      }
+    });
   } catch (error) {
-    if (!foundConfig) {
+    if (!foundConfig && isWorkspaceDiscoveryDefaultsError(error)) {
       terminal.write(
         "Automatic workspace discovery could not complete with defaults.\nRun `eslint-config-snapshot init` to configure workspaces, then run `eslint-config-snapshot --update`.\n"
       );
@@ -572,6 +679,10 @@ async function executeCheck(cwd, format, terminal, snapshotDir, defaultInvocatio
     }
     throw error;
   }
+  if (!foundConfig) {
+    writeDiscoveredWorkspacesSummary(terminal, discoveredWorkspaces);
+  }
+  writeSkippedWorkspaceSummary(terminal, cwd, foundConfig?.path, skippedWorkspaces);
   if (storedSnapshots.size === 0) {
     const summary = summarizeSnapshots(currentSnapshots);
     terminal.write(
@@ -631,12 +742,7 @@ function printWhatChanged(terminal, changes, currentSnapshots, eslintVersionsByG
   if (changes.length === 0) {
     terminal.write(color.green("\u2705 Great news: no snapshot drift detected.\n"));
     terminal.section("\u{1F4CA} Summary");
-    terminal.write(
-      `- \u{1F4E6} baseline: ${currentSummary.groups} groups, ${currentSummary.rules} rules
-- \u{1F5C2}\uFE0F workspaces scanned: ${workspaceCount}
-- \u{1F39A}\uFE0F severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off
-`
-    );
+    terminal.write(formatBaselineSummaryLines(currentSummary, workspaceCount));
     writeEslintVersionSummary(terminal, eslintVersionsByGroup);
     return 0;
   }
@@ -671,6 +777,18 @@ function printWhatChanged(terminal, changes, currentSnapshots, eslintVersionsByG
   terminal.subtle(UPDATE_HINT);
   return 1;
 }
+function isWorkspaceDiscoveryDefaultsError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Unable to discover workspaces") || message.includes("Unmatched workspaces") || message.includes("zero-config mode");
+}
+function writeDiscoveredWorkspacesSummary(terminal, workspacesRel) {
+  if (workspacesRel.length === 0) {
+    terminal.subtle("Auto-discovered workspaces: none\n");
+    return;
+  }
+  terminal.subtle(`Auto-discovered workspaces (${workspacesRel.length}): ${workspacesRel.join(", ")}
+`);
+}
 
 // src/commands/print.ts
 var import_api4 = require("@eslint-config-snapshot/api");
@@ -736,10 +854,20 @@ async function executeUpdate(cwd, terminal, snapshotDir, printSummary) {
     );
   }
   let currentSnapshots;
+  const skippedWorkspaces = [];
+  let discoveredWorkspaces = [];
   try {
-    currentSnapshots = await computeCurrentSnapshots(cwd);
+    currentSnapshots = await computeCurrentSnapshots(cwd, {
+      allowWorkspaceExtractionFailure: !foundConfig,
+      onWorkspacesDiscovered: (workspacesRel) => {
+        discoveredWorkspaces = workspacesRel;
+      },
+      onWorkspaceSkipped: (skipped) => {
+        skippedWorkspaces.push(skipped);
+      }
+    });
   } catch (error) {
-    if (!foundConfig) {
+    if (!foundConfig && isWorkspaceDiscoveryDefaultsError2(error)) {
       terminal.write(
         "Automatic workspace discovery could not complete with defaults.\nRun `eslint-config-snapshot init` to configure workspaces, then run `eslint-config-snapshot --update`.\n"
       );
@@ -747,28 +875,42 @@ async function executeUpdate(cwd, terminal, snapshotDir, printSummary) {
     }
     throw error;
   }
+  if (!foundConfig) {
+    writeDiscoveredWorkspacesSummary2(terminal, discoveredWorkspaces);
+  }
+  writeSkippedWorkspaceSummary(terminal, cwd, foundConfig?.path, skippedWorkspaces);
   await writeSnapshots(cwd, snapshotDir, currentSnapshots);
   if (printSummary) {
     const summary = summarizeSnapshots(currentSnapshots);
     const workspaceCount = countUniqueWorkspaces(currentSnapshots);
     const eslintVersionsByGroup = terminal.showProgress ? await resolveGroupEslintVersions(cwd) : /* @__PURE__ */ new Map();
+    const baselineAction = storedSnapshots.size === 0 ? "created" : "updated";
+    terminal.success(`\u2705 Great news: baseline was successfully ${baselineAction} for your project.
+`);
     terminal.section("\u{1F4CA} Summary");
-    terminal.write(
-      `Baseline updated: ${summary.groups} groups, ${summary.rules} rules.
-Workspaces scanned: ${workspaceCount}.
-Severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off.
-`
-    );
+    terminal.write(formatBaselineSummaryLines(summary, workspaceCount));
     writeEslintVersionSummary(terminal, eslintVersionsByGroup);
   }
   return 0;
 }
+function isWorkspaceDiscoveryDefaultsError2(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Unable to discover workspaces") || message.includes("Unmatched workspaces") || message.includes("zero-config mode");
+}
+function writeDiscoveredWorkspacesSummary2(terminal, workspacesRel) {
+  if (workspacesRel.length === 0) {
+    terminal.subtle("Auto-discovered workspaces: none\n");
+    return;
+  }
+  terminal.subtle(`Auto-discovered workspaces (${workspacesRel.length}): ${workspacesRel.join(", ")}
+`);
+}
 
 // src/init.ts
 var import_api6 = require("@eslint-config-snapshot/api");
 var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 var import_promises2 = require("fs/promises");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 async function runInit(cwd, opts, runtime) {
   const force = opts.force ?? false;
   const showEffective = opts.showEffective ?? false;
@@ -836,7 +978,7 @@ async function runInitInFile(cwd, configObject, force, runtime) {
   ];
   for (const candidate of candidates) {
     try {
-      await (0, import_promises2.access)(import_node_path3.default.join(cwd, candidate));
+      await (0, import_promises2.access)(import_node_path4.default.join(cwd, candidate));
       if (!force) {
         runtime.writeStderr(`Config already exists: ${candidate}
 `);
@@ -845,14 +987,14 @@ async function runInitInFile(cwd, configObject, force, runtime) {
     } catch {
     }
   }
-  const target = import_node_path3.default.join(cwd, "eslint-config-snapshot.config.mjs");
+  const target = import_node_path4.default.join(cwd, "eslint-config-snapshot.config.mjs");
   await (0, import_promises2.writeFile)(target, toConfigScaffold(configObject), "utf8");
-  runtime.writeStdout(`Created ${import_node_path3.default.basename(target)}
+  runtime.writeStdout(`Created ${import_node_path4.default.basename(target)}
 `);
   return 0;
 }
 async function runInitInPackageJson(cwd, configObject, force, runtime) {
-  const packageJsonPath = import_node_path3.default.join(cwd, "package.json");
+  const packageJsonPath = import_node_path4.default.join(cwd, "package.json");
   let packageJsonRaw;
   try {
     packageJsonRaw = await (0, import_promises2.readFile)(packageJsonPath, "utf8");
@@ -913,7 +1055,7 @@ async function discoverInitWorkspaces(cwd) {
   if (!(discovered.workspacesRel.length === 1 && discovered.workspacesRel[0] === ".")) {
     return discovered.workspacesRel;
   }
-  const packageJsonPath = import_node_path3.default.join(cwd, "package.json");
+  const packageJsonPath = import_node_path4.default.join(cwd, "package.json");
   try {
     const raw = await (0, import_promises2.readFile)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -931,7 +1073,7 @@ async function discoverInitWorkspaces(cwd) {
       onlyFiles: true,
       dot: true
     });
-    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => (0, import_api6.normalizePath)(import_node_path3.default.dirname(entry))))].sort(
+    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => (0, import_api6.normalizePath)(import_node_path4.default.dirname(entry))))].sort(
       (a, b) => a.localeCompare(b)
     );
     if (workspaceDirs.length > 0) {
@@ -1342,7 +1484,7 @@ function isDirectCliExecution() {
   if (!entry) {
     return false;
   }
-  const normalized = import_node_path4.default.basename(entry).toLowerCase();
+  const normalized = import_node_path5.default.basename(entry).toLowerCase();
   return normalized === "index.js" || normalized === "index.cjs" || normalized === "index.ts" || normalized === "eslint-config-snapshot";
 }
 if (isDirectCliExecution()) {

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import { Command, CommanderError, InvalidArgumentError } from "commander";
 import createDebug2 from "debug";
-import path4 from "path";
+import path5 from "path";
 
 // src/commands/check.ts
 import { findConfigPath } from "@eslint-config-snapshot/api";
@@ -181,6 +181,12 @@ function formatStoredSnapshotSummary(storedSnapshots) {
   const summary = summarizeSnapshots(storedSnapshots);
   return `${summary.groups} groups, ${summary.rules} rules (severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off)`;
 }
+function formatBaselineSummaryLines(summary, workspaceCount) {
+  return `- \u{1F4E6} baseline: ${summary.groups} groups, ${summary.rules} rules
+- \u{1F5C2}\uFE0F workspaces scanned: ${workspaceCount}
+- \u{1F39A}\uFE0F severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off
+`;
+}
 function countRuleSeverities(ruleObjects) {
   let rules = 0;
   let error = 0;
@@ -373,19 +379,24 @@ import path2 from "path";
 var debugWorkspace = createDebug("eslint-config-snapshot:workspace");
 var debugDiff = createDebug("eslint-config-snapshot:diff");
 var debugTiming = createDebug("eslint-config-snapshot:timing");
-async function computeCurrentSnapshots(cwd) {
+async function computeCurrentSnapshots(cwd, options) {
+  const allowWorkspaceExtractionFailure = options?.allowWorkspaceExtractionFailure ?? false;
+  const onWorkspacesDiscovered = options?.onWorkspacesDiscovered;
+  const onWorkspaceSkipped = options?.onWorkspaceSkipped;
   const computeStartedAt = Date.now();
   const configStartedAt = Date.now();
   const config = await loadConfig(cwd);
   debugTiming("phase=loadConfig elapsedMs=%d", Date.now() - configStartedAt);
   const assignmentStartedAt = Date.now();
   const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config);
+  onWorkspacesDiscovered?.(discovery.workspacesRel);
   debugTiming("phase=resolveWorkspaceAssignments elapsedMs=%d", Date.now() - assignmentStartedAt);
   debugWorkspace("root=%s groups=%d workspaces=%d", discovery.rootAbs, assignments.length, discovery.workspacesRel.length);
   const snapshots = /* @__PURE__ */ new Map();
   for (const group of assignments) {
     const groupStartedAt = Date.now();
     const extractedForGroup = [];
+    const extractedWorkspaces = [];
     debugWorkspace("group=%s workspaces=%o", group.name, group.workspaces);
     for (const workspaceRel of group.workspaces) {
       const workspaceAbs = path2.resolve(discovery.rootAbs, workspaceRel);
@@ -418,7 +429,7 @@ async function computeCurrentSnapshots(cwd) {
           continue;
         }
         const message = result.error instanceof Error ? result.error.message : String(result.error);
-        if (isRecoverableExtractionError(message)) {
+        if (isRecoverableExtractionError(message) || allowWorkspaceExtractionFailure) {
           lastExtractionError = message;
           continue;
         }
@@ -426,10 +437,23 @@ async function computeCurrentSnapshots(cwd) {
       }
       if (extractedCount === 0) {
         const context = lastExtractionError ? ` Last error: ${lastExtractionError}` : "";
-        throw new Error(
-          `Unable to extract ESLint config for workspace ${workspaceRel}. All sampled files were ignored or produced non-JSON output.${context}`
-        );
+        if (allowWorkspaceExtractionFailure && isSkippableWorkspaceExtractionFailure(lastExtractionError)) {
+          onWorkspaceSkipped?.({
+            groupId: group.name,
+            workspaceRel,
+            reason: lastExtractionError ?? "unknown extraction failure"
+          });
+          debugWorkspace(
+            "group=%s workspace=%s skipped=true reason=%s",
+            group.name,
+            workspaceRel,
+            lastExtractionError ?? "unknown extraction failure"
+          );
+          continue;
+        }
+        throw new Error(`Unable to extract ESLint config for workspace ${workspaceRel}.${context}`);
       }
+      extractedWorkspaces.push(workspaceRel);
       debugWorkspace(
         "group=%s workspace=%s extracted=%d failed=%d",
         group.name,
@@ -438,8 +462,15 @@ async function computeCurrentSnapshots(cwd) {
         results.length - extractedCount
       );
     }
+    if (extractedForGroup.length === 0) {
+      if (allowWorkspaceExtractionFailure) {
+        debugWorkspace("group=%s skipped=true reason=no-extracted-workspaces", group.name);
+        continue;
+      }
+      throw new Error(`Unable to extract ESLint config for group ${group.name}: no workspace produced a valid config`);
+    }
     const aggregated = aggregateRules(extractedForGroup);
-    snapshots.set(group.name, buildSnapshot(group.name, group.workspaces, aggregated));
+    snapshots.set(group.name, buildSnapshot(group.name, extractedWorkspaces, aggregated));
     debugWorkspace(
       "group=%s aggregatedRules=%d groupElapsedMs=%d",
       group.name,
@@ -448,11 +479,20 @@ async function computeCurrentSnapshots(cwd) {
     );
   }
   debugTiming("phase=computeCurrentSnapshots elapsedMs=%d", Date.now() - computeStartedAt);
+  if (snapshots.size === 0) {
+    throw new Error("Unable to extract ESLint config from discovered workspaces in zero-config mode");
+  }
   return snapshots;
 }
 function isRecoverableExtractionError(message) {
   return message.startsWith("Invalid JSON from eslint --print-config") || message.startsWith("Empty ESLint print-config output") || message.includes("File ignored because of a matching ignore pattern") || message.includes("File ignored by default");
 }
+function isSkippableWorkspaceExtractionFailure(message) {
+  if (!message) {
+    return true;
+  }
+  return isRecoverableExtractionError(message) || message.startsWith("Failed to load config") || message.startsWith("Failed to run eslint --print-config") || message.startsWith("Unable to resolve eslint from workspace");
+}
 async function resolveWorkspaceAssignments(cwd, config) {
   const discovery = await discoverWorkspaces({ cwd, workspaceInput: config.workspaceInput });
   const assignments = config.grouping.mode === "standalone" ? discovery.workspacesRel.map((workspace) => ({ name: workspace, workspaces: [workspace] })) : assignGroupsByMatch(discovery.workspacesRel, config.grouping.groups ?? [{ name: "default", match: ["**/*"] }]);
@@ -522,6 +562,63 @@ async function resolveGroupEslintVersions(cwd) {
   return result;
 }
 
+// src/commands/skipped-workspaces.ts
+import path3 from "path";
+function writeSkippedWorkspaceSummary(terminal, cwd, configPath, skippedWorkspaces) {
+  if (skippedWorkspaces.length === 0) {
+    return;
+  }
+  const workspacePaths = collectSkippedWorkspacePaths(skippedWorkspaces);
+  terminal.warning(
+    `Heads up: ${workspacePaths.length} workspace(s) were skipped because ESLint auto-discovery could not extract an effective config for them.
+`
+  );
+  terminal.warning(`Skipped workspaces: ${workspacePaths.join(", ")}
+`);
+  terminal.subtle(formatScopedConfigHint(cwd, configPath, workspacePaths));
+}
+function collectSkippedWorkspacePaths(skippedWorkspaces) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const skipped of skippedWorkspaces) {
+    unique.add(skipped.workspaceRel);
+  }
+  return [...unique].sort();
+}
+function toExcludeGlobs(workspacePaths) {
+  return workspacePaths.map((workspacePath) => `${workspacePath}/**`);
+}
+function formatScopedConfigHint(cwd, configPath, workspacePaths) {
+  const excludeGlobs = toExcludeGlobs(workspacePaths);
+  if (configPath && path3.basename(configPath) === "package.json") {
+    return `Tip: if these workspaces are intentionally out of scope, add this under "eslint-config-snapshot" in package.json:
+${JSON.stringify(
+      {
+        sampling: {
+          excludeGlobs
+        }
+      },
+      null,
+      2
+    )}
+`;
+  }
+  const objectLiteral = `{
+  sampling: {
+    excludeGlobs: [
+${excludeGlobs.map((value) => `      '${value}'`).join(",\n")}
+    ]
+  }
+}
+`;
+  if (configPath) {
+    const relConfigPath = path3.relative(cwd, configPath) || path3.basename(configPath);
+    return `Tip: if these workspaces are intentionally out of scope, add this in ${relConfigPath}:
+${objectLiteral}`;
+  }
+  return `Tip: if these workspaces are intentionally out of scope, run \`eslint-config-snapshot init\` and add this config:
+${objectLiteral}`;
+}
+
 // src/commands/check.ts
 var UPDATE_HINT = "Tip: when you intentionally accept changes, run `eslint-config-snapshot --update` to refresh the baseline.\n";
 async function executeCheck(cwd, format, terminal, snapshotDir, defaultInvocation = false) {
@@ -539,10 +636,20 @@ async function executeCheck(cwd, format, terminal, snapshotDir, defaultInvocatio
     );
   }
   let currentSnapshots;
+  const skippedWorkspaces = [];
+  let discoveredWorkspaces = [];
   try {
-    currentSnapshots = await computeCurrentSnapshots(cwd);
+    currentSnapshots = await computeCurrentSnapshots(cwd, {
+      allowWorkspaceExtractionFailure: !foundConfig,
+      onWorkspacesDiscovered: (workspacesRel) => {
+        discoveredWorkspaces = workspacesRel;
+      },
+      onWorkspaceSkipped: (skipped) => {
+        skippedWorkspaces.push(skipped);
+      }
+    });
   } catch (error) {
-    if (!foundConfig) {
+    if (!foundConfig && isWorkspaceDiscoveryDefaultsError(error)) {
       terminal.write(
         "Automatic workspace discovery could not complete with defaults.\nRun `eslint-config-snapshot init` to configure workspaces, then run `eslint-config-snapshot --update`.\n"
       );
@@ -550,6 +657,10 @@ async function executeCheck(cwd, format, terminal, snapshotDir, defaultInvocatio
     }
     throw error;
   }
+  if (!foundConfig) {
+    writeDiscoveredWorkspacesSummary(terminal, discoveredWorkspaces);
+  }
+  writeSkippedWorkspaceSummary(terminal, cwd, foundConfig?.path, skippedWorkspaces);
   if (storedSnapshots.size === 0) {
     const summary = summarizeSnapshots(currentSnapshots);
     terminal.write(
@@ -609,12 +720,7 @@ function printWhatChanged(terminal, changes, currentSnapshots, eslintVersionsByG
   if (changes.length === 0) {
     terminal.write(color.green("\u2705 Great news: no snapshot drift detected.\n"));
     terminal.section("\u{1F4CA} Summary");
-    terminal.write(
-      `- \u{1F4E6} baseline: ${currentSummary.groups} groups, ${currentSummary.rules} rules
-- \u{1F5C2}\uFE0F workspaces scanned: ${workspaceCount}
-- \u{1F39A}\uFE0F severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off
-`
-    );
+    terminal.write(formatBaselineSummaryLines(currentSummary, workspaceCount));
     writeEslintVersionSummary(terminal, eslintVersionsByGroup);
     return 0;
   }
@@ -649,6 +755,18 @@ function printWhatChanged(terminal, changes, currentSnapshots, eslintVersionsByG
   terminal.subtle(UPDATE_HINT);
   return 1;
 }
+function isWorkspaceDiscoveryDefaultsError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Unable to discover workspaces") || message.includes("Unmatched workspaces") || message.includes("zero-config mode");
+}
+function writeDiscoveredWorkspacesSummary(terminal, workspacesRel) {
+  if (workspacesRel.length === 0) {
+    terminal.subtle("Auto-discovered workspaces: none\n");
+    return;
+  }
+  terminal.subtle(`Auto-discovered workspaces (${workspacesRel.length}): ${workspacesRel.join(", ")}
+`);
+}
 
 // src/commands/print.ts
 import { findConfigPath as findConfigPath2, loadConfig as loadConfig2 } from "@eslint-config-snapshot/api";
@@ -714,10 +832,20 @@ async function executeUpdate(cwd, terminal, snapshotDir, printSummary) {
     );
   }
   let currentSnapshots;
+  const skippedWorkspaces = [];
+  let discoveredWorkspaces = [];
   try {
-    currentSnapshots = await computeCurrentSnapshots(cwd);
+    currentSnapshots = await computeCurrentSnapshots(cwd, {
+      allowWorkspaceExtractionFailure: !foundConfig,
+      onWorkspacesDiscovered: (workspacesRel) => {
+        discoveredWorkspaces = workspacesRel;
+      },
+      onWorkspaceSkipped: (skipped) => {
+        skippedWorkspaces.push(skipped);
+      }
+    });
   } catch (error) {
-    if (!foundConfig) {
+    if (!foundConfig && isWorkspaceDiscoveryDefaultsError2(error)) {
       terminal.write(
         "Automatic workspace discovery could not complete with defaults.\nRun `eslint-config-snapshot init` to configure workspaces, then run `eslint-config-snapshot --update`.\n"
       );
@@ -725,28 +853,42 @@ async function executeUpdate(cwd, terminal, snapshotDir, printSummary) {
     }
     throw error;
   }
+  if (!foundConfig) {
+    writeDiscoveredWorkspacesSummary2(terminal, discoveredWorkspaces);
+  }
+  writeSkippedWorkspaceSummary(terminal, cwd, foundConfig?.path, skippedWorkspaces);
   await writeSnapshots(cwd, snapshotDir, currentSnapshots);
   if (printSummary) {
     const summary = summarizeSnapshots(currentSnapshots);
     const workspaceCount = countUniqueWorkspaces(currentSnapshots);
     const eslintVersionsByGroup = terminal.showProgress ? await resolveGroupEslintVersions(cwd) : /* @__PURE__ */ new Map();
+    const baselineAction = storedSnapshots.size === 0 ? "created" : "updated";
+    terminal.success(`\u2705 Great news: baseline was successfully ${baselineAction} for your project.
+`);
     terminal.section("\u{1F4CA} Summary");
-    terminal.write(
-      `Baseline updated: ${summary.groups} groups, ${summary.rules} rules.
-Workspaces scanned: ${workspaceCount}.
-Severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off.
-`
-    );
+    terminal.write(formatBaselineSummaryLines(summary, workspaceCount));
     writeEslintVersionSummary(terminal, eslintVersionsByGroup);
   }
   return 0;
 }
+function isWorkspaceDiscoveryDefaultsError2(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Unable to discover workspaces") || message.includes("Unmatched workspaces") || message.includes("zero-config mode");
+}
+function writeDiscoveredWorkspacesSummary2(terminal, workspacesRel) {
+  if (workspacesRel.length === 0) {
+    terminal.subtle("Auto-discovered workspaces: none\n");
+    return;
+  }
+  terminal.subtle(`Auto-discovered workspaces (${workspacesRel.length}): ${workspacesRel.join(", ")}
+`);
+}
 
 // src/init.ts
 import { discoverWorkspaces as discoverWorkspaces2, findConfigPath as findConfigPath4, getConfigScaffold, normalizePath as normalizePath2 } from "@eslint-config-snapshot/api";
 import fg2 from "fast-glob";
 import { access, readFile, writeFile } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 async function runInit(cwd, opts, runtime) {
   const force = opts.force ?? false;
   const showEffective = opts.showEffective ?? false;
@@ -814,7 +956,7 @@ async function runInitInFile(cwd, configObject, force, runtime) {
   ];
   for (const candidate of candidates) {
     try {
-      await access(path3.join(cwd, candidate));
+      await access(path4.join(cwd, candidate));
       if (!force) {
         runtime.writeStderr(`Config already exists: ${candidate}
 `);
@@ -823,14 +965,14 @@ async function runInitInFile(cwd, configObject, force, runtime) {
     } catch {
     }
   }
-  const target = path3.join(cwd, "eslint-config-snapshot.config.mjs");
+  const target = path4.join(cwd, "eslint-config-snapshot.config.mjs");
   await writeFile(target, toConfigScaffold(configObject), "utf8");
-  runtime.writeStdout(`Created ${path3.basename(target)}
+  runtime.writeStdout(`Created ${path4.basename(target)}
 `);
   return 0;
 }
 async function runInitInPackageJson(cwd, configObject, force, runtime) {
-  const packageJsonPath = path3.join(cwd, "package.json");
+  const packageJsonPath = path4.join(cwd, "package.json");
   let packageJsonRaw;
   try {
     packageJsonRaw = await readFile(packageJsonPath, "utf8");
@@ -891,7 +1033,7 @@ async function discoverInitWorkspaces(cwd) {
   if (!(discovered.workspacesRel.length === 1 && discovered.workspacesRel[0] === ".")) {
     return discovered.workspacesRel;
   }
-  const packageJsonPath = path3.join(cwd, "package.json");
+  const packageJsonPath = path4.join(cwd, "package.json");
   try {
     const raw = await readFile(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -909,7 +1051,7 @@ async function discoverInitWorkspaces(cwd) {
       onlyFiles: true,
       dot: true
     });
-    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => normalizePath2(path3.dirname(entry))))].sort(
+    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => normalizePath2(path4.dirname(entry))))].sort(
       (a, b) => a.localeCompare(b)
     );
     if (workspaceDirs.length > 0) {
@@ -1320,7 +1462,7 @@ function isDirectCliExecution() {
   if (!entry) {
     return false;
   }
-  const normalized = path4.basename(entry).toLowerCase();
+  const normalized = path5.basename(entry).toLowerCase();
   return normalized === "index.js" || normalized === "index.cjs" || normalized === "index.ts" || normalized === "eslint-config-snapshot";
 }
 if (isDirectCliExecution()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-config-snapshot/cli",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -31,6 +31,6 @@
     "commander": "^14.0.3",
     "debug": "^4.4.3",
     "fast-glob": "^3.3.3",
-    "@eslint-config-snapshot/api": "1.0.0"
+    "@eslint-config-snapshot/api": "1.1.0"
   }
 }

package/src/commands/check.ts

@@ -1,6 +1,13 @@
 import { findConfigPath } from '@eslint-config-snapshot/api'
 
-import { countUniqueWorkspaces, decorateDiffLine, formatDiff, summarizeChanges, summarizeSnapshots } from '../formatters.js'
+import {
+  countUniqueWorkspaces,
+  decorateDiffLine,
+  formatBaselineSummaryLines,
+  formatDiff,
+  summarizeChanges,
+  summarizeSnapshots
+} from '../formatters.js'
 import { writeEslintVersionSummary, writeRunContextHeader } from '../run-context.js'
 import {
   type BuiltSnapshot,
@@ -9,10 +16,12 @@ import {
   type GroupEslintVersions,
   loadStoredSnapshots,
   resolveGroupEslintVersions,
+  type SkippedWorkspace,
   type SnapshotDiff,
   writeSnapshots
 } from '../runtime.js'
 import { type TerminalIO } from '../terminal.js'
+import { writeSkippedWorkspaceSummary } from './skipped-workspaces.js'
 
 export type CheckFormat = 'summary' | 'status' | 'diff'
 
@@ -42,10 +51,20 @@ export async function executeCheck(
   }
 
   let currentSnapshots: Map<string, BuiltSnapshot>
+  const skippedWorkspaces: SkippedWorkspace[] = []
+  let discoveredWorkspaces: string[] = []
   try {
-    currentSnapshots = await computeCurrentSnapshots(cwd)
+    currentSnapshots = await computeCurrentSnapshots(cwd, {
+      allowWorkspaceExtractionFailure: !foundConfig,
+      onWorkspacesDiscovered: (workspacesRel) => {
+        discoveredWorkspaces = workspacesRel
+      },
+      onWorkspaceSkipped: (skipped) => {
+        skippedWorkspaces.push(skipped)
+      }
+    })
   } catch (error: unknown) {
-    if (!foundConfig) {
+    if (!foundConfig && isWorkspaceDiscoveryDefaultsError(error)) {
       terminal.write(
         'Automatic workspace discovery could not complete with defaults.\nRun `eslint-config-snapshot init` to configure workspaces, then run `eslint-config-snapshot --update`.\n'
       )
@@ -54,6 +73,10 @@ export async function executeCheck(
 
     throw error
   }
+  if (!foundConfig) {
+    writeDiscoveredWorkspacesSummary(terminal, discoveredWorkspaces)
+  }
+  writeSkippedWorkspaceSummary(terminal, cwd, foundConfig?.path, skippedWorkspaces)
   if (storedSnapshots.size === 0) {
     const summary = summarizeSnapshots(currentSnapshots)
     terminal.write(
@@ -126,9 +149,7 @@ function printWhatChanged(
   if (changes.length === 0) {
     terminal.write(color.green('✅ Great news: no snapshot drift detected.\n'))
     terminal.section('📊 Summary')
-    terminal.write(
-      `- 📦 baseline: ${currentSummary.groups} groups, ${currentSummary.rules} rules\n- 🗂️ workspaces scanned: ${workspaceCount}\n- 🎚️ severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off\n`
-    )
+    terminal.write(formatBaselineSummaryLines(currentSummary, workspaceCount))
     writeEslintVersionSummary(terminal, eslintVersionsByGroup)
     return 0
   }
@@ -155,3 +176,21 @@ function printWhatChanged(
 
   return 1
 }
+
+function isWorkspaceDiscoveryDefaultsError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error)
+  return (
+    message.includes('Unable to discover workspaces') ||
+    message.includes('Unmatched workspaces') ||
+    message.includes('zero-config mode')
+  )
+}
+
+function writeDiscoveredWorkspacesSummary(terminal: TerminalIO, workspacesRel: string[]): void {
+  if (workspacesRel.length === 0) {
+    terminal.subtle('Auto-discovered workspaces: none\n')
+    return
+  }
+
+  terminal.subtle(`Auto-discovered workspaces (${workspacesRel.length}): ${workspacesRel.join(', ')}\n`)
+}

package/src/commands/skipped-workspaces.ts

@@ -0,0 +1,66 @@
+import path from 'node:path'
+
+import { type SkippedWorkspace } from '../runtime.js'
+import { type TerminalIO } from '../terminal.js'
+
+export function writeSkippedWorkspaceSummary(
+  terminal: TerminalIO,
+  cwd: string,
+  configPath: string | undefined,
+  skippedWorkspaces: SkippedWorkspace[]
+): void {
+  if (skippedWorkspaces.length === 0) {
+    return
+  }
+
+  const workspacePaths = collectSkippedWorkspacePaths(skippedWorkspaces)
+  terminal.warning(
+    `Heads up: ${workspacePaths.length} workspace(s) were skipped because ESLint auto-discovery could not extract an effective config for them.\n`
+  )
+  terminal.warning(`Skipped workspaces: ${workspacePaths.join(', ')}\n`)
+  terminal.subtle(formatScopedConfigHint(cwd, configPath, workspacePaths))
+}
+
+function collectSkippedWorkspacePaths(skippedWorkspaces: SkippedWorkspace[]): string[] {
+  const unique = new Set<string>()
+  for (const skipped of skippedWorkspaces) {
+    unique.add(skipped.workspaceRel)
+  }
+
+  return [...unique].sort()
+}
+
+function toExcludeGlobs(workspacePaths: string[]): string[] {
+  return workspacePaths.map((workspacePath) => `${workspacePath}/**`)
+}
+
+function formatScopedConfigHint(cwd: string, configPath: string | undefined, workspacePaths: string[]): string {
+  const excludeGlobs = toExcludeGlobs(workspacePaths)
+
+  if (configPath && path.basename(configPath) === 'package.json') {
+    return `Tip: if these workspaces are intentionally out of scope, add this under "eslint-config-snapshot" in package.json:\n${JSON.stringify(
+      {
+        sampling: {
+          excludeGlobs
+        }
+      },
+      null,
+      2
+    )}\n`
+  }
+
+  const objectLiteral = `{
+  sampling: {
+    excludeGlobs: [
+${excludeGlobs.map((value) => `      '${value}'`).join(',\n')}
+    ]
+  }
+}\n`
+
+  if (configPath) {
+    const relConfigPath = path.relative(cwd, configPath) || path.basename(configPath)
+    return `Tip: if these workspaces are intentionally out of scope, add this in ${relConfigPath}:\n${objectLiteral}`
+  }
+
+  return `Tip: if these workspaces are intentionally out of scope, run \`eslint-config-snapshot init\` and add this config:\n${objectLiteral}`
+}

package/src/commands/update.ts

@@ -1,9 +1,10 @@
 import { findConfigPath } from '@eslint-config-snapshot/api'
 
-import { countUniqueWorkspaces, summarizeSnapshots } from '../formatters.js'
+import { countUniqueWorkspaces, formatBaselineSummaryLines, summarizeSnapshots } from '../formatters.js'
 import { writeEslintVersionSummary, writeRunContextHeader } from '../run-context.js'
-import { computeCurrentSnapshots, loadStoredSnapshots, resolveGroupEslintVersions, writeSnapshots } from '../runtime.js'
+import { computeCurrentSnapshots, loadStoredSnapshots, resolveGroupEslintVersions, type SkippedWorkspace, writeSnapshots } from '../runtime.js'
 import { type TerminalIO } from '../terminal.js'
+import { writeSkippedWorkspaceSummary } from './skipped-workspaces.js'
 
 export async function executeUpdate(cwd: string, terminal: TerminalIO, snapshotDir: string, printSummary: boolean): Promise<number> {
   const foundConfig = await findConfigPath(cwd)
@@ -20,10 +21,20 @@ export async function executeUpdate(cwd: string, terminal: TerminalIO, snapshotD
   }
 
   let currentSnapshots
+  const skippedWorkspaces: SkippedWorkspace[] = []
+  let discoveredWorkspaces: string[] = []
   try {
-    currentSnapshots = await computeCurrentSnapshots(cwd)
+    currentSnapshots = await computeCurrentSnapshots(cwd, {
+      allowWorkspaceExtractionFailure: !foundConfig,
+      onWorkspacesDiscovered: (workspacesRel) => {
+        discoveredWorkspaces = workspacesRel
+      },
+      onWorkspaceSkipped: (skipped) => {
+        skippedWorkspaces.push(skipped)
+      }
+    })
   } catch (error: unknown) {
-    if (!foundConfig) {
+    if (!foundConfig && isWorkspaceDiscoveryDefaultsError(error)) {
       terminal.write(
         'Automatic workspace discovery could not complete with defaults.\nRun `eslint-config-snapshot init` to configure workspaces, then run `eslint-config-snapshot --update`.\n'
       )
@@ -32,18 +43,40 @@ export async function executeUpdate(cwd: string, terminal: TerminalIO, snapshotD
 
     throw error
   }
+  if (!foundConfig) {
+    writeDiscoveredWorkspacesSummary(terminal, discoveredWorkspaces)
+  }
+  writeSkippedWorkspaceSummary(terminal, cwd, foundConfig?.path, skippedWorkspaces)
   await writeSnapshots(cwd, snapshotDir, currentSnapshots)
 
   if (printSummary) {
     const summary = summarizeSnapshots(currentSnapshots)
     const workspaceCount = countUniqueWorkspaces(currentSnapshots)
     const eslintVersionsByGroup = terminal.showProgress ? await resolveGroupEslintVersions(cwd) : new Map<string, string[]>()
+    const baselineAction = storedSnapshots.size === 0 ? 'created' : 'updated'
+    terminal.success(`✅ Great news: baseline was successfully ${baselineAction} for your project.\n`)
     terminal.section('📊 Summary')
-    terminal.write(
-      `Baseline updated: ${summary.groups} groups, ${summary.rules} rules.\nWorkspaces scanned: ${workspaceCount}.\nSeverity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off.\n`
-    )
+    terminal.write(formatBaselineSummaryLines(summary, workspaceCount))
     writeEslintVersionSummary(terminal, eslintVersionsByGroup)
   }
 
   return 0
 }
+
+function isWorkspaceDiscoveryDefaultsError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error)
+  return (
+    message.includes('Unable to discover workspaces') ||
+    message.includes('Unmatched workspaces') ||
+    message.includes('zero-config mode')
+  )
+}
+
+function writeDiscoveredWorkspacesSummary(terminal: TerminalIO, workspacesRel: string[]): void {
+  if (workspacesRel.length === 0) {
+    terminal.subtle('Auto-discovered workspaces: none\n')
+    return
+  }
+
+  terminal.subtle(`Auto-discovered workspaces (${workspacesRel.length}): ${workspacesRel.join(', ')}\n`)
+}

package/src/formatters.ts

@@ -213,6 +213,13 @@ export function formatStoredSnapshotSummary(storedSnapshots: Map<string, Snapsho
   return `${summary.groups} groups, ${summary.rules} rules (severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off)`
 }
 
+export function formatBaselineSummaryLines(
+  summary: { groups: number; rules: number; error: number; warn: number; off: number },
+  workspaceCount: number
+): string {
+  return `- 📦 baseline: ${summary.groups} groups, ${summary.rules} rules\n- 🗂️ workspaces scanned: ${workspaceCount}\n- 🎚️ severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off\n`
+}
+
 export function countRuleSeverities(ruleObjects: RuleObject[]) {
   let rules = 0
   let error = 0

package/src/runtime.ts

@@ -32,8 +32,23 @@ export type WorkspaceAssignments = {
   discovery: WorkspaceDiscovery
   assignments: GroupAssignment[]
 }
+export type SkippedWorkspace = {
+  groupId: string
+  workspaceRel: string
+  reason: string
+}
 
-export async function computeCurrentSnapshots(cwd: string): Promise<Map<string, BuiltSnapshot>> {
+export async function computeCurrentSnapshots(
+  cwd: string,
+  options?: {
+    allowWorkspaceExtractionFailure?: boolean
+    onWorkspacesDiscovered?: (workspacesRel: string[]) => void
+    onWorkspaceSkipped?: (skipped: SkippedWorkspace) => void
+  }
+): Promise<Map<string, BuiltSnapshot>> {
+  const allowWorkspaceExtractionFailure = options?.allowWorkspaceExtractionFailure ?? false
+  const onWorkspacesDiscovered = options?.onWorkspacesDiscovered
+  const onWorkspaceSkipped = options?.onWorkspaceSkipped
   const computeStartedAt = Date.now()
   const configStartedAt = Date.now()
   const config = await loadConfig(cwd)
@@ -41,6 +56,7 @@ export async function computeCurrentSnapshots(cwd: string): Promise<Map<string,
 
   const assignmentStartedAt = Date.now()
   const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config)
+  onWorkspacesDiscovered?.(discovery.workspacesRel)
   debugTiming('phase=resolveWorkspaceAssignments elapsedMs=%d', Date.now() - assignmentStartedAt)
   debugWorkspace('root=%s groups=%d workspaces=%d', discovery.rootAbs, assignments.length, discovery.workspacesRel.length)
 
@@ -49,6 +65,7 @@ export async function computeCurrentSnapshots(cwd: string): Promise<Map<string,
   for (const group of assignments) {
     const groupStartedAt = Date.now()
     const extractedForGroup = []
+    const extractedWorkspaces: string[] = []
     debugWorkspace('group=%s workspaces=%o', group.name, group.workspaces)
 
     for (const workspaceRel of group.workspaces) {
@@ -85,7 +102,7 @@ export async function computeCurrentSnapshots(cwd: string): Promise<Map<string,
         }
 
         const message = result.error instanceof Error ? result.error.message : String(result.error)
-        if (isRecoverableExtractionError(message)) {
+        if (isRecoverableExtractionError(message) || allowWorkspaceExtractionFailure) {
           lastExtractionError = message
           continue
         }
@@ -95,10 +112,24 @@ export async function computeCurrentSnapshots(cwd: string): Promise<Map<string,
 
       if (extractedCount === 0) {
         const context = lastExtractionError ? ` Last error: ${lastExtractionError}` : ''
-        throw new Error(
-          `Unable to extract ESLint config for workspace ${workspaceRel}. All sampled files were ignored or produced non-JSON output.${context}`
-        )
+        if (allowWorkspaceExtractionFailure && isSkippableWorkspaceExtractionFailure(lastExtractionError)) {
+          onWorkspaceSkipped?.({
+            groupId: group.name,
+            workspaceRel,
+            reason: lastExtractionError ?? 'unknown extraction failure'
+          })
+          debugWorkspace(
+            'group=%s workspace=%s skipped=true reason=%s',
+            group.name,
+            workspaceRel,
+            lastExtractionError ?? 'unknown extraction failure'
+          )
+          continue
+        }
+
+        throw new Error(`Unable to extract ESLint config for workspace ${workspaceRel}.${context}`)
       }
+      extractedWorkspaces.push(workspaceRel)
 
       debugWorkspace(
         'group=%s workspace=%s extracted=%d failed=%d',
@@ -109,8 +140,16 @@ export async function computeCurrentSnapshots(cwd: string): Promise<Map<string,
       )
     }
 
+    if (extractedForGroup.length === 0) {
+      if (allowWorkspaceExtractionFailure) {
+        debugWorkspace('group=%s skipped=true reason=no-extracted-workspaces', group.name)
+        continue
+      }
+      throw new Error(`Unable to extract ESLint config for group ${group.name}: no workspace produced a valid config`)
+    }
+
     const aggregated = aggregateRules(extractedForGroup)
-    snapshots.set(group.name, buildSnapshot(group.name, group.workspaces, aggregated))
+    snapshots.set(group.name, buildSnapshot(group.name, extractedWorkspaces, aggregated))
     debugWorkspace(
       'group=%s aggregatedRules=%d groupElapsedMs=%d',
       group.name,
@@ -120,6 +159,9 @@ export async function computeCurrentSnapshots(cwd: string): Promise<Map<string,
   }
 
   debugTiming('phase=computeCurrentSnapshots elapsedMs=%d', Date.now() - computeStartedAt)
+  if (snapshots.size === 0) {
+    throw new Error('Unable to extract ESLint config from discovered workspaces in zero-config mode')
+  }
   return snapshots
 }
 
@@ -132,6 +174,19 @@ function isRecoverableExtractionError(message: string): boolean {
   )
 }
 
+function isSkippableWorkspaceExtractionFailure(message: string | undefined): boolean {
+  if (!message) {
+    return true
+  }
+
+  return (
+    isRecoverableExtractionError(message) ||
+    message.startsWith('Failed to load config') ||
+    message.startsWith('Failed to run eslint --print-config') ||
+    message.startsWith('Unable to resolve eslint from workspace')
+  )
+}
+
 export async function resolveWorkspaceAssignments(cwd: string, config: SnapshotConfig): Promise<WorkspaceAssignments> {
   const discovery = await discoverWorkspaces({ cwd, workspaceInput: config.workspaceInput })
 

package/test/cli.integration.test.ts

@@ -105,6 +105,43 @@ describe.sequential('cli integration', () => {
     expect(code).toBe(1)
   })
 
+  it('update in zero-config mode skips workspaces with unrecoverable eslint extraction failures', async () => {
+    await rm(path.join(fixtureRoot, 'eslint-config-snapshot.config.mjs'), { force: true })
+    const packageJsonPath = path.join(fixtureRoot, 'package.json')
+    const packageJsonRaw = await readFile(packageJsonPath, 'utf8')
+    const packageJson = JSON.parse(packageJsonRaw) as Record<string, unknown>
+    delete packageJson['eslint-config-snapshot']
+    await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`)
+
+    await writeFile(
+      path.join(fixtureRoot, 'packages/ws-b/node_modules/eslint/bin/eslint.js'),
+      "console.error('Failed to load config \"next/core-web-vitals\" to extend from.'); process.exit(1)\n"
+    )
+
+    const writeSpy = vi.spyOn(process.stdout, 'write')
+    const code = await runCli('update', fixtureRoot)
+    expect(code).toBe(0)
+    expect(writeSpy).toHaveBeenCalledWith(
+      expect.stringContaining('workspace(s) were skipped because ESLint auto-discovery could not extract an effective config')
+    )
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('Skipped workspaces: packages/ws-b'))
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('excludeGlobs'))
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('packages/ws-b/**'))
+
+    const snapshotRaw = await readFile(path.join(fixtureRoot, '.eslint-config-snapshot/default.json'), 'utf8')
+    const snapshot = JSON.parse(snapshotRaw)
+
+    expect(snapshot).toEqual({
+      formatVersion: 1,
+      groupId: 'default',
+      workspaces: ['packages/ws-a'],
+      rules: {
+        eqeqeq: ['error', 'always'],
+        'no-console': ['warn']
+      }
+    })
+  })
+
   it('status is minimal and exits 0 when clean', async () => {
     await runCli('snapshot', fixtureRoot)
 
@@ -185,7 +222,7 @@ no-debugger: off
     const writeSpy = vi.spyOn(process.stdout, 'write')
     const code = await runCli(undefined, fixtureRoot, ['--update'])
     expect(code).toBe(0)
-    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('Baseline updated:'))
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('baseline was successfully created'))
   })
 
   it('supports canonical check and update commands', async () => {

package/test/cli.terminal.integration.test.ts

@@ -81,7 +81,7 @@ describe('cli terminal invocation', () => {
   it('snapshot succeeds and compare returns clean result', () => {
     const snapshot = run(['snapshot'])
     expect(snapshot.status).toBe(0)
-    expect(snapshot.stdout).toContain('Baseline updated:')
+    expect(snapshot.stdout).toContain('baseline was successfully created')
     expect(snapshot.stderr).toBe('')
 
     const compare = run(['compare'])
@@ -384,10 +384,21 @@ no-debugger: off
   it('updates snapshots with --update without command', () => {
     const result = run(['--update'])
     expect(result.status).toBe(0)
-    expect(result.stdout).toContain('Baseline updated:')
+    expect(result.stdout).toContain('baseline was successfully created')
     expect(result.stderr).toBe('')
   })
 
+  it('prints updated message when baseline already exists', () => {
+    const first = run(['--update'])
+    expect(first.status).toBe(0)
+    expect(first.stdout).toContain('baseline was successfully created')
+
+    const second = run(['--update'])
+    expect(second.status).toBe(0)
+    expect(second.stdout).toContain('baseline was successfully updated')
+    expect(second.stderr).toBe('')
+  })
+
   it('prints init help with select-prompt and force guidance', () => {
     const result = run(['init', '--help'])
     expect(result.status).toBe(0)
@@ -403,7 +414,7 @@ no-debugger: off
   it('supports canonical check and update commands', () => {
     const update = run(['update'])
     expect(update.status).toBe(0)
-    expect(update.stdout).toContain('Baseline updated:')
+    expect(update.stdout).toContain('baseline was successfully created')
 
     const check = run(['check'])
     expect(check.status).toBe(0)