@skill-map/cli 0.62.2 → 0.64.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 // 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]="454166ed-eb8e-57bb-b412-c9c6e9ff30f4")}catch(e){}}();
-import { existsSync as existsSync33 } from "fs";
+!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]="43bb2367-1e14-5df2-9221-a5e7a877a666")}catch(e){}}();
+import { existsSync as existsSync34 } from "fs";
 import { Builtins, Cli as Cli2 } from "clipanion";
 
 // kernel/adapters/in-memory-progress.ts
@@ -250,7 +250,7 @@ function bucketByKind(kind, instance, bag) {
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.62.2",
+  version: "0.64.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -1068,6 +1068,108 @@ function buildTooltip(names) {
   return `${joined.slice(0, TOOLTIP_MAX - 1)}\u2026`;
 }
 
+// plugins/agent-skills/providers/agent-skills/schemas/skill.schema.json
+var skill_schema_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://skill-map.ai/providers/agent-skills/v1/frontmatter/skill.schema.json",
+  title: "FrontmatterAgentSkillsSkill",
+  description: "Frontmatter shape for nodes classified as `skill` by the neutral `agent-skills` Provider, Agent Skills delivered as `SKILL.md` files at the open-standard path `.agents/skills/<name>/SKILL.md`. Jointly adopted by Anthropic, OpenAI (Codex), and Google (Gemini); the path is vendor-neutral so no single Provider should own it. Required fields are `name` and `description` (from spec base). The standard's optional frontmatter fields are declared below, mirrored verbatim from https://agentskills.io/specification: `license`, `compatibility`, `metadata`, and the experimental `allowed-tools`. `additionalProperties: true` so any future standard field flows through unchanged until this schema catches up.",
+  allOf: [
+    { $ref: "https://skill-map.ai/spec/v0/frontmatter/base.schema.json" }
+  ],
+  type: "object",
+  additionalProperties: true,
+  properties: {
+    license: {
+      type: "string",
+      description: "License applied to the skill: a license name (e.g. `Apache-2.0`) or a reference to a bundled license file. Source: https://agentskills.io/specification."
+    },
+    compatibility: {
+      type: "string",
+      maxLength: 500,
+      description: "Environment requirements (intended product, required system packages, network access, etc.). Most skills omit it. Max 500 characters. Source: https://agentskills.io/specification."
+    },
+    metadata: {
+      type: "object",
+      additionalProperties: { type: "string" },
+      description: "Arbitrary string-keyed, string-valued map for client-defined metadata not covered by the standard. Source: https://agentskills.io/specification."
+    },
+    "allowed-tools": {
+      type: "string",
+      description: "Space-separated list of pre-approved tools the skill may run (e.g. `Bash(git:*) Read`). Experimental in the open standard; support varies between agent implementations. Source: https://agentskills.io/specification."
+    }
+  }
+};
+
+// plugins/agent-skills/providers/agent-skills/index.ts
+var OPEN_SKILLS_READ = {
+  extensions: [".md"],
+  parser: "frontmatter-yaml"
+};
+var OPEN_SKILLS_KINDS = {
+  skill: {
+    schema: "./schemas/skill.schema.json",
+    schemaJson: skill_schema_default2,
+    ui: {
+      label: "Skills",
+      color: "#10b981",
+      colorDark: "#34d399",
+      icon: { kind: "pi", id: "pi-bolt" }
+    },
+    // Open-standard skills mirror Anthropic's: dirname between
+    // `.agents/skills/` and `/SKILL.md` is the canonical handle,
+    // `frontmatter.name` overrides when present.
+    identifiers: ["frontmatter.name", "dirname"]
+  }
+};
+var OPEN_SKILLS_RESOLUTION = { invokes: ["skill"] };
+function classifyOpenSkillsPath(path) {
+  if (/^\.agents\/skills\/[^/]+\/skill\.md$/.test(path.toLowerCase())) return "skill";
+  return null;
+}
+var agentSkillsProvider = {
+  id: "agent-skills",
+  pluginId: AGENT_SKILLS_PLUGIN_ID,
+  kind: "provider",
+  description: "Classifies files under `.agents/skills/<name>/SKILL.md` as Agent Skills.",
+  // Provider identity for the active-lens dropdown, the topbar lens chip,
+  // and the per-node provider chip. Neutral slate (this is the
+  // vendor-agnostic open-standard Provider, not a brand). Verbatim from
+  // the previous static UI catalog (`ui/src/services/provider-ui.ts`).
+  presentation: {
+    label: "Open Skills",
+    color: "#64748b",
+    colorDark: "#94a3b8"
+  },
+  // Gated like the vendor providers: `.agents/skills/*` is classified as
+  // `skill` ONLY under the `agent-skills` lens; under any other lens
+  // (including `markdown`) it falls through to `core/markdown`, the sole
+  // universal provider. Keeps the "one active lens" model honest.
+  gatedByActiveLens: true,
+  // Not yet ready for end users: ships disabled by default. The operator
+  // opts in via `sm plugins enable` / the Settings toggle / the tutorial's
+  // `--experimental` flow, so it neither classifies nor auto-detects until
+  // enabled.
+  stability: "experimental",
+  // Auto-detect marker: a `.agents/` directory marks an open-standard
+  // project. This is also the marker a Google/Antigravity project carries
+  // (Antigravity adopted the open standard). The marker only produces an
+  // auto-detect candidate once this experimental provider is enabled.
+  // Provider-owned.
+  detect: { markers: [".agents"] },
+  // Authoring target for `sm tutorial`: the open standard discovers skills
+  // under `.agents/skills/<name>/SKILL.md`. The same path is consumed by
+  // Antigravity (adopted the standard rather than a `.gemini/` layout) and
+  // OpenAI Codex (skills mirror the open standard), so `aka` surfaces both
+  // names in the destination prompt to orient testers on those agents.
+  // `aka` is display-only, `--for` still matches the `agent-skills` id.
+  scaffold: { skillDir: ".agents/skills", aka: ["Antigravity", "OpenAI Codex"] },
+  read: OPEN_SKILLS_READ,
+  kinds: OPEN_SKILLS_KINDS,
+  resolution: OPEN_SKILLS_RESOLUTION,
+  classify: classifyOpenSkillsPath
+};
+
 // plugins/antigravity/providers/antigravity/index.ts
 var antigravityProvider = {
   id: "antigravity",
@@ -1080,10 +1182,7 @@ var antigravityProvider = {
   presentation: {
     label: "Antigravity",
     color: "#7c3aed",
-    colorDark: "#a78bfa",
-    // Registered but not yet selectable as the active lens; the UI greys
-    // it with a `(coming soon)` suffix.
-    comingSoon: true
+    colorDark: "#a78bfa"
   },
   // No `detect` block: Antigravity has no vendor-specific workspace marker
   // (it adopted the open-standard `.agents/`, owned by `agent-skills`), so
@@ -1095,17 +1194,23 @@ var antigravityProvider = {
   // declaration anticipates the migration moment so we don't have to
   // remember to flip it then.
   gatedByActiveLens: true,
-  // No `read` config: this Provider does not walk the filesystem. The
-  // kernel walker only fires for Providers with `read` or `walk`; an
-  // empty Provider participates in registration (its `ui` block is
-  // available, its `reservedNames` catalog is loaded) without owning
-  // any on-disk territory.
-  kinds: {},
-  // Always disclaim: paths are owned by other Providers (`.agents/` ->
-  // `agent-skills`, `AGENTS.md` -> `core/markdown` fallback).
-  classify() {
-    return null;
-  },
+  // Not yet ready for end users: ships disabled by default (the operator
+  // opts in via `sm plugins enable` / Settings / the tutorial's
+  // `--experimental` flow). Replaces the retired `comingSoon` flag.
+  stability: "experimental",
+  // Adopt the open-standard `.agents/skills/` layout by REUSING the
+  // `agent-skills` classifier + kind + read config (composition at the
+  // manifest level, not a kernel rule). Under the antigravity lens the
+  // walker classifies `.agents/skills/<name>/SKILL.md` as
+  // `{ provider: 'antigravity', kind: 'skill' }`, so the reservedNames
+  // below apply via SELF scope. `agent-skills` itself is gated to its own
+  // lens, so it never competes here (under the antigravity lens it does
+  // not participate). This is why there is no cross-provider lens-scope
+  // rule in the kernel any more.
+  read: OPEN_SKILLS_READ,
+  kinds: OPEN_SKILLS_KINDS,
+  resolution: OPEN_SKILLS_RESOLUTION,
+  classify: classifyOpenSkillsPath,
   // 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
@@ -1123,12 +1228,10 @@ var antigravityProvider = {
   //
   // 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.
+  // (`.agents/skills/<name>/SKILL.md`). Because the antigravity lens now
+  // classifies those files itself (inherited classifier above), a user
+  // `.agents/skills/goal/SKILL.md` is flagged by SELF scope because `/goal`
+  // is built-in.
   //
   // **Reconciliation marker**: re-capture from `agy /help` on each major
   // Antigravity CLI release and bump the cited version above.
@@ -1245,10 +1348,7 @@ var openaiProvider = {
   presentation: {
     label: "OpenAI Codex",
     color: "#22c55e",
-    colorDark: "#4ade80",
-    // Registered but not yet selectable as the active lens; auto-detect
-    // skips its markers and the UI greys it with a `(coming soon)` suffix.
-    comingSoon: true
+    colorDark: "#4ade80"
   },
   // Auto-detect markers: a `.codex/` directory or a root `AGENTS.md` marks
   // a Codex CLI project. Provider-owned (replaces the old central
@@ -1259,6 +1359,10 @@ var openaiProvider = {
   // claiming Codex agents under a `claude` (or any other) lens, where
   // the Codex runtime would never resolve them anyway.
   gatedByActiveLens: true,
+  // Not yet ready for end users: ships disabled by default (the operator
+  // opts in via `sm plugins enable` / Settings / the tutorial's
+  // `--experimental` flow). Replaces the retired `comingSoon` flag.
+  stability: "experimental",
   read: { extensions: [".toml"], parser: "toml" },
   kinds: {
     agent: {
@@ -1291,98 +1395,6 @@ var openaiProvider = {
   }
 };
 
-// plugins/agent-skills/providers/agent-skills/schemas/skill.schema.json
-var skill_schema_default2 = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: "https://skill-map.ai/providers/agent-skills/v1/frontmatter/skill.schema.json",
-  title: "FrontmatterAgentSkillsSkill",
-  description: "Frontmatter shape for nodes classified as `skill` by the neutral `agent-skills` Provider, Agent Skills delivered as `SKILL.md` files at the open-standard path `.agents/skills/<name>/SKILL.md`. Jointly adopted by Anthropic, OpenAI (Codex), and Google (Gemini); the path is vendor-neutral so no single Provider should own it. Required fields are `name` and `description` (from spec base). The standard's optional frontmatter fields are declared below, mirrored verbatim from https://agentskills.io/specification: `license`, `compatibility`, `metadata`, and the experimental `allowed-tools`. `additionalProperties: true` so any future standard field flows through unchanged until this schema catches up.",
-  allOf: [
-    { $ref: "https://skill-map.ai/spec/v0/frontmatter/base.schema.json" }
-  ],
-  type: "object",
-  additionalProperties: true,
-  properties: {
-    license: {
-      type: "string",
-      description: "License applied to the skill: a license name (e.g. `Apache-2.0`) or a reference to a bundled license file. Source: https://agentskills.io/specification."
-    },
-    compatibility: {
-      type: "string",
-      maxLength: 500,
-      description: "Environment requirements (intended product, required system packages, network access, etc.). Most skills omit it. Max 500 characters. Source: https://agentskills.io/specification."
-    },
-    metadata: {
-      type: "object",
-      additionalProperties: { type: "string" },
-      description: "Arbitrary string-keyed, string-valued map for client-defined metadata not covered by the standard. Source: https://agentskills.io/specification."
-    },
-    "allowed-tools": {
-      type: "string",
-      description: "Space-separated list of pre-approved tools the skill may run (e.g. `Bash(git:*) Read`). Experimental in the open standard; support varies between agent implementations. Source: https://agentskills.io/specification."
-    }
-  }
-};
-
-// plugins/agent-skills/providers/agent-skills/index.ts
-var agentSkillsProvider = {
-  id: "agent-skills",
-  pluginId: AGENT_SKILLS_PLUGIN_ID,
-  kind: "provider",
-  description: "Classifies files under `.agents/skills/<name>/SKILL.md` as Agent Skills.",
-  // Provider identity for the active-lens dropdown, the topbar lens chip,
-  // and the per-node provider chip. Neutral slate (this is the
-  // vendor-agnostic open-standard Provider, not a brand). Verbatim from
-  // the previous static UI catalog (`ui/src/services/provider-ui.ts`).
-  presentation: {
-    label: "Open Skills",
-    color: "#64748b",
-    colorDark: "#94a3b8",
-    // Registered but not yet selectable as the active lens; auto-detect
-    // skips its `.agents/` marker and the UI greys it with a
-    // `(coming soon)` suffix.
-    comingSoon: true
-  },
-  // Auto-detect marker: a `.agents/` directory marks an open-standard
-  // project. This is also the marker a Google/Antigravity project carries
-  // (Antigravity adopted the open standard), so such projects auto-detect
-  // as this universal lens. Provider-owned.
-  detect: { markers: [".agents"] },
-  // Authoring target for `sm tutorial`: the open standard discovers skills
-  // under `.agents/skills/<name>/SKILL.md`. The same path is consumed by
-  // Antigravity (adopted the standard rather than a `.gemini/` layout) and
-  // OpenAI Codex (skills mirror the open standard), so `aka` surfaces both
-  // names in the destination prompt to orient testers on those agents.
-  // `aka` is display-only, `--for` still matches the `agent-skills` id.
-  scaffold: { skillDir: ".agents/skills", aka: ["Antigravity", "OpenAI Codex"] },
-  read: { extensions: [".md"], parser: "frontmatter-yaml" },
-  kinds: {
-    skill: {
-      schema: "./schemas/skill.schema.json",
-      schemaJson: skill_schema_default2,
-      ui: {
-        label: "Skills",
-        color: "#10b981",
-        colorDark: "#34d399",
-        icon: { kind: "pi", id: "pi-bolt" }
-      },
-      // Open-standard skills mirror Anthropic's: dirname between
-      // `.agents/skills/` and `/SKILL.md` is the canonical handle,
-      // `frontmatter.name` overrides when present.
-      identifiers: ["frontmatter.name", "dirname"]
-    }
-  },
-  // The open standard documents slash-style invocation of skills; no
-  // mention surface (no agents in this Provider's territory).
-  resolution: {
-    invokes: ["skill"]
-  },
-  classify(path) {
-    if (/^\.agents\/skills\/[^/]+\/skill\.md$/.test(path.toLowerCase())) return "skill";
-    return null;
-  }
-};
-
 // plugins/core/providers/core-markdown/schemas/markdown.schema.json
 var markdown_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -4548,6 +4560,25 @@ var ENTRY_TEXTS = {
    */
   bareNoProject: "{{glyph}}  No skill-map project found in {{cwd}}.\n   {{hint}}\n",
   bareNoProjectHint: "Run `sm init` to bootstrap one, or `sm --help` to see all commands.",
+  /**
+   * Hint variant for a bare `sm` in an EMPTY cwd when the interactive
+   * menu cannot run (non-TTY stdin) or the operator gave no valid pick.
+   * Points at the two getting-started verbs instead of `sm init` (a
+   * brand-new user in an empty folder wants to try the tool, not
+   * bootstrap an empty project).
+   */
+  bareEmptyHint: "Run `sm tutorial` for a guided walkthrough, or `sm example` to drop a project to explore.",
+  /**
+   * Getting-started menu shown on bare `sm` in an empty folder on an
+   * interactive terminal. Header uses a yellow `?` glyph; two numbered
+   * options dispatch to `sm tutorial` / `sm example`; the input line
+   * accepts a number, a verb name, or an empty answer (which takes the
+   * default, option 1, the tutorial).
+   */
+  emptyMenuHeader: "{{glyph}}  This folder is empty. How would you like to start?",
+  emptyMenuOptionTutorial: "     1) Run the guided tutorial          (sm tutorial)  (default)",
+  emptyMenuOptionExample: "     2) Copy an example project to try    (sm example)",
+  emptyMenuInput: "  Enter the number [default 1]: ",
   parseErrorHeadline: "sm: {{message}}",
   parseErrorUnknownOption: "unknown option '{{name}}'",
   parseErrorUnknownOptionForVerb: "{{verb}}: unknown option '{{name}}'",
@@ -4780,6 +4811,64 @@ function requireDbOrExit(path, stderr) {
   return ExitCode.NotFound;
 }
 
+// cli/util/empty-cwd.ts
+import { readdirSync } from "fs";
+function isDirEmpty(dir) {
+  return readdirSync(dir).length === 0;
+}
+function listCwdEntries(dir) {
+  const entries = readdirSync(dir).sort();
+  const shown = entries.slice(0, 5);
+  const more = entries.length > shown.length ? ", ..." : "";
+  return shown.join(", ") + more;
+}
+function displayCwd(cwd) {
+  const segments = cwd.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0) return "./";
+  return `./${segments[segments.length - 1]}/`;
+}
+
+// cli/util/empty-folder-prompt.ts
+import { createInterface } from "readline";
+async function decideBareNoArgs(state, prompt) {
+  if (state.hasDb) return { kind: "route", argv: ["serve"] };
+  if (state.isTty && state.isEmptyDir) {
+    const choice = await prompt();
+    if (choice !== null) return { kind: "route", argv: [choice] };
+  }
+  return { kind: "hint" };
+}
+function classifyEmptyFolderAnswer(trimmed) {
+  if (trimmed === "") return "tutorial";
+  if (trimmed === "1") return "tutorial";
+  if (trimmed === "2") return "example";
+  const lower = trimmed.toLowerCase();
+  if (lower === "tutorial") return "tutorial";
+  if (lower === "example") return "example";
+  return null;
+}
+async function promptEmptyFolderChoice(stdin, stderr, ansi) {
+  const menu = [
+    tx(ENTRY_TEXTS.emptyMenuHeader, { glyph: ansi.yellow("?") }),
+    ENTRY_TEXTS.emptyMenuOptionTutorial,
+    ENTRY_TEXTS.emptyMenuOptionExample
+  ].join("\n");
+  stderr.write(menu + "\n");
+  const rl = createInterface({ input: stdin, output: stderr });
+  try {
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+      const answer = await new Promise(
+        (resolveP) => rl.question(ENTRY_TEXTS.emptyMenuInput, resolveP)
+      );
+      const choice = classifyEmptyFolderAnswer(answer.trim());
+      if (choice !== null) return choice;
+    }
+    return null;
+  } finally {
+    rl.close();
+  }
+}
+
 // cli/util/edit-distance.ts
 function editDistance(a, b, max) {
   if (a === b) return 0;
@@ -4955,7 +5044,7 @@ function defaultRuntimeContext() {
 }
 
 // cli/telemetry/first-run-prompt.ts
-import { createInterface } from "readline/promises";
+import { createInterface as createInterface2 } from "readline/promises";
 
 // cli/i18n/telemetry.texts.ts
 var TELEMETRY_PROMPT_TEXTS = {
@@ -5258,7 +5347,7 @@ async function runConsentPrompt(stdin, stdout, nowMs) {
   const rendered = renderConsent(
     ansiFor({ isTTY: stdout.isTTY === true, noColorFlag: false })
   );
-  const rl = createInterface({ input: stdin, output: stdout });
+  const rl = createInterface2({ input: stdin, output: stdout });
   try {
     const consented = await readConsentDecision(rl, stdout, rendered);
     writeUserSettings({
@@ -5988,13 +6077,13 @@ var CONSENT_TEXTS = {
 };
 
 // cli/util/confirm.ts
-import { createInterface as createInterface2 } from "readline";
+import { createInterface as createInterface3 } 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 = createInterface2({ input: streams.stdin, output: streams.stderr });
+  const rl = createInterface3({ input: streams.stdin, output: streams.stderr });
   try {
     const answer = await new Promise(
       (resolveP) => rl.question(`${question}${suffix}`, resolveP)
@@ -6348,7 +6437,7 @@ var AsyncMutex = class {
       this.#locked = true;
       return;
     }
-    await new Promise((resolve43) => this.#waiters.push(resolve43));
+    await new Promise((resolve44) => this.#waiters.push(resolve44));
     this.#locked = true;
   }
   unlock() {
@@ -6795,7 +6884,7 @@ async function selectReferencedJobFilePaths(db) {
 }
 
 // kernel/adapters/sqlite/migrations.ts
-import { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync8, readdirSync } from "fs";
+import { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync8, readdirSync as readdirSync2 } from "fs";
 import { dirname as dirname7, join as join5, resolve as resolve10 } from "path";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 import { fileURLToPath } from "url";
@@ -6817,7 +6906,7 @@ function defaultMigrationsDir() {
 }
 function discoverMigrations(dir = defaultMigrationsDir()) {
   if (!existsSync8(dir)) return [];
-  const files = readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name).filter((name) => FILE_RE.test(name)).sort();
+  const files = readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name).filter((name) => FILE_RE.test(name)).sort();
   const out = [];
   for (const name of files) {
     const match = FILE_RE.exec(name);
@@ -6932,7 +7021,7 @@ function writeBackup(dbPath, destPath) {
 }
 
 // kernel/adapters/sqlite/plugin-migrations.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync9, readdirSync as readdirSync3 } from "fs";
 import { join as join6 } from "path";
 
 // kernel/adapters/sqlite/plugin-migrations-validator.ts
@@ -7252,7 +7341,7 @@ function resolvePluginMigrationsDir(plugin) {
 function discoverPluginMigrations(plugin) {
   const dir = resolvePluginMigrationsDir(plugin);
   if (!dir) return [];
-  const files = readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name).filter((name) => FILE_RE2.test(name)).sort();
+  const files = readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name).filter((name) => FILE_RE2.test(name)).sort();
   const out = [];
   for (const name of files) {
     const match = FILE_RE2.exec(name);
@@ -9851,7 +9940,7 @@ var PLUGIN_LOADER_TEXTS = {
 
 // kernel/adapters/plugin-loader/index.ts
 import { createRequire as createRequire5 } from "module";
-import { existsSync as existsSync13, readFileSync as readFileSync13, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync13, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
 import { join as join8, resolve as resolve16 } from "path";
 import { pathToFileURL } from "url";
 import semver from "semver";
@@ -10194,9 +10283,9 @@ function providerKindFailure(opts, status, fileName, errDescription) {
     }
   };
 }
-function isDirectorySafe(path, statSync12) {
+function isDirectorySafe(path, statSync13) {
   try {
-    return statSync12(path).isDirectory();
+    return statSync13(path).isDirectory();
   } catch {
     return false;
   }
@@ -10306,7 +10395,7 @@ var PluginLoader = class {
     const out = [];
     for (const root of this.#options.searchPaths) {
       if (!existsSync13(root)) continue;
-      for (const entry of readdirSync4(root, { withFileTypes: true })) {
+      for (const entry of readdirSync5(root, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         const candidate = join8(root, entry.name);
         if (existsSync13(join8(candidate, "plugin.json"))) {
@@ -10677,7 +10766,7 @@ function collectKindEntries(pluginPath, kindDir, out) {
   if (!existsSync13(kindAbs)) return;
   let entries;
   try {
-    entries = readdirSync4(kindAbs);
+    entries = readdirSync5(kindAbs);
   } catch {
     return;
   }
@@ -11826,13 +11915,14 @@ function detectProvidersFromFilesystem(cwd, providers) {
   return out;
 }
 function isDetectableUnderCwd(cwd, provider) {
-  if (provider.presentation?.comingSoon === true) return false;
+  if (!installedDefaultEnabled(provider.stability)) return false;
   const markers = provider.detect?.markers;
   if (!markers || markers.length === 0) return false;
   return markers.some((marker) => existsSync15(join10(cwd, marker)));
 }
 
 // core/config/active-provider.ts
+var MARKDOWN_LENS_ID = "markdown";
 function resolveActiveProvider(cwd, providers = []) {
   const detected = detectProvidersFromFilesystem(cwd, providers);
   const fromConfig = readConfigValue("activeProvider", { cwd });
@@ -11842,7 +11932,7 @@ function resolveActiveProvider(cwd, providers = []) {
   if (detected.length > 0) {
     return { resolved: detected[0], source: "autodetect", detected };
   }
-  return { resolved: null, source: "none", detected };
+  return { resolved: MARKDOWN_LENS_ID, source: "default", detected };
 }
 
 // cli/util/path-display.ts
@@ -12580,7 +12670,7 @@ import { Command as Command5, Option as Option5 } from "clipanion";
 
 // conformance/index.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { cpSync, existsSync as existsSync17, mkdtempSync, readdirSync as readdirSync5, readFileSync as readFileSync15, rmSync, statSync as statSync3 } from "fs";
+import { cpSync, existsSync as existsSync17, mkdtempSync, readdirSync as readdirSync6, readFileSync as readFileSync15, rmSync, statSync as statSync3 } from "fs";
 import { tmpdir } from "os";
 import { isAbsolute as isAbsolute6, join as join11, relative as relative3, resolve as resolve20 } from "path";
 
@@ -12736,7 +12826,7 @@ function runPriorScansSetup(c, options, scope, fixturesRoot, setupEnv) {
 }
 function replaceFixture(scope, fixturesRoot, fixture) {
   assertContained2(fixturesRoot, fixture, "fixture");
-  for (const entry of readdirSync5(scope)) {
+  for (const entry of readdirSync6(scope)) {
     if (entry === KERNEL_SKILL_MAP_DIR) continue;
     rmSync(join11(scope, entry), { recursive: true, force: true });
   }
@@ -12973,7 +13063,7 @@ var CONFORMANCE_TEXTS = {
 };
 
 // cli/util/conformance-scopes.ts
-import { existsSync as existsSync18, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
+import { existsSync as existsSync18, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
 import { dirname as dirname11, resolve as resolve21 } from "path";
 import { createRequire as createRequire6 } from "module";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -13014,7 +13104,7 @@ function collectProviderScopes(specRoot) {
   }
   const pluginsRoot = resolve21(workspaceRoot, "plugins");
   if (!existsSync18(pluginsRoot)) return out;
-  for (const pluginEntry of readdirSync6(pluginsRoot)) {
+  for (const pluginEntry of readdirSync7(pluginsRoot)) {
     const pluginDir = resolve21(pluginsRoot, pluginEntry);
     if (!isDir(pluginDir)) continue;
     const providersRoot = resolve21(pluginDir, "providers");
@@ -13031,7 +13121,7 @@ function isDir(path) {
   }
 }
 function collectPluginProviderScopes(providersRoot, specRoot, out) {
-  for (const entry of readdirSync6(providersRoot)) {
+  for (const entry of readdirSync7(providersRoot)) {
     const providerDir = resolve21(providersRoot, entry);
     if (!isDir(providerDir)) continue;
     const conformanceDir = resolve21(providerDir, "conformance");
@@ -13077,7 +13167,7 @@ function selectConformanceScopes(scope) {
 }
 function listCaseFiles(scope) {
   if (!existsSync18(scope.casesDir)) return [];
-  return readdirSync6(scope.casesDir).filter((entry) => entry.endsWith(".json")).sort().map((entry) => resolve21(scope.casesDir, entry));
+  return readdirSync7(scope.casesDir).filter((entry) => entry.endsWith(".json")).sort().map((entry) => resolve21(scope.casesDir, entry));
 }
 
 // cli/commands/conformance.ts
@@ -14206,78 +14296,398 @@ var DB_COMMANDS = [
   DbMigrateCommand
 ];
 
-// cli/commands/export.ts
+// cli/commands/example.ts
+import { cpSync as cpSync2, existsSync as existsSync21, statSync as statSync5 } from "fs";
+import { dirname as dirname16, relative as relative5, resolve as resolve26 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 import { Command as Command13, Option as Option12 } from "clipanion";
 
-// kernel/scan/query.ts
-var HAS_VALUES = /* @__PURE__ */ new Set(["issues"]);
-var ExportQueryError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ExportQueryError";
-  }
+// cli/i18n/example.texts.ts
+var EXAMPLE_TEXTS = {
+  // Success, written to stdout after the example project is created in
+  // the cwd. The project ships unscanned (no `.skill-map/`), so the
+  // next-steps block points the user at `sm scan` (provisions the
+  // project and builds the graph) then `sm serve` (opens the map).
+  written: "  {{glyph}}  Example project created in {{cwd}}\n\n  A small wired portfolio is ready to explore: a handbook\n  (AGENTS.md) that mentions a content-editor agent and invokes a\n  publish command, a check-links skill the command calls, and the\n  docs they reference. Next:\n\n      {{scanGlyph}} sm scan    build the graph from these files\n      {{serveGlyph}} sm serve   open the interactive map in the browser\n",
+  writtenScanGlyph: "1)",
+  writtenServeGlyph: "2)",
+  // Refusal, the cwd is not empty and `--force` was not set. Goes to
+  // stderr, exit code 2 (operational error per spec § Exit codes). The
+  // example writes a self-contained project into the cwd, so it needs an
+  // empty directory; the hint spells the two ways forward. Mirrors the
+  // error shape: glyph + headline + dim hint.
+  notEmpty: "{{glyph}}  sm example: the current directory is not empty (found {{entries}})\n   {{hint}}\n",
+  notEmptyHint: "sm example writes a self-contained project; run it in a fresh empty directory, or pass `--force` to use this one anyway (colliding files are overwritten).",
+  // Unexpected positional argument. The verb takes none. Goes to
+  // stderr, exit code 2. Mirrors the error shape: glyph + headline +
+  // dim hint.
+  unexpectedArg: "{{glyph}}  sm example: unexpected argument '{{arg}}'\n   {{hint}}\n",
+  unexpectedArgHint: "sm example takes no positional argument. Run `sm example` in an empty directory.",
+  // I/O failure on write or on reading the bundled example payload.
+  writeFailed: "{{glyph}}  sm example: failed to write the example project: {{message}}\n",
+  sourceMissing: "{{glyph}}  sm example: could not read the bundled example payload from the install.\n   {{hint}}\n",
+  sourceMissingHint: "Reinstall @skill-map/cli or report the bug."
 };
-function parseExportQuery(raw) {
-  const trimmed = raw.trim();
-  const out = { raw: trimmed };
-  if (trimmed.length === 0) return out;
-  const seen = /* @__PURE__ */ new Set();
-  for (const token of trimmed.split(/\s+/)) {
-    const eq = token.indexOf("=");
-    if (eq <= 0 || eq === token.length - 1) {
-      throw new ExportQueryError(
-        tx(QUERY_TEXTS.exportQueryInvalidToken, { token })
-      );
-    }
-    const key = token.slice(0, eq).toLowerCase();
-    const valuePart = token.slice(eq + 1);
-    if (seen.has(key)) {
-      throw new ExportQueryError(
-        tx(QUERY_TEXTS.exportQueryDuplicateKey, { key })
-      );
-    }
-    seen.add(key);
-    const values = valuePart.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
-    if (values.length === 0) {
-      throw new ExportQueryError(tx(QUERY_TEXTS.exportQueryEmptyValues, { key }));
-    }
-    switch (key) {
-      case "kind":
-        out.kinds = parseKindValues(values);
-        break;
-      case "has":
-        if (parseHasValues(values)) out.hasIssues = true;
-        break;
-      case "path":
-        out.pathGlobs = values;
-        break;
-      default:
-        throw new ExportQueryError(
-          tx(QUERY_TEXTS.exportQueryUnknownKey, { key })
-        );
-    }
-  }
-  return out;
-}
-function parseKindValues(values) {
-  for (const v of values) {
-    if (v.length === 0) {
-      throw new ExportQueryError(QUERY_TEXTS.exportQueryEmptyKind);
-    }
-  }
-  return values;
-}
-function parseHasValues(values) {
-  for (const v of values) {
-    if (!HAS_VALUES.has(v)) {
-      throw new ExportQueryError(
-        tx(QUERY_TEXTS.exportQueryUnsupportedHas, {
-          value: v,
-          allowed: [...HAS_VALUES].join(", ")
-        })
-      );
-    }
-  }
+
+// cli/util/serve-banner.ts
+import { relative as relative4, isAbsolute as isAbsolute7 } from "path";
+var ESC2 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  underline: "\x1B[4m",
+  /** 256-color violet (xterm 141). */
+  violet: "\x1B[38;5;141m",
+  /** 256-color green (xterm 42). */
+  green: "\x1B[38;5;42m",
+  /** 256-color yellow (xterm 214), matches `cli/util/ansi.ts:yellow`. */
+  yellow: "\x1B[38;5;214m"
+};
+var LOGO_LINES = [
+  "  ____  _    _ _ _   __  __             ",
+  " / ___|| | _(_) | | |  \\/  | __ _ _ __  ",
+  " \\___ \\| |/ / | | | | |\\/| |/ _` | '_ \\ ",
+  "  ___) |   <| | | | | |  | | (_| | |_) |",
+  " |____/|_|\\_\\_|_|_| |_|  |_|\\__,_| .__/ ",
+  "                                 |_|    "
+];
+var LOGO_WIDTH = 40;
+function renderBanner(input) {
+  const url = `http://${input.host}:${input.port}`;
+  const dbDisplay = formatDbPath(input.dbPath, input.cwd);
+  const browserLine = input.openBrowser ? "Opening browser\u2026  Press Ctrl+C to stop." : `Visit ${url}/ in your browser.  Press Ctrl+C to stop.`;
+  if (!input.isTTY) {
+    return renderFlat({
+      host: input.host,
+      port: input.port,
+      dbPath: input.dbPath,
+      openBrowser: input.openBrowser,
+      dev: input.dev === true
+    });
+  }
+  return renderFiglet({
+    version: input.version,
+    url,
+    dbDisplay,
+    pathDisplay: formatCwdPath(input.cwd),
+    browserLine,
+    colorEnabled: input.colorEnabled,
+    referencePaths: input.referencePaths ?? [],
+    dev: input.dev === true
+  });
+}
+function resolveColorEnabled(opts) {
+  if (opts.noColorFlag) return false;
+  const noColor = opts.env["NO_COLOR"];
+  if (noColor !== void 0 && noColor !== "") return false;
+  const forceColor = opts.env["FORCE_COLOR"];
+  if (forceColor !== void 0 && forceColor !== "") return true;
+  return opts.isTTY;
+}
+function renderFlat(input) {
+  const safeHost = sanitizeForTerminal(input.host);
+  const safeDb = sanitizeForTerminal(input.dbPath);
+  const url = `http://${safeHost}:${input.port}`;
+  const devSuffix = input.dev ? " [dev]" : "";
+  const linesOut = [];
+  linesOut.push(`sm serve${devSuffix}: listening on ${url} (db=${safeDb})`);
+  if (input.openBrowser) {
+    linesOut.push(`sm serve: opening ${url}/ in your browser. Press Ctrl+C to stop.`);
+  } else {
+    linesOut.push(`sm serve: visit ${url}/ in your browser. Press Ctrl+C to stop.`);
+  }
+  return linesOut.join("\n") + "\n";
+}
+function renderLogoBlock(input) {
+  const { dimOpen, dimClose, violetOpen, violetClose } = resolveAnsi(input.colorEnabled);
+  const logoLines = LOGO_LINES.map((line) => `${violetOpen}${line}${violetClose}`);
+  const versionText = `v${input.version}`;
+  const versionPad = Math.max(0, LOGO_WIDTH - versionText.length);
+  const versionLine = `${" ".repeat(versionPad)}${dimOpen}${versionText}${dimClose}`;
+  return `${logoLines.join("\n")}
+
+${versionLine}
+
+`;
+}
+function renderFiglet(input) {
+  const {
+    dimOpen,
+    dimClose,
+    greenUnderline,
+    greenUnderlineClose,
+    violetOpen,
+    violetClose,
+    yellowOpen,
+    yellowClose
+  } = resolveAnsi(input.colorEnabled);
+  const logoLines = LOGO_LINES.map((line) => `${violetOpen}${line}${violetClose}`);
+  const versionText = `v${input.version}`;
+  const devText = "[dev]";
+  const versionWidth = input.dev ? devText.length : versionText.length;
+  const versionPad = Math.max(0, LOGO_WIDTH - versionWidth);
+  const versionLine = input.dev ? `${" ".repeat(versionPad)}${yellowOpen}${devText}${yellowClose}` : `${" ".repeat(versionPad)}${dimOpen}${versionText}${dimClose}`;
+  const lines = [];
+  lines.push(...logoLines);
+  lines.push("");
+  lines.push(versionLine);
+  lines.push("");
+  lines.push(`  ${dimOpen}Server${dimClose}   ${greenUnderline}${input.url}${greenUnderlineClose}`);
+  lines.push(`  ${dimOpen}Path${dimClose}     ${input.pathDisplay}`);
+  lines.push(`  ${dimOpen}DB${dimClose}       ${input.dbDisplay}`);
+  lines.push(...renderListRows("Refs", input.referencePaths, dimOpen, dimClose));
+  lines.push("");
+  lines.push(`  ${dimOpen}${input.browserLine}${dimClose}`);
+  lines.push("");
+  return lines.join("\n") + "\n";
+}
+function renderListRows(label, values, dimOpen, dimClose) {
+  if (values.length === 0) return [];
+  const out = [];
+  const labelPad = " ".repeat(Math.max(1, 9 - label.length));
+  const continuationPad = " ".repeat(11);
+  out.push(`  ${dimOpen}${label}${dimClose}${labelPad}${sanitizeForTerminal(values[0])}`);
+  for (let i = 1; i < values.length; i += 1) {
+    out.push(`${continuationPad}${sanitizeForTerminal(values[i])}`);
+  }
+  return out;
+}
+var EMPTY_ANSI = {
+  dimOpen: "",
+  dimClose: "",
+  greenUnderline: "",
+  greenUnderlineClose: "",
+  violetOpen: "",
+  violetClose: "",
+  yellowOpen: "",
+  yellowClose: ""
+};
+var ENABLED_ANSI = {
+  dimOpen: ESC2.dim,
+  dimClose: ESC2.reset,
+  greenUnderline: `${ESC2.green}${ESC2.underline}`,
+  greenUnderlineClose: ESC2.reset,
+  violetOpen: ESC2.violet,
+  violetClose: ESC2.reset,
+  yellowOpen: ESC2.yellow,
+  yellowClose: ESC2.reset
+};
+function resolveAnsi(colorEnabled) {
+  return colorEnabled ? ENABLED_ANSI : EMPTY_ANSI;
+}
+function formatDbPath(dbPath, cwd) {
+  const safe = sanitizeForTerminal(dbPath);
+  if (!isAbsolute7(safe)) return safe;
+  const rel = relative4(cwd, safe);
+  if (rel === "" || rel.startsWith("..") || isAbsolute7(rel)) {
+    return safe;
+  }
+  return rel;
+}
+function formatCwdPath(cwd) {
+  return sanitizeForTerminal(cwd);
+}
+
+// cli/commands/example.ts
+var EXAMPLE_SOURCE_DIR = "fixtures/demo-scope";
+var ExampleCommand = class extends SmCommand {
+  static paths = [["example"]];
+  static usage = Command13.Usage({
+    category: "Setup",
+    description: "Materialize a ready-to-explore example project (the demo harness) in the current directory.",
+    details: `
+      Writes a small wired portfolio into <cwd>: a handbook (AGENTS.md)
+      that mentions a content-editor agent and invokes a publish command,
+      a check-links skill the command calls, and the docs they reference.
+      It is the same harness the public demo renders.
+
+      Ships unscanned (no .skill-map/): run \`sm scan\` then \`sm serve\`
+      to build and open the graph. Requires an empty directory; refuses a
+      non-empty cwd (exit 2) unless --force. Takes no positional argument.
+    `,
+    examples: [
+      ["Create the example project in the cwd", "$0 example"],
+      ["Create it even if the directory is not empty", "$0 example --force"]
+    ]
+  });
+  // The verb takes no positional argument. Accept one so a stray
+  // `sm example foo` lands on a friendly usage error (guarded in
+  // `run()`) instead of clipanion's generic "extraneous argument".
+  legacyPositional = Option12.String({ required: false });
+  force = Option12.Boolean("--force", false, {
+    description: "Overwrite colliding files in a non-empty directory without prompting."
+  });
+  async run() {
+    const ctx = defaultRuntimeContext();
+    const stderr = this.context.stderr;
+    const stderrAnsi = this.ansiFor("stderr");
+    const errGlyph = stderrAnsi.red("\u2715");
+    if (this.legacyPositional !== void 0) {
+      this.printer.error(
+        tx(EXAMPLE_TEXTS.unexpectedArg, {
+          glyph: errGlyph,
+          arg: this.legacyPositional,
+          hint: stderrAnsi.dim(EXAMPLE_TEXTS.unexpectedArgHint)
+        })
+      );
+      return ExitCode.Error;
+    }
+    if (!this.force && !isDirEmpty(ctx.cwd)) {
+      this.printer.error(
+        tx(EXAMPLE_TEXTS.notEmpty, {
+          glyph: errGlyph,
+          entries: listCwdEntries(ctx.cwd),
+          hint: stderrAnsi.dim(EXAMPLE_TEXTS.notEmptyHint)
+        })
+      );
+      return ExitCode.Error;
+    }
+    let sourceDir;
+    try {
+      sourceDir = resolveExampleSourceDir();
+    } catch {
+      this.printer.error(
+        tx(EXAMPLE_TEXTS.sourceMissing, {
+          glyph: errGlyph,
+          hint: stderrAnsi.dim(EXAMPLE_TEXTS.sourceMissingHint)
+        })
+      );
+      return ExitCode.Error;
+    }
+    try {
+      cpSync2(sourceDir, ctx.cwd, {
+        recursive: true,
+        // Never copy the example's own scan state: the project must ship
+        // unscanned so the user's first `sm scan` provisions it fresh.
+        filter: (src) => isExamplePayloadEntry(sourceDir, src)
+      });
+    } catch (err) {
+      this.printer.error(
+        tx(EXAMPLE_TEXTS.writeFailed, {
+          glyph: errGlyph,
+          message: formatErrorMessage(err)
+        })
+      );
+      return ExitCode.Error;
+    }
+    const colorEnabled = resolveColorEnabled({
+      isTTY: stderr.isTTY === true,
+      noColorFlag: this.noColor,
+      env: process.env
+    });
+    this.printer.info(renderLogoBlock({ version: VERSION, colorEnabled }));
+    const ansi = this.ansiFor("stdout");
+    this.printer.data(
+      tx(EXAMPLE_TEXTS.written, {
+        glyph: ansi.green("\u2713"),
+        cwd: ansi.dim(displayCwd(ctx.cwd)),
+        scanGlyph: ansi.dim(EXAMPLE_TEXTS.writtenScanGlyph),
+        serveGlyph: ansi.dim(EXAMPLE_TEXTS.writtenServeGlyph)
+      })
+    );
+    return ExitCode.Ok;
+  }
+};
+var cachedSourceDir;
+function resolveExampleSourceDir() {
+  if (cachedSourceDir !== void 0) return cachedSourceDir;
+  const here = dirname16(fileURLToPath5(import.meta.url));
+  const candidates = [
+    // dev: src/cli/commands/ → repo-root fixtures/demo-scope/
+    resolve26(here, "../../..", EXAMPLE_SOURCE_DIR),
+    // bundled: dist/cli.js → dist/cli/example (sibling)
+    resolve26(here, "cli/example"),
+    // bundled fallback: any-depth → cli/example
+    resolve26(here, "../cli/example")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync21(candidate) && statSync5(candidate).isDirectory()) {
+      cachedSourceDir = candidate;
+      return candidate;
+    }
+  }
+  throw new Error(
+    `example payload directory not found in any candidate location (last tried: ${candidates[candidates.length - 1]})`
+  );
+}
+function isExamplePayloadEntry(sourceRoot, src) {
+  const rel = relative5(sourceRoot, src);
+  if (rel === "") return true;
+  return rel.split(/[\\/]/)[0] !== ".skill-map";
+}
+
+// cli/commands/export.ts
+import { Command as Command14, Option as Option13 } from "clipanion";
+
+// kernel/scan/query.ts
+var HAS_VALUES = /* @__PURE__ */ new Set(["issues"]);
+var ExportQueryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ExportQueryError";
+  }
+};
+function parseExportQuery(raw) {
+  const trimmed = raw.trim();
+  const out = { raw: trimmed };
+  if (trimmed.length === 0) return out;
+  const seen = /* @__PURE__ */ new Set();
+  for (const token of trimmed.split(/\s+/)) {
+    const eq = token.indexOf("=");
+    if (eq <= 0 || eq === token.length - 1) {
+      throw new ExportQueryError(
+        tx(QUERY_TEXTS.exportQueryInvalidToken, { token })
+      );
+    }
+    const key = token.slice(0, eq).toLowerCase();
+    const valuePart = token.slice(eq + 1);
+    if (seen.has(key)) {
+      throw new ExportQueryError(
+        tx(QUERY_TEXTS.exportQueryDuplicateKey, { key })
+      );
+    }
+    seen.add(key);
+    const values = valuePart.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
+    if (values.length === 0) {
+      throw new ExportQueryError(tx(QUERY_TEXTS.exportQueryEmptyValues, { key }));
+    }
+    switch (key) {
+      case "kind":
+        out.kinds = parseKindValues(values);
+        break;
+      case "has":
+        if (parseHasValues(values)) out.hasIssues = true;
+        break;
+      case "path":
+        out.pathGlobs = values;
+        break;
+      default:
+        throw new ExportQueryError(
+          tx(QUERY_TEXTS.exportQueryUnknownKey, { key })
+        );
+    }
+  }
+  return out;
+}
+function parseKindValues(values) {
+  for (const v of values) {
+    if (v.length === 0) {
+      throw new ExportQueryError(QUERY_TEXTS.exportQueryEmptyKind);
+    }
+  }
+  return values;
+}
+function parseHasValues(values) {
+  for (const v of values) {
+    if (!HAS_VALUES.has(v)) {
+      throw new ExportQueryError(
+        tx(QUERY_TEXTS.exportQueryUnsupportedHas, {
+          value: v,
+          allowed: [...HAS_VALUES].join(", ")
+        })
+      );
+    }
+  }
   return values.includes("issues");
 }
 function applyExportQuery(scan, query) {
@@ -14386,7 +14796,7 @@ var DEFERRED_FORMATS = {
 };
 var ExportCommand = class extends SmCommand {
   static paths = [["export"]];
-  static usage = Command13.Usage({
+  static usage = Command14.Usage({
     category: "Browse",
     description: "Filtered export. Query syntax is implementation-defined pre-1.0.",
     details: `
@@ -14411,8 +14821,8 @@ var ExportCommand = class extends SmCommand {
       ["Files under a path glob", '$0 export "path=.claude/commands/**" --format json']
     ]
   });
-  query = Option12.String({ required: false });
-  format = Option12.String("--format", { required: false });
+  query = Option13.String({ required: false });
+  format = Option13.String("--format", { required: false });
   async run() {
     const stderrAnsi = this.ansiFor("stderr");
     const errGlyph = stderrAnsi.red("\u2715");
@@ -14636,7 +15046,7 @@ function pickTitle2(node) {
 }
 
 // cli/commands/graph.ts
-import { Command as Command14, Option as Option13 } from "clipanion";
+import { Command as Command15, Option as Option14 } from "clipanion";
 
 // cli/i18n/graph.texts.ts
 var GRAPH_TEXTS = {
@@ -14654,7 +15064,7 @@ var GRAPH_TEXTS = {
 var DEFAULT_FORMAT = "ascii";
 var GraphCommand = class extends SmCommand {
   static paths = [["graph"]];
-  static usage = Command14.Usage({
+  static usage = Command15.Usage({
     category: "Browse",
     description: "Render the full graph via the named formatter.",
     details: `
@@ -14671,10 +15081,10 @@ var GraphCommand = class extends SmCommand {
       ["Use a non-default DB file", "$0 graph --db /path/to/skill-map.db"]
     ]
   });
-  format = Option13.String("--format", DEFAULT_FORMAT, {
+  format = Option14.String("--format", DEFAULT_FORMAT, {
     description: `Formatter format. Must match the \`formatId\` field of a registered formatter. Default: ${DEFAULT_FORMAT}.`
   });
-  noPlugins = Option13.Boolean("--no-plugins", false, {
+  noPlugins = Option14.Boolean("--no-plugins", false, {
     description: "Skip drop-in plugin discovery. Only built-in formatters participate."
   });
   async run() {
@@ -14725,8 +15135,8 @@ var GraphCommand = class extends SmCommand {
 // cli/commands/help.ts
 import { readFileSync as readFileSync17 } from "fs";
 import { createRequire as createRequire7 } from "module";
-import { resolve as resolve26 } from "path";
-import { Command as Command15, Option as Option14 } from "clipanion";
+import { resolve as resolve27 } from "path";
+import { Command as Command16, Option as Option15 } from "clipanion";
 
 // cli/i18n/help.texts.ts
 var HELP_TEXTS = {
@@ -14869,9 +15279,9 @@ var HELP_GROUPS = {
 };
 
 // cli/commands/help.ts
-var HelpCommand = class extends Command15 {
+var HelpCommand = class extends Command16 {
   static paths = [["help"]];
-  static usage = Command15.Usage({
+  static usage = Command16.Usage({
     category: "Introspection",
     description: "Self-describing introspection. --format human|md|json.",
     details: `
@@ -14884,13 +15294,13 @@ var HelpCommand = class extends Command15 {
         json           : structured surface dump per spec/cli-contract.md.
     `
   });
-  verbParts = Option14.Rest({ required: 0 });
-  format = Option14.String("--format", "human");
+  verbParts = Option15.Rest({ required: 0 });
+  format = Option15.String("--format", "human");
   // `HelpCommand` extends Clipanion's `Command` directly (see block
   // comment), so it does not inherit `SmCommand`'s `--no-color`. Declared
   // here because the human overview now emits a coloured tutorial glyph;
   // `ansiFor` still layers `NO_COLOR` / `FORCE_COLOR` / TTY on top.
-  noColor = Option14.Boolean("--no-color", false, {
+  noColor = Option15.Boolean("--no-color", false, {
     description: "Disable ANSI color codes."
   });
   async execute() {
@@ -15039,7 +15449,7 @@ function resolveSpecVersion() {
   try {
     const req = createRequire7(import.meta.url);
     const indexPath = req.resolve("@skill-map/spec/index.json");
-    const pkgPath = resolve26(indexPath, "..", "package.json");
+    const pkgPath = resolve27(indexPath, "..", "package.json");
     const pkg = JSON.parse(readFileSync17(pkgPath, "utf8"));
     return pkg.version;
   } catch {
@@ -15282,12 +15692,12 @@ function renderCompactOverview(verbs, ansi) {
   lines.push(HELP_TEXTS.compactFooter);
   return lines.join("\n") + "\n";
 }
-var RootHelpCommand = class extends Command15 {
+var RootHelpCommand = class extends Command16 {
   static paths = [["-h"], ["--help"]];
   // Mirrors `HelpCommand.noColor`: this command extends Clipanion's
   // `Command` directly, so the flag is declared here to gate the
   // coloured tutorial glyph in the overview.
-  noColor = Option14.Boolean("--no-color", false, {
+  noColor = Option15.Boolean("--no-color", false, {
     description: "Disable ANSI color codes."
   });
   async execute() {
@@ -15347,8 +15757,8 @@ function registeredVerbPaths(cli2) {
 
 // cli/commands/hooks.ts
 import { chmod as chmod2, mkdir as mkdir3, readFile as readFile2, stat as stat2, writeFile } from "fs/promises";
-import { dirname as dirname16, resolve as resolve27 } from "path";
-import { Command as Command16, Option as Option15 } from "clipanion";
+import { dirname as dirname17, resolve as resolve28 } from "path";
+import { Command as Command17, Option as Option16 } from "clipanion";
 
 // cli/i18n/hooks.texts.ts
 var HOOKS_TEXTS = {
@@ -15395,7 +15805,7 @@ var SKILL_MAP_BLOCK = [
 var FRESH_HOOK_BODY = HOOK_SHEBANG + SKILL_MAP_BLOCK;
 var HooksInstallCommand = class extends SmCommand {
   static paths = [["hooks", "install"]];
-  static usage = Command16.Usage({
+  static usage = Command17.Usage({
     category: "Actions",
     description: "Install a git pre-commit hook that auto-bumps staged sidecar drift.",
     details: `
@@ -15418,8 +15828,8 @@ var HooksInstallCommand = class extends SmCommand {
       ["Preview what would be written", "$0 hooks install pre-commit-bump --dry-run"]
     ]
   });
-  flavour = Option15.String({ required: true });
-  dryRun = Option15.Boolean("-n,--dry-run", false);
+  flavour = Option16.String({ required: true });
+  dryRun = Option16.Boolean("-n,--dry-run", false);
   // The remaining cyclomatic count is from CLI ergonomics, flavour
   // guard, repo lookup, marker detection, dry-run / json / chained /
   // fresh branches each contributing a guard. Inner work already lives
@@ -15450,8 +15860,8 @@ var HooksInstallCommand = class extends SmCommand {
       );
       return ExitCode.NotFound;
     }
-    const hooksDir = resolve27(repoRoot, ".git", "hooks");
-    const hookPath = resolve27(hooksDir, "pre-commit");
+    const hooksDir = resolve28(repoRoot, ".git", "hooks");
+    const hookPath = resolve28(hooksDir, "pre-commit");
     const existing = await pathExists(hookPath) ? await readFile2(hookPath, "utf8") : null;
     const planned2 = computePlannedHookContent(existing);
     if (planned2.kind === "already-installed") {
@@ -15509,8 +15919,8 @@ var HooksInstallCommand = class extends SmCommand {
 async function findGitRepoRoot(cwd) {
   let current = cwd;
   while (true) {
-    if (await pathExists(resolve27(current, ".git"))) return current;
-    const parent = dirname16(current);
+    if (await pathExists(resolve28(current, ".git"))) return current;
+    const parent = dirname17(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -15532,11 +15942,11 @@ var HOOKS_COMMANDS = [HooksInstallCommand];
 // cli/commands/init.ts
 import { mkdir as mkdir4, readFile as readFile3, unlink, writeFile as writeFile2 } from "fs/promises";
 import { join as join16 } from "path";
-import { Command as Command17, Option as Option16 } from "clipanion";
+import { Command as Command18, Option as Option17 } from "clipanion";
 
 // kernel/orchestrator/index.ts
-import { existsSync as existsSync23, statSync as statSync6 } from "fs";
-import { isAbsolute as isAbsolute9, resolve as resolve30 } from "path";
+import { existsSync as existsSync24, statSync as statSync7 } from "fs";
+import { isAbsolute as isAbsolute10, resolve as resolve31 } from "path";
 import { Tiktoken as Tiktoken2 } from "js-tiktoken/lite";
 
 // kernel/i18n/orchestrator.texts.ts
@@ -16290,8 +16700,7 @@ function matchesKindPrecondition(ex, kind) {
 function matchesProviderPrecondition(ex, activeProvider) {
   const providers = ex.precondition?.provider;
   if (!providers || providers.length === 0) return true;
-  if (activeProvider === null) return false;
-  return providers.includes(activeProvider);
+  return activeProvider !== null && providers.includes(activeProvider);
 }
 function splitLegacy(applicableExtractors, applicableQualifiedIds, nodeHashCacheEligible) {
   const cachedQualifiedIds = /* @__PURE__ */ new Set();
@@ -16482,7 +16891,7 @@ function collectBrokenLinks(links, nodes, ctx) {
   return broken;
 }
 function applyResolution(link, indexes, ctx) {
-  const resolution = resolve28(link, indexes, ctx);
+  const resolution = resolve29(link, indexes, ctx);
   if (resolution === "none") return;
   link.resolvedTarget = resolution;
 }
@@ -16497,7 +16906,7 @@ function buildIndexes(nodes, ctx) {
   }
   return { byPath: byPath3, byName, nodeByPath };
 }
-function resolve28(link, indexes, ctx) {
+function resolve29(link, indexes, ctx) {
   if (indexes.byPath.has(link.target)) return link.target;
   return resolveByName(link, indexes, ctx);
 }
@@ -16886,7 +17295,7 @@ function detectRenamesAndOrphans(prior, current, issues, silenced) {
 }
 
 // kernel/orchestrator/walk.ts
-import { isAbsolute as isAbsolute8, resolve as resolve29 } from "path";
+import { isAbsolute as isAbsolute9, resolve as resolve30 } from "path";
 
 // kernel/sidecar/drift.ts
 function computeDriftStatus(args2) {
@@ -16899,8 +17308,8 @@ function computeDriftStatus(args2) {
 }
 
 // kernel/sidecar/discover-orphans.ts
-import { existsSync as existsSync21, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
-import { join as join13, relative as relative4, sep as sep4 } from "path";
+import { existsSync as existsSync22, readdirSync as readdirSync8, statSync as statSync6 } from "fs";
+import { join as join13, relative as relative6, sep as sep4 } from "path";
 function discoverOrphanSidecars(roots, shouldSkip) {
   const out = [];
   for (const root of roots) {
@@ -16911,13 +17320,13 @@ function discoverOrphanSidecars(roots, shouldSkip) {
 function walk2(root, current, shouldSkip, out) {
   let entries;
   try {
-    entries = readdirSync7(current, { withFileTypes: true, encoding: "utf8" });
+    entries = readdirSync8(current, { withFileTypes: true, encoding: "utf8" });
   } catch {
     return;
   }
   for (const entry of entries) {
     const full = join13(current, entry.name);
-    const rel = relative4(root, full).split(sep4).join("/");
+    const rel = relative6(root, full).split(sep4).join("/");
     if (shouldSkip(rel)) continue;
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
@@ -16927,13 +17336,13 @@ function walk2(root, current, shouldSkip, out) {
     if (!entry.isFile()) continue;
     if (!entry.name.endsWith(".sm")) continue;
     const expectedMd = `${full.slice(0, -".sm".length)}.md`;
-    if (existsSync21(expectedMd) && safeIsFile(expectedMd)) continue;
+    if (existsSync22(expectedMd) && safeIsFile(expectedMd)) continue;
     out.push({ sidecarPath: full, relativePath: rel, expectedMdPath: expectedMd });
   }
 }
 function safeIsFile(path) {
   try {
-    return statSync5(path).isFile();
+    return statSync6(path).isFile();
   } catch {
     return false;
   }
@@ -16941,8 +17350,8 @@ function safeIsFile(path) {
 
 // kernel/orchestrator/node-build.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync22 } from "fs";
-import { isAbsolute as isAbsolute7, resolve as resolvePath } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { isAbsolute as isAbsolute8, resolve as resolvePath } from "path";
 import "js-tiktoken/lite";
 import yaml4 from "js-yaml";
 
@@ -17105,12 +17514,12 @@ function resolveSidecarOverlay(relativePath2, nodePathForIssue, roots, liveBodyH
   };
 }
 function resolveAbsoluteMdPath(relativePath2, roots) {
-  if (isAbsolute7(relativePath2)) {
-    return existsSync22(relativePath2) ? relativePath2 : null;
+  if (isAbsolute8(relativePath2)) {
+    return existsSync23(relativePath2) ? relativePath2 : null;
   }
   for (const root of roots) {
     const candidate = resolvePath(root, relativePath2);
-    if (existsSync22(candidate)) return candidate;
+    if (existsSync23(candidate)) return candidate;
   }
   return null;
 }
@@ -17332,8 +17741,8 @@ function expandSidecarPaths(paths, priorNodesByPath) {
 }
 function toAbsolute(relPath, roots) {
   const root = roots[0] ?? ".";
-  const absRoot = isAbsolute8(root) ? root : resolve29(root);
-  return resolve29(absRoot, relPath);
+  const absRoot = isAbsolute9(root) ? root : resolve30(root);
+  return resolve30(absRoot, relPath);
 }
 function resolveEffectiveCaps(opts) {
   return {
@@ -17351,7 +17760,6 @@ function buildPriorMtimes(opts) {
 }
 function providerParticipates(provider, activeProvider) {
   if (!provider.gatedByActiveLens) return true;
-  if (activeProvider === null) return true;
   return provider.id === activeProvider;
 }
 function createWalkAccumulators() {
@@ -17773,8 +18181,7 @@ function buildPostWalkTransformCtx(providers, nodes, activeProvider) {
   const reservedNodePaths = buildReservedNodePaths(
     nodes,
     kindRegistry,
-    reservedNamesByProviderKind,
-    activeProvider
+    reservedNamesByProviderKind
   );
   return { kindRegistry, providerResolution, activeProvider, reservedNodePaths };
 }
@@ -17805,15 +18212,14 @@ function indexReservedNames(provider, out) {
     }
   }
 }
-function buildReservedNodePaths(nodes, kindRegistry, reservedNamesByProviderKind, activeProvider) {
+function buildReservedNodePaths(nodes, kindRegistry, reservedNamesByProviderKind) {
   const out = /* @__PURE__ */ new Set();
   for (const node of nodes) {
     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;
+    if (!hasEntries(selfReserved)) continue;
     const ids = deriveNodeIdentifiers(node, kindRegistry.get(selfKey));
-    if (ids.some((id) => selfReserved?.has(id) === true || lensReserved?.has(id) === true)) {
+    if (ids.some((id) => selfReserved?.has(id) === true)) {
       out.add(node.path);
     }
   }
@@ -17926,7 +18332,7 @@ function validateRoots(roots) {
     throw new Error(ORCHESTRATOR_TEXTS.runScanRootEmptyArray);
   }
   for (const root of roots) {
-    if (!existsSync23(root) || !statSync6(root).isDirectory()) {
+    if (!existsSync24(root) || !statSync7(root).isDirectory()) {
       throw new Error(tx(ORCHESTRATOR_TEXTS.runScanRootMissing, { root }));
     }
   }
@@ -17934,8 +18340,8 @@ function validateRoots(roots) {
 function resolveActiveProviderOption(optionValue, roots, providers) {
   if (optionValue !== void 0) return optionValue;
   for (const root of roots) {
-    const absRoot = isAbsolute9(root) ? root : resolve30(root);
-    if (!existsSync23(absRoot)) continue;
+    const absRoot = isAbsolute10(root) ? root : resolve31(root);
+    if (!existsSync24(absRoot)) continue;
     const detected = detectProvidersFromFilesystem(absRoot, providers)[0] ?? null;
     if (detected !== null) return detected;
   }
@@ -17943,10 +18349,10 @@ function resolveActiveProviderOption(optionValue, roots, providers) {
 }
 
 // kernel/scan/watcher.ts
-import { resolve as resolve31, relative as relative5, sep as sep5 } from "path";
+import { resolve as resolve32, relative as relative7, sep as sep5 } from "path";
 import chokidar from "chokidar";
 function createChokidarWatcher(opts) {
-  const absRoots = opts.roots.map((r) => resolve31(opts.cwd, r));
+  const absRoots = opts.roots.map((r) => resolve32(opts.cwd, r));
   const ignoreFilterOpt = opts.ignoreFilter;
   const getFilter = ignoreFilterOpt === void 0 ? void 0 : typeof ignoreFilterOpt === "function" ? ignoreFilterOpt : () => ignoreFilterOpt;
   const ignored = getFilter ? (path) => {
@@ -18039,7 +18445,7 @@ function createChokidarWatcher(opts) {
 }
 function relativePathFromRoots2(absolute, absRoots) {
   for (const root of absRoots) {
-    const rel = relative5(root, absolute);
+    const rel = relative7(root, absolute);
     if (rel === "" || rel === ".") return "";
     if (!rel.startsWith("..") && !rel.startsWith(`..${sep5}`)) {
       return rel.split(sep5).join("/");
@@ -18374,23 +18780,6 @@ var SCAN_RUNNER_TEXTS = {
    * operator notices a typo without the walker silently swallowing it.
    */
   referenceWalkMissingRoot: 'scan.referencePaths: configured path "{{path}}" does not exist; skipped.',
-  /**
-   * Active-provider bootstrap: filesystem auto-detect found no
-   * markers (`.claude/`, `.codex/`, `AGENTS.md`, `.cursor/`) anywhere
-   * under cwd or the effective scan roots. Plain-markdown projects
-   * keep scanning fine; provider-specific extractors silently no-op
-   * for this scan. Follows `context/cli-output-style.md` §3.1b
-   * (two-line block, glyph + dim hint):
-   *   - line 1: `{{glyph}}` (yellow `⚠`) + headline naming the
-   *     missing markers,
-   *   - line 2 (indent 3): `{{hint}}`, dim, names the consequence
-   *     and the actionable next step.
-   * Both the full block AND the bare hint are catalog-side so the
-   * caller can wrap the hint in `ansi.dim(...)` without splitting
-   * the template manually.
-   */
-  activeProviderNoMarkerWarning: "{{glyph}}  No provider markers detected (.claude/, .codex/, AGENTS.md, .cursor/).\n   {{hint}}\n",
-  activeProviderNoMarkerWarningHint: "Scanning as universal markdown only; provider-specific link types (e.g. claude @-directives, /-commands) will not appear. Set `activeProvider` in .skill-map/settings.json or install a provider plugin to enable them.",
   /**
    * Active-provider bootstrap: filesystem auto-detect found exactly
    * one marker and persisted the detected id to project settings.
@@ -18467,9 +18856,9 @@ function resolveScanRoots(inputs) {
 }
 
 // core/runtime/reference-paths-walker.ts
-import { readdirSync as readdirSync8, statSync as statSync7 } from "fs";
+import { readdirSync as readdirSync9, statSync as statSync8 } from "fs";
 import { homedir as osHomedir2 } from "os";
-import { isAbsolute as isAbsolute10, join as join14, resolve as resolve32 } from "path";
+import { isAbsolute as isAbsolute11, join as join14, resolve as resolve33 } from "path";
 var REFERENCE_WALK_MAX_FILES = 5e4;
 var SKIPPED_DIR_NAMES = /* @__PURE__ */ new Set([
   "node_modules",
@@ -18477,10 +18866,10 @@ var SKIPPED_DIR_NAMES = /* @__PURE__ */ new Set([
   SKILL_MAP_DIR
 ]);
 function resolveScanPath(raw, cwd) {
-  if (raw.startsWith("~/")) return resolve32(join14(osHomedir2(), raw.slice(2)));
-  if (raw === "~") return resolve32(osHomedir2());
-  if (isAbsolute10(raw)) return resolve32(raw);
-  return resolve32(cwd, raw);
+  if (raw.startsWith("~/")) return resolve33(join14(osHomedir2(), raw.slice(2)));
+  if (raw === "~") return resolve33(osHomedir2());
+  if (isAbsolute11(raw)) return resolve33(raw);
+  return resolve33(cwd, raw);
 }
 function walkReferencePaths(rawRoots, cwd) {
   const paths = /* @__PURE__ */ new Set();
@@ -18502,7 +18891,7 @@ function walkInto(dir, out) {
   if (out.size >= REFERENCE_WALK_MAX_FILES) return true;
   let entries;
   try {
-    entries = readdirSync8(dir, { withFileTypes: true });
+    entries = readdirSync9(dir, { withFileTypes: true });
   } catch {
     return false;
   }
@@ -18521,15 +18910,15 @@ function walkInto(dir, out) {
 }
 function safeStat(path) {
   try {
-    return statSync7(path);
+    return statSync8(path);
   } catch {
     return null;
   }
 }
 
 // core/runtime/active-provider-bootstrap.ts
-import { createInterface as createInterface3 } from "readline";
-import { isAbsolute as isAbsolute11, join as join15 } from "path";
+import { createInterface as createInterface4 } from "readline";
+import { isAbsolute as isAbsolute12, join as join15 } from "path";
 async function bootstrapActiveProvider(opts) {
   const fromCwd = resolveActiveProvider(opts.cwd, opts.providers);
   if (fromCwd.source === "config") {
@@ -18549,15 +18938,7 @@ async function bootstrapActiveProvider(opts) {
     opts.providers
   );
   if (detected.length === 0) {
-    const warnGlyph = opts.style?.warnGlyph ?? "\u26A0";
-    const dim = opts.style?.dim ?? ((s) => s);
-    opts.printer.warn(
-      tx(SCAN_RUNNER_TEXTS.activeProviderNoMarkerWarning, {
-        glyph: warnGlyph,
-        hint: dim(SCAN_RUNNER_TEXTS.activeProviderNoMarkerWarningHint)
-      })
-    );
-    return { kind: "ok", activeProvider: null, source: "none" };
+    return { kind: "ok", activeProvider: MARKDOWN_LENS_ID, source: "default" };
   }
   if (detected.length === 1) {
     const picked2 = detected[0];
@@ -18588,7 +18969,7 @@ function aggregateDetected(cwd, effectiveRoots, cwdDetected, providers) {
     out.push(id);
   }
   for (const root of effectiveRoots) {
-    const absRoot = isAbsolute11(root) ? root : join15(cwd, root);
+    const absRoot = isAbsolute12(root) ? root : join15(cwd, root);
     const r = resolveActiveProvider(absRoot, providers);
     for (const id of r.detected) {
       if (seen.has(id)) continue;
@@ -18620,7 +19001,13 @@ function handleDrift(opts, resolvedLens, currentMarkers) {
     backfillMarkersSnapshot(opts.cwd, currentMarkers);
     return;
   }
-  const diff = diffMarkers(snapshot, currentMarkers);
+  const shipsDisabled = new Set(
+    opts.providers.filter((p) => !installedDefaultEnabled(p.stability)).map((p) => p.id)
+  );
+  const diff = diffMarkers(
+    snapshot.filter((id) => !shipsDisabled.has(id)),
+    currentMarkers.filter((id) => !shipsDisabled.has(id))
+  );
   if (diff.added.length === 0 && diff.removed.length === 0) return;
   emitDriftWarn(opts, resolvedLens, diff);
 }
@@ -18630,7 +19017,7 @@ function emitDriftWarn(opts, resolvedLens, diff) {
   const hint = tx(SCAN_RUNNER_TEXTS.activeProviderDriftWarnHint, {
     added: diff.added.length === 0 ? "(none)" : diff.added.join(", "),
     removed: diff.removed.length === 0 ? "(none)" : diff.removed.join(", "),
-    currentLens: resolvedLens ?? "(none)"
+    currentLens: resolvedLens
   });
   opts.printer.warn(
     tx(SCAN_RUNNER_TEXTS.activeProviderDriftWarn, {
@@ -18662,7 +19049,6 @@ function diffMarkers(snapshot, current) {
   return { added, removed };
 }
 function warnIfLensPluginDisabled(args2) {
-  if (args2.activeProvider === null) return;
   if (args2.resolveEnabled(args2.activeProvider)) return;
   args2.printer.warn(
     tx(SCAN_RUNNER_TEXTS.activeProviderPluginDisabledWarning, {
@@ -18683,7 +19069,7 @@ async function promptForLens(detected, stdin, stderr, warnGlyph) {
     );
   }
   stderr.write(lines.join("\n") + "\n");
-  const rl = createInterface3({ input: stdin, output: stderr });
+  const rl = createInterface4({ input: stdin, output: stderr });
   try {
     const answer = await new Promise(
       (resolveP) => rl.question(SCAN_RUNNER_TEXTS.activeProviderPromptInput, resolveP)
@@ -18701,8 +19087,8 @@ async function promptForLens(detected, stdin, stderr, warnGlyph) {
 }
 
 // core/sqlite/db-drift-reset.ts
-import { existsSync as existsSync24 } from "fs";
-import { createInterface as createInterface4 } from "readline";
+import { existsSync as existsSync25 } from "fs";
+import { createInterface as createInterface5 } from "readline";
 import { DatabaseSync as DatabaseSync8 } from "node:sqlite";
 
 // core/sqlite/i18n/db-drift.texts.ts
@@ -18753,7 +19139,7 @@ function detectDriftReason(dbPath, currentVersion) {
   return classifyFingerprint(dbPath).kind === "drift" ? "schema" : null;
 }
 function readScannedByVersion(dbPath) {
-  if (dbPath === ":memory:" || !existsSync24(dbPath)) return null;
+  if (dbPath === ":memory:" || !existsSync25(dbPath)) return null;
   let raw = null;
   try {
     raw = new DatabaseSync8(dbPath, { readOnly: true });
@@ -18786,7 +19172,7 @@ async function askDriftReset(dbVersion, reason, policy) {
       hint: dim(DB_DRIFT_TEXTS.driftPromptHint)
     })
   );
-  const rl = createInterface4({ input: policy.stdin, output: policy.stderr });
+  const rl = createInterface5({ input: policy.stdin, output: policy.stderr });
   try {
     const answer = await new Promise(
       (resolveP) => rl.question(DB_DRIFT_TEXTS.driftPromptQuestion, resolveP)
@@ -19145,7 +19531,7 @@ var INIT_TEXTS = {
 // cli/commands/init.ts
 var InitCommand = class extends SmCommand {
   static paths = [["init"]];
-  static usage = Command17.Usage({
+  static usage = Command18.Usage({
     category: "Setup",
     description: "Bootstrap the current project: scaffold .skill-map/, provision DB, run first scan.",
     details: `
@@ -19164,16 +19550,16 @@ var InitCommand = class extends SmCommand {
       ["Preview what would be created", "$0 init --dry-run"]
     ]
   });
-  noScan = Option16.Boolean("--no-scan", false, {
+  noScan = Option17.Boolean("--no-scan", false, {
     description: "Skip the first scan after scaffolding."
   });
-  force = Option16.Boolean("--force", false, {
+  force = Option17.Boolean("--force", false, {
     description: "Overwrite an existing settings.json / settings.local.json / .skillmapignore."
   });
-  strict = Option16.Boolean("--strict", false, {
+  strict = Option17.Boolean("--strict", false, {
     description: "Strict mode: fail on any layered-loader warning AND promote frontmatter warnings to errors during the first scan. Same flag as sm scan / sm config."
   });
-  dryRun = Option16.Boolean("-n,--dry-run", false, {
+  dryRun = Option17.Boolean("-n,--dry-run", false, {
     description: "Preview the scope provisioning without touching the filesystem or the DB. Honours --force for the would-overwrite preview. Skips the first scan unconditionally; dry-run never persists."
   });
   // CLI orchestrator: paths setup + dry-run branch (delegated to
@@ -19426,7 +19812,7 @@ async function ensureGitignoreEntries(scopeRoot, entries) {
 }
 
 // cli/commands/history.ts
-import { Command as Command18, Option as Option17 } from "clipanion";
+import { Command as Command19, Option as Option18 } from "clipanion";
 
 // cli/i18n/history.texts.ts
 var HISTORY_TEXTS = {
@@ -19544,7 +19930,7 @@ function parseStatuses(input, stderr, ansi) {
 }
 var HistoryCommand = class extends SmCommand {
   static paths = [["history"]];
-  static usage = Command18.Usage({
+  static usage = Command19.Usage({
     category: "History",
     description: "Filter execution records. --json emits an array conforming to execution-record.schema.json.",
     details: `
@@ -19564,12 +19950,12 @@ var HistoryCommand = class extends SmCommand {
       ["Machine-readable, scoped to one node", "$0 history -n skills/foo.md --json"]
     ]
   });
-  node = Option17.String("-n", { required: false });
-  action = Option17.String("--action", { required: false });
-  status = Option17.String("--status", { required: false });
-  since = Option17.String("--since", { required: false });
-  until = Option17.String("--until", { required: false });
-  limit = Option17.String("--limit", { required: false });
+  node = Option18.String("-n", { required: false });
+  action = Option18.String("--action", { required: false });
+  status = Option18.String("--status", { required: false });
+  since = Option18.String("--since", { required: false });
+  until = Option18.String("--until", { required: false });
+  limit = Option18.String("--limit", { required: false });
   // CLI list verb: many optional filter flags (`--node`, `--action`,
   // `--status`, `--since`, `--until`, `--limit`, `--json`, `--quiet`)
   // each adding a guarded mutation to the filter or render path. Each
@@ -19620,7 +20006,7 @@ var HistoryCommand = class extends SmCommand {
 };
 var HistoryStatsCommand = class extends SmCommand {
   static paths = [["history", "stats"]];
-  static usage = Command18.Usage({
+  static usage = Command19.Usage({
     category: "History",
     description: "Aggregate counts, tokens, periods, top nodes, and error rates over state_executions. --json conforms to history-stats.schema.json.",
     details: `
@@ -19638,10 +20024,10 @@ var HistoryStatsCommand = class extends SmCommand {
       ["Top 5 nodes, JSON", "$0 history stats --top 5 --json"]
     ]
   });
-  since = Option17.String("--since", { required: false });
-  until = Option17.String("--until", { required: false });
-  period = Option17.String("--period", { required: false });
-  top = Option17.String("--top", { required: false });
+  since = Option18.String("--since", { required: false });
+  until = Option18.String("--until", { required: false });
+  period = Option18.String("--period", { required: false });
+  top = Option18.String("--top", { required: false });
   // CLI stats verb: range parsing + window flags + period flag + JSON
   // branch + per-period iteration. Each branch is a single-purpose
   // gate; the data work lives in `aggregateHistoryStats`.
@@ -19942,20 +20328,20 @@ function trimMs(iso) {
 
 // cli/commands/jobs.ts
 import { unlink as unlink2 } from "fs/promises";
-import { relative as relative6 } from "path";
-import { Command as Command19, Option as Option18 } from "clipanion";
+import { relative as relative8 } from "path";
+import { Command as Command20, Option as Option19 } from "clipanion";
 
 // kernel/jobs/orphan-files.ts
-import { readdirSync as readdirSync9, statSync as statSync8 } from "fs";
-import { join as join17, resolve as resolve33 } from "path";
+import { readdirSync as readdirSync10, statSync as statSync9 } from "fs";
+import { join as join17, resolve as resolve34 } from "path";
 function findOrphanJobFiles(jobsDir, referencedPaths) {
   let entries;
   try {
-    const stat3 = statSync8(jobsDir);
+    const stat3 = statSync9(jobsDir);
     if (!stat3.isDirectory()) {
       return { orphanFilePaths: [], referencedCount: referencedPaths.size };
     }
-    entries = readdirSync9(jobsDir, { withFileTypes: true });
+    entries = readdirSync10(jobsDir, { withFileTypes: true });
   } catch {
     return { orphanFilePaths: [], referencedCount: referencedPaths.size };
   }
@@ -19965,7 +20351,7 @@ function findOrphanJobFiles(jobsDir, referencedPaths) {
     if (!entry.isFile()) continue;
     const name = entry.name;
     if (!name.endsWith(".md")) continue;
-    const abs = resolve33(join17(jobsDir, name));
+    const abs = resolve34(join17(jobsDir, name));
     if (!referencedPaths.has(abs)) orphans.push(abs);
   }
   orphans.sort();
@@ -19994,7 +20380,7 @@ var JOBS_TEXTS = {
 // cli/commands/jobs.ts
 var JobPruneCommand = class extends SmCommand {
   static paths = [["job", "prune"]];
-  static usage = Command19.Usage({
+  static usage = Command20.Usage({
     category: "Jobs",
     description: "Retention GC for completed / failed jobs (per config policy). --orphan-files removes MD files with no DB row.",
     details: `
@@ -20021,10 +20407,10 @@ var JobPruneCommand = class extends SmCommand {
       ["Preview without touching the DB", "$0 job prune --dry-run --json"]
     ]
   });
-  orphanFiles = Option18.Boolean("--orphan-files", false, {
+  orphanFiles = Option19.Boolean("--orphan-files", false, {
     description: "Also remove MD files in .skill-map/jobs/ that have no matching state_jobs row."
   });
-  dryRun = Option18.Boolean("-n,--dry-run", false, {
+  dryRun = Option19.Boolean("-n,--dry-run", false, {
     description: "Report what would be pruned without touching the DB or filesystem."
   });
   async run() {
@@ -20107,7 +20493,7 @@ var JobPruneCommand = class extends SmCommand {
     let removed = 0;
     for (const p of paths) {
       try {
-        assertContained(jobsDir, relative6(jobsDir, p));
+        assertContained(jobsDir, relative8(jobsDir, p));
       } catch {
         continue;
       }
@@ -20162,7 +20548,7 @@ function formatPolicy(seconds) {
 }
 
 // cli/commands/list.ts
-import { Command as Command20, Option as Option19 } from "clipanion";
+import { Command as Command21, Option as Option20 } from "clipanion";
 
 // cli/i18n/list.texts.ts
 var LIST_TEXTS = {
@@ -20197,7 +20583,7 @@ var SORT_BY = {
 var PATH_COL_MAX_WIDTH = 60;
 var ListCommand = class extends SmCommand {
   static paths = [["list"]];
-  static usage = Command20.Usage({
+  static usage = Command21.Usage({
     category: "Browse",
     description: "Tabular listing of nodes. --json emits an array conforming to node.schema.json.",
     details: `
@@ -20221,11 +20607,11 @@ var ListCommand = class extends SmCommand {
       ["Filter by tag", "$0 list --tag urgent"]
     ]
   });
-  kind = Option19.String("--kind", { required: false });
-  issue = Option19.Boolean("--issue", false);
-  sortBy = Option19.String("--sort-by", { required: false });
-  limit = Option19.String("--limit", { required: false });
-  tag = Option19.String("--tag", { required: false });
+  kind = Option20.String("--kind", { required: false });
+  issue = Option20.Boolean("--issue", false);
+  sortBy = Option20.String("--sort-by", { required: false });
+  limit = Option20.String("--limit", { required: false });
+  tag = Option20.String("--tag", { required: false });
   async run() {
     const stderrAnsi = this.ansiFor("stderr");
     const flags = this.#parseFlags(stderrAnsi);
@@ -20409,7 +20795,7 @@ function formatDataRow(r, w, ansi) {
 }
 
 // cli/commands/orphans.ts
-import { Command as Command21, Option as Option20 } from "clipanion";
+import { Command as Command22, Option as Option21 } from "clipanion";
 
 // cli/i18n/orphans.texts.ts
 var ORPHANS_TEXTS = {
@@ -20492,7 +20878,7 @@ function isStringArray2(v) {
 }
 var OrphansCommand = class extends SmCommand {
   static paths = [["orphans"]];
-  static usage = Command21.Usage({
+  static usage = Command22.Usage({
     category: "Browse",
     description: "List orphan / auto-rename issues from the last scan. --json emits an array conforming to issue.schema.json.",
     details: `
@@ -20507,7 +20893,7 @@ var OrphansCommand = class extends SmCommand {
       ["Just the ambiguous ones, JSON", "$0 orphans --kind ambiguous --json"]
     ]
   });
-  kind = Option20.String("--kind", { required: false });
+  kind = Option21.String("--kind", { required: false });
   async run() {
     const stderrAnsi = this.ansiFor("stderr");
     let analyzerFilter = null;
@@ -20556,7 +20942,7 @@ var OrphansCommand = class extends SmCommand {
 };
 var OrphansReconcileCommand = class extends SmCommand {
   static paths = [["orphans", "reconcile"]];
-  static usage = Command21.Usage({
+  static usage = Command22.Usage({
     category: "Browse",
     description: "Migrate state_* FKs from an orphan path to a live node, resolving the orphan issue.",
     details: `
@@ -20572,9 +20958,9 @@ var OrphansReconcileCommand = class extends SmCommand {
       ["Reattach orphan history", "$0 orphans reconcile skills/old.md --to skills/new.md"]
     ]
   });
-  orphanPath = Option20.String({ required: true });
-  to = Option20.String("--to", { required: true });
-  dryRun = Option20.Boolean("-n,--dry-run", false);
+  orphanPath = Option21.String({ required: true });
+  to = Option21.String("--to", { required: true });
+  dryRun = Option21.Boolean("-n,--dry-run", false);
   async run() {
     const dbPath = resolveDbPath({ db: this.db, ...defaultRuntimeContext() });
     const exit = requireDbOrExit(dbPath, this.context.stderr);
@@ -20675,7 +21061,7 @@ var OrphansReconcileCommand = class extends SmCommand {
 };
 var OrphansUndoRenameCommand = class extends SmCommand {
   static paths = [["orphans", "undo-rename"]];
-  static usage = Command21.Usage({
+  static usage = Command22.Usage({
     category: "Browse",
     description: "Reverse a medium- or ambiguous-confidence auto-rename. Migrates state_* FKs back, emits a new orphan on the prior path.",
     details: `
@@ -20695,10 +21081,10 @@ var OrphansUndoRenameCommand = class extends SmCommand {
       ["Undo an ambiguous, picking a candidate", "$0 orphans undo-rename skills/new.md --from skills/old-a.md"]
     ]
   });
-  newPath = Option20.String({ required: true });
-  from = Option20.String("--from", { required: false });
-  force = Option20.Boolean("--force", false);
-  dryRun = Option20.Boolean("-n,--dry-run", false);
+  newPath = Option21.String({ required: true });
+  from = Option21.String("--from", { required: false });
+  force = Option21.Boolean("--force", false);
+  dryRun = Option21.Boolean("-n,--dry-run", false);
   async run() {
     const dbPath = resolveDbPath({ db: this.db, ...defaultRuntimeContext() });
     const exit = requireDbOrExit(dbPath, this.context.stderr);
@@ -20921,7 +21307,7 @@ var ORPHANS_COMMANDS = [
 ];
 
 // cli/commands/plugins/list.ts
-import { Command as Command22, Option as Option21 } from "clipanion";
+import { Command as Command23, Option as Option22 } from "clipanion";
 
 // cli/i18n/plugins.texts.ts
 var PLUGINS_TEXTS = {
@@ -21192,9 +21578,9 @@ function sortPluginsForPresentation(plugins) {
 }
 
 // cli/commands/plugins/shared.ts
-import { resolve as resolve34 } from "path";
+import { resolve as resolve35 } from "path";
 function resolveSearchPaths2(opts, cwd) {
-  if (opts.pluginDir) return [resolve34(opts.pluginDir)];
+  if (opts.pluginDir) return [resolve35(opts.pluginDir)];
   return [defaultProjectPluginsDir({ cwd })];
 }
 async function buildResolver() {
@@ -21312,7 +21698,7 @@ function wrapText(text, maxWidth) {
 // cli/commands/plugins/list.ts
 var PluginsListCommand = class extends SmCommand {
   static paths = [["plugins", "list"]];
-  static usage = Command22.Usage({
+  static usage = Command23.Usage({
     category: "Plugins",
     description: "List discovered plugins, or one plugin's extensions.",
     details: `
@@ -21323,8 +21709,8 @@ var PluginsListCommand = class extends SmCommand {
       \`<plugin>/<ext>\` id is rejected with a redirect to \`sm plugins show\`.
     `
   });
-  id = Option21.String({ required: false });
-  pluginDir = Option21.String("--plugin-dir", { required: false });
+  id = Option22.String({ required: false });
+  pluginDir = Option22.String("--plugin-dir", { required: false });
   async run() {
     const plugins = await loadAll({ pluginDir: this.pluginDir });
     const resolveEnabled = await buildResolver();
@@ -21566,10 +21952,10 @@ function renderExtensionItems(items) {
 }
 
 // cli/commands/plugins/show.ts
-import { Command as Command23, Option as Option22 } from "clipanion";
+import { Command as Command24, Option as Option23 } from "clipanion";
 var PluginsShowCommand = class extends SmCommand {
   static paths = [["plugins", "show"]];
-  static usage = Command23.Usage({
+  static usage = Command24.Usage({
     category: "Plugins",
     description: "Show a single extension's detail.",
     details: `
@@ -21582,8 +21968,8 @@ var PluginsShowCommand = class extends SmCommand {
       accept resolves cleanly here too.
     `
   });
-  id = Option22.String({ required: true });
-  pluginDir = Option22.String("--plugin-dir", { required: false });
+  id = Option23.String({ required: true });
+  pluginDir = Option23.String("--plugin-dir", { required: false });
   async run() {
     const plugins = await loadAll({ pluginDir: this.pluginDir });
     const resolveEnabled = await buildResolver();
@@ -21724,7 +22110,7 @@ function renderExtensionFields(meta) {
 }
 
 // cli/commands/plugins/doctor.ts
-import { Command as Command24, Option as Option23 } from "clipanion";
+import { Command as Command25, Option as Option24 } from "clipanion";
 var CONTRIB_ERROR_SAMPLE_CAP = 3;
 var STATUS_ORDER = [
   "enabled",
@@ -21737,12 +22123,12 @@ var STATUS_ORDER = [
 ];
 var PluginsDoctorCommand = class extends SmCommand {
   static paths = [["plugins", "doctor"]];
-  static usage = Command24.Usage({
+  static usage = Command25.Usage({
     category: "Plugins",
     description: "Run the full load pass and summarise by failure mode.",
     details: "Exit code 0 when every plugin loads or is intentionally disabled; 1 when any plugin is in an error / incompat state."
   });
-  pluginDir = Option23.String("--plugin-dir", { required: false });
+  pluginDir = Option24.String("--plugin-dir", { required: false });
   async run() {
     const plugins = await loadAll({ pluginDir: this.pluginDir });
     const resolveEnabled = await buildResolver();
@@ -22195,13 +22581,13 @@ function groupContributionErrorsByPlugin(errors) {
 }
 
 // cli/commands/plugins/toggle.ts
-import { Command as Command25, Option as Option24 } from "clipanion";
+import { Command as Command26, Option as Option25 } from "clipanion";
 var TogglePluginsBase = class extends SmCommand {
-  all = Option24.Boolean("--all", false);
-  yes = Option24.Boolean("--yes,-y", false, {
+  all = Option25.Boolean("--all", false);
+  yes = Option25.Boolean("--yes,-y", false, {
     description: "Skip the interactive confirm when a bare plugin id (or --all) fans the toggle out across multiple extensions."
   });
-  ids = Option24.Rest({ name: "ids" });
+  ids = Option25.Rest({ name: "ids" });
   async toggle(enabled) {
     const verb = enabled ? "enable" : "disable";
     const stderrAnsi = this.ansiFor("stderr");
@@ -22424,7 +22810,7 @@ async function purgeContributionsFor(adapter, id) {
 }
 var PluginsEnableCommand = class extends TogglePluginsBase {
   static paths = [["plugins", "enable"]];
-  static usage = Command25.Usage({
+  static usage = Command26.Usage({
     category: "Plugins",
     description: "Enable one or more extensions (or --all). Persists in config_plugins.",
     details: `
@@ -22452,7 +22838,7 @@ var PluginsEnableCommand = class extends TogglePluginsBase {
 };
 var PluginsDisableCommand = class extends TogglePluginsBase {
   static paths = [["plugins", "disable"]];
-  static usage = Command25.Usage({
+  static usage = Command26.Usage({
     category: "Plugins",
     description: "Disable one or more extensions (or --all). Persists in config_plugins; does not delete files.",
     details: `
@@ -22507,9 +22893,9 @@ function resolveBareToggle(id, catalogue) {
 }
 
 // cli/commands/plugins/create.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync5, writeFileSync } from "fs";
-import { dirname as dirname17, join as join18, resolve as resolve35 } from "path";
-import { Command as Command26, Option as Option25 } from "clipanion";
+import { existsSync as existsSync26, mkdirSync as mkdirSync5, writeFileSync } from "fs";
+import { dirname as dirname18, join as join18, resolve as resolve36 } from "path";
+import { Command as Command27, Option as Option26 } from "clipanion";
 
 // cli/commands/plugins/scaffold/action.ts
 function indexStub(extId) {
@@ -22914,7 +23300,7 @@ function generateScaffold(kind, pluginId, specVersion) {
 // cli/commands/plugins/create.ts
 var PluginsCreateCommand = class extends SmCommand {
   static paths = [["plugins", "create"]];
-  static usage = Command26.Usage({
+  static usage = Command27.Usage({
     category: "Plugins",
     description: "Scaffold a new plugin directory.",
     details: "Emits plugin.json + a per-kind extension stub + README. `<kind>` is one of: provider, extractor, analyzer, action, formatter, hook. The extractor stub ships one view contribution (slot `card.footer.left`) and one setting (`string-list`); edit to taste. Use `sm plugins slots list` to browse the slot / input-type catalog.",
@@ -22926,10 +23312,10 @@ var PluginsCreateCommand = class extends SmCommand {
   });
   // First positional: the extension kind (required). Declared before
   // `pluginId` so clipanion assigns it the first positional slot.
-  kind = Option25.String({ required: true, name: "kind" });
-  pluginId = Option25.String({ required: true, name: "plugin-id" });
-  at = Option25.String("--at", { required: false });
-  force = Option25.Boolean("--force", false);
+  kind = Option26.String({ required: true, name: "kind" });
+  pluginId = Option26.String({ required: true, name: "plugin-id" });
+  at = Option26.String("--at", { required: false });
+  force = Option26.Boolean("--force", false);
   async run() {
     const ansi = this.ansiFor("stderr");
     const errGlyph = ansi.red("\u2715");
@@ -22958,8 +23344,8 @@ var PluginsCreateCommand = class extends SmCommand {
     const kind = this.kind;
     const ctx = defaultRuntimeContext();
     const baseDir = defaultProjectPluginsDir(ctx);
-    const targetDir = this.at ? resolve35(this.at) : join18(baseDir, this.pluginId);
-    if (existsSync25(targetDir) && !this.force) {
+    const targetDir = this.at ? resolve36(this.at) : join18(baseDir, this.pluginId);
+    if (existsSync26(targetDir) && !this.force) {
       this.printer.error(
         tx(PLUGINS_TEXTS.createRefuseOverwrite, {
           glyph: errGlyph,
@@ -22973,7 +23359,7 @@ var PluginsCreateCommand = class extends SmCommand {
     const files = generateScaffold(kind, this.pluginId, specVersion);
     for (const file of files) {
       const abs = join18(targetDir, file.relPath);
-      mkdirSync5(dirname17(abs), { recursive: true });
+      mkdirSync5(dirname18(abs), { recursive: true });
       writeFileSync(abs, file.contents);
     }
     const mainFile = `${kind}s/${this.pluginId}-${kind}/index.js`;
@@ -22988,7 +23374,7 @@ var PluginsCreateCommand = class extends SmCommand {
 };
 
 // cli/commands/plugins/slots.ts
-import { Command as Command27 } from "clipanion";
+import { Command as Command28 } from "clipanion";
 
 // cli/commands/plugins/slots-catalog.ts
 var VIEW_SLOTS_CATALOG = [
@@ -23024,7 +23410,7 @@ var INPUT_TYPES_CATALOG = [
 // cli/commands/plugins/slots.ts
 var PluginsSlotsListCommand = class extends SmCommand {
   static paths = [["plugins", "slots", "list"]];
-  static usage = Command27.Usage({
+  static usage = Command28.Usage({
     category: "Plugins",
     description: "Print the closed catalogs of view slots and input-types.",
     details: "Read-only. Use this when picking a slot / input-type for a new plugin."
@@ -23073,15 +23459,15 @@ var PluginsSlotsListCommand = class extends SmCommand {
 };
 
 // cli/commands/plugins/upgrade.ts
-import { Command as Command28, Option as Option26 } from "clipanion";
+import { Command as Command29, Option as Option27 } from "clipanion";
 var PluginsUpgradeCommand = class extends SmCommand {
   static paths = [["plugins", "upgrade"]];
-  static usage = Command28.Usage({
+  static usage = Command29.Usage({
     category: "Plugins",
     description: "Apply catalog migrations to plugin manifests.",
     details: "No migrations registered against catalog v1.0.0 yet; this verb is a no-op today. The structure exists so future slot renames / deprecations land without spec churn."
   });
-  pluginId = Option26.String({ required: false, name: "plugin-id" });
+  pluginId = Option27.String({ required: false, name: "plugin-id" });
   async run() {
     this.printer.data(
       "sm plugins upgrade: no migrations registered for catalog v1.0.0.\n  All loaded plugins are catalog-current.\n  Run `sm plugins doctor` to surface any incompatible-catalog status.\n"
@@ -23091,7 +23477,7 @@ var PluginsUpgradeCommand = class extends SmCommand {
 };
 
 // cli/commands/plugins/config.ts
-import { Command as Command29, Option as Option27 } from "clipanion";
+import { Command as Command30, Option as Option28 } from "clipanion";
 
 // cli/i18n/plugins-config.texts.ts
 var PLUGINS_CONFIG_TEXTS = {
@@ -23132,7 +23518,7 @@ var PLUGINS_CONFIG_TEXTS = {
 // cli/commands/plugins/config.ts
 var PluginsConfigCommand = class extends SmCommand {
   static paths = [["plugins", "config"]];
-  static usage = Command29.Usage({
+  static usage = Command30.Usage({
     category: "Plugins",
     description: "Read or write an extension's declared settings.",
     details: `
@@ -23147,13 +23533,13 @@ var PluginsConfigCommand = class extends SmCommand {
       Secret values are shown as <redacted>. Run \`sm scan\` to apply.
     `
   });
-  id = Option27.String({ required: true });
-  settingId = Option27.String({ required: false });
-  value = Option27.String({ required: false });
-  reset = Option27.Boolean("--reset", false, {
+  id = Option28.String({ required: true });
+  settingId = Option28.String({ required: false });
+  value = Option28.String({ required: false });
+  reset = Option28.Boolean("--reset", false, {
     description: "Remove the override for <settingId> so the manifest default applies."
   });
-  pluginDir = Option27.String("--plugin-dir", { required: false });
+  pluginDir = Option28.String("--plugin-dir", { required: false });
   // Read-only when listing; the write / reset paths emit their own
   // receipt. `sm config` exempts the config family from "done in <…>";
   // mirror that here for the read path. The write path keeps the line.
@@ -23474,8 +23860,8 @@ var PLUGIN_COMMANDS = [
 
 // cli/commands/refresh.ts
 import { readFile as readFile4 } from "fs/promises";
-import { resolve as resolve36 } from "path";
-import { Command as Command30, Option as Option28 } from "clipanion";
+import { resolve as resolve37 } from "path";
+import { Command as Command31, Option as Option29 } from "clipanion";
 
 // cli/i18n/refresh.texts.ts
 var REFRESH_TEXTS = {
@@ -23531,7 +23917,7 @@ var REFRESH_TEXTS = {
 // cli/commands/refresh.ts
 var RefreshCommand = class extends SmCommand {
   static paths = [["refresh"]];
-  static usage = Command30.Usage({
+  static usage = Command31.Usage({
     category: "Scan",
     description: "Refresh enrichment rows: granular (single node) or batch (every stale row).",
     details: `
@@ -23553,11 +23939,11 @@ var RefreshCommand = class extends SmCommand {
       ["Refresh every node with stale enrichments", "$0 refresh --stale"]
     ]
   });
-  nodePath = Option28.String({ name: "node", required: false });
-  stale = Option28.Boolean("--stale", false, {
+  nodePath = Option29.String({ name: "node", required: false });
+  stale = Option29.Boolean("--stale", false, {
     description: "Refresh every node carrying a stale enrichment row (no-op in this revision; reserved for future Action-prob enrichments)."
   });
-  noPlugins = Option28.Boolean("--no-plugins", false, {
+  noPlugins = Option29.Boolean("--no-plugins", false, {
     description: "Skip drop-in plugin discovery; use only the built-in extractor set."
   });
   // The remaining cyclomatic count comes from CLI ergonomics that don't
@@ -23782,7 +24168,7 @@ var RefreshCommand = class extends SmCommand {
       let body;
       try {
         assertContained(cwd, node.path);
-        const raw = await readFile4(resolve36(cwd, node.path), "utf8");
+        const raw = await readFile4(resolve37(cwd, node.path), "utf8");
         body = stripFrontmatterFence(raw);
       } catch (err) {
         if (!this.json) {
@@ -23855,13 +24241,13 @@ var IntentionalFailCommand = class extends SmCommand {
     setTimeout(() => {
       throw new Error(INTENTIONAL_FAIL_TEXTS.errorMessage);
     }, 0);
-    await new Promise((resolve43) => setTimeout(resolve43, 5e3));
+    await new Promise((resolve44) => setTimeout(resolve44, 5e3));
     return ExitCode.Issues;
   }
 };
 
 // cli/commands/scan.ts
-import { Command as Command32, Option as Option30 } from "clipanion";
+import { Command as Command33, Option as Option31 } from "clipanion";
 
 // kernel/util/format-bytes.ts
 var UNITS = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"];
@@ -24020,10 +24406,10 @@ var SCAN_TEXTS = {
 };
 
 // cli/commands/watch.ts
-import { Command as Command31, Option as Option29 } from "clipanion";
+import { Command as Command32, Option as Option30 } from "clipanion";
 
 // core/watcher/runtime.ts
-import { dirname as dirname18, isAbsolute as isAbsolute12, relative as relative7, resolve as resolve37, sep as sep6 } from "path";
+import { dirname as dirname19, isAbsolute as isAbsolute13, relative as relative9, resolve as resolve38, sep as sep6 } from "path";
 
 // core/runtime/fresh-resolver.ts
 async function buildFreshResolver(deps) {
@@ -24069,7 +24455,7 @@ function applyPriorStateToRunOptions(runOptions, priorState, changedPaths) {
   }
 }
 function toIncrementalPaths(events, roots, cwd) {
-  const absRoots = roots.map((r) => isAbsolute12(r) ? r : resolve37(cwd, r));
+  const absRoots = roots.map((r) => isAbsolute13(r) ? r : resolve38(cwd, r));
   const changed = /* @__PURE__ */ new Set();
   const removed = /* @__PURE__ */ new Set();
   for (const ev of events) {
@@ -24083,12 +24469,15 @@ function toIncrementalPaths(events, roots, cwd) {
 }
 function relativeFromRoots2(absolute, absRoots) {
   for (const root of absRoots) {
-    const rel = relative7(root, absolute);
-    if (rel === "" || rel.startsWith("..") || isAbsolute12(rel)) continue;
+    const rel = relative9(root, absolute);
+    if (rel === "" || rel.startsWith("..") || isAbsolute13(rel)) continue;
     return rel.split(sep6).join("/");
   }
   return null;
 }
+function resolveWatcherLens(cwd, composed) {
+  return resolveActiveProvider(cwd, composed?.providers ?? []).resolved;
+}
 function createWatcherRuntime(opts) {
   const events = opts.events ?? {};
   const cwd = opts.runtimeContext.cwd;
@@ -24196,7 +24585,14 @@ function createWatcherRuntime(opts) {
         overrideScanCeiling: opts.maxScanOverride ?? null,
         maxRenderNodes: cfg.scan.maxNodes,
         overrideMaxRenderNodes: opts.maxNodesOverride ?? null,
-        maxFileSizeBytes: cfg.scan.maxFileSizeBytes
+        maxFileSizeBytes: cfg.scan.maxFileSizeBytes,
+        // Resolve the active lens from the persisted config (settings.json)
+        // so a lens switched via `PATCH /api/active-provider` is honoured by
+        // the next watcher batch. Without an explicit value the orchestrator
+        // falls back to filesystem detection, which ignores the operator's
+        // choice (e.g. selecting `markdown` while `.claude/` is still on disk
+        // would re-detect `claude` and silently overwrite the chosen lens).
+        activeProvider: resolveWatcherLens(cwd, composed)
       };
       if (cfg.scan.referencePaths.length > 0) {
         const walk3 = walkReferencePaths(cfg.scan.referencePaths, cwd);
@@ -24317,7 +24713,7 @@ function createWatcherRuntime(opts) {
         roots: [
           cwd,
           // parent of `.skillmapignore`
-          dirname18(settingsPath)
+          dirname19(settingsPath)
           // parent of `.skill-map/settings.json`
         ],
         cwd,
@@ -24607,7 +25003,7 @@ async function runWatchLoop(opts) {
 }
 var WatchCommand = class extends SmCommand {
   static paths = [["watch"]];
-  static usage = Command31.Usage({
+  static usage = Command32.Usage({
     category: "Scan",
     description: "Watch roots and run an incremental scan after each debounced batch of filesystem events.",
     details: `
@@ -24631,25 +25027,25 @@ var WatchCommand = class extends SmCommand {
       ["Stream ScanResult per batch as ndjson", "$0 watch --json"]
     ]
   });
-  roots = Option29.Rest({ name: "roots" });
-  noTokens = Option29.Boolean("--no-tokens", false, {
+  roots = Option30.Rest({ name: "roots" });
+  noTokens = Option30.Boolean("--no-tokens", false, {
     description: "Skip per-node token counts (cl100k_base BPE)."
   });
-  strict = Option29.Boolean("--strict", false, {
+  strict = Option30.Boolean("--strict", false, {
     description: "Promote frontmatter-validation findings from warn to error inside each batch. Does not change the watcher exit code."
   });
-  noPlugins = Option29.Boolean("--no-plugins", false, {
+  noPlugins = Option30.Boolean("--no-plugins", false, {
     description: "Skip drop-in plugin discovery for the watcher session."
   });
-  maxConsecutiveFailures = Option29.String("--max-consecutive-failures", {
+  maxConsecutiveFailures = Option30.String("--max-consecutive-failures", {
     required: false,
     description: "Shut down with exit 2 after N consecutive batch failures (default 5; 0 disables the breaker)."
   });
-  maxScan = Option29.String("--max-scan", {
+  maxScan = Option30.String("--max-scan", {
     required: false,
     description: "Per-batch override of scan.maxScan (default 50000), the WALK-INTAKE ceiling. The scan walks, parses, analyzes, and reference-validates the full corpus up to this number. Bidirectional: raises OR lowers the ceiling. When a batch hits it, additional files are dropped in stable order and the UI surfaces the persistent truncation banner. Validation: integer >= 1."
   });
-  maxNodes = Option29.String("--max-nodes", {
+  maxNodes = Option30.String("--max-nodes", {
     required: false,
     description: "Per-batch override of scan.maxNodes (default 256), the MAP RENDER cap (pure metadata): it does NOT bound the scan, only the graph projection. Bidirectional: raises OR lowers the render cap. Validation: integer >= 1."
   });
@@ -24736,7 +25132,7 @@ function parseMaxNodesLimit(raw, stderr, noColor) {
 // cli/commands/scan.ts
 var ScanCommand = class extends SmCommand {
   static paths = [["scan"]];
-  static usage = Command32.Usage({
+  static usage = Command33.Usage({
     category: "Scan",
     description: "Scan roots for markdown nodes, run extractors and analyzers.",
     details: `
@@ -24771,39 +25167,39 @@ var ScanCommand = class extends SmCommand {
       ["What would the next incremental scan persist?", "$0 scan --changed -n --json"]
     ]
   });
-  roots = Option30.Rest({ name: "roots" });
-  noBuiltIns = Option30.Boolean("--no-built-ins", false, {
+  roots = Option31.Rest({ name: "roots" });
+  noBuiltIns = Option31.Boolean("--no-built-ins", false, {
     description: "Skip the built-in extension set. Yields a zero-filled ScanResult (kernel-empty-boot parity); skips DB persistence."
   });
-  noPlugins = Option30.Boolean("--no-plugins", false, {
+  noPlugins = Option31.Boolean("--no-plugins", false, {
     description: "Skip drop-in plugin discovery. Only the built-in set runs. Combine with --no-built-ins for a fully empty pipeline."
   });
-  noTokens = Option30.Boolean("--no-tokens", false, {
+  noTokens = Option31.Boolean("--no-tokens", false, {
     description: "Skip per-node token counts (cl100k_base BPE). Leaves node.tokens undefined; spec-valid since the field is optional."
   });
-  dryRun = Option30.Boolean("-n,--dry-run", false, {
+  dryRun = Option31.Boolean("-n,--dry-run", false, {
     description: "Run the scan in memory and skip every DB write. Combined with --changed, still opens the DB read-side to load the prior snapshot."
   });
-  changed = Option30.Boolean("--changed", false, {
+  changed = Option31.Boolean("--changed", false, {
     description: "Incremental scan: reuse unchanged nodes from the persisted prior snapshot. Degrades to a full scan if no prior snapshot exists."
   });
-  allowEmpty = Option30.Boolean("--allow-empty", false, {
+  allowEmpty = Option31.Boolean("--allow-empty", false, {
     description: "Allow a zero-result scan to wipe an already-populated DB (replace-all replace by zero rows). Off by default to avoid the typo-trap where an invalid root silently clears your data."
   });
-  strict = Option30.Boolean("--strict", false, {
+  strict = Option31.Boolean("--strict", false, {
     description: "Promote frontmatter-validation findings from warn to error (exit code 1 on any violation). Overrides scan.strict from config when both are set."
   });
-  watch = Option30.Boolean("--watch", false, {
+  watch = Option31.Boolean("--watch", false, {
     description: "Long-running mode: watch the roots and trigger an incremental scan after each debounced batch of filesystem events. Alias of `sm watch`."
   });
-  yes = Option30.Boolean("--yes", false, {
+  yes = Option31.Boolean("--yes", false, {
     description: "Non-interactive mode. For ambiguous activeProvider auto-detect, multiple provider markers (.claude/, .codex/, AGENTS.md, .cursor/) under the scan tree exit non-zero instead of prompting; set the lens manually via `sm config set activeProvider <id>` and re-run. Also auto-confirms the pre-1.0 schema-drift rebuild (when the DB was written by a different skill-map major.minor it is deleted and regenerated) instead of prompting."
   });
-  maxScan = Option30.String("--max-scan", {
+  maxScan = Option31.String("--max-scan", {
     required: false,
     description: "Per-invocation override of `scan.maxScan` (default 50000). The WALK-INTAKE ceiling: the scan walks, parses, analyzes, and reference-validates the full corpus up to this number. Bidirectional: raises OR lowers the ceiling. When the walker hits it, additional files are dropped in stable order and the scan is marked truncated in scan_meta (the UI raises a persistent banner pointing at the .skillmapignore editor in Settings \u2192 Project). Validation: integer >= 1."
   });
-  maxNodes = Option30.String("--max-nodes", {
+  maxNodes = Option31.String("--max-nodes", {
     required: false,
     description: "Per-invocation override of `scan.maxNodes` (default 256). The MAP RENDER cap (pure metadata): it does NOT bound the scan, only how many nodes the graph view projects onto the canvas. Bidirectional: raises OR lowers the render cap. Validation: integer >= 1."
   });
@@ -25164,10 +25560,10 @@ function capOverrides(caps) {
 
 // cli/commands/scan-compare.ts
 import { access, readFile as readFile5 } from "fs/promises";
-import { Command as Command33, Option as Option31 } from "clipanion";
+import { Command as Command34, Option as Option32 } from "clipanion";
 var ScanCompareCommand = class extends SmCommand {
   static paths = [["scan", "compare-with"]];
-  static usage = Command33.Usage({
+  static usage = Command34.Usage({
     category: "Scan",
     description: "Run a fresh scan in memory and emit a delta against the saved ScanResult dump at <dump>. Read-only.",
     details: `
@@ -25195,15 +25591,15 @@ var ScanCompareCommand = class extends SmCommand {
       ["JSON output for tooling", "$0 scan compare-with baseline.json --json"]
     ]
   });
-  dump = Option31.String({ required: true });
-  roots = Option31.Rest({ name: "roots" });
-  noTokens = Option31.Boolean("--no-tokens", false, {
+  dump = Option32.String({ required: true });
+  roots = Option32.Rest({ name: "roots" });
+  noTokens = Option32.Boolean("--no-tokens", false, {
     description: "Skip per-node token counts during the fresh scan."
   });
-  strict = Option31.Boolean("--strict", false, {
+  strict = Option32.Boolean("--strict", false, {
     description: "Promote layered-config warnings and frontmatter-validation findings from warn to error."
   });
-  noPlugins = Option31.Boolean("--no-plugins", false, {
+  noPlugins = Option32.Boolean("--no-plugins", false, {
     description: "Skip drop-in plugin discovery."
   });
   // Cyclomatic count comes from CLI ergonomics: 3 distinct try/catch
@@ -25409,13 +25805,13 @@ function renderDeltaIssues(issues) {
 
 // cli/commands/serve.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync31 } from "fs";
-import { Command as Command34, Option as Option32 } from "clipanion";
+import { existsSync as existsSync32 } from "fs";
+import { Command as Command35, Option as Option33 } from "clipanion";
 
 // kernel/util/dev-mode.ts
 import { sep as sep7 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
-var SELF_PATH = fileURLToPath5(import.meta.url);
+import { fileURLToPath as fileURLToPath6 } from "url";
+var SELF_PATH = fileURLToPath6(import.meta.url);
 var IS_DEV_BUILD = isDevBuildFromPath(SELF_PATH, sep7);
 function isDevBuildFromPath(filePath, separator = sep7) {
   return !filePath.includes(`${separator}node_modules${separator}`);
@@ -26371,7 +26767,7 @@ function contentTypeFor(format) {
 }
 
 // server/health.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 var FALLBACK_SCHEMA_VERSION = "1";
 function buildHealth(deps) {
   const dev = isDevBuild();
@@ -26380,7 +26776,7 @@ function buildHealth(deps) {
     schemaVersion: FALLBACK_SCHEMA_VERSION,
     specVersion: deps.specVersion,
     implVersion: VERSION,
-    db: existsSync26(deps.dbPath) ? "present" : "missing",
+    db: existsSync27(deps.dbPath) ? "present" : "missing",
     cwd: deps.cwd,
     dbPath: deps.dbPath,
     // Only emit when truthy so a published install keeps the wire
@@ -26513,9 +26909,9 @@ import { HTTPException as HTTPException8 } from "hono/http-exception";
 // server/node-body.ts
 import { constants as fsConstants2 } from "fs";
 import { open } from "fs/promises";
-import { isAbsolute as isAbsolute13, resolve as resolvePath2, relative as relativePath, sep as sep8 } from "path";
+import { isAbsolute as isAbsolute14, resolve as resolvePath2, relative as relativePath, sep as sep8 } from "path";
 async function readNodeBody(cwd, relPath) {
-  if (isAbsolute13(relPath)) return null;
+  if (isAbsolute14(relPath)) return null;
   const absRoot = resolvePath2(cwd);
   const absFile = resolvePath2(absRoot, relPath);
   const rel = relativePath(absRoot, absFile);
@@ -27502,12 +27898,12 @@ var parsePatchBody2 = makeBodyValidator(PATCH_BODY_SCHEMA, {
 import { HTTPException as HTTPException12 } from "hono/http-exception";
 
 // server/util/skillmapignore-io.ts
-import { existsSync as existsSync27, readFileSync as readFileSync18, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve38 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync18, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve39 } from "path";
 var IGNORE_FILENAME2 = ".skillmapignore";
 function readPatterns(cwd) {
-  const path = resolve38(cwd, IGNORE_FILENAME2);
-  if (!existsSync27(path)) return [];
+  const path = resolve39(cwd, IGNORE_FILENAME2);
+  if (!existsSync28(path)) return [];
   let raw;
   try {
     raw = readFileSync18(path, "utf8");
@@ -27517,8 +27913,8 @@ function readPatterns(cwd) {
   return raw.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
 }
 function writePatterns(cwd, nextPatterns) {
-  const path = resolve38(cwd, IGNORE_FILENAME2);
-  const prior = existsSync27(path) ? safeRead(path) : "";
+  const path = resolve39(cwd, IGNORE_FILENAME2);
+  const prior = existsSync28(path) ? safeRead(path) : "";
   const content = buildContent(prior, nextPatterns);
   writeFileSync2(path, content, "utf8");
 }
@@ -27679,7 +28075,7 @@ var parsePatchBody3 = makeBodyValidator(PATCH_BODY_SCHEMA2, {
 });
 
 // server/routes/project-preferences.ts
-import { statSync as statSync9 } from "fs";
+import { statSync as statSync10 } from "fs";
 import { HTTPException as HTTPException13 } from "hono/http-exception";
 function registerProjectPreferencesRoute(app, deps) {
   app.get("/api/project-preferences", (c) => {
@@ -27855,7 +28251,7 @@ function formatPathDetail(path, cwd) {
 function isExistingDirectory(entry, cwd) {
   const abs = resolveScanPath(entry, cwd);
   try {
-    return statSync9(abs).isDirectory();
+    return statSync10(abs).isDirectory();
   } catch {
     return false;
   }
@@ -27897,7 +28293,7 @@ var parsePatchBody4 = makeBodyValidator(PATCH_BODY_SCHEMA3, {
 });
 
 // server/routes/active-provider.ts
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import { HTTPException as HTTPException14 } from "hono/http-exception";
 function registerActiveProviderRoute(app, deps) {
   app.get("/api/active-provider", async (c) => {
@@ -27927,7 +28323,6 @@ async function resolveSelectableProviders(deps) {
   });
   const selectable = /* @__PURE__ */ new Set();
   for (const provider of deps.providers) {
-    if (provider.presentation?.comingSoon === true) continue;
     if (isPluginExtensionEnabled(provider, resolveEnabled)) {
       selectable.add(provider.id);
     }
@@ -27946,7 +28341,7 @@ function applyLensSwitch(deps, newValue) {
     });
   }
   const dbPath = resolveDbPath({ db: void 0, cwd });
-  if (!existsSync28(dbPath)) return { dropped: null };
+  if (!existsSync29(dbPath)) return { dropped: null };
   const dropResult = dropScanZone(dbPath);
   return {
     dropped: {
@@ -27976,7 +28371,7 @@ var parsePatchBody5 = makeBodyValidator(PATCH_BODY_SCHEMA4, {
 
 // server/routes/actions.ts
 import { HTTPException as HTTPException16 } from "hono/http-exception";
-import { resolve as resolve39 } from "path";
+import { resolve as resolve40 } from "path";
 
 // server/routes/node-loader.ts
 import { HTTPException as HTTPException15 } from "hono/http-exception";
@@ -28036,7 +28431,7 @@ function registerActionsRoutes(app, deps) {
     let absPath;
     try {
       assertContained(deps.runtimeContext.cwd, node.path);
-      absPath = resolve39(deps.runtimeContext.cwd, node.path);
+      absPath = resolve40(deps.runtimeContext.cwd, node.path);
     } catch (err) {
       throw new HTTPException16(400, { message: formatErrorMessage(err) });
     }
@@ -28144,14 +28539,14 @@ async function withScanMutex(fn) {
   if (inFlight !== null) {
     throw new ScanBusyError();
   }
-  let resolve43;
+  let resolve44;
   inFlight = new Promise((r) => {
-    resolve43 = r;
+    resolve44 = r;
   });
   try {
     return await fn();
   } finally {
-    resolve43();
+    resolve44();
     inFlight = null;
   }
 }
@@ -28667,7 +29062,7 @@ function registerUpdateStatusRoute(app, deps) {
 }
 
 // server/static.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import { readFile as readFile6 } from "fs/promises";
 import { extname, join as join19 } from "path";
 import { serveStatic } from "@hono/node-server/serve-static";
@@ -28722,7 +29117,7 @@ function createSpaFallback(opts) {
     if (c.req.method !== "GET" && c.req.method !== "HEAD") return c.notFound();
     if (opts.uiDist === null) return htmlResponse(c, placeholder);
     const indexPath = join19(opts.uiDist, INDEX_HTML);
-    if (!existsSync29(indexPath)) return htmlResponse(c, placeholder);
+    if (!existsSync30(indexPath)) return htmlResponse(c, placeholder);
     return fileResponse(c, indexPath);
   };
 }
@@ -29271,7 +29666,6 @@ function buildProviderRegistry(providers) {
     if (ui.emoji !== void 0) entry.emoji = ui.emoji;
     if (ui.icon !== void 0) entry.icon = ui.icon;
     if (ui.hideChip !== void 0) entry.hideChip = ui.hideChip;
-    if (ui.comingSoon !== void 0) entry.comingSoon = ui.comingSoon;
     registry[provider.id] = entry;
   }
   return registry;
@@ -29449,9 +29843,9 @@ function validateNoUi(noUi, uiDist) {
 }
 
 // server/paths.ts
-import { existsSync as existsSync30, statSync as statSync10 } from "fs";
-import { dirname as dirname19, isAbsolute as isAbsolute14, join as join20, resolve as resolve40 } from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
+import { existsSync as existsSync31, statSync as statSync11 } from "fs";
+import { dirname as dirname20, isAbsolute as isAbsolute15, join as join20, resolve as resolve41 } from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
 var DEFAULT_UI_REL = join20("ui", "dist", "ui", "browser");
 var PACKAGE_UI_REL = "ui";
 var INDEX_HTML2 = "index.html";
@@ -29461,13 +29855,13 @@ function resolveDefaultUiDist(ctx) {
   return walkUpForUi(ctx.cwd);
 }
 function resolveExplicitUiDist(ctx, raw) {
-  return isAbsolute14(raw) ? raw : resolve40(ctx.cwd, raw);
+  return isAbsolute15(raw) ? raw : resolve41(ctx.cwd, raw);
 }
 function isUiBundleDir(path) {
-  if (!existsSync30(path)) return false;
+  if (!existsSync31(path)) return false;
   try {
-    if (!statSync10(path).isDirectory()) return false;
-    return existsSync30(join20(path, INDEX_HTML2));
+    if (!statSync11(path).isDirectory()) return false;
+    return existsSync31(join20(path, INDEX_HTML2));
   } catch {
     return false;
   }
@@ -29475,7 +29869,7 @@ function isUiBundleDir(path) {
 function resolvePackageBundledUi() {
   let here;
   try {
-    here = dirname19(fileURLToPath6(import.meta.url));
+    here = dirname20(fileURLToPath7(import.meta.url));
   } catch {
     return null;
   }
@@ -29488,18 +29882,18 @@ function resolvePackageBundledUiFrom(here) {
     if (isUiBundleDir(candidate)) return candidate;
     const distHere = join20(current, "dist", PACKAGE_UI_REL);
     if (isUiBundleDir(distHere)) return distHere;
-    const parent = dirname19(current);
+    const parent = dirname20(current);
     if (parent === current) return null;
     current = parent;
   }
   return null;
 }
 function walkUpForUi(startDir) {
-  let current = resolve40(startDir);
+  let current = resolve41(startDir);
   for (let i = 0; i < 64; i++) {
     const candidate = join20(current, DEFAULT_UI_REL);
     if (isUiBundleDir(candidate)) return candidate;
-    const parent = dirname19(current);
+    const parent = dirname20(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -29795,169 +30189,10 @@ var SERVE_TEXTS = {
   driftDeclined: "{{glyph}}  sm serve: cache rebuild declined; the {{dbVersion}} cache cannot be reused on {{currentVersion}} ({{reason}}).\n   {{hint}}\n"
 };
 
-// cli/util/serve-banner.ts
-import { relative as relative8, isAbsolute as isAbsolute15 } from "path";
-var ESC2 = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  underline: "\x1B[4m",
-  /** 256-color violet (xterm 141). */
-  violet: "\x1B[38;5;141m",
-  /** 256-color green (xterm 42). */
-  green: "\x1B[38;5;42m",
-  /** 256-color yellow (xterm 214), matches `cli/util/ansi.ts:yellow`. */
-  yellow: "\x1B[38;5;214m"
-};
-var LOGO_LINES = [
-  "  ____  _    _ _ _   __  __             ",
-  " / ___|| | _(_) | | |  \\/  | __ _ _ __  ",
-  " \\___ \\| |/ / | | | | |\\/| |/ _` | '_ \\ ",
-  "  ___) |   <| | | | | |  | | (_| | |_) |",
-  " |____/|_|\\_\\_|_|_| |_|  |_|\\__,_| .__/ ",
-  "                                 |_|    "
-];
-var LOGO_WIDTH = 40;
-function renderBanner(input) {
-  const url = `http://${input.host}:${input.port}`;
-  const dbDisplay = formatDbPath(input.dbPath, input.cwd);
-  const browserLine = input.openBrowser ? "Opening browser\u2026  Press Ctrl+C to stop." : `Visit ${url}/ in your browser.  Press Ctrl+C to stop.`;
-  if (!input.isTTY) {
-    return renderFlat({
-      host: input.host,
-      port: input.port,
-      dbPath: input.dbPath,
-      openBrowser: input.openBrowser,
-      dev: input.dev === true
-    });
-  }
-  return renderFiglet({
-    version: input.version,
-    url,
-    dbDisplay,
-    pathDisplay: formatCwdPath(input.cwd),
-    browserLine,
-    colorEnabled: input.colorEnabled,
-    referencePaths: input.referencePaths ?? [],
-    dev: input.dev === true
-  });
-}
-function resolveColorEnabled(opts) {
-  if (opts.noColorFlag) return false;
-  const noColor = opts.env["NO_COLOR"];
-  if (noColor !== void 0 && noColor !== "") return false;
-  const forceColor = opts.env["FORCE_COLOR"];
-  if (forceColor !== void 0 && forceColor !== "") return true;
-  return opts.isTTY;
-}
-function renderFlat(input) {
-  const safeHost = sanitizeForTerminal(input.host);
-  const safeDb = sanitizeForTerminal(input.dbPath);
-  const url = `http://${safeHost}:${input.port}`;
-  const devSuffix = input.dev ? " [dev]" : "";
-  const linesOut = [];
-  linesOut.push(`sm serve${devSuffix}: listening on ${url} (db=${safeDb})`);
-  if (input.openBrowser) {
-    linesOut.push(`sm serve: opening ${url}/ in your browser. Press Ctrl+C to stop.`);
-  } else {
-    linesOut.push(`sm serve: visit ${url}/ in your browser. Press Ctrl+C to stop.`);
-  }
-  return linesOut.join("\n") + "\n";
-}
-function renderLogoBlock(input) {
-  const { dimOpen, dimClose, violetOpen, violetClose } = resolveAnsi(input.colorEnabled);
-  const logoLines = LOGO_LINES.map((line) => `${violetOpen}${line}${violetClose}`);
-  const versionText = `v${input.version}`;
-  const versionPad = Math.max(0, LOGO_WIDTH - versionText.length);
-  const versionLine = `${" ".repeat(versionPad)}${dimOpen}${versionText}${dimClose}`;
-  return `${logoLines.join("\n")}
-
-${versionLine}
-
-`;
-}
-function renderFiglet(input) {
-  const {
-    dimOpen,
-    dimClose,
-    greenUnderline,
-    greenUnderlineClose,
-    violetOpen,
-    violetClose,
-    yellowOpen,
-    yellowClose
-  } = resolveAnsi(input.colorEnabled);
-  const logoLines = LOGO_LINES.map((line) => `${violetOpen}${line}${violetClose}`);
-  const versionText = `v${input.version}`;
-  const devText = "[dev]";
-  const versionWidth = input.dev ? devText.length : versionText.length;
-  const versionPad = Math.max(0, LOGO_WIDTH - versionWidth);
-  const versionLine = input.dev ? `${" ".repeat(versionPad)}${yellowOpen}${devText}${yellowClose}` : `${" ".repeat(versionPad)}${dimOpen}${versionText}${dimClose}`;
-  const lines = [];
-  lines.push(...logoLines);
-  lines.push("");
-  lines.push(versionLine);
-  lines.push("");
-  lines.push(`  ${dimOpen}Server${dimClose}   ${greenUnderline}${input.url}${greenUnderlineClose}`);
-  lines.push(`  ${dimOpen}Path${dimClose}     ${input.pathDisplay}`);
-  lines.push(`  ${dimOpen}DB${dimClose}       ${input.dbDisplay}`);
-  lines.push(...renderListRows("Refs", input.referencePaths, dimOpen, dimClose));
-  lines.push("");
-  lines.push(`  ${dimOpen}${input.browserLine}${dimClose}`);
-  lines.push("");
-  return lines.join("\n") + "\n";
-}
-function renderListRows(label, values, dimOpen, dimClose) {
-  if (values.length === 0) return [];
-  const out = [];
-  const labelPad = " ".repeat(Math.max(1, 9 - label.length));
-  const continuationPad = " ".repeat(11);
-  out.push(`  ${dimOpen}${label}${dimClose}${labelPad}${sanitizeForTerminal(values[0])}`);
-  for (let i = 1; i < values.length; i += 1) {
-    out.push(`${continuationPad}${sanitizeForTerminal(values[i])}`);
-  }
-  return out;
-}
-var EMPTY_ANSI = {
-  dimOpen: "",
-  dimClose: "",
-  greenUnderline: "",
-  greenUnderlineClose: "",
-  violetOpen: "",
-  violetClose: "",
-  yellowOpen: "",
-  yellowClose: ""
-};
-var ENABLED_ANSI = {
-  dimOpen: ESC2.dim,
-  dimClose: ESC2.reset,
-  greenUnderline: `${ESC2.green}${ESC2.underline}`,
-  greenUnderlineClose: ESC2.reset,
-  violetOpen: ESC2.violet,
-  violetClose: ESC2.reset,
-  yellowOpen: ESC2.yellow,
-  yellowClose: ESC2.reset
-};
-function resolveAnsi(colorEnabled) {
-  return colorEnabled ? ENABLED_ANSI : EMPTY_ANSI;
-}
-function formatDbPath(dbPath, cwd) {
-  const safe = sanitizeForTerminal(dbPath);
-  if (!isAbsolute15(safe)) return safe;
-  const rel = relative8(cwd, safe);
-  if (rel === "" || rel.startsWith("..") || isAbsolute15(rel)) {
-    return safe;
-  }
-  return rel;
-}
-function formatCwdPath(cwd) {
-  return sanitizeForTerminal(cwd);
-}
-
 // cli/commands/serve.ts
 var ServeCommand = class extends SmCommand {
   static paths = [["serve"]];
-  static usage = Command34.Usage({
+  static usage = Command35.Usage({
     category: "Setup",
     description: "Start the Hono BFF (single-port: REST + WebSocket + SPA bundle).",
     details: `
@@ -29981,18 +30216,18 @@ var ServeCommand = class extends SmCommand {
       ["Point at a pre-built UI bundle", "$0 serve --ui-dist ./ui/dist/browser"]
     ]
   });
-  port = Option32.String("--port", {
+  port = Option33.String("--port", {
     required: false,
     description: "Listening port (default 4242). 0 = OS-assigned."
   });
-  host = Option32.String("--host", {
+  host = Option33.String("--host", {
     required: false,
     description: "Listening host (default 127.0.0.1). Loopback-only enforced when --dev-cors is set."
   });
-  noBuiltIns = Option32.Boolean("--no-built-ins", false, {
+  noBuiltIns = Option33.Boolean("--no-built-ins", false, {
     description: "Skip built-in plugin registration (parity with sm scan --no-built-ins)."
   });
-  noPlugins = Option32.Boolean("--no-plugins", false, {
+  noPlugins = Option33.Boolean("--no-plugins", false, {
     description: "Skip drop-in plugin discovery."
   });
   // `Option.Boolean('--open', true)`, Clipanion's parser auto-derives
@@ -30002,35 +30237,35 @@ var ServeCommand = class extends SmCommand {
   // two registrations for the same flag and rejects the invocation
   // with "Ambiguous Syntax Error". Same convention shipped by every
   // other `--no-...` flag in the CLI tree.
-  open = Option32.Boolean("--open", true, {
+  open = Option33.Boolean("--open", true, {
     description: "Auto-open the SPA in the user's default browser after listen. --no-open opts out."
   });
-  devCors = Option32.Boolean("--dev-cors", false, {
+  devCors = Option33.Boolean("--dev-cors", false, {
     description: "Enable permissive CORS for the Angular dev-server proxy workflow."
   });
   // `--ui-dist` is intentionally undocumented in the Usage block above
   // (the demo build pipeline + tests rely on it; everyday users never
   // need it). Clipanion still exposes it on the parser; the Usage
   // omission is the "hidden" contract per the 14.1 brief.
-  uiDist = Option32.String("--ui-dist", { required: false, hidden: true });
-  noUi = Option32.Boolean("--no-ui", false, {
+  uiDist = Option33.String("--ui-dist", { required: false, hidden: true });
+  noUi = Option33.Boolean("--no-ui", false, {
     description: "Don't serve the Angular UI bundle. Use this when running the BFF alongside `ui:dev` (Angular dev server with HMR). The root `/` then renders an inline placeholder pointing the user at the dev server."
   });
-  noWatcher = Option32.Boolean("--no-watcher", false, {
+  noWatcher = Option33.Boolean("--no-watcher", false, {
     description: "Disable the chokidar-fed scan-and-broadcast loop. Use only for CI / read-only deployments."
   });
-  yes = Option32.Boolean("--yes", false, {
+  yes = Option33.Boolean("--yes", false, {
     description: "Skip the interactive prompt and rebuild the local cache when the on-disk DB has drifted (version skew or an inline schema change). Non-TTY invocations rebuild without asking regardless of this flag."
   });
   // `--watcher-debounce-ms` is undocumented sugar for advanced users
   // who want to tighten / relax the watcher's batching window without
   // editing settings.json. Hidden flag, the Usage block omits it.
-  watcherDebounceMs = Option32.String("--watcher-debounce-ms", { required: false, hidden: true });
-  maxScan = Option32.String("--max-scan", {
+  watcherDebounceMs = Option33.String("--watcher-debounce-ms", { required: false, hidden: true });
+  maxScan = Option33.String("--max-scan", {
     required: false,
     description: "Per-invocation override of scan.maxScan (default 50000), the WALK-INTAKE ceiling. The scan walks, parses, analyzes, and reference-validates the full corpus up to this number. Bidirectional: raises OR lowers the ceiling. Applies to every scan the server runs (initial watcher pass, debounced batches, POST /api/scan, GET /api/scan?fresh=1). Same flag is honoured on the bare `sm` invocation, which routes to `sm serve`."
   });
-  maxNodes = Option32.String("--max-nodes", {
+  maxNodes = Option33.String("--max-nodes", {
     required: false,
     description: "Per-invocation override of scan.maxNodes (default 256), the MAP RENDER cap (pure metadata): it does NOT bound the scan, only how many nodes the graph view projects onto the canvas. Bidirectional: raises OR lowers the render cap. Same flag is honoured on the bare `sm` invocation, which routes to `sm serve`."
   });
@@ -30060,7 +30295,7 @@ var ServeCommand = class extends SmCommand {
       return ExitCode.Error;
     }
     const dbPath = resolveDbPath({ db: this.db, ...runtimeCtx });
-    if (this.db !== void 0 && !existsSync31(dbPath)) {
+    if (this.db !== void 0 && !existsSync32(dbPath)) {
       this.printer.info(
         tx(SERVE_TEXTS.dbNotFound, {
           glyph: errGlyph,
@@ -30400,7 +30635,7 @@ function tryOpenBrowser(url, stderr, warnGlyph) {
 }
 
 // cli/commands/show.ts
-import { Command as Command35, Option as Option33 } from "clipanion";
+import { Command as Command36, Option as Option34 } from "clipanion";
 
 // cli/i18n/show.texts.ts
 var SHOW_TEXTS = {
@@ -30451,7 +30686,7 @@ var SHOW_TEXTS = {
 // cli/commands/show.ts
 var ShowCommand = class extends SmCommand {
   static paths = [["show"]];
-  static usage = Command35.Usage({
+  static usage = Command36.Usage({
     category: "Browse",
     description: "Node detail: weight, frontmatter, links, issues.",
     details: `
@@ -30467,7 +30702,7 @@ var ShowCommand = class extends SmCommand {
       ["Machine-readable detail", "$0 show .claude/agents/architect.md --json"]
     ]
   });
-  nodePath = Option33.String({ required: true });
+  nodePath = Option34.String({ required: true });
   async run() {
     const dbPath = resolveDbPath({ db: this.db, ...defaultRuntimeContext() });
     const exit = requireDbOrExit(dbPath, this.context.stderr);
@@ -30708,8 +30943,8 @@ function rankConfidenceForGrouping(c) {
 
 // cli/commands/sidecar.ts
 import { unlink as unlink3 } from "fs/promises";
-import { resolve as resolve41 } from "path";
-import { Command as Command36, Option as Option34 } from "clipanion";
+import { resolve as resolve42 } from "path";
+import { Command as Command37, Option as Option35 } from "clipanion";
 
 // cli/i18n/sidecar.texts.ts
 var SIDECAR_TEXTS = {
@@ -30790,7 +31025,7 @@ async function runWithSidecarConsent(bag, ansi, dispatch) {
 }
 var SidecarRefreshCommand = class extends SmCommand {
   static paths = [["sidecar", "refresh"]];
-  static usage = Command36.Usage({
+  static usage = Command37.Usage({
     category: "Actions",
     description: "Refresh a sidecar's `for.{bodyHash, frontmatterHash}` to match the live node. Does NOT bump the version.",
     details: `
@@ -30807,8 +31042,8 @@ var SidecarRefreshCommand = class extends SmCommand {
       ["Refresh a node's sidecar hashes", "$0 sidecar refresh .claude/agents/architect.md"]
     ]
   });
-  nodePath = Option34.String({ required: true });
-  yes = Option34.Boolean("--yes", false, {
+  nodePath = Option35.String({ required: true });
+  yes = Option35.Boolean("--yes", false, {
     description: "Confirm writing .sm sidecar files in this project (sets allowEditSmFiles=true on first run)."
   });
   async run() {
@@ -30866,7 +31101,7 @@ var SidecarRefreshCommand = class extends SmCommand {
     let absPath;
     try {
       assertContained(ctx.cwd, node.path);
-      absPath = resolve41(ctx.cwd, node.path);
+      absPath = resolve42(ctx.cwd, node.path);
     } catch (err) {
       this.printer.error(
         tx(SIDECAR_TEXTS.refreshFailed, { glyph: errGlyph, message: formatErrorMessage(err) })
@@ -30930,7 +31165,7 @@ var SidecarRefreshCommand = class extends SmCommand {
 };
 var SidecarPruneCommand = class extends SmCommand {
   static paths = [["sidecar", "prune"]];
-  static usage = Command36.Usage({
+  static usage = Command37.Usage({
     category: "Actions",
     description: "Delete orphan .sm files (sidecars whose accompanying .md no longer exists).",
     details: `
@@ -30952,8 +31187,8 @@ var SidecarPruneCommand = class extends SmCommand {
       ["Delete every orphan .sm file (non-interactive)", "$0 sidecar prune --yes"]
     ]
   });
-  dryRun = Option34.Boolean("-n,--dry-run", false);
-  yes = Option34.Boolean("--yes,--force", false, {
+  dryRun = Option35.Boolean("-n,--dry-run", false);
+  yes = Option35.Boolean("--yes,--force", false, {
     description: "Skip the interactive confirmation prompt. Required for non-interactive callers (CI, pre-commit hooks)."
   });
   // Complexity is from per-orphan handling, empty-set / dry-run /
@@ -31073,7 +31308,7 @@ var SidecarPruneCommand = class extends SmCommand {
 };
 var SidecarAnnotateCommand = class extends SmCommand {
   static paths = [["sidecar", "annotate"]];
-  static usage = Command36.Usage({
+  static usage = Command37.Usage({
     category: "Actions",
     description: "Scaffold an empty `<basename>.sm` next to a node ready for editing.",
     details: `
@@ -31091,9 +31326,9 @@ var SidecarAnnotateCommand = class extends SmCommand {
       ["Overwrite an existing one", "$0 sidecar annotate .claude/agents/architect.md --force"]
     ]
   });
-  nodePath = Option34.String({ required: true });
-  force = Option34.Boolean("--force", false);
-  yes = Option34.Boolean("--yes", false, {
+  nodePath = Option35.String({ required: true });
+  force = Option35.Boolean("--force", false);
+  yes = Option35.Boolean("--yes", false, {
     description: "Confirm writing .sm sidecar files in this project (sets allowEditSmFiles=true on first run)."
   });
   async run() {
@@ -31150,7 +31385,7 @@ var SidecarAnnotateCommand = class extends SmCommand {
     let absPath;
     try {
       assertContained(ctx.cwd, node.path);
-      absPath = resolve41(ctx.cwd, node.path);
+      absPath = resolve42(ctx.cwd, node.path);
     } catch (err) {
       this.printer.error(
         tx(SIDECAR_TEXTS.annotateFailed, { glyph: errGlyph, message: formatErrorMessage(err) })
@@ -31232,7 +31467,7 @@ var SIDECAR_COMMANDS = [
 ];
 
 // cli/commands/stubs.ts
-import { Command as Command37, Option as Option35 } from "clipanion";
+import { Command as Command38, Option as Option36 } from "clipanion";
 
 // cli/i18n/stubs.texts.ts
 var STUBS_TEXTS = {
@@ -31258,7 +31493,7 @@ var StubCommand = class extends SmCommand {
 };
 var DoctorCommand = class extends StubCommand {
   static paths = [["doctor"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     category: "Setup",
     description: planned("Diagnostic report: DB integrity, pending migrations, orphan rows, plugin status, runner availability.")
   });
@@ -31266,18 +31501,18 @@ var DoctorCommand = class extends StubCommand {
 };
 var FindingsCommand = class extends StubCommand {
   static paths = [["findings"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     category: "Browse",
     description: planned("Probabilistic findings: injection, stale summaries, low confidence.")
   });
-  kind = Option35.String("--kind", { required: false });
-  since = Option35.String("--since", { required: false });
-  threshold = Option35.String("--threshold", { required: false });
+  kind = Option36.String("--kind", { required: false });
+  since = Option36.String("--since", { required: false });
+  threshold = Option36.String("--threshold", { required: false });
   verbName = "findings";
 };
 var ActionsListCommand = class extends StubCommand {
   static paths = [["actions", "list"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     category: "Jobs",
     description: planned("Registered action types (manifest view).")
   });
@@ -31285,103 +31520,103 @@ var ActionsListCommand = class extends StubCommand {
 };
 var ActionsShowCommand = class extends StubCommand {
   static paths = [["actions", "show"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     category: "Jobs",
     description: planned("Full action manifest, including preconditions and expected duration.")
   });
-  id = Option35.String({ required: true });
+  id = Option36.String({ required: true });
   verbName = "actions show";
 };
 var JobSubmitCommand = class extends StubCommand {
   static paths = [["job", "submit"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     category: "Jobs",
     description: planned("Enqueue a single job or fan out to every matching node (--all).")
   });
-  action = Option35.String({ required: true });
-  node = Option35.String("-n", { required: false });
-  all = Option35.Boolean("--all", false);
+  action = Option36.String({ required: true });
+  node = Option36.String("-n", { required: false });
+  all = Option36.Boolean("--all", false);
   // CLI flag stays `--run`; field name is `runFlag` per the
   // shadow-avoidance convention documented on `SmCommand`.
-  runFlag = Option35.Boolean("--run", false);
-  force = Option35.Boolean("--force", false);
-  ttl = Option35.String("--ttl", { required: false });
-  priority = Option35.String("--priority", { required: false });
+  runFlag = Option36.Boolean("--run", false);
+  force = Option36.Boolean("--force", false);
+  ttl = Option36.String("--ttl", { required: false });
+  priority = Option36.String("--priority", { required: false });
   verbName = "job submit";
 };
 var JobListCommand = class extends StubCommand {
   static paths = [["job", "list"]];
-  static usage = Command37.Usage({ category: "Jobs", description: planned("List jobs.") });
-  status = Option35.String("--status", { required: false });
-  action = Option35.String("--action", { required: false });
-  node = Option35.String("--node", { required: false });
+  static usage = Command38.Usage({ category: "Jobs", description: planned("List jobs.") });
+  status = Option36.String("--status", { required: false });
+  action = Option36.String("--action", { required: false });
+  node = Option36.String("--node", { required: false });
   verbName = "job list";
 };
 var JobShowCommand = class extends StubCommand {
   static paths = [["job", "show"]];
-  static usage = Command37.Usage({ category: "Jobs", description: planned("Job detail: state, claim time, TTL, runner, content hash.") });
-  id = Option35.String({ required: true });
+  static usage = Command38.Usage({ category: "Jobs", description: planned("Job detail: state, claim time, TTL, runner, content hash.") });
+  id = Option36.String({ required: true });
   verbName = "job show";
 };
 var JobPreviewCommand = class extends StubCommand {
   static paths = [["job", "preview"]];
-  static usage = Command37.Usage({ category: "Jobs", description: planned("Render the job MD file without executing.") });
-  id = Option35.String({ required: true });
+  static usage = Command38.Usage({ category: "Jobs", description: planned("Render the job MD file without executing.") });
+  id = Option36.String({ required: true });
   verbName = "job preview";
 };
 var JobClaimCommand = class extends StubCommand {
   static paths = [["job", "claim"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     category: "Jobs",
     description: planned("Atomic primitive: return next queued job id, mark it running.")
   });
-  filter = Option35.String("--filter", { required: false });
+  filter = Option36.String("--filter", { required: false });
   verbName = "job claim";
 };
 var JobRunCommand = class extends StubCommand {
   static paths = [["job", "run"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     category: "Jobs",
     description: planned("Full CLI-runner loop: claim + spawn + record.")
   });
-  all = Option35.Boolean("--all", false);
-  max = Option35.String("--max", { required: false });
+  all = Option36.Boolean("--all", false);
+  max = Option36.String("--max", { required: false });
   verbName = "job run";
 };
 var JobStatusCommand = class extends StubCommand {
   static paths = [["job", "status"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     category: "Jobs",
     description: planned("Counts (per status) or single-job status.")
   });
-  id = Option35.String({ required: false });
+  id = Option36.String({ required: false });
   verbName = "job status";
 };
 var JobCancelCommand = class extends StubCommand {
   static paths = [["job", "cancel"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     category: "Jobs",
     description: planned("Force a running job to failed with reason user-cancelled.")
   });
-  id = Option35.String({ required: false });
-  all = Option35.Boolean("--all", false);
+  id = Option36.String({ required: false });
+  all = Option36.Boolean("--all", false);
   verbName = "job cancel";
 };
 var RecordCommand = class extends StubCommand {
   static paths = [["record"]];
-  static usage = Command37.Usage({
+  static usage = Command38.Usage({
     category: "Jobs",
     description: planned("Close a running job with success or failure. Nonce is the sole credential.")
   });
-  id = Option35.String("--id", { required: true });
-  nonce = Option35.String("--nonce", { required: true });
-  status = Option35.String("--status", { required: true });
-  report = Option35.String("--report", { required: false });
-  tokensIn = Option35.String("--tokens-in", { required: false });
-  tokensOut = Option35.String("--tokens-out", { required: false });
-  durationMs = Option35.String("--duration-ms", { required: false });
-  model = Option35.String("--model", { required: false });
-  error = Option35.String("--error", { required: false });
+  id = Option36.String("--id", { required: true });
+  nonce = Option36.String("--nonce", { required: true });
+  status = Option36.String("--status", { required: true });
+  report = Option36.String("--report", { required: false });
+  tokensIn = Option36.String("--tokens-in", { required: false });
+  tokensOut = Option36.String("--tokens-out", { required: false });
+  durationMs = Option36.String("--duration-ms", { required: false });
+  model = Option36.String("--model", { required: false });
+  error = Option36.String("--error", { required: false });
   verbName = "record";
 };
 var STUB_COMMANDS = [
@@ -31401,11 +31636,11 @@ var STUB_COMMANDS = [
 ];
 
 // cli/commands/tutorial.ts
-import { cpSync as cpSync2, existsSync as existsSync32, mkdirSync as mkdirSync6, readdirSync as readdirSync10, rmSync as rmSync2, statSync as statSync11 } from "fs";
-import { dirname as dirname20, join as join21, resolve as resolve42 } from "path";
-import { createInterface as createInterface5 } from "readline";
-import { fileURLToPath as fileURLToPath7 } from "url";
-import { Command as Command38, Option as Option36 } from "clipanion";
+import { cpSync as cpSync3, existsSync as existsSync33, mkdirSync as mkdirSync6, rmSync as rmSync2, statSync as statSync12 } from "fs";
+import { dirname as dirname21, join as join21, resolve as resolve43 } from "path";
+import { createInterface as createInterface6 } from "readline";
+import { fileURLToPath as fileURLToPath8 } from "url";
+import { Command as Command39, Option as Option37 } from "clipanion";
 
 // cli/i18n/tutorial.texts.ts
 var TUTORIAL_TEXTS = {
@@ -31428,14 +31663,8 @@ var TUTORIAL_TEXTS = {
   // default).
   promptHeader: "{{glyph}}  Which agent should host the tutorial skill?",
   promptOption: "     {{index}}) {{label}}: {{skillDir}}{{marker}}",
-  // Coming-soon Providers are listed for visibility but cannot be picked
-  // (no skillDir, a `(coming soon)` tag instead of a target path).
-  promptOptionComingSoon: "     {{index}}) {{label}}  (coming soon)",
   promptDefaultMarker: "  (default)",
   promptInput: "  Enter the number or provider id [default {{index}}]: ",
-  // Shown (and the prompt re-asked) when the tester picks a coming-soon
-  // entry: it is visible but not selectable yet.
-  promptComingSoonNotice: "  {{label}} is coming soon, not selectable yet. Pick {{defaultLabel}}.",
   // Prompt answer matched neither an index nor an id. Goes to stderr,
   // exit code 2. Mirrors the error shape: glyph + headline + dim hint.
   promptInvalid: "{{glyph}}  sm tutorial: that is not one of the listed providers\n   {{hint}}\n",
@@ -31473,7 +31702,7 @@ var TRIGGER_EN = "run the tutorial";
 var TRIGGER_ES = "ejecuta el tutorial";
 var TutorialCommand = class extends SmCommand {
   static paths = [["tutorial"]];
-  static usage = Command38.Usage({
+  static usage = Command39.Usage({
     category: "Setup",
     description: "Materialize an interactive tester tutorial as a Claude Code skill folder under `<cwd>/.claude/skills/`.",
     details: `
@@ -31486,27 +31715,36 @@ var TutorialCommand = class extends SmCommand {
       Does NOT require an initialized .skill-map/ project. Refuses to
       overwrite the target directory unless --force is passed. Takes no
       positional argument.
+
+      By default only ready providers are offered as destinations. Pass
+      --experimental to also offer experimental ones (e.g. agent-skills);
+      they ship disabled, so enable the chosen one with
+      \`sm plugins enable <id>\` before scanning under its lens.
     `,
     examples: [
       ["Materialize the tutorial skill in the cwd", "$0 tutorial"],
-      ["Overwrite an existing target directory", "$0 tutorial --force"]
+      ["Overwrite an existing target directory", "$0 tutorial --force"],
+      ["Offer experimental providers as destinations", "$0 tutorial --experimental"]
     ]
   });
   // Legacy positional catcher: the verb takes no positional argument any
   // more. Accept one so a stale `sm tutorial master` lands on a friendly
   // usage error (guarded in `run()`) instead of clipanion's generic
   // "extraneous argument" message.
-  legacyPositional = Option36.String({ required: false });
+  legacyPositional = Option37.String({ required: false });
   // Named `forProvider`, NOT `for` (reserved word). The CLI surface stays
   // `--for`; selects the destination Provider whose `scaffold.skillDir`
   // the skill is materialised under, skipping the interactive prompt.
-  forProvider = Option36.String("--for", {
+  forProvider = Option37.String("--for", {
     required: false,
     description: "Destination provider id (e.g. claude). Skips the prompt."
   });
-  force = Option36.Boolean("--force", false, {
+  force = Option37.Boolean("--force", false, {
     description: "Overwrite an existing target directory without prompting."
   });
+  experimental = Option37.Boolean("--experimental", false, {
+    description: "Offer experimental providers (e.g. agent-skills) as destinations. They ship disabled; enable the chosen one with `sm plugins enable <id>`."
+  });
   async run() {
     const ctx = defaultRuntimeContext();
     const stderr = this.context.stderr;
@@ -31532,7 +31770,7 @@ var TutorialCommand = class extends SmCommand {
       );
       return ExitCode.Error;
     }
-    const targets = listScaffoldTargets();
+    const targets = listScaffoldTargets(this.experimental);
     const target = await this.resolveScaffoldTarget(targets, stderrAnsi, errGlyph);
     if (target === null) return ExitCode.Error;
     if (target.skillDir === void 0) {
@@ -31556,8 +31794,8 @@ var TutorialCommand = class extends SmCommand {
     }
     try {
       rmSync2(targetDir, { recursive: true, force: true });
-      mkdirSync6(dirname20(targetDir), { recursive: true });
-      cpSync2(sourceDir, targetDir, { recursive: true });
+      mkdirSync6(dirname21(targetDir), { recursive: true });
+      cpSync3(sourceDir, targetDir, { recursive: true });
     } catch (err) {
       this.printer.error(
         tx(TUTORIAL_TEXTS.writeFailed, {
@@ -31602,21 +31840,20 @@ var TutorialCommand = class extends SmCommand {
    * Returns `null` after printing an error (caller exits non-zero).
    */
   async resolveScaffoldTarget(targets, stderrAnsi, errGlyph) {
-    const selectable = selectableTargets(targets);
-    if (selectable.length === 0) {
+    if (targets.length === 0) {
       this.printer.error(tx(TUTORIAL_TEXTS.noTargets, { glyph: errGlyph }));
       return null;
     }
     const requested = this.forProvider;
     if (requested !== void 0) {
-      const found = selectable.find((t) => t.id === requested);
+      const found = targets.find((t) => t.id === requested);
       if (found === void 0) {
         this.printer.error(
           tx(TUTORIAL_TEXTS.forUnknown, {
             glyph: errGlyph,
             provider: requested,
             hint: stderrAnsi.dim(
-              tx(TUTORIAL_TEXTS.forUnknownHint, { ids: selectable.map((t) => t.id).join(", ") })
+              tx(TUTORIAL_TEXTS.forUnknownHint, { ids: targets.map((t) => t.id).join(", ") })
             )
           })
         );
@@ -31624,7 +31861,7 @@ var TutorialCommand = class extends SmCommand {
       }
       return found;
     }
-    const def = selectable[0];
+    const def = targets[0];
     const stdin = this.context.stdin;
     if (stdin.isTTY !== true) return def;
     const stderr = this.context.stderr;
@@ -31640,7 +31877,7 @@ var TutorialCommand = class extends SmCommand {
         tx(TUTORIAL_TEXTS.promptInvalid, {
           glyph: errGlyph,
           hint: stderrAnsi.dim(
-            tx(TUTORIAL_TEXTS.forUnknownHint, { ids: selectable.map((t) => t.id).join(", ") })
+            tx(TUTORIAL_TEXTS.forUnknownHint, { ids: targets.map((t) => t.id).join(", ") })
           )
         })
       );
@@ -31649,37 +31886,25 @@ var TutorialCommand = class extends SmCommand {
     return picked;
   }
 };
-function toScaffoldTarget(provider) {
-  const comingSoon = provider.presentation.comingSoon === true;
-  if (comingSoon) {
-    return {
-      id: provider.id,
-      label: provider.presentation.label,
-      aka: provider.scaffold?.aka ?? [],
-      comingSoon: true
-    };
-  }
+function toScaffoldTarget(provider, includeExperimental) {
   const scaffold = provider.scaffold;
   if (!scaffold || !scaffold.skillDir) return null;
+  if (!installedDefaultEnabled(provider.stability) && !includeExperimental) return null;
   return {
     id: provider.id,
     label: provider.presentation.label,
     skillDir: scaffold.skillDir,
-    aka: scaffold.aka ?? [],
-    comingSoon: false
+    aka: scaffold.aka ?? []
   };
 }
-function listScaffoldTargets() {
+function listScaffoldTargets(includeExperimental = false) {
   const out = [];
   for (const provider of builtIns().providers) {
-    const target = toScaffoldTarget(provider);
+    const target = toScaffoldTarget(provider, includeExperimental);
     if (target !== null) out.push(target);
   }
   return out;
 }
-function selectableTargets(targets) {
-  return targets.filter((t) => !t.comingSoon);
-}
 function labelWithAka(target) {
   return target.aka.length > 0 ? `${target.label} (${target.aka.join(", ")})` : target.label;
 }
@@ -31688,7 +31913,7 @@ function renderTargetLines(targets, def, glyph) {
   for (let i = 0; i < targets.length; i += 1) {
     const t = targets[i];
     lines.push(
-      t.comingSoon ? tx(TUTORIAL_TEXTS.promptOptionComingSoon, { index: i + 1, label: t.label }) : tx(TUTORIAL_TEXTS.promptOption, {
+      tx(TUTORIAL_TEXTS.promptOption, {
         index: i + 1,
         label: labelWithAka(t),
         skillDir: `${t.skillDir}/`,
@@ -31707,56 +31932,35 @@ function classifyAnswer(trimmed, targets, def) {
 async function promptForTarget(targets, def, stdin, stderr, glyph) {
   stderr.write(renderTargetLines(targets, def, glyph) + "\n");
   const defIndex = targets.findIndex((t) => t.id === def.id);
-  const rl = createInterface5({ input: stdin, output: stderr });
+  const rl = createInterface6({ input: stdin, output: stderr });
   try {
     for (let attempt = 0; attempt < 5; attempt += 1) {
       const answer = await new Promise(
         (resolveP) => rl.question(tx(TUTORIAL_TEXTS.promptInput, { index: defIndex + 1 }), resolveP)
       );
       const result = classifyAnswer(answer.trim(), targets, def);
-      if (result === null) continue;
-      if (!result.comingSoon) return result;
-      stderr.write(
-        tx(TUTORIAL_TEXTS.promptComingSoonNotice, {
-          label: result.label,
-          defaultLabel: def.label
-        }) + "\n"
-      );
+      if (result !== null) return result;
     }
     return null;
   } finally {
     rl.close();
   }
 }
-function displayCwd(cwd) {
-  const segments = cwd.split("/").filter((s) => s.length > 0);
-  if (segments.length === 0) return "./";
-  return `./${segments[segments.length - 1]}/`;
-}
-function isDirEmpty(dir) {
-  return readdirSync10(dir).length === 0;
-}
-function listCwdEntries(dir) {
-  const entries = readdirSync10(dir).sort();
-  const shown = entries.slice(0, 5);
-  const more = entries.length > shown.length ? ", ..." : "";
-  return shown.join(", ") + more;
-}
-var cachedSourceDir;
+var cachedSourceDir2;
 function resolveSkillSourceDir() {
-  if (cachedSourceDir !== void 0) return cachedSourceDir;
-  const here = dirname20(fileURLToPath7(import.meta.url));
+  if (cachedSourceDir2 !== void 0) return cachedSourceDir2;
+  const here = dirname21(fileURLToPath8(import.meta.url));
   const candidates = [
     // dev: src/cli/commands/ → repo-root .claude/skills/sm-tutorial/
-    resolve42(here, "../../..", SKILL_SOURCE_DIR),
+    resolve43(here, "../../..", SKILL_SOURCE_DIR),
     // bundled: dist/cli.js → dist/cli/tutorial/sm-tutorial (sibling)
-    resolve42(here, "cli/tutorial", SKILL_SLUG),
+    resolve43(here, "cli/tutorial", SKILL_SLUG),
     // bundled fallback: any-depth → cli/tutorial/sm-tutorial
-    resolve42(here, "../cli/tutorial", SKILL_SLUG)
+    resolve43(here, "../cli/tutorial", SKILL_SLUG)
   ];
   for (const candidate of candidates) {
-    if (existsSync32(candidate) && statSync11(candidate).isDirectory()) {
-      cachedSourceDir = candidate;
+    if (existsSync33(candidate) && statSync12(candidate).isDirectory()) {
+      cachedSourceDir2 = candidate;
       return candidate;
     }
   }
@@ -31766,7 +31970,7 @@ function resolveSkillSourceDir() {
 }
 
 // cli/commands/version.ts
-import { Command as Command39 } from "clipanion";
+import { Command as Command40 } from "clipanion";
 
 // cli/i18n/version.texts.ts
 var VERSION_TEXTS = {
@@ -31781,7 +31985,7 @@ var VERSION_TEXTS = {
 // cli/commands/version.ts
 var VersionCommand = class extends SmCommand {
   static paths = [["version"]];
-  static usage = Command39.Usage({
+  static usage = Command40.Usage({
     category: "Introspection",
     description: "Print the CLI / spec / runtime / db-schema version matrix."
   });
@@ -31856,6 +32060,7 @@ cli.register(RootHelpCommand);
 cli.register(HelpCommand);
 cli.register(InitCommand);
 cli.register(TutorialCommand);
+cli.register(ExampleCommand);
 cli.register(IntentionalFailCommand);
 cli.register(ScanCommand);
 cli.register(ScanCompareCommand);
@@ -31888,7 +32093,7 @@ var logLevel = resolveLogLevel({
   errStream: process.stderr
 });
 configureLogger(new Logger({ level: logLevel, stream: process.stderr }));
-var bareArgs = resolveBareInvocation(args);
+var bareArgs = await resolveBareInvocation(args);
 var routedArgs = routeHelpArgs(bareArgs ?? args, cli);
 var telemetryVerb = routedArgs[0];
 await maybeRunFirstRunPrompt();
@@ -31946,23 +32151,41 @@ await lifecycleDispatcher.dispatch(
 await closeSentryCli();
 await flushUsageCli();
 process.exit(exitCode);
-function resolveBareInvocation(rawArgs) {
-  if (rawArgs.length === 0) return resolveBareDefault();
+async function resolveBareInvocation(rawArgs) {
+  if (rawArgs.length === 0) return resolveNoArgsBare();
   const first = rawArgs[0];
   const passthrough = /* @__PURE__ */ new Set(["--help", "-h", "--version", "-V", "-v"]);
   if (first !== void 0 && first.startsWith("-") && !passthrough.has(first)) {
     const isSingleDashLong = !first.startsWith("--") && first.length > 2;
     if (isSingleDashLong) return null;
-    if (existsSync33(defaultProjectDbPath(defaultRuntimeContext()))) {
+    if (existsSync34(defaultProjectDbPath(defaultRuntimeContext()))) {
       return ["serve", ...rawArgs];
     }
     return resolveBareDefault();
   }
   return null;
 }
+async function resolveNoArgsBare() {
+  const ctx = defaultRuntimeContext();
+  const stdin = process.stdin;
+  const result = await decideBareNoArgs(
+    {
+      hasDb: existsSync34(defaultProjectDbPath(ctx)),
+      isTty: stdin.isTTY === true,
+      isEmptyDir: isDirEmpty(ctx.cwd)
+    },
+    () => {
+      const stderr = process.stderr;
+      const ansi = ansiFor({ isTTY: stderr.isTTY === true, noColorFlag: false });
+      return promptEmptyFolderChoice(stdin, stderr, ansi);
+    }
+  );
+  if (result.kind === "route") return result.argv;
+  return resolveBareDefault();
+}
 function resolveBareDefault() {
   const ctx = defaultRuntimeContext();
-  if (existsSync33(defaultProjectDbPath(ctx))) {
+  if (existsSync34(defaultProjectDbPath(ctx))) {
     return ["serve"];
   }
   const stderr = process.stderr;
@@ -31971,10 +32194,12 @@ function resolveBareDefault() {
     tx(ENTRY_TEXTS.bareNoProject, {
       glyph: ansi.red("\u2715"),
       cwd: ctx.cwd,
-      hint: ansi.dim(ENTRY_TEXTS.bareNoProjectHint)
+      hint: ansi.dim(
+        isDirEmpty(ctx.cwd) ? ENTRY_TEXTS.bareEmptyHint : ENTRY_TEXTS.bareNoProjectHint
+      )
     })
   );
   process.exit(ExitCode.Error);
 }
 //# sourceMappingURL=cli.js.map
-//# debugId=454166ed-eb8e-57bb-b412-c9c6e9ff30f4
+//# debugId=43bb2367-1e14-5df2-9221-a5e7a877a666