kennel 0.2.31 → 0.2.33

package/dist/core/runtime.js

@@ -17027,8 +17027,8 @@ var require__2020 = __commonJS(function(exports, module) {
 import {
   createServer
 } from "node:http";
-import { readFile as readFile9, realpath as realpath5, stat as stat8 } from "node:fs/promises";
-import { extname as extname7, isAbsolute as isAbsolute7, relative as relative11, resolve as resolve12 } from "node:path";
+import { readFile as readFile11, realpath as realpath8, stat as stat10 } from "node:fs/promises";
+import { extname as extname7, isAbsolute as isAbsolute8, relative as relative12, resolve as resolve13 } from "node:path";
 
 // packages/api/src/server/watcher.ts
 import { existsSync, statSync, watch } from "node:fs";
@@ -21993,16 +21993,16 @@ function sendContract(response, url, body, headers = {}) {
 
 // packages/api/src/server/folder-metadata-plugin.ts
 import { realpathSync as realpathSync2 } from "node:fs";
-import { readdir as readdir5, readFile as readFile8, stat as stat7 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
+import { readdir as readdir6, readFile as readFile10, realpath as realpath7, stat as stat9 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
 import {
-  basename as basename6,
-  dirname as dirname9,
+  basename as basename7,
+  dirname as dirname10,
   extname as extname6,
-  isAbsolute as isAbsolute6,
-  relative as relative10,
-  resolve as resolve11,
-  sep as sep7
+  isAbsolute as isAbsolute7,
+  relative as relative11,
+  resolve as resolve12,
+  sep as sep8
 } from "node:path";
 
 // node_modules/.bun/@raggle-ai+barkdown@0.7.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react.js
@@ -35561,7 +35561,7 @@ async function readFolder(root) {
 }
 
 // packages/api/src/server/folder-metadata-plugin.ts
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 
 // packages/plugins/src/endpoint.ts
 var statusByCode = {
@@ -36688,19 +36688,215 @@ function createSchemaCollectionServer(host, options = {}) {
 // packages/api/src/server/folder-metadata-plugin.ts
 import local from "@raggle-ai/local";
 
-// packages/api/src/server/entity-folder.ts
-import { readdir as readdir3, readFile as readFile4, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+// packages/notes/src/store.ts
+import { execFile } from "node:child_process";
+import {
+  mkdir as mkdir2,
+  readdir as readdir3,
+  readFile as readFile4,
+  realpath as realpath3,
+  rename as rename2,
+  rm,
+  stat as stat3,
+  writeFile as writeFile2
+} from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
+import { basename as basename4, dirname as dirname5, join as join2, relative as relative6, resolve as resolve6, sep as sep4 } from "node:path";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var REPOSITORY_ID_KEY = "kennel.repoId";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+var markdownExtensions = new Set([".md", ".markdown"]);
+var caseInsensitiveHosts = new Set(["github.com", "gitlab.com", "bitbucket.org"]);
+class RepositoryNotesError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "RepositoryNotesError";
+    this.code = code;
+  }
+}
+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 readFile4(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(resolve6(folder));
+    if (!(await stat3(start)).isDirectory())
+      start = dirname5(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: relative6(directory, path).split(sep4).join("/"),
+        size: details.size
+      });
+    }
+  };
+  await visit(directory);
+  return notes.sort((left, right) => right.activityAt - left.activityAt);
+}
+
+// packages/api/src/server/entity-folder.ts
+import { readdir as readdir4, readFile as readFile5, realpath as realpath4, stat as stat4 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
 import {
-  basename as basename4,
-  dirname as dirname5,
+  basename as basename5,
+  dirname as dirname6,
   extname as extname2,
   isAbsolute as isAbsolute4,
-  join as join2,
-  relative as relative6,
-  resolve as resolve6
+  join as join3,
+  relative as relative7,
+  resolve as resolve7
 } from "node:path";
-var CONFIG_FILE = join2("kennel", "config.json");
+var CONFIG_FILE = join3("kennel", "config.json");
 var IGNORED_DIRECTORIES = new Set([
   ".git",
   ".gtl",
@@ -36741,11 +36937,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 readFile4(path, "utf8"));
+    return parseConfig(await readFile5(path, "utf8"));
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
       return null;
@@ -36762,6 +36958,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) => {
@@ -36773,12 +36971,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 = relative6(root, path);
+  const local = relative7(root, path);
   return local === "" || !local.startsWith("..") && !isAbsolute4(local);
 }
 async function normalizeRoot(rootPath, currentWorkspaceRoot) {
@@ -36786,13 +36984,13 @@ async function normalizeRoot(rootPath, currentWorkspaceRoot) {
   const fallback = currentWorkspaceRoot?.trim();
   if (!trimmed && !fallback)
     return null;
-  const requested = resolve6(trimmed || fallback);
-  const resolved = await realpath3(requested);
-  const info = await stat3(resolved);
+  const requested = resolve7(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");
@@ -36801,11 +36999,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;
@@ -36820,36 +37018,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 = dirname5(current);
+    current = dirname6(current);
   }
   return null;
 }
 async function readEntity(folderPath, rootPath) {
-  const indexPath = join2(folderPath, "index.md");
-  const index = parseMarkdown(await readFile4(indexPath, "utf8"));
+  const indexPath = join3(folderPath, "index.md");
+  const index = parseMarkdown(await readFile5(indexPath, "utf8"));
   const files = await markdownFiles(folderPath);
   const documents = await Promise.all(files.map(async (filePath) => {
-    const document2 = parseMarkdown(await readFile4(filePath, "utf8"));
+    const document2 = parseMarkdown(await readFile5(filePath, "utf8"));
     return {
       content: document2.body,
-      path: relative6(folderPath, filePath),
-      title: stringValue(document2.frontmatter.title) ?? heading(document2.body) ?? basename4(filePath, extname2(filePath))
+      path: relative7(folderPath, filePath),
+      title: stringValue(document2.frontmatter.title) ?? heading(document2.body) ?? basename5(filePath, extname2(filePath))
     };
   }));
-  const title = stringValue(index.frontmatter.title) ?? heading(index.body) ?? basename4(folderPath);
-  const relativePath = relative6(rootPath, folderPath) || ".";
+  const title = stringValue(index.frontmatter.title) ?? heading(index.body) ?? basename5(folderPath);
+  const relativePath = relative7(rootPath, folderPath) || ".";
   return {
     aliases: stringValues(index.frontmatter.aliases),
     content: [
@@ -36877,11 +37075,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);
@@ -36921,20 +37119,20 @@ async function loadEntityWorkspace(root, query, selectedPath, currentWorkspaceRo
 // packages/api/src/server/api/document-edit.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
-  readFile as readFile5,
-  realpath as realpath4,
-  rename as rename2,
-  stat as stat4,
+  readFile as readFile6,
+  realpath as realpath5,
+  rename as rename3,
+  stat as stat5,
   unlink as unlink2,
-  writeFile as writeFile2
+  writeFile as writeFile3
 } from "node:fs/promises";
 import {
-  dirname as dirname6,
+  dirname as dirname7,
   extname as extname3,
   isAbsolute as isAbsolute5,
-  relative as relative7,
-  resolve as resolve7,
-  sep as sep4
+  relative as relative8,
+  resolve as resolve8,
+  sep as sep5
 } from "node:path";
 
 // packages/api/src/shared/selection.ts
@@ -36952,10 +37150,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(resolve7(root, path));
-  const local = relative7(root, target);
-  if (!local || local === ".." || local.startsWith(`..${sep4}`) || isAbsolute5(local))
+  const root = await realpath5(folder);
+  const target = await realpath5(resolve8(root, path));
+  const local = relative8(root, target);
+  if (!local || local === ".." || local.startsWith(`..${sep5}`) || isAbsolute5(local))
     throw apiError("forbidden", "The document must be inside its folder.");
   let content;
   try {
@@ -36965,20 +37163,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 readFile5(target, "utf8") !== original)
+    if (await readFile6(target, "utf8") !== original)
       throw apiError("conflict", "This note changed on disk. Close this preview, reload the note, and try again.");
-    const temporary = resolve7(dirname6(target), `.kennel-edit-${randomUUID2()}.tmp`);
+    const temporary = resolve8(dirname7(target), `.kennel-edit-${randomUUID2()}.tmp`);
     try {
-      await writeFile2(temporary, content, {
+      await writeFile3(temporary, content, {
         flag: "wx",
         mode: details.mode & 511
       });
-      if (await readFile5(target, "utf8") !== original)
+      if (await readFile6(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(() => {});
     }
@@ -37001,7 +37199,7 @@ var documentEditRoute = {
       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(resolve7(folder, input.path)) !== context.lockedFile))
+    if (context.lockedFile && (typeof input.path !== "string" || await realpath5(resolve8(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 }));
@@ -37009,8 +37207,8 @@ var documentEditRoute = {
 };
 
 // packages/api/src/server/api/create-agent-file.ts
-import { writeFile as writeFile3 } from "node:fs/promises";
-import { resolve as resolve8 } from "node:path";
+import { writeFile as writeFile4 } from "node:fs/promises";
+import { resolve as resolve9 } from "node:path";
 var createAgentFileRoute = {
   method: "POST",
   maxBodyBytes: 0,
@@ -37021,9 +37219,9 @@ var createAgentFileRoute = {
     } catch (error) {
       throw apiError("not-found", error instanceof Error ? error.message : "Folder not found");
     }
-    const target = resolve8(folder, "AGENTS.md");
+    const target = resolve9(folder, "AGENTS.md");
     try {
-      await writeFile3(target, "", { flag: "wx" });
+      await writeFile4(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");
@@ -37035,7 +37233,7 @@ var createAgentFileRoute = {
 };
 
 // packages/api/src/server/api/open-path.ts
-import { execFile } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
 var openPathRoute = {
   method: "GET",
   async handle({ context, query, response }) {
@@ -37046,7 +37244,7 @@ var openPathRoute = {
       throw apiError("not-found", error instanceof Error ? error.message : "Path not found");
     }
     await new Promise((done, fail) => {
-      execFile("/usr/bin/open", [target], (error) => {
+      execFile2("/usr/bin/open", [target], (error) => {
         if (error)
           fail(apiError("failed", "Could not open path"));
         else
@@ -37059,11 +37257,11 @@ var openPathRoute = {
 };
 
 // packages/api/src/server/folder-favicon.ts
-import { readFile as readFile6 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { readFile as readFile7 } 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 readFile6(join3(folder, name), "utf8").catch(() => "");
+    const content = await readFile7(join4(folder, name), "utf8").catch(() => "");
     const entry = markdownMetadata(content).entries.find(([key]) => key === "website");
     if (entry)
       return websiteHost(entry[1]);
@@ -37073,7 +37271,7 @@ async function folderWebsite(folder) {
 
 // packages/api/src/server/folder-icons.ts
 import { createHash as createHash4 } from "node:crypto";
-import { readFile as readFile7, stat as stat5 } from "node:fs/promises";
+import { readFile as readFile8, stat as stat6 } from "node:fs/promises";
 import { extname as extname4 } from "node:path";
 import { discoverFolderIcon } from "@raggle-ai/local";
 var maxIconBytes2 = 4 * 1024 * 1024;
@@ -37112,13 +37310,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 readFile7(icon);
+  const data = await readFile8(icon);
   const hash = assetKey(data);
   const key = `local:${hash}`;
   assetFiles.set(hash, { mediaType, path: icon });
@@ -37137,12 +37335,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 readFile7(icon)).toString("base64")}`;
+  return `data:${mediaType};base64,${(await readFile8(icon)).toString("base64")}`;
 }
 async function faviconAsset(folderName, assets) {
   if (process.env.KENNEL_EXTERNAL_ICONS !== "1")
@@ -37188,11 +37386,19 @@ async function workspaceBreadcrumbIcons(breadcrumbs, assetFiles, assets = {}) {
 // packages/api/src/server/plugins.ts
 import { pathToFileURL } from "node:url";
 import { existsSync as existsSync3 } from "node:fs";
-import { dirname as dirname7, resolve as resolve10, sep as sep6 } from "node:path";
+import { mkdir as mkdir3, readFile as readFile9, stat as stat8, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname8, resolve as resolve11, sep as sep7 } from "node:path";
 
 // packages/notes/src/server.ts
-import { readdir as readdir4, stat as stat6 } from "node:fs/promises";
-import { basename as basename5, extname as extname5, relative as relative8, resolve as resolve9, sep as sep5 } from "node:path";
+import { readdir as readdir5, realpath as realpath6, stat as stat7 } from "node:fs/promises";
+import {
+  basename as basename6,
+  extname as extname5,
+  isAbsolute as isAbsolute6,
+  relative as relative9,
+  resolve as resolve10,
+  sep as sep6
+} from "node:path";
 
 // packages/notes/src/manifest.ts
 var notesManifest = {
@@ -37208,52 +37414,122 @@ var notesManifest = {
 };
 
 // packages/notes/src/server.ts
-var markdownExtensions = new Set([".md", ".markdown"]);
+var markdownExtensions2 = new Set([".md", ".markdown"]);
+var llmNoteLimit = 20;
 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 = resolve9(current, entry.name);
+      const path = resolve10(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: basename5(entry.name, extname5(entry.name)),
-        relativePath: relative8(folder, path).split(sep5).join("/")
+        name: basename6(entry.name, extname5(entry.name)),
+        relativePath: relative9(folder, path).split(sep6).join("/")
       });
     }
   };
   await visit(folder);
   return files.sort((left, right) => right.activityAt - left.activityAt);
 }
-async function loadNotes(folder, linkedFolders = []) {
+var canonical = (path) => realpath6(path).catch(() => path);
+function inside5(path, root) {
+  const local = relative9(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(resolve10(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,
     status: "available"
   };
 }
+function codeSpan(text) {
+  const escaped = text.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/gu, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
+  const longest = Math.max(0, ...(escaped.match(/`+/g) ?? []).map((run) => run.length));
+  const fence = "`".repeat(longest + 1);
+  const pad = escaped.startsWith("`") || escaped.endsWith("`") ? " " : "";
+  return `${fence}${pad}${escaped}${pad}${fence}`;
+}
+async function notesLlmSections({
+  folder,
+  linkedFolders = [],
+  managedFolders = [],
+  signal
+}) {
+  const groups = [];
+  const notes = [];
+  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));
+    groups.push({ folder: source, paths });
+    files.forEach((file, index) => notes.push({ activityAt: file.activityAt, path: paths[index] }));
+  }
+  if (notes.length === 0)
+    return [];
+  const recent = notes.sort((left, right) => right.activityAt - left.activityAt || (left.path < right.path ? -1 : left.path > right.path ? 1 : 0)).slice(0, llmNoteLimit);
+  return [
+    {
+      id: "notes",
+      title: "Markdown notes",
+      lines: [
+        ...groups.filter((group) => group.paths.length > 0).map((group) => `- Source: ${codeSpan(group.folder)} (${group.paths.length} ${group.paths.length === 1 ? "note" : "notes"})`),
+        `- Total notes: ${notes.length}`,
+        "",
+        `Most recently changed (${recent.length} of ${notes.length}):`,
+        "",
+        ...recent.map((note) => `- ${codeSpan(note.path)}`)
+      ]
+    }
+  ];
+}
 function createNotesPlugin() {
   return {
     ...notesManifest,
@@ -37265,10 +37541,15 @@ 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
   };
 }
 
@@ -37282,6 +37563,44 @@ function configuredFolderServerRegistry(registry, resolvedConfig) {
   ];
   return new Map(ids.map((id) => [id, registry.get(id)]));
 }
+var defaultPluginRegistryConfig = {
+  plugins: { disable: [], order: [] }
+};
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function parsePluginRegistryConfig(content) {
+  const parsed = JSON.parse(content);
+  const config = parsed && typeof parsed === "object" ? parsed : {};
+  return {
+    plugins: {
+      disable: stringArray(config.plugins?.disable),
+      order: stringArray(config.plugins?.order)
+    }
+  };
+}
+async function nearestKennelConfig(folder) {
+  for (let current = folder;; current = dirname8(current)) {
+    const candidate = resolve11(current, "kennel.json");
+    const details = await stat8(candidate).catch(() => {
+      return;
+    });
+    if (details?.isFile())
+      return candidate;
+    if (dirname8(current) === current)
+      return;
+  }
+}
+async function folderPluginRegistryConfig(folder) {
+  const path = await nearestKennelConfig(folder);
+  if (!path)
+    return defaultPluginRegistryConfig;
+  try {
+    return parsePluginRegistryConfig(await readFile9(path, "utf8"));
+  } catch {
+    return defaultPluginRegistryConfig;
+  }
+}
 function createFolderServerPlugins() {
   return [createNotesPlugin()];
 }
@@ -37325,7 +37644,7 @@ async function folderServerRegistryAsync() {
       ...server,
       async detect(context) {
         const detection = await server.detect(context);
-        if (detection.status === "unavailable" && existsSync3(resolve10(context.folder, entry.trigger))) {
+        if (detection.status === "unavailable" && existsSync3(resolve11(context.folder, entry.trigger))) {
           return { status: "available" };
         }
         return detection;
@@ -37364,13 +37683,13 @@ async function externalApiHandlers() {
 }
 
 // packages/api/src/server/project-discovery.ts
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 
 // packages/api/src/server/linked-folder-discovery.ts
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname8, join as join4 } from "node:path";
+import { dirname as dirname9, join as join5 } from "node:path";
 import { fileURLToPath } from "node:url";
 var script = `
 const local = require(process.argv[1]);
@@ -37393,19 +37712,19 @@ function resolveLocalModule(from = import.meta.url) {
   try {
     candidates.push(require2.resolve("@raggle-ai/local"));
   } catch {}
-  let directory = dirname8(fileURLToPath(from));
-  while (dirname8(directory) !== directory) {
-    if (existsSync4(join4(directory, "raggle.json"))) {
+  let directory = dirname9(fileURLToPath(from));
+  while (dirname9(directory) !== directory) {
+    if (existsSync4(join5(directory, "raggle.json"))) {
       for (const candidate of [
-        join4(dirname8(directory), "raggle-ai-scout", "packages", "local"),
-        join4(directory, "..", "..", "raggle-ai-scout", "packages", "local")
+        join5(dirname9(directory), "raggle-ai-scout", "packages", "local"),
+        join5(directory, "..", "..", "raggle-ai-scout", "packages", "local")
       ]) {
         if (!candidates.includes(candidate))
           candidates.push(candidate);
       }
       break;
     }
-    directory = dirname8(directory);
+    directory = dirname9(directory);
   }
   for (const candidate of candidates) {
     try {
@@ -37414,11 +37733,11 @@ function resolveLocalModule(from = import.meta.url) {
         return candidate;
     } catch {}
   }
-  return candidates[0] ?? join4(dirname8(fileURLToPath(from)), "..", "..", "..", "raggle-ai-scout", "packages", "local");
+  return candidates[0] ?? join5(dirname9(fileURLToPath(from)), "..", "..", "..", "raggle-ai-scout", "packages", "local");
 }
 function discoverLinkedFolders(folder, signal, modulePath = resolveLocalModule()) {
   return new Promise((resolve, reject) => {
-    execFile2(process.execPath, ["-e", script, modulePath, folder], {
+    execFile3(process.execPath, ["-e", script, modulePath, folder], {
       signal,
       timeout: 60000,
       maxBuffer: 8 * 1024 * 1024,
@@ -37509,7 +37828,7 @@ local.discoverProjectsUnderFolder({folder}).then(projects => {
 `;
 function discoverProjects(folder, signal) {
   return new Promise((resolve, reject) => {
-    execFile3(process.execPath, ["-e", script2, resolveLocalModule(), folder], {
+    execFile4(process.execPath, ["-e", script2, resolveLocalModule(), folder], {
       signal,
       timeout: 60000,
       maxBuffer: 8 * 1024 * 1024,
@@ -37766,10 +38085,10 @@ var metadataExtensions = new Set([
   ".txt"
 ]);
 function metadataFile(path, root) {
-  const candidate = relative10(root, path);
-  if (!candidate || candidate.startsWith("..") || isAbsolute6(candidate))
+  const candidate = relative11(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());
@@ -37780,11 +38099,11 @@ async function configuredAiInputModule(folder) {
   return typeof module === "string" && module.trim() ? module.trim() : null;
 }
 function folderPath(value, root, lockedRoot) {
-  const folder = realpathSync2(resolve11(value ?? root));
+  const folder = realpathSync2(resolve12(value ?? root));
   if (!lockedRoot)
     return folder;
-  const path = relative10(lockedRoot, folder);
-  if (!path || !path.startsWith("..") && !isAbsolute6(path))
+  const path = relative11(lockedRoot, folder);
+  if (!path || !path.startsWith("..") && !isAbsolute7(path))
     return folder;
   throw new Error(`Folder is outside the viewer root: ${folder}`);
 }
@@ -37855,15 +38174,15 @@ function unique(values) {
   return [...new Set(values)];
 }
 function isMachineRoot(folder) {
-  return folder === homedir3() || dirname9(folder) === folder;
+  return folder === homedir4() || dirname10(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 = resolve11(folder, entry.name);
-    const details = await stat7(path);
-    const content = await readFile8(path, "utf8").catch(() => "");
+    const path = resolve12(folder, entry.name);
+    const details = await stat9(path);
+    const content = await readFile10(path, "utf8").catch(() => "");
     const title = markdownMetadata(content).title;
     return {
       activityAt: details.mtimeMs,
@@ -37876,10 +38195,10 @@ async function shallowMetadata(folder) {
     };
   }));
   const projects = visible.filter((entry) => entry.isDirectory()).map((entry) => ({
-    id: createHash5("sha1").update(resolve11(folder, entry.name)).digest("hex"),
+    id: createHash5("sha1").update(resolve12(folder, entry.name)).digest("hex"),
     name: entry.name,
     relativePath: entry.name,
-    worktree: resolve11(folder, entry.name)
+    worktree: resolve12(folder, entry.name)
   })).sort((left, right) => left.name.localeCompare(right.name));
   return {
     changes: { items: [] },
@@ -37905,8 +38224,8 @@ async function loadFolderData(folder) {
       items: projects.map((project) => ({
         id: project.id,
         worktree: project.worktree,
-        name: project.name ?? basename6(project.worktree),
-        relativePath: relative10(folder, project.worktree)
+        name: project.name ?? basename7(project.worktree),
+        relativePath: relative11(folder, project.worktree)
       }))
     }
   };
@@ -37914,10 +38233,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 ? resolve11(folder, file.relativePath) : undefined);
+      const path = file.path ?? (file.relativePath ? resolve12(folder, file.relativePath) : undefined);
       if (!path)
         return origin ? { ...file, folder: origin } : file;
-      const content = [".markdown", ".md"].includes(extname6(path).toLowerCase()) ? await readFile8(path, "utf8").catch(() => "") : "";
+      const content = [".markdown", ".md"].includes(extname6(path).toLowerCase()) ? await readFile10(path, "utf8").catch(() => "") : "";
       const title = content ? markdownMetadata(content).title : undefined;
       return {
         ...file,
@@ -37928,6 +38247,31 @@ 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 readFile10(note.path, "utf8").catch(() => "");
+    const title = content ? markdownMetadata(content).title : undefined;
+    return {
+      ...note,
+      folder: directory,
+      name: title ?? note.name,
+      openHref: openPathHref(note.path)
+    };
+  }));
+}
+var canonicalPath = (path) => realpath7(path).catch(() => path);
+function insideFolder(path, root) {
+  const local = relative11(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;
@@ -37950,16 +38294,16 @@ async function localProjectSearchCache(cache) {
 function mediaTarget(folder, file, lockedTarget) {
   if (!file)
     return;
-  const rootReal = realpathSync2(resolve11(folder));
-  const path = resolve11(folder, file);
+  const rootReal = realpathSync2(resolve12(folder));
+  const path = resolve12(folder, file);
   let pathReal;
   try {
     pathReal = realpathSync2(path);
   } catch {
     return;
   }
-  const rel = relative10(rootReal, pathReal);
-  if (rel.startsWith("..") || isAbsolute6(rel))
+  const rel = relative11(rootReal, pathReal);
+  if (rel.startsWith("..") || isAbsolute7(rel))
     return;
   if (lockedTarget && pathReal !== lockedTarget)
     return;
@@ -37998,16 +38342,16 @@ function documentError(response) {
 function documentTarget(folder, file, lockedTarget) {
   if (!file)
     return;
-  const rootReal = realpathSync2(resolve11(folder));
-  const path = resolve11(folder, file);
+  const rootReal = realpathSync2(resolve12(folder));
+  const path = resolve12(folder, file);
   let pathReal;
   try {
     pathReal = realpathSync2(path);
   } catch {
     return;
   }
-  const rel = relative10(rootReal, pathReal);
-  if (rel.startsWith("..") || isAbsolute6(rel))
+  const rel = relative11(rootReal, pathReal);
+  if (rel.startsWith("..") || isAbsolute7(rel))
     return;
   if (lockedTarget && pathReal !== lockedTarget)
     return;
@@ -38035,44 +38379,6 @@ async function projectSearchItem(project, match) {
     worktree: project.worktree
   };
 }
-var defaultPluginRegistryConfig = {
-  plugins: { disable: [], order: [] }
-};
-function stringArray(value) {
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-function parsePluginRegistryConfig(content) {
-  const parsed = JSON.parse(content);
-  const config = parsed && typeof parsed === "object" ? parsed : {};
-  return {
-    plugins: {
-      disable: stringArray(config.plugins?.disable),
-      order: stringArray(config.plugins?.order)
-    }
-  };
-}
-async function nearestKennelConfig(folder) {
-  for (let current = folder;; current = dirname9(current)) {
-    const candidate = resolve11(current, "kennel.json");
-    const details = await stat7(candidate).catch(() => {
-      return;
-    });
-    if (details?.isFile())
-      return candidate;
-    if (dirname9(current) === current)
-      return;
-  }
-}
-async function folderPluginRegistryConfig(folder) {
-  const path = await nearestKennelConfig(folder);
-  if (!path)
-    return defaultPluginRegistryConfig;
-  try {
-    return parsePluginRegistryConfig(await readFile8(path, "utf8"));
-  } catch {
-    return defaultPluginRegistryConfig;
-  }
-}
 function pluginConfigWarnings(registry, config) {
   const ids = unique([...config.plugins.disable, ...config.plugins.order]);
   return ids.filter((id) => !registry.has(id)).map((id) => `unknown plugin id "${id}" — not installed in this build`);
@@ -38123,6 +38429,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",
@@ -38165,7 +38483,7 @@ function createFolderApi({
         if (!folder)
           return;
         server.emit({
-          data: { path: relative10(folder, path) },
+          data: { path: relative11(folder, path) },
           event: "kennel:metadata-changed",
           type: "custom"
         });
@@ -38248,7 +38566,7 @@ function createFolderApi({
               "Content-Type": asset.mediaType,
               ETag: `"${hash}"`
             });
-            response.end(await readFile8(asset.path));
+            response.end(await readFile10(asset.path));
           } catch (error) {
             response.writeHead(404, {
               "Content-Type": "text/plain; charset=utf-8"
@@ -38313,21 +38631,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) => execFile4(command, [folder], (error) => error ? fail(error) : done()));
+          await new Promise((done, fail) => execFile5(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, relative10(folder, lockedTarget), lockedTarget) : undefined;
+          const target = lockedTarget ? documentTarget(folder, relative11(folder, lockedTarget), lockedTarget) : undefined;
           const dataset = lockedTarget ? {
             root: folder,
             documents: target ? [
               {
-                path: relative10(folder, target.path),
+                path: relative11(folder, target.path),
                 kind: target.kind,
-                content: previewTextKind(target.kind) ? await readFile8(target.path, "utf8") : ""
+                content: previewTextKind(target.kind) ? await readFile10(target.path, "utf8") : ""
               }
             ] : []
           } : await readFolder(folder);
@@ -38343,7 +38661,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat7(target.path);
+            const details = await stat9(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -38355,16 +38673,16 @@ function createFolderApi({
               return;
             }
             watch(folder);
-            const content = previewTextKind(target.kind) ? await readFile8(target.path, "utf8") : "";
+            const content = previewTextKind(target.kind) ? await readFile10(target.path, "utf8") : "";
             sendContract(response, url, {
               content,
               kind: target.kind,
-              path: relative10(target.root, target.path),
+              path: relative11(target.root, target.path),
               root: folder,
               ...previewTextKind(target.kind) ? {} : {
                 rawUrl: `/api/raw?${new URLSearchParams({
                   path: folder,
-                  file: relative10(target.root, target.path)
+                  file: relative11(target.root, target.path)
                 })}`
               }
             }, {
@@ -38384,7 +38702,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat7(target.path);
+            const details = await stat9(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -38405,10 +38723,10 @@ function createFolderApi({
               ETag: etag,
               "X-Content-Type-Options": "nosniff",
               ...download ? {
-                "Content-Disposition": `attachment; filename="${basename6(target.path)}"`
+                "Content-Disposition": `attachment; filename="${basename7(target.path)}"`
               } : {}
             });
-            response.end(await readFile8(target.path));
+            response.end(await readFile10(target.path));
           } catch (error) {
             documentError(response);
           }
@@ -38422,7 +38740,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat7(target.path);
+            const details = await stat9(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -38434,7 +38752,7 @@ function createFolderApi({
               return;
             }
             watch(folder);
-            const data = await readFile8(target.path);
+            const data = await readFile10(target.path);
             const baseHeaders = {
               "Accept-Ranges": "bytes",
               "Cache-Control": "private, max-age=0, must-revalidate",
@@ -38488,9 +38806,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, {
@@ -38593,7 +38915,7 @@ function createFolderApi({
             workspace.breadcrumbs = await workspaceBreadcrumbIcons(workspace.breadcrumbs ?? [], assetFiles);
             const files = [
               workspace.configPath,
-              resolve11(workspace.root, "raggle.json")
+              resolve12(workspace.root, "raggle.json")
             ].filter((path) => Boolean(path));
             for (const path of files)
               contexts.add(path);
@@ -38617,7 +38939,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 [];
@@ -38628,20 +38957,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)
                 ]
               },
@@ -38740,26 +39074,26 @@ var contentTypes = {
   ".ttf": "font/ttf"
 };
 async function sendFile(request, response, directory, pathname, fallback) {
-  const root = await realpath5(directory);
+  const root = await realpath8(directory);
   const inside = (path) => {
-    const local = relative11(root, path);
-    return local !== ".." && !local.startsWith("../") && !isAbsolute7(local);
+    const local = relative12(root, path);
+    return local !== ".." && !local.startsWith("../") && !isAbsolute8(local);
   };
-  let target = resolve12(root, `.${decodeURIComponent(pathname)}`);
+  let target = resolve13(root, `.${decodeURIComponent(pathname)}`);
   if (!inside(target)) {
     response.writeHead(403);
     response.end();
     return;
   }
-  if (!(await stat8(target).catch(() => null))?.isFile()) {
+  if (!(await stat10(target).catch(() => null))?.isFile()) {
     if (!fallback) {
       response.writeHead(404);
       response.end();
       return;
     }
-    target = resolve12(root, fallback);
+    target = resolve13(root, fallback);
   }
-  target = await realpath5(target);
+  target = await realpath8(target);
   if (!inside(target)) {
     response.writeHead(403);
     response.end();
@@ -38769,7 +39103,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 readFile9(target));
+  response.end(request.method === "HEAD" ? undefined : await readFile11(target));
 }
 function createKennelApi(options) {
   const remote = options.remoteAccess || !isLoopbackServerHost(options.host);