kennel 0.2.32 → 0.2.33

package/dist/package/preview.js

@@ -38305,17 +38305,215 @@ var init_server2 = __esm(() => {
   init_node3();
 });
 
-// packages/api/src/server/entity-folder.ts
-import { readdir as readdir3, readFile as readFile5, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+// packages/notes/src/store.ts
+import { execFile as execFile2 } from "node:child_process";
+import {
+  mkdir as mkdir3,
+  readdir as readdir3,
+  readFile as readFile5,
+  realpath as realpath3,
+  rename as rename2,
+  rm as rm2,
+  stat as stat3,
+  writeFile as writeFile3
+} from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
+import { basename as basename5, dirname as dirname6, join as join2, relative as relative7, resolve as resolve7, sep as sep4 } from "node:path";
+import { promisify } from "node:util";
+function kennelConfigHome() {
+  const xdg = process.env.XDG_CONFIG_HOME?.trim();
+  return xdg ? xdg : join2(homedir2(), ".config");
+}
+function kennelConfigFile() {
+  return join2(kennelConfigHome(), "kennel", "config.json");
+}
+function repositoryNotesRoot() {
+  return join2(kennelConfigHome(), "kennel", "repos");
+}
+function isRepositoryId(value) {
+  return typeof value === "string" && UUID.test(value);
+}
+function managedNotesDirectory(id) {
+  if (!isRepositoryId(id)) {
+    throw new RepositoryNotesError("invalid-id", `Invalid repository id: ${id}`);
+  }
+  return join2(repositoryNotesRoot(), id);
+}
+async function readRepositoryNotesSettings() {
+  const file = kennelConfigFile();
+  let text;
+  try {
+    text = await readFile5(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { enabled: false };
+    }
+    throw new RepositoryNotesError("config-invalid", `Cannot read ${file}: ${errorMessage(error)}`);
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    throw new RepositoryNotesError("config-invalid", `Invalid JSON in ${file}: ${errorMessage(error)}`);
+  }
+  if (!isRecord(value)) {
+    throw new RepositoryNotesError("config-invalid", `${file} must hold an object`);
+  }
+  const section = value.repositoryNotes;
+  if (section === undefined)
+    return { enabled: false };
+  if (!isRecord(section) || section.enabled !== undefined && typeof section.enabled !== "boolean") {
+    throw new RepositoryNotesError("config-invalid", `${file}: repositoryNotes must be an object with a boolean "enabled" field`);
+  }
+  return { enabled: section.enabled === true };
+}
+async function git(args, cwd) {
+  const { stdout } = await run("git", args, {
+    cwd,
+    env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0" },
+    maxBuffer: 1024 * 1024
+  });
+  return stdout.replace(/\r?\n$/u, "");
+}
+function gitExitCode(error) {
+  const code = error.code;
+  return typeof code === "number" ? code : undefined;
+}
+async function resolveCheckout(folder) {
+  let start;
+  try {
+    start = await realpath3(resolve7(folder));
+    if (!(await stat3(start)).isDirectory())
+      start = dirname6(start);
+  } catch {
+    throw new RepositoryNotesError("not-git", `Folder does not exist: ${folder}`);
+  }
+  let output;
+  try {
+    output = await git(["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir"], start);
+  } catch (error) {
+    if (gitExitCode(error) === 128) {
+      throw new RepositoryNotesError("not-git", `Not a Git repository: ${start}. Repository notes need a Git checkout.`);
+    }
+    throw error;
+  }
+  const [top, common] = output.split(/\r?\n/u);
+  if (!top || !common) {
+    throw new RepositoryNotesError("not-git", `Not a Git work tree: ${start}`);
+  }
+  const root = await realpath3(top);
+  const commonDir = await realpath3(common);
+  return { root, commonDir, configFile: join2(commonDir, "config") };
+}
+async function readBinding(checkout) {
+  let value;
+  try {
+    value = await git(["config", "--file", checkout.configFile, "--get", REPOSITORY_ID_KEY], checkout.root);
+  } catch (error) {
+    if (gitExitCode(error) === 1)
+      return;
+    throw error;
+  }
+  const id = value.trim();
+  if (!id)
+    return;
+  if (!isRepositoryId(id)) {
+    throw new RepositoryNotesError("invalid-binding", `${checkout.configFile} has an invalid ${REPOSITORY_ID_KEY} value. Remove it or run "kennel notes new-identity".`);
+  }
+  return id;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function lookupRepositoryNotes(folder) {
+  let checkout;
+  try {
+    checkout = await resolveCheckout(folder);
+  } catch (error) {
+    if (error instanceof RepositoryNotesError && error.code === "not-git") {
+      return { status: "not-git", folder };
+    }
+    throw error;
+  }
+  const id = await readBinding(checkout);
+  if (!id)
+    return { status: "unregistered", checkout, root: checkout.root };
+  return {
+    status: "registered",
+    checkout,
+    id,
+    notesDirectory: managedNotesDirectory(id),
+    root: checkout.root
+  };
+}
+async function listManagedNotes(directory) {
+  const notes = [];
+  const visit = async (current) => {
+    let entries;
+    try {
+      entries = await readdir3(current, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return;
+      throw error;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.isSymbolicLink())
+        continue;
+      const path = join2(current, entry.name);
+      if (entry.isDirectory()) {
+        await visit(path);
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      const dot = entry.name.lastIndexOf(".");
+      const extension = dot === -1 ? "" : entry.name.slice(dot).toLowerCase();
+      if (!markdownExtensions.has(extension))
+        continue;
+      const details = await stat3(path);
+      notes.push({
+        activityAt: details.mtimeMs,
+        name: dot === -1 ? entry.name : entry.name.slice(0, dot),
+        path,
+        relativePath: relative7(directory, path).split(sep4).join("/"),
+        size: details.size
+      });
+    }
+  };
+  await visit(directory);
+  return notes.sort((left, right) => right.activityAt - left.activityAt);
+}
+var run, REPOSITORY_ID_KEY = "kennel.repoId", UUID, markdownExtensions, caseInsensitiveHosts, RepositoryNotesError;
+var init_store = __esm(() => {
+  run = promisify(execFile2);
+  UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+  markdownExtensions = new Set([".md", ".markdown"]);
+  caseInsensitiveHosts = new Set(["github.com", "gitlab.com", "bitbucket.org"]);
+  RepositoryNotesError = class RepositoryNotesError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "RepositoryNotesError";
+      this.code = code;
+    }
+  };
+});
+
+// packages/api/src/server/entity-folder.ts
+import { readdir as readdir4, readFile as readFile6, realpath as realpath4, stat as stat4 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
 import {
-  basename as basename5,
-  dirname as dirname6,
+  basename as basename6,
+  dirname as dirname7,
   extname as extname2,
   isAbsolute as isAbsolute4,
-  join as join2,
-  relative as relative7,
-  resolve as resolve7
+  join as join3,
+  relative as relative8,
+  resolve as resolve8
 } from "node:path";
 function parseMarkdown(source) {
   if (!source.startsWith(`---
@@ -38350,11 +38548,11 @@ function paragraph(body) {
 }
 function configPath() {
   const xdg = process.env.XDG_CONFIG_HOME?.trim();
-  return xdg ? join2(xdg, CONFIG_FILE) : join2(homedir2(), ".config", CONFIG_FILE);
+  return xdg ? join3(xdg, CONFIG_FILE) : join3(homedir3(), ".config", CONFIG_FILE);
 }
 async function readConfig(path) {
   try {
-    return parseConfig(await readFile5(path, "utf8"));
+    return parseConfig(await readFile6(path, "utf8"));
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
       return null;
@@ -38371,6 +38569,8 @@ function parseConfig(source) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw new Error("Invalid Kennel entity root config");
   const roots = value.allowedRoots;
+  if (roots === undefined)
+    return {};
   if (!Array.isArray(roots))
     throw new Error("Invalid Kennel entity root config");
   const allowedRoots = roots.map((root) => {
@@ -38382,12 +38582,12 @@ function parseConfig(source) {
 }
 async function allowedRoots(currentWorkspaceRoot) {
   const config = await readConfig(configPath());
-  if (config)
+  if (config?.allowedRoots)
     return config.allowedRoots;
   return currentWorkspaceRoot?.trim() ? [currentWorkspaceRoot] : [];
 }
 function inside4(root, path) {
-  const local = relative7(root, path);
+  const local = relative8(root, path);
   return local === "" || !local.startsWith("..") && !isAbsolute4(local);
 }
 async function normalizeRoot(rootPath, currentWorkspaceRoot) {
@@ -38395,13 +38595,13 @@ async function normalizeRoot(rootPath, currentWorkspaceRoot) {
   const fallback = currentWorkspaceRoot?.trim();
   if (!trimmed && !fallback)
     return null;
-  const requested = resolve7(trimmed || fallback);
-  const resolved = await realpath3(requested);
-  const info = await stat3(resolved);
+  const requested = resolve8(trimmed || fallback);
+  const resolved = await realpath4(requested);
+  const info = await stat4(resolved);
   if (!info.isDirectory())
     throw new Error(`${resolved} is not a folder`);
   const roots = await allowedRoots(currentWorkspaceRoot);
-  const realAllowedRoots = await Promise.all(roots.map((root) => realpath3(root)));
+  const realAllowedRoots = await Promise.all(roots.map((root) => realpath4(root)));
   const allowed = realAllowedRoots.some((root) => inside4(root, resolved));
   if (!allowed)
     throw new Error("Entity root is outside the configured roots");
@@ -38410,11 +38610,11 @@ async function normalizeRoot(rootPath, currentWorkspaceRoot) {
 async function markdownFiles(folderPath) {
   const files = [];
   async function walk(currentPath) {
-    const entries = await readdir3(currentPath, { withFileTypes: true });
+    const entries = await readdir4(currentPath, { withFileTypes: true });
     for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
       if (entry.name.startsWith(".") || IGNORED_DIRECTORIES.has(entry.name))
         continue;
-      const entryPath = join2(currentPath, entry.name);
+      const entryPath = join3(currentPath, entry.name);
       if (entry.isDirectory()) {
         if (entryPath !== folderPath && await hasIndex(entryPath))
           continue;
@@ -38429,36 +38629,36 @@ async function markdownFiles(folderPath) {
   return files;
 }
 async function hasIndex(folderPath) {
-  return stat3(join2(folderPath, "index.md")).then((value) => value.isFile()).catch(() => false);
+  return stat4(join3(folderPath, "index.md")).then((value) => value.isFile()).catch(() => false);
 }
 async function schemaPath(folderPath, rootPath) {
   let current = folderPath;
   while (current === rootPath || current.startsWith(`${rootPath}/`)) {
     for (const name of ["schema.json", "_schema.json"]) {
-      const candidate = join2(current, name);
-      if (await stat3(candidate).then((value) => value.isFile()).catch(() => false))
+      const candidate = join3(current, name);
+      if (await stat4(candidate).then((value) => value.isFile()).catch(() => false))
         return candidate;
     }
     if (current === rootPath)
       return null;
-    current = dirname6(current);
+    current = dirname7(current);
   }
   return null;
 }
 async function readEntity(folderPath, rootPath) {
-  const indexPath = join2(folderPath, "index.md");
-  const index = parseMarkdown(await readFile5(indexPath, "utf8"));
+  const indexPath = join3(folderPath, "index.md");
+  const index = parseMarkdown(await readFile6(indexPath, "utf8"));
   const files = await markdownFiles(folderPath);
   const documents = await Promise.all(files.map(async (filePath) => {
-    const document2 = parseMarkdown(await readFile5(filePath, "utf8"));
+    const document2 = parseMarkdown(await readFile6(filePath, "utf8"));
     return {
       content: document2.body,
-      path: relative7(folderPath, filePath),
-      title: stringValue(document2.frontmatter.title) ?? heading(document2.body) ?? basename5(filePath, extname2(filePath))
+      path: relative8(folderPath, filePath),
+      title: stringValue(document2.frontmatter.title) ?? heading(document2.body) ?? basename6(filePath, extname2(filePath))
     };
   }));
-  const title = stringValue(index.frontmatter.title) ?? heading(index.body) ?? basename5(folderPath);
-  const relativePath = relative7(rootPath, folderPath) || ".";
+  const title = stringValue(index.frontmatter.title) ?? heading(index.body) ?? basename6(folderPath);
+  const relativePath = relative8(rootPath, folderPath) || ".";
   return {
     aliases: stringValues(index.frontmatter.aliases),
     content: [
@@ -38486,11 +38686,11 @@ async function discover(rootPath) {
   async function walk(folderPath) {
     if (await hasIndex(folderPath))
       folders.push(folderPath);
-    const entries = await readdir3(folderPath, { withFileTypes: true });
+    const entries = await readdir4(folderPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".") || IGNORED_DIRECTORIES.has(entry.name))
         continue;
-      await walk(join2(folderPath, entry.name));
+      await walk(join3(folderPath, entry.name));
     }
   }
   await walk(rootPath);
@@ -38529,7 +38729,7 @@ async function loadEntityWorkspace(root, query, selectedPath, currentWorkspaceRo
 var CONFIG_FILE, IGNORED_DIRECTORIES;
 var init_entity_folder = __esm(() => {
   init_dist3();
-  CONFIG_FILE = join2("kennel", "config.json");
+  CONFIG_FILE = join3("kennel", "config.json");
   IGNORED_DIRECTORIES = new Set([
     ".git",
     ".gtl",
@@ -38549,20 +38749,20 @@ function replaceSelection(content, start, end, replacement) {
 // packages/api/src/server/api/document-edit.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import {
-  readFile as readFile6,
-  realpath as realpath4,
-  rename as rename2,
-  stat as stat4,
+  readFile as readFile7,
+  realpath as realpath5,
+  rename as rename3,
+  stat as stat5,
   unlink as unlink2,
-  writeFile as writeFile3
+  writeFile as writeFile4
 } from "node:fs/promises";
 import {
-  dirname as dirname7,
+  dirname as dirname8,
   extname as extname3,
   isAbsolute as isAbsolute5,
-  relative as relative8,
-  resolve as resolve8,
-  sep as sep4
+  relative as relative9,
+  resolve as resolve9,
+  sep as sep5
 } from "node:path";
 async function editDocument(folder, input) {
   const { path, original, start, end, replacement } = input;
@@ -38570,10 +38770,10 @@ async function editDocument(folder, input) {
     throw apiError("bad-request", "Invalid document edit.");
   if (![".md", ".markdown"].includes(extname3(path).toLowerCase()))
     throw apiError("bad-request", "Only Markdown notes can be edited.");
-  const root = await realpath4(folder);
-  const target = await realpath4(resolve8(root, path));
-  const local = relative8(root, target);
-  if (!local || local === ".." || local.startsWith(`..${sep4}`) || isAbsolute5(local))
+  const root = await realpath5(folder);
+  const target = await realpath5(resolve9(root, path));
+  const local = relative9(root, target);
+  if (!local || local === ".." || local.startsWith(`..${sep5}`) || isAbsolute5(local))
     throw apiError("forbidden", "The document must be inside its folder.");
   let content;
   try {
@@ -38583,20 +38783,20 @@ async function editDocument(folder, input) {
   }
   const previous = pending.get(target) ?? Promise.resolve();
   const operation = previous.catch(() => {}).then(async () => {
-    const details = await stat4(target);
+    const details = await stat5(target);
     if (!details.isFile() || details.nlink !== 1)
       throw apiError("forbidden", "Only regular, unlinked files can be edited.");
-    if (await readFile6(target, "utf8") !== original)
+    if (await readFile7(target, "utf8") !== original)
       throw apiError("conflict", "This note changed on disk. Close this preview, reload the note, and try again.");
-    const temporary = resolve8(dirname7(target), `.kennel-edit-${randomUUID3()}.tmp`);
+    const temporary = resolve9(dirname8(target), `.kennel-edit-${randomUUID3()}.tmp`);
     try {
-      await writeFile3(temporary, content, {
+      await writeFile4(temporary, content, {
         flag: "wx",
         mode: details.mode & 511
       });
-      if (await readFile6(target, "utf8") !== original)
+      if (await readFile7(target, "utf8") !== original)
         throw apiError("conflict", "This note changed on disk. Reload before applying an edit.");
-      await rename2(temporary, target);
+      await rename3(temporary, target);
     } finally {
       await unlink2(temporary).catch(() => {});
     }
@@ -38624,7 +38824,7 @@ var init_document_edit = __esm(() => {
         throw apiError("bad-request", "Invalid document edit.");
       const input = parsed.data;
       const folder = context.authorize(input.folder);
-      if (context.lockedFile && (typeof input.path !== "string" || await realpath4(resolve8(folder, input.path)) !== context.lockedFile))
+      if (context.lockedFile && (typeof input.path !== "string" || await realpath5(resolve9(folder, input.path)) !== context.lockedFile))
         throw apiError("forbidden", "Only the selected document can be edited.");
       await editDocument(folder, input);
       jsonResponse(response, 200, routes.documentEdit.response.parse({ saved: true }));
@@ -38633,8 +38833,8 @@ var init_document_edit = __esm(() => {
 });
 
 // packages/api/src/server/api/create-agent-file.ts
-import { writeFile as writeFile4 } from "node:fs/promises";
-import { resolve as resolve9 } from "node:path";
+import { writeFile as writeFile5 } from "node:fs/promises";
+import { resolve as resolve10 } from "node:path";
 var createAgentFileRoute;
 var init_create_agent_file = __esm(() => {
   init_endpoint();
@@ -38648,9 +38848,9 @@ var init_create_agent_file = __esm(() => {
       } catch (error) {
         throw apiError("not-found", error instanceof Error ? error.message : "Folder not found");
       }
-      const target = resolve9(folder, "AGENTS.md");
+      const target = resolve10(folder, "AGENTS.md");
       try {
-        await writeFile4(target, "", { flag: "wx" });
+        await writeFile5(target, "", { flag: "wx" });
       } catch (error) {
         if (error && typeof error === "object" && "code" in error && error.code === "EEXIST") {
           throw apiError("conflict", "AGENTS.md already exists in this folder");
@@ -38663,7 +38863,7 @@ var init_create_agent_file = __esm(() => {
 });
 
 // packages/api/src/server/api/open-path.ts
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 var openPathRoute;
 var init_open_path = __esm(() => {
   init_endpoint();
@@ -38677,7 +38877,7 @@ var init_open_path = __esm(() => {
         throw apiError("not-found", error instanceof Error ? error.message : "Path not found");
       }
       await new Promise((done, fail) => {
-        execFile2("/usr/bin/open", [target], (error) => {
+        execFile3("/usr/bin/open", [target], (error) => {
           if (error)
             fail(apiError("failed", "Could not open path"));
           else
@@ -38696,11 +38896,11 @@ var init_favicon2 = __esm(() => {
 });
 
 // packages/api/src/server/folder-favicon.ts
-import { readFile as readFile7 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import { join as join4 } from "node:path";
 async function folderWebsite(folder) {
   for (const name of ["AGENTS.md", "README.md"]) {
-    const content = await readFile7(join3(folder, name), "utf8").catch(() => "");
+    const content = await readFile8(join4(folder, name), "utf8").catch(() => "");
     const entry = markdownMetadata(content).entries.find(([key]) => key === "website");
     if (entry)
       return websiteHost(entry[1]);
@@ -38714,7 +38914,7 @@ var init_folder_favicon = __esm(() => {
 
 // packages/api/src/server/folder-icons.ts
 import { createHash as createHash4 } from "node:crypto";
-import { readFile as readFile8, stat as stat5 } from "node:fs/promises";
+import { readFile as readFile9, stat as stat6 } from "node:fs/promises";
 import { extname as extname4 } from "node:path";
 import { discoverFolderIcon } from "@raggle-ai/local";
 function assetKey(value) {
@@ -38733,13 +38933,13 @@ function iconUrl(folder, hash, mediaType) {
 async function folderIcon(folder, assets, assetFiles, fallback) {
   const icon = discoverFolderIcon(folder);
   const mediaType = icon ? iconTypes.get(extname4(icon).toLowerCase()) : null;
-  const details = icon && mediaType ? await stat5(icon).catch(() => {
+  const details = icon && mediaType ? await stat6(icon).catch(() => {
     return;
   }) : undefined;
   if (!icon || !mediaType || !details?.size || details.size > maxIconBytes2) {
     return fallback ? await fallback(folder, assets) : undefined;
   }
-  const data = await readFile8(icon);
+  const data = await readFile9(icon);
   const hash = assetKey(data);
   const key = `local:${hash}`;
   assetFiles.set(hash, { mediaType, path: icon });
@@ -38758,12 +38958,12 @@ async function searchIconDataUrl(icon) {
   const mediaType = searchIconTypes.get(extname4(icon).toLowerCase());
   if (!mediaType)
     return;
-  const details = await stat5(icon).catch(() => {
+  const details = await stat6(icon).catch(() => {
     return;
   });
   if (!details?.size || details.size > maxSearchIconBytes)
     return;
-  return `data:${mediaType};base64,${(await readFile8(icon)).toString("base64")}`;
+  return `data:${mediaType};base64,${(await readFile9(icon)).toString("base64")}`;
 }
 async function faviconAsset(folderName, assets) {
   if (process.env.KENNEL_EXTERNAL_ICONS !== "1")
@@ -38847,47 +39047,77 @@ var init_manifest = __esm(() => {
 });
 
 // packages/notes/src/server.ts
-import { readdir as readdir4, stat as stat6 } from "node:fs/promises";
-import { basename as basename6, extname as extname5, relative as relative9, resolve as resolve10, sep as sep5 } from "node:path";
+import { readdir as readdir5, realpath as realpath6, stat as stat7 } from "node:fs/promises";
+import {
+  basename as basename7,
+  extname as extname5,
+  isAbsolute as isAbsolute6,
+  relative as relative10,
+  resolve as resolve11,
+  sep as sep6
+} from "node:path";
 async function listMarkdownFiles(folder) {
   const files = [];
   const visit = async (current) => {
-    const entries = await readdir4(current, { withFileTypes: true }).catch(() => []);
+    const entries = await readdir5(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name.startsWith("."))
         continue;
-      const path = resolve10(current, entry.name);
+      const path = resolve11(current, entry.name);
       if (entry.isDirectory()) {
         await visit(path);
         continue;
       }
-      if (!entry.isFile() || !markdownExtensions.has(extname5(entry.name))) {
+      if (!entry.isFile() || !markdownExtensions2.has(extname5(entry.name))) {
         continue;
       }
-      const details = await stat6(path).catch(() => {
+      const details = await stat7(path).catch(() => {
         return;
       });
       files.push({
         activityAt: details?.mtimeMs ?? 0,
-        name: basename6(entry.name, extname5(entry.name)),
-        relativePath: relative9(folder, path).split(sep5).join("/")
+        name: basename7(entry.name, extname5(entry.name)),
+        relativePath: relative10(folder, path).split(sep6).join("/")
       });
     }
   };
   await visit(folder);
   return files.sort((left, right) => right.activityAt - left.activityAt);
 }
-async function loadNotes(folder, linkedFolders = []) {
+function inside5(path, root) {
+  const local = relative10(root, path);
+  return local === "" || !local.startsWith("..") && !isAbsolute6(local);
+}
+async function withoutManaged(groups, managedRoots) {
+  if (!managedRoots.length)
+    return groups;
+  const roots = await Promise.all(managedRoots.map(canonical));
+  return Promise.all(groups.map(async (group) => {
+    if (roots.includes(await canonical(group.folder))) {
+      return { ...group, files: [] };
+    }
+    const files = await Promise.all(group.files.map(async (file) => {
+      const real = await canonical(resolve11(group.folder, file.relativePath));
+      return roots.some((root) => inside5(real, root)) ? undefined : file;
+    }));
+    return { ...group, files: files.filter((file) => file !== undefined) };
+  }));
+}
+async function loadNotes(folder, linkedFolders = [], managedFolders = []) {
   const localFiles = await listMarkdownFiles(folder);
-  const linked = await Promise.all(linkedFolders.map(async (linkedFolder) => ({
-    files: await listMarkdownFiles(linkedFolder),
-    folder: linkedFolder
+  const listGroups = (folders) => Promise.all(folders.map(async (source) => ({
+    files: await listMarkdownFiles(source),
+    folder: source
   })));
+  const [managed, linked] = await Promise.all([
+    listGroups(managedFolders),
+    listGroups(linkedFolders).then((groups) => withoutManaged(groups, managedFolders))
+  ]);
   return {
     files: {
       items: [
         ...localFiles,
-        ...linked.flatMap((group) => group.files.map((file) => ({ ...file, folder: group.folder })))
+        ...[...managed, ...linked].flatMap((group) => group.files.map((file) => ({ ...file, folder: group.folder })))
       ]
     },
     folder,
@@ -38904,14 +39134,20 @@ function codeSpan(text) {
 async function notesLlmSections({
   folder,
   linkedFolders = [],
+  managedFolders = [],
   signal
 }) {
   const groups = [];
   const notes = [];
-  for (const source of [folder, ...linkedFolders]) {
+  const seen = new Set;
+  for (const source of [folder, ...managedFolders, ...linkedFolders]) {
     signal.throwIfAborted();
+    const identity = await canonical(source);
+    if (seen.has(identity))
+      continue;
+    seen.add(identity);
     const files = await listMarkdownFiles(source);
-    const paths = files.map((file) => resolve10(source, file.relativePath));
+    const paths = files.map((file) => resolve11(source, file.relativePath));
     groups.push({ folder: source, paths });
     files.forEach((file, index) => notes.push({ activityAt: file.activityAt, path: paths[index] }));
   }
@@ -38944,24 +39180,28 @@ function createNotesPlugin() {
     },
     async handle({
       folder,
-      linkedFolders
+      linkedFolders,
+      managedFolders
     }) {
-      return { data: await loadNotes(folder, linkedFolders), kind: "available" };
+      return {
+        data: await loadNotes(folder, linkedFolders, managedFolders),
+        kind: "available"
+      };
     },
     llm: notesLlmSections
   };
 }
-var markdownExtensions, llmNoteLimit = 20;
+var markdownExtensions2, llmNoteLimit = 20, canonical = (path) => realpath6(path).catch(() => path);
 var init_server3 = __esm(() => {
   init_manifest();
-  markdownExtensions = new Set([".md", ".markdown"]);
+  markdownExtensions2 = new Set([".md", ".markdown"]);
 });
 
 // packages/api/src/server/plugins.ts
 import { pathToFileURL } from "node:url";
 import { existsSync as existsSync4 } from "node:fs";
-import { mkdir as mkdir3, readFile as readFile9, stat as stat7, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname8, resolve as resolve11, sep as sep6 } from "node:path";
+import { mkdir as mkdir4, readFile as readFile10, stat as stat8, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname9, resolve as resolve12, sep as sep7 } from "node:path";
 function configuredFolderServerRegistry(registry, resolvedConfig) {
   const disabled = new Set(resolvedConfig.plugins.disable);
   const orderedIds = resolvedConfig.plugins.order.filter((id) => registry.has(id) && !disabled.has(id));
@@ -38985,14 +39225,14 @@ function parsePluginRegistryConfig(content) {
   };
 }
 async function nearestKennelConfig(folder) {
-  for (let current = folder;; current = dirname8(current)) {
-    const candidate = resolve11(current, "kennel.json");
-    const details = await stat7(candidate).catch(() => {
+  for (let current = folder;; current = dirname9(current)) {
+    const candidate = resolve12(current, "kennel.json");
+    const details = await stat8(candidate).catch(() => {
       return;
     });
     if (details?.isFile())
       return candidate;
-    if (dirname8(current) === current)
+    if (dirname9(current) === current)
       return;
   }
 }
@@ -39001,7 +39241,7 @@ async function folderPluginRegistryConfig(folder) {
   if (!path)
     return defaultPluginRegistryConfig;
   try {
-    return parsePluginRegistryConfig(await readFile9(path, "utf8"));
+    return parsePluginRegistryConfig(await readFile10(path, "utf8"));
   } catch {
     return defaultPluginRegistryConfig;
   }
@@ -39049,7 +39289,7 @@ async function folderServerRegistryAsync() {
       ...server,
       async detect(context) {
         const detection = await server.detect(context);
-        if (detection.status === "unavailable" && existsSync4(resolve11(context.folder, entry.trigger))) {
+        if (detection.status === "unavailable" && existsSync4(resolve12(context.folder, entry.trigger))) {
           return { status: "available" };
         }
         return detection;
@@ -39095,10 +39335,10 @@ var init_plugins = __esm(() => {
 });
 
 // packages/api/src/server/linked-folder-discovery.ts
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 import { existsSync as existsSync5 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname9, join as join4 } from "node:path";
+import { dirname as dirname10, join as join5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function resolveLocalModule(from = import.meta.url) {
   const require2 = createRequire2(from);
@@ -39106,19 +39346,19 @@ function resolveLocalModule(from = import.meta.url) {
   try {
     candidates.push(require2.resolve("@raggle-ai/local"));
   } catch {}
-  let directory = dirname9(fileURLToPath2(from));
-  while (dirname9(directory) !== directory) {
-    if (existsSync5(join4(directory, "raggle.json"))) {
+  let directory = dirname10(fileURLToPath2(from));
+  while (dirname10(directory) !== directory) {
+    if (existsSync5(join5(directory, "raggle.json"))) {
       for (const candidate of [
-        join4(dirname9(directory), "raggle-ai-scout", "packages", "local"),
-        join4(directory, "..", "..", "raggle-ai-scout", "packages", "local")
+        join5(dirname10(directory), "raggle-ai-scout", "packages", "local"),
+        join5(directory, "..", "..", "raggle-ai-scout", "packages", "local")
       ]) {
         if (!candidates.includes(candidate))
           candidates.push(candidate);
       }
       break;
     }
-    directory = dirname9(directory);
+    directory = dirname10(directory);
   }
   for (const candidate of candidates) {
     try {
@@ -39127,11 +39367,11 @@ function resolveLocalModule(from = import.meta.url) {
         return candidate;
     } catch {}
   }
-  return candidates[0] ?? join4(dirname9(fileURLToPath2(from)), "..", "..", "..", "raggle-ai-scout", "packages", "local");
+  return candidates[0] ?? join5(dirname10(fileURLToPath2(from)), "..", "..", "..", "raggle-ai-scout", "packages", "local");
 }
 function discoverLinkedFolders(folder, signal, modulePath = resolveLocalModule()) {
   return new Promise((resolve, reject) => {
-    execFile3(process.execPath, ["-e", script, modulePath, folder], {
+    execFile4(process.execPath, ["-e", script, modulePath, folder], {
       signal,
       timeout: 60000,
       maxBuffer: 8 * 1024 * 1024,
@@ -39227,10 +39467,10 @@ const { stat } = require('node:fs/promises');
 var init_linked_folder_discovery = () => {};
 
 // packages/api/src/server/project-discovery.ts
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 function discoverProjects(folder, signal) {
   return new Promise((resolve, reject) => {
-    execFile4(process.execPath, ["-e", script2, resolveLocalModule(), folder], {
+    execFile5(process.execPath, ["-e", script2, resolveLocalModule(), folder], {
       signal,
       timeout: 60000,
       maxBuffer: 8 * 1024 * 1024,
@@ -39317,24 +39557,24 @@ var init_project_discovery = __esm(() => {
 // packages/api/src/server/folder-metadata-plugin.ts
 import { createHash as createHash5 } from "node:crypto";
 import { realpathSync as realpathSync2 } from "node:fs";
-import { readdir as readdir5, readFile as readFile10, stat as stat8 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
+import { readdir as readdir6, readFile as readFile11, realpath as realpath7, stat as stat9 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
 import {
-  basename as basename7,
-  dirname as dirname10,
+  basename as basename8,
+  dirname as dirname11,
   extname as extname6,
-  isAbsolute as isAbsolute6,
-  relative as relative11,
-  resolve as resolve12,
-  sep as sep7
+  isAbsolute as isAbsolute7,
+  relative as relative12,
+  resolve as resolve13,
+  sep as sep8
 } from "node:path";
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import local from "@raggle-ai/local";
 function metadataFile(path, root) {
-  const candidate = relative11(root, path);
-  if (!candidate || candidate.startsWith("..") || isAbsolute6(candidate))
+  const candidate = relative12(root, path);
+  if (!candidate || candidate.startsWith("..") || isAbsolute7(candidate))
     return false;
-  const parts = candidate.split(sep7);
+  const parts = candidate.split(sep8);
   if (parts.some((part) => part === "node_modules"))
     return false;
   return metadataExtensions.has(extname6(candidate).toLowerCase());
@@ -39345,11 +39585,11 @@ async function configuredAiInputModule(folder) {
   return typeof module === "string" && module.trim() ? module.trim() : null;
 }
 function folderPath(value, root, lockedRoot) {
-  const folder = realpathSync2(resolve12(value ?? root));
+  const folder = realpathSync2(resolve13(value ?? root));
   if (!lockedRoot)
     return folder;
-  const path = relative11(lockedRoot, folder);
-  if (!path || !path.startsWith("..") && !isAbsolute6(path))
+  const path = relative12(lockedRoot, folder);
+  if (!path || !path.startsWith("..") && !isAbsolute7(path))
     return folder;
   throw new Error(`Folder is outside the viewer root: ${folder}`);
 }
@@ -39413,15 +39653,15 @@ function unique(values) {
   return [...new Set(values)];
 }
 function isMachineRoot(folder) {
-  return folder === homedir3() || dirname10(folder) === folder;
+  return folder === homedir4() || dirname11(folder) === folder;
 }
 async function shallowMetadata(folder) {
-  const entries = await readdir5(folder, { withFileTypes: true });
+  const entries = await readdir6(folder, { withFileTypes: true });
   const visible = entries.filter((entry) => !entry.name.startsWith(".") && entry.name !== "node_modules");
   const files = await Promise.all(visible.filter((entry) => entry.isFile() && [".markdown", ".md"].includes(extname6(entry.name).toLowerCase())).map(async (entry) => {
-    const path = resolve12(folder, entry.name);
-    const details = await stat8(path);
-    const content = await readFile10(path, "utf8").catch(() => "");
+    const path = resolve13(folder, entry.name);
+    const details = await stat9(path);
+    const content = await readFile11(path, "utf8").catch(() => "");
     const title = markdownMetadata(content).title;
     return {
       activityAt: details.mtimeMs,
@@ -39434,10 +39674,10 @@ async function shallowMetadata(folder) {
     };
   }));
   const projects = visible.filter((entry) => entry.isDirectory()).map((entry) => ({
-    id: createHash5("sha1").update(resolve12(folder, entry.name)).digest("hex"),
+    id: createHash5("sha1").update(resolve13(folder, entry.name)).digest("hex"),
     name: entry.name,
     relativePath: entry.name,
-    worktree: resolve12(folder, entry.name)
+    worktree: resolve13(folder, entry.name)
   })).sort((left, right) => left.name.localeCompare(right.name));
   return {
     changes: { items: [] },
@@ -39463,8 +39703,8 @@ async function loadFolderData(folder) {
       items: projects.map((project) => ({
         id: project.id,
         worktree: project.worktree,
-        name: project.name ?? basename7(project.worktree),
-        relativePath: relative11(folder, project.worktree)
+        name: project.name ?? basename8(project.worktree),
+        relativePath: relative12(folder, project.worktree)
       }))
     }
   };
@@ -39472,10 +39712,10 @@ async function loadFolderData(folder) {
 async function notesFiles(folder, files, origin) {
   return {
     items: await Promise.all(files.map(async (file) => {
-      const path = file.path ?? (file.relativePath ? resolve12(folder, file.relativePath) : undefined);
+      const path = file.path ?? (file.relativePath ? resolve13(folder, file.relativePath) : undefined);
       if (!path)
         return origin ? { ...file, folder: origin } : file;
-      const content = [".markdown", ".md"].includes(extname6(path).toLowerCase()) ? await readFile10(path, "utf8").catch(() => "") : "";
+      const content = [".markdown", ".md"].includes(extname6(path).toLowerCase()) ? await readFile11(path, "utf8").catch(() => "") : "";
       const title = content ? markdownMetadata(content).title : undefined;
       return {
         ...file,
@@ -39486,6 +39726,30 @@ async function notesFiles(folder, files, origin) {
     }))
   };
 }
+async function managedNotesFiles(directory) {
+  const notes = await listManagedNotes(directory);
+  return Promise.all(notes.map(async (note) => {
+    const content = await readFile11(note.path, "utf8").catch(() => "");
+    const title = content ? markdownMetadata(content).title : undefined;
+    return {
+      ...note,
+      folder: directory,
+      name: title ?? note.name,
+      openHref: openPathHref(note.path)
+    };
+  }));
+}
+function insideFolder(path, root) {
+  const local = relative12(root, path);
+  return local === "" || !local.startsWith("..") && !isAbsolute7(local);
+}
+async function withoutManagedFiles(items, managedRoot) {
+  if (!managedRoot)
+    return items;
+  const root = await canonicalPath(managedRoot);
+  const outside = await Promise.all(items.map(async (item) => !item.path || !insideFolder(await canonicalPath(item.path), root)));
+  return items.filter((_, index) => outside[index]);
+}
 async function localProjectSearchCache(cache) {
   if (cache && Date.now() - cache.loadedAt < projectSearchCacheMs)
     return cache;
@@ -39508,16 +39772,16 @@ async function localProjectSearchCache(cache) {
 function mediaTarget(folder, file, lockedTarget) {
   if (!file)
     return;
-  const rootReal = realpathSync2(resolve12(folder));
-  const path = resolve12(folder, file);
+  const rootReal = realpathSync2(resolve13(folder));
+  const path = resolve13(folder, file);
   let pathReal;
   try {
     pathReal = realpathSync2(path);
   } catch {
     return;
   }
-  const rel = relative11(rootReal, pathReal);
-  if (rel.startsWith("..") || isAbsolute6(rel))
+  const rel = relative12(rootReal, pathReal);
+  if (rel.startsWith("..") || isAbsolute7(rel))
     return;
   if (lockedTarget && pathReal !== lockedTarget)
     return;
@@ -39556,16 +39820,16 @@ function documentError(response) {
 function documentTarget(folder, file, lockedTarget) {
   if (!file)
     return;
-  const rootReal = realpathSync2(resolve12(folder));
-  const path = resolve12(folder, file);
+  const rootReal = realpathSync2(resolve13(folder));
+  const path = resolve13(folder, file);
   let pathReal;
   try {
     pathReal = realpathSync2(path);
   } catch {
     return;
   }
-  const rel = relative11(rootReal, pathReal);
-  if (rel.startsWith("..") || isAbsolute6(rel))
+  const rel = relative12(rootReal, pathReal);
+  if (rel.startsWith("..") || isAbsolute7(rel))
     return;
   if (lockedTarget && pathReal !== lockedTarget)
     return;
@@ -39643,6 +39907,18 @@ function createFolderApi({
   const linkedDiscovery = createLinkedFolderDiscovery(linkedFolderLoader, (folder) => discoveryChanged(folder));
   const linkedState = (folder) => lockedRoot || isMachineRoot(folder) ? { folders: [], status: "ready" } : linkedDiscovery.read(folder);
   const resolveLinkedFolders = (folder) => lockedRoot || isMachineRoot(folder) ? Promise.resolve([]) : linkedDiscovery.folders(folder);
+  const managedNotesFolder = async (folder) => {
+    if (lockedRoot || lockedTarget || isMachineRoot(folder))
+      return;
+    try {
+      if (!(await readRepositoryNotesSettings()).enabled)
+        return;
+      const lookup = await lookupRepositoryNotes(folder);
+      return lookup.status === "registered" ? lookup.notesDirectory : undefined;
+    } catch {
+      return;
+    }
+  };
   const favicon = faviconService();
   return {
     name: "kennel-folder-metadata",
@@ -39685,7 +39961,7 @@ function createFolderApi({
         if (!folder)
           return;
         server.emit({
-          data: { path: relative11(folder, path) },
+          data: { path: relative12(folder, path) },
           event: "kennel:metadata-changed",
           type: "custom"
         });
@@ -39768,7 +40044,7 @@ function createFolderApi({
               "Content-Type": asset.mediaType,
               ETag: `"${hash}"`
             });
-            response.end(await readFile10(asset.path));
+            response.end(await readFile11(asset.path));
           } catch (error) {
             response.writeHead(404, {
               "Content-Type": "text/plain; charset=utf-8"
@@ -39833,21 +40109,21 @@ function createFolderApi({
           }
           const folder = folderPath(url.searchParams.get("path"), root, lockedRoot);
           const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer.exe" : "xdg-open";
-          await new Promise((done, fail) => execFile5(command, [folder], (error) => error ? fail(error) : done()));
+          await new Promise((done, fail) => execFile6(command, [folder], (error) => error ? fail(error) : done()));
           response.writeHead(204);
           response.end();
           return;
         }
         if (url.pathname === "/api/documents") {
           const folder = folderPath(url.searchParams.get("path"), root, lockedRoot);
-          const target = lockedTarget ? documentTarget(folder, relative11(folder, lockedTarget), lockedTarget) : undefined;
+          const target = lockedTarget ? documentTarget(folder, relative12(folder, lockedTarget), lockedTarget) : undefined;
           const dataset = lockedTarget ? {
             root: folder,
             documents: target ? [
               {
-                path: relative11(folder, target.path),
+                path: relative12(folder, target.path),
                 kind: target.kind,
-                content: previewTextKind(target.kind) ? await readFile10(target.path, "utf8") : ""
+                content: previewTextKind(target.kind) ? await readFile11(target.path, "utf8") : ""
               }
             ] : []
           } : await readFolder(folder);
@@ -39863,7 +40139,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat8(target.path);
+            const details = await stat9(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -39875,16 +40151,16 @@ function createFolderApi({
               return;
             }
             watch(folder);
-            const content = previewTextKind(target.kind) ? await readFile10(target.path, "utf8") : "";
+            const content = previewTextKind(target.kind) ? await readFile11(target.path, "utf8") : "";
             sendContract(response, url, {
               content,
               kind: target.kind,
-              path: relative11(target.root, target.path),
+              path: relative12(target.root, target.path),
               root: folder,
               ...previewTextKind(target.kind) ? {} : {
                 rawUrl: `/api/raw?${new URLSearchParams({
                   path: folder,
-                  file: relative11(target.root, target.path)
+                  file: relative12(target.root, target.path)
                 })}`
               }
             }, {
@@ -39904,7 +40180,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat8(target.path);
+            const details = await stat9(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -39925,10 +40201,10 @@ function createFolderApi({
               ETag: etag,
               "X-Content-Type-Options": "nosniff",
               ...download ? {
-                "Content-Disposition": `attachment; filename="${basename7(target.path)}"`
+                "Content-Disposition": `attachment; filename="${basename8(target.path)}"`
               } : {}
             });
-            response.end(await readFile10(target.path));
+            response.end(await readFile11(target.path));
           } catch (error) {
             documentError(response);
           }
@@ -39942,7 +40218,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat8(target.path);
+            const details = await stat9(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -39954,7 +40230,7 @@ function createFolderApi({
               return;
             }
             watch(folder);
-            const data = await readFile10(target.path);
+            const data = await readFile11(target.path);
             const baseHeaders = {
               "Accept-Ranges": "bytes",
               "Cache-Control": "private, max-age=0, must-revalidate",
@@ -40008,9 +40284,13 @@ function createFolderApi({
             if (!lockedRoot && !isMachineRoot(folder) && request.headers["x-kennel-retry-linked"] === "1")
               linkedDiscovery.retry(folder);
             const discovery = linkedState(folder);
+            const managed = await managedNotesFolder(folder);
+            if (managed)
+              watch(managed);
             const result = await plugin.handle({
               folder,
-              linkedFolders: discovery.folders
+              linkedFolders: discovery.folders,
+              ...managed ? { managedFolders: [managed] } : {}
             }, subpath);
             if (result.kind === "unavailable") {
               response.writeHead(200, {
@@ -40113,7 +40393,7 @@ function createFolderApi({
             workspace.breadcrumbs = await workspaceBreadcrumbIcons(workspace.breadcrumbs ?? [], assetFiles);
             const files = [
               workspace.configPath,
-              resolve12(workspace.root, "raggle.json")
+              resolve13(workspace.root, "raggle.json")
             ].filter((path) => Boolean(path));
             for (const path of files)
               contexts.add(path);
@@ -40137,7 +40417,14 @@ function createFolderApi({
           const machine = isMachineRoot(folder);
           if (part === "notes") {
             const scope = url.searchParams.get("notesScope");
+            const managed = await managedNotesFolder(folder);
             const localFiles = scope === "linked" ? Promise.resolve({ items: [] }) : (machine ? shallowMetadata(folder).then((data) => data.files.items) : listLocalMarkdownFiles({ folder, limit: 200 })).then((files) => notesFiles(folder, files));
+            const managedFiles = async () => {
+              if (scope === "linked" || !managed)
+                return [];
+              watch(managed);
+              return managedNotesFiles(managed);
+            };
             const linkedFiles = async () => {
               if (scope === "local" || machine || lockedRoot)
                 return [];
@@ -40148,20 +40435,25 @@ function createFolderApi({
                 throw new Error("Linked notes discovery failed. Retry to try again.");
               return Promise.all(linkedFolders.map(async (linkedFolder) => {
                 watch(linkedFolder);
-                return notesFiles(linkedFolder, await listLocalMarkdownFiles({
+                const group = await notesFiles(linkedFolder, await listLocalMarkdownFiles({
                   folder: linkedFolder,
                   limit: 200
                 }), linkedFolder);
+                return {
+                  items: await withoutManagedFiles(group.items, managed)
+                };
               }));
             };
-            const [files, linked] = await Promise.all([
+            const [files, managedItems, linked] = await Promise.all([
               localFiles,
+              managedFiles(),
               linkedFiles()
             ]);
             sendContract(response, url, {
               files: {
                 items: [
                   ...files.items,
+                  ...managedItems,
                   ...linked.flatMap((group) => group.items)
                 ]
               },
@@ -40242,7 +40534,7 @@ function createFolderApi({
     }
   };
 }
-var applyProjectFavorites, buildProjectCatalog, buildProjectSearchIndex, catalogProjectToLocalProject, discoverProjectIcon, discoverProjectsUnderFolder, listLocalMarkdownFiles, projectRepositoryAccessory, projectSubtitle, projectTitle, readRaggleUserSettings, gitRemoteUrl, githubRepositoryPath, repositoryDisplayName, searchProjectIndex, sortProjectList, projectSearchCacheMs = 5000, metadataExtensions, loopbackServerHosts;
+var applyProjectFavorites, buildProjectCatalog, buildProjectSearchIndex, catalogProjectToLocalProject, discoverProjectIcon, discoverProjectsUnderFolder, listLocalMarkdownFiles, projectRepositoryAccessory, projectSubtitle, projectTitle, readRaggleUserSettings, gitRemoteUrl, githubRepositoryPath, repositoryDisplayName, searchProjectIndex, sortProjectList, projectSearchCacheMs = 5000, metadataExtensions, loopbackServerHosts, canonicalPath = (path) => realpath7(path).catch(() => path);
 var init_folder_metadata_plugin = __esm(() => {
   init_contracts();
   init_markdown();
@@ -40252,6 +40544,7 @@ var init_folder_metadata_plugin = __esm(() => {
   init_server();
   init_workspace2();
   init_server2();
+  init_store();
   init_entity_folder();
   init_document_edit();
   init_create_agent_file();
@@ -40305,29 +40598,29 @@ var init_folder_metadata_plugin = __esm(() => {
 import {
   createServer
 } from "node:http";
-import { readFile as readFile11, realpath as realpath5, stat as stat9 } from "node:fs/promises";
-import { extname as extname7, isAbsolute as isAbsolute7, relative as relative12, resolve as resolve13 } from "node:path";
+import { readFile as readFile12, realpath as realpath8, stat as stat10 } from "node:fs/promises";
+import { extname as extname7, isAbsolute as isAbsolute8, relative as relative13, resolve as resolve14 } from "node:path";
 async function sendFile(request, response, directory, pathname, fallback) {
-  const root = await realpath5(directory);
+  const root = await realpath8(directory);
   const inside = (path) => {
-    const local = relative12(root, path);
-    return local !== ".." && !local.startsWith("../") && !isAbsolute7(local);
+    const local = relative13(root, path);
+    return local !== ".." && !local.startsWith("../") && !isAbsolute8(local);
   };
-  let target = resolve13(root, `.${decodeURIComponent(pathname)}`);
+  let target = resolve14(root, `.${decodeURIComponent(pathname)}`);
   if (!inside(target)) {
     response.writeHead(403);
     response.end();
     return;
   }
-  if (!(await stat9(target).catch(() => null))?.isFile()) {
+  if (!(await stat10(target).catch(() => null))?.isFile()) {
     if (!fallback) {
       response.writeHead(404);
       response.end();
       return;
     }
-    target = resolve13(root, fallback);
+    target = resolve14(root, fallback);
   }
-  target = await realpath5(target);
+  target = await realpath8(target);
   if (!inside(target)) {
     response.writeHead(403);
     response.end();
@@ -40337,7 +40630,7 @@ async function sendFile(request, response, directory, pathname, fallback) {
     "Content-Type": contentTypes[extname7(target)] ?? "application/octet-stream",
     "X-Content-Type-Options": "nosniff"
   });
-  response.end(request.method === "HEAD" ? undefined : await readFile11(target));
+  response.end(request.method === "HEAD" ? undefined : await readFile12(target));
 }
 function createKennelApi(options) {
   const remote = options.remoteAccess || !isLoopbackServerHost(options.host);
@@ -40513,7 +40806,7 @@ var init_server4 = __esm(() => {
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync6, realpathSync as realpathSync3, statSync as statSync3 } from "node:fs";
 import { createServer as createServer2 } from "node:net";
-import { dirname as dirname11, isAbsolute as isAbsolute8, relative as relative13, resolve as resolve14 } from "node:path";
+import { dirname as dirname12, isAbsolute as isAbsolute9, relative as relative14, resolve as resolve15 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function isLoopbackHost(host) {
   return loopbackHosts.has(host) || host.startsWith("127.");
@@ -40592,7 +40885,7 @@ function splitViewerArgs(input) {
     }
     if (arg.startsWith("-"))
       throw new Error(`Unknown viewer option: ${arg}`);
-    const candidate = resolve14(arg);
+    const candidate = resolve15(arg);
     const isDirectory = existsSync6(candidate) && statSync3(candidate).isDirectory();
     if (isDirectory) {
       if (hasRoot)
@@ -40603,7 +40896,7 @@ function splitViewerArgs(input) {
     }
     if (hasRoot)
       throw new Error("kennel accepts one folder");
-    options.root = dirname11(candidate);
+    options.root = dirname12(candidate);
     options.target = candidate;
     hasRoot = true;
   }
@@ -40644,7 +40937,7 @@ function popUrl(host, port, options) {
     url.pathname = `/folder/${encodeBase64Url2(options.root)}/notes`;
     return url.href;
   }
-  url.pathname = `/folder/${encodeBase64Url2(options.root)}/document/${encodeBase64Url2(relative13(options.root, options.target))}`;
+  url.pathname = `/folder/${encodeBase64Url2(options.root)}/document/${encodeBase64Url2(relative14(options.root, options.target))}`;
   if (options.watch)
     url.searchParams.set("watch", "1");
   return url.href;
@@ -40655,8 +40948,8 @@ function viewerPortWasExplicit(input) {
 function isSameOrDescendant(parent, child) {
   const parentReal = realpathSync3(parent);
   const childReal = realpathSync3(child);
-  const childRelative = relative13(parentReal, childReal);
-  return childRelative === "" || !childRelative.startsWith("..") && !isAbsolute8(childRelative);
+  const childRelative = relative14(parentReal, childReal);
+  return childRelative === "" || !childRelative.startsWith("..") && !isAbsolute9(childRelative);
 }
 async function runningViewer(url) {
   try {
@@ -40717,8 +41010,8 @@ async function viewer(input) {
     await hotViewer(options);
     return;
   }
-  const web = resolve14(dirname11(fileURLToPath3(import.meta.url)), "../../web");
-  if (!existsSync6(resolve14(web, "index.html"))) {
+  const web = resolve15(dirname12(fileURLToPath3(import.meta.url)), "../../web");
+  if (!existsSync6(resolve15(web, "index.html"))) {
     throw new Error(`Kennel web app not found. Run the CLI build first.`);
   }
   const remote = options.tailscale || !isLoopbackHost(options.host);
@@ -40857,14 +41150,14 @@ async function startProtectedShare(handle) {
 var init_protected_share = () => {};
 
 // packages/preview/src/tailscale-share.ts
-import { execFile as execFile6 } from "node:child_process";
-import { promisify } from "node:util";
+import { execFile as execFile7 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
 async function serveConfig() {
-  const { stdout } = await run("tailscale", ["serve", "status", "--json"]);
+  const { stdout } = await run2("tailscale", ["serve", "status", "--json"]);
   return JSON.parse(stdout);
 }
 async function tailscaleHostname() {
-  const { stdout } = await run("tailscale", ["status", "--json"]);
+  const { stdout } = await run2("tailscale", ["status", "--json"]);
   const status = JSON.parse(stdout);
   const host = status.Self?.DNSName?.replace(/\.$/, "");
   if (status.BackendState !== "Running" || !host || !host.endsWith(".ts.net")) {
@@ -40883,11 +41176,11 @@ async function startTailscaleProxy(host, port) {
     const current = await serveConfig();
     const handlers = current.Web?.[authority]?.Handlers;
     if (handlers?.["/"]?.Proxy === target && Object.keys(handlers).length === 1) {
-      await run("tailscale", ["serve", `--https=${port}`, "off"]);
+      await run2("tailscale", ["serve", `--https=${port}`, "off"]);
     }
   };
   try {
-    await run("tailscale", ["serve", "--bg", "--yes", `--https=${port}`, target], { timeout: 30000 });
+    await run2("tailscale", ["serve", "--bg", "--yes", `--https=${port}`, target], { timeout: 30000 });
     const current = await serveConfig();
     if (current.AllowFunnel?.[authority] || current.Web?.[authority]?.Handlers?.["/"]?.Proxy !== target) {
       throw new Error("Tailscale did not create the expected private HTTPS proxy");
@@ -40898,13 +41191,13 @@ async function startTailscaleProxy(host, port) {
     throw error;
   }
 }
-var run;
+var run2;
 var init_tailscale_share = __esm(() => {
-  run = promisify(execFile6);
+  run2 = promisify2(execFile7);
 });
 
 // packages/preview/src/share.ts
-import { dirname as dirname12, resolve as resolve15 } from "node:path";
+import { dirname as dirname13, resolve as resolve16 } from "node:path";
 import { existsSync as existsSync7, realpathSync as realpathSync4 } from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function splitShareArgs(input) {
@@ -40956,7 +41249,7 @@ function splitShareArgs(input) {
   if (folder && !existsSync7(folder)) {
     throw new Error(`Folder not found: ${folder}`);
   }
-  options.folder = folder ? resolve15(folder) : undefined;
+  options.folder = folder ? resolve16(folder) : undefined;
   return options;
 }
 async function runningViewerRoot(port = plainViewerPort) {
@@ -40977,8 +41270,8 @@ async function runningViewerRoot(port = plainViewerPort) {
 }
 async function startPreviewShare(target) {
   const root = realpathSync4(target.root);
-  const web = resolve15(dirname12(fileURLToPath4(import.meta.url)), "../../web");
-  if (!existsSync7(resolve15(web, "index.html"))) {
+  const web = resolve16(dirname13(fileURLToPath4(import.meta.url)), "../../web");
+  if (!existsSync7(resolve16(web, "index.html"))) {
     throw new Error("Kennel web app not found. Run the CLI build first.");
   }
   const host = await tailscaleHostname();