@skill-map/cli 0.45.0 → 0.46.0

package/dist/cli.js

@@ -1,4 +1,6 @@
 // cli/entry.ts
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="7c131b78-b7ad-5f03-b19c-1f70afdfeefb")}catch(e){}}();
 import { existsSync as existsSync32 } from "fs";
 import { Builtins, Cli as Cli2 } from "clipanion";
 
@@ -241,6 +243,123 @@ function bucketByKind(kind, instance, bag) {
   }
 }
 
+// package.json
+var package_default = {
+  name: "@skill-map/cli",
+  version: "0.46.0",
+  description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
+  license: "MIT",
+  type: "module",
+  homepage: "https://skill-map.ai",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/crystian/skill-map.git",
+    directory: "src"
+  },
+  bugs: {
+    url: "https://github.com/crystian/skill-map/issues"
+  },
+  keywords: [
+    "skill-map",
+    "markdown",
+    "ai-agents",
+    "claude-code",
+    "graph"
+  ],
+  bin: {
+    sm: "bin/sm.js",
+    "skill-map": "bin/sm.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./kernel": {
+      types: "./dist/kernel/index.d.ts",
+      import: "./dist/kernel/index.js"
+    },
+    "./conformance": {
+      types: "./dist/conformance/index.d.ts",
+      import: "./dist/conformance/index.js"
+    }
+  },
+  files: [
+    "bin/",
+    "dist/",
+    "migrations/",
+    "README.md"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    "dev:serve": "node scripts/dev-serve.js",
+    typecheck: "tsc --noEmit",
+    lint: "eslint .",
+    "lint:fix": "eslint . --fix",
+    "build-built-ins": "node ../scripts/generate-built-ins.js",
+    "built-ins:check": "node ../scripts/generate-built-ins.js --check",
+    prebuild: "pnpm build-built-ins",
+    validate: "pnpm validate:compile && pnpm validate:test",
+    "validate:compile": "pnpm typecheck && pnpm lint && pnpm build && pnpm built-ins:check",
+    "validate:test": "pnpm test:ci",
+    pretest: "tsup",
+    "pretest:coverage": "tsup",
+    "pretest:coverage:html": "tsup",
+    test: "tsc --noEmit && SKILL_MAP_TELEMETRY=0 node --import tsx --test --test-reporter=./scripts/test-reporter.js --test-reporter-destination=stdout '__tests__/**/*.spec.ts' 'kernel/**/__tests__/**/*.spec.ts' 'cli/**/__tests__/**/*.spec.ts' 'server/**/__tests__/**/*.spec.ts' 'plugins/**/__tests__/**/*.spec.ts' 'core/**/__tests__/**/*.spec.ts' 'conformance/**/__tests__/**/*.spec.ts'",
+    "test:ci": "FORCE_COLOR=1 SKILL_MAP_TELEMETRY=0 node --import tsx --test --test-reporter=./scripts/test-reporter.js --test-reporter-destination=stdout '__tests__/**/*.spec.ts' 'kernel/**/__tests__/**/*.spec.ts' 'cli/**/__tests__/**/*.spec.ts' 'server/**/__tests__/**/*.spec.ts' 'plugins/**/__tests__/**/*.spec.ts' 'core/**/__tests__/**/*.spec.ts' 'conformance/**/__tests__/**/*.spec.ts'",
+    "test:spec": "SKILL_MAP_TELEMETRY=0 node --import tsx --test --test-reporter=spec '__tests__/**/*.spec.ts' 'kernel/**/__tests__/**/*.spec.ts' 'cli/**/__tests__/**/*.spec.ts' 'server/**/__tests__/**/*.spec.ts' 'plugins/**/__tests__/**/*.spec.ts' 'core/**/__tests__/**/*.spec.ts' 'conformance/**/__tests__/**/*.spec.ts'",
+    "test:coverage": "tsc --noEmit && SKILL_MAP_TELEMETRY=0 SKILL_MAP_SKIP_BENCHMARK=1 node --experimental-default-config-file --import tsx --test --experimental-test-coverage '__tests__/**/*.spec.ts' 'kernel/**/__tests__/**/*.spec.ts' 'cli/**/__tests__/**/*.spec.ts' 'server/**/__tests__/**/*.spec.ts' 'plugins/**/__tests__/**/*.spec.ts' 'core/**/__tests__/**/*.spec.ts' 'conformance/**/__tests__/**/*.spec.ts'",
+    "test:coverage:html": "tsc --noEmit && SKILL_MAP_TELEMETRY=0 SKILL_MAP_SKIP_BENCHMARK=1 c8 node --import tsx --test '__tests__/**/*.spec.ts' 'kernel/**/__tests__/**/*.spec.ts' 'cli/**/__tests__/**/*.spec.ts' 'server/**/__tests__/**/*.spec.ts' 'plugins/**/__tests__/**/*.spec.ts' 'core/**/__tests__/**/*.spec.ts' 'conformance/**/__tests__/**/*.spec.ts'",
+    clean: "rm -rf dist coverage"
+  },
+  dependencies: {
+    "@hono/node-server": "2.0.1",
+    "@sentry/node": "10.55.0",
+    "@skill-map/spec": "workspace:*",
+    ajv: "8.18.0",
+    "ajv-formats": "3.0.1",
+    chokidar: "5.0.0",
+    clipanion: "4.0.0-rc.4",
+    hono: "4.12.18",
+    ignore: "7.0.5",
+    "js-tiktoken": "1.0.21",
+    "js-yaml": "4.1.1",
+    kysely: "0.28.17",
+    "posthog-node": "5.35.6",
+    semver: "7.7.4",
+    "smol-toml": "1.6.1",
+    typanion: "3.14.0",
+    ws: "8.21.0"
+  },
+  devDependencies: {
+    "@eslint/js": "10.0.1",
+    "@stylistic/eslint-plugin": "5.10.0",
+    "@types/js-yaml": "4.0.9",
+    "@types/node": "24.12.2",
+    "@types/semver": "7.7.1",
+    "@types/ws": "8.18.1",
+    c8: "11.0.0",
+    eslint: "10.2.1",
+    "eslint-plugin-import-x": "4.16.2",
+    tsup: "8.5.1",
+    tsx: "4.22.3",
+    typescript: "5.9.3",
+    "typescript-eslint": "8.59.1"
+  },
+  engines: {
+    node: ">=24.0"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// version.ts
+var VERSION = package_default.version;
+var BINARY_NAME = "sm";
+var BINARY_LABEL = "skill-map";
+
 // plugins/claude/providers/claude/schemas/skill.schema.json
 var skill_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -481,7 +600,7 @@ var claudeProvider = {
   read: { extensions: [".md"], parser: "frontmatter-yaml" },
   // Per spec § A.6, defaultRefreshAction values MUST be qualified action
   // ids. The summarize-* actions are not yet implemented as registry
-  // entries (they ship later under the Claude bundle), but the qualified
+  // entries (they ship later under the Claude plugin), but the qualified
   // form is the contract: when those actions land, they will register
   // under `claude/summarize-<kind>` and the Provider resolves them
   // deterministically.
@@ -1192,7 +1311,7 @@ var markdown_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
   $id: "https://skill-map.ai/providers/core/v1/frontmatter/markdown.schema.json",
   title: "FrontmatterMarkdown",
-  description: "Frontmatter shape for nodes classified as `markdown` by the built-in `core/markdown` Provider, the universal fallback for any markdown file no vendor-specific Provider claims (Claude, OpenAI Codex, agent-skills, plus the metadata-only Antigravity bundle). The kind is named after the format because the file is a generic fallback; format-named kinds apply only as the generic fallback, a TOML file that IS a Codex agent still classifies as `agent`, not `toml`. Extends the spec's universal `frontmatter/base.schema.json` via $ref-by-$id with no additional fields. Ownership relocated from the Claude Provider in spec 0.18.0, markdown is provider-agnostic and lives under `core` so adding new vendor Providers does not require choosing which one owns the universal fallback.",
+  description: "Frontmatter shape for nodes classified as `markdown` by the built-in `core/markdown` Provider, the universal fallback for any markdown file no vendor-specific Provider claims (Claude, OpenAI Codex, agent-skills, plus the metadata-only Antigravity plugin). The kind is named after the format because the file is a generic fallback; format-named kinds apply only as the generic fallback, a TOML file that IS a Codex agent still classifies as `agent`, not `toml`. Extends the spec's universal `frontmatter/base.schema.json` via $ref-by-$id with no additional fields. Ownership relocated from the Claude Provider in spec 0.18.0, markdown is provider-agnostic and lives under `core` so adding new vendor Providers does not require choosing which one owns the universal fallback.",
   allOf: [
     { $ref: "https://skill-map.ai/spec/v0/frontmatter/base.schema.json" }
   ],
@@ -1223,7 +1342,7 @@ var coreMarkdownProvider = {
   read: { extensions: [".md"], parser: "frontmatter-yaml" },
   // Per spec § A.6, defaultRefreshAction values MUST be qualified
   // action ids. The summarize-markdown action is not yet implemented
-  // as a registry entry (it ships later under the core bundle), but
+  // as a registry entry (it ships later under the core plugin), but
   // the qualified form is the contract.
   //
   // UI presentation: same neutral teal that the per-vendor Providers
@@ -3957,123 +4076,6 @@ var UPDATE_CHECK_TEXTS = {
   availableHint: "Run `npm i -g @skill-map/cli@latest` to update."
 };
 
-// package.json
-var package_default = {
-  name: "@skill-map/cli",
-  version: "0.45.0",
-  description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
-  license: "MIT",
-  type: "module",
-  homepage: "https://skill-map.ai",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/crystian/skill-map.git",
-    directory: "src"
-  },
-  bugs: {
-    url: "https://github.com/crystian/skill-map/issues"
-  },
-  keywords: [
-    "skill-map",
-    "markdown",
-    "ai-agents",
-    "claude-code",
-    "graph"
-  ],
-  bin: {
-    sm: "bin/sm.js",
-    "skill-map": "bin/sm.js"
-  },
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.js"
-    },
-    "./kernel": {
-      types: "./dist/kernel/index.d.ts",
-      import: "./dist/kernel/index.js"
-    },
-    "./conformance": {
-      types: "./dist/conformance/index.d.ts",
-      import: "./dist/conformance/index.js"
-    }
-  },
-  files: [
-    "bin/",
-    "dist/",
-    "migrations/",
-    "README.md"
-  ],
-  scripts: {
-    build: "tsup",
-    dev: "tsup --watch",
-    "dev:serve": "node scripts/dev-serve.js",
-    typecheck: "tsc --noEmit",
-    lint: "eslint .",
-    "lint:fix": "eslint . --fix",
-    "build-built-ins": "node ../scripts/generate-built-ins.js",
-    "built-ins:check": "node ../scripts/generate-built-ins.js --check",
-    prebuild: "pnpm build-built-ins",
-    validate: "pnpm validate:compile && pnpm validate:test",
-    "validate:compile": "pnpm typecheck && pnpm lint && pnpm build && pnpm built-ins:check",
-    "validate:test": "pnpm test:ci",
-    pretest: "tsup",
-    "pretest:coverage": "tsup",
-    "pretest:coverage:html": "tsup",
-    test: "tsc --noEmit && SKILL_MAP_TELEMETRY=0 node --import tsx --test --test-reporter=./scripts/test-reporter.js --test-reporter-destination=stdout '__tests__/**/*.spec.ts' 'kernel/**/__tests__/**/*.spec.ts' 'cli/**/__tests__/**/*.spec.ts' 'server/**/__tests__/**/*.spec.ts' 'plugins/**/__tests__/**/*.spec.ts' 'core/**/__tests__/**/*.spec.ts' 'conformance/**/__tests__/**/*.spec.ts'",
-    "test:ci": "FORCE_COLOR=1 SKILL_MAP_TELEMETRY=0 node --import tsx --test --test-reporter=./scripts/test-reporter.js --test-reporter-destination=stdout '__tests__/**/*.spec.ts' 'kernel/**/__tests__/**/*.spec.ts' 'cli/**/__tests__/**/*.spec.ts' 'server/**/__tests__/**/*.spec.ts' 'plugins/**/__tests__/**/*.spec.ts' 'core/**/__tests__/**/*.spec.ts' 'conformance/**/__tests__/**/*.spec.ts'",
-    "test:spec": "SKILL_MAP_TELEMETRY=0 node --import tsx --test --test-reporter=spec '__tests__/**/*.spec.ts' 'kernel/**/__tests__/**/*.spec.ts' 'cli/**/__tests__/**/*.spec.ts' 'server/**/__tests__/**/*.spec.ts' 'plugins/**/__tests__/**/*.spec.ts' 'core/**/__tests__/**/*.spec.ts' 'conformance/**/__tests__/**/*.spec.ts'",
-    "test:coverage": "tsc --noEmit && SKILL_MAP_TELEMETRY=0 SKILL_MAP_SKIP_BENCHMARK=1 node --experimental-default-config-file --import tsx --test --experimental-test-coverage '__tests__/**/*.spec.ts' 'kernel/**/__tests__/**/*.spec.ts' 'cli/**/__tests__/**/*.spec.ts' 'server/**/__tests__/**/*.spec.ts' 'plugins/**/__tests__/**/*.spec.ts' 'core/**/__tests__/**/*.spec.ts' 'conformance/**/__tests__/**/*.spec.ts'",
-    "test:coverage:html": "tsc --noEmit && SKILL_MAP_TELEMETRY=0 SKILL_MAP_SKIP_BENCHMARK=1 c8 node --import tsx --test '__tests__/**/*.spec.ts' 'kernel/**/__tests__/**/*.spec.ts' 'cli/**/__tests__/**/*.spec.ts' 'server/**/__tests__/**/*.spec.ts' 'plugins/**/__tests__/**/*.spec.ts' 'core/**/__tests__/**/*.spec.ts' 'conformance/**/__tests__/**/*.spec.ts'",
-    clean: "rm -rf dist coverage"
-  },
-  dependencies: {
-    "@hono/node-server": "2.0.1",
-    "@sentry/node": "10.55.0",
-    "@skill-map/spec": "workspace:*",
-    ajv: "8.18.0",
-    "ajv-formats": "3.0.1",
-    chokidar: "5.0.0",
-    clipanion: "4.0.0-rc.4",
-    hono: "4.12.18",
-    ignore: "7.0.5",
-    "js-tiktoken": "1.0.21",
-    "js-yaml": "4.1.1",
-    kysely: "0.28.17",
-    "posthog-node": "5.35.6",
-    semver: "7.7.4",
-    "smol-toml": "1.6.1",
-    typanion: "3.14.0",
-    ws: "8.21.0"
-  },
-  devDependencies: {
-    "@eslint/js": "10.0.1",
-    "@stylistic/eslint-plugin": "5.10.0",
-    "@types/js-yaml": "4.0.9",
-    "@types/node": "24.12.2",
-    "@types/semver": "7.7.1",
-    "@types/ws": "8.18.1",
-    c8: "11.0.0",
-    eslint: "10.2.1",
-    "eslint-plugin-import-x": "4.16.2",
-    tsup: "8.5.1",
-    tsx: "4.22.3",
-    typescript: "5.9.3",
-    "typescript-eslint": "8.59.1"
-  },
-  engines: {
-    node: ">=24.0"
-  },
-  publishConfig: {
-    access: "public"
-  }
-};
-
-// version.ts
-var VERSION = package_default.version;
-var BINARY_NAME = "sm";
-var BINARY_LABEL = "skill-map";
-
 // cli/util/ansi.ts
 var ESC = {
   reset: "\x1B[0m",
@@ -4430,41 +4432,41 @@ var updateCheckHook = {
 };
 
 // plugins/built-ins.ts
-var claudeProvider2 = { ...claudeProvider, pluginId: "claude", version: "0.45.0" };
-var atDirectiveExtractor2 = { ...atDirectiveExtractor, pluginId: "claude", version: "0.45.0" };
-var slashCommandExtractor2 = { ...slashCommandExtractor, pluginId: "claude", version: "0.45.0" };
-var antigravityProvider2 = { ...antigravityProvider, pluginId: "antigravity", version: "0.45.0" };
-var openaiProvider2 = { ...openaiProvider, pluginId: "openai", version: "0.45.0" };
-var agentSkillsProvider2 = { ...agentSkillsProvider, pluginId: "agent-skills", version: "0.45.0" };
-var coreMarkdownProvider2 = { ...coreMarkdownProvider, pluginId: "core", version: "0.45.0" };
-var annotationsExtractor2 = { ...annotationsExtractor, pluginId: "core", version: "0.45.0" };
-var externalUrlCounterExtractor2 = { ...externalUrlCounterExtractor, pluginId: "core", version: "0.45.0" };
-var markdownLinkExtractor2 = { ...markdownLinkExtractor, pluginId: "core", version: "0.45.0" };
-var mcpToolsExtractor2 = { ...mcpToolsExtractor, pluginId: "core", version: "0.45.0" };
-var toolsCounterExtractor2 = { ...toolsCounterExtractor, pluginId: "core", version: "0.45.0" };
-var annotationFieldUnknownAnalyzer2 = { ...annotationFieldUnknownAnalyzer, pluginId: "core", version: "0.45.0" };
-var annotationOrphanAnalyzer2 = { ...annotationOrphanAnalyzer, pluginId: "core", version: "0.45.0" };
-var annotationStaleAnalyzer2 = { ...annotationStaleAnalyzer, pluginId: "core", version: "0.45.0" };
-var contributionOrphanAnalyzer2 = { ...contributionOrphanAnalyzer, pluginId: "core", version: "0.45.0" };
-var issueCounterAnalyzer2 = { ...issueCounterAnalyzer, pluginId: "core", version: "0.45.0" };
-var jobFileOrphanAnalyzer2 = { ...jobFileOrphanAnalyzer, pluginId: "core", version: "0.45.0" };
-var linkConflictAnalyzer2 = { ...linkConflictAnalyzer, pluginId: "core", version: "0.45.0" };
-var linkCounterAnalyzer2 = { ...linkCounterAnalyzer, pluginId: "core", version: "0.45.0" };
-var linkSelfLoopAnalyzer2 = { ...linkSelfLoopAnalyzer, pluginId: "core", version: "0.45.0" };
-var nameReservedAnalyzer2 = { ...nameReservedAnalyzer, pluginId: "core", version: "0.45.0" };
-var nodeStabilityAnalyzer2 = { ...nodeStabilityAnalyzer, pluginId: "core", version: "0.45.0" };
-var nodeSupersededAnalyzer2 = { ...nodeSupersededAnalyzer, pluginId: "core", version: "0.45.0" };
-var referenceBrokenAnalyzer2 = { ...referenceBrokenAnalyzer, pluginId: "core", version: "0.45.0" };
-var referenceRedundantAnalyzer2 = { ...referenceRedundantAnalyzer, pluginId: "core", version: "0.45.0" };
-var schemaViolationAnalyzer2 = { ...schemaViolationAnalyzer, pluginId: "core", version: "0.45.0" };
-var signalCollisionAnalyzer2 = { ...signalCollisionAnalyzer, pluginId: "core", version: "0.45.0" };
-var triggerCollisionAnalyzer2 = { ...triggerCollisionAnalyzer, pluginId: "core", version: "0.45.0" };
-var asciiFormatter2 = { ...asciiFormatter, pluginId: "core", version: "0.45.0" };
-var jsonFormatter2 = { ...jsonFormatter, pluginId: "core", version: "0.45.0" };
-var nodeBumpAction2 = { ...nodeBumpAction, pluginId: "core", version: "0.45.0" };
-var nodeSupersedeAction2 = { ...nodeSupersedeAction, pluginId: "core", version: "0.45.0" };
-var updateCheckHook2 = { ...updateCheckHook, pluginId: "core", version: "0.45.0" };
-var builtInBundles = [
+var claudeProvider2 = { ...claudeProvider, pluginId: "claude", version: VERSION };
+var atDirectiveExtractor2 = { ...atDirectiveExtractor, pluginId: "claude", version: VERSION };
+var slashCommandExtractor2 = { ...slashCommandExtractor, pluginId: "claude", version: VERSION };
+var antigravityProvider2 = { ...antigravityProvider, pluginId: "antigravity", version: VERSION };
+var openaiProvider2 = { ...openaiProvider, pluginId: "openai", version: VERSION };
+var agentSkillsProvider2 = { ...agentSkillsProvider, pluginId: "agent-skills", version: VERSION };
+var coreMarkdownProvider2 = { ...coreMarkdownProvider, pluginId: "core", version: VERSION };
+var annotationsExtractor2 = { ...annotationsExtractor, pluginId: "core", version: VERSION };
+var externalUrlCounterExtractor2 = { ...externalUrlCounterExtractor, pluginId: "core", version: VERSION };
+var markdownLinkExtractor2 = { ...markdownLinkExtractor, pluginId: "core", version: VERSION };
+var mcpToolsExtractor2 = { ...mcpToolsExtractor, pluginId: "core", version: VERSION };
+var toolsCounterExtractor2 = { ...toolsCounterExtractor, pluginId: "core", version: VERSION };
+var annotationFieldUnknownAnalyzer2 = { ...annotationFieldUnknownAnalyzer, pluginId: "core", version: VERSION };
+var annotationOrphanAnalyzer2 = { ...annotationOrphanAnalyzer, pluginId: "core", version: VERSION };
+var annotationStaleAnalyzer2 = { ...annotationStaleAnalyzer, pluginId: "core", version: VERSION };
+var contributionOrphanAnalyzer2 = { ...contributionOrphanAnalyzer, pluginId: "core", version: VERSION };
+var issueCounterAnalyzer2 = { ...issueCounterAnalyzer, pluginId: "core", version: VERSION };
+var jobFileOrphanAnalyzer2 = { ...jobFileOrphanAnalyzer, pluginId: "core", version: VERSION };
+var linkConflictAnalyzer2 = { ...linkConflictAnalyzer, pluginId: "core", version: VERSION };
+var linkCounterAnalyzer2 = { ...linkCounterAnalyzer, pluginId: "core", version: VERSION };
+var linkSelfLoopAnalyzer2 = { ...linkSelfLoopAnalyzer, pluginId: "core", version: VERSION };
+var nameReservedAnalyzer2 = { ...nameReservedAnalyzer, pluginId: "core", version: VERSION };
+var nodeStabilityAnalyzer2 = { ...nodeStabilityAnalyzer, pluginId: "core", version: VERSION };
+var nodeSupersededAnalyzer2 = { ...nodeSupersededAnalyzer, pluginId: "core", version: VERSION };
+var referenceBrokenAnalyzer2 = { ...referenceBrokenAnalyzer, pluginId: "core", version: VERSION };
+var referenceRedundantAnalyzer2 = { ...referenceRedundantAnalyzer, pluginId: "core", version: VERSION };
+var schemaViolationAnalyzer2 = { ...schemaViolationAnalyzer, pluginId: "core", version: VERSION };
+var signalCollisionAnalyzer2 = { ...signalCollisionAnalyzer, pluginId: "core", version: VERSION };
+var triggerCollisionAnalyzer2 = { ...triggerCollisionAnalyzer, pluginId: "core", version: VERSION };
+var asciiFormatter2 = { ...asciiFormatter, pluginId: "core", version: VERSION };
+var jsonFormatter2 = { ...jsonFormatter, pluginId: "core", version: VERSION };
+var nodeBumpAction2 = { ...nodeBumpAction, pluginId: "core", version: VERSION };
+var nodeSupersedeAction2 = { ...nodeSupersedeAction, pluginId: "core", version: VERSION };
+var updateCheckHook2 = { ...updateCheckHook, pluginId: "core", version: VERSION };
+var builtInPlugins = [
   {
     id: "claude",
     description: "Claude Code platform integration. Classifies files under `.claude/{agents,commands,skills}` and detects Claude-flavored slash commands and at-directives in their bodies.",
@@ -4539,8 +4541,8 @@ function builtIns() {
     actions: [],
     hooks: []
   };
-  for (const bundle of builtInBundles) {
-    for (const ext of bundle.extensions) {
+  for (const plugin of builtInPlugins) {
+    for (const ext of plugin.extensions) {
       bucketBuiltIn(ext, out);
     }
   }
@@ -4548,8 +4550,8 @@ function builtIns() {
 }
 function listBuiltIns() {
   const out = [];
-  for (const bundle of builtInBundles) {
-    for (const x of bundle.extensions) {
+  for (const plugin of builtInPlugins) {
+    for (const x of plugin.extensions) {
       out.push(toExtensionRow(x));
     }
   }
@@ -4603,6 +4605,8 @@ var ENTRY_TEXTS = {
   parseErrorFlagSuggestion: "Did you mean '{{suggestion}}'?",
   parseErrorVerbSuggestion: "Did you mean {{suggestions}}?",
   parseErrorVerbHelpHint: "Run 'sm help {{verb}}' for usage.",
+  /** Footer for the incomplete-namespace error, points at that namespace's overview. */
+  parseErrorNamespaceHelpHint: "Run 'sm help {{name}}' to see all subcommands.",
   parseErrorFooter: "Run 'sm help' to see the full command list."
 };
 
@@ -4891,7 +4895,8 @@ function formatParseError(params) {
     const suggestion2 = tx(ENTRY_TEXTS.parseErrorSubcommandList, {
       suggestions: formatSuggestionList(subcommands)
     });
-    return renderError(headline, suggestion2);
+    const footer = tx(ENTRY_TEXTS.parseErrorNamespaceHelpHint, { name: firstToken });
+    return renderError(headline, suggestion2, footer);
   }
   const candidates = closestVerbs(firstToken, verbPaths);
   const suggestion = candidates.length > 0 ? tx(ENTRY_TEXTS.parseErrorVerbSuggestion, { suggestions: formatSuggestionList(candidates) }) : null;
@@ -4932,10 +4937,10 @@ function matchedVerbPrefix(args2, verbPaths) {
   }
   return best.join(" ");
 }
-function renderError(headline, suggestion) {
+function renderError(headline, suggestion, footer = ENTRY_TEXTS.parseErrorFooter) {
   const lines = [tx(ENTRY_TEXTS.parseErrorHeadline, { message: headline })];
   if (suggestion) lines.push(suggestion);
-  lines.push(ENTRY_TEXTS.parseErrorFooter);
+  lines.push(footer);
   return lines.join("\n") + "\n";
 }
 function extractOffendingFlag(message) {
@@ -5107,7 +5112,7 @@ async function initSentryCli(version, loadSdk = () => import("@sentry/node")) {
   const Sentry = await loadSdk();
   Sentry.init({
     dsn: SENTRY_DSN_NODE,
-    release: `@skill-map/cli@${version}`,
+    release: `skill-map-cli@${version}`,
     environment: resolveTelemetryEnv(),
     // CLI and BFF share one Sentry project; the `surface` tag tells their
     // events apart in the shared issue stream.
@@ -5365,16 +5370,13 @@ function kernelLocalSettingsPath(scopeRoot) {
 // config/defaults.json
 var defaults_default = {
   schemaVersion: 1,
-  autoMigrate: true,
   allowEditSmFiles: false,
   tokenizer: "cl100k_base",
-  providers: [],
   roots: [],
   ignore: [],
   scan: {
     tokenize: true,
     strict: false,
-    followSymlinks: false,
     maxFileSizeBytes: 1048576,
     maxNodes: 256,
     watch: {
@@ -5383,9 +5385,6 @@ var defaults_default = {
     referencePaths: []
   },
   plugins: {},
-  history: {
-    share: false
-  },
   jobs: {
     ttlSeconds: 3600,
     graceMultiplier: 3,
@@ -5396,9 +5395,6 @@ var defaults_default = {
       completed: 2592e3,
       failed: null
     }
-  },
-  i18n: {
-    locale: "en"
   }
 };
 
@@ -7510,6 +7506,7 @@ async function loadScanResult(db) {
       version: metaRow.scannedByVersion,
       specVersion: metaRow.scannedBySpecVersion
     };
+    const oversizedFiles = parseJsonArray(metaRow.oversizedFilesJson);
     return {
       schemaVersion: 1,
       scannedAt: metaRow.scannedAt,
@@ -7518,12 +7515,14 @@ async function loadScanResult(db) {
       scannedBy,
       recommendedNodeLimit: metaRow.recommendedNodeLimit,
       overrideMaxNodes: metaRow.overrideMaxNodes,
+      oversizedFiles,
       nodes,
       links,
       issues,
       stats: {
         filesWalked: metaRow.statsFilesWalked,
         filesSkipped: metaRow.statsFilesSkipped,
+        filesOversized: metaRow.filesOversized,
         nodesCount: nodes.length,
         linksCount: links.length,
         issuesCount: issues.length,
@@ -7546,12 +7545,14 @@ async function loadScanResult(db) {
     // scan overwrites scan_meta with the live values on next run.
     recommendedNodeLimit: 256,
     overrideMaxNodes: null,
+    oversizedFiles: [],
     nodes,
     links,
     issues,
     stats: {
       filesWalked: 0,
       filesSkipped: 0,
+      filesOversized: 0,
       nodesCount: nodes.length,
       linksCount: links.length,
       issuesCount: issues.length,
@@ -8128,7 +8129,15 @@ function metaToRow(result) {
     statsFilesWalked: result.stats.filesWalked,
     statsFilesSkipped: result.stats.filesSkipped,
     statsDurationMs: result.stats.durationMs,
-    ...projectNodeLimitColumns(result)
+    ...projectNodeLimitColumns(result),
+    ...projectOversizedColumns(result)
+  };
+}
+function projectOversizedColumns(result) {
+  const oversized = result.oversizedFiles ?? [];
+  return {
+    filesOversized: result.stats.filesOversized ?? oversized.length,
+    oversizedFilesJson: oversized.length > 0 ? JSON.stringify(oversized) : null
   };
 }
 function projectNodeLimitColumns(result) {
@@ -9452,6 +9461,7 @@ var PLUGIN_LOADER_TEXTS = {
   invalidManifestDirMismatch: "directory name '{{dirName}}' does not match manifest id '{{manifestId}}'. Rename the directory to match the id, or update the manifest id to match the directory.",
   idCollision: "Plugin '{{id}}' at {{pathA}} collides with the plugin at {{pathB}}. Rename one and rerun.",
   loadErrorPluginIdMismatch: "{{relEntry}}: extension declares pluginId '{{declared}}' but its plugin.json declares id '{{manifestId}}'. Remove the explicit pluginId from the extension; the loader injects it from plugin.json#/id.",
+  invalidManifestRedeclaredField: "{{relEntry}}: extension manifest declares {{fields}}, derived from the folder layout (structure-as-truth) and not a manifest field. Remove it: id is the leaf folder, kind the parent folder, provider kinds the `kinds/` catalog, formatter formatId the formatter folder name.",
   loadErrorStorageSchemaRead: "plugin '{{pluginId}}' failed to load schema for table '{{table}}': {{schemaPath}}: {{errDescription}}",
   loadErrorStorageSchemaCompile: "plugin '{{pluginId}}' failed to compile schema for table '{{table}}': {{schemaPath}}: {{errDescription}}",
   loadErrorStorageKvSchemaRead: "plugin '{{pluginId}}' failed to load KV schema: {{schemaPath}}: {{errDescription}}",
@@ -9556,7 +9566,7 @@ function extractDefault(mod) {
   if (!isRecord(mod)) return mod;
   return "default" in mod ? mod["default"] : mod;
 }
-var LOADER_INJECTED_KEYS = /* @__PURE__ */ new Set(["pluginId", "id", "kind", "kinds", "formatId"]);
+var LOADER_INJECTED_KEYS = /* @__PURE__ */ new Set(["pluginId"]);
 function stripFunctionsAndPluginId(input) {
   if (!isRecord(input)) return input;
   const out = {};
@@ -10177,6 +10187,21 @@ var PluginLoader = class {
         manifest
       } };
     }
+    const redeclared = DERIVED_MANIFEST_KEYS.filter((field) => field in exported);
+    if (redeclared.length > 0) {
+      return { ok: false, failure: {
+        ...fail(
+          pluginPath,
+          pluginId,
+          "invalid-manifest",
+          tx(PLUGIN_LOADER_TEXTS.invalidManifestRedeclaredField, {
+            relEntry,
+            fields: redeclared.map((field) => `\`${field}\``).join(", ")
+          })
+        ),
+        manifest
+      } };
+    }
     const manifestView = stripFunctionsAndPluginId(exported);
     if (kind === "hook") {
       const hookFailure = validateHookTriggers(pluginPath, pluginId, manifest, relEntry, exported, manifestView);
@@ -10233,8 +10258,7 @@ var PluginLoader = class {
     const instance = { ...exported, pluginId, id: pathId2, kind };
     if (kind === "formatter") instance["formatId"] = pathId2;
     if (kind === "provider" && discoveredKinds) {
-      const inlineKinds = isRecord(exported["kinds"]) ? exported["kinds"] : {};
-      instance["kinds"] = { ...inlineKinds, ...discoveredKinds };
+      instance["kinds"] = discoveredKinds;
     }
     return { ok: true, extension: {
       kind,
@@ -10247,6 +10271,7 @@ var PluginLoader = class {
     } };
   }
 };
+var DERIVED_MANIFEST_KEYS = ["id", "kind", "kinds", "formatId"];
 var KIND_DIR_NAMES = [
   "providers",
   "extractors",
@@ -10365,11 +10390,11 @@ function makeEnabledResolver(cfg, dbOverrides) {
 function defaultResolveEnabled(_id) {
   return true;
 }
-function isBuiltInExtensionEnabled(bundle, ext, resolveEnabled) {
-  return isBundleEntryEnabled(bundle, ext.id, resolveEnabled);
+function isBuiltInExtensionEnabled(plugin, ext, resolveEnabled) {
+  return isPluginEntryEnabled(plugin, ext.id, resolveEnabled);
 }
-function isBundleEntryEnabled(bundle, extId, resolveEnabled) {
-  return resolveEnabled(qualifiedExtensionId(bundle.id, extId));
+function isPluginEntryEnabled(plugin, extId, resolveEnabled) {
+  return resolveEnabled(qualifiedExtensionId(plugin.id, extId));
 }
 function isPluginExtensionEnabled(ext, resolveEnabled) {
   return resolveEnabled(qualifiedExtensionId(ext.pluginId, ext.id));
@@ -10568,8 +10593,9 @@ async function* walkContent(roots, options) {
   if (!parser) throw new UnknownParserError(options.parser);
   const filter = options.ignoreFilter ?? buildIgnoreFilter();
   const extensions = options.extensions;
+  const sizeLimit = buildSizeLimit(options);
   for (const root of roots) {
-    for await (const file of walkRoot(root, root, filter, extensions)) {
+    for await (const file of walkRoot(root, root, filter, extensions, sizeLimit)) {
       const relPath = relative2(root, file).split(sep3).join("/");
       let raw;
       try {
@@ -10592,7 +10618,15 @@ async function* walkContent(roots, options) {
     }
   }
 }
-async function* walkRoot(root, current, filter, extensions) {
+function buildSizeLimit(options) {
+  const sizeLimit = {};
+  if (options.maxFileSizeBytes !== void 0) {
+    sizeLimit.maxFileSizeBytes = options.maxFileSizeBytes;
+  }
+  if (options.onOversizedFile) sizeLimit.onOversizedFile = options.onOversizedFile;
+  return sizeLimit;
+}
+async function* walkRoot(root, current, filter, extensions, sizeLimit) {
   let entries;
   try {
     entries = await readdir(current, { withFileTypes: true, encoding: "utf8" });
@@ -10606,11 +10640,16 @@ async function* walkRoot(root, current, filter, extensions) {
     if (filter.ignores(rel)) continue;
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
-      yield* walkRoot(root, full, filter, extensions);
+      yield* walkRoot(root, full, filter, extensions, sizeLimit);
     } else if (entry.isFile() && hasMatchingExtension(name, extensions)) {
       try {
         const s = await lstat(full);
-        if (s.isFile()) yield full;
+        if (!s.isFile()) continue;
+        if (sizeLimit.maxFileSizeBytes !== void 0 && s.size > sizeLimit.maxFileSizeBytes) {
+          sizeLimit.onOversizedFile?.({ path: rel, bytes: s.size });
+          continue;
+        }
+        yield full;
       } catch {
       }
     }
@@ -10640,6 +10679,10 @@ function resolveProviderWalk(provider) {
       parser: read.parser
     };
     if (options?.ignoreFilter) walkOptions.ignoreFilter = options.ignoreFilter;
+    if (options?.maxFileSizeBytes !== void 0) {
+      walkOptions.maxFileSizeBytes = options.maxFileSizeBytes;
+    }
+    if (options?.onOversizedFile) walkOptions.onOversizedFile = options.onOversizedFile;
     return walkContent(roots, walkOptions);
   };
 }
@@ -10674,19 +10717,19 @@ function collectViewContributions(pluginId, extensionId, instance, out, options
 }
 
 // core/runtime/plugin-runtime/bucketing.ts
-function bucketLoaded(loaded, bundle) {
+function bucketLoaded(loaded, runtime) {
   for (const ext of loaded) {
     const instance = ext.instance;
     if (!isExtensionInstance(instance)) continue;
     bucketByKind(ext.kind, instance, {
-      provider: bundle.extensions.providers,
-      extractor: bundle.extensions.extractors,
-      analyzer: bundle.extensions.analyzers,
-      formatter: bundle.extensions.formatters,
-      hook: bundle.extensions.hooks
+      provider: runtime.extensions.providers,
+      extractor: runtime.extensions.extractors,
+      analyzer: runtime.extensions.analyzers,
+      formatter: runtime.extensions.formatters,
+      hook: runtime.extensions.hooks
       // `action` intentionally absent, see docstring.
     });
-    bundle.manifests.push({
+    runtime.manifests.push({
       id: ext.id,
       pluginId: ext.pluginId,
       kind: ext.kind,
@@ -10694,8 +10737,8 @@ function bucketLoaded(loaded, bundle) {
       description: instance.description ?? "",
       ...ext.entryPath ? { entry: ext.entryPath } : {}
     });
-    collectAnnotationContributions(ext.pluginId, instance, bundle.annotationContributions);
-    collectViewContributions(ext.pluginId, ext.id, instance, bundle.viewContributions);
+    collectAnnotationContributions(ext.pluginId, instance, runtime.annotationContributions);
+    collectViewContributions(ext.pluginId, ext.id, instance, runtime.viewContributions);
   }
 }
 function collectAnnotationContributions(pluginId, instance, out) {
@@ -10753,8 +10796,8 @@ var PLUGIN_RUNTIME_TEXTS = {
 // core/runtime/plugin-runtime/warnings.ts
 var PLUGIN_ID_DISPLAY_CAP = 200;
 var PLUGIN_REASON_DISPLAY_CAP = 1e3;
-function emitWarnings(bundle, printer) {
-  for (const warn of bundle.warnings) {
+function emitWarnings(runtime, printer) {
+  for (const warn of runtime.warnings) {
     printer.warn(`${warn}
 `);
   }
@@ -10793,7 +10836,7 @@ async function loadPluginRuntime(opts = {}) {
   if (resolveEnabled) loaderOpts.resolveEnabled = resolveEnabled;
   const loader = createPluginLoader(loaderOpts);
   const discovered = await loader.discoverAndLoadAll();
-  const bundle = {
+  const runtime = {
     extensions: { providers: [], extractors: [], analyzers: [], formatters: [], hooks: [] },
     annotationContributions: [],
     viewContributions: [],
@@ -10807,14 +10850,14 @@ async function loadPluginRuntime(opts = {}) {
   };
   for (const plugin of discovered) {
     if (plugin.status === "enabled") {
-      bucketLoaded(plugin.extensions ?? [], bundle);
+      bucketLoaded(plugin.extensions ?? [], runtime);
       continue;
     }
     if (plugin.status === "disabled") continue;
-    bundle.warnings.push(formatWarning(plugin));
+    runtime.warnings.push(formatWarning(plugin));
   }
-  enforceRootExclusivity(bundle.annotationContributions);
-  return bundle;
+  enforceRootExclusivity(runtime.annotationContributions);
+  return runtime;
 }
 var AnnotationContributionConflictError = class extends Error {
   /** The colliding root-exclusive key. */
@@ -10848,7 +10891,7 @@ function enforceRootExclusivity(catalog) {
   }
 }
 function emptyPluginRuntime() {
-  const bundle = {
+  const runtime = {
     extensions: { providers: [], extractors: [], analyzers: [], formatters: [], hooks: [] },
     annotationContributions: [],
     viewContributions: [],
@@ -10860,7 +10903,7 @@ function emptyPluginRuntime() {
       emitWarnings(this, printer);
     }
   };
-  return bundle;
+  return runtime;
 }
 
 // core/runtime/plugin-runtime/catalogs.ts
@@ -10878,12 +10921,12 @@ function collectRegisteredContributionKeys(composed) {
   return keys;
 }
 function filterBuiltInManifests(manifests, resolveEnabled) {
-  const bundleByPluginId = /* @__PURE__ */ new Map();
-  for (const bundle of builtInBundles) bundleByPluginId.set(bundle.id, bundle);
+  const pluginById = /* @__PURE__ */ new Map();
+  for (const plugin of builtInPlugins) pluginById.set(plugin.id, plugin);
   return manifests.filter((m) => {
-    const bundle = bundleByPluginId.get(m.pluginId);
-    if (!bundle) return true;
-    return isBundleEntryEnabled(bundle, m.id, resolveEnabled);
+    const plugin = pluginById.get(m.pluginId);
+    if (!plugin) return true;
+    return isPluginEntryEnabled(plugin, m.id, resolveEnabled);
   });
 }
 
@@ -10926,9 +10969,9 @@ function composeScanExtensions(opts) {
   };
 }
 function accumulateBuiltInScanExtensions(buckets, resolveEnabled) {
-  for (const bundle of builtInBundles) {
-    for (const ext of bundle.extensions) {
-      if (!isBuiltInExtensionEnabled(bundle, ext, resolveEnabled)) continue;
+  for (const plugin of builtInPlugins) {
+    for (const ext of plugin.extensions) {
+      if (!isBuiltInExtensionEnabled(plugin, ext, resolveEnabled)) continue;
       switch (ext.kind) {
         case "provider":
           buckets.providers.push(ext);
@@ -10959,10 +11002,10 @@ function composeFormatters(opts) {
   const resolveEnabled = opts.resolveEnabled ?? opts.pluginRuntime.resolveEnabled;
   const out = [];
   if (!noBuiltIns) {
-    for (const bundle of builtInBundles) {
-      for (const ext of bundle.extensions) {
+    for (const plugin of builtInPlugins) {
+      for (const ext of plugin.extensions) {
         if (ext.kind !== "formatter") continue;
-        if (!isBuiltInExtensionEnabled(bundle, ext, resolveEnabled)) continue;
+        if (!isBuiltInExtensionEnabled(plugin, ext, resolveEnabled)) continue;
         out.push(ext);
       }
     }
@@ -10998,9 +11041,9 @@ function registerEnabledExtensions(kernel, pluginRuntime, options = {}) {
     );
     const merged = [...userContribs];
     if (!noBuiltIns) {
-      for (const bundle of builtInBundles) {
-        for (const ext of bundle.extensions) {
-          if (!isBundleEntryEnabled(bundle, ext.id, resolveEnabled)) continue;
+      for (const plugin of builtInPlugins) {
+        for (const ext of plugin.extensions) {
+          if (!isPluginEntryEnabled(plugin, ext.id, resolveEnabled)) continue;
           collectViewContributions(ext.pluginId, ext.id, ext, merged);
         }
       }
@@ -11408,7 +11451,6 @@ var CONFIG_TEXTS = {
   listSectionScan: "Scan",
   listSectionJobs: "Jobs",
   listSectionRootsAndPlugins: "Roots & plugins",
-  listSectionHistory: "History",
   listSectionOther: "Other"
 };
 
@@ -11525,15 +11567,14 @@ var ConfigListCommand = class extends SmCommand {
 var SECTION_DEFS = [
   {
     title: CONFIG_TEXTS.listSectionGeneral,
-    exactKeys: ["autoMigrate", "schemaVersion", "tokenizer", "i18n.locale"]
+    exactKeys: ["schemaVersion", "tokenizer"]
   },
   { title: CONFIG_TEXTS.listSectionScan, prefix: "scan.", stripPrefix: true },
   { title: CONFIG_TEXTS.listSectionJobs, prefix: "jobs.", stripPrefix: true },
   {
     title: CONFIG_TEXTS.listSectionRootsAndPlugins,
-    exactKeys: ["roots", "providers", "plugins", "ignore"]
-  },
-  { title: CONFIG_TEXTS.listSectionHistory, prefix: "history.", stripPrefix: true }
+    exactKeys: ["roots", "plugins", "ignore"]
+  }
 ];
 function renderConfigSections(rows, ansi) {
   const out = [];
@@ -12451,12 +12492,12 @@ function collectProviderScopes(specRoot) {
   }
   const pluginsRoot = resolve21(workspaceRoot, "plugins");
   if (!existsSync17(pluginsRoot)) return out;
-  for (const bundleEntry of readdirSync6(pluginsRoot)) {
-    const bundleDir = resolve21(pluginsRoot, bundleEntry);
-    if (!isDir(bundleDir)) continue;
-    const providersRoot = resolve21(bundleDir, "providers");
+  for (const pluginEntry of readdirSync6(pluginsRoot)) {
+    const pluginDir = resolve21(pluginsRoot, pluginEntry);
+    if (!isDir(pluginDir)) continue;
+    const providersRoot = resolve21(pluginDir, "providers");
     if (!isDir(providersRoot)) continue;
-    collectBundleProviderScopes(providersRoot, specRoot, out);
+    collectPluginProviderScopes(providersRoot, specRoot, out);
   }
   return out;
 }
@@ -12467,7 +12508,7 @@ function isDir(path) {
     return false;
   }
 }
-function collectBundleProviderScopes(providersRoot, specRoot, out) {
+function collectPluginProviderScopes(providersRoot, specRoot, out) {
   for (const entry of readdirSync6(providersRoot)) {
     const providerDir = resolve21(providersRoot, entry);
     if (!isDir(providerDir)) continue;
@@ -14214,6 +14255,22 @@ var HELP_TEXTS = {
   /** Trailing fragment for `humanFlagRow`'s `{{required}}` slot. */
   humanFlagRowRequiredFragment: " (required)",
   humanFooter: "Run `sm help {{name}} --format md` for the full reference.",
+  // --- human group renderer (sm <namespace> --help, sm help <namespace>) ---
+  /**
+   * USAGE row for a command namespace (a prefix that owns subcommands but
+   * is not itself a runnable verb, e.g. `plugins`, `db`). Mirrors
+   * `humanUsageRow` but advertises the `<command>` slot instead of
+   * positionals.
+   */
+  humanGroupUsageRow: "  sm {{name}} <command> [options]",
+  /** Section heading listing the subcommands of a namespace. */
+  humanCommandsHeading: "COMMANDS",
+  /** Aligned subcommand row; `{{name}}` is the subcommand relative to the namespace. */
+  humanCommandRow: "  {{name}}{{padding}}  {{description}}",
+  /** Footer for the namespace overview, points at per-subcommand help. */
+  humanGroupFooter: "Run `sm {{name}} <command> --help` for flags and arguments.",
+  /** Fallback header description when a namespace has no curated entry in `HELP_GROUPS`. */
+  groupFallbackDescription: "{{category}} commands",
   // --- human compact overview (sm / sm --help / sm help, no verb) ---------
   /**
    * Compact-overview header. Replaces the Clipanion default ANSI banner.
@@ -14244,6 +14301,40 @@ var HELP_TEXTS = {
   compactExampleRow: "  {{command}}{{padding}}  {{description}}",
   compactFooter: "Run `sm <command> --help` for flags and arguments."
 };
+var HELP_GROUPS = {
+  plugins: {
+    description: "Discover, inspect, and toggle plugins",
+    details: "A plugin is a directory of extensions (extractors, analyzers, actions,\nhooks, formatters, providers) discovered under the project plugins dir.\n\nUse `list` and `show` to inspect what loaded, `doctor` to diagnose load\nfailures, `enable` / `disable` to toggle extensions (persisted in the DB),\nand `create` / `upgrade` to scaffold and migrate your own."
+  },
+  config: {
+    description: "Read and write project configuration",
+    details: "Configuration is a layered merge: library defaults, the committed\n`settings.json`, the gitignored `settings.local.json`, env vars, then\nCLI flags, with later layers winning.\n\nUse `list` / `get` to read the effective values, `show --source` to see\nwhich layer set a key, and `set` / `reset` to write or revert one.\nPrivacy-sensitive keys (paths outside the project) require `--yes`."
+  },
+  db: {
+    description: "Inspect and maintain the project database",
+    details: "The project database is a single SQLite file at\n`.skill-map/skill-map.db`, holding the scan graph and plugin state.\n\nUse `backup` / `restore` around risky operations, `migrate` to apply\npending kernel and plugin migrations, `reset` to drop tables (or the\nwhole file), and `dump` / `shell` / `browser` to inspect the data."
+  },
+  job: {
+    description: "Manage the background job queue",
+    details: "Probabilistic and long-running work runs as jobs: queued, persisted in\nthe database, and resumable across restarts.\n\nUse `submit` to enqueue (or `--all` to fan out across nodes), `run` to\nexecute the claim-spawn-record loop, `status` / `list` / `show` to\ninspect, `preview` to render a job without executing it, and\n`cancel` / `prune` to clean up."
+  },
+  actions: {
+    description: "Inspect the registered Action catalog",
+    details: "An Action operates on one or more nodes and is either deterministic\n(in-process code) or probabilistic (a rendered prompt a runner executes).\n\nUse `list` for the catalog of registered action types and `show` for a\nsingle action's full manifest, including its preconditions and expected\nduration."
+  },
+  sidecar: {
+    description: "Manage `.sm` annotation sidecars",
+    details: "Skill-map's annotation layer lives in co-located `.sm` YAML sidecars\nnext to each node, leaving the vendor file untouched.\n\nUse `annotate` to scaffold an empty sidecar ready for editing, `refresh`\nto realign its drift hashes with the live node, and `prune` to delete\nsidecars whose `.md` no longer exists."
+  },
+  hooks: {
+    description: "Install git hooks for sidecar drift",
+    details: "Git hooks keep your sidecars in sync with the repo as you commit.\n\n`install` writes a pre-commit hook that auto-bumps staged sidecar drift\nbefore each commit."
+  },
+  conformance: {
+    description: "Run the spec conformance suite",
+    details: "The conformance suite checks an implementation against the spec.\n\n`run` executes the spec-owned cases plus every built-in Provider and\nreports the results."
+  }
+};
 
 // cli/commands/help.ts
 var HelpCommand = class extends Command15 {
@@ -14282,18 +14373,23 @@ var HelpCommand = class extends Command15 {
     const verb = this.verbParts.join(" ").trim();
     if (verb) {
       const target = verbs.find((v) => v.name === verb);
-      if (!target) {
-        this.context.stderr.write(
-          tx(HELP_TEXTS.unknownVerb, {
-            glyph: errGlyph,
-            verb,
-            hint: ansi.dim(HELP_TEXTS.unknownVerbHint)
-          })
-        );
-        return ExitCode.NotFound;
+      if (target) {
+        this.context.stdout.write(renderSingle(target, format));
+        return ExitCode.Ok;
       }
-      this.context.stdout.write(renderSingle(target, format));
-      return ExitCode.Ok;
+      const subcommands = verbs.filter((v) => v.name.startsWith(verb + " "));
+      if (subcommands.length > 0) {
+        this.context.stdout.write(renderGroup(verb, subcommands, format));
+        return ExitCode.Ok;
+      }
+      this.context.stderr.write(
+        tx(HELP_TEXTS.unknownVerb, {
+          glyph: errGlyph,
+          verb,
+          hint: ansi.dim(HELP_TEXTS.unknownVerbHint)
+        })
+      );
+      return ExitCode.NotFound;
     }
     if (format === "human") {
       this.context.stdout.write(renderCompactOverview(verbs));
@@ -14480,6 +14576,51 @@ function renderSingle(verb, format) {
   }
   return renderSingleHuman(verb);
 }
+function renderGroup(group, subcommands, format) {
+  if (format === "json" || format === "md") {
+    const doc = {
+      cliVersion: VERSION,
+      specVersion: resolveSpecVersion(),
+      globalFlags: [],
+      verbs: subcommands
+    };
+    return format === "json" ? JSON.stringify(doc, null, 2) + "\n" : renderMarkdown2(doc);
+  }
+  return renderGroupHuman(group, subcommands);
+}
+function renderGroupHuman(group, subcommands) {
+  const meta = HELP_GROUPS[group];
+  const description = meta?.description ?? tx(HELP_TEXTS.groupFallbackDescription, { category: subcommands[0]?.category ?? "Other" });
+  const out = [];
+  out.push(tx(HELP_TEXTS.humanVerbHeader, { name: group, description }));
+  out.push("");
+  out.push(HELP_TEXTS.humanUsageHeading);
+  out.push(tx(HELP_TEXTS.humanGroupUsageRow, { name: group }));
+  if (meta?.details) out.push(...renderHumanDescription(meta.details));
+  out.push(...renderGroupCommands(group, subcommands));
+  out.push("");
+  out.push(tx(HELP_TEXTS.humanGroupFooter, { name: group }));
+  return out.join("\n") + "\n";
+}
+function renderGroupCommands(group, subcommands) {
+  const out = ["", HELP_TEXTS.humanCommandsHeading];
+  const sorted = [...subcommands].sort((a, b) => a.name.localeCompare(b.name));
+  const labels = sorted.map((v) => v.name.slice(group.length + 1));
+  const width = Math.max(...labels.map((l) => l.length));
+  for (let i = 0; i < sorted.length; i++) {
+    const verb = sorted[i];
+    const label = labels[i];
+    const { isStub, clean } = classifyDescription(verb.description);
+    const description = (isStub ? HELP_TEXTS.compactStubMarker : "") + firstSentence(clean);
+    const row = tx(HELP_TEXTS.humanCommandRow, {
+      name: label,
+      padding: padRight("", width - label.length),
+      description
+    });
+    out.push(truncate2(row, COMPACT_ROW_MAX));
+  }
+  return out;
+}
 function renderSingleHuman(verb) {
   const out = [];
   out.push(buildHumanHeader(verb));
@@ -14611,7 +14752,7 @@ function routeHelpArgs(args2, cli2) {
   if (!shouldRouteHelp(args2)) return args2;
   const leading = leadingPositionals(args2);
   if (leading.length === 0) return args2;
-  const verbPath = longestVerbPrefix(leading, registeredVerbPaths(cli2));
+  const verbPath = longestVerbOrGroupPrefix(leading, registeredVerbPaths(cli2));
   if (verbPath.length === 0) return args2;
   return ["help", ...verbPath];
 }
@@ -14630,14 +14771,15 @@ function leadingPositionals(args2) {
   }
   return out;
 }
-function longestVerbPrefix(positionals, verbPaths) {
-  let best = [];
-  for (const path of verbPaths) {
-    if (path.length > positionals.length) continue;
-    const matches = path.every((tok, i) => positionals[i] === tok);
-    if (matches && path.length > best.length) best = path;
+function longestVerbOrGroupPrefix(positionals, verbPaths) {
+  for (let len = positionals.length; len >= 1; len--) {
+    const prefix = positionals.slice(0, len);
+    const matches = verbPaths.some(
+      (path) => path.length >= len && prefix.every((tok, i) => path[i] === tok)
+    );
+    if (matches) return prefix;
   }
-  return best;
+  return [];
 }
 function registeredVerbPaths(cli2) {
   const rawDefs = cli2.definitions();
@@ -16157,7 +16299,18 @@ async function walkAndExtract(opts) {
   const accum = createWalkAccumulators();
   const wctx = buildWalkContext(opts);
   const claimedPaths = /* @__PURE__ */ new Set();
-  const walkOptions = opts.ignoreFilter ? { ignoreFilter: opts.ignoreFilter } : {};
+  const oversizedFiles = [];
+  const oversizedSeen = /* @__PURE__ */ new Set();
+  const onOversizedFile = (info) => {
+    if (oversizedSeen.has(info.path)) return;
+    oversizedSeen.add(info.path);
+    oversizedFiles.push(info);
+  };
+  const walkOptions = {
+    ...opts.ignoreFilter ? { ignoreFilter: opts.ignoreFilter } : {},
+    onOversizedFile,
+    ...opts.maxFileSizeBytes !== void 0 ? { maxFileSizeBytes: opts.maxFileSizeBytes } : {}
+  };
   let filesWalked = 0;
   let index = 0;
   const effectiveMaxNodes = opts.overrideMaxNodes ?? opts.recommendedNodeLimit;
@@ -16190,6 +16343,7 @@ async function walkAndExtract(opts) {
     cachedPaths: accum.cachedPaths,
     frontmatterIssues: accum.frontmatterIssues,
     filesWalked,
+    oversizedFiles,
     recommendedNodeLimit: opts.recommendedNodeLimit,
     overrideMaxNodes: opts.overrideMaxNodes,
     capReached,
@@ -16477,7 +16631,8 @@ async function runScanInternal(_kernel, options) {
     pluginStores: options.pluginStores,
     activeProvider: activeProviderId,
     recommendedNodeLimit: options.recommendedNodeLimit ?? 256,
-    overrideMaxNodes: options.overrideMaxNodes ?? null
+    overrideMaxNodes: options.overrideMaxNodes ?? null,
+    ...options.maxFileSizeBytes !== void 0 ? { maxFileSizeBytes: options.maxFileSizeBytes } : {}
   });
   const activeProvider = activeProviderId ? exts.providers.find((p) => p.id === activeProviderId) ?? null : null;
   const resolved = resolveSignals({
@@ -16636,6 +16791,7 @@ function buildScanStats(walked, issues, start) {
     // Providers compete.
     filesWalked: walked.filesWalked,
     filesSkipped: 0,
+    filesOversized: walked.oversizedFiles.length,
     nodesCount: walked.nodes.length,
     linksCount: walked.internalLinks.length,
     issuesCount: issues.length,
@@ -16652,6 +16808,7 @@ function buildScanReturn(walked, issues, renameOps, stats, options, setup) {
       scannedBy: SCANNED_BY,
       recommendedNodeLimit: walked.recommendedNodeLimit,
       overrideMaxNodes: walked.overrideMaxNodes,
+      oversizedFiles: walked.oversizedFiles,
       nodes: walked.nodes,
       links: walked.internalLinks,
       issues,
@@ -17047,13 +17204,13 @@ var SCAN_RUNNER_TEXTS = {
   activeProviderAmbiguousUnderYes: "{{glyph}}  Multiple provider markers detected ({{candidates}}) and --yes is set.\n   {{hint}}\n",
   activeProviderAmbiguousUnderYesHint: "Set the lens explicitly with `sm config set activeProvider <id>` and re-run, or omit --yes for interactive selection.",
   /**
-   * Active lens points at a bundle the operator has disabled (via
+   * Active lens points at a plugin the operator has disabled (via
    * `sm plugins disable <id>` or the Settings UI). Classification keeps
    * running because it's provider-driven, but the lens-gated extractors
-   * for the disabled bundle silently no-op. Without this warning the
+   * for the disabled plugin silently no-op. Without this warning the
    * graph quietly differs from what the lens implies.
    */
-  activeProviderBundleDisabledWarning: 'activeProvider = "{{id}}" but the "{{id}}" plugin bundle is currently disabled; provider-specific extractors will not run. Re-enable the bundle with `sm plugins enable {{id}}` or switch the lens with `sm config set activeProvider <id>` to silence this warning.',
+  activeProviderPluginDisabledWarning: 'activeProvider = "{{id}}" but the "{{id}}" plugin is currently disabled; provider-specific extractors will not run. Re-enable the plugin with `sm plugins enable {{id}}` or switch the lens with `sm config set activeProvider <id>` to silence this warning.',
   /**
    * Active-provider drift: the snapshot of provider markers persisted
    * when `activeProvider` was set (`activeProviderMarkers`) no longer
@@ -17222,7 +17379,6 @@ function persistActiveProvider(cwd, id, markers, printer) {
       target: "project",
       cwd
     });
-    printer.info(tx(SCAN_RUNNER_TEXTS.activeProviderAutodetected, { id }));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     printer.warn(
@@ -17279,11 +17435,11 @@ function diffMarkers(snapshot, current) {
   }
   return { added, removed };
 }
-function warnIfLensBundleDisabled(args2) {
+function warnIfLensPluginDisabled(args2) {
   if (args2.activeProvider === null) return;
   if (args2.resolveEnabled(args2.activeProvider)) return;
   args2.printer.warn(
-    tx(SCAN_RUNNER_TEXTS.activeProviderBundleDisabledWarning, {
+    tx(SCAN_RUNNER_TEXTS.activeProviderPluginDisabledWarning, {
       id: args2.activeProvider
     })
   );
@@ -17448,10 +17604,12 @@ async function runScanForCommand(opts) {
     referenceablePaths,
     ctx.cwd,
     activeProvider,
-    cfg.scan.maxNodes
+    cfg.scan.maxNodes,
+    cfg.scan.maxFileSizeBytes
   );
   const willPersist = !opts.noBuiltIns && !opts.dryRun;
-  return willPersist ? runPersistPath(opts, dbPath, jobsDir, strict, loadPrior, runScanWith, extensions) : runEphemeralPath(opts, dbPath, strict, loadPrior, runScanWith);
+  const scanned = await (willPersist ? runPersistPath(opts, dbPath, jobsDir, strict, loadPrior, runScanWith, extensions) : runEphemeralPath(opts, dbPath, strict, loadPrior, runScanWith));
+  return scanned.kind === "ok" ? { ...scanned, lensAutoDetected: lens.autoDetected } : scanned;
 }
 function detectionProviders(extensions) {
   return extensions?.providers ?? [];
@@ -17480,12 +17638,20 @@ async function resolveActiveLens(opts, ctx, effectiveRoots, pluginRuntime, provi
       })
     };
   }
-  warnIfLensBundleDisabled({
+  warnIfLensPluginDisabled({
     activeProvider: bootstrap.activeProvider,
     resolveEnabled: opts.resolveEnabledOverride ?? pluginRuntime.resolveEnabled,
     printer: opts.printer
   });
-  return { kind: "ok", activeProvider: bootstrap.activeProvider };
+  return {
+    kind: "ok",
+    activeProvider: bootstrap.activeProvider,
+    // Only when the lens was freshly auto-detected (not read from
+    // config) does the caller announce it. The bootstrap no longer
+    // prints it itself, to avoid interleaving stderr with the
+    // stdout scan summary on a tty.
+    autoDetected: bootstrap.source === "autodetect" ? bootstrap.activeProvider : null
+  };
 }
 function emitReferenceWalkAdvisory(walk3, opts) {
   if (walk3.truncated) {
@@ -17553,7 +17719,7 @@ function makePriorLoader(noBuiltIns, strict) {
     return loaded;
   };
 }
-function makeScanRunner(kernel, opts, effectiveRoots, ignoreFilter, strict, extensions, referenceablePaths, scanCwd, activeProvider, recommendedNodeLimit) {
+function makeScanRunner(kernel, opts, effectiveRoots, ignoreFilter, strict, extensions, referenceablePaths, scanCwd, activeProvider, recommendedNodeLimit, maxFileSizeBytes) {
   return async (prior, priorExtractorRuns, orphanJobFiles) => {
     if (opts.changed && prior === null) {
       opts.stderr.write(SCAN_RUNNER_TEXTS.changedNoPriorWarning);
@@ -17569,6 +17735,7 @@ function makeScanRunner(kernel, opts, effectiveRoots, ignoreFilter, strict, exte
       prior,
       activeProvider,
       recommendedNodeLimit,
+      maxFileSizeBytes,
       ...priorExtractorRuns ? { priorExtractorRuns } : {},
       ...orphanJobFiles ? { orphanJobFiles } : {}
     });
@@ -17590,7 +17757,8 @@ function buildRunScanOptions(args2) {
     orphanJobFiles: orphanJobFiles ?? [],
     activeProvider: args2.activeProvider,
     recommendedNodeLimit: args2.recommendedNodeLimit,
-    overrideMaxNodes: opts.maxNodes ?? null
+    overrideMaxNodes: opts.maxNodes ?? null,
+    maxFileSizeBytes: args2.maxFileSizeBytes
   };
   if (args2.extensions) runOptions.extensions = args2.extensions;
   if (prior) {
@@ -17962,6 +18130,11 @@ async function runFirstScan(scopeRoot, strict, printer, stderr, stdin, ansi) {
     return ExitCode.Ok;
   }
   const result = outcome.result;
+  if (outcome.lensAutoDetected) {
+    printer.info(
+      tx(SCAN_RUNNER_TEXTS.activeProviderAutodetected, { id: outcome.lensAutoDetected })
+    );
+  }
   const hasErrors = result.issues.some((i) => i.severity === "error");
   printer.info(
     tx(INIT_TEXTS.firstScanSummary, {
@@ -19480,10 +19653,10 @@ var PLUGINS_TEXTS = {
   pluginNotFoundHint: "Run `sm plugins list` for discovered ids and the qualified extension ids.",
   pluginLocked: '{{glyph}}  Plugin "{{id}}" is locked by the host and cannot be toggled.\n   {{hint}}\n',
   pluginLockedHint: "Locked plugins are mandatory for correct operation. To remove the lock, edit `src/kernel/config/locked-plugins.ts`.",
-  qualifiedIdNotFound: "{{glyph}}  Qualified extension id not found: {{id}}\n   The owning bundle '{{bundleId}}' does not declare an extension with id '{{extId}}'.\n   {{hint}}\n",
-  qualifiedIdNotFoundHint: "Run `sm plugins list` to see what each bundle ships.",
-  qualifiedIdUnknownBundle: "{{glyph}}  Qualified extension id references unknown bundle: {{bundleId}}\n   {{hint}}\n",
-  qualifiedIdUnknownBundleHint: "Run `sm plugins list` for known bundle ids.",
+  qualifiedIdNotFound: "{{glyph}}  Qualified extension id not found: {{id}}\n   The owning plugin '{{pluginId}}' does not declare an extension with id '{{extId}}'.\n   {{hint}}\n",
+  qualifiedIdNotFoundHint: "Run `sm plugins list` to see what each plugin ships.",
+  qualifiedIdUnknownPlugin: "{{glyph}}  Qualified extension id references unknown plugin: {{pluginId}}\n   {{hint}}\n",
+  qualifiedIdUnknownPluginHint: "Run `sm plugins list` for known plugin ids.",
   // Spec § A.10, `applicableKinds` filter on Extractors. When an extractor
   // declares a kind that no installed Provider emits, the load succeeds
   // (the Provider may arrive later) but `sm plugins doctor` surfaces a
@@ -19508,7 +19681,7 @@ var PLUGINS_TEXTS = {
   // --- doctor verb -----------------------------------------------------
   /**
    * One-line summary that opens the human doctor output. `enabled` is
-   * the count of enabled extensions across every bundle (every
+   * the count of enabled extensions across every plugin (every
    * extension is independently toggle-able by its qualified id); the
    * value matches the row count rendered by `sm plugins list` once
    * disabled extensions are filtered out.
@@ -19552,10 +19725,10 @@ var PLUGINS_TEXTS = {
   /**
    * Macro expansion summary printed on stderr before the confirm
    * prompt (or before the `--yes` rejection). The block lists every
-   * qualified extension id the bare bundle id resolves to, so the
+   * qualified extension id the bare plugin id resolves to, so the
    * user sees the exact set that would flip.
    */
-  bundleMacroHeader: "sm plugins {{verb}} {{bundleId}}: this will affect {{count}} extensions:\n",
+  bundleMacroHeader: "sm plugins {{verb}} {{pluginId}}: this will affect {{count}} extensions:\n",
   bundleMacroRow: "  - {{id}}\n",
   /**
    * Interactive prompt rendered to a TTY by the macro path. The
@@ -19575,7 +19748,7 @@ var PLUGINS_TEXTS = {
    * the directed re-run hint.
    */
   bundleMacroRequiresYes: "{{glyph}}  Refusing to {{verb}} multiple extensions without confirmation.\n   {{hint}}\n",
-  bundleMacroRequiresYesHint: "Re-run with --yes to apply, or pass a qualified id `<bundle>/<extension>` for a single extension.",
+  bundleMacroRequiresYesHint: "Re-run with --yes to apply, or pass a qualified id `<plugin>/<extension>` for a single extension.",
   // --- list / show renderers ------------------------------------------
   rowStatusOk: "ok",
   rowStatusOff: "off",
@@ -19588,18 +19761,18 @@ var PLUGINS_TEXTS = {
   sourceBuiltIn: "built-in",
   sourceUser: "user",
   /**
-   * Compact bundle row: `  GLYPH  ID(pad)  N ext   SOURCE`.
+   * Compact plugin row: `  GLYPH  ID(pad)  N ext   SOURCE`.
    * Padding for `id` and `count` is computed at render time so all rows
    * align regardless of length. The glyph is wrapped in color before the
    * template substitution.
    */
-  bundleRow: "  {{glyph}}  {{id}}{{count}} ext   {{source}}",
+  pluginRow: "  {{glyph}}  {{id}}{{count}} ext   {{source}}",
   /**
-   * Indent applied to the names / reason lines under each bundle row.
+   * Indent applied to the names / reason lines under each plugin row.
    * Kept as a single source of truth so the wrap math (`wrapNames`) and
    * the visible output stay in sync.
    */
-  bundleSubIndent: "       ",
+  pluginSubIndent: "       ",
   listTipShow: "\nTip: `sm plugins show <id>` for kinds, versions, and per-extension status.\n",
   /** Show command, built-in header (no version row, no path). */
   detailHeaderBuiltIn: "  {{glyph}}  {{id}}   {{source}}   {{count}} extension{{plural}}\n",
@@ -19621,11 +19794,11 @@ var PLUGINS_TEXTS = {
   /** Extensions block heading, separated from the header by a blank line. */
   detailExtensionsBlock: "\n",
   /**
-   * Extension row inside the bundle detail. Every extension is
+   * Extension row inside the plugin detail. Every extension is
    * independently toggle-able, so every row carries its own glyph
    * (✓ / ✕). Padding for {{kind}} and {{name}} is computed at render
    * time so columns align inside the block. `{{versionSuffix}}` is
-   * either `  v<x.y.z>` (user plugins) or empty (built-in bundles,
+   * either `  v<x.y.z>` (user plugins) or empty (built-in plugins,
    * which inherit the CLI version and do not maintain per-extension
    * versions of their own).
    */
@@ -19633,7 +19806,7 @@ var PLUGINS_TEXTS = {
   detailVersionUnknown: "?",
   detailCompatUnknown: "?",
   /**
-   * Show command, single-extension header (qualified `<bundle>/<ext>` id
+   * Show command, single-extension header (qualified `<plugin>/<ext>` id
    * shape). Mirrors `detailHeaderBuiltIn` but the count slot is replaced
    * by the kind so the reader sees at a glance whether they are looking
    * at an extractor, analyzer, etc. Version moves down into the field
@@ -19680,19 +19853,19 @@ var PLUGINS_TEXTS = {
 };
 
 // plugins/presentation-order.ts
-var BUILT_IN_BUNDLE_PRESENTATION_ORDER = [
+var BUILT_IN_PLUGIN_PRESENTATION_ORDER = [
   "core",
   "claude",
   "antigravity",
   "openai",
   "agent-skills"
 ];
-function sortBundlesForPresentation(bundles) {
+function sortPluginsForPresentation(plugins) {
   const orderIndex = (id) => {
-    const idx = BUILT_IN_BUNDLE_PRESENTATION_ORDER.indexOf(id);
-    return idx >= 0 ? idx : BUILT_IN_BUNDLE_PRESENTATION_ORDER.length;
+    const idx = BUILT_IN_PLUGIN_PRESENTATION_ORDER.indexOf(id);
+    return idx >= 0 ? idx : BUILT_IN_PLUGIN_PRESENTATION_ORDER.length;
   };
-  return [...bundles].sort((a, b) => {
+  return [...plugins].sort((a, b) => {
     const ai = orderIndex(a.id);
     const bi = orderIndex(b.id);
     if (ai !== bi) return ai - bi;
@@ -19729,24 +19902,24 @@ async function loadAll(opts) {
   return loader.discoverAndLoadAll();
 }
 function builtInRows(resolveEnabled) {
-  return sortBundlesForPresentation(builtInBundles).map((bundle) => {
-    const extensions = bundle.extensions.map((ext) => extensionRowFromBuiltIn(ext, bundle, resolveEnabled));
-    const manifestSummary = bundle.extensions.map((ext) => `${ext.kind}:${qualifiedExtensionId(bundle.id, ext.id)}@${ext.version}`).join(", ");
+  return sortPluginsForPresentation(builtInPlugins).map((plugin) => {
+    const extensions = plugin.extensions.map((ext) => extensionRowFromBuiltIn(ext, plugin, resolveEnabled));
+    const manifestSummary = plugin.extensions.map((ext) => `${ext.kind}:${qualifiedExtensionId(plugin.id, ext.id)}@${ext.version}`).join(", ");
     return {
-      id: bundle.id,
+      id: plugin.id,
       enabled: extensions.some((e) => e.enabled),
-      description: bundle.description,
+      description: plugin.description,
       extensions,
       manifestSummary
     };
   });
 }
-function extensionRowFromBuiltIn(ext, bundle, resolveEnabled) {
+function extensionRowFromBuiltIn(ext, plugin, resolveEnabled) {
   const row = {
     id: ext.id,
     kind: ext.kind,
     version: ext.version,
-    enabled: resolveEnabled(qualifiedExtensionId(bundle.id, ext.id)),
+    enabled: resolveEnabled(qualifiedExtensionId(plugin.id, ext.id)),
     description: ext.description ?? ""
   };
   if (ext.entry !== void 0) row.entry = ext.entry;
@@ -19782,7 +19955,7 @@ var PluginsListCommand = class extends SmCommand {
   static usage = Command22.Usage({
     category: "Plugins",
     description: "List discovered plugins and their load status.",
-    details: "Scans <cwd>/.skill-map/plugins (or --plugin-dir <path>). Built-in bundles (claude, core) are listed alongside user plugins."
+    details: "Scans <cwd>/.skill-map/plugins (or --plugin-dir <path>). Built-in plugins (claude, core) are listed alongside user plugins."
   });
   pluginDir = Option21.String("--plugin-dir", { required: false });
   async run() {
@@ -19819,14 +19992,14 @@ function renderListHuman(builtIns2, plugins, resolveEnabled, ansi) {
     const idCol = row.id.padEnd(idWidth);
     const countCol = String(row.names.length).padStart(countWidth);
     lines.push(
-      tx(PLUGINS_TEXTS.bundleRow, {
+      tx(PLUGINS_TEXTS.pluginRow, {
         glyph,
         id: idCol,
         count: ` ${countCol}`,
         source: ansi.dim(row.source)
       })
     );
-    const indent = PLUGINS_TEXTS.bundleSubIndent;
+    const indent = PLUGINS_TEXTS.pluginSubIndent;
     if (row.reason) {
       lines.push(`${indent}${ansi.dim(row.reason)}`);
     } else if (row.names.length > 0) {
@@ -19890,11 +20063,11 @@ var PluginsShowCommand = class extends SmCommand {
     category: "Plugins",
     description: "Show a single plugin's manifest + loaded extensions.",
     details: `
-      Accepts a bundle / plugin id (\`core\`, \`claude\`, \`my-plugin\`)
+      Accepts a plugin id (\`core\`, \`claude\`, \`my-plugin\`)
       or a qualified extension id (\`core/<ext-id>\`,
       \`<plugin>/<ext-id>\`). When given a qualified id, validates the
       extension exists and renders a single-extension detail block.
-      The bare form renders the parent bundle's detail with per-extension
+      The bare form renders the parent plugin's detail with per-extension
       status. The same id shapes \`sm plugins enable\` and
       \`sm plugins disable\` accept resolve cleanly here too.
     `
@@ -19911,9 +20084,9 @@ var PluginsShowCommand = class extends SmCommand {
       this.printer.error(lookupResult.error);
       return ExitCode.NotFound;
     }
-    const { bundleId, extId } = lookupResult;
-    const builtIn = builtIns2.find((b) => b.id === bundleId);
-    const match = plugins.find((p) => p.id === bundleId);
+    const { pluginId, extId } = lookupResult;
+    const builtIn = builtIns2.find((b) => b.id === pluginId);
+    const match = plugins.find((p) => p.id === pluginId);
     if (!builtIn && !match) {
       this.printer.error(
         tx(PLUGINS_TEXTS.pluginNotFound, {
@@ -19925,7 +20098,7 @@ var PluginsShowCommand = class extends SmCommand {
       return ExitCode.NotFound;
     }
     if (extId !== void 0) {
-      return this.renderExtensionDetail({ extId, bundleId, builtIn, match });
+      return this.renderExtensionDetail({ extId, pluginId, builtIn, match });
     }
     if (this.json) {
       const payload = builtIn ?? match;
@@ -19939,23 +20112,23 @@ var PluginsShowCommand = class extends SmCommand {
   }
   /**
    * Render the single-extension detail block, the path taken when the
-   * user supplies a qualified `<bundle>/<ext>` id. `--json` emits the
-   * single extension row (no surrounding bundle envelope) so tooling
+   * user supplies a qualified `<plugin>/<ext>` id. `--json` emits the
+   * single extension row (no surrounding plugin envelope) so tooling
    * can pipe straight into `jq`; human mode renders a focused header
    * plus a Kind / Version / Stability / Description / Preconditions /
    * Entry field block.
    */
   renderExtensionDetail(args2) {
-    const { extId, bundleId, builtIn, match } = args2;
+    const { extId, pluginId, builtIn, match } = args2;
     const ansi = this.ansiFor("stdout");
     if (builtIn) {
       const ext = builtIn.extensions.find((e) => e.id === extId);
       if (!ext) return ExitCode.NotFound;
       if (this.json) {
-        this.printer.data(JSON.stringify({ pluginId: bundleId, ...ext }, omitModule, 2) + "\n");
+        this.printer.data(JSON.stringify({ pluginId, ...ext }, omitModule, 2) + "\n");
         return ExitCode.Ok;
       }
-      this.printer.data(renderBuiltInExtensionDetail(bundleId, ext, ansi));
+      this.printer.data(renderBuiltInExtensionDetail(pluginId, ext, ansi));
       return ExitCode.Ok;
     }
     const userExt = match?.extensions?.find((e) => e.id === extId);
@@ -19964,53 +20137,53 @@ var PluginsShowCommand = class extends SmCommand {
       this.printer.data(JSON.stringify(userExt, omitModule, 2) + "\n");
       return ExitCode.Ok;
     }
-    this.printer.data(renderUserExtensionDetail(bundleId, userExt, ansi));
+    this.printer.data(renderUserExtensionDetail(pluginId, userExt, ansi));
     return ExitCode.Ok;
   }
 };
 function resolveShowLookupId(id, builtIns2, plugins, ansi) {
-  if (!id.includes("/")) return { bundleId: id };
+  if (!id.includes("/")) return { pluginId: id };
   const parsed = parseQualifiedId(id);
   if ("error" in parsed) return { error: malformedQualifiedError(id, ansi) };
-  const { bundleId, extId } = parsed;
-  const knownExts = collectKnownExtensions(bundleId, builtIns2, plugins);
-  if (knownExts === null) return { error: unknownBundleError(bundleId, ansi) };
+  const { pluginId, extId } = parsed;
+  const knownExts = collectKnownExtensions(pluginId, builtIns2, plugins);
+  if (knownExts === null) return { error: unknownPluginError(pluginId, ansi) };
   if (!knownExts.includes(extId)) {
-    return { error: unknownExtensionError(id, bundleId, extId, ansi) };
+    return { error: unknownExtensionError(id, pluginId, extId, ansi) };
   }
-  return { bundleId, extId };
+  return { pluginId, extId };
 }
 function parseQualifiedId(id) {
-  const [bundleId, extId, ...rest] = id.split("/");
-  if (!bundleId || !extId || rest.length > 0) return { error: true };
-  return { bundleId, extId };
+  const [pluginId, extId, ...rest] = id.split("/");
+  if (!pluginId || !extId || rest.length > 0) return { error: true };
+  return { pluginId, extId };
 }
-function collectKnownExtensions(bundleId, builtIns2, plugins) {
-  const builtIn = builtIns2.find((b) => b.id === bundleId);
+function collectKnownExtensions(pluginId, builtIns2, plugins) {
+  const builtIn = builtIns2.find((b) => b.id === pluginId);
   if (builtIn) return builtIn.extensions.map((e) => e.id);
-  const userPlugin = plugins.find((p) => p.id === bundleId);
+  const userPlugin = plugins.find((p) => p.id === pluginId);
   if (userPlugin) return userPlugin.extensions?.map((e) => e.id) ?? [];
   return null;
 }
 function malformedQualifiedError(id, ansi) {
-  return tx(PLUGINS_TEXTS.qualifiedIdUnknownBundle, {
+  return tx(PLUGINS_TEXTS.qualifiedIdUnknownPlugin, {
     glyph: ansi.red("\u2715"),
-    bundleId: sanitizeForTerminal(id),
-    hint: ansi.dim(PLUGINS_TEXTS.qualifiedIdUnknownBundleHint)
+    pluginId: sanitizeForTerminal(id),
+    hint: ansi.dim(PLUGINS_TEXTS.qualifiedIdUnknownPluginHint)
   });
 }
-function unknownBundleError(bundleId, ansi) {
-  return tx(PLUGINS_TEXTS.qualifiedIdUnknownBundle, {
+function unknownPluginError(pluginId, ansi) {
+  return tx(PLUGINS_TEXTS.qualifiedIdUnknownPlugin, {
     glyph: ansi.red("\u2715"),
-    bundleId: sanitizeForTerminal(bundleId),
-    hint: ansi.dim(PLUGINS_TEXTS.qualifiedIdUnknownBundleHint)
+    pluginId: sanitizeForTerminal(pluginId),
+    hint: ansi.dim(PLUGINS_TEXTS.qualifiedIdUnknownPluginHint)
   });
 }
-function unknownExtensionError(id, bundleId, extId, ansi) {
+function unknownExtensionError(id, pluginId, extId, ansi) {
   return tx(PLUGINS_TEXTS.qualifiedIdNotFound, {
     glyph: ansi.red("\u2715"),
     id: sanitizeForTerminal(id),
-    bundleId: sanitizeForTerminal(bundleId),
+    pluginId: sanitizeForTerminal(pluginId),
     extId: sanitizeForTerminal(extId),
     hint: ansi.dim(PLUGINS_TEXTS.qualifiedIdNotFoundHint)
   });
@@ -20101,18 +20274,18 @@ function renderPluginDetailFields(match) {
 function collectPluginExtensionItems(match, ansi) {
   const enabled = match.status === "enabled";
   if (!enabled || !match.extensions) return [];
-  const safeBundleId = sanitizeForTerminal(match.id);
+  const safePluginId = sanitizeForTerminal(match.id);
   const sorted = sortExtensionsCanonical(match.extensions);
   return sorted.map((ext) => {
     const safeExtId = sanitizeForTerminal(ext.id);
     return {
       // User plugins surfaced via `loadAll` already filter on the
       // resolver, so a reachable extension on this surface is enabled
-      // by construction. The disabled path goes through the bundle
+      // by construction. The disabled path goes through the plugin
       // status header above (✕ on the row).
       glyph: ansi.green(PLUGINS_TEXTS.rowGlyphOk),
       kind: sanitizeForTerminal(ext.kind),
-      name: `${safeBundleId}/${safeExtId}`,
+      name: `${safePluginId}/${safeExtId}`,
       version: sanitizeForTerminal(ext.version)
     };
   });
@@ -20138,11 +20311,11 @@ function renderExtensionItems(items) {
   }
   return out.join("");
 }
-function renderBuiltInExtensionDetail(bundleId, ext, ansi) {
+function renderBuiltInExtensionDetail(pluginId, ext, ansi) {
   const glyph = ext.enabled ? ansi.green(PLUGINS_TEXTS.rowGlyphOk) : ansi.red(PLUGINS_TEXTS.rowGlyphOff);
   const header = tx(PLUGINS_TEXTS.detailHeaderExtensionBuiltIn, {
     glyph,
-    qualifiedId: sanitizeForTerminal(`${bundleId}/${ext.id}`),
+    qualifiedId: sanitizeForTerminal(`${pluginId}/${ext.id}`),
     source: ansi.dim(PLUGINS_TEXTS.sourceBuiltIn)
   });
   const meta = { kind: ext.kind };
@@ -20150,11 +20323,11 @@ function renderBuiltInExtensionDetail(bundleId, ext, ansi) {
   if (ext.entry !== void 0) meta.entry = ext.entry;
   return header + "\n" + renderExtensionFields(meta);
 }
-function renderUserExtensionDetail(bundleId, ext, ansi) {
+function renderUserExtensionDetail(pluginId, ext, ansi) {
   const glyph = ansi.green(PLUGINS_TEXTS.rowGlyphOk);
   const header = tx(PLUGINS_TEXTS.detailHeaderExtensionUser, {
     glyph,
-    qualifiedId: sanitizeForTerminal(`${bundleId}/${ext.id}`),
+    qualifiedId: sanitizeForTerminal(`${pluginId}/${ext.id}`),
     source: ansi.dim(PLUGINS_TEXTS.sourceUser)
   });
   const meta = readInstanceMeta(ext.instance);
@@ -20408,13 +20581,13 @@ function forEachProviderInstance(plugins, callback) {
   forEachUserPluginProvider(plugins, callback);
 }
 function forEachBuiltInProvider(callback) {
-  for (const bundle of builtInBundles) {
-    for (const ext of bundle.extensions) {
+  for (const plugin of builtInPlugins) {
+    for (const ext of plugin.extensions) {
       if (ext.kind !== "provider") continue;
       const provider = ext;
       callback({
         id: provider.id,
-        pluginId: bundle.id,
+        pluginId: plugin.id,
         instance: provider
       });
     }
@@ -20457,15 +20630,15 @@ function collectApplicableKindWarnings(plugins, knownKinds) {
   return out;
 }
 function collectBuiltInApplicableKindWarnings(out, knownKinds) {
-  for (const bundle of builtInBundles) {
-    for (const ext of bundle.extensions) {
+  for (const plugin of builtInPlugins) {
+    for (const ext of plugin.extensions) {
       if (ext.kind !== "extractor") continue;
       const extractor = ext;
       const kinds = extractor.precondition?.kind;
       if (!kinds || kinds.length === 0) continue;
       appendUnknownKindWarnings(
         out,
-        qualifiedExtensionId(bundle.id, extractor.id),
+        qualifiedExtensionId(plugin.id, extractor.id),
         kinds,
         knownKinds
       );
@@ -20508,11 +20681,11 @@ function collectUnknownSlotWarnings(plugins, knownSlots) {
   return out;
 }
 function collectBuiltInUnknownSlotWarnings(out, knownSlots) {
-  for (const bundle of builtInBundles) {
-    for (const ext of bundle.extensions) {
+  for (const plugin of builtInPlugins) {
+    for (const ext of plugin.extensions) {
       const vc = ext.viewContributions;
       if (!vc) continue;
-      appendUnknownSlotWarnings(out, qualifiedExtensionId(bundle.id, ext.id), vc, knownSlots);
+      appendUnknownSlotWarnings(out, qualifiedExtensionId(plugin.id, ext.id), vc, knownSlots);
     }
   }
 }
@@ -20594,7 +20767,7 @@ import { Command as Command25, Option as Option24 } from "clipanion";
 var TogglePluginsBase = class extends SmCommand {
   all = Option24.Boolean("--all", false);
   yes = Option24.Boolean("--yes,-y", false, {
-    description: "Skip the interactive confirm when a bare bundle id (or --all) fans the toggle out across multiple extensions."
+    description: "Skip the interactive confirm when a bare plugin id (or --all) fans the toggle out across multiple extensions."
   });
   ids = Option24.Rest({ name: "ids" });
   async toggle(enabled) {
@@ -20603,7 +20776,7 @@ var TogglePluginsBase = class extends SmCommand {
     const argError = this.#validateArgs(stderrAnsi, verb);
     if (argError !== null) return argError;
     const plugins = await loadAll({ pluginDir: void 0 });
-    const catalogue = bundleCatalogue(plugins);
+    const catalogue = pluginCatalogue(plugins);
     const targetsResult = this.#pickTargets(catalogue, stderrAnsi);
     if (typeof targetsResult === "number") return targetsResult;
     let targets = targetsResult;
@@ -20661,7 +20834,7 @@ var TogglePluginsBase = class extends SmCommand {
     if (this.all) {
       return catalogue.map((b) => ({
         origin: "bare",
-        bundleId: b.id,
+        pluginId: b.id,
         keys: b.extensionIds.map((extId) => qualifiedExtensionId(b.id, extId))
       }));
     }
@@ -20682,8 +20855,8 @@ var TogglePluginsBase = class extends SmCommand {
   }
   /**
    * Macro gate: when the request would fan a single user input out
-   * across more than one extension (either `--all` or a bare bundle
-   * id whose bundle holds ≥2 extensions), confirm the intent.
+   * across more than one extension (either `--all` or a bare plugin
+   * id whose plugin holds ≥2 extensions), confirm the intent.
    *
    * Resolution order:
    *   1. `--yes` flag: skip the prompt entirely.
@@ -20692,7 +20865,7 @@ var TogglePluginsBase = class extends SmCommand {
    *      message that names the extensions and points at `--yes`.
    *
    * Returns `true` when the verb should proceed, `false` when it
-   * should abort. Single-extension targets (bare bundle id mapping to
+   * should abort. Single-extension targets (bare plugin id mapping to
    * one child, or qualified ids) skip the gate uniformly.
    */
   // Cyclomatic count comes from the three-stage gate (--yes shortcut,
@@ -20706,11 +20879,11 @@ var TogglePluginsBase = class extends SmCommand {
     if (this.yes) return true;
     const isTty = Boolean(this.context.stdin && "isTTY" in this.context.stdin && this.context.stdin.isTTY);
     for (const target of macroTargets) {
-      const bundleLabel = target.origin === "bare" ? target.bundleId ?? "--all" : "--all";
+      const pluginLabel = target.origin === "bare" ? target.pluginId ?? "--all" : "--all";
       this.printer.info(
         tx(PLUGINS_TEXTS.bundleMacroHeader, {
           verb,
-          bundleId: sanitizeForTerminal(bundleLabel),
+          pluginId: sanitizeForTerminal(pluginLabel),
           count: target.keys.length
         })
       );
@@ -20766,7 +20939,7 @@ var TogglePluginsBase = class extends SmCommand {
    * Persist every qualified id in `config_plugins`. On disable, also
    * purge the plugin's `scan_contributions` rows immediately (matches
    * the BFF route, see `server/routes/plugins.ts:applyChangeToAdapter`).
-   * Every key is `<bundle>/<ext>` shape so the contribution purge can
+   * Every key is `<plugin>/<ext>` shape so the contribution purge can
    * split into `(pluginId, extensionId)` cleanly.
    */
   async #persistKeys(keys, enabled) {
@@ -20829,11 +21002,11 @@ var PluginsEnableCommand = class extends TogglePluginsBase {
       flip; sm config reset plugins.<id>.enabled drops the settings.json
       baseline.
 
-      Accepts qualified ids (\`claude/at-directive\`) and bare bundle
+      Accepts qualified ids (\`claude/at-directive\`) and bare plugin
       ids (\`claude\`, which fans the toggle out across every extension
-      inside the bundle). Multi-extension bundles need --yes (or an
+      inside the plugin). Multi-extension plugins need --yes (or an
       interactive TTY confirm) to avoid flipping 27 core extensions by
-      accident. Single-extension bundles (openai, agent-skills,
+      accident. Single-extension plugins (openai, agent-skills,
       antigravity) apply without prompting.
 
       Batches are all-or-nothing: a single unknown id aborts before
@@ -20856,11 +21029,11 @@ var PluginsDisableCommand = class extends TogglePluginsBase {
       sm plugins list, but with status=disabled; the kernel will not
       run any of its disabled extensions.
 
-      Accepts qualified ids (\`core/markdown-link\`) and bare bundle
+      Accepts qualified ids (\`core/markdown-link\`) and bare plugin
       ids (\`core\`, which fans the toggle out across every extension
-      inside the bundle). Multi-extension bundles need --yes (or an
+      inside the plugin). Multi-extension plugins need --yes (or an
       interactive TTY confirm) to avoid flipping 27 core extensions by
-      accident. Single-extension bundles (openai, agent-skills,
+      accident. Single-extension plugins (openai, agent-skills,
       antigravity) apply without prompting.
 
       Batches are all-or-nothing: a single unknown id aborts before
@@ -20872,12 +21045,12 @@ var PluginsDisableCommand = class extends TogglePluginsBase {
     return this.toggle(false);
   }
 };
-function bundleCatalogue(plugins) {
+function pluginCatalogue(plugins) {
   const out = [];
-  for (const bundle of builtInBundles) {
+  for (const plugin of builtInPlugins) {
     out.push({
-      id: bundle.id,
-      extensionIds: bundle.extensions.map((e) => e.id)
+      id: plugin.id,
+      extensionIds: plugin.extensions.map((e) => e.id)
     });
   }
   for (const p of plugins) {
@@ -20893,32 +21066,32 @@ function resolveToggleTarget(id, catalogue, ansi) {
 }
 function resolveQualifiedToggle(id, catalogue, ansi) {
   const errGlyph = ansi.red("\u2715");
-  const [bundleId, extId, ...rest] = id.split("/");
-  if (!bundleId || !extId || rest.length > 0) {
+  const [pluginId, extId, ...rest] = id.split("/");
+  if (!pluginId || !extId || rest.length > 0) {
     return {
-      error: tx(PLUGINS_TEXTS.qualifiedIdUnknownBundle, {
+      error: tx(PLUGINS_TEXTS.qualifiedIdUnknownPlugin, {
         glyph: errGlyph,
-        bundleId: sanitizeForTerminal(id),
-        hint: ansi.dim(PLUGINS_TEXTS.qualifiedIdUnknownBundleHint)
+        pluginId: sanitizeForTerminal(id),
+        hint: ansi.dim(PLUGINS_TEXTS.qualifiedIdUnknownPluginHint)
       })
     };
   }
-  const bundle = catalogue.find((b) => b.id === bundleId);
-  if (!bundle) {
+  const plugin = catalogue.find((b) => b.id === pluginId);
+  if (!plugin) {
     return {
-      error: tx(PLUGINS_TEXTS.qualifiedIdUnknownBundle, {
+      error: tx(PLUGINS_TEXTS.qualifiedIdUnknownPlugin, {
         glyph: errGlyph,
-        bundleId: sanitizeForTerminal(bundleId),
-        hint: ansi.dim(PLUGINS_TEXTS.qualifiedIdUnknownBundleHint)
+        pluginId: sanitizeForTerminal(pluginId),
+        hint: ansi.dim(PLUGINS_TEXTS.qualifiedIdUnknownPluginHint)
       })
     };
   }
-  if (!bundle.extensionIds.includes(extId)) {
+  if (!plugin.extensionIds.includes(extId)) {
     return {
       error: tx(PLUGINS_TEXTS.qualifiedIdNotFound, {
         glyph: errGlyph,
         id: sanitizeForTerminal(id),
-        bundleId: sanitizeForTerminal(bundleId),
+        pluginId: sanitizeForTerminal(pluginId),
         extId: sanitizeForTerminal(extId),
         hint: ansi.dim(PLUGINS_TEXTS.qualifiedIdNotFoundHint)
       })
@@ -20926,12 +21099,12 @@ function resolveQualifiedToggle(id, catalogue, ansi) {
   }
   return {
     origin: "qualified",
-    keys: [qualifiedExtensionId(bundleId, extId)]
+    keys: [qualifiedExtensionId(pluginId, extId)]
   };
 }
 function resolveBareToggle(id, catalogue) {
-  const bundle = catalogue.find((b) => b.id === id);
-  if (!bundle) {
+  const plugin = catalogue.find((b) => b.id === id);
+  if (!plugin) {
     return {
       error: tx(PLUGINS_TEXTS.pluginNotFound, {
         glyph: "\u2715",
@@ -20942,8 +21115,8 @@ function resolveBareToggle(id, catalogue) {
   }
   return {
     origin: "bare",
-    bundleId: bundle.id,
-    keys: bundle.extensionIds.map((extId) => qualifiedExtensionId(bundle.id, extId))
+    pluginId: plugin.id,
+    keys: plugin.extensionIds.map((extId) => qualifiedExtensionId(plugin.id, extId))
   };
 }
 
@@ -20991,20 +21164,10 @@ var PluginsCreateCommand = class extends SmCommand {
     mkdirSync5(join18(targetDir, "extractors", extractorName), { recursive: true });
     const specVersion = installedSpecVersion();
     const manifest = {
-      id: this.pluginId,
       version: "0.1.0",
       specCompat: `^${specVersion}`,
       catalogCompat: "^1.0.0",
-      description: "Generated by `sm plugins create`. Edit to taste.",
-      settings: {
-        keywords: {
-          type: "string-list",
-          label: "Keywords to track",
-          description: "Words counted across each scanned node body.",
-          default: ["TODO", "FIXME"],
-          min: 1
-        }
-      }
+      description: "Generated by `sm plugins create`. Edit to taste."
     };
     writeFileSync(
       join18(targetDir, "plugin.json"),
@@ -21029,36 +21192,44 @@ function scaffolderExtractorStub(extractorId) {
  * Generated by \`sm plugins create\`. Edit the extract() body.
  *
  * Loader contract: the plugin loader resolves the extension via the
- * MODULE'S DEFAULT EXPORT (\`export default { ... }\`). Renaming or
- * splitting into a named export will surface as \`load-error: default
- * export missing a string \\\`kind\\\` field\`.
+ * MODULE'S DEFAULT EXPORT (\`export default { ... }\`). It must be an
+ * object literal; renaming or splitting into a named export surfaces as
+ * a \`load-error\`.
  *
  * Folder convention: this file lives at
- * \`extractors/${extractorId}/index.js\`. The bundle's plugin.json#/id
- * provides the qualified id \`<plugin-id>/${extractorId}\`; the loader
- * injects \`pluginId\` automatically, do NOT hardcode it here.
+ * \`extractors/${extractorId}/index.js\`. The folder layout is the
+ * source of truth (structure-as-truth): the loader derives \`kind\`
+ * (\`extractor\`) from the parent folder and the id (\`${extractorId}\`)
+ * from the leaf folder, and injects \`pluginId\` from the plugin, so none
+ * of them are declared here. Re-declaring \`kind\` / \`id\` is rejected as
+ * \`invalid-manifest\`.
  *
- * Declared view contributions (in plugin.json):
+ * Declared view contributions (\`ui\`):
  *   - 'count' \u2192 slot \`card.footer.left\` (renders as a chip
  *     in the left footer of the node card)
  *
- * Declared settings:
+ * Declared settings (\`settings\`):
  *   - 'keywords' (string-list) \u2192 exposed as ctx.settings.keywords
  *
  * See: spec/plugin-author-guide.md \xA7View contributions
  *      spec/view-slots.md
  */
 export default {
-  id: '${extractorId}',
-  kind: 'extractor',
   version: '0.1.0',
   description: 'Counts configured keywords per node.',
-  stability: 'experimental',
-  emitsLinkKinds: [],
-  defaultConfidence: 'high',
   scope: 'body',
 
-  viewContributions: {
+  settings: {
+    keywords: {
+      type: 'string-list',
+      label: 'Keywords to track',
+      description: 'Words counted across each scanned node body.',
+      default: ['TODO', 'FIXME'],
+      min: 1,
+    },
+  },
+
+  ui: {
     count: {
       slot: 'card.footer.left',
       icon: '\u{1F50D}',
@@ -21084,7 +21255,7 @@ export default {
 function scaffolderReadme(pluginId) {
   return `# ${pluginId}
 
-Generated by \`sm plugins create\`. Edit \`extensions/extractor.js\` to taste.
+Generated by \`sm plugins create\`. Edit \`extractors/${pluginId}-extractor/index.js\` to taste.
 
 ## Verbs
 
@@ -21604,6 +21775,31 @@ var IntentionalFailCommand = class extends SmCommand {
 // cli/commands/scan.ts
 import { Command as Command31, Option as Option29 } from "clipanion";
 
+// kernel/util/format-bytes.ts
+var UNITS = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"];
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  if (bytes < 1024) return `${Math.round(bytes)} B`;
+  let value = bytes;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < UNITS.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  const rounded = Math.round(value * 10) / 10;
+  const text = Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+  return `${text} ${UNITS[unitIndex]}`;
+}
+
+// kernel/util/format-oversized.ts
+function formatOversizedFilePair(file) {
+  return `${file.path} (${formatBytes(file.bytes)})`;
+}
+function formatOversizedFileRows(files) {
+  return files.map((file) => `     - ${formatOversizedFilePair(file)}
+`);
+}
+
 // cli/i18n/scan.texts.ts
 var SCAN_TEXTS = {
   // --- scan command ----------------------------------------------------
@@ -21651,6 +21847,20 @@ var SCAN_TEXTS = {
    */
   scanCappedNotice: "{{glyph}}  Scan capped at {{limit}} nodes ({{source}}).\n     {{hint}}\n",
   scanCappedNoticeHint: "Trim .skillmapignore to exclude noisy paths (preferred), or re-run with --max-nodes <N> to raise the cap. Past the recommended limit the graph is hard to read and analyzer signal drops.",
+  /**
+   * File-size skip notice, printed (WARN, stderr) when the walker
+   * skipped one or more files for exceeding `scan.maxFileSizeBytes`.
+   * `{{glyph}}` is the yellow warning glyph, `{{count}}`/`{{noun}}` the
+   * skipped-file tally, `{{files}}` the pre-rendered list of
+   * `path (size)` rows, `{{hint}}` the dim escape-route line.
+   */
+  scanSkippedFilesNotice: "{{glyph}}  Skipped {{count}} {{noun}} over the size limit (scan.maxFileSizeBytes):\n{{files}}     {{hint}}\n",
+  // The per-file `     - path (size)\n` rows that fill `{{files}}` are
+  // rendered by `kernel/util/format-oversized.ts:formatOversizedFileRows`,
+  // shared with `sm watch` / `sm serve` so the three surfaces never drift.
+  scanSkippedFileNounSingular: "file",
+  scanSkippedFileNounPlural: "files",
+  scanSkippedFilesNoticeHint: "Raise scan.maxFileSizeBytes to include these, or add them to .skillmapignore to skip them on purpose.",
   /**
    * Validation message for an invalid `--max-nodes` value. Surfaced as a
    * §3.1b two-line block.
@@ -21829,7 +22039,8 @@ function createWatcherRuntime(opts) {
         strict,
         emitter,
         recommendedNodeLimit: cfg.scan.maxNodes,
-        overrideMaxNodes: opts.maxNodesOverride ?? null
+        overrideMaxNodes: opts.maxNodesOverride ?? null,
+        maxFileSizeBytes: cfg.scan.maxFileSizeBytes
       };
       if (cfg.scan.referencePaths.length > 0) {
         const walk3 = walkReferencePaths(cfg.scan.referencePaths, cwd);
@@ -22047,7 +22258,20 @@ var WATCH_TEXTS = {
    * §3.1b two-line block. Validation rejection for `--max-nodes`.
    */
   maxNodesInvalid: "{{glyph}}  sm watch: --max-nodes must be an integer >= 1 (got {{raw}}).\n   {{hint}}\n",
-  maxNodesInvalidHint: "Pass a positive integer, e.g. --max-nodes 256."
+  maxNodesInvalidHint: "Pass a positive integer, e.g. --max-nodes 256.",
+  /**
+   * File-size skip WARN, emitted per batch (stderr) when the walker
+   * skipped one or more files for exceeding `scan.maxFileSizeBytes`.
+   * Mirrors `sm scan`'s notice. `{{files}}` is the pre-rendered list of
+   * `path (size)` rows.
+   */
+  skippedFilesNotice: "{{glyph}}  Skipped {{count}} {{noun}} over the size limit (scan.maxFileSizeBytes):\n{{files}}     {{hint}}\n",
+  // The per-file `     - path (size)\n` rows that fill `{{files}}` are
+  // rendered by `kernel/util/format-oversized.ts:formatOversizedFileRows`,
+  // shared with `sm scan` / `sm serve` so the three surfaces never drift.
+  skippedFileNounSingular: "file",
+  skippedFileNounPlural: "files",
+  skippedFilesNoticeHint: "Raise scan.maxFileSizeBytes to include these, or add them to .skillmapignore to skip them on purpose."
 };
 
 // cli/commands/watch.ts
@@ -22088,6 +22312,21 @@ async function runWatchLoop(opts) {
         })
       );
     }
+    renderOversizedWarning(result);
+  };
+  const renderOversizedWarning = (result) => {
+    const oversized = result.oversizedFiles ?? [];
+    if ((result.stats.filesOversized ?? oversized.length) <= 0) return;
+    const files = formatOversizedFileRows(oversized).join("");
+    context.stderr.write(
+      tx(WATCH_TEXTS.skippedFilesNotice, {
+        glyph: stderrAnsi.yellow("\u26A0"),
+        count: oversized.length,
+        noun: oversized.length === 1 ? WATCH_TEXTS.skippedFileNounSingular : WATCH_TEXTS.skippedFileNounPlural,
+        files,
+        hint: stderrAnsi.dim(WATCH_TEXTS.skippedFilesNoticeHint)
+      })
+    );
   };
   const runtimeOpts = {
     dbPath,
@@ -22414,7 +22653,13 @@ var ScanCommand = class extends SmCommand {
     });
     if (outcome.kind === "ok") {
       setScanExtensions(buildScanExtensionSet(outcome.executedExtensionIds));
-      return this.renderOutcome(outcome.result, outcome.persistedTo, outcome.dbPath, outcome.strict);
+      return this.renderOutcome(
+        outcome.result,
+        outcome.persistedTo,
+        outcome.dbPath,
+        outcome.strict,
+        outcome.lensAutoDetected
+      );
     }
     return this.renderFailure(outcome);
   }
@@ -22523,12 +22768,13 @@ var ScanCommand = class extends SmCommand {
    * the exit code. Exit 1 only when at least one issue is at `error`
    * severity (mirrors `sm check`, per spec § Exit codes).
    */
-  renderOutcome(result, persistedTo, dbPath, strict) {
+  renderOutcome(result, persistedTo, dbPath, strict, lensAutoDetected) {
     const exitCode2 = result.issues.some((i) => i.severity === "error") ? ExitCode.Issues : ExitCode.Ok;
     if (this.json) {
       return this.#renderJsonOutcome(result, exitCode2, strict);
     }
     const ansi = this.ansiFor("stdout");
+    this.#announceAutoDetectedLens(lensAutoDetected);
     const cwd = defaultRuntimeContext().cwd;
     const hasErrors = exitCode2 === ExitCode.Issues;
     const severityCounts = countBySeverity(result.issues);
@@ -22558,8 +22804,32 @@ var ScanCommand = class extends SmCommand {
       );
     }
     this.maybePrintCapNotice(result, ansi);
+    this.maybePrintSkippedFilesNotice(result, ansi);
     return exitCode2;
   }
+  /**
+   * Surface a WARN when the walker skipped one or more files for
+   * exceeding `scan.maxFileSizeBytes`. Lists every skipped file as
+   * `path (humanSize)` and points the user at the two levers
+   * (`scan.maxFileSizeBytes` to raise the limit, `.skillmapignore` to
+   * exclude the path). Routed through `printer.warn` (stderr) because a
+   * silently dropped file is degraded state the operator should read,
+   * not a mid-flight progress line.
+   */
+  maybePrintSkippedFilesNotice(result, ansi) {
+    const oversized = result.oversizedFiles ?? [];
+    if ((result.stats.filesOversized ?? oversized.length) <= 0) return;
+    const lines = formatOversizedFileRows(oversized).join("");
+    this.printer.warn(
+      tx(SCAN_TEXTS.scanSkippedFilesNotice, {
+        glyph: ansi.yellow("\u26A0"),
+        count: String(oversized.length),
+        noun: oversized.length === 1 ? SCAN_TEXTS.scanSkippedFileNounSingular : SCAN_TEXTS.scanSkippedFileNounPlural,
+        files: lines,
+        hint: ansi.dim(SCAN_TEXTS.scanSkippedFilesNoticeHint)
+      })
+    );
+  }
   /**
    * Surface the §Node cap notice when the walker actually stopped
    * accepting files because of the cap. Derivation: `filesWalked >
@@ -22583,6 +22853,21 @@ var ScanCommand = class extends SmCommand {
       })
     );
   }
+  /**
+   * Print the lens auto-detect line on stdout (the SAME stream as the
+   * scan summary) so the two never interleave on a tty. The bootstrap
+   * deliberately no longer prints this to stderr; the runner threads
+   * `lensAutoDetected` through so the CLI announces it here, in order,
+   * right before the summary. The text ends in a newline, so the
+   * summary lands cleanly on its own line. No-op when the lens came
+   * from config or no marker matched (`null` / `undefined`).
+   */
+  #announceAutoDetectedLens(lensAutoDetected) {
+    if (!lensAutoDetected) return;
+    this.printer.data(
+      tx(SCAN_RUNNER_TEXTS.activeProviderAutodetected, { id: lensAutoDetected })
+    );
+  }
   /**
    * `--json` output path. Under `--strict` (H4) self-validates the
    * ScanResult against `scan-result.schema.json` before emitting it,
@@ -23055,6 +23340,12 @@ var SERVER_TEXTS = {
   // watcher loop continues, a transient FS error must not kill the
   // broadcaster.
   watcherBatchFailed: "skill-map server: watcher batch failed ({{message}}).\n",
+  // Logged on the server pane when a scan batch (initial or follow-up)
+  // skipped one or more files for exceeding `scan.maxFileSizeBytes`.
+  // `{{files}}` is the comma-separated `path (size)` list. The SPA
+  // raises its own banner from the persisted `oversizedFiles`, so this
+  // is log-only (no WS advisory).
+  watcherFilesOversized: "skill-map server: skipped {{count}} file(s) over the size limit (scan.maxFileSizeBytes): {{files}}. Raise the limit or add them to .skillmapignore.\n",
   // Logged once when the pre-1.0 schema-drift check rebuilt the DB on
   // watcher boot (the on-disk cache was written by a different
   // major.minor). The scan that follows repopulates it; .sm sidecars
@@ -23140,19 +23431,19 @@ var SERVER_TEXTS = {
   // 400, cascade route rejects qualified ids: the bare-id PATCH is the
   // bundle macro endpoint. Anything containing `/` needs the dedicated
   // per-extension route below.
-  pluginsCascadeRouteQualifiedRejected: 'Plugin id "{{id}}" contains "/"; toggle individual extensions via PATCH /api/plugins/<bundle>/extensions/<extensionId>.',
+  pluginsCascadeRouteQualifiedRejected: 'Plugin id "{{id}}" contains "/"; toggle individual extensions via PATCH /api/plugins/<plugin>/extensions/<extensionId>.',
   // 404, unknown plugin / extension.
   pluginsUnknown: 'No plugin with id "{{id}}".',
-  pluginsExtensionUnknown: 'Plugin "{{bundleId}}" has no extension named "{{extensionId}}".',
+  pluginsExtensionUnknown: 'Plugin "{{pluginId}}" has no extension named "{{extensionId}}".',
   // 500, DB missing on a write path. Read paths degrade to empty
   // shapes, but mutations cannot persist without a DB so they fail fast.
   pluginsDbMissing: "Cannot persist plugin override: project DB not found at {{path}}. Run `sm scan` first or pass --db <path>.",
   // 403, host-enforced lock from `src/server/locked-plugins.ts`. The
-  // bundle (or qualified extension) is in the hardcoded lock-list and
+  // plugin (or qualified extension) is in the hardcoded lock-list and
   // its enabled state is fixed; the UI mirrors the same rule by
   // disabling the toggle.
   pluginsLocked: 'Plugin "{{id}}" is locked by the host and cannot be toggled.',
-  pluginsExtensionLocked: 'Extension "{{bundleId}}/{{extensionId}}" is locked by the host and cannot be toggled.',
+  pluginsExtensionLocked: 'Extension "{{pluginId}}/{{extensionId}}" is locked by the host and cannot be toggled.',
   // 400 envelopes specific to the bulk `PATCH /api/plugins` endpoint.
   // The single-id variants above still apply for per-entry validation
   // (unknown id, granularity mismatch, lock); these cover the
@@ -24219,28 +24510,28 @@ function registerPluginsRoute(app, deps) {
       });
     }
     const body = await parsePatchBody(c.req.raw);
-    const childIds = bundleExtensionIds(handle).map((extId) => qualifiedExtensionId(id, extId));
+    const childIds = pluginExtensionIds(handle).map((extId) => qualifiedExtensionId(id, extId));
     const writable = childIds.filter((q) => !isPluginLocked(q));
     return await persistManyAndProject(c, deps, writable, body.enabled);
   });
-  app.patch("/api/plugins/:bundleId/extensions/:extensionId", async (c) => {
-    const bundleId = c.req.param("bundleId");
+  app.patch("/api/plugins/:pluginId/extensions/:extensionId", async (c) => {
+    const pluginId = c.req.param("pluginId");
     const extensionId = c.req.param("extensionId");
-    const handle = findHandle(bundleId, deps);
+    const handle = findHandle(pluginId, deps);
     if (!handle) {
       throw new HTTPException9(404, {
-        message: tx(SERVER_TEXTS.pluginsUnknown, { id: bundleId })
+        message: tx(SERVER_TEXTS.pluginsUnknown, { id: pluginId })
       });
     }
     if (!hasExtension(handle, extensionId)) {
       throw new HTTPException9(404, {
-        message: tx(SERVER_TEXTS.pluginsExtensionUnknown, { bundleId, extensionId })
+        message: tx(SERVER_TEXTS.pluginsExtensionUnknown, { pluginId, extensionId })
       });
     }
-    const qualified = qualifiedExtensionId(bundleId, extensionId);
-    if (isPluginLocked(qualified) || isPluginLocked(bundleId)) {
+    const qualified = qualifiedExtensionId(pluginId, extensionId);
+    if (isPluginLocked(qualified) || isPluginLocked(pluginId)) {
       throw new HTTPException9(403, {
-        message: tx(SERVER_TEXTS.pluginsExtensionLocked, { bundleId, extensionId })
+        message: tx(SERVER_TEXTS.pluginsExtensionLocked, { pluginId, extensionId })
       });
     }
     const body = await parsePatchBody(c.req.raw);
@@ -24269,11 +24560,11 @@ function listItems(deps, resolveEnabled) {
   ];
 }
 function buildBuiltInItems(resolveEnabled) {
-  return sortBundlesForPresentation(builtInBundles).map((bundle) => {
-    const bundleLocked = isPluginLocked(bundle.id);
-    const extensions = bundle.extensions.map((ext) => {
-      const qualified = qualifiedExtensionId(bundle.id, ext.id);
-      const extLocked = bundleLocked || isPluginLocked(qualified);
+  return sortPluginsForPresentation(builtInPlugins).map((plugin) => {
+    const pluginLocked = isPluginLocked(plugin.id);
+    const extensions = plugin.extensions.map((ext) => {
+      const qualified = qualifiedExtensionId(plugin.id, ext.id);
+      const extLocked = pluginLocked || isPluginLocked(qualified);
       return {
         id: ext.id,
         kind: ext.kind,
@@ -24283,17 +24574,17 @@ function buildBuiltInItems(resolveEnabled) {
         ...extLocked ? { locked: true } : {}
       };
     });
-    const bundleEnabled = extensions.some((e) => e.enabled);
+    const pluginEnabled = extensions.some((e) => e.enabled);
     return {
-      id: bundle.id,
-      version: firstVersion(bundle.extensions),
-      kinds: uniqueKinds(bundle.extensions.map((e) => e.kind)),
-      status: bundleEnabled ? "enabled" : "disabled",
+      id: plugin.id,
+      version: firstVersion(plugin.extensions),
+      kinds: uniqueKinds(plugin.extensions.map((e) => e.kind)),
+      status: pluginEnabled ? "enabled" : "disabled",
       reason: null,
       source: "built-in",
-      description: bundle.description,
+      description: plugin.description,
       ...extensions.length > 0 ? { extensions } : {},
-      ...bundleLocked ? { locked: true } : {}
+      ...pluginLocked ? { locked: true } : {}
     };
   });
 }
@@ -24301,8 +24592,8 @@ function buildDiscoveredItems(discovered, deps, resolveEnabled) {
   return discovered.map((plugin) => buildDiscoveredItem(plugin, deps, resolveEnabled));
 }
 function buildDiscoveredItem(plugin, deps, resolveEnabled) {
-  const bundleLocked = isPluginLocked(plugin.id);
-  const extensions = projectExtensionRows(plugin, resolveEnabled, bundleLocked);
+  const pluginLocked = isPluginLocked(plugin.id);
+  const extensions = projectExtensionRows(plugin, resolveEnabled, pluginLocked);
   const optional = optionalDiscoveredFields(plugin, extensions);
   return {
     id: plugin.id,
@@ -24312,7 +24603,7 @@ function buildDiscoveredItem(plugin, deps, resolveEnabled) {
     reason: plugin.reason ?? null,
     source: classifyPluginSource(plugin.path, deps),
     ...optional,
-    ...bundleLocked ? { locked: true } : {},
+    ...pluginLocked ? { locked: true } : {},
     ...plugin.status === "disabled" ? { startsAsDisabled: true } : {}
   };
 }
@@ -24323,12 +24614,12 @@ function optionalDiscoveredFields(plugin, extensions) {
   if (extensions) out.extensions = extensions;
   return out;
 }
-function projectExtensionRows(plugin, resolveEnabled, bundleLocked) {
+function projectExtensionRows(plugin, resolveEnabled, pluginLocked) {
   if (!plugin.extensions || plugin.extensions.length === 0) return void 0;
   return plugin.extensions.map((ext) => {
     const description = readInstanceDescription(ext.instance);
     const qualified = qualifiedExtensionId(plugin.id, ext.id);
-    const extLocked = bundleLocked || isPluginLocked(qualified);
+    const extLocked = pluginLocked || isPluginLocked(qualified);
     return {
       id: ext.id,
       kind: ext.kind,
@@ -24437,28 +24728,28 @@ function validateBulkChange(change, deps) {
     }
     return null;
   }
-  const bundleId = change.id.slice(0, slash);
+  const pluginId = change.id.slice(0, slash);
   const extensionId = change.id.slice(slash + 1);
-  const handle = findHandle(bundleId, deps);
+  const handle = findHandle(pluginId, deps);
   if (!handle) {
     return {
       status: 404,
       code: "not-found",
-      message: tx(SERVER_TEXTS.pluginsUnknown, { id: bundleId })
+      message: tx(SERVER_TEXTS.pluginsUnknown, { id: pluginId })
     };
   }
   if (!hasExtension(handle, extensionId)) {
     return {
       status: 404,
       code: "not-found",
-      message: tx(SERVER_TEXTS.pluginsExtensionUnknown, { bundleId, extensionId })
+      message: tx(SERVER_TEXTS.pluginsExtensionUnknown, { pluginId, extensionId })
     };
   }
-  if (isPluginLocked(change.id) || isPluginLocked(bundleId)) {
+  if (isPluginLocked(change.id) || isPluginLocked(pluginId)) {
     return {
       status: 403,
       code: "locked",
-      message: tx(SERVER_TEXTS.pluginsExtensionLocked, { bundleId, extensionId })
+      message: tx(SERVER_TEXTS.pluginsExtensionLocked, { pluginId, extensionId })
     };
   }
   return null;
@@ -24482,7 +24773,7 @@ function expandBulkChangeKeys(change, deps) {
   if (change.id.includes("/")) return [change.id];
   const handle = findHandle(change.id, deps);
   if (!handle) return [];
-  return bundleExtensionIds(handle).map((extId) => qualifiedExtensionId(change.id, extId)).filter((q) => !isPluginLocked(q));
+  return pluginExtensionIds(handle).map((extId) => qualifiedExtensionId(change.id, extId)).filter((q) => !isPluginLocked(q));
 }
 async function buildFreshResolver2(deps) {
   return buildFreshResolver({
@@ -24495,21 +24786,21 @@ function composeResolver2(deps, overrides) {
   return composeResolver(deps.configService.effective(), overrides);
 }
 function findHandle(id, deps) {
-  const builtIn = builtInBundles.find((b) => b.id === id);
-  if (builtIn) return { kind: "built-in", bundle: builtIn };
+  const builtIn = builtInPlugins.find((b) => b.id === id);
+  if (builtIn) return { kind: "built-in", plugin: builtIn };
   const discovered = deps.pluginRuntime.discovered.find((p) => p.id === id);
   if (discovered) return { kind: "discovered", plugin: discovered };
   return null;
 }
-function bundleExtensionIds(handle) {
+function pluginExtensionIds(handle) {
   if (handle.kind === "built-in") {
-    return handle.bundle.extensions.map((e) => e.id);
+    return handle.plugin.extensions.map((e) => e.id);
   }
   return (handle.plugin.extensions ?? []).map((e) => e.id);
 }
 function hasExtension(handle, extensionId) {
   if (handle.kind === "built-in") {
-    return handle.bundle.extensions.some((e) => e.id === extensionId);
+    return handle.plugin.extensions.some((e) => e.id === extensionId);
   }
   return (handle.plugin.extensions ?? []).some((e) => e.id === extensionId);
 }
@@ -25116,7 +25407,9 @@ function createWatcherService(opts) {
                 message: sanitizeForTerminal(outcome.message)
               })
             );
+            return;
           }
+          warnOversizedFiles(outcome.result);
         },
         onWatcherError: (message) => {
           log.warn(
@@ -25179,6 +25472,17 @@ function createWatcherService(opts) {
     }
   };
 }
+function warnOversizedFiles(result) {
+  const oversized = result.oversizedFiles ?? [];
+  if ((result.stats.filesOversized ?? oversized.length) <= 0) return;
+  const files = oversized.map((f) => formatOversizedFilePair({ path: sanitizeForTerminal(f.path), bytes: f.bytes })).join(", ");
+  log.warn(
+    tx(SERVER_TEXTS.watcherFilesOversized, {
+      count: String(oversized.length),
+      files
+    })
+  );
+}
 function buildBroadcasterEmitter(broadcaster) {
   return {
     emit(event) {
@@ -26354,8 +26658,8 @@ function assembleKernel(pluginRuntime, noBuiltIns) {
         (c) => `${c.pluginId}/${c.extensionId}/${c.contributionId}`
       )
     );
-    for (const bundle of builtInBundles) {
-      for (const ext of bundle.extensions) {
+    for (const plugin of builtInPlugins) {
+      for (const ext of plugin.extensions) {
         collectViewContributions(ext.pluginId, ext.id, ext, mergedViewContributions, {
           excludeQualifiedIds: userKey
         });
@@ -26368,8 +26672,8 @@ function assembleKernel(pluginRuntime, noBuiltIns) {
 }
 function collectBuiltInProviders() {
   const out = [];
-  for (const bundle of builtInBundles) {
-    for (const ext of bundle.extensions) {
+  for (const plugin of builtInPlugins) {
+    for (const ext of plugin.extensions) {
       if (ext.kind === "provider") {
         out.push(ext);
       }
@@ -28615,4 +28919,5 @@ function resolveBareDefault() {
   );
   process.exit(ExitCode.Error);
 }
-//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map
+//# debugId=7c131b78-b7ad-5f03-b19c-1f70afdfeefb