@skill-map/cli 0.31.0 → 0.32.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 // cli/entry.ts
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import { Builtins, Cli as Cli2 } from "clipanion";
 
 // kernel/adapters/in-memory-progress.ts
@@ -2963,7 +2963,7 @@ var UPDATE_CHECK_TEXTS = {
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.31.0",
+  version: "0.32.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -3893,7 +3893,6 @@ var defaults_default = {
     watch: {
       debounceMs: 300
     },
-    extraFolders: [],
     referencePaths: []
   },
   plugins: {},
@@ -3919,7 +3918,6 @@ var defaults_default = {
 // kernel/config/loader.ts
 var PROJECT_LOCAL_ONLY_KEYS = /* @__PURE__ */ new Set([
   "allowEditSmFiles",
-  "scan.extraFolders",
   "scan.referencePaths"
 ]);
 var DEFAULTS = defaults_default;
@@ -4258,7 +4256,6 @@ function writeJsonAtomic(path, content) {
 
 // core/config/helper.ts
 var PRIVACY_SENSITIVE_KEYS = /* @__PURE__ */ new Set([
-  "scan.extraFolders",
   "scan.referencePaths"
 ]);
 var ProjectLocalOnlyKeyError = class extends Error {
@@ -4330,19 +4327,17 @@ var ConfigValidationError = class extends Error {
 function projectPathExposure(inputs) {
   const empty = { expandsSurface: false, exposedPaths: [] };
   if (!PRIVACY_SENSITIVE_KEYS.has(inputs.key)) return empty;
-  if (inputs.key === "scan.extraFolders" || inputs.key === "scan.referencePaths") {
-    if (!Array.isArray(inputs.value)) return empty;
-    const before = readConfigValue(inputs.key, {
-      cwd: inputs.cwd,
-      default: []
-    }) ?? [];
-    const beforeSet = new Set(before);
-    const added = inputs.value.filter((entry) => typeof entry === "string").filter((entry) => !beforeSet.has(entry));
-    const exposed = added.map((entry) => resolveScanPathForExposure(entry, inputs.cwd)).filter((abs) => abs !== null && !isUnderProject(abs, inputs.cwd));
-    if (exposed.length === 0) return empty;
-    return { expandsSurface: true, exposedPaths: exposed };
-  }
-  return empty;
+  if (inputs.key !== "scan.referencePaths") return empty;
+  if (!Array.isArray(inputs.value)) return empty;
+  const before = readConfigValue(inputs.key, {
+    cwd: inputs.cwd,
+    default: []
+  }) ?? [];
+  const beforeSet = new Set(before);
+  const added = inputs.value.filter((entry) => typeof entry === "string").filter((entry) => !beforeSet.has(entry));
+  const exposed = added.map((entry) => resolveScanPathForExposure(entry, inputs.cwd)).filter((abs) => abs !== null && !isUnderProject(abs, inputs.cwd));
+  if (exposed.length === 0) return empty;
+  return { expandsSurface: true, exposedPaths: exposed };
 }
 function resolveScanPathForExposure(raw, cwd) {
   if (raw.startsWith("~/")) return resolve6(join4(osHomedir(), raw.slice(2)));
@@ -4890,7 +4885,7 @@ var AsyncMutex = class {
       this.#locked = true;
       return;
     }
-    await new Promise((resolve37) => this.#waiters.push(resolve37));
+    await new Promise((resolve38) => this.#waiters.push(resolve38));
     this.#locked = true;
   }
   unlock() {
@@ -8081,9 +8076,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;
   }
@@ -9879,7 +9874,7 @@ var ConfigSetCommand = class extends SmCommand {
   key = Option4.String({ required: true });
   value = Option4.String({ required: true });
   yes = Option4.Boolean("--yes", false, {
-    description: "Confirm a privacy-sensitive write that opens disk access outside the project (scan.extraFolders / scan.referencePaths)."
+    description: "Confirm a privacy-sensitive write that opens disk access outside the project (scan.referencePaths)."
   });
   // CLI orchestrator: each branch is one validation gate (forbidden
   // segment / privacy guard / schema violation) or output dispatch.
@@ -14346,12 +14341,6 @@ var SCAN_RUNNER_TEXTS = {
    * validation.
    */
   priorSchemaValidationFailed: "prior scan-result loaded from DB failed schema validation: {{errors}}. Run `sm db backup` then re-scan without --strict to rebuild from disk.",
-  /**
-   * Honest disclosure when the scan surface expanded beyond the cwd
-   * via `scan.extraFolders`. The list of paths makes it obvious which
-   * extra folders the operator just opted into.
-   */
-  includingExtraFoldersAdvisory: "Including extra folders: {{paths}}",
   /**
    * Reference-paths walker hit `REFERENCE_WALK_MAX_FILES` and stopped
    * early. The set may be incomplete for link validation; `core/broken-ref`
@@ -14366,6 +14355,14 @@ var SCAN_RUNNER_TEXTS = {
   referenceWalkMissingRoot: 'scan.referencePaths: configured path "{{path}}" does not exist; skipped.'
 };
 
+// core/runtime/scan-roots.ts
+function resolveScanRoots(inputs) {
+  if (inputs.positionalRoots.length > 0) {
+    return inputs.positionalRoots.slice();
+  }
+  return ["."];
+}
+
 // core/runtime/reference-paths-walker.ts
 import { readdirSync as readdirSync9, statSync as statSync9 } from "fs";
 import { homedir as osHomedir2 } from "os";
@@ -14427,26 +14424,6 @@ function safeStat(path) {
   }
 }
 
-// core/runtime/scan-roots.ts
-function resolveScanRoots(inputs) {
-  if (inputs.positionalRoots.length > 0) {
-    return {
-      roots: inputs.positionalRoots.slice(),
-      fromExtra: []
-    };
-  }
-  const cwdRoot = ".";
-  const extra = inputs.extraFolders.map((r) => resolveScanPath(r, inputs.cwd));
-  const seen = /* @__PURE__ */ new Set();
-  const out = [cwdRoot];
-  for (const root of extra) {
-    if (seen.has(root)) continue;
-    seen.add(root);
-    out.push(root);
-  }
-  return { roots: out, fromExtra: extra };
-}
-
 // core/runtime/scan-runner.ts
 async function runScanForCommand(opts) {
   const ctx = opts.ctx ?? defaultRuntimeContext();
@@ -14464,13 +14441,7 @@ async function runScanForCommand(opts) {
   const strict = opts.strict || cfg.scan.strict === true;
   let effectiveRoots;
   try {
-    const resolution = resolveScanRoots({
-      positionalRoots: opts.roots,
-      cwd: ctx.cwd,
-      extraFolders: cfg.scan.extraFolders
-    });
-    effectiveRoots = resolution.roots;
-    emitRootsAdvisory(resolution.fromExtra, opts);
+    effectiveRoots = resolveScanRoots({ positionalRoots: opts.roots });
   } catch (err) {
     return { kind: "config-error", message: formatErrorMessage(err) };
   }
@@ -14495,12 +14466,6 @@ async function runScanForCommand(opts) {
   const willPersist = !opts.noBuiltIns && !opts.dryRun;
   return willPersist ? runPersistPath(opts, dbPath, jobsDir, strict, loadPrior, runScanWith, extensions) : runEphemeralPath(opts, dbPath, strict, loadPrior, runScanWith);
 }
-function emitRootsAdvisory(fromExtra, opts) {
-  if (fromExtra.length === 0) return;
-  opts.printer.info(
-    tx(SCAN_RUNNER_TEXTS.includingExtraFoldersAdvisory, { paths: fromExtra.join(", ") }) + "\n"
-  );
-}
 function emitReferenceWalkAdvisory(walk2, opts) {
   if (walk2.truncated) {
     opts.printer.warn(SCAN_RUNNER_TEXTS.referenceWalkTruncated);
@@ -18518,6 +18483,13 @@ function createWatcherRuntime(opts) {
         strict,
         emitter
       };
+      if (cfg.scan.referencePaths.length > 0) {
+        const walk2 = walkReferencePaths(cfg.scan.referencePaths, cwd);
+        if (walk2.paths.size > 0) {
+          runOptions.referenceablePaths = walk2.paths;
+          runOptions.cwd = cwd;
+        }
+      }
       if (composed) runOptions.extensions = composed;
       if (priorState) {
         runOptions.priorSnapshot = priorState.snapshot;
@@ -18952,12 +18924,11 @@ var ScanCommand = class extends SmCommand {
       the prior snapshot from the DB, reuse unchanged nodes, and only
       reprocess new / modified files.
 
-      Scans honour scan.extraFolders (append extra dirs verbatim, the
-      only way to extend the scan beyond cwd) and scan.referencePaths
-      (walk the configured dirs for link-validation only; files there
-      are not indexed). Both are
+      Scans honour scan.referencePaths (walk the configured dirs for
+      link-validation only; files there are not indexed). The key is
       privacy-sensitive; see "sm config set --help" for the --yes
-      gate.
+      gate. To extend the indexed scan beyond cwd, pass extra roots
+      positionally.
     `,
     examples: [
       ["Scan the current directory", "$0 scan"],
@@ -19418,7 +19389,7 @@ function renderDeltaIssues(issues) {
 
 // cli/commands/serve.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { Command as Command33, Option as Option31 } from "clipanion";
 
 // cli/util/browser-launch.ts
@@ -19440,7 +19411,7 @@ import { WebSocketServer } from "ws";
 // server/app.ts
 import { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
-import { HTTPException as HTTPException13 } from "hono/http-exception";
+import { HTTPException as HTTPException14 } from "hono/http-exception";
 
 // core/config/service.ts
 var ConfigService = class {
@@ -19682,13 +19653,60 @@ var SERVER_TEXTS = {
   // silently widen the scan surface.
   projectPrefsBodyNotJson: "Request body must be valid JSON.",
   projectPrefsBodyNotObject: "Request body must be a JSON object.",
-  projectPrefsBodyEmpty: "Request body must contain a `scan` block with at least one of `extraFolders`, `referencePaths`.",
+  projectPrefsBodyEmpty: "Request body must contain a `scan` block with `referencePaths`.",
   projectPrefsConfirmNotBoolean: "`confirm` must be a boolean.",
-  projectPrefsScanNotObject: '`scan` must be an object (e.g. `{"scan": {"extraFolders": ["~/.claude/agents"]}}`).',
+  projectPrefsScanNotObject: '`scan` must be an object (e.g. `{"scan": {"referencePaths": ["~/Documents"]}}`).',
   projectPrefsListNotArray: "`{{key}}` must be an array of strings.",
   projectPrefsListEntryNotString: "`{{key}}` entries must be strings.",
   projectPrefsConfirmRequired: "This change opens disk access outside the project: {{paths}}. Re-issue the request with `confirm: true` to proceed.",
   projectPrefsPersistFailed: "Could not persist `{{key}}`: {{message}}",
+  // Returned for every NEW entry that does not resolve to an existing
+  // directory on disk. The list is comma-separated; pre-existing
+  // entries are not re-validated.
+  projectPrefsPathNotFound: "These folders do not exist on disk: {{paths}}. Add only paths that already exist.",
+  // AJV `pattern` violation, an entry contains a comma. The UI rejects
+  // comma input client-side; this message is the server-side safety
+  // net (defense in depth).
+  projectPrefsEntryHasComma: "Folder entries must not contain commas. Add one folder per entry.",
+  // Server-stderr advisories emitted by `PATCH /api/project-preferences`
+  // after a successful write. The operator running `sm serve` sees
+  // each add / remove on the console without opening the config file.
+  // `{{detail}}` is composed in JS (see `formatPathDetail`) so the
+  // single template covers all three path shapes (home / relative /
+  // absolute) without a template explosion.
+  projectPrefsPathAdded: "project-prefs: + {{key}} {{detail}}",
+  projectPrefsPathRemoved: "project-prefs: - {{key}} {{detail}}",
+  // `PATCH /api/project-preferences` mutated `scan.*` and the
+  // post-write `watcherService.restart()` call threw. The on-disk
+  // write itself succeeded; the operator sees this advisory and
+  // restarts the server to pick up the new root list manually.
+  projectPrefsWatcherRestartFailed: "project-prefs: watcher restart after scan-config write failed ({{message}}). Restart `sm serve` to pick up the new roots.",
+  // ---- project-ignore route (routes/project-ignore.ts) -------------------
+  //
+  // GET / PATCH /api/project-ignore. Backing is the project-root
+  // `.skillmapignore` file (gitignore-syntax). Comments and blank
+  // lines are preserved on write; only the active pattern list is
+  // exchanged over the wire. No privacy gate, the patterns narrow the
+  // scan surface and never widen disk access.
+  projectIgnoreBodyNotJson: "Request body must be valid JSON.",
+  projectIgnoreBodyNotObject: "Request body must be a JSON object.",
+  projectIgnoreBodyEmpty: "Request body must contain a `patterns` array.",
+  projectIgnoreListNotArray: "`patterns` must be an array of strings.",
+  projectIgnoreEntryNotString: "`patterns` entries must be strings.",
+  // AJV `minLength: 1` on each pattern after the route trims server-side;
+  // surfaces when the operator sends `"   "` or an empty string.
+  projectIgnorePatternEmpty: "Pattern entries must not be empty or whitespace-only.",
+  // AJV `pattern` violation: a single pattern carried a newline,
+  // carriage return, or other ASCII control character. The UI rejects
+  // these client-side; this message is the server-side safety net.
+  projectIgnorePatternHasControlChar: "Pattern entries must be a single line without control characters.",
+  // Duplicate detection runs after trim; the UI rejects duplicates
+  // client-side, this is the server-side safety net.
+  projectIgnorePatternDuplicate: 'Duplicate pattern: "{{pattern}}". Each pattern must be unique.',
+  projectIgnorePersistFailed: "Could not persist `.skillmapignore`: {{message}}",
+  projectIgnorePatternAdded: "project-ignore: + {{pattern}}",
+  projectIgnorePatternRemoved: "project-ignore: - {{pattern}}",
+  projectIgnoreWatcherRestartFailed: "project-ignore: watcher restart after `.skillmapignore` write failed ({{message}}). Restart `sm serve` to pick up the new filter.",
   // A connected client's outbound buffer exceeded the backpressure
   // threshold. The broadcaster closes the client with code 1009 and
   // unregisters it. Logged so operators can spot a wedged consumer.
@@ -20922,26 +20940,203 @@ var parsePatchBody2 = makeBodyValidator(PATCH_BODY_SCHEMA, {
   }
 });
 
-// server/routes/project-preferences.ts
+// server/routes/project-ignore.ts
 import { HTTPException as HTTPException10 } from "hono/http-exception";
-function registerProjectPreferencesRoute(app, deps) {
-  app.get("/api/project-preferences", (c) => {
+
+// server/util/skillmapignore-io.ts
+import { existsSync as existsSync25, readFileSync as readFileSync19, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve33 } from "path";
+var IGNORE_FILENAME2 = ".skillmapignore";
+function readPatterns(cwd) {
+  const path = resolve33(cwd, IGNORE_FILENAME2);
+  if (!existsSync25(path)) return [];
+  let raw;
+  try {
+    raw = readFileSync19(path, "utf8");
+  } catch {
+    return [];
+  }
+  return raw.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
+}
+function writePatterns(cwd, nextPatterns) {
+  const path = resolve33(cwd, IGNORE_FILENAME2);
+  const prior = existsSync25(path) ? safeRead(path) : "";
+  const content = buildContent(prior, nextPatterns);
+  writeFileSync4(path, content, "utf8");
+}
+function safeRead(path) {
+  try {
+    return readFileSync19(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+function buildContent(prior, nextPatterns) {
+  const wanted = new Set(nextPatterns);
+  const kept = /* @__PURE__ */ new Set();
+  const outLines = [];
+  for (const line of splitLines(prior)) {
+    pushPriorLine(line, wanted, kept, outLines);
+  }
+  appendNewPatterns(nextPatterns, kept, outLines);
+  return outLines.length === 0 ? "" : outLines.join("\n") + "\n";
+}
+function splitLines(prior) {
+  if (prior.length === 0) return [];
+  const lines = prior.split(/\r?\n/);
+  if (lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function pushPriorLine(line, wanted, kept, outLines) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0 || trimmed.startsWith("#")) {
+    outLines.push(line);
+    return;
+  }
+  if (wanted.has(trimmed)) {
+    outLines.push(trimmed);
+    kept.add(trimmed);
+  }
+}
+function appendNewPatterns(nextPatterns, kept, outLines) {
+  for (const p of nextPatterns) {
+    if (kept.has(p)) continue;
+    outLines.push(p);
+    kept.add(p);
+  }
+}
+
+// server/routes/project-ignore.ts
+function registerProjectIgnoreRoute(app, deps) {
+  app.get("/api/project-ignore", (c) => {
     return c.json(buildEnvelope2(deps));
   });
-  app.patch("/api/project-preferences", async (c) => {
+  app.patch("/api/project-ignore", async (c) => {
     const body = await parsePatchBody3(c.req.raw);
-    applyPatch2(deps, body);
+    await applyPatch2(deps, body);
     return c.json(buildEnvelope2(deps));
   });
 }
 function buildEnvelope2(deps) {
+  const cwd = deps.runtimeContext.cwd;
+  return { patterns: readPatterns(cwd) };
+}
+async function applyPatch2(deps, body) {
+  const cwd = deps.runtimeContext.cwd;
+  const trimmed = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of body.patterns) {
+    const t = raw.trim();
+    if (t.length === 0) {
+      throw new HTTPException10(400, {
+        message: SERVER_TEXTS.projectIgnorePatternEmpty
+      });
+    }
+    if (seen.has(t)) {
+      throw new HTTPException10(400, {
+        message: tx(SERVER_TEXTS.projectIgnorePatternDuplicate, { pattern: t })
+      });
+    }
+    seen.add(t);
+    trimmed.push(t);
+  }
+  const before = readPatterns(cwd);
+  try {
+    writePatterns(cwd, trimmed);
+  } catch (err) {
+    throw new HTTPException10(400, {
+      message: tx(SERVER_TEXTS.projectIgnorePersistFailed, {
+        message: formatErrorMessage(err)
+      })
+    });
+  }
+  logPatternChanges(before, trimmed);
+  if (arrayChanged(before, trimmed)) await maybeRestartWatcher(deps);
+}
+function arrayChanged(before, next) {
+  if (before.length !== next.length) return true;
+  const beforeSet = new Set(before);
+  for (const p of next) {
+    if (!beforeSet.has(p)) return true;
+  }
+  return false;
+}
+function logPatternChanges(before, next) {
+  const beforeSet = new Set(before);
+  const nextSet = new Set(next);
+  for (const p of next) {
+    if (beforeSet.has(p)) continue;
+    log.warn(
+      tx(SERVER_TEXTS.projectIgnorePatternAdded, {
+        pattern: sanitizeForTerminal(p)
+      })
+    );
+  }
+  for (const p of before) {
+    if (nextSet.has(p)) continue;
+    log.warn(
+      tx(SERVER_TEXTS.projectIgnorePatternRemoved, {
+        pattern: sanitizeForTerminal(p)
+      })
+    );
+  }
+}
+async function maybeRestartWatcher(deps) {
+  const watcher = deps.watcherHolder.current;
+  if (!watcher) return;
+  try {
+    await watcher.restart();
+  } catch (err) {
+    log.warn(
+      tx(SERVER_TEXTS.projectIgnoreWatcherRestartFailed, {
+        message: formatErrorMessage(err)
+      })
+    );
+  }
+}
+var PATCH_BODY_SCHEMA2 = {
+  type: "object",
+  additionalProperties: false,
+  required: ["patterns"],
+  properties: {
+    patterns: {
+      type: "array",
+      items: {
+        type: "string",
+        pattern: "^[^\\n\\r\\x00-\\x1F\\x7F]+$"
+      }
+    }
+  }
+};
+var parsePatchBody3 = makeBodyValidator(PATCH_BODY_SCHEMA2, {
+  notJson: SERVER_TEXTS.projectIgnoreBodyNotJson,
+  notObject: SERVER_TEXTS.projectIgnoreBodyNotObject,
+  invalid: SERVER_TEXTS.projectIgnoreBodyEmpty,
+  mapping: {
+    "/patterns:required": SERVER_TEXTS.projectIgnoreBodyEmpty,
+    "/patterns:type:array": SERVER_TEXTS.projectIgnoreListNotArray,
+    "/patterns/*:type:string": SERVER_TEXTS.projectIgnoreEntryNotString,
+    "/patterns/*:pattern": SERVER_TEXTS.projectIgnorePatternHasControlChar
+  }
+});
+
+// server/routes/project-preferences.ts
+import { statSync as statSync10 } from "fs";
+import { HTTPException as HTTPException11 } from "hono/http-exception";
+function registerProjectPreferencesRoute(app, deps) {
+  app.get("/api/project-preferences", (c) => {
+    return c.json(buildEnvelope3(deps));
+  });
+  app.patch("/api/project-preferences", async (c) => {
+    const body = await parsePatchBody4(c.req.raw);
+    await applyPatch3(deps, body);
+    return c.json(buildEnvelope3(deps));
+  });
+}
+function buildEnvelope3(deps) {
   const cwd = deps.runtimeContext.cwd;
   return {
     scan: {
-      extraFolders: readConfigValue("scan.extraFolders", {
-        cwd,
-        default: []
-      }) ?? [],
       referencePaths: readConfigValue("scan.referencePaths", {
         cwd,
         default: []
@@ -20949,46 +21144,138 @@ function buildEnvelope2(deps) {
     }
   };
 }
-function applyPatch2(deps, body) {
+async function applyPatch3(deps, body) {
   const writes = collectWrites(body);
   if (writes.length === 0) return;
   const cwd = deps.runtimeContext.cwd;
+  const missingPaths = collectMissingPaths(writes, cwd);
+  if (missingPaths.length > 0) {
+    throw new HTTPException11(400, {
+      message: tx(SERVER_TEXTS.projectPrefsPathNotFound, {
+        paths: missingPaths.join(", ")
+      })
+    });
+  }
   const exposures = writes.map((w) => projectPathExposure({ key: w.key, value: w.value, cwd })).filter((e) => e.expandsSurface);
   if (exposures.length > 0 && body.confirm !== true) {
     const exposed = exposures.flatMap((e) => e.exposedPaths);
-    throw new HTTPException10(412, {
+    throw new HTTPException11(412, {
       message: tx(SERVER_TEXTS.projectPrefsConfirmRequired, {
         paths: exposed.join(", ")
       })
     });
   }
+  let scanSurfaceMutated = false;
   for (const w of writes) {
-    try {
-      writeConfigValue(w.key, w.value, { target: "project-local", cwd });
-    } catch (err) {
-      const status = err instanceof ConfigValidationError ? 400 : 400;
-      throw new HTTPException10(status, {
-        message: tx(SERVER_TEXTS.projectPrefsPersistFailed, {
-          key: w.key,
-          message: formatErrorMessage(err)
-        })
-      });
-    }
+    if (runWrite(w, cwd)) scanSurfaceMutated = true;
   }
+  if (scanSurfaceMutated) await maybeRestartWatcher2(deps);
   deps.configService.reload();
 }
 function collectWrites(body) {
   if (!body.scan) return [];
   const out = [];
-  if (Array.isArray(body.scan.extraFolders)) {
-    out.push({ key: "scan.extraFolders", value: body.scan.extraFolders });
-  }
   if (Array.isArray(body.scan.referencePaths)) {
     out.push({ key: "scan.referencePaths", value: body.scan.referencePaths });
   }
   return out;
 }
-var PATCH_BODY_SCHEMA2 = {
+function collectMissingPaths(writes, cwd) {
+  const missing = [];
+  for (const w of writes) {
+    if (!Array.isArray(w.value)) continue;
+    const current = readConfigValue(w.key, { cwd, default: [] }) ?? [];
+    const currentSet = new Set(current);
+    for (const entry of w.value) {
+      if (currentSet.has(entry)) continue;
+      if (!isExistingDirectory(entry, cwd)) missing.push(entry);
+    }
+  }
+  return missing;
+}
+async function maybeRestartWatcher2(deps) {
+  const watcher = deps.watcherHolder.current;
+  if (!watcher) return;
+  try {
+    await watcher.restart();
+  } catch (err) {
+    log.warn(
+      tx(SERVER_TEXTS.projectPrefsWatcherRestartFailed, {
+        message: formatErrorMessage(err)
+      })
+    );
+  }
+}
+function runWrite(w, cwd) {
+  const before = readConfigValue(w.key, { cwd, default: [] }) ?? [];
+  try {
+    writeConfigValue(w.key, w.value, { target: "project-local", cwd });
+  } catch (err) {
+    throw new HTTPException11(400, {
+      message: tx(SERVER_TEXTS.projectPrefsPersistFailed, {
+        key: w.key,
+        message: formatErrorMessage(err)
+      })
+    });
+  }
+  logPathChanges(w.key, before, w.value, cwd);
+  return arrayChanged2(before, w.value);
+}
+function arrayChanged2(before, nextValue) {
+  if (!Array.isArray(nextValue)) return false;
+  const next = nextValue;
+  if (before.length !== next.length) return true;
+  const beforeSet = new Set(before);
+  for (const p of next) {
+    if (!beforeSet.has(p)) return true;
+  }
+  return false;
+}
+function logPathChanges(key, before, nextValue, cwd) {
+  if (!Array.isArray(nextValue)) return;
+  const next = nextValue;
+  const beforeSet = new Set(before);
+  const nextSet = new Set(next);
+  for (const path of next) {
+    if (beforeSet.has(path)) continue;
+    log.warn(
+      tx(SERVER_TEXTS.projectPrefsPathAdded, {
+        key,
+        detail: formatPathDetail(path, cwd)
+      })
+    );
+  }
+  for (const path of before) {
+    if (nextSet.has(path)) continue;
+    log.warn(
+      tx(SERVER_TEXTS.projectPrefsPathRemoved, {
+        key,
+        detail: formatPathDetail(path, cwd)
+      })
+    );
+  }
+}
+function formatPathDetail(path, cwd) {
+  const safePath = sanitizeForTerminal(path);
+  if (path.startsWith("~/") || path === "~") {
+    const abs2 = sanitizeForTerminal(resolveScanPath(path, cwd));
+    return `${safePath} (home) \u2192 ${abs2}`;
+  }
+  if (path.startsWith("/")) {
+    return `${safePath} (absolute)`;
+  }
+  const abs = sanitizeForTerminal(resolveScanPath(path, cwd));
+  return `${safePath} (relative) \u2192 ${abs}`;
+}
+function isExistingDirectory(entry, cwd) {
+  const abs = resolveScanPath(entry, cwd);
+  try {
+    return statSync10(abs).isDirectory();
+  } catch {
+    return false;
+  }
+}
+var PATCH_BODY_SCHEMA3 = {
   type: "object",
   additionalProperties: false,
   required: ["scan"],
@@ -20999,13 +21286,15 @@ var PATCH_BODY_SCHEMA2 = {
       additionalProperties: false,
       minProperties: 1,
       properties: {
-        extraFolders: { type: "array", items: { type: "string" } },
-        referencePaths: { type: "array", items: { type: "string" } }
+        referencePaths: {
+          type: "array",
+          items: { type: "string", pattern: "^[^,]+$" }
+        }
       }
     }
   }
 };
-var parsePatchBody3 = makeBodyValidator(PATCH_BODY_SCHEMA2, {
+var parsePatchBody4 = makeBodyValidator(PATCH_BODY_SCHEMA3, {
   notJson: SERVER_TEXTS.projectPrefsBodyNotJson,
   notObject: SERVER_TEXTS.projectPrefsBodyNotObject,
   invalid: SERVER_TEXTS.projectPrefsBodyEmpty,
@@ -21014,15 +21303,14 @@ var parsePatchBody3 = makeBodyValidator(PATCH_BODY_SCHEMA2, {
     "/scan:minProperties": SERVER_TEXTS.projectPrefsBodyEmpty,
     "/scan:type:object": SERVER_TEXTS.projectPrefsScanNotObject,
     "/confirm:type:boolean": SERVER_TEXTS.projectPrefsConfirmNotBoolean,
-    "/scan/extraFolders:type:array": tx(SERVER_TEXTS.projectPrefsListNotArray, { key: "scan.extraFolders" }),
     "/scan/referencePaths:type:array": tx(SERVER_TEXTS.projectPrefsListNotArray, { key: "scan.referencePaths" }),
-    "/scan/extraFolders/*:type:string": tx(SERVER_TEXTS.projectPrefsListEntryNotString, { key: "scan.extraFolders" }),
-    "/scan/referencePaths/*:type:string": tx(SERVER_TEXTS.projectPrefsListEntryNotString, { key: "scan.referencePaths" })
+    "/scan/referencePaths/*:type:string": tx(SERVER_TEXTS.projectPrefsListEntryNotString, { key: "scan.referencePaths" }),
+    "/scan/referencePaths/*:pattern": SERVER_TEXTS.projectPrefsEntryHasComma
   }
 });
 
 // server/routes/scan.ts
-import { HTTPException as HTTPException11 } from "hono/http-exception";
+import { HTTPException as HTTPException12 } from "hono/http-exception";
 
 // server/scan-mutex.ts
 var inFlight = null;
@@ -21030,14 +21318,14 @@ async function withScanMutex(fn) {
   if (inFlight !== null) {
     throw new ScanBusyError();
   }
-  let resolve37;
+  let resolve38;
   inFlight = new Promise((r) => {
-    resolve37 = r;
+    resolve38 = r;
   });
   try {
     return await fn();
   } finally {
-    resolve37();
+    resolve38();
     inFlight = null;
   }
 }
@@ -21077,61 +21365,80 @@ function buildWatcherErrorEvent(data) {
 }
 
 // server/watcher.ts
-var WATCH_ROOT = ".";
 function createWatcherService(opts) {
-  const runtimeOpts = {
-    dbPath: opts.options.dbPath,
-    roots: [WATCH_ROOT],
-    runtimeContext: opts.runtimeContext,
-    noBuiltIns: opts.options.noBuiltIns,
-    noPlugins: opts.options.noPlugins,
-    emitterFactory: () => buildBroadcasterEmitter(opts.broadcaster),
-    runInitialBatch: true,
-    // BFF ordering: subscribe first so edits arriving during the initial
-    // scan queue against the armed chokidar and fire a follow-up batch.
-    subscribeBeforeInitial: true,
-    failOnInitialBatchError: false,
-    events: {
-      onBatch: (outcome) => {
-        if (outcome.kind === "error") {
+  let currentRuntime = null;
+  const buildRuntimeOpts = () => {
+    const runtimeOpts = {
+      dbPath: opts.options.dbPath,
+      roots: ["."],
+      runtimeContext: opts.runtimeContext,
+      noBuiltIns: opts.options.noBuiltIns,
+      noPlugins: opts.options.noPlugins,
+      emitterFactory: () => buildBroadcasterEmitter(opts.broadcaster),
+      runInitialBatch: true,
+      // BFF ordering: subscribe first so edits arriving during the
+      // initial scan queue against the armed chokidar and fire a
+      // follow-up batch.
+      subscribeBeforeInitial: true,
+      failOnInitialBatchError: false,
+      events: {
+        onBatch: (outcome) => {
+          if (outcome.kind === "error") {
+            log.warn(
+              tx(SERVER_TEXTS.watcherBatchFailed, {
+                message: sanitizeForTerminal(outcome.message)
+              })
+            );
+          }
+        },
+        onWatcherError: (message) => {
           log.warn(
-            tx(SERVER_TEXTS.watcherBatchFailed, {
-              message: sanitizeForTerminal(outcome.message)
+            tx(SERVER_TEXTS.watcherError, {
+              message: sanitizeForTerminal(message)
+            })
+          );
+          opts.broadcaster.broadcast(buildWatcherErrorEvent({ message }));
+        },
+        onPluginWarning: (message) => {
+          log.warn(sanitizeForTerminal(message));
+        },
+        onReady: (info) => {
+          opts.broadcaster.broadcast(
+            buildWatcherStartedEvent({ roots: info.roots, debounceMs: info.debounceMs })
+          );
+          log.info(
+            tx(SERVER_TEXTS.watcherReady, {
+              roots: info.roots.join(","),
+              debounceMs: String(info.debounceMs)
             })
           );
         }
-      },
-      onWatcherError: (message) => {
-        log.warn(
-          tx(SERVER_TEXTS.watcherError, {
-            message: sanitizeForTerminal(message)
-          })
-        );
-        opts.broadcaster.broadcast(buildWatcherErrorEvent({ message }));
-      },
-      onPluginWarning: (message) => {
-        log.warn(sanitizeForTerminal(message));
-      },
-      onReady: (info) => {
-        opts.broadcaster.broadcast(
-          buildWatcherStartedEvent({ roots: info.roots, debounceMs: info.debounceMs })
-        );
-        log.info(
-          tx(SERVER_TEXTS.watcherReady, {
-            roots: info.roots.join(","),
-            debounceMs: String(info.debounceMs)
-          })
-        );
       }
+    };
+    if (opts.debounceMsOverride !== void 0) {
+      runtimeOpts.debounceMsOverride = opts.debounceMsOverride;
     }
+    return runtimeOpts;
   };
-  if (opts.debounceMsOverride !== void 0) {
-    runtimeOpts.debounceMsOverride = opts.debounceMsOverride;
-  }
-  const handle = createWatcherRuntime(runtimeOpts);
   return {
-    start: handle.start,
-    stop: handle.stop
+    async start() {
+      currentRuntime = createWatcherRuntime(buildRuntimeOpts());
+      await currentRuntime.start();
+    },
+    async stop() {
+      if (currentRuntime) {
+        await currentRuntime.stop();
+        currentRuntime = null;
+      }
+    },
+    async restart() {
+      if (currentRuntime) {
+        await currentRuntime.stop();
+        currentRuntime = null;
+      }
+      currentRuntime = createWatcherRuntime(buildRuntimeOpts());
+      await currentRuntime.start();
+    }
   };
 }
 function buildBroadcasterEmitter(broadcaster) {
@@ -21158,7 +21465,7 @@ function registerScanRoute(app, deps) {
 }
 async function runPersistedScan(c, deps) {
   if (deps.options.noBuiltIns || deps.options.noPlugins) {
-    throw new HTTPException11(400, { message: SERVER_TEXTS.scanPostRequiresFullPipeline });
+    throw new HTTPException12(400, { message: SERVER_TEXTS.scanPostRequiresFullPipeline });
   }
   const dbExists = await tryWithSqlite(
     { databasePath: deps.options.dbPath, autoBackup: false },
@@ -21187,7 +21494,7 @@ async function runPersistedScan(c, deps) {
         emitterFactory: () => buildBroadcasterEmitter(deps.broadcaster)
       });
       if (outcome.kind !== "ok") {
-        throw new HTTPException11(500, {
+        throw new HTTPException12(500, {
           message: outcome.kind === "guard-trip" ? tx(SERVER_TEXTS.scanGuardTrip, { existing: outcome.existing }) : outcome.message
         });
       }
@@ -21195,7 +21502,7 @@ async function runPersistedScan(c, deps) {
     });
   } catch (err) {
     if (err instanceof ScanBusyError) {
-      throw new HTTPException11(409, { message: SERVER_TEXTS.scanPostBusy });
+      throw new HTTPException12(409, { message: SERVER_TEXTS.scanPostBusy });
     }
     throw err;
   }
@@ -21259,7 +21566,7 @@ function groupTagsBySource2(rows) {
 }
 async function runFreshScan(deps) {
   if (deps.options.noBuiltIns || deps.options.noPlugins) {
-    throw new HTTPException11(400, { message: SERVER_TEXTS.freshScanRequiresPipeline });
+    throw new HTTPException12(400, { message: SERVER_TEXTS.freshScanRequiresPipeline });
   }
   const resolveEnabledOverride = await buildBffResolverOverride(deps);
   const outcome = await runScanForCommand({
@@ -21288,7 +21595,7 @@ async function runFreshScan(deps) {
     printer: bffScanRunnerPrinter
   });
   if (outcome.kind !== "ok") {
-    throw new HTTPException11(500, {
+    throw new HTTPException12(500, {
       message: outcome.kind === "guard-trip" ? tx(SERVER_TEXTS.freshScanGuardTrip, { existing: outcome.existing }) : outcome.message
     });
   }
@@ -21322,8 +21629,8 @@ function emptyScanResult() {
 }
 
 // server/routes/sidecar.ts
-import { HTTPException as HTTPException12 } from "hono/http-exception";
-import { resolve as resolve33 } from "path";
+import { HTTPException as HTTPException13 } from "hono/http-exception";
+import { resolve as resolve34 } from "path";
 var STATUS_FRESH = "fresh";
 var ENVELOPE_KIND2 = "sidecar.bumped";
 var BUMP_BODY_SCHEMA = {
@@ -21357,13 +21664,13 @@ function registerSidecarRoutes(app, deps) {
     let absPath;
     try {
       assertContained(deps.runtimeContext.cwd, node.path);
-      absPath = resolve33(deps.runtimeContext.cwd, node.path);
+      absPath = resolve34(deps.runtimeContext.cwd, node.path);
     } catch (err) {
-      throw new HTTPException12(500, { message: formatErrorMessage(err) });
+      throw new HTTPException13(500, { message: formatErrorMessage(err) });
     }
     const result = invokeBump2(node, absPath, body);
     if (result.report.ok === false && result.report.reason === "fresh") {
-      throw new HTTPException12(409, { message: SERVER_TEXTS.sidecarFreshRefusal });
+      throw new HTTPException13(409, { message: SERVER_TEXTS.sidecarFreshRefusal });
     }
     if (result.report.ok === true && result.report.noop === true) {
       const envelope2 = {
@@ -21390,7 +21697,7 @@ function registerSidecarRoutes(app, deps) {
       }
     } catch (err) {
       if (err instanceof EConsentRequiredError) throw err;
-      throw new HTTPException12(500, { message: formatErrorMessage(err) });
+      throw new HTTPException13(500, { message: formatErrorMessage(err) });
     }
     if (body.confirm === true) {
       deps.configService.reload();
@@ -21427,7 +21734,7 @@ async function loadNode(deps, nodePath) {
   );
   const node = persisted?.nodes.find((n) => n.path === nodePath);
   if (!node) {
-    throw new HTTPException12(404, {
+    throw new HTTPException13(404, {
       message: tx(SERVER_TEXTS.nodeNotFound, { path: sanitizeForTerminal(nodePath) })
     });
   }
@@ -21435,7 +21742,7 @@ async function loadNode(deps, nodePath) {
 }
 function invokeBump2(node, absPath, body) {
   if (!bumpAction.invoke) {
-    throw new HTTPException12(500, { message: SERVER_TEXTS.sidecarBumpInvokeMissing });
+    throw new HTTPException13(500, { message: SERVER_TEXTS.sidecarBumpInvokeMissing });
   }
   const input = {};
   if (body.force === true) input.force = true;
@@ -21481,7 +21788,7 @@ function registerUpdateStatusRoute(app, deps) {
 }
 
 // server/static.ts
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { readFile as readFile5 } from "fs/promises";
 import { extname, join as join17 } from "path";
 import { serveStatic } from "@hono/node-server/serve-static";
@@ -21536,7 +21843,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 = join17(opts.uiDist, INDEX_HTML);
-    if (!existsSync25(indexPath)) return htmlResponse(c, placeholder);
+    if (!existsSync26(indexPath)) return htmlResponse(c, placeholder);
     return fileResponse(c, indexPath);
   };
 }
@@ -21622,13 +21929,13 @@ function attachBroadcasterRoute(app, broadcaster) {
 
 // server/app.ts
 var BODY_LIMIT_BYTES = 1024 * 1024;
-var DbMissingError = class extends HTTPException13 {
+var DbMissingError = class extends HTTPException14 {
   constructor(message) {
     super(500, { message });
     this.name = "DbMissingError";
   }
 };
-var BulkValidationError = class extends HTTPException13 {
+var BulkValidationError = class extends HTTPException14 {
   id;
   code;
   constructor(init) {
@@ -21638,7 +21945,7 @@ var BulkValidationError = class extends HTTPException13 {
     this.code = init.code;
   }
 };
-var LoopbackGateError = class extends HTTPException13 {
+var LoopbackGateError = class extends HTTPException14 {
   code;
   constructor(init) {
     super(403, { message: init.message });
@@ -21658,7 +21965,7 @@ function createApp(deps) {
     bodyLimit({
       maxSize: BODY_LIMIT_BYTES,
       onError: () => {
-        throw new HTTPException13(413, { message: tx(SERVER_TEXTS.bodyTooLarge, { maxBytes: String(BODY_LIMIT_BYTES) }) });
+        throw new HTTPException14(413, { message: tx(SERVER_TEXTS.bodyTooLarge, { maxBytes: String(BODY_LIMIT_BYTES) }) });
       }
     })
   );
@@ -21682,7 +21989,8 @@ function createApp(deps) {
     kindRegistry: deps.kindRegistry,
     contributionsRegistry: deps.contributionsRegistry,
     pluginRuntime: deps.pluginRuntime,
-    configService
+    configService,
+    watcherHolder: deps.watcherHolder
   };
   registerScanRoute(app, { ...routeDeps, broadcaster: deps.broadcaster });
   registerNodesRoutes(app, routeDeps);
@@ -21698,8 +22006,9 @@ function createApp(deps) {
   registerUpdateStatusRoute(app, routeDeps);
   registerPreferencesRoute(app, routeDeps);
   registerProjectPreferencesRoute(app, routeDeps);
+  registerProjectIgnoreRoute(app, routeDeps);
   app.all("/api/*", (c) => {
-    throw new HTTPException13(404, {
+    throw new HTTPException14(404, {
       message: tx(SERVER_TEXTS.unknownApiEndpoint, { path: sanitizeForTerminal(c.req.path) })
     });
   });
@@ -21707,7 +22016,7 @@ function createApp(deps) {
   app.use("*", createStaticHandler({ uiDist: deps.options.uiDist, noUi: deps.options.noUi }));
   app.get("*", createSpaFallback({ uiDist: deps.options.uiDist, noUi: deps.options.noUi }));
   app.notFound((c) => {
-    throw new HTTPException13(404, {
+    throw new HTTPException14(404, {
       message: tx(SERVER_TEXTS.unknownPath, { path: sanitizeForTerminal(c.req.path) })
     });
   });
@@ -21762,7 +22071,7 @@ function formatError2(err, c) {
     };
     return c.json(envelope, 403);
   }
-  if (err instanceof HTTPException13) {
+  if (err instanceof HTTPException14) {
     const status = err.status;
     const envelope = {
       ok: false,
@@ -22105,8 +22414,8 @@ function validateNoUi(noUi, uiDist) {
 }
 
 // server/paths.ts
-import { existsSync as existsSync26, statSync as statSync10 } from "fs";
-import { dirname as dirname18, isAbsolute as isAbsolute9, join as join18, resolve as resolve34 } from "path";
+import { existsSync as existsSync27, statSync as statSync11 } from "fs";
+import { dirname as dirname18, isAbsolute as isAbsolute9, join as join18, resolve as resolve35 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var DEFAULT_UI_REL = join18("ui", "dist", "ui", "browser");
 var PACKAGE_UI_REL = "ui";
@@ -22117,13 +22426,13 @@ function resolveDefaultUiDist(ctx) {
   return walkUpForUi(ctx.cwd);
 }
 function resolveExplicitUiDist(ctx, raw) {
-  return isAbsolute9(raw) ? raw : resolve34(ctx.cwd, raw);
+  return isAbsolute9(raw) ? raw : resolve35(ctx.cwd, raw);
 }
 function isUiBundleDir(path) {
-  if (!existsSync26(path)) return false;
+  if (!existsSync27(path)) return false;
   try {
-    if (!statSync10(path).isDirectory()) return false;
-    return existsSync26(join18(path, INDEX_HTML2));
+    if (!statSync11(path).isDirectory()) return false;
+    return existsSync27(join18(path, INDEX_HTML2));
   } catch {
     return false;
   }
@@ -22151,7 +22460,7 @@ function resolvePackageBundledUiFrom(here) {
   return null;
 }
 function walkUpForUi(startDir) {
-  let current = resolve34(startDir);
+  let current = resolve35(startDir);
   for (let i = 0; i < 64; i++) {
     const candidate = join18(current, DEFAULT_UI_REL);
     if (isUiBundleDir(candidate)) return candidate;
@@ -22169,6 +22478,7 @@ async function createServer(options, extra = {}) {
   const broadcaster = new WsBroadcaster();
   const { pluginRuntime, kindRegistry } = await assemblePluginRuntime(options, runtimeContext);
   const { kernel, contributionsRegistry } = assembleKernel(pluginRuntime, options.noBuiltIns);
+  const watcherHolder = { current: null };
   const app = createApp({
     options,
     specVersion,
@@ -22177,6 +22487,7 @@ async function createServer(options, extra = {}) {
     kindRegistry,
     contributionsRegistry,
     pluginRuntime,
+    watcherHolder,
     kernel
   });
   const wss = new WebSocketServer({ noServer: true });
@@ -22196,6 +22507,7 @@ async function createServer(options, extra = {}) {
     try {
       await candidate.start();
       watcherService = candidate;
+      watcherHolder.current = candidate;
     } catch (err) {
       const message = formatErrorMessage(err);
       log.warn(
@@ -22390,7 +22702,8 @@ function renderBanner(input) {
     dbDisplay,
     pathDisplay: formatCwdPath(input.cwd),
     browserLine,
-    colorEnabled: input.colorEnabled
+    colorEnabled: input.colorEnabled,
+    referencePaths: input.referencePaths ?? []
   });
 }
 function resolveColorEnabled(opts) {
@@ -22447,11 +22760,23 @@ function renderFiglet(input) {
   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: "",
@@ -22571,7 +22896,7 @@ var ServeCommand = class extends SmCommand {
       return ExitCode.Error;
     }
     const dbPath = resolveDbPath({ db: this.db, ...runtimeCtx });
-    if (this.db !== void 0 && !existsSync27(dbPath)) {
+    if (this.db !== void 0 && !existsSync28(dbPath)) {
       this.printer.info(
         tx(SERVE_TEXTS.dbNotFound, { path: sanitizeForTerminal(dbPath) })
       );
@@ -22647,6 +22972,12 @@ var ServeCommand = class extends SmCommand {
       noColorFlag: this.noColor,
       env: process.env
     });
+    let referencePaths = [];
+    try {
+      const cfg = loadConfig({ cwd: runtimeCtx.cwd }).effective;
+      referencePaths = cfg.scan.referencePaths;
+    } catch {
+    }
     this.printer.info(
       renderBanner({
         version: VERSION,
@@ -22656,7 +22987,8 @@ var ServeCommand = class extends SmCommand {
         cwd: runtimeCtx.cwd,
         openBrowser: validation.options.open,
         isTTY,
-        colorEnabled
+        colorEnabled,
+        referencePaths
       })
     );
     if (validation.options.open) {
@@ -23067,8 +23399,8 @@ function rankConfidenceForGrouping(c) {
 }
 
 // cli/commands/sidecar.ts
-import { existsSync as existsSync28, unlinkSync as unlinkSync2 } from "fs";
-import { resolve as resolve35 } from "path";
+import { existsSync as existsSync29, unlinkSync as unlinkSync2 } from "fs";
+import { resolve as resolve36 } from "path";
 import { Command as Command35, Option as Option33 } from "clipanion";
 
 // cli/i18n/sidecar.texts.ts
@@ -23219,7 +23551,7 @@ var SidecarRefreshCommand = class extends SmCommand {
     let absPath;
     try {
       assertContained(ctx.cwd, node.path);
-      absPath = resolve35(ctx.cwd, node.path);
+      absPath = resolve36(ctx.cwd, node.path);
     } catch (err) {
       this.printer.error(
         tx(SIDECAR_TEXTS.refreshFailed, { glyph: errGlyph, message: formatErrorMessage(err) })
@@ -23500,7 +23832,7 @@ var SidecarAnnotateCommand = class extends SmCommand {
     let absPath;
     try {
       assertContained(ctx.cwd, node.path);
-      absPath = resolve35(ctx.cwd, node.path);
+      absPath = resolve36(ctx.cwd, node.path);
     } catch (err) {
       this.printer.error(
         tx(SIDECAR_TEXTS.annotateFailed, { glyph: errGlyph, message: formatErrorMessage(err) })
@@ -23508,7 +23840,7 @@ var SidecarAnnotateCommand = class extends SmCommand {
       return ExitCode.Error;
     }
     const sidecarAbsPath = sidecarPathFor(absPath);
-    if (existsSync28(sidecarAbsPath) && this.force !== true) {
+    if (existsSync29(sidecarAbsPath) && this.force !== true) {
       this.printer.error(
         tx(SIDECAR_TEXTS.annotateExists, {
           glyph: errGlyph,
@@ -23518,7 +23850,7 @@ var SidecarAnnotateCommand = class extends SmCommand {
       );
       return ExitCode.Error;
     }
-    if (existsSync28(sidecarAbsPath) && this.force === true) {
+    if (existsSync29(sidecarAbsPath) && this.force === true) {
       try {
         unlinkSync2(sidecarAbsPath);
       } catch (err) {
@@ -23748,8 +24080,8 @@ var STUB_COMMANDS = [
 ];
 
 // cli/commands/tutorial.ts
-import { cpSync as cpSync2, existsSync as existsSync29, mkdirSync as mkdirSync7, rmSync as rmSync2, statSync as statSync11 } from "fs";
-import { dirname as dirname19, join as join19, resolve as resolve36 } from "path";
+import { cpSync as cpSync2, existsSync as existsSync30, mkdirSync as mkdirSync7, rmSync as rmSync2, statSync as statSync12 } from "fs";
+import { dirname as dirname19, join as join19, resolve as resolve37 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { Command as Command37, Option as Option35 } from "clipanion";
 
@@ -23847,7 +24179,7 @@ var TutorialCommand = class extends SmCommand {
     const spec = VARIANT_SPECS[variant];
     const targetDir = join19(ctx.cwd, ".claude", "skills", spec.slug);
     const targetDisplay = `.claude/skills/${spec.slug}/`;
-    if (existsSync29(targetDir) && !this.force) {
+    if (existsSync30(targetDir) && !this.force) {
       this.printer.error(
         tx(TUTORIAL_TEXTS.alreadyExists, {
           glyph: errGlyph,
@@ -23923,14 +24255,14 @@ function resolveSkillSourceDir(variant) {
   const here = dirname19(fileURLToPath6(import.meta.url));
   const candidates = [
     // dev: src/cli/commands/ → repo-root .claude/skills/<slug>/
-    resolve36(here, "../../..", spec.sourceDir),
+    resolve37(here, "../../..", spec.sourceDir),
     // bundled: dist/cli.js → dist/cli/tutorial/<slug> (sibling)
-    resolve36(here, "cli/tutorial", spec.slug),
+    resolve37(here, "cli/tutorial", spec.slug),
     // bundled fallback: any-depth → cli/tutorial/<slug>
-    resolve36(here, "../cli/tutorial", spec.slug)
+    resolve37(here, "../cli/tutorial", spec.slug)
   ];
   for (const candidate of candidates) {
-    if (existsSync29(candidate) && statSync11(candidate).isDirectory()) {
+    if (existsSync30(candidate) && statSync12(candidate).isDirectory()) {
       cachedSourceDirs.set(variant, candidate);
       return candidate;
     }
@@ -24107,7 +24439,7 @@ await lifecycleDispatcher.dispatch(
 process.exit(exitCode);
 function resolveBareDefault() {
   const ctx = defaultRuntimeContext();
-  if (existsSync30(defaultProjectDbPath(ctx))) {
+  if (existsSync31(defaultProjectDbPath(ctx))) {
     return ["serve"];
   }
   process.stderr.write(tx(ENTRY_TEXTS.bareNoProject, { cwd: ctx.cwd }));