@skill-map/cli 0.43.0 → 0.44.0

package/dist/cli.js

@@ -912,75 +912,77 @@ var antigravityProvider = {
   classify() {
     return null;
   },
-  // Seed catalog, PROVISIONAL, derived from the Gemini CLI slash-command
-  // surface. The Google Developers Blog post that announced the Antigravity
-  // CLI rollout on 2026-05-19 states verbatim: "The Antigravity CLI fully
-  // replaces the Gemini CLI ... preserves the most critical Gemini CLI
-  // features: Agent Skills, Hooks, Subagents, and Extensions (now rebranded
-  // as Antigravity plugins) ... shares the same agent harness as Antigravity
-  // 2.0, the new Antigravity desktop application." Since the four feature
-  // pillars carry over 1:1 and the agent harness is shared, the operator's
-  // built-in slash-command vocabulary is overwhelmingly likely to be
-  // Gemini CLI's. We mirror the full 38-verb Gemini CLI catalog (plus its
-  // four documented aliases: `dir`, `?`, `exit`, `bashes`) so a user file
-  // that names a skill / command `help`, `clear`, `mcp`, etc. is flagged
-  // immediately by `core/name-reserved` once the lens activates the catalog.
+  // Built-in slash-command catalog, captured verbatim from `agy /help`
+  // (Antigravity CLI v1.0.3). This REPLACES the earlier provisional list
+  // that mirrored Gemini CLI's verbs: `agy` ships its own surface. It
+  // DROPPED Gemini-only verbs (`vim`, `theme`, `terminal-setup`,
+  // `setup-github`, `bashes`, `shells`, `policies`, `extensions`, `about`,
+  // `auth`, `bug`, `chat`, `compress`, `docs`, `editor`, `ide`, `init`,
+  // `memory`, `restore`, `stats`, `tools`, `upgrade`, `?`, `dir`) and
+  // ADDED agent-first ones (`goal`, `grill-me`, `schedule`, `fast`, `btw`,
+  // `artifact`, `context`, `diff`, `fork`, `tasks`, `add-dir`, `credits`,
+  // `feedback`, `logout`, `open`, `planning`, `rename`, `statusline`,
+  // `title`, `usage`). Both the 35 primary verbs and the 8 documented
+  // aliases (`new`, `settings`, `quit`, `branch`, `switch`, `conversation`,
+  // `undo`, `quota`) are reserved: a user skill named after either is
+  // silently shadowed by the built-in once the catalog activates.
   //
-  // The catalog is INACTIVE today: the analyzer keys on `node.provider`
-  // and this Provider's `classify()` returns `null` for every path, so
-  // no node carries `provider: 'antigravity'`. The seed lives here so
-  // the day Antigravity grows its own on-disk kind (e.g. a vendor-specific
-  // `.antigravity/commands/` directory beyond the open-standard
-  // `.agents/skills/`) the catalog is already in place with no migration.
+  // Declared under the `skill` kind (NOT `command`): Antigravity has no
+  // vendor-specific command directory, its user slash-commands are skills
+  // (`.agents/skills/<name>/SKILL.md`, owned by the universal `agent-skills`
+  // Provider). The catalog is ACTIVE via the LENS SCOPE in
+  // `buildReservedNodePaths` (spec/architecture.md §Provider ·
+  // reservedNames): when `activeProvider === 'antigravity'` the orchestrator
+  // lends this `skill` catalog to `agent-skills` skill nodes, so a user
+  // `.agents/skills/goal/SKILL.md` is flagged because `/goal` is built-in.
   //
-  // **Reconciliation marker**: the day Google's docs at
-  // antigravity.google/docs publishes the authoritative slash-command
-  // reference, replace this comment + array with the official list (and
-  // bump the file's leading docblock to cite the new source URL).
+  // **Reconciliation marker**: re-capture from `agy /help` on each major
+  // Antigravity CLI release and bump the cited version above.
   reservedNames: {
-    command: [
-      "?",
-      "about",
+    skill: [
+      "add-dir",
       "agents",
-      "auth",
-      "bashes",
-      "bug",
-      "chat",
+      "artifact",
+      "branch",
+      "btw",
+      "changelog",
       "clear",
-      "commands",
-      "compress",
+      "config",
+      "context",
+      "conversation",
       "copy",
-      "dir",
-      "directory",
-      "docs",
-      "editor",
+      "credits",
+      "diff",
       "exit",
-      "extensions",
+      "fast",
+      "feedback",
+      "fork",
+      "goal",
+      "grill-me",
       "help",
       "hooks",
-      "ide",
-      "init",
+      "keybindings",
+      "logout",
       "mcp",
-      "memory",
       "model",
+      "new",
+      "open",
       "permissions",
-      "plan",
-      "policies",
-      "privacy",
+      "planning",
       "quit",
-      "restore",
+      "quota",
+      "rename",
       "resume",
       "rewind",
+      "schedule",
       "settings",
-      "setup-github",
-      "shells",
       "skills",
-      "stats",
-      "terminal-setup",
-      "theme",
-      "tools",
-      "upgrade",
-      "vim"
+      "statusline",
+      "switch",
+      "tasks",
+      "title",
+      "undo",
+      "usage"
     ]
   }
 };
@@ -3946,7 +3948,7 @@ var UPDATE_CHECK_TEXTS = {
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.43.0",
+  version: "0.44.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -3997,25 +3999,25 @@ var package_default = {
     typecheck: "tsc --noEmit",
     lint: "eslint .",
     "lint:fix": "eslint . --fix",
-    reference: "node scripts/build-reference.js",
-    "reference:check": "node scripts/build-reference.js --check",
     "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 reference:check && pnpm built-ins:check",
+    "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 && 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:ci": "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'",
-    "test:coverage": "tsc --noEmit && 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_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'",
+    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",
@@ -4026,6 +4028,7 @@ var package_default = {
     "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",
@@ -4096,6 +4099,7 @@ function ansiFor(opts) {
 }
 
 // cli/util/user-settings-store.ts
+import { randomUUID } from "crypto";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync5 } from "fs";
 import { homedir } from "os";
 import { join as join2 } from "path";
@@ -4204,13 +4208,13 @@ function userSettingsFilePath() {
   return join2(homedir(), SKILL_MAP_DIR, FILENAME);
 }
 function defaultSettings() {
-  return { schemaVersion: SCHEMA_VERSION, updateCheck: {} };
+  return { schemaVersion: SCHEMA_VERSION, updateCheck: {}, telemetry: {} };
 }
 function readUserSettings() {
   const parsed = readParsedFile();
   if (parsed === null) return defaultSettings();
   const validated = validateOrDefault(parsed);
-  return backfillUpdateCheck(validated);
+  return backfillSubObjects(validated);
 }
 function readParsedFile() {
   const path = userSettingsFilePath();
@@ -4232,11 +4236,12 @@ function validateOrDefault(parsed) {
   if (!result.ok) return defaultSettings();
   return result.data;
 }
-function backfillUpdateCheck(settings) {
-  if (settings.updateCheck === void 0) {
-    return { ...settings, updateCheck: {} };
-  }
-  return settings;
+function backfillSubObjects(settings) {
+  return {
+    ...settings,
+    updateCheck: settings.updateCheck ?? {},
+    telemetry: settings.telemetry ?? {}
+  };
 }
 function writeUserSettings(patch) {
   const dir = join2(homedir(), SKILL_MAP_DIR);
@@ -4258,14 +4263,49 @@ function isUpdateCheckEnabled() {
   const settings = readUserSettings();
   return settings.updateCheck?.enabled !== false;
 }
+function isErrorTelemetryEnabled() {
+  const settings = readUserSettings();
+  return settings.telemetry?.errorsEnabled === true;
+}
+function isUsageCliTelemetryEnabled() {
+  const settings = readUserSettings();
+  return settings.telemetry?.usageCliEnabled === true;
+}
+function isUsageUiTelemetryEnabled() {
+  const settings = readUserSettings();
+  return settings.telemetry?.usageUiEnabled === true;
+}
+function readAnonymousId() {
+  const settings = readUserSettings();
+  return settings.telemetry?.anonymousId ?? null;
+}
+function ensureAnonymousId(generate = () => randomUUID()) {
+  const existing = readAnonymousId();
+  if (existing !== null && existing !== "") return existing;
+  const id = generate();
+  writeUserSettings({ telemetry: { anonymousId: id } });
+  return id;
+}
+function hasTelemetryPromptBeenShown() {
+  const settings = readUserSettings();
+  return typeof settings.telemetry?.promptedAt === "number";
+}
+function hasSeenFirstRun() {
+  const settings = readUserSettings();
+  return typeof settings.telemetry?.firstRunAt === "number";
+}
 function mergeSettings(current, patch) {
   const merged = {
     schemaVersion: SCHEMA_VERSION,
-    updateCheck: { ...current.updateCheck ?? {} }
+    updateCheck: { ...current.updateCheck ?? {} },
+    telemetry: { ...current.telemetry ?? {} }
   };
   if (patch.updateCheck) {
     merged.updateCheck = { ...merged.updateCheck, ...patch.updateCheck };
   }
+  if (patch.telemetry) {
+    merged.telemetry = { ...merged.telemetry, ...patch.telemetry };
+  }
   return merged;
 }
 function tryLoadValidators() {
@@ -4378,40 +4418,40 @@ var updateCheckHook = {
 };
 
 // plugins/built-ins.ts
-var claudeProvider2 = { ...claudeProvider, pluginId: "claude", version: "0.43.0" };
-var atDirectiveExtractor2 = { ...atDirectiveExtractor, pluginId: "claude", version: "0.43.0" };
-var slashCommandExtractor2 = { ...slashCommandExtractor, pluginId: "claude", version: "0.43.0" };
-var antigravityProvider2 = { ...antigravityProvider, pluginId: "antigravity", version: "0.43.0" };
-var openaiProvider2 = { ...openaiProvider, pluginId: "openai", version: "0.43.0" };
-var agentSkillsProvider2 = { ...agentSkillsProvider, pluginId: "agent-skills", version: "0.43.0" };
-var coreMarkdownProvider2 = { ...coreMarkdownProvider, pluginId: "core", version: "0.43.0" };
-var annotationsExtractor2 = { ...annotationsExtractor, pluginId: "core", version: "0.43.0" };
-var externalUrlCounterExtractor2 = { ...externalUrlCounterExtractor, pluginId: "core", version: "0.43.0" };
-var markdownLinkExtractor2 = { ...markdownLinkExtractor, pluginId: "core", version: "0.43.0" };
-var mcpToolsExtractor2 = { ...mcpToolsExtractor, pluginId: "core", version: "0.43.0" };
-var toolsCounterExtractor2 = { ...toolsCounterExtractor, pluginId: "core", version: "0.43.0" };
-var annotationFieldUnknownAnalyzer2 = { ...annotationFieldUnknownAnalyzer, pluginId: "core", version: "0.43.0" };
-var annotationOrphanAnalyzer2 = { ...annotationOrphanAnalyzer, pluginId: "core", version: "0.43.0" };
-var annotationStaleAnalyzer2 = { ...annotationStaleAnalyzer, pluginId: "core", version: "0.43.0" };
-var contributionOrphanAnalyzer2 = { ...contributionOrphanAnalyzer, pluginId: "core", version: "0.43.0" };
-var issueCounterAnalyzer2 = { ...issueCounterAnalyzer, pluginId: "core", version: "0.43.0" };
-var jobFileOrphanAnalyzer2 = { ...jobFileOrphanAnalyzer, pluginId: "core", version: "0.43.0" };
-var linkConflictAnalyzer2 = { ...linkConflictAnalyzer, pluginId: "core", version: "0.43.0" };
-var linkCounterAnalyzer2 = { ...linkCounterAnalyzer, pluginId: "core", version: "0.43.0" };
-var linkSelfLoopAnalyzer2 = { ...linkSelfLoopAnalyzer, pluginId: "core", version: "0.43.0" };
-var nameReservedAnalyzer2 = { ...nameReservedAnalyzer, pluginId: "core", version: "0.43.0" };
-var nodeStabilityAnalyzer2 = { ...nodeStabilityAnalyzer, pluginId: "core", version: "0.43.0" };
-var nodeSupersededAnalyzer2 = { ...nodeSupersededAnalyzer, pluginId: "core", version: "0.43.0" };
-var referenceBrokenAnalyzer2 = { ...referenceBrokenAnalyzer, pluginId: "core", version: "0.43.0" };
-var referenceRedundantAnalyzer2 = { ...referenceRedundantAnalyzer, pluginId: "core", version: "0.43.0" };
-var schemaViolationAnalyzer2 = { ...schemaViolationAnalyzer, pluginId: "core", version: "0.43.0" };
-var signalCollisionAnalyzer2 = { ...signalCollisionAnalyzer, pluginId: "core", version: "0.43.0" };
-var triggerCollisionAnalyzer2 = { ...triggerCollisionAnalyzer, pluginId: "core", version: "0.43.0" };
-var asciiFormatter2 = { ...asciiFormatter, pluginId: "core", version: "0.43.0" };
-var jsonFormatter2 = { ...jsonFormatter, pluginId: "core", version: "0.43.0" };
-var nodeBumpAction2 = { ...nodeBumpAction, pluginId: "core", version: "0.43.0" };
-var nodeSupersedeAction2 = { ...nodeSupersedeAction, pluginId: "core", version: "0.43.0" };
-var updateCheckHook2 = { ...updateCheckHook, pluginId: "core", version: "0.43.0" };
+var claudeProvider2 = { ...claudeProvider, pluginId: "claude", version: "0.44.0" };
+var atDirectiveExtractor2 = { ...atDirectiveExtractor, pluginId: "claude", version: "0.44.0" };
+var slashCommandExtractor2 = { ...slashCommandExtractor, pluginId: "claude", version: "0.44.0" };
+var antigravityProvider2 = { ...antigravityProvider, pluginId: "antigravity", version: "0.44.0" };
+var openaiProvider2 = { ...openaiProvider, pluginId: "openai", version: "0.44.0" };
+var agentSkillsProvider2 = { ...agentSkillsProvider, pluginId: "agent-skills", version: "0.44.0" };
+var coreMarkdownProvider2 = { ...coreMarkdownProvider, pluginId: "core", version: "0.44.0" };
+var annotationsExtractor2 = { ...annotationsExtractor, pluginId: "core", version: "0.44.0" };
+var externalUrlCounterExtractor2 = { ...externalUrlCounterExtractor, pluginId: "core", version: "0.44.0" };
+var markdownLinkExtractor2 = { ...markdownLinkExtractor, pluginId: "core", version: "0.44.0" };
+var mcpToolsExtractor2 = { ...mcpToolsExtractor, pluginId: "core", version: "0.44.0" };
+var toolsCounterExtractor2 = { ...toolsCounterExtractor, pluginId: "core", version: "0.44.0" };
+var annotationFieldUnknownAnalyzer2 = { ...annotationFieldUnknownAnalyzer, pluginId: "core", version: "0.44.0" };
+var annotationOrphanAnalyzer2 = { ...annotationOrphanAnalyzer, pluginId: "core", version: "0.44.0" };
+var annotationStaleAnalyzer2 = { ...annotationStaleAnalyzer, pluginId: "core", version: "0.44.0" };
+var contributionOrphanAnalyzer2 = { ...contributionOrphanAnalyzer, pluginId: "core", version: "0.44.0" };
+var issueCounterAnalyzer2 = { ...issueCounterAnalyzer, pluginId: "core", version: "0.44.0" };
+var jobFileOrphanAnalyzer2 = { ...jobFileOrphanAnalyzer, pluginId: "core", version: "0.44.0" };
+var linkConflictAnalyzer2 = { ...linkConflictAnalyzer, pluginId: "core", version: "0.44.0" };
+var linkCounterAnalyzer2 = { ...linkCounterAnalyzer, pluginId: "core", version: "0.44.0" };
+var linkSelfLoopAnalyzer2 = { ...linkSelfLoopAnalyzer, pluginId: "core", version: "0.44.0" };
+var nameReservedAnalyzer2 = { ...nameReservedAnalyzer, pluginId: "core", version: "0.44.0" };
+var nodeStabilityAnalyzer2 = { ...nodeStabilityAnalyzer, pluginId: "core", version: "0.44.0" };
+var nodeSupersededAnalyzer2 = { ...nodeSupersededAnalyzer, pluginId: "core", version: "0.44.0" };
+var referenceBrokenAnalyzer2 = { ...referenceBrokenAnalyzer, pluginId: "core", version: "0.44.0" };
+var referenceRedundantAnalyzer2 = { ...referenceRedundantAnalyzer, pluginId: "core", version: "0.44.0" };
+var schemaViolationAnalyzer2 = { ...schemaViolationAnalyzer, pluginId: "core", version: "0.44.0" };
+var signalCollisionAnalyzer2 = { ...signalCollisionAnalyzer, pluginId: "core", version: "0.44.0" };
+var triggerCollisionAnalyzer2 = { ...triggerCollisionAnalyzer, pluginId: "core", version: "0.44.0" };
+var asciiFormatter2 = { ...asciiFormatter, pluginId: "core", version: "0.44.0" };
+var jsonFormatter2 = { ...jsonFormatter, pluginId: "core", version: "0.44.0" };
+var nodeBumpAction2 = { ...nodeBumpAction, pluginId: "core", version: "0.44.0" };
+var nodeSupersedeAction2 = { ...nodeSupersedeAction, pluginId: "core", version: "0.44.0" };
+var updateCheckHook2 = { ...updateCheckHook, pluginId: "core", version: "0.44.0" };
 var builtInBundles = [
   {
     id: "claude",
@@ -4943,6 +4983,341 @@ function defaultRuntimeContext() {
   return { cwd: process.cwd() };
 }
 
+// cli/telemetry/first-run-prompt.ts
+import { createInterface } from "readline/promises";
+
+// cli/i18n/telemetry.texts.ts
+var TELEMETRY_PROMPT_TEXTS = {
+  // Header + body of the one-time question (glyph `ℹ` added by the renderer).
+  title: "Anonymous error and usage reporting",
+  intro: [
+    "skill-map can send anonymous reports to help fix bugs and decide what to",
+    "build next. No personal information is ever sent: not your files or their",
+    "contents, not your folder or home paths, not your settings."
+  ],
+  question: "Enable anonymous error and usage reporting?",
+  answerYes: "[Y]es",
+  answerNo: "[n]o",
+  answerDetails: "[d]etails",
+  // Disclosure shown on `[d]etails`, then the question is re-asked.
+  detailsSentTitle: "Sent, only if you turn this on",
+  detailsSent: [
+    "crashes: error name, code, message, and a path-stripped stack trace",
+    "usage: the command you ran and its flag names (never their values)",
+    "usage: which built-in extractors ran, and which UI views you opened",
+    "cli version, node major, os, arch, and a random anonymous id"
+  ],
+  detailsNeverTitle: "Never sent",
+  detailsNever: [
+    "your files, their contents, frontmatter, annotations",
+    "absolute paths, hostname, your username, ip address",
+    "your settings values or any flag values"
+  ],
+  detailsHint: "Turn error reports, CLI usage, and UI usage on or off independently in Settings, or force everything off with SKILL_MAP_TELEMETRY=0.",
+  // Confirmation lines (glyph added by the renderer).
+  enabled: "Telemetry on. Thanks. Turn error reports, CLI usage, and UI usage off independently in Settings.",
+  disabled: "Telemetry off. You can turn any of it on later in Settings."
+};
+
+// public-config.ts
+var SENTRY_DSN_NODE = "https://8b73dbb2563da4b77def12ce5ee46e75@o4511475590037504.ingest.de.sentry.io/4511475708002384";
+var POSTHOG_KEY_NODE = "phc_vMX3PcNeDsacWNg2hYEbKVXDijSWcjKFzabCkzU7RNEr";
+var POSTHOG_HOST = "https://eu.i.posthog.com";
+
+// core/telemetry/scrub.ts
+var HOME_PLACEHOLDER = "<HOME>";
+var STRIPPED_ENVELOPE_KEYS = ["server_name", "user"];
+var HOME_PATTERNS = [
+  // Windows: drive + Users + one user segment (back- or forward-slash).
+  /[A-Za-z]:[\\/]Users[\\/][^\\/\s:*?"<>|]+/g,
+  // POSIX user homes: /home/<user> or macOS /Users/<user>.
+  /\/(?:home|Users)\/[^/\s:]+/g,
+  // Root account home.
+  /\/root(?=\/|\b)/g
+];
+function scrubString(value) {
+  let out = value;
+  for (const pattern of HOME_PATTERNS) {
+    out = out.replace(pattern, HOME_PLACEHOLDER);
+  }
+  return out;
+}
+function scrubEvent(event) {
+  const walked = walk(event);
+  if (walked !== null && typeof walked === "object" && !Array.isArray(walked)) {
+    const record = walked;
+    for (const key of STRIPPED_ENVELOPE_KEYS) {
+      if (key in record) delete record[key];
+    }
+  }
+  return walked;
+}
+function walk(value) {
+  if (typeof value === "string") return scrubString(value);
+  if (Array.isArray(value)) return value.map((item) => walk(item));
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      out[key] = walk(child);
+    }
+    return out;
+  }
+  return value;
+}
+
+// cli/telemetry/telemetry-env.ts
+var TELEMETRY_ENV_VAR = "SKILL_MAP_TELEMETRY_ENV";
+function resolveTelemetryEnv() {
+  const raw = process.env[TELEMETRY_ENV_VAR];
+  if (raw === void 0 || raw.trim() === "" || raw === "prod" || raw === "production") {
+    return "prod";
+  }
+  return "dev";
+}
+
+// cli/telemetry/sentry-init.ts
+var KILL_SWITCH_ENV = "SKILL_MAP_TELEMETRY";
+var sdk = null;
+function isCliDsnConfigured() {
+  return SENTRY_DSN_NODE !== "";
+}
+function isTelemetryForcedOff() {
+  return process.env[KILL_SWITCH_ENV] === "0";
+}
+function isTelemetryActive(dsn) {
+  if (isTelemetryForcedOff()) return false;
+  if (dsn === "") return false;
+  return isErrorTelemetryEnabled();
+}
+async function initSentryCli(version, loadSdk = () => import("@sentry/node")) {
+  if (sdk) return;
+  if (!isTelemetryActive(SENTRY_DSN_NODE)) return;
+  const Sentry = await loadSdk();
+  Sentry.init({
+    dsn: SENTRY_DSN_NODE,
+    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.
+    initialScope: { tags: { surface: "cli" } },
+    // Errors only: do NOT register the OpenTelemetry ESM loader hooks. We
+    // run no tracing / auto-instrumentation, and the hook calls the
+    // deprecated `module.register()` (a `DEP0205` warning on Node >= 26 that
+    // would print on every telemetry-on invocation). Disabling it keeps
+    // stderr clean and skips the loader's startup cost.
+    registerEsmLoaderHooks: false,
+    defaultIntegrations: false,
+    integrations: [
+      Sentry.onUncaughtExceptionIntegration(),
+      Sentry.onUnhandledRejectionIntegration()
+    ],
+    tracesSampleRate: 0,
+    sendDefaultPii: false,
+    beforeSend: (event) => scrubEvent(event)
+  });
+  sdk = Sentry;
+}
+function setTelemetryVerbTag(verb) {
+  if (!sdk || verb === void 0 || verb === "") return;
+  sdk.setTag("verb", verb);
+}
+async function closeSentryCli(timeoutMs = 2e3) {
+  if (!sdk) return;
+  try {
+    await sdk.close(timeoutMs);
+  } catch {
+  }
+}
+
+// cli/telemetry/usage-collector.ts
+var BUILT_IN_PLUGIN_IDS = /* @__PURE__ */ new Set([
+  "claude",
+  "antigravity",
+  "openai",
+  "agent-skills",
+  "core"
+]);
+var EXTERNAL_PLUGIN_PLACEHOLDER = "external_plugin";
+function qualifyExtensionForUsage(qualifiedId2) {
+  const slash = qualifiedId2.indexOf("/");
+  if (slash <= 0) return EXTERNAL_PLUGIN_PLACEHOLDER;
+  const pluginId = qualifiedId2.slice(0, slash);
+  return BUILT_IN_PLUGIN_IDS.has(pluginId) ? qualifiedId2 : EXTERNAL_PLUGIN_PLACEHOLDER;
+}
+function buildScanExtensionSet(executedExtensionIds) {
+  const out = /* @__PURE__ */ new Set();
+  for (const id of executedExtensionIds) {
+    out.add(qualifyExtensionForUsage(id));
+  }
+  return [...out].sort();
+}
+function extractFlagNames(args2) {
+  const out = /* @__PURE__ */ new Set();
+  for (const arg of args2) {
+    if (!arg.startsWith("-")) continue;
+    const name = arg.replace(/^-+/, "").split("=")[0];
+    if (name !== void 0 && name !== "") out.add(name);
+  }
+  return [...out].sort();
+}
+function cliVerbEventName(verb, knownVerbs) {
+  return `cli.${knownVerbs.has(verb) ? verb : "unknown"}`;
+}
+function buildCliVerbProperties(flagNames, extensions) {
+  const flags = [...new Set(flagNames)].sort();
+  return extensions ? { flags, extensions } : { flags };
+}
+function envUsageProps(cliVersion) {
+  return {
+    cli_version: cliVersion,
+    node_major: Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10),
+    os: process.platform,
+    arch: process.arch,
+    environment: resolveTelemetryEnv()
+  };
+}
+
+// cli/telemetry/posthog-init.ts
+var client = null;
+function isUsageKeyConfigured() {
+  return POSTHOG_KEY_NODE !== "";
+}
+function isUsageCliTelemetryActive(key) {
+  if (isTelemetryForcedOff()) return false;
+  if (key === "") return false;
+  return isUsageCliTelemetryEnabled();
+}
+function scrubUsageEvent(event) {
+  return event === null ? null : scrubEvent(event);
+}
+async function initUsageCli(loadSdk = () => import("posthog-node")) {
+  if (client) return;
+  if (!isUsageCliTelemetryActive(POSTHOG_KEY_NODE)) return;
+  const { PostHog } = await loadSdk();
+  client = new PostHog(POSTHOG_KEY_NODE, {
+    host: POSTHOG_HOST,
+    // Second line of defense behind the project-level IP drop: the client
+    // never attaches an IP or geo, and never autocaptures.
+    disableGeoip: true,
+    before_send: scrubUsageEvent
+  });
+}
+function captureUsage(event, properties) {
+  if (client === null) return;
+  const distinctId = readAnonymousId();
+  if (distinctId === null) return;
+  client.capture({
+    distinctId,
+    event,
+    properties: { ...envUsageProps(VERSION), ...properties }
+  });
+}
+var pendingScanExtensions = null;
+function setScanExtensions(extensions) {
+  pendingScanExtensions = extensions;
+}
+function captureCliInvocation(verb, flagNames, knownVerbs) {
+  const extensions = pendingScanExtensions;
+  pendingScanExtensions = null;
+  captureUsage(cliVerbEventName(verb, knownVerbs), buildCliVerbProperties(flagNames, extensions));
+}
+async function flushUsageCli(timeoutMs = 2e3) {
+  if (client === null) return;
+  try {
+    await client.shutdown(timeoutMs);
+  } catch {
+  }
+}
+
+// cli/telemetry/first-run-prompt.ts
+function interpretConsentAnswer(raw) {
+  const value = raw.trim().toLowerCase();
+  if (value === "n" || value === "no") return "no";
+  if (value === "d" || value === "details") return "details";
+  return "yes";
+}
+function isPromptEligible(opts) {
+  return opts.dsnConfigured && opts.isTTY && !opts.isCI && !opts.forcedOff && !opts.alreadyPrompted;
+}
+function liveGateInputs(stdout) {
+  return {
+    dsnConfigured: isCliDsnConfigured() || isUsageKeyConfigured(),
+    isTTY: stdout.isTTY === true,
+    isCI: Boolean(process.env["CI"]),
+    forcedOff: isTelemetryForcedOff(),
+    alreadyPrompted: hasTelemetryPromptBeenShown()
+  };
+}
+function renderConsent(ansi) {
+  const t = TELEMETRY_PROMPT_TEXTS;
+  const answerLine = `     ${t.question}  ${ansi.bold(t.answerYes)}  ${t.answerNo}  ${ansi.dim(t.answerDetails)} `;
+  return {
+    question: [
+      `  ${ansi.cyan("\u2139")}  ${ansi.bold(t.title)}`,
+      ...t.intro.map((line) => `     ${line}`),
+      "",
+      answerLine
+    ].join("\n"),
+    reprompt: answerLine,
+    details: [
+      "",
+      `     ${t.detailsSentTitle}`,
+      ...t.detailsSent.map((line) => `       ${ansi.dim("\u2192")}  ${line}`),
+      `     ${t.detailsNeverTitle}`,
+      ...t.detailsNever.map((line) => `       ${ansi.red("\u2715")}  ${line}`),
+      "",
+      `     ${ansi.dim(t.detailsHint)}`,
+      ""
+    ].join("\n"),
+    enabled: `  ${ansi.green("\u2713")}  ${t.enabled}
+`,
+    disabled: `  ${ansi.cyan("\u2139")}  ${t.disabled}
+`
+  };
+}
+async function readConsentDecision(rl, stdout, rendered) {
+  let answer = interpretConsentAnswer(await rl.question(rendered.question));
+  while (answer === "details") {
+    stdout.write(rendered.details);
+    answer = interpretConsentAnswer(await rl.question(rendered.reprompt));
+  }
+  return answer === "yes";
+}
+async function runConsentPrompt(stdin, stdout, nowMs) {
+  const rendered = renderConsent(
+    ansiFor({ isTTY: stdout.isTTY === true, noColorFlag: false })
+  );
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const consented = await readConsentDecision(rl, stdout, rendered);
+    writeUserSettings({
+      telemetry: {
+        errorsEnabled: consented,
+        usageCliEnabled: consented,
+        usageUiEnabled: consented,
+        promptedAt: nowMs
+      }
+    });
+    if (consented) ensureAnonymousId();
+    stdout.write(consented ? rendered.enabled : rendered.disabled);
+  } catch {
+  } finally {
+    rl.close();
+  }
+}
+async function maybeRunFirstRunPrompt({
+  stdin = process.stdin,
+  stdout = process.stdout,
+  nowMs = Date.now()
+} = {}) {
+  if (!isPromptEligible(liveGateInputs(stdout))) return;
+  if (!hasSeenFirstRun()) {
+    writeUserSettings({ telemetry: { firstRunAt: nowMs } });
+    return;
+  }
+  await runConsentPrompt(stdin, stdout, nowMs);
+}
+
 // cli/commands/bump.ts
 import { Command as Command2, Option as Option2 } from "clipanion";
 
@@ -5625,13 +6000,13 @@ var CONSENT_TEXTS = {
 };
 
 // cli/util/confirm.ts
-import { createInterface } from "readline";
+import { createInterface as createInterface2 } from "readline";
 var YES_PATTERN = new RegExp(UTIL_TEXTS.confirmYesPatternSource, "i");
 var NO_PATTERN = new RegExp(UTIL_TEXTS.confirmNoPatternSource, "i");
 async function confirm(question, streams, opts) {
   const defaultAnswer = opts?.defaultAnswer ?? "no";
   const suffix = defaultAnswer === "yes" ? UTIL_TEXTS.confirmPromptSuffixDefaultYes : UTIL_TEXTS.confirmPromptSuffix;
-  const rl = createInterface({ input: streams.stdin, output: streams.stderr });
+  const rl = createInterface2({ input: streams.stdin, output: streams.stderr });
   try {
     const answer = await new Promise(
       (resolveP) => rl.question(`${question}${suffix}`, resolveP)
@@ -7904,7 +8279,7 @@ var SqliteStorageAdapter = class {
   /**
    * Access the underlying Kysely instance.
    *
-   * Test-only escape hatch (per AGENTS.md § Kernel boundaries, tests
+   * Test-only escape hatch (per context/kernel.md §Kernel boundaries, tests
    * are the documented exception). CLI commands MUST consume the
    * adapter through the namespaced port surfaces (`port.<namespace>.*`
    * or `port.transaction(...)`); reaching for this getter from a
@@ -10243,8 +10618,8 @@ var DEFAULT_READ_CONFIG = Object.freeze({
 });
 function resolveProviderWalk(provider) {
   if (provider.walk) {
-    const walk2 = provider.walk.bind(provider);
-    return walk2;
+    const walk3 = provider.walk.bind(provider);
+    return walk3;
   }
   const read = provider.read ?? DEFAULT_READ_CONFIG;
   return (roots, options) => {
@@ -13870,8 +14245,7 @@ var HelpCommand = class extends Command15 {
 
       Formats:
         human (default): pretty terminal output.
-        md             : canonical markdown. context/cli-reference.md is
-                         regenerated from this and CI fails on drift.
+        md             : canonical markdown for documentation.
         json           : structured surface dump per spec/cli-contract.md.
     `
   });
@@ -15508,11 +15882,11 @@ import { join as join13, relative as relative4, sep as sep4 } from "path";
 function discoverOrphanSidecars(roots, shouldSkip) {
   const out = [];
   for (const root of roots) {
-    walk(root, root, shouldSkip ?? (() => false), out);
+    walk2(root, root, shouldSkip ?? (() => false), out);
   }
   return out;
 }
-function walk(root, current, shouldSkip, out) {
+function walk2(root, current, shouldSkip, out) {
   let entries;
   try {
     entries = readdirSync7(current, { withFileTypes: true, encoding: "utf8" });
@@ -15525,7 +15899,7 @@ function walk(root, current, shouldSkip, out) {
     if (shouldSkip(rel)) continue;
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
-      walk(root, full, shouldSkip, out);
+      walk2(root, full, shouldSkip, out);
       continue;
     }
     if (!entry.isFile()) continue;
@@ -16149,7 +16523,8 @@ function buildPostWalkTransformCtx(providers, nodes, activeProvider) {
   const reservedNodePaths = buildReservedNodePaths(
     nodes,
     kindRegistry,
-    reservedNamesByProviderKind
+    reservedNamesByProviderKind,
+    activeProvider
   );
   return { kindRegistry, providerResolution, activeProvider, reservedNodePaths };
 }
@@ -16180,19 +16555,23 @@ function indexReservedNames(provider, out) {
     }
   }
 }
-function buildReservedNodePaths(nodes, kindRegistry, reservedNamesByProviderKind) {
+function buildReservedNodePaths(nodes, kindRegistry, reservedNamesByProviderKind, activeProvider) {
   const out = /* @__PURE__ */ new Set();
   for (const node of nodes) {
-    const key = `${node.provider}/${node.kind}`;
-    const reservedSet = reservedNamesByProviderKind.get(key);
-    if (!reservedSet || reservedSet.size === 0) continue;
-    const ids = deriveNodeIdentifiers(node, kindRegistry.get(key));
-    if (ids.some((id) => reservedSet.has(id))) {
+    const selfKey = `${node.provider}/${node.kind}`;
+    const selfReserved = reservedNamesByProviderKind.get(selfKey);
+    const lensReserved = activeProvider && activeProvider !== node.provider ? reservedNamesByProviderKind.get(`${activeProvider}/${node.kind}`) : void 0;
+    if (!hasEntries(selfReserved) && !hasEntries(lensReserved)) continue;
+    const ids = deriveNodeIdentifiers(node, kindRegistry.get(selfKey));
+    if (ids.some((id) => selfReserved?.has(id) === true || lensReserved?.has(id) === true)) {
       out.add(node.path);
     }
   }
   return out;
 }
+function hasEntries(set) {
+  return set !== void 0 && set.size > 0;
+}
 function buildScanSetup(options) {
   const start = Date.now();
   const emitter = options.emitter ?? new InMemoryProgressEmitter();
@@ -16754,7 +17133,7 @@ function safeStat(path) {
 }
 
 // core/runtime/active-provider-bootstrap.ts
-import { createInterface as createInterface2 } from "readline";
+import { createInterface as createInterface3 } from "readline";
 import { isAbsolute as isAbsolute9, join as join16 } from "path";
 async function bootstrapActiveProvider(opts) {
   const fromCwd = resolveActiveProvider(opts.cwd, opts.providers);
@@ -16910,7 +17289,7 @@ async function promptForLens(detected, stdin, stderr, warnGlyph) {
     );
   }
   stderr.write(lines.join("\n") + "\n");
-  const rl = createInterface2({ input: stdin, output: stderr });
+  const rl = createInterface3({ input: stdin, output: stderr });
   try {
     const answer = await new Promise(
       (resolveP) => rl.question(SCAN_RUNNER_TEXTS.activeProviderPromptInput, resolveP)
@@ -16929,7 +17308,7 @@ async function promptForLens(detected, stdin, stderr, warnGlyph) {
 
 // core/sqlite/db-drift-reset.ts
 import { existsSync as existsSync23 } from "fs";
-import { createInterface as createInterface3 } from "readline";
+import { createInterface as createInterface4 } from "readline";
 import { DatabaseSync as DatabaseSync7 } from "node:sqlite";
 
 // core/sqlite/i18n/db-drift.texts.ts
@@ -16996,7 +17375,7 @@ async function askDriftReset(dbVersion, policy) {
       hint: dim(DB_DRIFT_TEXTS.driftPromptHint)
     })
   );
-  const rl = createInterface3({ input: policy.stdin, output: policy.stderr });
+  const rl = createInterface4({ input: policy.stdin, output: policy.stderr });
   try {
     const answer = await new Promise(
       (resolveP) => rl.question(DB_DRIFT_TEXTS.driftPromptQuestion, resolveP)
@@ -17032,9 +17411,9 @@ async function runScanForCommand(opts) {
   const { cfg, ignoreFilter, strict, effectiveRoots } = scanInputs;
   let referenceablePaths;
   if (cfg.scan.referencePaths.length > 0) {
-    const walk2 = walkReferencePaths(cfg.scan.referencePaths, ctx.cwd);
-    referenceablePaths = walk2.paths;
-    emitReferenceWalkAdvisory(walk2, opts);
+    const walk3 = walkReferencePaths(cfg.scan.referencePaths, ctx.cwd);
+    referenceablePaths = walk3.paths;
+    emitReferenceWalkAdvisory(walk3, opts);
   }
   const loadPrior = makePriorLoader(opts.noBuiltIns, strict);
   const jobsDir = defaultProjectJobsDir(ctx);
@@ -17096,11 +17475,11 @@ async function resolveActiveLens(opts, ctx, effectiveRoots, pluginRuntime, provi
   });
   return { kind: "ok", activeProvider: bootstrap.activeProvider };
 }
-function emitReferenceWalkAdvisory(walk2, opts) {
-  if (walk2.truncated) {
+function emitReferenceWalkAdvisory(walk3, opts) {
+  if (walk3.truncated) {
     opts.printer.warn(SCAN_RUNNER_TEXTS.referenceWalkTruncated);
   }
-  for (const missing of walk2.missingRoots) {
+  for (const missing of walk3.missingRoots) {
     opts.printer.warn(
       tx(SCAN_RUNNER_TEXTS.referenceWalkMissingRoot, { path: missing })
     );
@@ -17279,7 +17658,8 @@ async function runPersistPath(opts, dbPath, jobsDir, strict, loadPrior, runScanW
     renameOps: outcome.renameOps,
     persistedTo: dbPath,
     dbPath,
-    strict
+    strict,
+    executedExtensionIds: outcome.extractorRuns.map((run) => run.extractorId)
   };
 }
 async function runEphemeralPath(opts, dbPath, strict, loadPrior, runScanWith) {
@@ -17297,7 +17677,8 @@ async function runEphemeralPath(opts, dbPath, strict, loadPrior, runScanWith) {
       renameOps: scanned.renameOps,
       persistedTo: null,
       dbPath,
-      strict
+      strict,
+      executedExtensionIds: scanned.extractorRuns.map((run) => run.extractorId)
     };
   } catch (err) {
     return { kind: "scan-error", message: formatErrorMessage(err) };
@@ -20221,6 +20602,8 @@ var TogglePluginsBase = class extends SmCommand {
     targets = lockError;
     const keys = expandToKeys(targets);
     await this.#persistKeys(keys, enabled);
+    const set = buildScanExtensionSet(keys);
+    captureUsage("plugin.apply", enabled ? { enabled: set, disabled: [] } : { enabled: [], disabled: set });
     this.#renderSuccess(keys, enabled);
     return ExitCode.Ok;
   }
@@ -21183,6 +21566,29 @@ function stripFrontmatterFence(text) {
 }
 var REFRESH_COMMANDS = [RefreshCommand];
 
+// cli/i18n/intentional-fail.texts.ts
+var INTENTIONAL_FAIL_TEXTS = {
+  triggering: "Triggering an intentional uncaught error to exercise Sentry error reporting...",
+  errorMessage: "skill-map intentional failure (Sentry self-test)"
+};
+
+// cli/commands/intentional-fail.ts
+var IntentionalFailCommand = class extends SmCommand {
+  static paths = [["intentional-fail"]];
+  // No `static usage` on purpose: that is what keeps the verb out of every
+  // help / reference surface Clipanion drives from command definitions.
+  // A self-test crash has no meaningful "done in <...>" line.
+  emitElapsed = false;
+  async run() {
+    this.printer.warn(INTENTIONAL_FAIL_TEXTS.triggering);
+    setTimeout(() => {
+      throw new Error(INTENTIONAL_FAIL_TEXTS.errorMessage);
+    }, 0);
+    await new Promise((resolve40) => setTimeout(resolve40, 5e3));
+    return 1;
+  }
+};
+
 // cli/commands/scan.ts
 import { Command as Command31, Option as Option29 } from "clipanion";
 
@@ -21414,9 +21820,9 @@ function createWatcherRuntime(opts) {
         overrideMaxNodes: opts.maxNodesOverride ?? null
       };
       if (cfg.scan.referencePaths.length > 0) {
-        const walk2 = walkReferencePaths(cfg.scan.referencePaths, cwd);
-        if (walk2.paths.size > 0) {
-          runOptions.referenceablePaths = walk2.paths;
+        const walk3 = walkReferencePaths(cfg.scan.referencePaths, cwd);
+        if (walk3.paths.size > 0) {
+          runOptions.referenceablePaths = walk3.paths;
           runOptions.cwd = cwd;
         }
       }
@@ -21994,7 +22400,11 @@ var ScanCommand = class extends SmCommand {
       style,
       ...parsedMaxNodes.value !== void 0 ? { maxNodes: parsedMaxNodes.value } : {}
     });
-    return outcome.kind === "ok" ? this.renderOutcome(outcome.result, outcome.persistedTo, outcome.dbPath, outcome.strict) : this.renderFailure(outcome);
+    if (outcome.kind === "ok") {
+      setScanExtensions(buildScanExtensionSet(outcome.executedExtensionIds));
+      return this.renderOutcome(outcome.result, outcome.persistedTo, outcome.dbPath, outcome.strict);
+    }
+    return this.renderFailure(outcome);
   }
   /**
    * Parse `--max-nodes <N>`. Returns either the integer value (or
@@ -22512,7 +22922,7 @@ import { WebSocketServer } from "ws";
 // server/app.ts
 import { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
-import { HTTPException as HTTPException15 } from "hono/http-exception";
+import { HTTPException as HTTPException16 } from "hono/http-exception";
 
 // core/config/service.ts
 var ConfigService = class {
@@ -22749,6 +23159,10 @@ var SERVER_TEXTS = {
   preferencesBodyEmpty: "Request body must contain at least one known preference (e.g. `updateCheck.enabled`).",
   preferencesUpdateCheckNotObject: '`updateCheck` must be an object (e.g. `{"updateCheck": {"enabled": false}}`).',
   preferencesUpdateCheckEnabledNotBoolean: "`updateCheck.enabled` must be a boolean.",
+  preferencesTelemetryNotObject: '`telemetry` must be an object (e.g. `{"telemetry": {"errorsEnabled": true}}`).',
+  preferencesTelemetryErrorsEnabledNotBoolean: "`telemetry.errorsEnabled` must be a boolean.",
+  preferencesTelemetryUsageCliEnabledNotBoolean: "`telemetry.usageCliEnabled` must be a boolean.",
+  preferencesTelemetryUsageUiEnabledNotBoolean: "`telemetry.usageUiEnabled` must be a boolean.",
   preferencesPersistFailed: "Could not persist preferences: {{message}}",
   // ---- project-preferences route (routes/project-preferences.ts) ----------
   //
@@ -22908,6 +23322,53 @@ function createSecurityHeaders() {
   };
 }
 
+// server/telemetry/sentry.ts
+import { HTTPException } from "hono/http-exception";
+var sdk2 = null;
+async function initSentryBff(version, loadSdk = () => import("@sentry/node")) {
+  if (sdk2) return;
+  if (!isTelemetryActive(SENTRY_DSN_NODE)) return;
+  const Sentry = await loadSdk();
+  Sentry.init({
+    dsn: SENTRY_DSN_NODE,
+    release: `@skill-map/cli@${version}`,
+    environment: resolveTelemetryEnv(),
+    // Shared project with the CLI; the `surface` tag separates the two.
+    initialScope: { tags: { surface: "bff" } },
+    // Errors only: skip the OpenTelemetry ESM loader hooks (we run no
+    // tracing). They call the deprecated `module.register()` (a Node >= 26
+    // DEP0205 warning) and add startup cost for nothing here.
+    registerEsmLoaderHooks: false,
+    defaultIntegrations: false,
+    integrations: [],
+    tracesSampleRate: 0,
+    sendDefaultPii: false,
+    beforeSend: (event) => scrubEvent(event)
+  });
+  sdk2 = Sentry;
+}
+function shouldCaptureError(err) {
+  if (err instanceof HTTPException) return err.status >= 500;
+  return true;
+}
+function createSentryRequestCapture() {
+  return async function sentryRequestCapture(c, next) {
+    try {
+      await next();
+    } catch (err) {
+      const client2 = sdk2;
+      if (client2 && shouldCaptureError(err)) {
+        client2.withScope((scope) => {
+          scope.setTag("route", c.req.routePath ?? c.req.path);
+          scope.setTag("method", c.req.method);
+          client2.captureException(err);
+        });
+      }
+      throw err;
+    }
+  };
+}
+
 // server/routes/annotations.ts
 var ENVELOPE_KIND = "annotations.registered";
 function registerAnnotationsRoute(app, deps) {
@@ -22924,10 +23385,10 @@ function registerAnnotationsRoute(app, deps) {
 }
 
 // server/routes/contributions.ts
-import { HTTPException as HTTPException2 } from "hono/http-exception";
+import { HTTPException as HTTPException3 } from "hono/http-exception";
 
 // server/util/parse-query.ts
-import { HTTPException } from "hono/http-exception";
+import { HTTPException as HTTPException2 } from "hono/http-exception";
 function parseCsv(value) {
   if (value === void 0) return [];
   return value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
@@ -22936,7 +23397,7 @@ function parsePagination(query, defaults) {
   const offset = parseNonNegativeInt(query.offset, "offset", 0);
   const limit = parseNonNegativeInt(query.limit, "limit", defaults.limit);
   if (limit > defaults.max) {
-    throw new HTTPException(400, {
+    throw new HTTPException2(400, {
       message: tx(SERVER_TEXTS.paginationLimitTooLarge, {
         value: limit,
         max: defaults.max
@@ -22950,7 +23411,7 @@ function parseBooleanFlag(value) {
 }
 function parseRequiredString(value, name) {
   if (typeof value !== "string" || value.length === 0) {
-    throw new HTTPException(400, {
+    throw new HTTPException2(400, {
       message: tx(SERVER_TEXTS.queryRequiredString, { name })
     });
   }
@@ -22961,7 +23422,7 @@ function parseNonNegativeInt(raw, name, fallback) {
   const trimmed = raw.trim();
   const parsed = Number.parseInt(trimmed, 10);
   if (!Number.isInteger(parsed) || parsed < 0 || String(parsed) !== trimmed) {
-    throw new HTTPException(400, {
+    throw new HTTPException2(400, {
       message: tx(SERVER_TEXTS.paginationInvalidInteger, { name, value: raw })
     });
   }
@@ -22972,7 +23433,7 @@ function parseNonNegativeInt(raw, name, fallback) {
 var QUALIFIED_ID_SEGMENT = /^[A-Za-z0-9._-]+$/;
 function parseQualifiedIdSegment(value, name) {
   if (!QUALIFIED_ID_SEGMENT.test(value)) {
-    throw new HTTPException2(400, {
+    throw new HTTPException3(400, {
       message: tx(SERVER_TEXTS.qualifiedIdMalformed, {
         name,
         value: sanitizeForTerminal(value)
@@ -23002,7 +23463,7 @@ function registerContributionsRoutes(app, deps) {
       (e) => e.pluginId === pluginId && e.extensionId === extensionId && e.contributionId === contributionId
     );
     if (!catalogEntry) {
-      throw new HTTPException2(404, {
+      throw new HTTPException3(404, {
         message: tx(SERVER_TEXTS.contributionUnknown, {
           pluginId: sanitizeForTerminal(pluginId),
           extensionId: sanitizeForTerminal(extensionId),
@@ -23033,7 +23494,7 @@ function registerContributionsRoutes(app, deps) {
 }
 
 // server/routes/config.ts
-import { HTTPException as HTTPException3 } from "hono/http-exception";
+import { HTTPException as HTTPException4 } from "hono/http-exception";
 
 // server/envelope.ts
 var REST_ENVELOPE_SCHEMA_VERSION = "1";
@@ -23072,7 +23533,7 @@ function registerConfigRoute(app, deps) {
     try {
       loaded = deps.configService.get();
     } catch (err) {
-      throw new HTTPException3(500, { message: formatErrorMessage(err) });
+      throw new HTTPException4(500, { message: formatErrorMessage(err) });
     }
     for (const warn of loaded.warnings) {
       log.warn(sanitizeForTerminal(warn));
@@ -23090,7 +23551,7 @@ function registerConfigRoute(app, deps) {
 }
 
 // server/routes/favorites.ts
-import { HTTPException as HTTPException4 } from "hono/http-exception";
+import { HTTPException as HTTPException5 } from "hono/http-exception";
 
 // server/path-codec.ts
 var PathCodecError = class extends Error {
@@ -23130,7 +23591,7 @@ function registerFavoritesRoutes(app, deps) {
       }
     );
     if (!result || !result.found) {
-      throw new HTTPException4(404, {
+      throw new HTTPException5(404, {
         message: tx(SERVER_TEXTS.nodeNotFound, { path: sanitizeForTerminal(nodePath) })
       });
     }
@@ -23150,14 +23611,14 @@ function decodePath(pathB64) {
     return decodeNodePath(pathB64);
   } catch (err) {
     if (err instanceof PathCodecError) {
-      throw new HTTPException4(404, { message: SERVER_TEXTS.pathB64Malformed });
+      throw new HTTPException5(404, { message: SERVER_TEXTS.pathB64Malformed });
     }
     throw err;
   }
 }
 
 // server/routes/graph.ts
-import { HTTPException as HTTPException5 } from "hono/http-exception";
+import { HTTPException as HTTPException6 } from "hono/http-exception";
 var DEFAULT_FORMAT2 = "ascii";
 var FORMAT_ID_PATTERN = /^[a-z0-9-]+$/;
 var FORMAT_ID_MAX = 32;
@@ -23165,7 +23626,7 @@ function registerGraphRoute(app, deps) {
   app.get("/api/graph", async (c) => {
     const format = c.req.query("format") ?? DEFAULT_FORMAT2;
     if (format.length > FORMAT_ID_MAX || !FORMAT_ID_PATTERN.test(format)) {
-      throw new HTTPException5(400, {
+      throw new HTTPException6(400, {
         // Sanitize defensively, the regex above already rejects ANSI
         // and control bytes, but the message interpolates user input
         // and the BFF mirrors error envelopes into the server log.
@@ -23181,7 +23642,7 @@ function registerGraphRoute(app, deps) {
     const formatter = formatters.find((f) => f.formatId === format);
     if (!formatter) {
       const available = formatters.map((f) => f.formatId).sort().join(", ");
-      throw new HTTPException5(400, {
+      throw new HTTPException6(400, {
         message: tx(SERVER_TEXTS.graphUnknownFormat, {
           format,
           available: available || "(none)"
@@ -23354,7 +23815,7 @@ function registerLinksRoute(app, deps) {
 }
 
 // server/routes/nodes.ts
-import { HTTPException as HTTPException6 } from "hono/http-exception";
+import { HTTPException as HTTPException7 } from "hono/http-exception";
 
 // server/node-body.ts
 import { constants as fsConstants2 } from "fs";
@@ -23465,7 +23926,7 @@ function registerNodesRoutes(app, deps) {
       nodePath = decodeNodePath(pathB64);
     } catch (err) {
       if (err instanceof PathCodecError) {
-        throw new HTTPException6(404, { message: SERVER_TEXTS.pathB64Malformed });
+        throw new HTTPException7(404, { message: SERVER_TEXTS.pathB64Malformed });
       }
       throw err;
     }
@@ -23497,7 +23958,7 @@ function registerNodesRoutes(app, deps) {
     const contributions = result?.contributions ?? [];
     const tags = result?.tags ?? [];
     if (!bundle) {
-      throw new HTTPException6(404, {
+      throw new HTTPException7(404, {
         message: tx(SERVER_TEXTS.nodeNotFound, { path: nodePath })
       });
     }
@@ -23607,11 +24068,11 @@ async function groupContributionsByPath(rows) {
 }
 
 // server/routes/plugins.ts
-import { HTTPException as HTTPException8 } from "hono/http-exception";
+import { HTTPException as HTTPException9 } from "hono/http-exception";
 
 // server/util/parse-body.ts
 import { Ajv2020 as Ajv20207 } from "ajv/dist/2020.js";
-import { HTTPException as HTTPException7 } from "hono/http-exception";
+import { HTTPException as HTTPException8 } from "hono/http-exception";
 function makeBodyValidator(schema, messages) {
   const ajv = new Ajv20207({ strict: false, allErrors: false });
   const validate = ajv.compile(schema);
@@ -23620,16 +24081,16 @@ function makeBodyValidator(schema, messages) {
     try {
       raw = await req.json();
     } catch {
-      throw new HTTPException7(400, { message: messages.notJson });
+      throw new HTTPException8(400, { message: messages.notJson });
     }
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-      throw new HTTPException7(400, { message: messages.notObject });
+      throw new HTTPException8(400, { message: messages.notObject });
     }
     if (validate(raw)) {
       return raw;
     }
     const message = resolveErrorMessage(validate.errors, messages);
-    throw new HTTPException7(400, { message });
+    throw new HTTPException8(400, { message });
   };
 }
 function resolveErrorMessage(errors, messages) {
@@ -23730,18 +24191,18 @@ function registerPluginsRoute(app, deps) {
   app.patch("/api/plugins/:id", async (c) => {
     const id = c.req.param("id");
     if (id.includes("/")) {
-      throw new HTTPException8(400, {
+      throw new HTTPException9(400, {
         message: tx(SERVER_TEXTS.pluginsCascadeRouteQualifiedRejected, { id })
       });
     }
     const handle = findHandle(id, deps);
     if (!handle) {
-      throw new HTTPException8(404, {
+      throw new HTTPException9(404, {
         message: tx(SERVER_TEXTS.pluginsUnknown, { id })
       });
     }
     if (isPluginLocked(id)) {
-      throw new HTTPException8(403, {
+      throw new HTTPException9(403, {
         message: tx(SERVER_TEXTS.pluginsLocked, { id })
       });
     }
@@ -23755,18 +24216,18 @@ function registerPluginsRoute(app, deps) {
     const extensionId = c.req.param("extensionId");
     const handle = findHandle(bundleId, deps);
     if (!handle) {
-      throw new HTTPException8(404, {
+      throw new HTTPException9(404, {
         message: tx(SERVER_TEXTS.pluginsUnknown, { id: bundleId })
       });
     }
     if (!hasExtension(handle, extensionId)) {
-      throw new HTTPException8(404, {
+      throw new HTTPException9(404, {
         message: tx(SERVER_TEXTS.pluginsExtensionUnknown, { bundleId, extensionId })
       });
     }
     const qualified = qualifiedExtensionId(bundleId, extensionId);
     if (isPluginLocked(qualified) || isPluginLocked(bundleId)) {
-      throw new HTTPException8(403, {
+      throw new HTTPException9(403, {
         message: tx(SERVER_TEXTS.pluginsExtensionLocked, { bundleId, extensionId })
       });
     }
@@ -24042,7 +24503,7 @@ function hasExtension(handle, extensionId) {
 }
 
 // server/routes/preferences.ts
-import { HTTPException as HTTPException9 } from "hono/http-exception";
+import { HTTPException as HTTPException10 } from "hono/http-exception";
 function registerPreferencesRoute(app, _deps) {
   app.get("/api/preferences", (c) => {
     return c.json(buildEnvelope());
@@ -24055,20 +24516,43 @@ function registerPreferencesRoute(app, _deps) {
 }
 function buildEnvelope() {
   return {
-    updateCheck: { enabled: isUpdateCheckEnabled() }
+    updateCheck: { enabled: isUpdateCheckEnabled() },
+    telemetry: {
+      errorsEnabled: isErrorTelemetryEnabled(),
+      usageCliEnabled: isUsageCliTelemetryEnabled(),
+      usageUiEnabled: isUsageUiTelemetryEnabled(),
+      anonymousId: readAnonymousId(),
+      environment: resolveTelemetryEnv()
+    }
   };
 }
 function applyPatch(body) {
-  if (body.updateCheck && typeof body.updateCheck.enabled === "boolean") {
-    try {
+  try {
+    if (body.updateCheck && typeof body.updateCheck.enabled === "boolean") {
       writeUserSettings({ updateCheck: { enabled: body.updateCheck.enabled } });
-    } catch (err) {
-      throw new HTTPException9(400, {
-        message: tx(SERVER_TEXTS.preferencesPersistFailed, {
-          message: formatErrorMessage(err)
-        })
-      });
     }
+    if (body.telemetry) {
+      applyTelemetryPatch(body.telemetry);
+    }
+  } catch (err) {
+    throw new HTTPException10(400, {
+      message: tx(SERVER_TEXTS.preferencesPersistFailed, {
+        message: formatErrorMessage(err)
+      })
+    });
+  }
+}
+function applyTelemetryPatch(t) {
+  if (typeof t.errorsEnabled === "boolean") {
+    writeUserSettings({ telemetry: { errorsEnabled: t.errorsEnabled } });
+  }
+  if (typeof t.usageCliEnabled === "boolean") {
+    writeUserSettings({ telemetry: { usageCliEnabled: t.usageCliEnabled } });
+    if (t.usageCliEnabled) ensureAnonymousId();
+  }
+  if (typeof t.usageUiEnabled === "boolean") {
+    writeUserSettings({ telemetry: { usageUiEnabled: t.usageUiEnabled } });
+    if (t.usageUiEnabled) ensureAnonymousId();
   }
 }
 var PATCH_BODY_SCHEMA = {
@@ -24082,6 +24566,15 @@ var PATCH_BODY_SCHEMA = {
       properties: {
         enabled: { type: "boolean" }
       }
+    },
+    telemetry: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        errorsEnabled: { type: "boolean" },
+        usageCliEnabled: { type: "boolean" },
+        usageUiEnabled: { type: "boolean" }
+      }
     }
   }
 };
@@ -24092,12 +24585,16 @@ var parsePatchBody2 = makeBodyValidator(PATCH_BODY_SCHEMA, {
   mapping: {
     ":minProperties": SERVER_TEXTS.preferencesBodyEmpty,
     "/updateCheck:type:object": SERVER_TEXTS.preferencesUpdateCheckNotObject,
-    "/updateCheck/enabled:type:boolean": SERVER_TEXTS.preferencesUpdateCheckEnabledNotBoolean
+    "/updateCheck/enabled:type:boolean": SERVER_TEXTS.preferencesUpdateCheckEnabledNotBoolean,
+    "/telemetry:type:object": SERVER_TEXTS.preferencesTelemetryNotObject,
+    "/telemetry/errorsEnabled:type:boolean": SERVER_TEXTS.preferencesTelemetryErrorsEnabledNotBoolean,
+    "/telemetry/usageCliEnabled:type:boolean": SERVER_TEXTS.preferencesTelemetryUsageCliEnabledNotBoolean,
+    "/telemetry/usageUiEnabled:type:boolean": SERVER_TEXTS.preferencesTelemetryUsageUiEnabledNotBoolean
   }
 });
 
 // server/routes/project-ignore.ts
-import { HTTPException as HTTPException10 } from "hono/http-exception";
+import { HTTPException as HTTPException11 } from "hono/http-exception";
 
 // server/util/skillmapignore-io.ts
 import { existsSync as existsSync26, readFileSync as readFileSync17, writeFileSync as writeFileSync2 } from "fs";
@@ -24184,12 +24681,12 @@ async function applyPatch2(deps, body) {
   for (const raw of body.patterns) {
     const t = raw.trim();
     if (t.length === 0) {
-      throw new HTTPException10(400, {
+      throw new HTTPException11(400, {
         message: SERVER_TEXTS.projectIgnorePatternEmpty
       });
     }
     if (seen.has(t)) {
-      throw new HTTPException10(400, {
+      throw new HTTPException11(400, {
         message: tx(SERVER_TEXTS.projectIgnorePatternDuplicate, { pattern: t })
       });
     }
@@ -24200,7 +24697,7 @@ async function applyPatch2(deps, body) {
   try {
     writePatterns(cwd, trimmed);
   } catch (err) {
-    throw new HTTPException10(400, {
+    throw new HTTPException11(400, {
       message: tx(SERVER_TEXTS.projectIgnorePersistFailed, {
         message: formatErrorMessage(err)
       })
@@ -24278,7 +24775,7 @@ var parsePatchBody3 = makeBodyValidator(PATCH_BODY_SCHEMA2, {
 
 // server/routes/project-preferences.ts
 import { statSync as statSync9 } from "fs";
-import { HTTPException as HTTPException11 } from "hono/http-exception";
+import { HTTPException as HTTPException12 } from "hono/http-exception";
 function registerProjectPreferencesRoute(app, deps) {
   app.get("/api/project-preferences", (c) => {
     return c.json(buildEnvelope3(deps));
@@ -24306,7 +24803,7 @@ async function applyPatch3(deps, body) {
   const cwd = deps.runtimeContext.cwd;
   const missingPaths = collectMissingPaths(writes, cwd);
   if (missingPaths.length > 0) {
-    throw new HTTPException11(400, {
+    throw new HTTPException12(400, {
       message: tx(SERVER_TEXTS.projectPrefsPathNotFound, {
         paths: missingPaths.join(", ")
       })
@@ -24315,7 +24812,7 @@ async function applyPatch3(deps, body) {
   const exposures = writes.map((w) => projectPathExposure({ key: w.key, value: w.value, cwd })).filter((e) => e.expandsSurface);
   if (exposures.length > 0 && body.confirm !== true) {
     const exposed = exposures.flatMap((e) => e.exposedPaths);
-    throw new HTTPException11(412, {
+    throw new HTTPException12(412, {
       message: tx(SERVER_TEXTS.projectPrefsConfirmRequired, {
         paths: exposed.join(", ")
       })
@@ -24367,7 +24864,7 @@ function runWrite(w, cwd) {
   try {
     writeConfigValue(w.key, w.value, { target: "project-local", cwd });
   } catch (err) {
-    throw new HTTPException11(400, {
+    throw new HTTPException12(400, {
       message: tx(SERVER_TEXTS.projectPrefsPersistFailed, {
         key: w.key,
         message: formatErrorMessage(err)
@@ -24467,7 +24964,7 @@ var parsePatchBody4 = makeBodyValidator(PATCH_BODY_SCHEMA3, {
 
 // server/routes/active-provider.ts
 import { existsSync as existsSync27 } from "fs";
-import { HTTPException as HTTPException12 } from "hono/http-exception";
+import { HTTPException as HTTPException13 } from "hono/http-exception";
 function registerActiveProviderRoute(app, deps) {
   app.get("/api/active-provider", (c) => {
     return c.json(buildEnvelope4(deps));
@@ -24492,7 +24989,7 @@ function applyLensSwitch(deps, newValue) {
   try {
     writeConfigValue("activeProvider", newValue, { target: "project", cwd });
   } catch (err) {
-    throw new HTTPException12(400, {
+    throw new HTTPException13(400, {
       message: tx(SERVER_TEXTS.activeProviderPersistFailed, {
         message: formatErrorMessage(err)
       })
@@ -24528,7 +25025,7 @@ var parsePatchBody5 = makeBodyValidator(PATCH_BODY_SCHEMA4, {
 });
 
 // server/routes/scan.ts
-import { HTTPException as HTTPException13 } from "hono/http-exception";
+import { HTTPException as HTTPException14 } from "hono/http-exception";
 
 // server/scan-mutex.ts
 var inFlight = null;
@@ -24694,7 +25191,7 @@ function registerScanRoute(app, deps) {
 }
 async function runPersistedScan(c, deps) {
   if (deps.options.noBuiltIns || deps.options.noPlugins) {
-    throw new HTTPException13(400, { message: SERVER_TEXTS.scanPostRequiresFullPipeline });
+    throw new HTTPException14(400, { message: SERVER_TEXTS.scanPostRequiresFullPipeline });
   }
   const dbExists = await tryWithSqlite(
     { databasePath: deps.options.dbPath, autoBackup: false },
@@ -24731,7 +25228,7 @@ async function runPersistedScan(c, deps) {
         ...deps.options.maxNodes !== void 0 ? { maxNodes: deps.options.maxNodes } : {}
       });
       if (outcome.kind !== "ok") {
-        throw new HTTPException13(500, {
+        throw new HTTPException14(500, {
           message: outcome.kind === "guard-trip" ? tx(SERVER_TEXTS.scanGuardTrip, { existing: outcome.existing }) : outcome.message
         });
       }
@@ -24739,7 +25236,7 @@ async function runPersistedScan(c, deps) {
     });
   } catch (err) {
     if (err instanceof ScanBusyError) {
-      throw new HTTPException13(409, { message: SERVER_TEXTS.scanPostBusy });
+      throw new HTTPException14(409, { message: SERVER_TEXTS.scanPostBusy });
     }
     throw err;
   }
@@ -24800,7 +25297,7 @@ function groupTagsByPath2(rows) {
 }
 async function runFreshScan(deps) {
   if (deps.options.noBuiltIns || deps.options.noPlugins) {
-    throw new HTTPException13(400, { message: SERVER_TEXTS.freshScanRequiresPipeline });
+    throw new HTTPException14(400, { message: SERVER_TEXTS.freshScanRequiresPipeline });
   }
   const resolveEnabledOverride = await buildBffResolverOverride(deps);
   const outcome = await runScanForCommand({
@@ -24835,7 +25332,7 @@ async function runFreshScan(deps) {
     ...deps.options.maxNodes !== void 0 ? { maxNodes: deps.options.maxNodes } : {}
   });
   if (outcome.kind !== "ok") {
-    throw new HTTPException13(500, {
+    throw new HTTPException14(500, {
       message: outcome.kind === "guard-trip" ? tx(SERVER_TEXTS.freshScanGuardTrip, { existing: outcome.existing }) : outcome.message
     });
   }
@@ -24875,7 +25372,7 @@ function emptyScanResult() {
 }
 
 // server/routes/sidecar.ts
-import { HTTPException as HTTPException14 } from "hono/http-exception";
+import { HTTPException as HTTPException15 } from "hono/http-exception";
 import { resolve as resolve36 } from "path";
 var STATUS_FRESH = "fresh";
 var ENVELOPE_KIND2 = "sidecar.bumped";
@@ -24912,11 +25409,11 @@ function registerSidecarRoutes(app, deps) {
       assertContained(deps.runtimeContext.cwd, node.path);
       absPath = resolve36(deps.runtimeContext.cwd, node.path);
     } catch (err) {
-      throw new HTTPException14(400, { message: formatErrorMessage(err) });
+      throw new HTTPException15(400, { message: formatErrorMessage(err) });
     }
     const result = invokeBump2(node, absPath, body);
     if (result.report.ok === false && result.report.reason === "fresh") {
-      throw new HTTPException14(409, { message: SERVER_TEXTS.sidecarFreshRefusal });
+      throw new HTTPException15(409, { message: SERVER_TEXTS.sidecarFreshRefusal });
     }
     if (result.report.ok === true && result.report.noop === true) {
       const envelope2 = {
@@ -24943,7 +25440,7 @@ function registerSidecarRoutes(app, deps) {
       }
     } catch (err) {
       if (err instanceof EConsentRequiredError) throw err;
-      throw new HTTPException14(500, { message: formatErrorMessage(err) });
+      throw new HTTPException15(500, { message: formatErrorMessage(err) });
     }
     if (body.confirm === true) {
       deps.configService.reload();
@@ -24980,7 +25477,7 @@ async function loadNode(deps, nodePath) {
   );
   const node = persisted?.nodes.find((n) => n.path === nodePath);
   if (!node) {
-    throw new HTTPException14(404, {
+    throw new HTTPException15(404, {
       message: tx(SERVER_TEXTS.nodeNotFound, { path: sanitizeForTerminal(nodePath) })
     });
   }
@@ -24988,7 +25485,7 @@ async function loadNode(deps, nodePath) {
 }
 function invokeBump2(node, absPath, body) {
   if (!nodeBumpAction.invoke) {
-    throw new HTTPException14(500, { message: SERVER_TEXTS.sidecarBumpInvokeMissing });
+    throw new HTTPException15(500, { message: SERVER_TEXTS.sidecarBumpInvokeMissing });
   }
   const input = {};
   if (body.force === true) input.force = true;
@@ -25175,13 +25672,13 @@ function attachBroadcasterRoute(app, broadcaster) {
 
 // server/app.ts
 var BODY_LIMIT_BYTES = 1024 * 1024;
-var DbMissingError = class extends HTTPException15 {
+var DbMissingError = class extends HTTPException16 {
   constructor(message) {
     super(500, { message });
     this.name = "DbMissingError";
   }
 };
-var BulkValidationError = class extends HTTPException15 {
+var BulkValidationError = class extends HTTPException16 {
   id;
   code;
   constructor(init) {
@@ -25191,7 +25688,7 @@ var BulkValidationError = class extends HTTPException15 {
     this.code = init.code;
   }
 };
-var LoopbackGateError = class extends HTTPException15 {
+var LoopbackGateError = class extends HTTPException16 {
   code;
   constructor(init) {
     super(403, { message: init.message });
@@ -25204,6 +25701,7 @@ function createApp(deps) {
   const configService = new ConfigService({
     cwd: deps.runtimeContext.cwd
   });
+  app.use("*", createSentryRequestCapture());
   app.use("*", createLoopbackGate({ port: deps.options.port }));
   app.use("*", createSecurityHeaders());
   app.use(
@@ -25211,7 +25709,7 @@ function createApp(deps) {
     bodyLimit({
       maxSize: BODY_LIMIT_BYTES,
       onError: () => {
-        throw new HTTPException15(413, { message: tx(SERVER_TEXTS.bodyTooLarge, { maxBytes: String(BODY_LIMIT_BYTES) }) });
+        throw new HTTPException16(413, { message: tx(SERVER_TEXTS.bodyTooLarge, { maxBytes: String(BODY_LIMIT_BYTES) }) });
       }
     })
   );
@@ -25257,7 +25755,7 @@ function createApp(deps) {
   registerActiveProviderRoute(app, routeDeps);
   registerProjectIgnoreRoute(app, routeDeps);
   app.all("/api/*", (c) => {
-    throw new HTTPException15(404, {
+    throw new HTTPException16(404, {
       message: tx(SERVER_TEXTS.unknownApiEndpoint, { path: sanitizeForTerminal(c.req.path) })
     });
   });
@@ -25265,7 +25763,7 @@ function createApp(deps) {
   app.use("*", createStaticHandler({ uiDist: deps.options.uiDist, noUi: deps.options.noUi }));
   app.get("*", createSpaFallback({ uiDist: deps.options.uiDist, noUi: deps.options.noUi }));
   app.notFound((c) => {
-    throw new HTTPException15(404, {
+    throw new HTTPException16(404, {
       message: tx(SERVER_TEXTS.unknownPath, { path: sanitizeForTerminal(c.req.path) })
     });
   });
@@ -25320,7 +25818,7 @@ function formatError2(err, c) {
     };
     return c.json(envelope, 403);
   }
-  if (err instanceof HTTPException15) {
+  if (err instanceof HTTPException16) {
     const status = err.status;
     const envelope = {
       ok: false,
@@ -25419,7 +25917,7 @@ var WsBroadcaster = class {
    * stop the rest from receiving the event. A failing socket is closed
    * + unregistered so the next broadcast doesn't waste cycles on it.
    *
-   * Backpressure check (per AGENTS.md §Watcher integration): if a
+   * Backpressure check (per context/kernel.md §Kernel boundaries): if a
    * client's `bufferedAmount` exceeds `MAX_BUFFERED_BYTES`, it's evicted
    * with close code 1009. The check runs BEFORE `send` so the threshold
    * acts as an admission gate, not a post-mortem.
@@ -25439,8 +25937,8 @@ var WsBroadcaster = class {
       return;
     }
     const snapshot = Array.from(this.#clients);
-    for (const client of snapshot) {
-      this.#deliver(client, payload);
+    for (const client2 of snapshot) {
+      this.#deliver(client2, payload);
     }
   }
   /**
@@ -25454,9 +25952,9 @@ var WsBroadcaster = class {
     this.#shutDown = true;
     const snapshot = Array.from(this.#clients);
     this.#clients.clear();
-    for (const client of snapshot) {
+    for (const client2 of snapshot) {
       try {
-        client.close(CLOSE_CODE_GOING_AWAY, "server shutdown");
+        client2.close(CLOSE_CODE_GOING_AWAY, "server shutdown");
       } catch {
       }
     }
@@ -25465,31 +25963,31 @@ var WsBroadcaster = class {
    * Per-client delivery: backpressure check, then `send()`. Eviction +
    * unregistration on either failure mode.
    */
-  #deliver(client, payload) {
-    if (client.readyState !== READY_STATE_OPEN) {
-      this.#clients.delete(client);
+  #deliver(client2, payload) {
+    if (client2.readyState !== READY_STATE_OPEN) {
+      this.#clients.delete(client2);
       return;
     }
-    if (client.bufferedAmount > MAX_BUFFERED_BYTES) {
-      this.#clients.delete(client);
+    if (client2.bufferedAmount > MAX_BUFFERED_BYTES) {
+      this.#clients.delete(client2);
       try {
-        client.close(CLOSE_CODE_MESSAGE_TOO_BIG, "backpressure exceeded");
+        client2.close(CLOSE_CODE_MESSAGE_TOO_BIG, "backpressure exceeded");
       } catch {
       }
       log.warn(
         tx(SERVER_TEXTS.wsBackpressureEvicted, {
-          buffered: String(client.bufferedAmount),
+          buffered: String(client2.bufferedAmount),
           threshold: String(MAX_BUFFERED_BYTES)
         })
       );
       return;
     }
     try {
-      client.send(payload);
+      client2.send(payload);
     } catch (err) {
-      this.#clients.delete(client);
+      this.#clients.delete(client2);
       try {
-        client.close();
+        client2.close();
       } catch {
       }
       const message = formatErrorMessage(err);
@@ -26250,7 +26748,7 @@ var ServeCommand = class extends SmCommand {
   emitElapsed = false;
   // CLI orchestrator with multi-flag handling, each `if (this.flag)`
   // branch is one cyclomatic point. Splitting per branch scatters the
-  // validation away from the flag it gates. Per AGENTS.md §Linting
+  // validation away from the flag it gates. Per context/lint.md
   // category 1 ("CLI orchestrators with multi-flag handling").
   // eslint-disable-next-line complexity
   async run() {
@@ -26353,6 +26851,7 @@ var ServeCommand = class extends SmCommand {
       this.printer.info(formatValidationError(validation.error, stderrAnsi));
       return ExitCode.Error;
     }
+    await initSentryBff(VERSION);
     let handle;
     try {
       handle = await createServer(validation.options);
@@ -27822,6 +28321,7 @@ cli.register(RootHelpCommand);
 cli.register(HelpCommand);
 cli.register(InitCommand);
 cli.register(TutorialCommand);
+cli.register(IntentionalFailCommand);
 cli.register(ScanCommand);
 cli.register(ScanCompareCommand);
 cli.register(ServeCommand);
@@ -27855,6 +28355,13 @@ var logLevel = resolveLogLevel({
 configureLogger(new Logger({ level: logLevel, stream: process.stderr }));
 var bareArgs = resolveBareInvocation(args);
 var routedArgs = routeHelpArgs(bareArgs ?? args, cli);
+var telemetryVerb = routedArgs[0];
+await maybeRunFirstRunPrompt();
+if (telemetryVerb !== "serve") {
+  await initSentryCli(VERSION);
+  setTelemetryVerbTag(telemetryVerb);
+  await initUsageCli();
+}
 var lifecycleDispatcher = makeHookDispatcher(
   builtIns().hooks ?? [],
   new InMemoryProgressEmitter()
@@ -27891,10 +28398,18 @@ var exitCode = await cli.run(routedArgs, {
   stdout: process.stdout,
   stderr: process.stderr
 });
+if (telemetryVerb !== void 0 && telemetryVerb !== "") {
+  const knownVerbs = new Set(
+    registeredVerbPaths(cli).map((path) => path[0]).filter((token) => token !== void 0)
+  );
+  captureCliInvocation(telemetryVerb, extractFlagNames(routedArgs.slice(1)), knownVerbs);
+}
 await lifecycleDispatcher.dispatch(
   "shutdown",
   makeEvent("shutdown", { exitCode })
 );
+await closeSentryCli();
+await flushUsageCli();
 process.exit(exitCode);
 function resolveBareInvocation(rawArgs) {
   if (rawArgs.length === 0) return resolveBareDefault();