diffwiki-core 0.14.0 → 0.15.0

package/dist/index.cjs

@@ -110,6 +110,9 @@ function configPath() {
 function collectionsDir() {
   return import_node_path.default.join(resolveHome(), "collections");
 }
+function templatesDir() {
+  return import_node_path.default.join(resolveHome(), "templates");
+}
 function collectionDir(name) {
   return import_node_path.default.join(collectionsDir(), name);
 }
@@ -134,7 +137,7 @@ function isMissing(err) {
 }
 async function readRegistry() {
   try {
-    const parsed = JSON.parse(await import_promises.default.readFile(registryPath(), "utf8"));
+    const parsed = JSON.parse(await import_promises2.default.readFile(registryPath(), "utf8"));
     return { version: parsed.version ?? 1, collections: parsed.collections ?? [] };
   } catch (err) {
     if (isMissing(err)) return { version: 1, collections: [] };
@@ -142,8 +145,8 @@ async function readRegistry() {
   }
 }
 async function writeRegistry(registry) {
-  await import_promises.default.mkdir(resolveHome(), { recursive: true });
-  await import_promises.default.writeFile(registryPath(), `${JSON.stringify(registry, null, 2)}
+  await import_promises2.default.mkdir(resolveHome(), { recursive: true });
+  await import_promises2.default.writeFile(registryPath(), `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 async function registerCollection(entry) {
@@ -161,11 +164,11 @@ async function unregisterCollection(name) {
   registry.collections = registry.collections.filter((c) => c.name !== name);
   await writeRegistry(registry);
 }
-var import_promises;
+var import_promises2;
 var init_registry = __esm({
   "src/registry.ts"() {
     "use strict";
-    import_promises = __toESM(require("fs/promises"), 1);
+    import_promises2 = __toESM(require("fs/promises"), 1);
     init_paths();
   }
 });
@@ -176,7 +179,7 @@ function isMissing2(err) {
 }
 async function readPluginRegistry() {
   try {
-    const parsed = JSON.parse(await import_promises2.default.readFile(pluginsRegistryPath(), "utf8"));
+    const parsed = JSON.parse(await import_promises3.default.readFile(pluginsRegistryPath(), "utf8"));
     return { version: parsed.version ?? 1, plugins: parsed.plugins ?? [] };
   } catch (err) {
     if (isMissing2(err)) return { version: 1, plugins: [] };
@@ -184,8 +187,8 @@ async function readPluginRegistry() {
   }
 }
 async function writePluginRegistry(registry) {
-  await import_promises2.default.mkdir(resolveHome(), { recursive: true });
-  await import_promises2.default.writeFile(pluginsRegistryPath(), `${JSON.stringify(registry, null, 2)}
+  await import_promises3.default.mkdir(resolveHome(), { recursive: true });
+  await import_promises3.default.writeFile(pluginsRegistryPath(), `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 async function upsertPlugin(record) {
@@ -216,11 +219,11 @@ async function findPluginRecord(name) {
   const registry = await readPluginRegistry();
   return registry.plugins.find((p) => p.name === name);
 }
-var import_promises2;
+var import_promises3;
 var init_registry2 = __esm({
   "src/plugins/registry.ts"() {
     "use strict";
-    import_promises2 = __toESM(require("fs/promises"), 1);
+    import_promises3 = __toESM(require("fs/promises"), 1);
     init_paths();
   }
 });
@@ -247,7 +250,7 @@ var init_logger = __esm({
 // src/plugins/host.ts
 async function invokePlugin(command, op, params, opts) {
   const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const scope = opts?.name ?? (0, import_node_path2.basename)(command[1] ?? command[0] ?? "plugin");
+  const scope = opts?.name ?? (0, import_node_path3.basename)(command[1] ?? command[0] ?? "plugin");
   return new Promise((resolve, reject) => {
     const child = (0, import_node_child_process.spawn)(command[0], command.slice(1), {
       stdio: ["pipe", "pipe", "pipe"]
@@ -351,7 +354,7 @@ function mapHits(result, collections) {
     if (typeof h.collection !== "string" || typeof h.relPath !== "string") continue;
     const title = typeof h.title === "string" ? h.title : h.relPath;
     const coll = collections.find((c) => c.name === h.collection);
-    const abs = coll ? import_node_path2.default.join(coll.path, h.relPath) : h.relPath;
+    const abs = coll ? import_node_path3.default.join(coll.path, h.relPath) : h.relPath;
     out.push({
       collection: h.collection,
       path: abs,
@@ -359,7 +362,11 @@ function mapHits(result, collections) {
       tags: Array.isArray(h.tags) ? h.tags.filter((t) => typeof t === "string") : [],
       snippet: typeof h.snippet === "string" ? h.snippet : void 0,
       score: typeof h.score === "number" ? h.score : void 0,
-      docid: typeof h.docid === "string" ? h.docid : void 0
+      docid: typeof h.docid === "string" ? h.docid : void 0,
+      rawChunk: typeof h.rawChunk === "string" ? h.rawChunk : void 0,
+      cleanedChunk: typeof h.cleanedChunk === "string" ? h.cleanedChunk : void 0,
+      line: typeof h.line === "number" ? h.line : void 0,
+      snippetFromBody: h.snippetFromBody === true ? true : void 0
     });
   }
   return out;
@@ -389,7 +396,8 @@ async function loadSearchProvider(name) {
           collections: toWireCollections(collections),
           collection: opts?.collection,
           type: opts?.type,
-          limit: opts?.limit
+          limit: opts?.limit,
+          expansions: opts?.expansions
         },
         { timeoutMs: SEARCH_TIMEOUT_MS, name: record.name }
       );
@@ -447,12 +455,12 @@ async function listSearchModes() {
   }
   return modes;
 }
-var import_node_child_process, import_node_path2, LEVEL_METHOD, DEFAULT_TIMEOUT_MS, SEARCH_TIMEOUT_MS, LONG_TIMEOUT_MS;
+var import_node_child_process, import_node_path3, LEVEL_METHOD, DEFAULT_TIMEOUT_MS, SEARCH_TIMEOUT_MS, LONG_TIMEOUT_MS;
 var init_host = __esm({
   "src/plugins/host.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
-    import_node_path2 = __toESM(require("path"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
     init_logger();
     init_types();
     init_registry2();
@@ -526,7 +534,7 @@ async function findCollectionById(id) {
 async function createCollection(name, opts) {
   if (await findCollection(name)) throw new CollectionExistsError(name);
   const dir = collectionDir(name);
-  await import_promises3.default.mkdir(dir, { recursive: true });
+  await import_promises4.default.mkdir(dir, { recursive: true });
   const entry = {
     name,
     type: "global",
@@ -543,16 +551,16 @@ async function removeCollection(name) {
   if (!entry) throw new CollectionNotFoundError(name);
   await unregisterCollection(name);
   if (entry.type === "global") {
-    await import_promises3.default.rm(entry.path, { recursive: true, force: true });
+    await import_promises4.default.rm(entry.path, { recursive: true, force: true });
   }
   void fireHook("collection-removed", name);
   return entry;
 }
-var import_promises3;
+var import_promises4;
 var init_collections = __esm({
   "src/collections.ts"() {
     "use strict";
-    import_promises3 = __toESM(require("fs/promises"), 1);
+    import_promises4 = __toESM(require("fs/promises"), 1);
     init_paths();
     init_registry();
     init_errors();
@@ -616,11 +624,14 @@ __export(index_exports, {
   listEnabledPlugins: () => listEnabledPlugins,
   listPlugins: () => listPlugins,
   listSearchModes: () => listSearchModes,
+  listTemplateShapes: () => listTemplateShapes,
+  listTemplates: () => listTemplates,
   loadSearchProvider: () => loadSearchProvider,
   localGraph: () => localGraph,
   nativeSearch: () => nativeSearch,
   parseAddTarget: () => parseAddTarget,
   parseArticle: () => parseArticle,
+  parseFrontmatter: () => parseFrontmatter,
   parsePathTarget: () => parsePathTarget,
   pluginsDir: () => pluginsDir,
   pluginsRegistryPath: () => pluginsRegistryPath,
@@ -642,6 +653,7 @@ __export(index_exports, {
   removePlugin: () => removePlugin,
   removeTags: () => removeTags,
   renderArticle: () => renderArticle,
+  repairPlugins: () => repairPlugins,
   repoId: () => repoId,
   repoRemoteName: () => repoRemoteName,
   resolveCollectionSelection: () => resolveCollectionSelection,
@@ -655,13 +667,17 @@ __export(index_exports, {
   resolveProjectCollections: () => resolveProjectCollections,
   search: () => search,
   seedProjectHome: () => seedProjectHome,
+  seedTemplates: () => seedTemplates,
   serializeArticle: () => serializeArticle,
   setArticleMeta: () => setArticleMeta,
   setConfigValue: () => setConfigValue,
+  setContextCollections: () => setContextCollections,
   setTags: () => setTags,
   showSystemEnabled: () => showSystemEnabled,
   slugify: () => slugify,
   slugifyPath: () => slugifyPath,
+  stripFrontmatter: () => stripFrontmatter,
+  templatesDir: () => templatesDir,
   toTreeNodes: () => toTreeNodes,
   tokenize: () => tokenize,
   unregisterCollection: () => unregisterCollection,
@@ -677,70 +693,10 @@ init_types();
 init_errors();
 init_paths();
 
-// src/config.ts
-var import_promises4 = __toESM(require("fs/promises"), 1);
+// src/templates.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 init_paths();
-init_collections();
-init_errors();
-init_registry2();
-init_types();
-function isMissing3(err) {
-  return err?.code === "ENOENT";
-}
-async function readConfig() {
-  try {
-    return JSON.parse(await import_promises4.default.readFile(configPath(), "utf8"));
-  } catch (err) {
-    if (isMissing3(err)) return {};
-    throw err;
-  }
-}
-async function writeConfig(config) {
-  await import_promises4.default.mkdir(resolveHome(), { recursive: true });
-  await import_promises4.default.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
-`, "utf8");
-}
-async function setConfigValue(key, value) {
-  if (key === "defaultCollection" && !await findCollection(value)) {
-    throw new CollectionNotFoundError(value);
-  }
-  if (key === "defaultSearch") {
-    const engine = value.split(":")[0];
-    if (engine !== NATIVE_ENGINE) {
-      const enabled = await listEnabledPlugins("search");
-      if (!enabled.some((p) => p.name === engine)) {
-        console.warn(
-          `! defaultSearch "${value}" names an engine that is not installed/enabled \u2014 native will be used until it is`
-        );
-      }
-    }
-  }
-  const config = await readConfig();
-  config[key] = value;
-  await writeConfig(config);
-}
-async function getConfigValue(key) {
-  const config = await readConfig();
-  const value = config[key];
-  return typeof value === "string" ? value : void 0;
-}
-async function showSystemEnabled() {
-  const config = await readConfig();
-  return config.showSystem === true || config.showSystem === "true";
-}
-
-// src/index.ts
-init_registry();
-
-// src/slugify.ts
-function slugify(input) {
-  const slug = input.toLowerCase().replace(/^#+\s*/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/g, "");
-  return slug.length > 0 ? slug : "untitled";
-}
-function slugifyPath(input) {
-  const segs = input.split("/").map((s) => s.trim()).filter((s) => s.length > 0).map((s) => slugify(s));
-  return segs.length > 0 ? segs.join("/") : "untitled";
-}
 
 // src/frontmatter.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
@@ -787,6 +743,18 @@ function parseFallback(raw) {
   }
   return { title, tags: [], audience, status, body: body.replace(/^\n+/, "") };
 }
+var FRONTMATTER_BLOCK_RE = /^\uFEFF?[ \t]*---\r?\n[\s\S]*?\r?\n---[ \t]*(?:\r?\n|$)/;
+function stripFrontmatter(raw) {
+  return raw.replace(FRONTMATTER_BLOCK_RE, "");
+}
+function parseFrontmatter(raw) {
+  try {
+    const { data, content } = (0, import_gray_matter.default)(raw, MATTER_OPTS);
+    return { data: data ?? {}, body: content };
+  } catch {
+    return { data: {}, body: raw };
+  }
+}
 function parseArticle(raw) {
   try {
     const { data, content } = (0, import_gray_matter.default)(raw, MATTER_OPTS);
@@ -807,12 +775,118 @@ function serializeArticle(article) {
   return import_gray_matter.default.stringify(article.body, front, MATTER_OPTS);
 }
 
+// src/templates.ts
+async function seedTemplates(srcDir) {
+  const dir = templatesDir();
+  await import_promises.default.mkdir(dir, { recursive: true });
+  const files = (await import_promises.default.readdir(srcDir)).filter((f) => f.endsWith(".md")).sort();
+  const seeded = [];
+  const skipped = [];
+  for (const file of files) {
+    const dest = import_node_path2.default.join(dir, file);
+    try {
+      await import_promises.default.access(dest);
+      skipped.push(file);
+      continue;
+    } catch {
+    }
+    await import_promises.default.copyFile(import_node_path2.default.join(srcDir, file), dest);
+    seeded.push(file);
+  }
+  return { seeded, skipped, dir };
+}
+async function listTemplateShapes(srcDir) {
+  const files = await import_promises.default.readdir(srcDir);
+  return files.filter((f) => f.endsWith("-template.md")).map((f) => f.replace(/-template\.md$/, "")).sort();
+}
+async function listTemplates(srcDir) {
+  const files = (await import_promises.default.readdir(srcDir)).filter((f) => f.endsWith("-template.md")).sort();
+  const out = [];
+  for (const file of files) {
+    let data = {};
+    try {
+      ({ data } = parseFrontmatter(await import_promises.default.readFile(import_node_path2.default.join(srcDir, file), "utf8")));
+    } catch {
+    }
+    const shape = typeof data.shape === "string" && data.shape ? data.shape : file.replace(/-template\.md$/, "");
+    const purpose = typeof data.purpose === "string" ? data.purpose : "";
+    const budget = Array.isArray(data.budget) && data.budget.length === 2 ? [Number(data.budget[0]), Number(data.budget[1])] : void 0;
+    out.push({ shape, purpose, budget, file });
+  }
+  return out;
+}
+
+// src/config.ts
+var import_promises5 = __toESM(require("fs/promises"), 1);
+init_paths();
+init_collections();
+init_errors();
+init_registry2();
+init_types();
+function isMissing3(err) {
+  return err?.code === "ENOENT";
+}
+async function readConfig() {
+  try {
+    return JSON.parse(await import_promises5.default.readFile(configPath(), "utf8"));
+  } catch (err) {
+    if (isMissing3(err)) return {};
+    throw err;
+  }
+}
+async function writeConfig(config) {
+  await import_promises5.default.mkdir(resolveHome(), { recursive: true });
+  await import_promises5.default.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+async function setConfigValue(key, value) {
+  if (key === "defaultCollection" && !await findCollection(value)) {
+    throw new CollectionNotFoundError(value);
+  }
+  if (key === "defaultSearch") {
+    const engine = value.split(":")[0];
+    if (engine !== NATIVE_ENGINE) {
+      const enabled = await listEnabledPlugins("search");
+      if (!enabled.some((p) => p.name === engine)) {
+        console.warn(
+          `! defaultSearch "${value}" names an engine that is not installed/enabled \u2014 native will be used until it is`
+        );
+      }
+    }
+  }
+  const config = await readConfig();
+  config[key] = value;
+  await writeConfig(config);
+}
+async function getConfigValue(key) {
+  const config = await readConfig();
+  const value = config[key];
+  return typeof value === "string" ? value : void 0;
+}
+async function showSystemEnabled() {
+  const config = await readConfig();
+  return config.showSystem === true || config.showSystem === "true";
+}
+
+// src/index.ts
+init_registry();
+
+// src/slugify.ts
+function slugify(input) {
+  const slug = input.toLowerCase().replace(/^#+\s*/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/g, "");
+  return slug.length > 0 ? slug : "untitled";
+}
+function slugifyPath(input) {
+  const segs = input.split("/").map((s) => s.trim()).filter((s) => s.length > 0).map((s) => slugify(s));
+  return segs.length > 0 ? segs.join("/") : "untitled";
+}
+
 // src/index.ts
 init_collections();
 
 // src/articles.ts
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 init_collections();
 init_errors();
 async function fireHook2(event, collection, relPath) {
@@ -859,24 +933,24 @@ function ensureMdPath(file) {
 async function createArticle(opts) {
   const { collection, title } = parseAddTarget(opts.target);
   const { name, dir } = await resolveCollectionDir(collection);
-  const filePath = import_node_path3.default.join(dir, `${slugifyPath(title)}.md`);
+  const filePath = import_node_path4.default.join(dir, `${slugifyPath(title)}.md`);
   const body = opts.body ?? `# ${title}
 `;
-  await import_promises5.default.mkdir(import_node_path3.default.dirname(filePath), { recursive: true });
-  await import_promises5.default.writeFile(
+  await import_promises6.default.mkdir(import_node_path4.default.dirname(filePath), { recursive: true });
+  await import_promises6.default.writeFile(
     filePath,
     serializeArticle({ title, tags: opts.tags, body, audience: opts.audience, status: opts.status }),
     "utf8"
   );
-  void fireHook2("article-created", name, import_node_path3.default.relative(dir, filePath));
+  void fireHook2("article-created", name, import_node_path4.default.relative(dir, filePath));
   return { title, tags: opts.tags, path: filePath, collection: name };
 }
 async function loadArticle(target) {
   const { collection, file } = parsePathTarget(target);
   const { dir } = await resolveCollectionDir(collection);
-  const filePath = import_node_path3.default.join(dir, ensureMdPath(file));
+  const filePath = import_node_path4.default.join(dir, ensureMdPath(file));
   try {
-    return { filePath, dir, raw: await import_promises5.default.readFile(filePath, "utf8"), collection };
+    return { filePath, dir, raw: await import_promises6.default.readFile(filePath, "utf8"), collection };
   } catch (err) {
     if (err.code === "ENOENT") throw new ArticleNotFoundError(target);
     throw err;
@@ -885,7 +959,7 @@ async function loadArticle(target) {
 async function updateArticleBody(target, body) {
   const { filePath, dir, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
-  await import_promises5.default.writeFile(
+  await import_promises6.default.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -896,14 +970,14 @@ async function updateArticleBody(target, body) {
     }),
     "utf8"
   );
-  void fireHook2("article-updated", collection, import_node_path3.default.relative(dir, filePath));
+  void fireHook2("article-updated", collection, import_node_path4.default.relative(dir, filePath));
   return { title: parsed.title, tags: parsed.tags, path: filePath, collection };
 }
 async function mutateTags(target, fn) {
   const { filePath, dir, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
   const tags = fn(parsed.tags);
-  await import_promises5.default.writeFile(
+  await import_promises6.default.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -914,7 +988,7 @@ async function mutateTags(target, fn) {
     }),
     "utf8"
   );
-  void fireHook2("article-updated", collection, import_node_path3.default.relative(dir, filePath));
+  void fireHook2("article-updated", collection, import_node_path4.default.relative(dir, filePath));
   return { title: parsed.title, tags, path: filePath, collection };
 }
 function addTags(target, tags) {
@@ -932,24 +1006,24 @@ async function setArticleMeta(target, meta) {
   const parsed = parseArticle(raw);
   const audience = meta.audience ?? parsed.audience;
   const status = meta.status ?? parsed.status;
-  await import_promises5.default.writeFile(
+  await import_promises6.default.writeFile(
     filePath,
     serializeArticle({ title: parsed.title, tags: parsed.tags, audience, status, body: parsed.body }),
     "utf8"
   );
-  void fireHook2("article-updated", collection, import_node_path3.default.relative(dir, filePath));
+  void fireHook2("article-updated", collection, import_node_path4.default.relative(dir, filePath));
   return { title: parsed.title, tags: parsed.tags, path: filePath, collection };
 }
 async function removeArticle(target) {
   const { filePath, dir, collection } = await loadArticle(target);
-  await import_promises5.default.rm(filePath);
-  void fireHook2("article-removed", collection, import_node_path3.default.relative(dir, filePath));
+  await import_promises6.default.rm(filePath);
+  void fireHook2("article-removed", collection, import_node_path4.default.relative(dir, filePath));
   return filePath;
 }
 
 // src/repo.ts
-var import_promises7 = __toESM(require("fs/promises"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_promises8 = __toESM(require("fs/promises"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var import_node_child_process3 = require("child_process");
 var import_node_util2 = require("util");
 var import_yaml2 = require("yaml");
@@ -957,8 +1031,8 @@ init_collections();
 init_registry();
 
 // src/git.ts
-var import_promises6 = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var import_promises7 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var import_node_child_process2 = require("child_process");
 var import_node_util = require("util");
 init_logger();
@@ -984,8 +1058,8 @@ async function isLinkedWorktree(cwd) {
   const gitDir = await git(cwd, ["rev-parse", "--absolute-git-dir"]);
   const commonDir = await git(cwd, ["rev-parse", "--git-common-dir"]);
   if (!gitDir || !commonDir) return false;
-  const commonAbs = import_node_path4.default.isAbsolute(commonDir) ? commonDir : import_node_path4.default.resolve(cwd, commonDir);
-  return import_node_path4.default.resolve(gitDir) !== import_node_path4.default.resolve(commonAbs);
+  const commonAbs = import_node_path5.default.isAbsolute(commonDir) ? commonDir : import_node_path5.default.resolve(cwd, commonDir);
+  return import_node_path5.default.resolve(gitDir) !== import_node_path5.default.resolve(commonAbs);
 }
 async function repoRemoteName(cwd) {
   const url = await git(cwd, ["remote", "get-url", "origin"]);
@@ -1027,8 +1101,8 @@ var timestampCache = /* @__PURE__ */ new Map();
 async function fileTimestamps(absPath) {
   const cached2 = timestampCache.get(absPath);
   if (cached2) return cached2;
-  const dir = import_node_path4.default.dirname(absPath);
-  const base = import_node_path4.default.basename(absPath);
+  const dir = import_node_path5.default.dirname(absPath);
+  const base = import_node_path5.default.basename(absPath);
   const [addLog, lastLog] = await Promise.all([
     git(dir, ["log", "--follow", "--diff-filter=A", "--format=%aI", "--", base]),
     git(dir, ["log", "-1", "--format=%aI", "--", base])
@@ -1039,7 +1113,7 @@ async function fileTimestamps(absPath) {
   let updated = gitUpdated;
   if (!created || !updated) {
     try {
-      const st = await import_promises6.default.stat(absPath);
+      const st = await import_promises7.default.stat(absPath);
       if (!updated) updated = st.mtime.toISOString();
       if (!created) created = isEpochish(st.birthtime) ? st.mtime.toISOString() : st.birthtime.toISOString();
     } catch {
@@ -1057,18 +1131,18 @@ var REPO_CONFIG_FILE = "diffwiki.yaml";
 async function detectRepoName(cwd) {
   try {
     const { stdout } = await execFileAsync2("git", ["rev-parse", "--show-toplevel"], { cwd });
-    return import_node_path5.default.basename(stdout.trim());
+    return import_node_path6.default.basename(stdout.trim());
   } catch {
-    return import_node_path5.default.basename(import_node_path5.default.resolve(cwd));
+    return import_node_path6.default.basename(import_node_path6.default.resolve(cwd));
   }
 }
 async function readRepoConfig(cwd) {
   try {
-    const raw = await import_promises7.default.readFile(import_node_path5.default.join(cwd, REPO_CONFIG_FILE), "utf8");
+    const raw = await import_promises8.default.readFile(import_node_path6.default.join(cwd, REPO_CONFIG_FILE), "utf8");
     const parsed = (0, import_yaml2.parse)(raw) ?? {};
     if (!parsed.path) return void 0;
     return {
-      collection: parsed.collection ?? import_node_path5.default.basename(import_node_path5.default.resolve(cwd)),
+      collection: parsed.collection ?? import_node_path6.default.basename(import_node_path6.default.resolve(cwd)),
       path: parsed.path
     };
   } catch (err) {
@@ -1077,9 +1151,9 @@ async function readRepoConfig(cwd) {
   }
 }
 async function initRepoWiki(opts) {
-  const cwd = import_node_path5.default.resolve(opts.cwd);
+  const cwd = import_node_path6.default.resolve(opts.cwd);
   const wikiPath = opts.wikiPath ?? "wiki";
-  const absWiki = import_node_path5.default.join(cwd, wikiPath);
+  const absWiki = import_node_path6.default.join(cwd, wikiPath);
   let name = opts.collection ?? await detectRepoName(cwd);
   const existing = await findCollection(name);
   if (existing && existing.path !== absWiki) {
@@ -1094,9 +1168,9 @@ async function initRepoWiki(opts) {
       n += 1;
     }
   }
-  await import_promises7.default.mkdir(absWiki, { recursive: true });
+  await import_promises8.default.mkdir(absWiki, { recursive: true });
   const config = { collection: name, path: wikiPath };
-  await import_promises7.default.writeFile(import_node_path5.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml2.stringify)(config), "utf8");
+  await import_promises8.default.writeFile(import_node_path6.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml2.stringify)(config), "utf8");
   const entry = {
     name,
     type: "repo",
@@ -1107,15 +1181,15 @@ async function initRepoWiki(opts) {
   return entry;
 }
 async function addExternalCollection(opts) {
-  const cwd = import_node_path5.default.resolve(opts.cwd);
+  const cwd = import_node_path6.default.resolve(opts.cwd);
   const root = await ensureGitRepo(cwd);
   if (await isLinkedWorktree(cwd)) throw new WorktreeNotAllowedError(root);
   const id = await repoId(root) ?? `path:${root}`;
   const already = await findCollectionById(id);
   if (already) throw new CollectionAlreadyAddedError(already.name);
   const docsRel = opts.docsDir ?? "docs";
-  const contentDir = import_node_path5.default.join(root, docsRel);
-  let name = await repoRemoteName(root) ?? import_node_path5.default.basename(root);
+  const contentDir = import_node_path6.default.join(root, docsRel);
+  let name = await repoRemoteName(root) ?? import_node_path6.default.basename(root);
   if (await findCollection(name)) {
     let n = 2;
     while (await findCollection(`${name}-${n}`)) n += 1;
@@ -1134,14 +1208,14 @@ async function addExternalCollection(opts) {
   return entry;
 }
 async function resolveCwdCollection(cwd) {
-  const abs = import_node_path5.default.resolve(cwd);
+  const abs = import_node_path6.default.resolve(cwd);
   const root = await gitToplevel(abs);
   if (root) {
     const id = await repoId(root) ?? `path:${root}`;
     const byId = await findCollectionById(id);
     if (byId) return byId;
   }
-  const within = (base) => abs === base || abs.startsWith(base + import_node_path5.default.sep);
+  const within = (base) => abs === base || abs.startsWith(base + import_node_path6.default.sep);
   const all = await listCollections();
   let best;
   let bestLen = -1;
@@ -1165,9 +1239,9 @@ async function collectionGitStatus(entry) {
 }
 
 // src/project.ts
-var import_promises8 = __toESM(require("fs/promises"), 1);
+var import_promises9 = __toESM(require("fs/promises"), 1);
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 var import_yaml3 = require("yaml");
 var PROJECT_CONFIG_FILE = "diffwiki.yaml";
 function normaliseSite(raw) {
@@ -1222,7 +1296,7 @@ function normaliseContext(raw) {
 async function readProjectConfig(dir) {
   let raw;
   try {
-    raw = await import_promises8.default.readFile(import_node_path6.default.join(dir, PROJECT_CONFIG_FILE), "utf8");
+    raw = await import_promises9.default.readFile(import_node_path7.default.join(dir, PROJECT_CONFIG_FILE), "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
     throw err;
@@ -1243,7 +1317,7 @@ async function readProjectConfig(dir) {
     }
     collections.sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
   } else if (typeof parsed.path === "string") {
-    const name = typeof parsed.collection === "string" ? parsed.collection : import_node_path6.default.basename(import_node_path6.default.resolve(dir));
+    const name = typeof parsed.collection === "string" ? parsed.collection : import_node_path7.default.basename(import_node_path7.default.resolve(dir));
     collections.push({ name, path: parsed.path });
   }
   const site = normaliseSite(parsed.site);
@@ -1253,15 +1327,28 @@ async function readProjectConfig(dir) {
 async function readContextCollections(dir) {
   return (await readProjectConfig(dir))?.context?.collections ?? [];
 }
+async function setContextCollections(dir, collections) {
+  const file = import_node_path7.default.join(dir, PROJECT_CONFIG_FILE);
+  let raw = "";
+  try {
+    raw = await import_promises9.default.readFile(file, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const doc = (0, import_yaml3.parseDocument)(raw);
+  doc.setIn(["context", "collections"], collections);
+  await import_promises9.default.writeFile(file, doc.toString(), "utf8");
+  return file;
+}
 async function resolveProjectCollections(dir) {
   const config = await readProjectConfig(dir);
   if (!config) return [];
-  const root = import_node_path6.default.resolve(dir);
+  const root = import_node_path7.default.resolve(dir);
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
   return config.collections.map((c) => ({
     name: c.name,
     type: "repo",
-    path: import_node_path6.default.resolve(root, c.path),
+    path: import_node_path7.default.resolve(root, c.path),
     createdAt
   }));
 }
@@ -1271,11 +1358,11 @@ async function readSiteConfig(dir) {
 async function seedProjectHome(dir) {
   const entries = await resolveProjectCollections(dir);
   if (entries.length === 0) {
-    throw new Error(`No collections to render from diffwiki.yaml in ${import_node_path6.default.resolve(dir)}`);
+    throw new Error(`No collections to render from diffwiki.yaml in ${import_node_path7.default.resolve(dir)}`);
   }
-  const home = await import_promises8.default.mkdtemp(import_node_path6.default.join(import_node_os2.default.tmpdir(), "diffwiki-project-"));
-  await import_promises8.default.writeFile(
-    import_node_path6.default.join(home, "registry.json"),
+  const home = await import_promises9.default.mkdtemp(import_node_path7.default.join(import_node_os2.default.tmpdir(), "diffwiki-project-"));
+  await import_promises9.default.writeFile(
+    import_node_path7.default.join(home, "registry.json"),
     `${JSON.stringify({ version: 1, collections: entries }, null, 2)}
 `,
     "utf8"
@@ -1287,8 +1374,8 @@ async function seedProjectHome(dir) {
 init_collections();
 
 // src/browse.ts
-var import_promises9 = __toESM(require("fs/promises"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_promises10 = __toESM(require("fs/promises"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 init_collections();
 init_errors();
 var INDEX_RE = /^(index|readme)\.mdx?$/i;
@@ -1334,7 +1421,7 @@ function buildArticleTree(relPaths) {
 async function collectRelPaths(dir, rel = "") {
   let dirents;
   try {
-    dirents = await import_promises9.default.readdir(dir, { withFileTypes: true });
+    dirents = await import_promises10.default.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -1343,7 +1430,7 @@ async function collectRelPaths(dir, rel = "") {
     if (d.name.startsWith(".")) continue;
     const childRel = rel ? `${rel}/${d.name}` : d.name;
     if (d.isDirectory()) {
-      out.push(...await collectRelPaths(import_node_path7.default.join(dir, d.name), childRel));
+      out.push(...await collectRelPaths(import_node_path8.default.join(dir, d.name), childRel));
     } else if (/\.(mdx?)$/.test(d.name)) {
       out.push(childRel);
     }
@@ -1352,7 +1439,7 @@ async function collectRelPaths(dir, rel = "") {
 }
 async function readdirSafe(dir) {
   try {
-    return await import_promises9.default.readdir(dir);
+    return await import_promises10.default.readdir(dir);
   } catch {
     return [];
   }
@@ -1370,7 +1457,7 @@ var CHEAP_META_BYTES = 8192;
 async function cheapMeta(absPath) {
   let handle;
   try {
-    handle = await import_promises9.default.open(absPath, "r");
+    handle = await import_promises10.default.open(absPath, "r");
     const buf = Buffer.alloc(CHEAP_META_BYTES);
     const { bytesRead } = await handle.read(buf, 0, CHEAP_META_BYTES, 0);
     const snippet = buf.subarray(0, bytesRead).toString("utf8");
@@ -1404,10 +1491,10 @@ async function enrichTitles(nodes, collDir) {
         let status = node.status;
         let order = node.order;
         if (node.slug) {
-          const dir = import_node_path7.default.join(collDir, node.slug);
+          const dir = import_node_path8.default.join(collDir, node.slug);
           const idx = pickIndexFile(await readdirSafe(dir));
           if (idx) {
-            const meta = await cheapMeta(import_node_path7.default.join(dir, idx));
+            const meta = await cheapMeta(import_node_path8.default.join(dir, idx));
             title = meta.title ?? title;
             audience = meta.audience ?? audience;
             status = meta.status ?? status;
@@ -1417,7 +1504,7 @@ async function enrichTitles(nodes, collDir) {
         return { ...node, title, audience, status, order, children };
       }
       for (const ext of [".mdx", ".md"]) {
-        const meta = await cheapMeta(import_node_path7.default.join(collDir, `${node.slug}${ext}`));
+        const meta = await cheapMeta(import_node_path8.default.join(collDir, `${node.slug}${ext}`));
         if (meta.title || meta.audience || meta.status || meta.order != null) {
           return {
             ...node,
@@ -1436,49 +1523,49 @@ async function enrichTitles(nodes, collDir) {
 async function collectionMeta(collDir) {
   const idx = pickIndexFile(await readdirSafe(collDir));
   if (!idx) return {};
-  const meta = await cheapMeta(import_node_path7.default.join(collDir, idx));
+  const meta = await cheapMeta(import_node_path8.default.join(collDir, idx));
   return { title: meta.title, audience: meta.audience, status: meta.status };
 }
 async function listArticleTree(coll) {
   const entry = await findCollection(coll);
   if (!entry) throw new CollectionNotFoundError(coll);
   const rels = await collectRelPaths(entry.path);
-  return enrichTitles(buildArticleTree(rels), import_node_path7.default.resolve(entry.path));
+  return enrichTitles(buildArticleTree(rels), import_node_path8.default.resolve(entry.path));
 }
 async function readArticle(coll, slug) {
   const entry = await findCollection(coll);
   if (!entry) throw new CollectionNotFoundError(coll);
-  const collDir = import_node_path7.default.resolve(entry.path);
+  const collDir = import_node_path8.default.resolve(entry.path);
   const normalized = slug.replace(/\\/g, "/");
   if (normalized.split("/").some((s) => s === "..")) {
     throw new InvalidTargetError(slug, "path traversal detected");
   }
   const safeSlug = normalized.split("/").filter((s) => s !== "" && s !== ".").join("/");
-  const inJail = (p) => p === collDir || p.startsWith(collDir + import_node_path7.default.sep);
+  const inJail = (p) => p === collDir || p.startsWith(collDir + import_node_path8.default.sep);
   let abs;
   let isIndex = false;
   for (const rel of safeSlug ? [`${safeSlug}.mdx`, `${safeSlug}.md`] : []) {
-    const candidate = import_node_path7.default.resolve(collDir, rel);
+    const candidate = import_node_path8.default.resolve(collDir, rel);
     if (!inJail(candidate)) throw new InvalidTargetError(slug, "path traversal detected");
     try {
-      await import_promises9.default.access(candidate);
+      await import_promises10.default.access(candidate);
       abs = candidate;
       break;
     } catch {
     }
   }
   if (!abs) {
-    const dir = import_node_path7.default.resolve(collDir, safeSlug);
+    const dir = import_node_path8.default.resolve(collDir, safeSlug);
     if (inJail(dir)) {
       const idx = pickIndexFile(await readdirSafe(dir));
       if (idx) {
-        abs = import_node_path7.default.join(dir, idx);
+        abs = import_node_path8.default.join(dir, idx);
         isIndex = true;
       }
     }
   }
   if (!abs) throw new ArticleNotFoundError(`${coll}/${safeSlug}`);
-  const parsed = parseArticle(await import_promises9.default.readFile(abs, "utf8"));
+  const parsed = parseArticle(await import_promises10.default.readFile(abs, "utf8"));
   const title = parsed.title?.trim() || (safeSlug ? safeSlug.split("/").pop() ?? safeSlug : coll);
   return {
     coll,
@@ -1494,7 +1581,7 @@ async function readArticle(coll, slug) {
 }
 
 // src/render.ts
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 var import_unified = require("unified");
 var import_remark_parse = __toESM(require("remark-parse"), 1);
 var import_remark_gfm = __toESM(require("remark-gfm"), 1);
@@ -1511,7 +1598,7 @@ function isNonRelativeHref(href) {
   return /^[a-z][a-z0-9+.-]*:/i.test(href);
 }
 function rehypeRewriteLinks(ctx) {
-  const slugDir = ctx.isIndex ? ctx.slug || "." : import_node_path8.default.posix.dirname(ctx.slug || ".");
+  const slugDir = ctx.isIndex ? ctx.slug || "." : import_node_path9.default.posix.dirname(ctx.slug || ".");
   return (tree) => {
     (0, import_unist_util_visit.visit)(tree, "element", (node) => {
       if (node.tagName !== "a") return;
@@ -1521,8 +1608,8 @@ function rehypeRewriteLinks(ctx) {
       const suffix = suffixMatch ? suffixMatch[0] : "";
       const pathPart = suffix ? raw.slice(0, raw.length - suffix.length) : raw;
       if (pathPart === "") return;
-      const joined = import_node_path8.default.posix.join(slugDir === "." ? "" : slugDir, pathPart);
-      const normalized = import_node_path8.default.posix.normalize(joined);
+      const joined = import_node_path9.default.posix.join(slugDir === "." ? "" : slugDir, pathPart);
+      const normalized = import_node_path9.default.posix.normalize(joined);
       const toRoute = (p) => p.replace(/\.(mdx?)$/i, "").replace(/(^|\/)(index|readme)$/i, "$1").replace(/\/+$/, "").replace(/^\/+/, "");
       if (normalized.startsWith("../")) {
         const sibling = normalized.slice(3);
@@ -1925,8 +2012,8 @@ function resolveCollectionSelection(all, sel = {}) {
 }
 
 // src/query.ts
-var import_promises10 = __toESM(require("fs/promises"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_promises11 = __toESM(require("fs/promises"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 init_collections();
 init_errors();
 init_logger();
@@ -1987,6 +2074,12 @@ function rankDocs(term, docs) {
     if (total > 0) scored.push({ ...d, score: total });
   }
   scored.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+  const max = scored[0]?.score ?? 0;
+  if (max > 0) {
+    for (const d of scored) {
+      if (typeof d.score === "number") d.score = Number((d.score / max).toFixed(4));
+    }
+  }
   return scored;
 }
 
@@ -1995,13 +2088,13 @@ var log2 = getLogger("query");
 async function collectMarkdownFiles(dir) {
   let entries;
   try {
-    entries = await import_promises10.default.readdir(dir, { withFileTypes: true });
+    entries = await import_promises11.default.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const files = [];
   for (const entry of entries) {
-    const full = import_node_path9.default.join(dir, entry.name);
+    const full = import_node_path10.default.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await collectMarkdownFiles(full));
     } else if (entry.isFile() && /\.mdx?$/.test(entry.name)) {
@@ -2028,12 +2121,12 @@ async function nativeSearch(term, collections, collection, hideSystem = false) {
   const docs = [];
   for (const entry of targets) {
     for (const full of await collectMarkdownFiles(entry.path)) {
-      const fallbackTitle = import_node_path9.default.basename(full).replace(/\.mdx?$/, "");
+      const fallbackTitle = import_node_path10.default.basename(full).replace(/\.mdx?$/, "");
       let title = fallbackTitle;
       let tags = [];
       let body = "";
       try {
-        const parsed = parseArticle(await import_promises10.default.readFile(full, "utf8"));
+        const parsed = parseArticle(await import_promises11.default.readFile(full, "utf8"));
         if (hideSystem && parsed.audience === "system") continue;
         if (parsed.title) title = parsed.title;
         tags = parsed.tags;
@@ -2091,7 +2184,7 @@ async function dropSystemHits(hits) {
   const kept = [];
   for (const hit of hits) {
     try {
-      if (parseArticle(await import_promises10.default.readFile(hit.path, "utf8")).audience === "system") continue;
+      if (parseArticle(await import_promises11.default.readFile(hit.path, "utf8")).audience === "system") continue;
     } catch {
     }
     kept.push(hit);
@@ -2107,6 +2200,7 @@ async function search(term, opts) {
   const showSystem = opts?.showSystem ?? await showSystemEnabled();
   const hideSystem = !showSystem && wanted.length === 0;
   const searchable = hideSystem ? collections.filter((c) => c.audience !== "system") : collections;
+  const systemCollections = new Set(collections.filter((c) => c.audience === "system").map((c) => c.name));
   const filterHits = (hits) => wanted.length > 0 ? hits.filter((h) => wanted.includes(h.collection)) : hits;
   const engine = opts?.engine ?? await resolveDefaultEngine();
   log2.debug(`resolved search engine "${engine}"`);
@@ -2124,7 +2218,7 @@ async function search(term, opts) {
   try {
     const providerOpts = { ...opts, collection: wanted.length === 1 ? wanted[0] : void 0 };
     const raw = filterHits(await provider.handleSearch(term, searchable, providerOpts));
-    const hits = hideSystem ? await dropSystemHits(raw) : raw;
+    const hits = hideSystem ? await dropSystemHits(raw.filter((h) => !systemCollections.has(h.collection))) : raw;
     return { hits, engine, fellBackToNative: false };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -2138,14 +2232,14 @@ async function query(term, opts) {
 }
 
 // src/search.ts
-var import_promises11 = __toESM(require("fs/promises"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_promises12 = __toESM(require("fs/promises"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 init_collections();
 var isStatic2 = () => process.env.DIFFWIKI_STATIC === "1";
 async function readArticleParts(collDir, slug) {
   for (const ext of [".mdx", ".md"]) {
     try {
-      const parsed = parseArticle(await import_promises11.default.readFile(import_node_path10.default.join(collDir, `${slug}${ext}`), "utf8"));
+      const parsed = parseArticle(await import_promises12.default.readFile(import_node_path11.default.join(collDir, `${slug}${ext}`), "utf8"));
       return { tags: parsed.tags, body: parsed.body };
     } catch {
     }
@@ -2181,7 +2275,7 @@ async function buildSearchIndex(collection) {
   for (const e of entries) {
     try {
       const collEntry = await findCollection(e.name);
-      const collDir = import_node_path10.default.resolve(collEntry?.path ?? e.path);
+      const collDir = import_node_path11.default.resolve(collEntry?.path ?? e.path);
       if (collEntry?.audience === "system") continue;
       if (isStatic2()) {
         const cm = await collectionMeta(collDir);
@@ -2195,15 +2289,15 @@ async function buildSearchIndex(collection) {
 }
 
 // src/doctor.ts
-var import_promises13 = __toESM(require("fs/promises"), 1);
+var import_promises14 = __toESM(require("fs/promises"), 1);
 init_paths();
 init_registry();
 init_collections();
 
 // src/plugins/manager.ts
-var import_promises12 = __toESM(require("fs/promises"), 1);
+var import_promises13 = __toESM(require("fs/promises"), 1);
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 init_paths();
 init_errors();
 init_collections();
@@ -2214,7 +2308,7 @@ init_host();
 var import_node_child_process4 = require("child_process");
 var import_node_util3 = require("util");
 var import_node_fs = require("fs");
-var import_node_path11 = require("path");
+var import_node_path12 = require("path");
 var import_node_url = require("url");
 var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
 async function runProcess(file, args, opts) {
@@ -2230,7 +2324,7 @@ async function runProcess(file, args, opts) {
 // src/plugins/manager.ts
 async function readPackageJson(file) {
   try {
-    return JSON.parse(await import_promises12.default.readFile(file, "utf8"));
+    return JSON.parse(await import_promises13.default.readFile(file, "utf8"));
   } catch {
     return null;
   }
@@ -2246,7 +2340,7 @@ function binOf(manifest) {
 async function pluginManifestDirs(nodeModules) {
   let entries;
   try {
-    entries = await import_promises12.default.readdir(nodeModules);
+    entries = await import_promises13.default.readdir(nodeModules);
   } catch {
     return [];
   }
@@ -2256,44 +2350,44 @@ async function pluginManifestDirs(nodeModules) {
     if (entry.startsWith("@")) {
       let scoped;
       try {
-        scoped = await import_promises12.default.readdir(import_node_path12.default.join(nodeModules, entry));
+        scoped = await import_promises13.default.readdir(import_node_path13.default.join(nodeModules, entry));
       } catch {
         continue;
       }
       for (const pkg of scoped) {
         if (pkg.startsWith(".")) continue;
-        dirs.push(import_node_path12.default.join(nodeModules, entry, pkg));
+        dirs.push(import_node_path13.default.join(nodeModules, entry, pkg));
       }
     } else {
-      dirs.push(import_node_path12.default.join(nodeModules, entry));
+      dirs.push(import_node_path13.default.join(nodeModules, entry));
     }
   }
   return dirs;
 }
 async function ensurePluginRoot() {
   const dir = pluginsDir();
-  await import_promises12.default.mkdir(dir, { recursive: true });
-  const pkgPath = import_node_path12.default.join(dir, "package.json");
+  await import_promises13.default.mkdir(dir, { recursive: true });
+  const pkgPath = import_node_path13.default.join(dir, "package.json");
   if (await readPackageJson(pkgPath) === null) {
     const pkg = { name: "diffwiki-plugins", private: true, version: "0.0.0" };
-    await import_promises12.default.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
+    await import_promises13.default.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
   }
   return dir;
 }
 async function asSearchPackage(pkgDir) {
-  const manifest = await readPackageJson(import_node_path12.default.join(pkgDir, "package.json"));
+  const manifest = await readPackageJson(import_node_path13.default.join(pkgDir, "package.json"));
   if (!manifest?.name || manifest.diffwiki?.kind !== "search") return null;
   const bin = binOf(manifest);
   if (!bin) return null;
-  return { name: manifest.name, version: manifest.version, binAbs: import_node_path12.default.resolve(pkgDir, bin) };
+  return { name: manifest.name, version: manifest.version, binAbs: import_node_path13.default.resolve(pkgDir, bin) };
 }
 async function packageNameFromSpec(spec) {
   const looksLikePath = spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("~") || spec.startsWith("file:");
   if (looksLikePath) {
     const raw = spec.startsWith("file:") ? spec.slice("file:".length) : spec;
-    const abs = import_node_path12.default.resolve(raw.replace(/^~(?=$|\/)/, import_node_os3.default.homedir()));
-    return (await readPackageJson(import_node_path12.default.join(abs, "package.json")))?.name ?? null;
+    const abs = import_node_path13.default.resolve(raw.replace(/^~(?=$|\/)/, import_node_os3.default.homedir()));
+    return (await readPackageJson(import_node_path13.default.join(abs, "package.json")))?.name ?? null;
   }
   if (/^(git\+|git:|https?:|ssh:)/.test(spec)) return null;
   if (spec.startsWith("@")) {
@@ -2304,10 +2398,10 @@ async function packageNameFromSpec(spec) {
   return at <= 0 ? spec : spec.slice(0, at);
 }
 async function resolveSearchPackage(dir, name) {
-  return asSearchPackage(import_node_path12.default.join(dir, "node_modules", ...name.split("/")));
+  return asSearchPackage(import_node_path13.default.join(dir, "node_modules", ...name.split("/")));
 }
 async function discoverSearchPackage(dir) {
-  const nodeModules = import_node_path12.default.join(dir, "node_modules");
+  const nodeModules = import_node_path13.default.join(dir, "node_modules");
   for (const pkgDir of await pluginManifestDirs(nodeModules)) {
     const found = await asSearchPackage(pkgDir);
     if (found) return found;
@@ -2404,6 +2498,14 @@ async function registerPlugin(name, command) {
   await runSetup(command, name);
   return record;
 }
+async function repairPlugins() {
+  const enabled = (await readPluginRegistry()).plugins.filter((p) => p.enabled && p.kind === "search");
+  const out = [];
+  for (const p of enabled) {
+    out.push({ name: p.name, setup: await runSetup(p.command, p.name) });
+  }
+  return out;
+}
 async function removePlugin(name) {
   const record = (await readPluginRegistry()).plugins.find((p) => p.name === name);
   if (!record) throw new PluginError(`plugin "${name}" is not registered`);
@@ -2439,7 +2541,7 @@ init_host();
 init_types();
 async function exists(target) {
   try {
-    await import_promises13.default.access(target);
+    await import_promises14.default.access(target);
     return true;
   } catch {
     return false;
@@ -2545,17 +2647,16 @@ async function appendPluginDiagnostics(out, config) {
 }
 
 // src/lint.ts
-var import_promises14 = __toESM(require("fs/promises"), 1);
-var import_node_path13 = __toESM(require("path"), 1);
+var import_promises15 = __toESM(require("fs/promises"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 init_collections();
 init_errors();
 var BUDGETS = {
   recipe: { min: 300, max: 1e3 },
   "recipe-steps": { min: 500, max: 1500 },
   guide: { min: 1500, max: 5e3 },
-  "system-design": { min: 2e3, max: 6e3 },
-  "component-design": { min: 1e3, max: 3e3 },
-  // Fallback for a bare `architecture` tag when system vs component isn't declared.
+  reference: { min: 300, max: 2e3 },
+  // Generic fallback budget for a bare `architecture` tag (no dedicated template).
   architecture: { min: 1e3, max: 6e3 }
 };
 function estimateTokens(body) {
@@ -2564,8 +2665,7 @@ function estimateTokens(body) {
 function inferShape(tags, body) {
   const t = new Set(tags.map((x) => x.toLowerCase()));
   if (t.has("guide")) return "guide";
-  if (t.has("component-design") || t.has("component")) return "component-design";
-  if (t.has("system-design") || t.has("system")) return "system-design";
+  if (t.has("reference")) return "reference";
   if (t.has("architecture")) return "architecture";
   if (/^###\s+Step\b/im.test(body)) return "recipe-steps";
   return "recipe";
@@ -2636,13 +2736,13 @@ function lintArticle(article) {
 async function walkMarkdown(dir) {
   let entries;
   try {
-    entries = await import_promises14.default.readdir(dir, { withFileTypes: true });
+    entries = await import_promises15.default.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const e of entries) {
-    const full = import_node_path13.default.join(dir, e.name);
+    const full = import_node_path14.default.join(dir, e.name);
     if (e.isDirectory()) out.push(...await walkMarkdown(full));
     else if (e.isFile() && /\.mdx?$/.test(e.name) && !/-template\.mdx?$/.test(e.name)) out.push(full);
   }
@@ -2672,11 +2772,11 @@ async function lintCollections(scope) {
   let warnCount = 0;
   for (const coll of collections) {
     for (const full of await walkMarkdown(coll.path)) {
-      const rel = import_node_path13.default.relative(coll.path, full);
+      const rel = import_node_path14.default.relative(coll.path, full);
       const label = `${coll.name}/${rel}`;
       let findings = [];
       try {
-        const parsed = parseArticle(await import_promises14.default.readFile(full, "utf8"));
+        const parsed = parseArticle(await import_promises15.default.readFile(full, "utf8"));
         findings = lintArticle(parsed);
       } catch (err) {
         findings = [{ level: "error", rule: "parse", message: `could not parse: ${err.message}` }];
@@ -2803,11 +2903,14 @@ init_registry2();
   listEnabledPlugins,
   listPlugins,
   listSearchModes,
+  listTemplateShapes,
+  listTemplates,
   loadSearchProvider,
   localGraph,
   nativeSearch,
   parseAddTarget,
   parseArticle,
+  parseFrontmatter,
   parsePathTarget,
   pluginsDir,
   pluginsRegistryPath,
@@ -2829,6 +2932,7 @@ init_registry2();
   removePlugin,
   removeTags,
   renderArticle,
+  repairPlugins,
   repoId,
   repoRemoteName,
   resolveCollectionSelection,
@@ -2842,13 +2946,17 @@ init_registry2();
   resolveProjectCollections,
   search,
   seedProjectHome,
+  seedTemplates,
   serializeArticle,
   setArticleMeta,
   setConfigValue,
+  setContextCollections,
   setTags,
   showSystemEnabled,
   slugify,
   slugifyPath,
+  stripFrontmatter,
+  templatesDir,
   toTreeNodes,
   tokenize,
   unregisterCollection,