kennel 0.2.2 → 0.2.5

package/dist/core/runtime.js

@@ -55493,8 +55493,8 @@ var require_dist4 = __commonJS((exports) => {
 import {
   createServer
 } from "node:http";
-import { readFile as readFile15, realpath as realpath8, stat as stat10 } from "node:fs/promises";
-import { extname as extname7, isAbsolute as isAbsolute10, relative as relative15, resolve as resolve19 } from "node:path";
+import { readFile as readFile10, realpath as realpath6, stat as stat9 } from "node:fs/promises";
+import { extname as extname7, isAbsolute as isAbsolute7, relative as relative11, resolve as resolve13 } from "node:path";
 
 // packages/api/src/server/watcher.ts
 import { existsSync, statSync, watch } from "node:fs";
@@ -55540,7 +55540,7 @@ function createWatcher(onChange) {
 }
 
 // packages/api/src/server/folder-metadata-plugin.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 // node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -70192,17 +70192,17 @@ function sendContract(response, url2, body, headers = {}) {
 }
 
 // packages/api/src/server/folder-metadata-plugin.ts
-import { realpathSync as realpathSync3 } from "node:fs";
-import { readdir as readdir9, readFile as readFile14, stat as stat9 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
+import { realpathSync as realpathSync2 } from "node:fs";
+import { readdir as readdir5, readFile as readFile9, stat as stat8 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
 import {
-  basename as basename9,
-  dirname as dirname16,
+  basename as basename7,
+  dirname as dirname10,
   extname as extname6,
-  isAbsolute as isAbsolute9,
-  relative as relative14,
-  resolve as resolve18,
-  sep as sep12
+  isAbsolute as isAbsolute6,
+  relative as relative10,
+  resolve as resolve12,
+  sep as sep7
 } from "node:path";
 
 // node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react.js
@@ -83665,7 +83665,7 @@ async function readFolder(root) {
   };
 }
 // packages/api/src/server/folder-metadata-plugin.ts
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 
 // packages/folder-plugin/src/endpoint.ts
 var statusByCode = {
@@ -83832,7 +83832,7 @@ async function runApiRoute(request, response, url2, spec, context) {
 }
 
 // packages/api/src/server/folder-metadata-plugin.ts
-var import_yaml5 = __toESM(require_dist(), 1);
+var import_yaml4 = __toESM(require_dist(), 1);
 
 // packages/folder-plugin/src/server.ts
 class FolderPluginFailure extends Error {
@@ -84793,1819 +84793,6 @@ function createSchemaCollectionServer(host, options = {}) {
 // packages/api/src/server/folder-metadata-plugin.ts
 var import_local3 = __toESM(require_dist4(), 1);
 
-// plugins/mail/src/history.ts
-import { createHash as createHash4 } from "node:crypto";
-import {
-  lstat,
-  mkdir as mkdir3,
-  readFile as readFile4,
-  realpath as realpath3,
-  rename as rename2,
-  unlink as unlink2,
-  writeFile as writeFile2
-} from "node:fs/promises";
-import { dirname as dirname6, isAbsolute as isAbsolute4, relative as relative6, resolve as resolve7, sep as sep4 } from "node:path";
-
-// plugins/mail/src/flock.ts
-import { closeSync, constants as constants2, openSync } from "node:fs";
-import { mkdir as mkdir2 } from "node:fs/promises";
-import { dirname as dirname5, resolve as resolve6 } from "node:path";
-
-class FlockTimeoutError extends Error {
-  lockPath;
-  constructor(lockPath, timeoutMs) {
-    super(`Timed out after ${timeoutMs}ms waiting for the draft lock ${resolve6(lockPath)}`);
-    this.name = "FlockTimeoutError";
-    this.lockPath = resolve6(lockPath);
-  }
-}
-var LOCK_EX = 2;
-var LOCK_NB = 4;
-var LOCK_UN = 8;
-var EINTR = 4;
-var EWOULDBLOCK_DARWIN = 35;
-var EWOULDBLOCK_LINUX = 11;
-function isBunRuntime() {
-  return typeof process !== "undefined" && typeof process.versions !== "undefined" && "bun" in process.versions;
-}
-var libcPath = process.platform === "darwin" ? "/usr/lib/libSystem.B.dylib" : "libc.so.6";
-var backendPromise = null;
-async function loadBackend() {
-  backendPromise ??= (async () => {
-    if (isBunRuntime()) {
-      const { dlopen } = await import("bun:ffi");
-      const libc2 = dlopen(libcPath, {
-        flock: { args: ["int", "int"], returns: "int" }
-      });
-      return { flock: libc2.symbols.flock, errno: () => 0 };
-    }
-    const koffi = (await import("koffi")).default;
-    const libc = koffi.load(libcPath);
-    return {
-      flock: libc.func("int flock(int fd, int operation)"),
-      errno: koffi.errno
-    };
-  })();
-  return backendPromise;
-}
-var wouldBlockErrno = process.platform === "darwin" ? EWOULDBLOCK_DARWIN : EWOULDBLOCK_LINUX;
-function sleep(ms) {
-  return new Promise((resolveSleep) => {
-    setTimeout(resolveSleep, ms);
-  });
-}
-async function withFlock(lockPath, timeoutMs, action) {
-  const resolved = resolve6(lockPath);
-  await mkdir2(dirname5(resolved), { mode: 448, recursive: true }).catch(() => {
-    return;
-  });
-  const { flock, errno } = await loadBackend();
-  const fd = openSync(resolved, constants2.O_RDWR | constants2.O_CREAT, 384);
-  try {
-    const deadline = Date.now() + timeoutMs;
-    for (;; ) {
-      if (flock(fd, LOCK_EX | LOCK_NB) === 0)
-        break;
-      const code = errno();
-      if (code !== 0 && code !== EINTR && code !== wouldBlockErrno) {
-        throw new Error(`flock failed on ${resolved} (errno ${code})`);
-      }
-      const remaining = deadline - Date.now();
-      if (remaining <= 0) {
-        throw new FlockTimeoutError(resolved, timeoutMs);
-      }
-      await sleep(Math.min(50, remaining));
-    }
-    return await action();
-  } finally {
-    try {
-      flock(fd, LOCK_UN);
-    } finally {
-      closeSync(fd);
-    }
-  }
-}
-
-// plugins/mail/src/parse.ts
-var import_yaml3 = __toESM(require_dist(), 1);
-function stringOrNull(value) {
-  return typeof value === "string" && value.trim() ? value : null;
-}
-function boolValue(value) {
-  return value === true || value === "true";
-}
-function stringList(value) {
-  if (!value)
-    return [];
-  if (Array.isArray(value))
-    return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
-  if (typeof value === "string")
-    return value.trim() ? [value.trim()] : [];
-  return [];
-}
-function parseMailMarkdown(content) {
-  if (!content.startsWith(`---
-`)) {
-    return {
-      id: null,
-      status: null,
-      tags: [],
-      folder: null,
-      attachments: [],
-      from: null,
-      inReplyTo: null,
-      references: [],
-      to: [],
-      cc: [],
-      bcc: [],
-      subject: null,
-      createdAt: null,
-      updatedAt: null,
-      noSignature: false,
-      body: content
-    };
-  }
-  const end = content.indexOf(`
----
-`);
-  if (end < 0) {
-    return {
-      id: null,
-      status: null,
-      tags: [],
-      folder: null,
-      attachments: [],
-      from: null,
-      inReplyTo: null,
-      references: [],
-      to: [],
-      cc: [],
-      bcc: [],
-      subject: null,
-      createdAt: null,
-      updatedAt: null,
-      noSignature: false,
-      body: content
-    };
-  }
-  const frontmatterRaw = content.slice(4, end);
-  const body = content.slice(end + `
----
-`.length).replace(/^\n+/, "");
-  const frontmatterValue = import_yaml3.parse(frontmatterRaw);
-  const frontmatter2 = frontmatterValue && typeof frontmatterValue === "object" && !Array.isArray(frontmatterValue) ? frontmatterValue : {};
-  return {
-    id: stringOrNull(frontmatter2.id),
-    status: stringOrNull(frontmatter2.status),
-    tags: stringList(frontmatter2.tags),
-    folder: stringOrNull(frontmatter2.folder),
-    attachments: stringList(frontmatter2.file),
-    from: stringOrNull(frontmatter2.from),
-    inReplyTo: stringOrNull(frontmatter2.in_reply_to),
-    references: stringList(frontmatter2.references),
-    to: stringList(frontmatter2.to),
-    cc: stringList(frontmatter2.cc),
-    bcc: stringList(frontmatter2.bcc),
-    subject: stringOrNull(frontmatter2.subject),
-    createdAt: stringOrNull(frontmatter2.created_at),
-    updatedAt: stringOrNull(frontmatter2.updated_at),
-    noSignature: boolValue(frontmatter2.no_signature),
-    body
-  };
-}
-function mailExcerpt(body, maxChars = 280) {
-  const normalized = body.trim().replace(/\r\n/g, `
-`).replace(/\n{3,}/g, `
-
-`);
-  if (normalized.length <= maxChars)
-    return normalized;
-  return `${normalized.slice(0, maxChars).trimEnd()}…`;
-}
-
-// plugins/mail/src/history.ts
-class MailDeleteError extends Error {
-  outcome;
-  constructor(outcome, message) {
-    super(message);
-    this.name = "MailDeleteError";
-    this.outcome = outcome;
-  }
-}
-var deleteLockTimeoutMs = 30000;
-function validDraftId(id) {
-  const trimmed = id.trim();
-  return Boolean(trimmed) && trimmed !== "." && trimmed !== ".." && !/[\\/]/.test(trimmed);
-}
-function draftRevision(content) {
-  return createHash4("sha256").update(content).digest("hex");
-}
-async function ensureRealDirChain(anchor, childPath) {
-  const rel = relative6(anchor, childPath);
-  if (!rel || rel === ".." || rel.startsWith(`..${sep4}`) || isAbsolute4(rel)) {
-    throw new MailDeleteError("invalid", "Lock/history path escapes the mail folder");
-  }
-  let current = anchor;
-  for (const segment of rel.split(sep4)) {
-    if (!segment)
-      continue;
-    current = resolve7(current, segment);
-    let info = await lstat(current).catch(() => {
-      return;
-    });
-    if (!info) {
-      await mkdir3(current, { mode: 448 }).catch(() => {
-        return;
-      });
-      info = await lstat(current).catch(() => {
-        return;
-      });
-      if (!info || info.isSymbolicLink() || !info.isDirectory()) {
-        throw new MailDeleteError("invalid", "Could not create a real directory for the draft lock/history");
-      }
-      continue;
-    }
-    if (info.isSymbolicLink() || !info.isDirectory()) {
-      throw new MailDeleteError("invalid", "Draft lock/history path must use real directories (no symlinked components)");
-    }
-  }
-}
-async function deleteLocalDraftVerified(mail, mailDir) {
-  if (!validDraftId(mail.id)) {
-    throw new MailDeleteError("invalid", "Invalid mail id");
-  }
-  const mailDirReal = await realpath3(resolve7(mailDir));
-  const target = resolve7(mail.filePath);
-  const targetDir = await realpath3(dirname6(target)).catch(() => null);
-  if (targetDir !== mailDirReal) {
-    throw new MailDeleteError("invalid", "Draft path is outside the mail folder");
-  }
-  const expected = resolve7(mailDirReal, `${mail.id.trim()}.md`);
-  const targetReal = await realpath3(target).catch(() => null);
-  if (targetReal === null) {
-    throw new MailDeleteError("missing", "Draft no longer exists");
-  }
-  if (targetReal !== expected) {
-    throw new MailDeleteError("invalid", "Draft path is not a direct file in the mail folder");
-  }
-  if (!/^[a-f0-9]{64}$/i.test(mail.revision)) {
-    throw new MailDeleteError("invalid", "Invalid draft revision");
-  }
-  const locksDir = resolve7(mailDirReal, ".locks");
-  await ensureRealDirChain(mailDirReal, locksDir);
-  const lockPath = resolve7(locksDir, `${mail.id.trim()}.md.lock`);
-  try {
-    return await withFlock(lockPath, deleteLockTimeoutMs, async () => {
-      const content = await readFile4(target, "utf8").catch(() => null);
-      if (content === null) {
-        throw new MailDeleteError("missing", "Draft no longer exists");
-      }
-      if (draftRevision(content) !== mail.revision.toLowerCase()) {
-        throw new MailDeleteError("changed", "Draft changed since it was loaded; refusing to delete newer work");
-      }
-      const historyDir = resolve7(mailDirReal, "history", mail.id);
-      await ensureRealDirChain(mailDirReal, historyDir);
-      const historyPath = resolve7(historyDir, `${mail.revision}.md`);
-      const existingLstat = await lstat(historyPath).catch(() => {
-        return;
-      });
-      if (existingLstat?.isSymbolicLink()) {
-        throw new MailDeleteError("invalid", "History snapshot path is a symlink; refusing to touch it");
-      }
-      const existing = existingLstat ?? undefined;
-      if (existing?.isFile()) {
-        const existingContent = await readFile4(historyPath, "utf8").catch(() => null);
-        if (existingContent === null || draftRevision(existingContent) !== mail.revision.toLowerCase()) {
-          throw new MailDeleteError("changed", "Existing draft history does not match this revision; refusing to delete");
-        }
-      } else if (existing) {
-        throw new MailDeleteError("invalid", "History snapshot path is not a regular file");
-      } else {
-        const tempPath = resolve7(historyDir, `${mail.revision}.md.tmp`);
-        for (let attempt = 0;; attempt += 1) {
-          try {
-            await writeFile2(tempPath, content, { flag: "wx", mode: 384 });
-            break;
-          } catch (error51) {
-            if (error51.code !== "EEXIST")
-              throw error51;
-            const tempInfo = await lstat(tempPath).catch(() => {
-              return;
-            });
-            if (attempt === 0 && tempInfo?.isFile()) {
-              await unlink2(tempPath);
-              continue;
-            }
-            throw new MailDeleteError("invalid", "Temp snapshot path is not a plain file; refusing to write through it");
-          }
-        }
-        const written = await readFile4(tempPath, "utf8").catch(() => null);
-        if (written !== content || draftRevision(written ?? "") !== mail.revision.toLowerCase()) {
-          throw new MailDeleteError("changed", "Draft changed while snapshotting; refusing to delete");
-        }
-        await rename2(tempPath, historyPath);
-      }
-      const current = await readFile4(target, "utf8").catch(() => null);
-      if (current === null) {
-        throw new MailDeleteError("missing", "Draft no longer exists");
-      }
-      if (draftRevision(current) !== mail.revision.toLowerCase()) {
-        throw new MailDeleteError("changed", "Draft changed since it was loaded; refusing to delete newer work");
-      }
-      const finalReal = await realpath3(target).catch(() => null);
-      if (finalReal !== expected) {
-        throw new MailDeleteError("invalid", "Draft path changed identity before deletion; refusing to unlink");
-      }
-      await unlink2(target);
-      return "deleted";
-    });
-  } catch (error51) {
-    if (error51 instanceof FlockTimeoutError) {
-      throw new MailDeleteError("changed", "Draft is locked by another process (MailOS or another delete); try again");
-    }
-    throw error51;
-  }
-}
-
-class MailAttachmentError extends Error {
-  outcome;
-  constructor(outcome, message) {
-    super(message);
-    this.name = "MailAttachmentError";
-    this.outcome = outcome;
-  }
-}
-function rewriteFileFrontmatter(frontmatterRaw, remaining, updatedAt) {
-  const lines = frontmatterRaw.split(`
-`);
-  const fileIndex = lines.findIndex((line) => /^file:/.test(line));
-  if (fileIndex < 0)
-    return null;
-  let end = fileIndex + 1;
-  if ((lines[fileIndex] ?? "").trim() === "file:") {
-    while (end < lines.length) {
-      if (!/^\s+- /.test(lines[end] ?? ""))
-        break;
-      end += 1;
-    }
-  }
-  const fileBlock = remaining.length ? ["file:", ...remaining.map((path) => `  - ${JSON.stringify(path)}`)] : ["file: []"];
-  lines.splice(fileIndex, end - fileIndex, ...fileBlock);
-  const updatedIndex = lines.findIndex((line) => /^updated_at:/.test(line));
-  if (updatedIndex >= 0) {
-    lines[updatedIndex] = `updated_at: ${JSON.stringify(updatedAt)}`;
-  }
-  return lines.join(`
-`);
-}
-async function removeDraftAttachmentVerified(mail, mailDir, attachment) {
-  if (!validDraftId(mail.id)) {
-    throw new MailAttachmentError("invalid", "Invalid mail id");
-  }
-  const mailDirReal = await realpath3(resolve7(mailDir));
-  const target = resolve7(mail.filePath);
-  const targetDir = await realpath3(dirname6(target)).catch(() => null);
-  if (targetDir !== mailDirReal) {
-    throw new MailAttachmentError("invalid", "Draft path is outside the mail folder");
-  }
-  const expected = resolve7(mailDirReal, `${mail.id.trim()}.md`);
-  const targetReal = await realpath3(target).catch(() => null);
-  if (targetReal === null) {
-    throw new MailAttachmentError("missing", "Draft no longer exists");
-  }
-  if (targetReal !== expected) {
-    throw new MailAttachmentError("invalid", "Draft path is not a direct file in the mail folder");
-  }
-  if (!/^[a-f0-9]{64}$/i.test(mail.revision)) {
-    throw new MailAttachmentError("invalid", "Invalid draft revision");
-  }
-  const locksDir = resolve7(mailDirReal, ".locks");
-  await ensureRealDirChain(mailDirReal, locksDir);
-  const lockPath = resolve7(locksDir, `${mail.id.trim()}.md.lock`);
-  try {
-    return await withFlock(lockPath, deleteLockTimeoutMs, async () => {
-      const revision = mail.revision.toLowerCase();
-      const content = await readFile4(target, "utf8").catch(() => null);
-      if (content === null) {
-        throw new MailAttachmentError("missing", "Draft no longer exists");
-      }
-      if (draftRevision(content) !== revision) {
-        throw new MailAttachmentError("changed", "Draft changed since it was loaded; refusing to edit");
-      }
-      if (!content.startsWith(`---
-`)) {
-        throw new MailAttachmentError("invalid", "Draft has no frontmatter");
-      }
-      const end = content.indexOf(`
----
-`);
-      if (end < 0) {
-        throw new MailAttachmentError("invalid", "Draft has no frontmatter");
-      }
-      const parsed = parseMailMarkdown(content);
-      if (!parsed.attachments.includes(attachment)) {
-        throw new MailAttachmentError("missing", "Attachment is not linked to this draft");
-      }
-      const remaining = parsed.attachments.filter((path) => path !== attachment);
-      const frontmatterRaw = content.slice(4, end);
-      const newFrontmatter = rewriteFileFrontmatter(frontmatterRaw, remaining, new Date().toISOString());
-      if (newFrontmatter === null) {
-        throw new MailAttachmentError("invalid", "Draft frontmatter has no file list");
-      }
-      const newContent = `---
-${newFrontmatter}
----
-${content.slice(end + `
----
-`.length)}`;
-      const tempPath = resolve7(mailDirReal, `${mail.id.trim()}.md.tmp`);
-      for (let attempt = 0;; attempt += 1) {
-        try {
-          await writeFile2(tempPath, newContent, { flag: "wx", mode: 384 });
-          break;
-        } catch (error51) {
-          if (error51.code !== "EEXIST")
-            throw error51;
-          const tempInfo = await lstat(tempPath).catch(() => {
-            return;
-          });
-          if (attempt === 0 && tempInfo?.isFile()) {
-            await unlink2(tempPath);
-            continue;
-          }
-          throw new MailAttachmentError("invalid", "Temp draft path is not a plain file; refusing to write through it");
-        }
-      }
-      const written = await readFile4(tempPath, "utf8").catch(() => null);
-      if (written !== newContent) {
-        throw new MailAttachmentError("changed", "Draft changed while writing; refusing to save");
-      }
-      const current = await readFile4(target, "utf8").catch(() => null);
-      if (current === null) {
-        throw new MailAttachmentError("missing", "Draft no longer exists");
-      }
-      if (draftRevision(current) !== revision) {
-        throw new MailAttachmentError("changed", "Draft changed since it was loaded; refusing to edit");
-      }
-      await rename2(tempPath, target);
-      return { revision: draftRevision(newContent) };
-    });
-  } catch (error51) {
-    if (error51 instanceof FlockTimeoutError) {
-      throw new MailAttachmentError("changed", "Draft is locked by another process (MailOS or another edit); try again");
-    }
-    throw error51;
-  }
-}
-
-// plugins/mail/src/mailos.ts
-import { execFile as execFileCb } from "node:child_process";
-import { constants as constants3 } from "node:fs";
-import { access, realpath as realpath4 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { delimiter, isAbsolute as isAbsolute5, resolve as resolvePath, sep as sep5 } from "node:path";
-import { promisify } from "node:util";
-var defaultExecFileLike = promisify(execFileCb);
-
-class MailosCommandError extends Error {
-  code;
-  timedOut;
-  aborted;
-  exitCode;
-  constructor(code, message, details = {}) {
-    super(message);
-    this.name = "MailosCommandError";
-    this.code = code;
-    this.timedOut = details.timedOut ?? code === "timeout";
-    this.aborted = details.aborted ?? code === "aborted";
-    this.exitCode = details.exitCode ?? null;
-  }
-}
-function classifyExecError(error51) {
-  if (error51 instanceof MailosCommandError)
-    return error51;
-  if (!(error51 instanceof Error)) {
-    return new MailosCommandError("failed", "MailOS command failed");
-  }
-  if (error51.name === "AbortError") {
-    return new MailosCommandError("aborted", "MailOS command cancelled");
-  }
-  const execError = error51;
-  if (execError.killed) {
-    return new MailosCommandError("timeout", "MailOS command timed out", {
-      timedOut: true,
-      exitCode: typeof execError.code === "number" ? execError.code : null
-    });
-  }
-  return new MailosCommandError("failed", "MailOS command failed to complete", {
-    exitCode: typeof execError.code === "number" ? execError.code : null
-  });
-}
-async function runMailos(execFile, mailosBin, args, options) {
-  if (options.signal?.aborted) {
-    throw new MailosCommandError("aborted", "MailOS command cancelled");
-  }
-  try {
-    return await execFile(mailosBin, args, {
-      cwd: options.cwd,
-      timeout: options.timeoutMs,
-      maxBuffer: options.maxBufferBytes ?? 10 * 1024 * 1024,
-      windowsHide: true,
-      signal: options.signal
-    });
-  } catch (error51) {
-    const classified = classifyExecError(error51);
-    if (options.signal?.aborted && classified.code !== "aborted") {
-      throw new MailosCommandError("aborted", "MailOS command cancelled");
-    }
-    throw classified;
-  }
-}
-
-class MailSendFailure extends Error {
-  reason;
-  constructor(reason, message) {
-    super(message);
-    this.name = "MailSendFailure";
-    this.reason = reason;
-  }
-}
-async function isExecutable(path) {
-  try {
-    await access(path, constants3.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function pathIsWithin(child, parent) {
-  const rel = child.startsWith(parent) ? child.slice(parent.length) : null;
-  if (!rel)
-    return false;
-  return rel === "" || rel.startsWith(sep5);
-}
-async function resolveMailosBinary({
-  cwd
-}) {
-  const preferred = resolvePath(homedir2(), ".local", "bin", "mailos");
-  if (await isExecutable(preferred))
-    return preferred;
-  const pathEnv = process.env.PATH ?? "";
-  for (const dir of pathEnv.split(delimiter)) {
-    const trimmed = dir.trim();
-    if (!trimmed)
-      continue;
-    if (!isAbsolute5(trimmed))
-      continue;
-    const candidate = resolvePath(trimmed, "mailos");
-    if (!isAbsolute5(candidate))
-      continue;
-    if (pathIsWithin(candidate, cwd))
-      continue;
-    if (await isExecutable(candidate))
-      return candidate;
-  }
-  throw new Error("MailOS binary not found. Expected ~/.local/bin/mailos or an absolute PATH entry.");
-}
-var conversationCache = {
-  inFlight: new Map,
-  success: new Map
-};
-var conversationLimits = {
-  maxReferences: 12,
-  perReadTimeoutMs: 60000,
-  totalBudgetMs: 75000,
-  concurrency: 3,
-  successCacheSize: 40,
-  successTtlMs: 60000
-};
-function scopeKey(cwd, id) {
-  return `${cwd}\x00${id}`;
-}
-function parseConversationMarkdown(id, output) {
-  const subject = /^#\s+(.+)$/m.exec(output)?.[1]?.trim() ?? null;
-  const from = /^\*\*From:\*\*\s+(.+?)(?:\s{2,}|$)/m.exec(output)?.[1]?.trim() ?? null;
-  const to = /^\*\*To:\*\*\s+(.+?)(?:\s{2,}|$)/m.exec(output)?.[1]?.trim() ?? null;
-  const date5 = /^\*\*Date:\*\*\s+(.+?)(?:\s{2,}|$)/m.exec(output)?.[1]?.trim() ?? null;
-  const separator = output.indexOf(`
----
-`);
-  const body = (separator >= 0 ? output.slice(separator + 5) : output).trim();
-  return { body, date: date5, from, id, subject, to };
-}
-function requireDraftDir(draftDir) {
-  if (!draftDir || !isAbsolute5(draftDir)) {
-    throw new MailSendFailure("invalid-draft", "A send draft directory (the authorized mailDir) is required");
-  }
-  return draftDir;
-}
-function sameCanonicalDir(left, right) {
-  const canonical = async (value) => realpath4(value).catch(() => resolvePath(value));
-  return Promise.all([canonical(left), canonical(right)]).then(([leftReal, rightReal]) => leftReal === rightReal);
-}
-function mailosGlobalDraftDir() {
-  return resolvePath(homedir2(), ".email", "drafts");
-}
-function createMailosService(options = {}) {
-  const execFile = options.execFile ?? defaultExecFileLike;
-  const mailosBin = options.mailosBin;
-  const globalDraftDir = options.globalDraftDir;
-  async function binary(cwd) {
-    if (mailosBin) {
-      if (!isAbsolute5(mailosBin)) {
-        throw new Error("mailosBin must be an absolute path");
-      }
-      if (pathIsWithin(mailosBin, cwd)) {
-        throw new Error("mailosBin cannot live inside the working folder");
-      }
-      return mailosBin;
-    }
-    return resolveMailosBinary({ cwd });
-  }
-  function normalizeIdentityValue(value) {
-    return value && value !== "(not set)" ? value : null;
-  }
-  async function identity(cwd) {
-    try {
-      const bin = await binary(cwd);
-      const { stdout, stderr } = await runMailos(execFile, bin, ["whoami"], {
-        cwd,
-        timeoutMs: 15000
-      });
-      const output = [stdout, stderr].filter(Boolean).join(`
-`);
-      const from = normalizeIdentityValue(/^Effective From:[ \t]*([^\r\n]+)$/im.exec(output)?.[1]?.trim() ?? null);
-      const name = normalizeIdentityValue(/^From Name:[ \t]*([^\r\n]+)$/im.exec(output)?.[1]?.trim() ?? null);
-      return { from, name, ok: Boolean(from ?? name) };
-    } catch {
-      return { from: null, name: null, ok: false };
-    }
-  }
-  async function signature(folder2, signal) {
-    try {
-      const bin = await binary(folder2);
-      const { stdout } = await runMailos(execFile, bin, ["sig", folder2], {
-        cwd: folder2,
-        timeoutMs: 15000,
-        signal
-      });
-      const output = stdout.trim();
-      if (!output)
-        return null;
-      if (output.includes("(no signature configured)"))
-        return null;
-      if (output.includes("(signature is empty)"))
-        return null;
-      return output;
-    } catch {
-      return null;
-    }
-  }
-  async function readMessage(cwd, id, signal) {
-    const bin = await binary(cwd);
-    const { stdout } = await runMailos(execFile, bin, ["read", id, "--markdown"], {
-      cwd,
-      timeoutMs: conversationLimits.perReadTimeoutMs,
-      signal
-    });
-    return parseConversationMarkdown(id, stdout);
-  }
-  function cachedRead(cwd, id, signal) {
-    const key = scopeKey(cwd, id);
-    const cached2 = conversationCache.success.get(key);
-    if (cached2) {
-      if (Date.now() - cached2.at < conversationLimits.successTtlMs) {
-        return Promise.resolve(cached2.message);
-      }
-      conversationCache.success.delete(key);
-    }
-    let entry = conversationCache.inFlight.get(key);
-    if (!entry) {
-      const controller = new AbortController;
-      const started = readMessage(cwd, id, controller.signal);
-      const created = {
-        promise: started,
-        controller,
-        signals: new Map
-      };
-      entry = created;
-      conversationCache.inFlight.set(key, created);
-      started.then((message) => {
-        const success2 = conversationCache.success;
-        if (success2.size >= conversationLimits.successCacheSize) {
-          success2.delete(success2.keys().next().value);
-        }
-        success2.set(key, { message, at: Date.now() });
-      }).catch(() => {}).finally(() => {
-        conversationCache.inFlight.delete(key);
-        for (const [subscriber, onAbort] of created.signals) {
-          subscriber.removeEventListener("abort", onAbort);
-        }
-      });
-    }
-    const active = entry;
-    if (signal) {
-      const onAbort = () => {
-        active.signals.delete(signal);
-        if (active.signals.size === 0)
-          active.controller.abort();
-      };
-      active.signals.set(signal, onAbort);
-      if (signal.aborted)
-        onAbort();
-      else
-        signal.addEventListener("abort", onAbort, { once: true });
-    }
-    if (!signal)
-      return active.promise;
-    return new Promise((resolveOuter, rejectOuter) => {
-      let settled = false;
-      const settleRace = (value) => {
-        if (settled)
-          return;
-        settled = true;
-        signal.removeEventListener("abort", onCallerAbort);
-        if (value instanceof Error)
-          rejectOuter(value);
-        else
-          resolveOuter(value);
-      };
-      const onCallerAbort = () => settleRace(new MailosCommandError("aborted", "MailOS command cancelled"));
-      active.promise.then((message) => settleRace(message), (error51) => settleRace(error51 instanceof Error ? error51 : new Error(String(error51))));
-      signal.addEventListener("abort", onCallerAbort, { once: true });
-      if (signal.aborted)
-        onCallerAbort();
-    });
-  }
-  async function conversation(cwd, references, signal) {
-    const ids = [
-      ...new Set(references.map((candidate) => candidate.trim()).filter((candidate) => Boolean(candidate) && !/\s/.test(candidate)))
-    ].slice(0, conversationLimits.maxReferences);
-    const items2 = [];
-    const missing = [];
-    if (!ids.length)
-      return { items: items2, missing, outcome: "empty" };
-    const deadline = Date.now() + conversationLimits.totalBudgetMs;
-    let timedOut = false;
-    const queued = ids.map((id) => ({ id, started: false, done: false }));
-    let nextIndex = 0;
-    const worker = async () => {
-      while (nextIndex < queued.length) {
-        const slot = queued[nextIndex];
-        if (!slot)
-          break;
-        nextIndex += 1;
-        slot.started = true;
-        try {
-          const message = await cachedRead(cwd, slot.id, signal);
-          if (!items2.some((item) => item.id === message.id)) {
-            items2.push(message);
-          }
-        } catch (error51) {
-          if (error51 instanceof MailosCommandError) {
-            if (error51.timedOut)
-              timedOut = true;
-            if (error51.aborted)
-              throw error51;
-          }
-          missing.push(slot.id);
-        }
-        if (Date.now() >= deadline) {
-          timedOut = true;
-          break;
-        }
-      }
-    };
-    const workers = Array.from({ length: Math.min(conversationLimits.concurrency, ids.length) }, () => worker());
-    await Promise.all(workers);
-    if (timedOut)
-      return { items: items2, missing, outcome: "timeout" };
-    if (!items2.length && missing.length === ids.length) {
-      return { items: items2, missing, outcome: "not-found" };
-    }
-    if (missing.length > 0)
-      return { items: items2, missing, outcome: "partial" };
-    return { items: items2, missing, outcome: "ok" };
-  }
-  async function sendPreview(cwd, id, options2 = {}) {
-    const draftDir = requireDraftDir(options2.draftDir);
-    const bin = await binary(cwd);
-    const args = ["send", "draft", id, "--draft-dir", draftDir, "--preview"];
-    const { stdout, stderr } = await runMailos(execFile, bin, args, {
-      cwd,
-      timeoutMs: 30000,
-      signal: options2.signal
-    });
-    const output = [stdout, stderr].filter(Boolean).join(`
-`);
-    const revision = /^Revision:\s*([a-f0-9]{64})\s*$/im.exec(output)?.[1];
-    if (!revision) {
-      throw new MailSendFailure("invalid-draft", "MailOS did not return a revision; the draft is not sendable.");
-    }
-    return { dryRun: true, output, revision };
-  }
-  async function confirmSend(cwd, id, revision, options2 = {}) {
-    if (!/^[a-f0-9]{64}$/i.test(revision)) {
-      throw new MailSendFailure("revision-match", "Invalid draft revision");
-    }
-    const draftDir = requireDraftDir(options2.draftDir);
-    const bin = await binary(cwd);
-    const args = [
-      "send",
-      "draft",
-      id,
-      "--draft-dir",
-      draftDir,
-      "--draft-revision",
-      revision,
-      "--delete-after=false"
-    ];
-    const { stdout, stderr } = await runMailos(execFile, bin, args, {
-      cwd,
-      timeoutMs: 60000,
-      signal: options2.signal
-    });
-    const output = [stdout, stderr].filter(Boolean).join(`
-`);
-    if (/\n?\s*❌\s*Draft\s+\S+\s+changed after preview/.test(output)) {
-      throw new MailSendFailure("revision-match", "Draft changed after preview; refresh and preview again before sending");
-    }
-    const contract = validateSendContract(output);
-    if (!contract.ok) {
-      throw new MailSendFailure("contract", contract.reason);
-    }
-    return { dryRun: false, output };
-  }
-  async function archive(cwd, id, options2 = {}) {
-    const draftDir = requireDraftDir(options2.draftDir);
-    if (!await sameCanonicalDir(draftDir, globalDraftDir ?? mailosGlobalDraftDir())) {
-      throw new MailSendFailure("unsupported-draft-dir", "MailOS drafts archive can only address the default ~/.email/drafts folder; this draft lives elsewhere. Delete it or archive it directly with mailos.");
-    }
-    const bin = await binary(cwd);
-    await runMailos(execFile, bin, ["drafts", "archive", id], {
-      cwd,
-      timeoutMs: 30000,
-      signal: options2.signal
-    });
-  }
-  return {
-    identity,
-    signature,
-    conversation,
-    sendPreview,
-    confirmSend,
-    archive
-  };
-}
-function validateSendContract(output) {
-  const markers = /^\s*(❌|⏭️)/m.exec(output);
-  if (markers) {
-    return { ok: false, reason: "MailOS reported a failed or skipped draft" };
-  }
-  if (output.includes("No draft files found to send")) {
-    return { ok: false, reason: "MailOS did not find the draft to send" };
-  }
-  const errors3 = /^\s*❌\s*Errors:\s*(\d+)/m.exec(output);
-  if (errors3?.[1] && Number(errors3[1]) > 0) {
-    return {
-      ok: false,
-      reason: `MailOS reported ${errors3[1]} send error(s)`
-    };
-  }
-  const sent = /^\s*✅\s*(?:Sent|Previewed|Would send):\s*(\d+)/m.exec(output);
-  if (!sent || Number(sent[1]) < 1) {
-    return { ok: false, reason: "MailOS did not confirm the draft was sent" };
-  }
-  return { ok: true };
-}
-
-// plugins/mail/src/node.ts
-import { createHash as createHash5 } from "node:crypto";
-import { realpathSync as realpathSync2 } from "node:fs";
-import { readdir as readdir3, readFile as readFile5 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { isAbsolute as isAbsolute6, relative as relative7, resolve as resolve8, sep as sep6 } from "node:path";
-function defaultMailDir() {
-  return resolve8(homedir3(), ".email/drafts");
-}
-function draftFilePath(mailDir, id) {
-  const trimmed = id.trim();
-  if (!trimmed || trimmed === "." || trimmed === ".." || /[\\/]/.test(trimmed)) {
-    throw new Error("Invalid mail id");
-  }
-  return resolve8(mailDir, `${trimmed}.md`);
-}
-var activeStatuses = new Set(["working", "ready"]);
-function isActiveStatus(status) {
-  return status !== null && activeStatuses.has(status);
-}
-function canonicalDraftPath(path) {
-  try {
-    return realpathSync2(resolve8(path));
-  } catch {
-    return null;
-  }
-}
-function isFolderWithin(root, candidate) {
-  if (!candidate)
-    return false;
-  const anchor = canonicalDraftPath(root);
-  if (anchor === null)
-    return false;
-  const target = canonicalDraftPath(candidate);
-  if (target === null)
-    return false;
-  if (anchor === target)
-    return true;
-  const rel = relative7(anchor, target);
-  if (!rel)
-    return true;
-  if (rel === ".." || rel.startsWith(`..${sep6}`))
-    return false;
-  return !isAbsolute6(rel);
-}
-function sortDateKey(value) {
-  const parsed = value ? Date.parse(value) : Number.NaN;
-  if (Number.isNaN(parsed))
-    return 0;
-  return parsed;
-}
-function sortMail(items2) {
-  items2.sort((a, b) => {
-    const aKey = sortDateKey(a.updatedAt ?? a.createdAt);
-    const bKey = sortDateKey(b.updatedAt ?? b.createdAt);
-    return bKey - aKey;
-  });
-  return items2;
-}
-function draftRevision2(content) {
-  return createHash5("sha256").update(content).digest("hex");
-}
-async function mailFromFile(filePath) {
-  const content = await readFile5(filePath, "utf8").catch(() => null);
-  if (!content)
-    return null;
-  const parsed = parseMailMarkdown(content);
-  if (!parsed.id)
-    return null;
-  if (!isActiveStatus(parsed.status))
-    return null;
-  return {
-    id: parsed.id,
-    status: parsed.status,
-    tags: parsed.tags,
-    folder: parsed.folder,
-    attachments: parsed.attachments,
-    from: parsed.from,
-    inReplyTo: parsed.inReplyTo,
-    references: parsed.references,
-    to: parsed.to,
-    cc: parsed.cc,
-    bcc: parsed.bcc,
-    subject: parsed.subject,
-    createdAt: parsed.createdAt,
-    updatedAt: parsed.updatedAt,
-    noSignature: parsed.noSignature,
-    body: parsed.body,
-    filePath,
-    revision: draftRevision2(content)
-  };
-}
-async function listMailForFolder({
-  mailDir = defaultMailDir(),
-  folder: folder2
-}) {
-  const entries = await readdir3(mailDir, { withFileTypes: true });
-  const items2 = [];
-  for (const entry of entries) {
-    if (!entry.isFile())
-      continue;
-    if (!entry.name.endsWith(".md"))
-      continue;
-    const filePath = resolve8(mailDir, entry.name);
-    const mail = await mailFromFile(filePath);
-    if (!mail)
-      continue;
-    if (!isFolderWithin(folder2, mail.folder))
-      continue;
-    items2.push({
-      id: mail.id,
-      status: mail.status,
-      tags: mail.tags,
-      folder: mail.folder,
-      attachments: mail.attachments,
-      from: mail.from,
-      inReplyTo: mail.inReplyTo,
-      references: mail.references,
-      to: mail.to,
-      cc: mail.cc,
-      bcc: mail.bcc,
-      subject: mail.subject,
-      createdAt: mail.createdAt,
-      updatedAt: mail.updatedAt,
-      noSignature: mail.noSignature,
-      excerpt: mailExcerpt(mail.body),
-      filePath,
-      revision: mail.revision
-    });
-  }
-  return sortMail(items2);
-}
-async function readMailById(id, mailDir = defaultMailDir()) {
-  return mailFromFile(draftFilePath(mailDir, id));
-}
-
-// plugins/mail/src/api.ts
-var defaultMailos = createMailosService();
-function defaultPreviewer(mailos) {
-  return async ({ mail }) => ({
-    body: mail.body,
-    signature: mail.noSignature ? null : mail.folder ? await mailos.signature(mail.folder) : null
-  });
-}
-function mailDirOption(mailDir) {
-  return mailDir ?? defaultMailDir();
-}
-function requireString(value, name) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw apiError("bad-request", `Missing ${name} parameter`);
-  }
-  return value.trim();
-}
-function requireRevision(value) {
-  const revision = requireString(value, "revision");
-  if (!/^[a-f0-9]{64}$/i.test(revision)) {
-    throw apiError("bad-request", "Invalid revision parameter");
-  }
-  return revision.toLowerCase();
-}
-async function authorizedMail(context, id, pathValue) {
-  const trimmed = id.trim();
-  if (!trimmed)
-    throw apiError("bad-request", "Missing id parameter");
-  const folder2 = context.authorizeFolder(pathValue);
-  const mail = await readMailById(trimmed, mailDirOption(context.mailDir));
-  if (!mail)
-    throw apiError("not-found", "Mail not found");
-  if (!mail.folder)
-    throw apiError("not-found", "Mail has no folder");
-  if (!isFolderWithin(folder2, mail.folder)) {
-    throw apiError("not-found", "Mail not found for this folder");
-  }
-  return { folder: folder2, mail: { ...mail, folder: mail.folder } };
-}
-var listMail = async ({ context, query, response }) => {
-  const folder2 = context.authorizeFolder(query.get("path"));
-  const items2 = await listMailForFolder({
-    folder: folder2,
-    mailDir: mailDirOption(context.mailDir)
-  });
-  jsonResponse(response, 200, { folder: folder2, items: items2 });
-};
-var readItem = async ({ context, query, response }) => {
-  const id = requireString(query.get("id"), "id");
-  const { folder: folder2, mail } = await authorizedMail(context, id, query.get("path"));
-  context.watch(folder2);
-  let preview;
-  try {
-    const previewer = context.mailPreviewer ?? defaultPreviewer(context.mailos ?? defaultMailos);
-    preview = await previewer({ id, folder: folder2, mail });
-  } catch (error51) {
-    const detail = error51 instanceof Error ? error51.message : "Unknown preview error";
-    throw apiError("internal", `Mail preview failed: ${detail}`);
-  }
-  jsonResponse(response, 200, { mail, preview });
-};
-var resolveSender = async ({ context, query, response }) => {
-  const id = requireString(query.get("id"), "id");
-  const { mail } = await authorizedMail(context, id, query.get("path"));
-  const mailos = context.mailos ?? defaultMailos;
-  const identity = await mailos.identity(mail.folder);
-  jsonResponse(response, 200, identity);
-};
-var readConversation = async ({
-  context,
-  query,
-  response,
-  signal
-}) => {
-  const id = requireString(query.get("id"), "id");
-  const { mail } = await authorizedMail(context, id, query.get("path"));
-  const mailos = context.mailos ?? defaultMailos;
-  const references = [...mail.references, mail.inReplyTo].filter((reference) => Boolean(reference));
-  const result = await mailos.conversation(mail.folder, references, signal);
-  jsonResponse(response, 200, result);
-};
-function commandFailureError(error51) {
-  if (error51.timedOut || error51.code === "timeout") {
-    throw apiError("timeout", "MailOS command timed out");
-  }
-  if (error51.code === "aborted")
-    throw error51;
-  throw apiError("failed", "MailOS command failed");
-}
-function sendFailureError(error51) {
-  switch (error51.reason) {
-    case "revision-match":
-      return apiError("conflict", error51.message);
-    case "invalid-draft":
-      return apiError("bad-request", error51.message);
-    case "unsupported-draft-dir":
-      return apiError("bad-request", error51.message);
-    default:
-      return apiError("failed", error51.message);
-  }
-}
-var runAction = async ({ body, context, response, signal }) => {
-  const parsed = parseJsonBody(body);
-  const action = requireString(parsed.action, "action");
-  const id = requireString(parsed.id, "id");
-  const revision = requireRevision(parsed.revision);
-  if (action !== "archive" && action !== "delete" && action !== "remove-attachment") {
-    throw apiError("bad-request", "Invalid action parameter");
-  }
-  const { mail } = await authorizedMail(context, id, pathFromParsed(parsed));
-  if (mail.revision !== revision) {
-    throw apiError("conflict", "Draft changed since it was loaded");
-  }
-  const mailos = context.mailos ?? defaultMailos;
-  if (action === "remove-attachment") {
-    const attachment = requireString(parsed.attachment, "attachment");
-    try {
-      await removeDraftAttachmentVerified(mail, mailDirOption(context.mailDir), attachment);
-    } catch (error51) {
-      if (error51 instanceof MailAttachmentError) {
-        switch (error51.outcome) {
-          case "missing":
-            throw apiError("not-found", error51.message);
-          case "invalid":
-            throw apiError("bad-request", error51.message);
-          case "changed":
-            throw apiError("conflict", error51.message);
-        }
-      }
-      throw error51;
-    }
-  } else if (action === "delete") {
-    try {
-      await deleteLocalDraftVerified(mail, mailDirOption(context.mailDir));
-    } catch (error51) {
-      if (error51 instanceof MailDeleteError) {
-        switch (error51.outcome) {
-          case "missing":
-            throw apiError("not-found", error51.message);
-          case "invalid":
-            throw apiError("bad-request", error51.message);
-          case "changed":
-            throw apiError("conflict", error51.message);
-        }
-      }
-      throw error51;
-    }
-  } else {
-    try {
-      await mailos.archive(mail.folder, mail.id, {
-        draftDir: mailDirOption(context.mailDir),
-        signal
-      });
-    } catch (error51) {
-      if (error51 instanceof MailSendFailure)
-        throw sendFailureError(error51);
-      if (error51 instanceof MailosCommandError)
-        commandFailureError(error51);
-      throw error51;
-    }
-  }
-  jsonResponse(response, 200, { action, id: mail.id, ok: true });
-};
-var runSend = async ({ body, context, response, signal }) => {
-  const parsed = parseJsonBody(body);
-  const id = requireString(parsed.id, "id");
-  const dryRun = parsed.dryRun === true;
-  const { mail } = await authorizedMail(context, id, pathFromParsed(parsed));
-  const mailos = context.mailos ?? defaultMailos;
-  if (dryRun) {
-    const preview = await mailos.sendPreview(mail.folder, mail.id, {
-      draftDir: mailDirOption(context.mailDir),
-      signal
-    }).catch((error51) => {
-      if (error51 instanceof MailSendFailure)
-        throw sendFailureError(error51);
-      if (error51 instanceof MailosCommandError)
-        commandFailureError(error51);
-      throw error51;
-    });
-    jsonResponse(response, 200, preview);
-    return;
-  }
-  const revision = requireRevision(parsed.revision);
-  if (mail.revision !== revision) {
-    throw apiError("conflict", "Draft changed since it was loaded");
-  }
-  const result = await mailos.confirmSend(mail.folder, mail.id, revision, {
-    draftDir: mailDirOption(context.mailDir),
-    signal
-  }).catch((error51) => {
-    if (error51 instanceof MailSendFailure)
-      throw sendFailureError(error51);
-    if (error51 instanceof MailosCommandError)
-      commandFailureError(error51);
-    throw error51;
-  });
-  jsonResponse(response, 200, result);
-};
-function pathFromParsed(parsed) {
-  return typeof parsed.path === "string" && parsed.path ? parsed.path : null;
-}
-async function handleMailApiRoutes(request, response, context) {
-  const url2 = new URL(request.url ?? "/", "http://127.0.0.1");
-  const specByPath = {
-    "/api/mail": { method: "GET", handle: listMail },
-    "/api/mail/item": { method: "GET", handle: readItem },
-    "/api/mail/from": { method: "GET", handle: resolveSender },
-    "/api/mail/conversation": {
-      method: "GET",
-      timeoutMs: 75000,
-      handle: readConversation
-    },
-    "/api/mail/action": {
-      method: "POST",
-      maxBodyBytes: 16 * 1024,
-      timeoutMs: 60000,
-      handle: runAction
-    },
-    "/api/mail/send": {
-      method: "POST",
-      maxBodyBytes: 16 * 1024,
-      timeoutMs: 90000,
-      handle: runSend
-    }
-  };
-  const spec = specByPath[url2.pathname];
-  if (!spec)
-    return false;
-  await runApiRoute(request, response, url2, spec, context);
-  return true;
-}
-
-// plugins/tasks/src/api.ts
-import { readdir as readdir4, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname7, resolve as resolve9 } from "node:path";
-
-// packages/folder-plugin/src/validation.ts
-function parseJsonSource(source, validate) {
-  let value;
-  try {
-    value = JSON.parse(source);
-  } catch (error51) {
-    const detail = error51 instanceof Error && error51.message ? error51.message : "could not be parsed";
-    return {
-      ok: false,
-      issues: [{ path: "#", message: `not valid JSON: ${detail}` }]
-    };
-  }
-  const issues = validate(value);
-  if (issues.length > 0)
-    return { ok: false, issues };
-  return { ok: true, document: value };
-}
-function issueSummary(issues, file3 = "content file") {
-  const first = issues[0];
-  if (!first)
-    return `${file3} is valid`;
-  const label = first.path && first.path !== "#" ? first.path : file3;
-  if (issues.length === 1)
-    return `${label}: ${first.message}`;
-  return `${issues.length} problems found in ${file3} (first: ${label} — ${first.message})`;
-}
-
-// plugins/tasks/src/data/parse.ts
-var TASK_TYPES = [
-  "task",
-  "bug",
-  "feature",
-  "chore",
-  "spike",
-  "epic",
-  "milestone"
-];
-var TASK_STATUSES = [
-  "todo",
-  "in_progress",
-  "blocked",
-  "review",
-  "done",
-  "canceled"
-];
-var LINK_PROVIDERS = ["github", "linear", "jira", "web"];
-var LINK_KINDS = [
-  "issue",
-  "pull_request",
-  "commit",
-  "repository",
-  "project",
-  "document",
-  "design",
-  "discussion",
-  "external"
-];
-var LINK_RELATIONS = [
-  "references",
-  "implemented_by",
-  "fixes",
-  "reported_by",
-  "spec",
-  "design",
-  "review",
-  "deployment",
-  "blocked_by"
-];
-var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function nonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function todoIssueSummary(issues) {
-  return issueSummary(issues, "todo.json");
-}
-function validateTodoFile(value) {
-  if (!isRecord(value)) {
-    return [{ path: "#", message: "todo.json must contain a JSON object" }];
-  }
-  const issues = [];
-  if (value.version !== undefined && value.version !== 1 && value.version !== 2) {
-    issues.push({
-      path: "version",
-      message: `must be 1 or 2; got ${JSON.stringify(value.version)}`
-    });
-  }
-  if (value.$schema !== undefined && !nonEmptyString(value.$schema)) {
-    issues.push({ path: "$schema", message: "must be a non-empty string" });
-  }
-  if (value.id !== undefined && !nonEmptyString(value.id)) {
-    issues.push({ path: "id", message: "must be a non-empty string" });
-  }
-  if (value.title !== undefined && !nonEmptyString(value.title)) {
-    issues.push({ path: "title", message: "must be a non-empty string" });
-  }
-  if (!Array.isArray(value.tasks)) {
-    issues.push({ path: "tasks", message: "must be an array of tasks" });
-    return issues;
-  }
-  const ids = new Set;
-  const keys = new Set;
-  value.tasks.forEach((task, index) => {
-    validateTask(task, `tasks[${index}]`, issues, ids, keys);
-  });
-  value.tasks.forEach((task, index) => {
-    if (!isRecord(task) || !Array.isArray(task.relations))
-      return;
-    task.relations.forEach((relation, relIndex) => {
-      if (!isRecord(relation))
-        return;
-      const target = relation.targetTaskId;
-      if (typeof target === "string" && !ids.has(target)) {
-        issues.push({
-          path: `tasks[${index}].relations[${relIndex}].targetTaskId`,
-          message: `references unknown task id ${JSON.stringify(target)}`
-        });
-      }
-    });
-  });
-  return issues;
-}
-function validateTask(task, path, issues, ids, keys) {
-  if (!isRecord(task)) {
-    issues.push({ path, message: "must be a task object" });
-    return;
-  }
-  if (!nonEmptyString(task.name)) {
-    issues.push({
-      path: `${path}.name`,
-      message: "required; a task needs a non-empty name"
-    });
-  }
-  if (task.id !== undefined) {
-    if (!nonEmptyString(task.id)) {
-      issues.push({ path: `${path}.id`, message: "must be a non-empty string" });
-    } else if (ids.has(task.id)) {
-      issues.push({
-        path: `${path}.id`,
-        message: `duplicate task id ${JSON.stringify(task.id)}`
-      });
-    } else {
-      ids.add(task.id);
-    }
-  }
-  if (task.key !== undefined) {
-    if (!nonEmptyString(task.key)) {
-      issues.push({
-        path: `${path}.key`,
-        message: "must be a non-empty string"
-      });
-    } else if (keys.has(task.key)) {
-      issues.push({
-        path: `${path}.key`,
-        message: `duplicate task key ${JSON.stringify(task.key)}`
-      });
-    } else {
-      keys.add(task.key);
-    }
-  }
-  if (task.type !== undefined && !inEnum(task.type, TASK_TYPES)) {
-    issues.push({
-      path: `${path}.type`,
-      message: `must be one of ${TASK_TYPES.join(", ")}; got ${JSON.stringify(task.type)}`
-    });
-  }
-  if (task.status !== undefined && !inEnum(task.status, TASK_STATUSES)) {
-    issues.push({
-      path: `${path}.status`,
-      message: `must be one of ${TASK_STATUSES.join(", ")}; got ${JSON.stringify(task.status)}`
-    });
-  }
-  if (task.done !== undefined && typeof task.done !== "boolean") {
-    issues.push({ path: `${path}.done`, message: "must be a boolean" });
-  }
-  if (task.priority !== undefined && task.priority !== null) {
-    const priority = task.priority;
-    if (typeof priority !== "number" || !Number.isInteger(priority) || priority < 1 || priority > 5) {
-      issues.push({
-        path: `${path}.priority`,
-        message: "must be an integer between 1 and 5"
-      });
-    }
-  }
-  if (task.deadline !== undefined && task.deadline !== null && (typeof task.deadline !== "string" || !DATE_PATTERN.test(task.deadline))) {
-    issues.push({
-      path: `${path}.deadline`,
-      message: "must be an ISO date (YYYY-MM-DD)"
-    });
-  }
-  for (const section of ["acceptanceCriteria", "steps"]) {
-    const items2 = task[section];
-    if (items2 === undefined)
-      continue;
-    if (!Array.isArray(items2)) {
-      issues.push({
-        path: `${path}.${section}`,
-        message: "must be an array of check items"
-      });
-      continue;
-    }
-    items2.forEach((item, index) => {
-      validateCheckItem(item, `${path}.${section}[${index}]`, issues);
-    });
-  }
-  if (task.links !== undefined) {
-    if (!Array.isArray(task.links)) {
-      issues.push({
-        path: `${path}.links`,
-        message: "must be an array of links"
-      });
-    } else {
-      task.links.forEach((link, index) => {
-        validateLink(link, `${path}.links[${index}]`, issues);
-      });
-    }
-  }
-  if (task.notes !== undefined) {
-    if (!Array.isArray(task.notes)) {
-      issues.push({
-        path: `${path}.notes`,
-        message: "must be an array of note references"
-      });
-    } else {
-      task.notes.forEach((note, index) => {
-        validateNoteRef(note, `${path}.notes[${index}]`, issues);
-      });
-    }
-  }
-}
-var UNSAFE_NOTE_REFERENCE = /^(?:\/|\\\\|[a-z][a-z0-9+.-]*:|~)/i;
-function validateNoteRef(note, path, issues) {
-  if (!nonEmptyString(note)) {
-    issues.push({ path, message: "must be a non-empty string" });
-    return;
-  }
-  if (/^https?:\/\//i.test(note)) {
-    let url2;
-    try {
-      url2 = new URL(note);
-    } catch {
-      issues.push({ path, message: "is not a valid absolute URL" });
-      return;
-    }
-    if (url2.username || url2.password) {
-      issues.push({ path, message: "must not contain embedded credentials" });
-      return;
-    }
-    const isLocalhost = url2.hostname === "localhost" || url2.hostname === "127.0.0.1" || url2.hostname === "::1";
-    if (url2.protocol !== "https:" && !(url2.protocol === "http:" && isLocalhost)) {
-      issues.push({
-        path,
-        message: "must use https, except localhost development links"
-      });
-    }
-    return;
-  }
-  if (UNSAFE_NOTE_REFERENCE.test(note) || note.split(/[\\/]/).includes("..")) {
-    issues.push({
-      path,
-      message: "must be a folder-relative path (or an https URL)"
-    });
-  }
-}
-function validateCheckItem(item, path, issues) {
-  if (!isRecord(item)) {
-    issues.push({
-      path,
-      message: "must be an object with id, text and done"
-    });
-    return;
-  }
-  if (!nonEmptyString(item.id)) {
-    issues.push({ path: `${path}.id`, message: "required non-empty string" });
-  }
-  if (!nonEmptyString(item.text)) {
-    issues.push({ path: `${path}.text`, message: "required non-empty string" });
-  }
-  if (typeof item.done !== "boolean") {
-    issues.push({ path: `${path}.done`, message: "required boolean" });
-  }
-}
-function validateLink(link, path, issues) {
-  if (!isRecord(link)) {
-    issues.push({ path, message: "must be a link object" });
-    return;
-  }
-  for (const field of ["id", "provider", "kind", "relation", "url"]) {
-    if (!nonEmptyString(link[field])) {
-      issues.push({
-        path: `${path}.${field}`,
-        message: "required non-empty string"
-      });
-    }
-  }
-  if (link.provider !== undefined && !inEnum(link.provider, LINK_PROVIDERS)) {
-    issues.push({
-      path: `${path}.provider`,
-      message: `must be one of ${LINK_PROVIDERS.join(", ")}; got ${JSON.stringify(link.provider)}`
-    });
-  }
-  if (link.kind !== undefined && !inEnum(link.kind, LINK_KINDS)) {
-    issues.push({
-      path: `${path}.kind`,
-      message: `must be one of ${LINK_KINDS.join(", ")}; got ${JSON.stringify(link.kind)}`
-    });
-  }
-  if (link.relation !== undefined && !inEnum(link.relation, LINK_RELATIONS)) {
-    issues.push({
-      path: `${path}.relation`,
-      message: `must be one of ${LINK_RELATIONS.join(", ")}; got ${JSON.stringify(link.relation)}`
-    });
-  }
-  const urlValue = link.url;
-  if (typeof urlValue === "string") {
-    let url2;
-    try {
-      url2 = new URL(urlValue);
-    } catch {
-      issues.push({
-        path: `${path}.url`,
-        message: "is not a valid absolute URL"
-      });
-      return;
-    }
-    if (url2.username || url2.password) {
-      issues.push({
-        path: `${path}.url`,
-        message: "must not contain embedded credentials"
-      });
-    }
-    const isLocalhost = url2.hostname === "localhost" || url2.hostname === "127.0.0.1" || url2.hostname === "::1";
-    if (url2.protocol !== "https:" && !(url2.protocol === "http:" && isLocalhost)) {
-      issues.push({
-        path: `${path}.url`,
-        message: "must use https, except localhost development links"
-      });
-    }
-    if (link.provider === "github" && url2.hostname !== "github.com") {
-      issues.push({
-        path: `${path}.url`,
-        message: "github links must use github.com"
-      });
-    }
-    if (link.provider === "linear" && url2.hostname !== "linear.app" && !url2.hostname.endsWith(".linear.app")) {
-      issues.push({
-        path: `${path}.url`,
-        message: "linear links must use linear.app"
-      });
-    }
-    if (link.provider === "jira" && !url2.hostname.endsWith(".atlassian.net") && url2.hostname !== "jira.atlassian.com") {
-      issues.push({
-        path: `${path}.url`,
-        message: "jira links must use an Atlassian Jira host"
-      });
-    }
-  }
-}
-function inEnum(value, allowed) {
-  return allowed.includes(String(value));
-}
-function todoFileWarnings(value) {
-  if (!isRecord(value) || !Array.isArray(value.tasks))
-    return [];
-  return value.tasks.flatMap((task, index) => isRecord(task) && Array.isArray(task.notes) && task.notes.some((note) => nonEmptyString(note)) ? [] : [
-    {
-      message: "no notes; link the accompanying note file or https reference",
-      path: `tasks[${index}].notes`,
-      severity: "warning"
-    }
-  ]);
-}
-function parseTodoSource(source) {
-  return parseJsonSource(source, validateTodoFile);
-}
-function starterTodoSource(folder2) {
-  const title = folder2.trim().split(/[\\/]/).filter(Boolean).at(-1) ?? "Tasks";
-  return `${JSON.stringify({
-    $schema: "https://raggle.co/schemas/tasks.json",
-    version: 2,
-    id: "todo",
-    title,
-    people: [],
-    projects: [],
-    cycles: [],
-    milestones: [],
-    components: [],
-    areas: [],
-    integrations: [],
-    customFields: [],
-    automations: [],
-    tasks: [
-      {
-        id: "todo:0",
-        key: "TODO-1",
-        index: 0,
-        rank: "0001",
-        name: "First task",
-        description: "Describe what needs to happen.",
-        type: "task",
-        status: "todo",
-        done: false,
-        priority: 3,
-        deadline: null,
-        assigneeIds: [],
-        acceptanceCriteria: [
-          { id: "ac-1", text: "Acceptance check", done: false }
-        ]
-      }
-    ]
-  }, null, 2)}
-`;
-}
-
-// packages/folder-plugin/src/client.ts
-function folderPathId(path) {
-  const bytes = new TextEncoder().encode(path);
-  let binary = "";
-  for (const byte of bytes)
-    binary += String.fromCharCode(byte);
-  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
-}
-
-// plugins/tasks/src/data/task-id.ts
-var QUALIFIER = "@";
-var REF_PATTERN = /^[A-Za-z0-9_-]+$/;
-function parseQualifiedTaskId(value) {
-  const at = value.indexOf(QUALIFIER);
-  if (at < 1)
-    return;
-  const ref = value.slice(0, at);
-  const id = value.slice(at + 1);
-  if (!id || !REF_PATTERN.test(ref))
-    return;
-  return { id, ref };
-}
-function refMatchesFolder(ref, sourceFolder) {
-  return typeof sourceFolder === "string" && folderPathId(sourceFolder) === ref;
-}
-
-// plugins/tasks/src/api.ts
-var TASKS_FILE = "todo.json";
-function requireString2(value, name) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw apiError("bad-request", `Missing ${name} parameter`);
-  }
-  return value.trim();
-}
-function serializeTodoSource(document3, original) {
-  const indent = /^\{[\s\S]*?\n([ \t]+)"/m.exec(original)?.[1] ?? "  ";
-  const trailing = original.endsWith(`
-`) ? `
-` : "";
-  return `${JSON.stringify(document3, null, indent)}${trailing}`;
-}
-function toggleTaskSource(source, id) {
-  const parsed = parseTodoSource(source);
-  if (!parsed.ok) {
-    throw apiError("bad-request", todoIssueSummary(parsed.issues));
-  }
-  const tasks = Array.isArray(parsed.document.tasks) ? parsed.document.tasks : [];
-  const task = tasks.find((item) => item.id === id || item.key === id);
-  if (!task)
-    throw apiError("not-found", `Task not found: ${id}`);
-  const wasDone = task.done === true || task.status === "done";
-  const done = !wasDone;
-  const now = new Date().toISOString();
-  if (done) {
-    task.done = true;
-    task.status = "done";
-    task.resolution = "completed";
-    task.completedAt = now;
-  } else {
-    task.done = false;
-    task.status = "todo";
-    task.resolution = null;
-    task.completedAt = null;
-  }
-  task.updatedAt = now;
-  return { done, next: serializeTodoSource(parsed.document, source) };
-}
-async function findTaskSource(folder2, id) {
-  const search = async (paths2, target) => {
-    for (const path of paths2) {
-      const source = await readFile6(path, "utf8");
-      const parsed = parseTodoSource(source);
-      if (!parsed.ok)
-        continue;
-      const tasks = Array.isArray(parsed.document.tasks) ? parsed.document.tasks : [];
-      if (tasks.some((task) => task.id === target || task.key === target)) {
-        return { path, source };
-      }
-    }
-    return;
-  };
-  const visit = async (current) => {
-    const entries = await readdir4(current, { withFileTypes: true }).catch(() => []);
-    const paths2 = [];
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name === TASKS_FILE) {
-        paths2.push(resolve9(current, entry.name));
-        continue;
-      }
-      if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules")
-        continue;
-      paths2.push(...await visit(resolve9(current, entry.name)));
-    }
-    return paths2;
-  };
-  const paths = (await visit(folder2)).sort((left, right) => left.localeCompare(right));
-  const qualified = parseQualifiedTaskId(id);
-  if (qualified) {
-    const owned = paths.filter((path) => refMatchesFolder(qualified.ref, dirname7(path)));
-    if (owned.length > 0) {
-      return await search(owned, qualified.id);
-    }
-  }
-  return await search(paths, qualified?.id ?? id);
-}
-var toggleTask = async ({ body, context, response }) => {
-  if (context.readOnly) {
-    throw apiError("forbidden", "Task updates are disabled for remote access");
-  }
-  const parsed = parseJsonBody(body);
-  const id = requireString2(parsed.id, "id");
-  const folder2 = context.authorizeFolder(typeof parsed.path === "string" && parsed.path ? parsed.path : null);
-  const found = await findTaskSource(folder2, id);
-  if (!found)
-    throw apiError("not-found", `Task not found: ${id}`);
-  const target = parseQualifiedTaskId(id)?.id ?? id;
-  const { done, next } = toggleTaskSource(found.source, target);
-  await writeFile3(found.path, next, "utf8");
-  context.watch(folder2);
-  jsonResponse(response, 200, { done, folder: folder2, id, ok: true });
-};
-var specByPath = {
-  "/api/tasks/toggle": {
-    method: "POST",
-    maxBodyBytes: 16 * 1024,
-    timeoutMs: 30000,
-    handle: toggleTask
-  }
-};
-async function handleTasksApiRoutes(request, response, context) {
-  const url2 = new URL(request.url ?? "/", "http://127.0.0.1");
-  const spec = specByPath[url2.pathname];
-  if (!spec)
-    return false;
-  await runApiRoute(request, response, url2, spec, context);
-  return true;
-}
-
 // packages/session-finding/src/index.ts
 var import_local = __toESM(require_dist4(), 1);
 var import_sessions = __toESM(require_sessions(), 1);
@@ -86657,17 +84844,17 @@ function createSessionFinding(deps2) {
 var { listFolderSessions, readSessionTranscript } = createSessionFinding(deps);
 
 // packages/api/src/server/entity-folder.ts
-var import_yaml4 = __toESM(require_dist(), 1);
-import { readdir as readdir5, readFile as readFile7, realpath as realpath5, stat as stat3 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
+var import_yaml3 = __toESM(require_dist(), 1);
+import { readdir as readdir3, readFile as readFile4, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
 import {
   basename as basename4,
-  dirname as dirname8,
+  dirname as dirname5,
   extname as extname2,
-  isAbsolute as isAbsolute7,
+  isAbsolute as isAbsolute4,
   join as join2,
-  relative as relative8,
-  resolve as resolve10
+  relative as relative6,
+  resolve as resolve6
 } from "node:path";
 var CONFIG_FILE = join2("kennel", "config.json");
 var IGNORED_DIRECTORIES = new Set([
@@ -86685,7 +84872,7 @@ function parseMarkdown(source) {
 ---`, 4);
   if (end === -1)
     return { body: source.trim(), frontmatter: {} };
-  const document3 = import_yaml4.default.parseDocument(source.slice(4, end));
+  const document3 = import_yaml3.default.parseDocument(source.slice(4, end));
   const value = document3.errors.length === 0 ? document3.toJS() : {};
   return {
     body: source.slice(end + 4).trim(),
@@ -86710,11 +84897,11 @@ function paragraph(body) {
 }
 function configPath() {
   const xdg = process.env.XDG_CONFIG_HOME?.trim();
-  return xdg ? join2(xdg, CONFIG_FILE) : join2(homedir4(), ".config", CONFIG_FILE);
+  return xdg ? join2(xdg, CONFIG_FILE) : join2(homedir2(), ".config", CONFIG_FILE);
 }
 async function readConfig(path) {
   try {
-    return parseConfig(await readFile7(path, "utf8"));
+    return parseConfig(await readFile4(path, "utf8"));
   } catch (error51) {
     if (error51 && typeof error51 === "object" && "code" in error51 && error51.code === "ENOENT")
       return null;
@@ -86734,7 +84921,7 @@ function parseConfig(source) {
   if (!Array.isArray(roots))
     throw new Error("Invalid Kennel entity root config");
   const allowedRoots = roots.map((root) => {
-    if (typeof root !== "string" || !root.trim() || !isAbsolute7(root))
+    if (typeof root !== "string" || !root.trim() || !isAbsolute4(root))
       throw new Error("Invalid Kennel entity root config");
     return root.trim();
   });
@@ -86747,21 +84934,21 @@ async function allowedRoots(currentWorkspaceRoot) {
   return currentWorkspaceRoot?.trim() ? [currentWorkspaceRoot] : [];
 }
 function inside4(root, path) {
-  const local = relative8(root, path);
-  return local === "" || !local.startsWith("..") && !isAbsolute7(local);
+  const local = relative6(root, path);
+  return local === "" || !local.startsWith("..") && !isAbsolute4(local);
 }
 async function normalizeRoot(rootPath, currentWorkspaceRoot) {
   const trimmed = rootPath?.trim();
   const fallback = currentWorkspaceRoot?.trim();
   if (!trimmed && !fallback)
     return null;
-  const requested = resolve10(trimmed || fallback);
-  const resolved = await realpath5(requested);
+  const requested = resolve6(trimmed || fallback);
+  const resolved = await realpath3(requested);
   const info = await stat3(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) => realpath5(root)));
+  const realAllowedRoots = await Promise.all(roots.map((root) => realpath3(root)));
   const allowed = realAllowedRoots.some((root) => inside4(root, resolved));
   if (!allowed)
     throw new Error("Entity root is outside the configured roots");
@@ -86770,7 +84957,7 @@ async function normalizeRoot(rootPath, currentWorkspaceRoot) {
 async function markdownFiles(folderPath) {
   const files = [];
   async function walk(currentPath) {
-    const entries = await readdir5(currentPath, { withFileTypes: true });
+    const entries = await readdir3(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;
@@ -86801,24 +84988,24 @@ async function schemaPath(folderPath, rootPath) {
     }
     if (current === rootPath)
       return null;
-    current = dirname8(current);
+    current = dirname5(current);
   }
   return null;
 }
 async function readEntity(folderPath, rootPath) {
   const indexPath = join2(folderPath, "index.md");
-  const index = parseMarkdown(await readFile7(indexPath, "utf8"));
+  const index = parseMarkdown(await readFile4(indexPath, "utf8"));
   const files = await markdownFiles(folderPath);
   const documents = await Promise.all(files.map(async (filePath) => {
-    const document3 = parseMarkdown(await readFile7(filePath, "utf8"));
+    const document3 = parseMarkdown(await readFile4(filePath, "utf8"));
     return {
       content: document3.body,
-      path: relative8(folderPath, filePath),
+      path: relative6(folderPath, filePath),
       title: stringValue(document3.frontmatter.title) ?? heading(document3.body) ?? basename4(filePath, extname2(filePath))
     };
   }));
   const title = stringValue(index.frontmatter.title) ?? heading(index.body) ?? basename4(folderPath);
-  const relativePath = relative8(rootPath, folderPath) || ".";
+  const relativePath = relative6(rootPath, folderPath) || ".";
   return {
     aliases: stringValues(index.frontmatter.aliases),
     content: [
@@ -86846,7 +85033,7 @@ async function discover(rootPath) {
   async function walk(folderPath) {
     if (await hasIndex(folderPath))
       folders.push(folderPath);
-    const entries = await readdir5(folderPath, { withFileTypes: true });
+    const entries = await readdir3(folderPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".") || IGNORED_DIRECTORIES.has(entry.name))
         continue;
@@ -86890,20 +85077,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 readFile8,
-  realpath as realpath6,
-  rename as rename3,
+  readFile as readFile5,
+  realpath as realpath4,
+  rename as rename2,
   stat as stat4,
-  unlink as unlink3,
-  writeFile as writeFile4
+  unlink as unlink2,
+  writeFile as writeFile2
 } from "node:fs/promises";
 import {
-  dirname as dirname9,
+  dirname as dirname6,
   extname as extname3,
-  isAbsolute as isAbsolute8,
-  relative as relative9,
-  resolve as resolve11,
-  sep as sep7
+  isAbsolute as isAbsolute5,
+  relative as relative7,
+  resolve as resolve7,
+  sep as sep4
 } from "node:path";
 
 // packages/api/src/shared/selection.ts
@@ -86921,10 +85108,10 @@ async function editDocument(folder2, 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 realpath6(folder2);
-  const target = await realpath6(resolve11(root, path));
-  const local = relative9(root, target);
-  if (!local || local === ".." || local.startsWith(`..${sep7}`) || isAbsolute8(local))
+  const root = await realpath4(folder2);
+  const target = await realpath4(resolve7(root, path));
+  const local = relative7(root, target);
+  if (!local || local === ".." || local.startsWith(`..${sep4}`) || isAbsolute5(local))
     throw apiError("forbidden", "The document must be inside its folder.");
   let content;
   try {
@@ -86937,19 +85124,19 @@ async function editDocument(folder2, input) {
     const details = await stat4(target);
     if (!details.isFile() || details.nlink !== 1)
       throw apiError("forbidden", "Only regular, unlinked files can be edited.");
-    if (await readFile8(target, "utf8") !== original)
+    if (await readFile5(target, "utf8") !== original)
       throw apiError("conflict", "This note changed on disk. Close this preview, reload the note, and try again.");
-    const temporary = resolve11(dirname9(target), `.kennel-edit-${randomUUID2()}.tmp`);
+    const temporary = resolve7(dirname6(target), `.kennel-edit-${randomUUID2()}.tmp`);
     try {
-      await writeFile4(temporary, content, {
+      await writeFile2(temporary, content, {
         flag: "wx",
         mode: details.mode & 511
       });
-      if (await readFile8(target, "utf8") !== original)
+      if (await readFile5(target, "utf8") !== original)
         throw apiError("conflict", "This note changed on disk. Reload before applying an edit.");
-      await rename3(temporary, target);
+      await rename2(temporary, target);
     } finally {
-      await unlink3(temporary).catch(() => {});
+      await unlink2(temporary).catch(() => {});
     }
     return content;
   });
@@ -86970,7 +85157,7 @@ var documentEditRoute = {
       throw apiError("bad-request", "Invalid document edit.");
     const input = parsed.data;
     const folder2 = context.authorize(input.folder);
-    if (context.lockedFile && (typeof input.path !== "string" || await realpath6(resolve11(folder2, input.path)) !== context.lockedFile))
+    if (context.lockedFile && (typeof input.path !== "string" || await realpath4(resolve7(folder2, input.path)) !== context.lockedFile))
       throw apiError("forbidden", "Only the selected document can be edited.");
     await editDocument(folder2, input);
     jsonResponse(response, 200, routes.documentEdit.response.parse({ saved: true }));
@@ -86978,8 +85165,8 @@ var documentEditRoute = {
 };
 
 // packages/api/src/server/api/create-agent-file.ts
-import { writeFile as writeFile5 } from "node:fs/promises";
-import { resolve as resolve12 } from "node:path";
+import { writeFile as writeFile3 } from "node:fs/promises";
+import { resolve as resolve8 } from "node:path";
 var createAgentFileRoute = {
   method: "POST",
   maxBodyBytes: 0,
@@ -86990,9 +85177,9 @@ var createAgentFileRoute = {
     } catch (error51) {
       throw apiError("not-found", error51 instanceof Error ? error51.message : "Folder not found");
     }
-    const target = resolve12(folder2, "AGENTS.md");
+    const target = resolve8(folder2, "AGENTS.md");
     try {
-      await writeFile5(target, "", { flag: "wx" });
+      await writeFile3(target, "", { flag: "wx" });
     } catch (error51) {
       if (error51 && typeof error51 === "object" && "code" in error51 && error51.code === "EEXIST") {
         throw apiError("conflict", "AGENTS.md already exists in this folder");
@@ -87028,11 +85215,11 @@ var openPathRoute = {
 };
 
 // packages/api/src/server/folder-favicon.ts
-import { readFile as readFile9 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { join as join3 } from "node:path";
 async function folderWebsite(folder2) {
   for (const name of ["AGENTS.md", "README.md"]) {
-    const content = await readFile9(join3(folder2, name), "utf8").catch(() => "");
+    const content = await readFile6(join3(folder2, name), "utf8").catch(() => "");
     const entry = markdownMetadata(content).entries.find(([key]) => key === "website");
     if (entry)
       return websiteHost(entry[1]);
@@ -87042,8 +85229,8 @@ async function folderWebsite(folder2) {
 
 // packages/api/src/server/folder-icons.ts
 var import_local2 = __toESM(require_dist4(), 1);
-import { createHash as createHash6 } from "node:crypto";
-import { readFile as readFile10, stat as stat5 } from "node:fs/promises";
+import { createHash as createHash4 } from "node:crypto";
+import { readFile as readFile7, stat as stat5 } from "node:fs/promises";
 import { extname as extname4 } from "node:path";
 var maxIconBytes2 = 4 * 1024 * 1024;
 var iconTypes = new Map([
@@ -87056,7 +85243,7 @@ var iconExtensions = new Map([
   ["image/png", "png"]
 ]);
 function assetKey(value) {
-  return createHash6("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 function encodeBase64Url(value) {
   return Buffer.from(value, "utf8").toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
@@ -87073,7 +85260,7 @@ async function folderIcon(folder2, assets2, assetFiles, fallback) {
   if (!icon2 || !mediaType || !details?.size || details.size > maxIconBytes2) {
     return fallback ? await fallback(folder2, assets2) : undefined;
   }
-  const data = await readFile10(icon2);
+  const data = await readFile7(icon2);
   const hash3 = assetKey(data);
   const key = `local:${hash3}`;
   assetFiles.set(hash3, { mediaType, path: icon2 });
@@ -87094,8 +85281,8 @@ async function workspaceBreadcrumbIcons(breadcrumbs, assetFiles, assets2 = {}) {
 
 // packages/api/src/server/plugins.ts
 import { pathToFileURL } from "node:url";
-import { existsSync as existsSync4 } from "node:fs";
-import { dirname as dirname14, resolve as resolve17, sep as sep11 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname8, resolve as resolve11, sep as sep6 } from "node:path";
 
 // packages/agents/src/manifest.ts
 var agentsManifest = {
@@ -87104,9 +85291,9 @@ var agentsManifest = {
 };
 
 // packages/agents/src/node.ts
-import { lstat as lstat2, readFile as readFile11, realpath as realpath7, stat as stat6 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { basename as basename5, dirname as dirname10, resolve as resolve13 } from "node:path";
+import { lstat, readFile as readFile8, realpath as realpath5, stat as stat6 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { basename as basename5, dirname as dirname7, resolve as resolve9 } from "node:path";
 
 // packages/agents/src/profiles.ts
 var CLIENT_ORDER = [
@@ -87250,13 +85437,13 @@ function sortSources(sources) {
 // packages/agents/src/node.ts
 async function canonicalize(path) {
   try {
-    return await realpath7(path);
+    return await realpath5(path);
   } catch {
     return null;
   }
 }
 async function hasGit(folder2) {
-  const entry = await lstat2(resolve13(folder2, ".git")).catch(() => {
+  const entry = await lstat(resolve9(folder2, ".git")).catch(() => {
     return;
   });
   return Boolean(entry);
@@ -87266,7 +85453,7 @@ async function nearestGitRoot(folder2) {
   while (true) {
     if (await hasGit(current))
       return current;
-    const parent = dirname10(current);
+    const parent = dirname7(current);
     if (parent === current)
       return null;
     current = parent;
@@ -87275,12 +85462,12 @@ async function nearestGitRoot(folder2) {
 async function nearestRaggleRoot(folder2) {
   let current = folder2;
   while (true) {
-    const entry = await lstat2(resolve13(current, "raggle.json")).catch(() => {
+    const entry = await lstat(resolve9(current, "raggle.json")).catch(() => {
       return;
     });
     if (entry)
       return current;
-    const parent = dirname10(current);
+    const parent = dirname7(current);
     if (parent === current)
       return null;
     current = parent;
@@ -87291,7 +85478,7 @@ async function ancestorBoundary(folder2, scope) {
   while (true) {
     if (scope === "git" && await hasGit(current))
       return current;
-    const parent = dirname10(current);
+    const parent = dirname7(current);
     if (parent === current)
       return current;
     current = parent;
@@ -87304,7 +85491,7 @@ function ancestorChain(folder2, boundary) {
     chain.push(current);
     if (current === boundary)
       break;
-    const parent = dirname10(current);
+    const parent = dirname7(current);
     if (parent === current)
       break;
     current = parent;
@@ -87352,16 +85539,16 @@ function mergeChains(chains) {
 async function selectFiles(directory, candidates, mode) {
   if (mode === "all") {
     const found = [];
-    for (const relative10 of candidates) {
-      if (await isRegularFile(resolve13(directory, relative10))) {
-        found.push({ filename: basename5(relative10), relative: relative10 });
+    for (const relative8 of candidates) {
+      if (await isRegularFile(resolve9(directory, relative8))) {
+        found.push({ filename: basename5(relative8), relative: relative8 });
       }
     }
     return found;
   }
-  for (const relative10 of candidates) {
-    if (await isRegularFile(resolve13(directory, relative10))) {
-      return [{ filename: basename5(relative10), relative: relative10 }];
+  for (const relative8 of candidates) {
+    if (await isRegularFile(resolve9(directory, relative8))) {
+      return [{ filename: basename5(relative8), relative: relative8 }];
     }
   }
   return [];
@@ -87370,7 +85557,7 @@ function expandHome(path, homeDir) {
   if (path === "~")
     return homeDir;
   if (path.startsWith("~/"))
-    return resolve13(homeDir, path.slice(2));
+    return resolve9(homeDir, path.slice(2));
   return path;
 }
 function globalDirectory(profile, homeDir) {
@@ -87381,7 +85568,7 @@ function globalDirectory(profile, homeDir) {
     return expandHome(envValue, homeDir);
   if (profile.globalDir === "")
     return homeDir;
-  return resolve13(homeDir, profile.globalDir);
+  return resolve9(homeDir, profile.globalDir);
 }
 function readError(error51) {
   return error51 instanceof Error ? error51.message : "Could not read file";
@@ -87389,7 +85576,7 @@ function readError(error51) {
 var INSTRUCTION_NAMES = new Set(Object.values(PROFILES).flatMap((profile) => [...profile.files, ...profile.globalFiles]).map((path) => basename5(path).toLowerCase()));
 async function codexModelInstructionsFile(codexHome) {
   try {
-    const content = await readFile11(resolve13(codexHome, "config.toml"), "utf8");
+    const content = await readFile8(resolve9(codexHome, "config.toml"), "utf8");
     const match = /^\s*model_instructions_file\s*=\s*["']?([^"'\n]+)["']?\s*$/m.exec(content);
     return match?.[1]?.trim() ?? null;
   } catch {
@@ -87404,7 +85591,7 @@ async function loadSource(input) {
       path: input.literalPath,
       sourcePaths: [input.literalPath],
       filename: input.filename,
-      directory: dirname10(input.literalPath),
+      directory: dirname7(input.literalPath),
       level: input.level,
       status: "unreadable",
       text: "",
@@ -87420,7 +85607,7 @@ async function loadSource(input) {
     path: real,
     sourcePaths: [input.literalPath],
     filename: input.filename,
-    directory: dirname10(real),
+    directory: dirname7(real),
     level: input.level,
     status: "loaded",
     text: "",
@@ -87445,7 +85632,7 @@ async function loadSource(input) {
   record2.size = details.size;
   if (input.readText) {
     try {
-      record2.text = await readFile11(real, "utf8");
+      record2.text = await readFile8(real, "utf8");
     } catch (error51) {
       record2.status = "unreadable";
       record2.reason = readError(error51);
@@ -87454,7 +85641,7 @@ async function loadSource(input) {
   return record2;
 }
 async function resolveAgents(options) {
-  const homeDir = options.homeDir ?? homedir5();
+  const homeDir = options.homeDir ?? homedir3();
   const client = options.client ?? "all";
   const readText = options.readText ?? true;
   const folder2 = await canonicalize(options.folder);
@@ -87487,7 +85674,7 @@ async function resolveAgents(options) {
           clientId: profileId,
           filename: file3.filename,
           level,
-          literalPath: resolve13(directory, file3.relative),
+          literalPath: resolve9(directory, file3.relative),
           override: file3.filename === "AGENTS.override.md",
           readText
         });
@@ -87510,7 +85697,7 @@ async function resolveAgents(options) {
           clientId: profileId,
           filename: file3.filename,
           level: "linked",
-          literalPath: resolve13(canonicalLinked, file3.relative),
+          literalPath: resolve9(canonicalLinked, file3.relative),
           override: file3.filename === "AGENTS.override.md",
           readText
         });
@@ -87525,7 +85712,7 @@ async function resolveAgents(options) {
           clientId: profileId,
           filename: file3.filename,
           level: "global",
-          literalPath: resolve13(globalDir, file3.relative),
+          literalPath: resolve9(globalDir, file3.relative),
           override: file3.filename === "AGENTS.override.md",
           readText
         });
@@ -87608,559 +85795,9 @@ function createAgentsPlugin(options = {}) {
   };
 }
 
-// plugins/calendar/src/server.ts
-import { readdir as readdir6, readFile as readFile12 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname11, relative as relative10, resolve as resolve14, sep as sep8 } from "node:path";
-
-// plugins/calendar/src/manifest.ts
-var calendarManifest = {
-  id: "calendar",
-  label: "Calendar"
-};
-
-// node_modules/.bun/date-fns@4.1.0/node_modules/date-fns/constants.js
-var daysInYear = 365.2425;
-var maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1000;
-var minTime = -maxTime;
-var secondsInHour = 3600;
-var secondsInDay = secondsInHour * 24;
-var secondsInWeek = secondsInDay * 7;
-var secondsInYear = secondsInDay * daysInYear;
-var secondsInMonth = secondsInYear / 12;
-var secondsInQuarter = secondsInMonth * 3;
-var constructFromSymbol = Symbol.for("constructDateFrom");
-
-// node_modules/.bun/date-fns@4.1.0/node_modules/date-fns/constructFrom.js
-function constructFrom(date5, value) {
-  if (typeof date5 === "function")
-    return date5(value);
-  if (date5 && typeof date5 === "object" && constructFromSymbol in date5)
-    return date5[constructFromSymbol](value);
-  if (date5 instanceof Date)
-    return new date5.constructor(value);
-  return new Date(value);
-}
-
-// node_modules/.bun/date-fns@4.1.0/node_modules/date-fns/toDate.js
-function toDate(argument, context) {
-  return constructFrom(context || argument, argument);
-}
-
-// node_modules/.bun/date-fns@4.1.0/node_modules/date-fns/endOfDay.js
-function endOfDay(date5, options) {
-  const _date2 = toDate(date5, options?.in);
-  _date2.setHours(23, 59, 59, 999);
-  return _date2;
-}
-
-// plugins/calendar/src/parse.ts
-var colors = new Set([
-  "blue",
-  "green",
-  "red",
-  "yellow",
-  "purple",
-  "orange"
-]);
-var repeats = new Set(["daily", "weekly", "monthly"]);
-var statuses = new Set([
-  "confirmed",
-  "tentative",
-  "cancelled"
-]);
-function valueAt(record2, keys) {
-  for (const key of keys) {
-    const value = record2[key];
-    if (value !== undefined && value !== null && value !== "")
-      return value;
-  }
-  return;
-}
-function text2(record2, keys) {
-  const value = valueAt(record2, keys);
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function texts(value) {
-  if (!Array.isArray(value))
-    return;
-  const values = [
-    ...new Set(value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean))
-  ];
-  return values.length ? values : undefined;
-}
-function numbers(value) {
-  if (!Array.isArray(value))
-    return;
-  const values = [
-    ...new Set(value.filter((item) => typeof item === "number" && Number.isInteger(item) && item >= 0))
-  ].sort((left, right) => left - right);
-  return values.length ? values : undefined;
-}
-var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
-function localDateOnly(value) {
-  const trimmed = value.trim();
-  if (!DATE_ONLY.test(trimmed))
-    return;
-  const [year, month, day] = trimmed.split("-").map(Number);
-  return new Date(year ?? 0, (month ?? 1) - 1, day ?? 1);
-}
-function date5(value, fallback) {
-  if (value instanceof Date && !Number.isNaN(value.getTime()))
-    return value;
-  if (typeof value === "number" && Number.isFinite(value))
-    return new Date(value);
-  if (typeof value === "string" && value.trim()) {
-    const parsed = localDateOnly(value) ?? new Date(value);
-    if (!Number.isNaN(parsed.getTime()))
-      return parsed;
-  }
-  return fallback;
-}
-function color(value) {
-  if (typeof value !== "string")
-    return;
-  const candidate = value.toLowerCase();
-  return colors.has(candidate) ? candidate : undefined;
-}
-function repeating(value) {
-  if (typeof value !== "string")
-    return;
-  const candidate = value.toLowerCase();
-  return repeats.has(candidate) ? candidate : undefined;
-}
-function status(value) {
-  if (typeof value !== "string")
-    return;
-  const candidate = value.toLowerCase();
-  return statuses.has(candidate) ? candidate : undefined;
-}
-function url2(value) {
-  if (typeof value !== "string" || !value.trim())
-    return;
-  const candidate = value.trim();
-  return /^https?:\/\/[^\s]+$/i.test(candidate) ? candidate : undefined;
-}
-function dates(value) {
-  if (!Array.isArray(value))
-    return;
-  const values = value.map((item) => date5(item, new Date(Number.NaN))).filter((item) => !Number.isNaN(item.getTime()));
-  return values.length ? values : undefined;
-}
-function until(value) {
-  if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value)) {
-    const parsed2 = date5(value, new Date(Number.NaN));
-    return Number.isNaN(parsed2.getTime()) ? undefined : endOfDay(parsed2);
-  }
-  const parsed = date5(value, new Date(Number.NaN));
-  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
-}
-function parseCalendar(calendar) {
-  if (Array.isArray(calendar))
-    return { events: parseEvents(calendar) };
-  if (!calendar || typeof calendar !== "object")
-    return;
-  const record2 = calendar;
-  if (!Array.isArray(record2.events))
-    return;
-  return {
-    color: color(record2.color),
-    startDate: typeof record2.startDate === "string" && record2.startDate.trim() ? record2.startDate.trim() : undefined,
-    group: typeof record2.group === "string" && record2.group.trim() ? record2.group.trim() : undefined,
-    title: typeof record2.title === "string" && record2.title.trim() ? record2.title.trim() : undefined,
-    events: parseEvents(record2.events)
-  };
-}
-function parseCalendarJson(source) {
-  try {
-    return parseCalendar(JSON.parse(source));
-  } catch {
-    return;
-  }
-}
-function parseEvents(events) {
-  return events.map((record2, index) => normalizeEvent(record2, index));
-}
-function normalizeEvent(record2, index) {
-  const id = valueAt(record2, ["id", "uid", "key"])?.toString() ?? String(index);
-  const startValue = date5(valueAt(record2, ["start", "startDate", "start_date", "date", "begin"]), new Date(0));
-  const endValue = date5(valueAt(record2, ["end", "endDate", "end_date", "due", "finish"]), startValue);
-  const allDay = typeof record2.allDay === "boolean" ? record2.allDay : undefined;
-  const start = startValue;
-  const end = endValue > start ? endValue : new Date(start.getTime() + (allDay ? 86400000 : 3600000));
-  const rawColor = valueAt(record2, [
-    "color",
-    "colour",
-    "calendarId",
-    "calendar",
-    "category"
-  ]) ?? valueAt(record2, ["calendars"]);
-  const eventColor = color(rawColor) ?? color(Array.isArray(rawColor) ? rawColor[0] : undefined);
-  return {
-    id,
-    start,
-    end,
-    color: eventColor,
-    folder: typeof record2.folder === "string" ? record2.folder : undefined,
-    group: text2(record2, ["group"]),
-    groupColor: color(record2.groupColor),
-    repeating: repeating(record2.repeating),
-    allDay,
-    attendees: texts(record2.attendees),
-    excludeDates: dates(record2.excludeDates),
-    location: text2(record2, ["location"]),
-    organizer: text2(record2, ["organizer"]),
-    reminders: numbers(record2.reminders),
-    repeatUntil: until(record2.repeatUntil),
-    status: status(record2.status),
-    tags: texts(record2.tags),
-    url: url2(record2.url),
-    description: text2(record2, [
-      "description",
-      "detail",
-      "notes",
-      "summary",
-      "body"
-    ]),
-    title: text2(record2, ["title", "name", "subject", "summary", "label"]) ?? "Untitled"
-  };
-}
-function mergeCalendars(sources) {
-  const root = sources.find((source) => source.path === "calendar.json");
-  return {
-    title: root?.calendar.title ?? sources[0]?.calendar.title,
-    startDate: root?.calendar.startDate ?? sources[0]?.calendar.startDate,
-    events: sources.flatMap((source) => {
-      const group = source.calendar.group ?? source.group;
-      return source.calendar.events.map((event) => ({
-        ...event,
-        folder: source.folder,
-        group: event.group ?? group,
-        groupColor: event.groupColor ?? source.calendar.color,
-        id: `${source.path}:${event.id}`
-      }));
-    })
-  };
-}
-function eventCount(calendar) {
-  return calendar?.events.length ?? 0;
-}
-var EVENT_TITLE_KEYS = [
-  "title",
-  "name",
-  "subject",
-  "summary",
-  "label"
-];
-var EVENT_START_KEYS = [
-  "start",
-  "startDate",
-  "start_date",
-  "date",
-  "begin"
-];
-var EVENT_END_KEYS = ["end", "endDate", "end_date", "due", "finish"];
-function isRecord2(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function strictDate(value) {
-  if (value instanceof Date && !Number.isNaN(value.getTime()))
-    return value;
-  if (typeof value === "number" && Number.isFinite(value))
-    return new Date(value);
-  if (typeof value === "string" && value.trim()) {
-    const parsed = localDateOnly(value) ?? new Date(value);
-    if (!Number.isNaN(parsed.getTime()))
-      return parsed;
-  }
-  return;
-}
-function validateCalendarFile(value) {
-  if (Array.isArray(value)) {
-    return value.flatMap((event, index) => validateEvent(event, `events[${index}]`));
-  }
-  if (!isRecord2(value)) {
-    return [
-      {
-        path: "#",
-        message: "calendar.json must contain an object or an array of events"
-      }
-    ];
-  }
-  const issues = [];
-  if (!Array.isArray(value.events)) {
-    issues.push({ path: "events", message: "must be an array of events" });
-  } else {
-    value.events.forEach((event, index) => {
-      issues.push(...validateEvent(event, `events[${index}]`));
-    });
-  }
-  return issues;
-}
-function validateEvent(event, path) {
-  if (!isRecord2(event)) {
-    return [{ path, message: "must be an event object" }];
-  }
-  const issues = [];
-  const hasTitle = EVENT_TITLE_KEYS.some((key) => typeof event[key] === "string" && event[key].trim().length > 0);
-  if (!hasTitle) {
-    issues.push({
-      path,
-      message: "has no title (expected one of title, name, subject, summary, label)"
-    });
-  }
-  const startValue = EVENT_START_KEYS.find((key) => event[key] !== undefined);
-  if (startValue !== undefined && !strictDate(event[startValue])) {
-    issues.push({
-      path: `${path}.${startValue}`,
-      message: "could not be parsed as a date"
-    });
-  }
-  const endValue = EVENT_END_KEYS.find((key) => event[key] !== undefined);
-  if (endValue !== undefined && event[endValue] !== null && !strictDate(event[endValue])) {
-    issues.push({
-      path: `${path}.${endValue}`,
-      message: "could not be parsed as a date"
-    });
-  }
-  if (event.allDay !== undefined && typeof event.allDay !== "boolean") {
-    issues.push({ path: `${path}.allDay`, message: "must be a boolean" });
-  }
-  if (event.repeating !== undefined && !["daily", "weekly", "monthly"].includes(String(event.repeating))) {
-    issues.push({
-      path: `${path}.repeating`,
-      message: "must be one of daily, weekly, monthly"
-    });
-  }
-  if (event.status !== undefined && !["confirmed", "tentative", "cancelled"].includes(String(event.status))) {
-    issues.push({
-      path: `${path}.status`,
-      message: "must be one of confirmed, tentative, cancelled"
-    });
-  }
-  if (event.excludeDates !== undefined && !Array.isArray(event.excludeDates)) {
-    issues.push({
-      path: `${path}.excludeDates`,
-      message: "must be an array of dates"
-    });
-  }
-  return issues;
-}
-function parseCalendarSource(source) {
-  return parseJsonSource(source, validateCalendarFile);
-}
-function calendarIssueSummary(issues) {
-  return issueSummary(issues, "calendar.json");
-}
-function starterCalendarSource() {
-  return `${JSON.stringify({
-    color: "blue",
-    events: [
-      {
-        id: "1",
-        title: "First event",
-        description: "Describe what happens.",
-        start: "2030-01-01T09:00:00",
-        end: "2030-01-01T10:00:00",
-        allDay: false,
-        status: "confirmed",
-        attendees: []
-      }
-    ]
-  }, null, 2)}
-`;
-}
-
-// plugins/calendar/src/server.ts
-async function loadSources(folder2) {
-  const visit = async (current) => {
-    const entries = await readdir6(current, { withFileTypes: true }).catch(() => []);
-    const paths2 = [];
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name === "calendar.json") {
-        paths2.push(resolve14(current, entry.name));
-        continue;
-      }
-      if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules")
-        continue;
-      paths2.push(...await visit(resolve14(current, entry.name)));
-    }
-    return paths2;
-  };
-  const paths = (await visit(folder2)).sort((left, right) => relative10(folder2, left).localeCompare(relative10(folder2, right)));
-  const issues = [];
-  const sources = [];
-  await Promise.all(paths.map(async (path) => {
-    const sourceText = await readFile12(path, "utf8");
-    const file3 = relative10(folder2, path).split(sep8).join("/");
-    const validation = parseCalendarSource(sourceText);
-    if (!validation.ok) {
-      issues.push({ file: file3, problems: validation.issues });
-      return;
-    }
-    const calendar = parseCalendarJson(sourceText);
-    if (!calendar) {
-      issues.push({
-        file: file3,
-        problems: [{ path: "#", message: "could not be read as a calendar" }]
-      });
-      return;
-    }
-    const directory = dirname11(file3);
-    sources.push({
-      calendar,
-      folder: dirname11(path),
-      group: directory === "." ? basename6(folder2) : directory,
-      path: file3
-    });
-  }));
-  issues.sort((left, right) => left.file.localeCompare(right.file));
-  return { issues, sources };
-}
-function flattenIssues(load) {
-  return load.issues.flatMap(({ file: file3, problems }) => problems.map((problem) => ({
-    path: problem.path === "#" ? file3 : `${file3}: ${problem.path}`,
-    message: problem.message
-  })));
-}
-function detectionFor(load) {
-  const noContent = load.sources.length === 0 && load.issues.length === 0;
-  if (noContent)
-    return { status: "unavailable" };
-  if (load.issues.length > 0) {
-    return {
-      status: "error",
-      error: calendarIssueSummary(flattenIssues(load))
-    };
-  }
-  return {
-    count: eventCount(mergeCalendars(load.sources)),
-    status: "available"
-  };
-}
-function createCalendarPlugin() {
-  return {
-    ...calendarManifest,
-    async detect(context) {
-      return detectionFor(await loadSources(context.folder));
-    },
-    async handle(context, subpath) {
-      if (subpath !== "")
-        return { kind: "unavailable" };
-      const load = await loadSources(context.folder);
-      const detection = detectionFor(load);
-      if (detection.status === "unavailable")
-        return { kind: "unavailable" };
-      const calendar = mergeCalendars(load.sources);
-      const issues = flattenIssues(load);
-      return {
-        kind: "available",
-        data: {
-          calendar: {
-            count: calendar.events.length,
-            items: calendar.events,
-            startDate: calendar.startDate,
-            title: calendar.title
-          },
-          folder: context.folder,
-          issues: issues.length > 0 ? issues : undefined,
-          status: issues.length > 0 ? "error" : "available"
-        }
-      };
-    },
-    async init(context) {
-      return {
-        files: [{ path: "calendar.json", content: starterCalendarSource() }]
-      };
-    }
-  };
-}
-
-// plugins/mail/src/manifest.ts
-var mailManifest = {
-  id: "mail",
-  label: "Mail"
-};
-
-// plugins/mail/src/server.ts
-function detailData(mail, preview) {
-  return {
-    kind: "available",
-    data: {
-      mail: {
-        ...mail,
-        bcc: mail.bcc,
-        body: mail.body,
-        cc: mail.cc,
-        createdAt: mail.createdAt,
-        filePath: mail.filePath,
-        folder: mail.folder,
-        id: mail.id,
-        status: mail.status,
-        subject: mail.subject,
-        tags: mail.tags,
-        to: mail.to,
-        updatedAt: mail.updatedAt,
-        noSignature: mail.noSignature
-      },
-      preview
-    }
-  };
-}
-function createMailPlugin({
-  mailDir = defaultMailDir(),
-  previewer
-} = {}) {
-  const mailos = createMailosService();
-  const compose = previewer ?? (async ({ mail }) => ({
-    body: mail.body,
-    signature: mail.noSignature ? null : mail.folder ? await mailos.signature(mail.folder) : null
-  }));
-  return {
-    ...mailManifest,
-    async detect(context) {
-      const items2 = await listMailForFolder({ folder: context.folder, mailDir });
-      if (!items2.length)
-        return { status: "unavailable" };
-      return { count: items2.length, status: "available" };
-    },
-    async handle(context, subpath) {
-      const folder2 = context.folder;
-      if (subpath === "") {
-        const items2 = await listMailForFolder({ folder: folder2, mailDir });
-        if (!items2.length) {
-          return {
-            kind: "available",
-            data: { folder: folder2, items: [], status: "unavailable" }
-          };
-        }
-        return {
-          kind: "available",
-          data: { folder: folder2, items: items2, status: "available" }
-        };
-      }
-      const id = subpath.trim();
-      const mail = await readMailById(id, mailDir);
-      if (!mail)
-        throw new Error("Mail not found");
-      if (!mail.folder)
-        throw new Error("Mail has no folder");
-      if (!isFolderWithin(folder2, mail.folder))
-        throw new Error("Mail not found for this folder");
-      let preview;
-      try {
-        preview = await compose({ folder: folder2, id: mail.id, mail });
-      } catch (error51) {
-        const message = error51 instanceof Error ? error51.message : "Unknown preview error";
-        throw new FolderPluginFailure(`Mail preview failed: ${message}`);
-      }
-      return detailData(mail, preview);
-    }
-  };
-}
-
 // packages/notes/src/server.ts
-import { readdir as readdir7, stat as stat7 } from "node:fs/promises";
-import { basename as basename7, extname as extname5, relative as relative11, resolve as resolve15, sep as sep9 } from "node:path";
+import { readdir as readdir4, stat as stat7 } from "node:fs/promises";
+import { basename as basename6, extname as extname5, relative as relative8, resolve as resolve10, sep as sep5 } from "node:path";
 
 // packages/notes/src/manifest.ts
 var notesManifest = {
@@ -88173,11 +85810,11 @@ var markdownExtensions = new Set([".md", ".markdown"]);
 async function listMarkdownFiles(folder2) {
   const files = [];
   const visit = async (current) => {
-    const entries = await readdir7(current, { withFileTypes: true }).catch(() => []);
+    const entries = await readdir4(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name.startsWith("."))
         continue;
-      const path = resolve15(current, entry.name);
+      const path = resolve10(current, entry.name);
       if (entry.isDirectory()) {
         await visit(path);
         continue;
@@ -88190,8 +85827,8 @@ async function listMarkdownFiles(folder2) {
       });
       files.push({
         activityAt: details?.mtimeMs ?? 0,
-        name: basename7(entry.name, extname5(entry.name)),
-        relativePath: relative11(folder2, path).split(sep9).join("/")
+        name: basename6(entry.name, extname5(entry.name)),
+        relativePath: relative8(folder2, path).split(sep5).join("/")
       });
     }
   };
@@ -88233,505 +85870,6 @@ function createNotesPlugin() {
   };
 }
 
-// plugins/projects/src/server.ts
-import { execFile as execFile2 } from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname12, join as join4 } from "node:path";
-import { fileURLToPath } from "node:url";
-
-// plugins/projects/src/manifest.ts
-var projectsManifest = {
-  id: "projects",
-  label: "Projects"
-};
-
-// plugins/projects/src/server.ts
-var scoutScript = `
-const local = require(process.argv[1]);
-(async () => {
-  const folder = process.argv[2];
-  const connected = await local.listConnectedProjects(folder, {
-    depth: 1,
-    focused: true,
-  });
-  process.stdout.write(JSON.stringify(local.connectedProjectsList(folder, connected)));
-})().catch(error => { console.error(error); process.exitCode = 1; });
-`;
-function resolveScoutModule() {
-  const require2 = createRequire2(import.meta.url);
-  const candidates = [];
-  try {
-    candidates.push(require2.resolve("@raggle-ai/local"));
-  } catch {}
-  let directory = dirname12(fileURLToPath(import.meta.url));
-  while (dirname12(directory) !== directory) {
-    if (existsSync3(join4(directory, "raggle.json"))) {
-      candidates.push(join4(dirname12(directory), "raggle-ai-scout", "packages", "local"));
-      break;
-    }
-    directory = dirname12(directory);
-  }
-  for (const candidate of candidates) {
-    try {
-      const mod = require2(candidate);
-      if (typeof mod.listConnectedProjects === "function" && typeof mod.connectedProjectsList === "function") {
-        return candidate;
-      }
-    } catch {}
-  }
-  return;
-}
-function normalizeRepositories(raw) {
-  const repositories = [];
-  if (!Array.isArray(raw.repositories))
-    return repositories;
-  for (const value of raw.repositories) {
-    const row = value;
-    if (!row || typeof row !== "object" || typeof row.worktree !== "string")
-      continue;
-    const type = row.type;
-    const direction = row.direction;
-    if (type !== "dependency" && type !== "implementation" && type !== "notes" && type !== "related" || direction !== "incoming" && direction !== "outgoing" || typeof row.depth !== "number" || typeof row.repository !== "string" || row.worktree.length === 0)
-      continue;
-    repositories.push({
-      depth: row.depth,
-      direction,
-      repository: row.repository,
-      type,
-      worktree: row.worktree
-    });
-  }
-  return repositories;
-}
-function discoverProjects(scoutModule, folder2) {
-  return new Promise((resolve16) => {
-    execFile2(process.execPath, ["-e", scoutScript, scoutModule, folder2], {
-      timeout: 60000,
-      maxBuffer: 8 * 1024 * 1024,
-      env: { ...process.env, NODE_OPTIONS: "" }
-    }, (error51, stdout) => {
-      if (error51) {
-        resolve16({
-          message: "Raggle Scout discovery timed out or failed. Retry the view to try again.",
-          projects: [],
-          status: "error"
-        });
-        return;
-      }
-      try {
-        const list = JSON.parse(stdout);
-        resolve16({
-          projects: normalizeRepositories(list),
-          status: "available"
-        });
-      } catch (parseError) {
-        resolve16({
-          message: `Could not parse the Scout response: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
-          projects: [],
-          status: "error"
-        });
-      }
-    });
-  });
-}
-var TTL = 60000;
-var cache = new Map;
-var stamps = new Map;
-var inflight = new Map;
-var queue = Promise.resolve();
-function requestProjects(scoutModule, folder2) {
-  const existing = inflight.get(folder2);
-  if (existing)
-    return existing;
-  const run = queue.then(() => discoverProjects(scoutModule, folder2), () => discoverProjects(scoutModule, folder2));
-  queue = run.then(() => {
-    return;
-  }, () => {
-    return;
-  });
-  inflight.set(folder2, run);
-  return run.finally(() => {
-    inflight.delete(folder2);
-  });
-}
-async function loadProjects(context) {
-  const folder2 = context.folder;
-  const cached2 = cache.get(folder2);
-  const stamp = stamps.get(folder2) ?? 0;
-  if (cached2 && Date.now() - stamp < TTL)
-    return cached2;
-  const scoutModule = resolveScoutModule();
-  if (cached2 && !scoutModule)
-    return cached2;
-  if (scoutModule) {
-    const promise2 = requestProjects(scoutModule, folder2);
-    if (cached2) {
-      promise2.then((load2) => {
-        if (load2.status === "available") {
-          cache.set(folder2, load2);
-          stamps.set(folder2, Date.now());
-        }
-      });
-      return cached2;
-    }
-    const load = await promise2;
-    if (load.status === "available") {
-      cache.set(folder2, load);
-      stamps.set(folder2, Date.now());
-    }
-    return load;
-  }
-  return {
-    message: "Raggle Scout module (@raggle-ai/local with connected-project discovery) could not be resolved.",
-    projects: [],
-    status: "error"
-  };
-}
-function createProjectsPlugin() {
-  return {
-    ...projectsManifest,
-    async detect(_context) {
-      return { status: "available" };
-    },
-    async handle(context, _subpath) {
-      const load = await loadProjects(context);
-      if (load.status === "error") {
-        return {
-          kind: "available",
-          data: {
-            folder: context.folder,
-            message: load.message,
-            projects: [],
-            status: "error"
-          }
-        };
-      }
-      return {
-        kind: "available",
-        data: {
-          folder: context.folder,
-          projects: load.projects,
-          status: "available"
-        }
-      };
-    }
-  };
-}
-
-// plugins/tasks/src/server.ts
-import { readdir as readdir8, readFile as readFile13, stat as stat8 } from "node:fs/promises";
-import { basename as basename8, dirname as dirname13, relative as relative12, resolve as resolve16, sep as sep10 } from "node:path";
-
-// packages/folder-plugin/src/subpath.ts
-function matchSubpath(sources, subpath, itemsOf, matches) {
-  const id = subpath.trim();
-  if (!id)
-    return;
-  for (const source of sources) {
-    for (const item of itemsOf(source)) {
-      if (matches(item, id))
-        return { item, source };
-    }
-  }
-  return;
-}
-
-// plugins/tasks/src/manifest.ts
-var tasksManifest = {
-  id: "tasks",
-  label: "Tasks"
-};
-
-// plugins/tasks/src/server.ts
-async function loadTaskSources(viewRoot, scanRoot = viewRoot) {
-  const visit = async (current) => {
-    const entries = await readdir8(current, { withFileTypes: true }).catch(() => []);
-    const paths2 = [];
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name === "todo.json") {
-        paths2.push(resolve16(current, entry.name));
-        continue;
-      }
-      if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules")
-        continue;
-      paths2.push(...await visit(resolve16(current, entry.name)));
-    }
-    return paths2;
-  };
-  const paths = (await visit(scanRoot)).sort((left, right) => relative12(scanRoot, left).localeCompare(relative12(scanRoot, right)));
-  const issues = [];
-  const warnings = [];
-  const sources = [];
-  await Promise.all(paths.map(async (path) => {
-    const sourceText = await readFile13(path, "utf8");
-    const file3 = relative12(viewRoot, path).split(sep10).join("/");
-    const parsed = parseTodoSource(sourceText);
-    if (!parsed.ok) {
-      issues.push({ file: file3, problems: parsed.issues });
-      return;
-    }
-    warnings.push({
-      file: file3,
-      problems: [
-        ...todoFileWarnings(parsed.document),
-        ...await missingNoteIssues(parsed.document, dirname13(path))
-      ]
-    });
-    sources.push({
-      document: parsed.document,
-      folder: dirname13(path),
-      path: file3
-    });
-  }));
-  issues.sort((left, right) => left.file.localeCompare(right.file));
-  return { issues, sources, warnings };
-}
-async function loadLinkedTaskSources(viewRoot, linkedFolders) {
-  const loads = await Promise.all(linkedFolders.map((folder2) => loadTaskSources(viewRoot, folder2)));
-  return {
-    issues: loads.flatMap((load) => load.issues),
-    sources: loads.flatMap((load) => load.sources),
-    warnings: loads.flatMap((load) => load.warnings)
-  };
-}
-function flattenIssues2(load) {
-  return load.issues.flatMap(({ file: file3, problems }) => problems.map((problem) => ({
-    path: file3 === "todo.json" ? problem.path : `${file3}: ${problem.path}`,
-    message: problem.message
-  })));
-}
-function flattenWarnings(load) {
-  return load.warnings.flatMap(({ file: file3, problems }) => problems.map((problem) => ({
-    path: file3 === "todo.json" ? problem.path : `${file3}: ${problem.path}`,
-    message: problem.message,
-    severity: problem.severity
-  })));
-}
-async function missingNoteIssues(document3, folder2) {
-  const missing = [];
-  for (const [index, task] of document3.tasks.entries()) {
-    const notes = task.notes;
-    if (!Array.isArray(notes))
-      continue;
-    for (const [noteIndex, note] of notes.entries()) {
-      if (typeof note !== "string" || /^https?:\/\//i.test(note))
-        continue;
-      const target = (note.split("#", 1)[0] ?? "").trim();
-      if (!target)
-        continue;
-      const exists = await stat8(resolve16(folder2, target)).then((entry) => entry.isFile()).catch(() => false);
-      if (!exists) {
-        missing.push({
-          message: `references a missing note file: ${target}`,
-          path: `tasks[${index}].notes[${noteIndex}]`,
-          severity: "warning"
-        });
-      }
-    }
-  }
-  return missing;
-}
-function taskCompleted(task) {
-  return task.done === true || task.status === "done";
-}
-function tasksOf(source) {
-  return Array.isArray(source.document.tasks) ? source.document.tasks : [];
-}
-function sourceTitle(folder2) {
-  return `${basename8(folder2)} tasks`;
-}
-function mergedDataset(folder2, sources) {
-  const root = sources.find((source) => source.path === "todo.json");
-  const title = root && typeof root.document.title === "string" ? root.document.title : sourceTitle(folder2);
-  const byFolder = new Map;
-  for (const source of sources) {
-    byFolder.set(source.folder, [
-      ...byFolder.get(source.folder) ?? [],
-      source
-    ]);
-  }
-  const ordered = new Map;
-  ordered.set(folder2, byFolder.get(folder2) ?? []);
-  for (const sourceFolder of [...byFolder.keys()].sort()) {
-    const docs = byFolder.get(sourceFolder);
-    if (docs && sourceFolder !== folder2)
-      ordered.set(sourceFolder, docs);
-  }
-  const datasetSources = [];
-  const tasks = [];
-  for (const [sourceFolder, docs] of ordered) {
-    const fileTasks = docs.flatMap(tasksOf);
-    const completed2 = fileTasks.filter(taskCompleted).length;
-    datasetSources.push({
-      id: sourceFolder,
-      open: fileTasks.length - completed2,
-      title: sourceTitle(sourceFolder),
-      total: fileTasks.length
-    });
-    for (const task of fileTasks) {
-      tasks.push({
-        ...task,
-        source: { id: sourceFolder, title: sourceTitle(sourceFolder) }
-      });
-    }
-  }
-  const completed = tasks.filter(taskCompleted).length;
-  return {
-    ...root?.document,
-    $schema: typeof root?.document.$schema === "string" ? root.document.$schema : "https://raggle.co/schemas/tasks.json",
-    id: typeof root?.document.id === "string" ? root.document.id : "todo",
-    project: { name: title },
-    sources: datasetSources,
-    summary: {
-      completed,
-      open: tasks.length - completed,
-      sources: datasetSources.length
-    },
-    tasks,
-    title,
-    version: typeof root?.document.version === "number" ? root.document.version : 1
-  };
-}
-function singleTaskDataset(folder2, source, task) {
-  const completed = taskCompleted(task);
-  return {
-    ...source.document,
-    $schema: typeof source.document.$schema === "string" ? source.document.$schema : "https://raggle.co/schemas/tasks.json",
-    version: typeof source.document.version === "number" ? source.document.version : 1,
-    project: { name: sourceTitle(folder2) },
-    sources: [
-      {
-        id: source.folder,
-        open: completed ? 0 : 1,
-        title: sourceTitle(source.folder),
-        total: 1
-      }
-    ],
-    summary: {
-      completed: completed ? 1 : 0,
-      open: completed ? 0 : 1,
-      sources: 1
-    },
-    tasks: [
-      {
-        ...task,
-        source: { id: source.folder, title: sourceTitle(source.folder) }
-      }
-    ]
-  };
-}
-function createTasksPlugin() {
-  return {
-    ...tasksManifest,
-    async detect(context) {
-      const [loads, linked] = await Promise.all([
-        loadTaskSources(context.folder),
-        loadLinkedTaskSources(context.folder, context.linkedFolders ?? [])
-      ]);
-      const merged = {
-        issues: [...loads.issues, ...linked.issues],
-        sources: [...loads.sources, ...linked.sources],
-        warnings: []
-      };
-      const noContent = merged.sources.length === 0 && merged.issues.length === 0;
-      if (noContent)
-        return { status: "unavailable" };
-      if (merged.issues.length > 0) {
-        return {
-          status: "error",
-          error: todoIssueSummary(flattenIssues2(merged))
-        };
-      }
-      return {
-        count: merged.sources.reduce((sum, source) => sum + tasksOf(source).length, 0),
-        status: "available"
-      };
-    },
-    async handle(context, subpath) {
-      const [load, linked] = await Promise.all([
-        loadTaskSources(context.folder),
-        loadLinkedTaskSources(context.folder, context.linkedFolders ?? [])
-      ]);
-      const sources = [...load.sources, ...linked.sources];
-      const rootIssue = load.issues.find((issue3) => issue3.file === "todo.json");
-      if (rootIssue) {
-        return {
-          kind: "available",
-          data: {
-            folder: context.folder,
-            issues: rootIssue.problems,
-            status: "error"
-          }
-        };
-      }
-      const warnings = flattenWarnings({
-        issues: [],
-        sources: [],
-        warnings: [...load.warnings, ...linked.warnings]
-      });
-      if (subpath === "" || sources.length === 0) {
-        return {
-          kind: "available",
-          data: {
-            dataset: mergedDataset(context.folder, sources),
-            folder: context.folder,
-            status: "available",
-            warnings
-          }
-        };
-      }
-      const id = subpath.trim();
-      const qualified = parseQualifiedTaskId(id);
-      if (qualified) {
-        const source = sources.find((item) => refMatchesFolder(qualified.ref, item.folder));
-        if (source) {
-          const task = tasksOf(source).find((item) => item.id === qualified.id || item.key === qualified.id);
-          return {
-            kind: "available",
-            data: task ? {
-              dataset: singleTaskDataset(context.folder, source, task),
-              folder: context.folder,
-              status: "available",
-              warnings
-            } : {
-              folder: context.folder,
-              message: `Task not found: ${id}`,
-              status: "error"
-            }
-          };
-        }
-      }
-      const bare = matchSubpath(sources, id, tasksOf, (item, target) => item.id === target || item.key === target);
-      if (bare) {
-        return {
-          kind: "available",
-          data: {
-            dataset: singleTaskDataset(context.folder, bare.source, bare.item),
-            folder: context.folder,
-            status: "available",
-            warnings
-          }
-        };
-      }
-      return {
-        kind: "available",
-        data: {
-          folder: context.folder,
-          message: `Task not found: ${id}`,
-          status: "error"
-        }
-      };
-    },
-    init(context) {
-      return {
-        files: [
-          { path: "todo.json", content: starterTodoSource(context.folder) }
-        ]
-      };
-    }
-  };
-}
 // packages/api/src/server/plugins.ts
 function configuredFolderServerRegistry(registry2, resolvedConfig) {
   const disabled = new Set(resolvedConfig.plugins.disable);
@@ -88744,14 +85882,10 @@ function configuredFolderServerRegistry(registry2, resolvedConfig) {
 }
 function createFolderServerPlugins(options = {}) {
   return [
-    createCalendarPlugin(),
-    createMailPlugin(options),
     createAgentsPlugin({
       homeDir: options.agentsHomeDir
     }),
-    createNotesPlugin(),
-    createTasksPlugin(),
-    createProjectsPlugin()
+    createNotesPlugin()
   ];
 }
 function folderServerRegistry(options = {}) {
@@ -88794,7 +85928,7 @@ async function folderServerRegistryAsync(options = {}) {
       ...server,
       async detect(context) {
         const detection = await server.detect(context);
-        if (detection.status === "unavailable" && existsSync4(resolve17(context.folder, entry.trigger))) {
+        if (detection.status === "unavailable" && existsSync3(resolve11(context.folder, entry.trigger))) {
           return { status: "available" };
         }
         return detection;
@@ -88804,16 +85938,43 @@ async function folderServerRegistryAsync(options = {}) {
   }
   return registry2;
 }
+function externalApiEntries() {
+  const source = process.env.KENNEL_EXTERNAL_API_ENTRIES;
+  if (!source)
+    return [];
+  const value = JSON.parse(source);
+  if (!Array.isArray(value))
+    throw new Error("Invalid external plugin API config");
+  return value.map((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      throw new Error("Invalid external plugin API config");
+    const item = entry;
+    if (typeof item.id !== "string" || typeof item.module !== "string" || typeof item.symbol !== "string")
+      throw new Error("Invalid external plugin API config");
+    return { id: item.id, module: item.module, symbol: item.symbol };
+  });
+}
+async function externalApiHandlers() {
+  const handlers = [];
+  for (const entry of externalApiEntries()) {
+    const imported = await import(pathToFileURL(entry.module).href);
+    const handler = imported[entry.symbol];
+    if (typeof handler !== "function")
+      throw new Error(`External plugin ${entry.id} did not export API handler ${entry.symbol}`);
+    handlers.push(handler);
+  }
+  return handlers;
+}
 
 // packages/api/src/server/project-discovery.ts
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 
 // packages/api/src/server/linked-folder-discovery.ts
-import { execFile as execFile3 } from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname15, join as join5 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { execFile as execFile2 } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname9, join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
 var script = `
 const local = require(process.argv[1]);
 const { stat } = require('node:fs/promises');
@@ -88830,24 +85991,24 @@ const { stat } = require('node:fs/promises');
 })().catch(error => { console.error(error); process.exitCode = 1; });
 `;
 function resolveLocalModule(from = import.meta.url) {
-  const require2 = createRequire3(from);
+  const require2 = createRequire2(from);
   const candidates = [];
   try {
     candidates.push(require2.resolve("@raggle-ai/local"));
   } catch {}
-  let directory = dirname15(fileURLToPath2(from));
-  while (dirname15(directory) !== directory) {
-    if (existsSync5(join5(directory, "raggle.json"))) {
+  let directory = dirname9(fileURLToPath(from));
+  while (dirname9(directory) !== directory) {
+    if (existsSync4(join4(directory, "raggle.json"))) {
       for (const candidate of [
-        join5(dirname15(directory), "raggle-ai-scout", "packages", "local"),
-        join5(directory, "..", "..", "raggle-ai-scout", "packages", "local")
+        join4(dirname9(directory), "raggle-ai-scout", "packages", "local"),
+        join4(directory, "..", "..", "raggle-ai-scout", "packages", "local")
       ]) {
         if (!candidates.includes(candidate))
           candidates.push(candidate);
       }
       break;
     }
-    directory = dirname15(directory);
+    directory = dirname9(directory);
   }
   for (const candidate of candidates) {
     try {
@@ -88856,11 +86017,11 @@ function resolveLocalModule(from = import.meta.url) {
         return candidate;
     } catch {}
   }
-  return candidates[0] ?? join5(dirname15(fileURLToPath2(from)), "..", "..", "..", "raggle-ai-scout", "packages", "local");
+  return candidates[0] ?? join4(dirname9(fileURLToPath(from)), "..", "..", "..", "raggle-ai-scout", "packages", "local");
 }
 function discoverLinkedFolders(folder2, signal, modulePath = resolveLocalModule()) {
-  return new Promise((resolve18, reject) => {
-    execFile3(process.execPath, ["-e", script, modulePath, folder2], {
+  return new Promise((resolve12, reject) => {
+    execFile2(process.execPath, ["-e", script, modulePath, folder2], {
       signal,
       timeout: 60000,
       maxBuffer: 8 * 1024 * 1024,
@@ -88872,7 +86033,7 @@ function discoverLinkedFolders(folder2, signal, modulePath = resolveLocalModule(
         const folders = JSON.parse(stdout);
         if (!Array.isArray(folders) || !folders.every((path) => typeof path === "string"))
           throw new Error("Invalid linked folder discovery response");
-        resolve18(folders);
+        resolve12(folders);
       } catch (error52) {
         reject(error52);
       }
@@ -88882,7 +86043,7 @@ function discoverLinkedFolders(folder2, signal, modulePath = resolveLocalModule(
 function createLinkedFolderDiscovery(load = discoverLinkedFolders, changed = () => {}) {
   const controller = new AbortController;
   const entries = new Map;
-  let queue2 = Promise.resolve();
+  let queue = Promise.resolve();
   function read(folder2) {
     let entry = entries.get(folder2);
     if (controller.signal.aborted)
@@ -88895,7 +86056,7 @@ function createLinkedFolderDiscovery(load = discoverLinkedFolders, changed = ()
     }
     const current = entry;
     current.state = { folders: current.state.folders, status: "pending" };
-    current.pending = queue2.then(async () => {
+    current.pending = queue.then(async () => {
       if (controller.signal.aborted)
         return;
       try {
@@ -88910,7 +86071,7 @@ function createLinkedFolderDiscovery(load = discoverLinkedFolders, changed = ()
           changed(folder2);
       }
     });
-    queue2 = current.pending;
+    queue = current.pending;
     return current.state;
   }
   return {
@@ -88949,9 +86110,9 @@ local.discoverProjectsUnderFolder({folder}).then(projects => {
     name:p.name ?? basename(p.worktree), relativePath:relative(folder,p.worktree)}))));
 }).catch(error => { console.error(error); process.exitCode = 1; });
 `;
-function discoverProjects2(folder2, signal) {
-  return new Promise((resolve18, reject) => {
-    execFile4(process.execPath, ["-e", script2, resolveLocalModule(), folder2], {
+function discoverProjects(folder2, signal) {
+  return new Promise((resolve12, reject) => {
+    execFile3(process.execPath, ["-e", script2, resolveLocalModule(), folder2], {
       signal,
       timeout: 60000,
       maxBuffer: 8 * 1024 * 1024,
@@ -88960,16 +86121,16 @@ function discoverProjects2(folder2, signal) {
       if (error51)
         return reject(error51);
       try {
-        resolve18(JSON.parse(stdout));
+        resolve12(JSON.parse(stdout));
       } catch (error52) {
         reject(error52);
       }
     });
   });
 }
-function createProjectDiscovery(load = discoverProjects2) {
+function createProjectDiscovery(load = discoverProjects) {
   const jobs = new Map;
-  let queue2 = Promise.resolve();
+  let queue = Promise.resolve();
   let closed = false;
   return {
     read(folder2, signal) {
@@ -88978,21 +86139,21 @@ function createProjectDiscovery(load = discoverProjects2) {
       let job = jobs.get(folder2);
       if (!job) {
         const controller = new AbortController;
-        const promise2 = queue2.then(() => {
+        const promise2 = queue.then(() => {
           controller.signal.throwIfAborted();
           return load(folder2, controller.signal);
         });
         job = { controller, promise: promise2, users: 0 };
         jobs.set(folder2, job);
         const current2 = job;
-        queue2 = promise2.then(() => {}, () => {}).finally(() => {
+        queue = promise2.then(() => {}, () => {}).finally(() => {
           if (jobs.get(folder2) === current2)
             jobs.delete(folder2);
         });
       }
       const current = job;
       current.users++;
-      return new Promise((resolve18, reject) => {
+      return new Promise((resolve12, reject) => {
         let done = false;
         const finish = (error51, value) => {
           if (done)
@@ -89007,7 +86168,7 @@ function createProjectDiscovery(load = discoverProjects2) {
           if (error51)
             reject(error51);
           else
-            resolve18(value);
+            resolve12(value);
         };
         const abort = () => finish(new Error("Discovery cancelled"));
         signal.addEventListener("abort", abort, { once: true });
@@ -89200,13 +86361,13 @@ function skillDescription(content) {
 ---`, 4);
   if (end < 0)
     return;
-  const schema = import_yaml5.parse(content.slice(4, end));
+  const schema = import_yaml4.parse(content.slice(4, end));
   return typeof schema.description === "string" ? schema.description : undefined;
 }
 function skillSource(folder2, root) {
   if (root === folder2)
     return "local";
-  if (root.startsWith(resolve18(folder2, ".gtl") + sep12))
+  if (root.startsWith(resolve12(folder2, ".gtl") + sep7))
     return "local";
   return "global";
 }
@@ -89242,10 +86403,10 @@ var metadataExtensions = new Set([
   ".txt"
 ]);
 function metadataFile(path, root) {
-  const candidate = relative14(root, path);
-  if (!candidate || candidate.startsWith("..") || isAbsolute9(candidate))
+  const candidate = relative10(root, path);
+  if (!candidate || candidate.startsWith("..") || isAbsolute6(candidate))
     return false;
-  const parts = candidate.split(sep12);
+  const parts = candidate.split(sep7);
   if (parts.some((part) => part === "node_modules"))
     return false;
   return metadataExtensions.has(extname6(candidate).toLowerCase());
@@ -89259,18 +86420,18 @@ function label(value) {
   return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").replace(/\b\w/g, (match) => match.toUpperCase());
 }
 function folderPath(value, root, lockedRoot) {
-  const folder2 = realpathSync3(resolve18(value ?? root));
+  const folder2 = realpathSync2(resolve12(value ?? root));
   if (!lockedRoot)
     return folder2;
-  const path = relative14(lockedRoot, folder2);
-  if (!path || !path.startsWith("..") && !isAbsolute9(path))
+  const path = relative10(lockedRoot, folder2);
+  if (!path || !path.startsWith("..") && !isAbsolute6(path))
     return folder2;
   throw new Error(`Folder is outside the viewer root: ${folder2}`);
 }
 function openPathHref(path) {
-  const url3 = new URL("/api/open-path", "http://127.0.0.1");
-  url3.searchParams.set("path", path);
-  return `${url3.pathname}${url3.search}`;
+  const url2 = new URL("/api/open-path", "http://127.0.0.1");
+  url2.searchParams.set("path", path);
+  return `${url2.pathname}${url2.search}`;
 }
 var loopbackServerHosts = new Set([
   "127.0.0.1",
@@ -89319,12 +86480,12 @@ async function searchIconDataUrl(icon2) {
   const mediaType = searchIconTypes.get(extname6(icon2).toLowerCase());
   if (!mediaType)
     return;
-  const details = await stat9(icon2).catch(() => {
+  const details = await stat8(icon2).catch(() => {
     return;
   });
   if (!details?.size || details.size > maxIconBytes3)
     return;
-  return `data:${mediaType};base64,${(await readFile14(icon2)).toString("base64")}`;
+  return `data:${mediaType};base64,${(await readFile9(icon2)).toString("base64")}`;
 }
 async function iconWithFaviconFallback(folder2, assets2, assetFiles) {
   return folderIcon(folder2, assets2, assetFiles, async (folderName) => {
@@ -89362,7 +86523,7 @@ function unique2(values) {
   return [...new Set(values)];
 }
 async function existingDirectory(path) {
-  const details = await stat9(path).catch(() => {
+  const details = await stat8(path).catch(() => {
     return;
   });
   return details?.isDirectory() ? path : undefined;
@@ -89372,7 +86533,7 @@ function metadataPaths(metadata) {
 }
 function ancestorFolders(folder2) {
   const folders = [];
-  for (let current = folder2;dirname16(current) !== current; current = dirname16(current)) {
+  for (let current = folder2;dirname10(current) !== current; current = dirname10(current)) {
     folders.push(current);
   }
   return folders;
@@ -89380,13 +86541,13 @@ function ancestorFolders(folder2) {
 async function linkedSkillRoots(folder2, metadata) {
   const gtlNames = metadataPaths(metadata).map((path) => path.split(/[\\/]\.gtl[\\/]/)[1]).filter((path) => Boolean(path)).map((path) => path.split(/[\\/]/)[0]).filter((name2) => Boolean(name2));
   const gtlRoots = gtlNames.flatMap((name2) => [
-    resolve18(folder2, ".gtl", name2),
-    ...ancestorFolders(folder2).map((ancestor) => resolve18(ancestor, name2))
+    resolve12(folder2, ".gtl", name2),
+    ...ancestorFolders(folder2).map((ancestor) => resolve12(ancestor, name2))
   ]);
   const name = folder2.replace(/[\\/]+$/, "").split(/[\\/]/).at(-1);
   const siblingIndex = name ? [
-    resolve18(dirname16(folder2), `${name}-index`),
-    resolve18(dirname16(dirname16(folder2)), `${name}-index`)
+    resolve12(dirname10(folder2), `${name}-index`),
+    resolve12(dirname10(dirname10(folder2)), `${name}-index`)
   ] : [];
   const roots = await Promise.all(unique2([...gtlRoots, ...siblingIndex]).map(existingDirectory));
   return roots.filter((path) => Boolean(path));
@@ -89394,24 +86555,24 @@ async function linkedSkillRoots(folder2, metadata) {
 async function listFolderSkills(folder2, metadata) {
   const roots = unique2([folder2, ...await linkedSkillRoots(folder2, metadata)]);
   const skills = await Promise.all(roots.map(async (root) => {
-    const skillsFolder = resolve18(root, ".agents", "skills");
-    const entries = await readdir9(skillsFolder, {
+    const skillsFolder = resolve12(root, ".agents", "skills");
+    const entries = await readdir5(skillsFolder, {
       withFileTypes: true
     }).catch(() => []);
     return (await Promise.all(entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map(async (entry) => {
-      const path = resolve18(skillsFolder, entry.name);
-      const skillPath = resolve18(path, "SKILL.md");
-      const details = await stat9(skillPath).catch(() => {
+      const path = resolve12(skillsFolder, entry.name);
+      const skillPath = resolve12(path, "SKILL.md");
+      const details = await stat8(skillPath).catch(() => {
         return;
       });
       if (!details?.isFile())
         return;
-      const content = await readFile14(skillPath, "utf8").catch(() => "");
+      const content = await readFile9(skillPath, "utf8").catch(() => "");
       return {
         description: skillDescription(content),
         name: label(entry.name),
         openHref: openPathHref(path),
-        relativePath: relative14(root, path),
+        relativePath: relative10(root, path),
         source: skillSource(folder2, root)
       };
     }))).filter((skill2) => skill2);
@@ -89419,15 +86580,15 @@ async function listFolderSkills(folder2, metadata) {
   return unique2(skills.flat().map((skill2) => JSON.stringify(skill2))).map((skill2) => JSON.parse(skill2)).sort((left, right) => left.name.localeCompare(right.name));
 }
 function isMachineRoot(folder2) {
-  return folder2 === homedir6() || dirname16(folder2) === folder2;
+  return folder2 === homedir4() || dirname10(folder2) === folder2;
 }
 async function shallowMetadata(folder2) {
-  const entries = await readdir9(folder2, { withFileTypes: true });
+  const entries = await readdir5(folder2, { 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 = resolve18(folder2, entry.name);
-    const details = await stat9(path);
-    const content = await readFile14(path, "utf8").catch(() => "");
+    const path = resolve12(folder2, entry.name);
+    const details = await stat8(path);
+    const content = await readFile9(path, "utf8").catch(() => "");
     const title = markdownMetadata(content).title;
     return {
       activityAt: details.mtimeMs,
@@ -89440,10 +86601,10 @@ async function shallowMetadata(folder2) {
     };
   }));
   const projects = visible.filter((entry) => entry.isDirectory()).map((entry) => ({
-    id: createHash7("sha1").update(resolve18(folder2, entry.name)).digest("hex"),
+    id: createHash5("sha1").update(resolve12(folder2, entry.name)).digest("hex"),
     name: entry.name,
     relativePath: entry.name,
-    worktree: resolve18(folder2, entry.name)
+    worktree: resolve12(folder2, entry.name)
   })).sort((left, right) => left.name.localeCompare(right.name));
   return {
     changes: { items: [] },
@@ -89470,8 +86631,8 @@ async function loadFolderData(folder2) {
       items: projects.map((project2) => ({
         id: project2.id,
         worktree: project2.worktree,
-        name: project2.name ?? basename9(project2.worktree),
-        relativePath: relative14(folder2, project2.worktree)
+        name: project2.name ?? basename7(project2.worktree),
+        relativePath: relative10(folder2, project2.worktree)
       }))
     }
   };
@@ -89479,10 +86640,10 @@ async function loadFolderData(folder2) {
 async function notesFiles(folder2, files, origin) {
   return {
     items: await Promise.all(files.map(async (file3) => {
-      const path = file3.path ?? (file3.relativePath ? resolve18(folder2, file3.relativePath) : undefined);
+      const path = file3.path ?? (file3.relativePath ? resolve12(folder2, file3.relativePath) : undefined);
       if (!path)
         return origin ? { ...file3, folder: origin } : file3;
-      const content = [".markdown", ".md"].includes(extname6(path).toLowerCase()) ? await readFile14(path, "utf8").catch(() => "") : "";
+      const content = [".markdown", ".md"].includes(extname6(path).toLowerCase()) ? await readFile9(path, "utf8").catch(() => "") : "";
       const title = content ? markdownMetadata(content).title : undefined;
       return {
         ...file3,
@@ -89493,9 +86654,9 @@ async function notesFiles(folder2, files, origin) {
     }))
   };
 }
-async function localProjectSearchCache(cache2) {
-  if (cache2 && Date.now() - cache2.loadedAt < projectSearchCacheMs)
-    return cache2;
+async function localProjectSearchCache(cache) {
+  if (cache && Date.now() - cache.loadedAt < projectSearchCacheMs)
+    return cache;
   const settings = readRaggleUserSettings();
   const projects = applyProjectFavorites((await buildProjectCatalog({
     cloneSources: settings.cloneDirectories.map((cloneDirectory) => ({
@@ -89515,16 +86676,16 @@ async function localProjectSearchCache(cache2) {
 function mediaTarget(folder2, file3, lockedTarget) {
   if (!file3)
     return;
-  const rootReal = realpathSync3(resolve18(folder2));
-  const path = resolve18(folder2, file3);
+  const rootReal = realpathSync2(resolve12(folder2));
+  const path = resolve12(folder2, file3);
   let pathReal;
   try {
-    pathReal = realpathSync3(path);
+    pathReal = realpathSync2(path);
   } catch {
     return;
   }
-  const rel = relative14(rootReal, pathReal);
-  if (rel.startsWith("..") || isAbsolute9(rel))
+  const rel = relative10(rootReal, pathReal);
+  if (rel.startsWith("..") || isAbsolute6(rel))
     return;
   if (lockedTarget && pathReal !== lockedTarget)
     return;
@@ -89563,16 +86724,16 @@ function documentError(response) {
 function documentTarget(folder2, file3, lockedTarget) {
   if (!file3)
     return;
-  const rootReal = realpathSync3(resolve18(folder2));
-  const path = resolve18(folder2, file3);
+  const rootReal = realpathSync2(resolve12(folder2));
+  const path = resolve12(folder2, file3);
   let pathReal;
   try {
-    pathReal = realpathSync3(path);
+    pathReal = realpathSync2(path);
   } catch {
     return;
   }
-  const rel = relative14(rootReal, pathReal);
-  if (rel.startsWith("..") || isAbsolute9(rel))
+  const rel = relative10(rootReal, pathReal);
+  if (rel.startsWith("..") || isAbsolute6(rel))
     return;
   if (lockedTarget && pathReal !== lockedTarget)
     return;
@@ -89582,7 +86743,7 @@ function documentTarget(folder2, file3, lockedTarget) {
   return { kind, path: pathReal, root: rootReal };
 }
 function documentEtag(details) {
-  return `"${createHash7("sha256").update(`${details.mtimeMs}:${details.size}`).digest("hex")}"`;
+  return `"${createHash5("sha256").update(`${details.mtimeMs}:${details.size}`).digest("hex")}"`;
 }
 async function projectSearchItem(project2, match) {
   const icon2 = await searchIconDataUrl(project2.icon) ?? await searchIconDataUrl(discoverProjectIcon(project2.worktree));
@@ -89617,14 +86778,14 @@ function parsePluginRegistryConfig(content) {
   };
 }
 async function nearestKennelConfig(folder2) {
-  for (let current = folder2;; current = dirname16(current)) {
-    const candidate = resolve18(current, "kennel.json");
-    const details = await stat9(candidate).catch(() => {
+  for (let current = folder2;; current = dirname10(current)) {
+    const candidate = resolve12(current, "kennel.json");
+    const details = await stat8(candidate).catch(() => {
       return;
     });
     if (details?.isFile())
       return candidate;
-    if (dirname16(current) === current)
+    if (dirname10(current) === current)
       return;
   }
 }
@@ -89633,14 +86794,14 @@ async function folderPluginRegistryConfig(folder2) {
   if (!path)
     return defaultPluginRegistryConfig;
   try {
-    return parsePluginRegistryConfig(await readFile14(path, "utf8"));
+    return parsePluginRegistryConfig(await readFile9(path, "utf8"));
   } catch {
     return defaultPluginRegistryConfig;
   }
 }
 function pluginConfigWarnings(registry2, config2) {
   const ids = unique2([...config2.plugins.disable, ...config2.plugins.order]);
-  return ids.filter((id) => !registry2.has(id)).map((id) => `unknown plugin id "${id}" — not bundled in this build`);
+  return ids.filter((id) => !registry2.has(id)).map((id) => `unknown plugin id "${id}" — not installed in this build`);
 }
 async function pluginAvailability(registry2, folder2, linkedFolders, configWarnings = []) {
   const items2 = [];
@@ -89672,25 +86833,21 @@ function createFolderApi({
   restrictToRoot = false,
   root,
   sessionFinding,
-  mailPreviewer,
-  mailDir,
-  mailos,
   agentsHomeDir,
   linkedFolderLoader,
   remoteAccess = false,
   lockedFile
 }) {
-  let lockedRoot = restrictToRoot ? realpathSync3(root) : undefined;
-  const lockedTarget = lockedFile ? realpathSync3(lockedFile) : undefined;
+  let lockedRoot = restrictToRoot ? realpathSync2(root) : undefined;
+  const lockedTarget = lockedFile ? realpathSync2(lockedFile) : undefined;
   const resolveSession = sessionFinding ?? {
     listFolderSessions,
     readSessionTranscript
   };
   const basePlugins = folderServerRegistryAsync({
-    mailDir,
-    previewer: mailPreviewer,
     agentsHomeDir
   });
+  const baseExternalApiHandlers = externalApiHandlers();
   const assetFiles = new Map;
   let projectSearchCache;
   const projectDiscovery = createProjectDiscovery();
@@ -89714,7 +86871,7 @@ function createFolderApi({
       const serverHost = server.host;
       const remote = remoteAccess || serverHost === true || typeof serverHost === "string" && !isLoopbackServerHost(serverHost);
       if (remote)
-        lockedRoot = lockedRoot ?? realpathSync3(root);
+        lockedRoot = lockedRoot ?? realpathSync2(root);
       const collectionServer = createSchemaCollectionServer(server, {
         boundary: lockedRoot,
         lockedTarget
@@ -89740,7 +86897,7 @@ function createFolderApi({
         if (!folder2)
           return;
         server.emit({
-          data: { path: relative14(folder2, path) },
+          data: { path: relative10(folder2, path) },
           event: "kennel:metadata-changed",
           type: "custom"
         });
@@ -89749,7 +86906,7 @@ function createFolderApi({
         watch2(root);
       server.onChange(refresh);
       server.use(async (request, response, next) => {
-        const url3 = new URL(request.url ?? "/", "http://127.0.0.1");
+        const url2 = new URL(request.url ?? "/", "http://127.0.0.1");
         if (!apiHostAllowed(request.headers.host, remote)) {
           response.writeHead(403, {
             "Content-Type": "text/plain; charset=utf-8"
@@ -89757,10 +86914,10 @@ function createFolderApi({
           response.end("Untrusted Host header");
           return;
         }
-        if (!validateQuery(request, response, url3))
+        if (!validateQuery(request, response, url2))
           return;
-        if (url3.pathname === "/api/capabilities") {
-          sendContract(response, url3, {
+        if (url2.pathname === "/api/capabilities") {
+          sendContract(response, url2, {
             acp: !remote,
             download: true,
             hostActions: remote ? "none" : "local",
@@ -89769,22 +86926,22 @@ function createFolderApi({
           }, { "Cache-Control": "no-store" });
           return;
         }
-        if (url3.pathname === "/api/config") {
-          const folder2 = folderPath(url3.searchParams.get("path"), root, lockedRoot);
-          sendContract(response, url3, { aiInputModule: await configuredAiInputModule(folder2) }, { "Cache-Control": "no-store" });
+        if (url2.pathname === "/api/config") {
+          const folder2 = folderPath(url2.searchParams.get("path"), root, lockedRoot);
+          sendContract(response, url2, { aiInputModule: await configuredAiInputModule(folder2) }, { "Cache-Control": "no-store" });
           return;
         }
-        if (url3.pathname === "/api/health") {
-          sendContract(response, url3, { viewer: viewerName, root, kernelKey: process.env.KENNEL_KERNEL_KEY ?? "core" }, { "Cache-Control": "no-store" });
+        if (url2.pathname === "/api/health") {
+          sendContract(response, url2, { viewer: viewerName, root, kernelKey: process.env.KENNEL_KERNEL_KEY ?? "core" }, { "Cache-Control": "no-store" });
           return;
         }
-        if (url3.pathname === "/api/folder-favicon") {
+        if (url2.pathname === "/api/folder-favicon") {
           const data = await (async () => {
             if (process.env.KENNEL_EXTERNAL_ICONS !== "1")
               return;
-            const folder2 = folderPath(url3.searchParams.get("path"), root, lockedRoot);
+            const folder2 = folderPath(url2.searchParams.get("path"), root, lockedRoot);
             const host = await folderWebsite(folder2);
-            if (!host || host !== url3.searchParams.get("host"))
+            if (!host || host !== url2.searchParams.get("host"))
               return;
             return favicon(host);
           })().catch(() => {
@@ -89798,7 +86955,7 @@ function createFolderApi({
           response.end(data ?? "Icon unavailable");
           return;
         }
-        const assetMatch = /^\/api\/folders\/([^/]+)\/assets\/([a-f0-9]{64})\.(?:jpg|png)$/.exec(url3.pathname);
+        const assetMatch = /^\/api\/folders\/([^/]+)\/assets\/([a-f0-9]{64})\.(?:jpg|png)$/.exec(url2.pathname);
         if (assetMatch) {
           try {
             const [, folderId, hash3] = assetMatch;
@@ -89824,7 +86981,7 @@ function createFolderApi({
               "Content-Type": asset.mediaType,
               ETag: `"${hash3}"`
             });
-            response.end(await readFile14(asset.path));
+            response.end(await readFile9(asset.path));
           } catch (error51) {
             response.writeHead(404, {
               "Content-Type": "text/plain; charset=utf-8"
@@ -89833,19 +86990,19 @@ function createFolderApi({
           }
           return;
         }
-        if (remote && ["/api/project-search", "/api/entities"].includes(url3.pathname)) {
+        if (remote && ["/api/project-search", "/api/entities"].includes(url2.pathname)) {
           response.writeHead(403);
           response.end("Global discovery is disabled for remote access");
           return;
         }
-        if (url3.pathname === "/api/project-search") {
-          const query = url3.searchParams.get("q")?.trim() ?? "";
-          const cache2 = await localProjectSearchCache(projectSearchCache);
-          projectSearchCache = cache2;
-          const result = searchProjectIndex(cache2.index, query, {
+        if (url2.pathname === "/api/project-search") {
+          const query = url2.searchParams.get("q")?.trim() ?? "";
+          const cache = await localProjectSearchCache(projectSearchCache);
+          projectSearchCache = cache;
+          const result = searchProjectIndex(cache.index, query, {
             limit: query ? 40 : 20
           });
-          sendContract(response, url3, {
+          sendContract(response, url2, {
             items: await Promise.all(result.hits.map((hit) => projectSearchItem(hit.project, hit))),
             query,
             scanned: result.scanned,
@@ -89853,10 +87010,10 @@ function createFolderApi({
           }, { "Cache-Control": "no-store" });
           return;
         }
-        if (url3.pathname === "/api/entities") {
+        if (url2.pathname === "/api/entities") {
           try {
-            const workspace2 = await loadEntityWorkspace(url3.searchParams.get("root") ?? undefined, url3.searchParams.get("q") ?? "", url3.searchParams.get("entity"), root);
-            sendContract(response, url3, workspace2, {
+            const workspace2 = await loadEntityWorkspace(url2.searchParams.get("root") ?? undefined, url2.searchParams.get("q") ?? "", url2.searchParams.get("entity"), root);
+            sendContract(response, url2, workspace2, {
               "Cache-Control": "no-store"
             });
           } catch (error51) {
@@ -89867,7 +87024,7 @@ function createFolderApi({
           }
           return;
         }
-        if (url3.pathname === "/api/document/edit") {
+        if (url2.pathname === "/api/document/edit") {
           if (remote) {
             response.writeHead(403, {
               "Content-Type": "text/plain; charset=utf-8"
@@ -89875,51 +87032,51 @@ function createFolderApi({
             response.end("Host actions are disabled for remote access");
             return;
           }
-          await runApiRoute(request, response, url3, documentEditRoute, {
+          await runApiRoute(request, response, url2, documentEditRoute, {
             lockedFile: lockedTarget,
             authorize: (folder2) => folderPath(folder2, root, lockedRoot)
           });
           return;
         }
-        if (url3.pathname === "/api/open-folder") {
+        if (url2.pathname === "/api/open-folder") {
           if (remote || request.method !== "POST" || !sameOrigin(request)) {
             response.writeHead(remote || request.method === "POST" ? 403 : 405);
             response.end("Folder action not allowed");
             return;
           }
-          const folder2 = folderPath(url3.searchParams.get("path"), root, lockedRoot);
+          const folder2 = folderPath(url2.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, [folder2], (error51) => error51 ? fail(error51) : done()));
+          await new Promise((done, fail) => execFile4(command, [folder2], (error51) => error51 ? fail(error51) : done()));
           response.writeHead(204);
           response.end();
           return;
         }
-        if (url3.pathname === "/api/documents") {
-          const folder2 = folderPath(url3.searchParams.get("path"), root, lockedRoot);
-          const target = lockedTarget ? documentTarget(folder2, relative14(folder2, lockedTarget), lockedTarget) : undefined;
+        if (url2.pathname === "/api/documents") {
+          const folder2 = folderPath(url2.searchParams.get("path"), root, lockedRoot);
+          const target = lockedTarget ? documentTarget(folder2, relative10(folder2, lockedTarget), lockedTarget) : undefined;
           const dataset = lockedTarget ? {
             root: folder2,
             documents: target ? [
               {
-                path: relative14(folder2, target.path),
+                path: relative10(folder2, target.path),
                 kind: target.kind,
-                content: previewTextKind(target.kind) ? await readFile14(target.path, "utf8") : ""
+                content: previewTextKind(target.kind) ? await readFile9(target.path, "utf8") : ""
               }
             ] : []
           } : await readFolder(folder2);
           watch2(folder2);
-          sendContract(response, url3, dataset, { "Cache-Control": "no-store" });
+          sendContract(response, url2, dataset, { "Cache-Control": "no-store" });
           return;
         }
-        if (url3.pathname === "/api/document") {
+        if (url2.pathname === "/api/document") {
           try {
-            const folder2 = folderPath(url3.searchParams.get("path"), root, lockedRoot);
-            const target = documentTarget(folder2, url3.searchParams.get("file"), lockedTarget);
+            const folder2 = folderPath(url2.searchParams.get("path"), root, lockedRoot);
+            const target = documentTarget(folder2, url2.searchParams.get("file"), lockedTarget);
             if (!target) {
               documentError(response);
               return;
             }
-            const details = await stat9(target.path);
+            const details = await stat8(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -89931,16 +87088,16 @@ function createFolderApi({
               return;
             }
             watch2(folder2);
-            const content = previewTextKind(target.kind) ? await readFile14(target.path, "utf8") : "";
-            sendContract(response, url3, {
+            const content = previewTextKind(target.kind) ? await readFile9(target.path, "utf8") : "";
+            sendContract(response, url2, {
               content,
               kind: target.kind,
-              path: relative14(target.root, target.path),
+              path: relative10(target.root, target.path),
               root: folder2,
               ...previewTextKind(target.kind) ? {} : {
                 rawUrl: `/api/raw?${new URLSearchParams({
                   path: folder2,
-                  file: relative14(target.root, target.path)
+                  file: relative10(target.root, target.path)
                 })}`
               }
             }, {
@@ -89952,15 +87109,15 @@ function createFolderApi({
           }
           return;
         }
-        if (url3.pathname === "/api/raw") {
+        if (url2.pathname === "/api/raw") {
           try {
-            const folder2 = folderPath(url3.searchParams.get("path"), root, lockedRoot);
-            const target = documentTarget(folder2, url3.searchParams.get("file"), lockedTarget);
+            const folder2 = folderPath(url2.searchParams.get("path"), root, lockedRoot);
+            const target = documentTarget(folder2, url2.searchParams.get("file"), lockedTarget);
             if (!target) {
               documentError(response);
               return;
             }
-            const details = await stat9(target.path);
+            const details = await stat8(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -89973,7 +87130,7 @@ function createFolderApi({
             }
             watch2(folder2);
             const active = target.kind === "html" || target.path.toLowerCase().endsWith(".svg");
-            const download = url3.searchParams.get("download") === "1" || active;
+            const download = url2.searchParams.get("download") === "1" || active;
             const mime = target.kind === "html" ? "application/octet-stream" : previewRawMime(target.path) ?? "application/octet-stream";
             response.writeHead(200, {
               "Cache-Control": "private, max-age=0, must-revalidate",
@@ -89981,24 +87138,24 @@ function createFolderApi({
               ETag: etag,
               "X-Content-Type-Options": "nosniff",
               ...download ? {
-                "Content-Disposition": `attachment; filename="${basename9(target.path)}"`
+                "Content-Disposition": `attachment; filename="${basename7(target.path)}"`
               } : {}
             });
-            response.end(await readFile14(target.path));
+            response.end(await readFile9(target.path));
           } catch (error51) {
             documentError(response);
           }
           return;
         }
-        if (url3.pathname === "/api/media") {
+        if (url2.pathname === "/api/media") {
           try {
-            const folder2 = folderPath(url3.searchParams.get("path"), root, lockedRoot);
-            const target = mediaTarget(folder2, url3.searchParams.get("file"), lockedTarget);
+            const folder2 = folderPath(url2.searchParams.get("path"), root, lockedRoot);
+            const target = mediaTarget(folder2, url2.searchParams.get("file"), lockedTarget);
             if (!target) {
               documentError(response);
               return;
             }
-            const details = await stat9(target.path);
+            const details = await stat8(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -90010,7 +87167,7 @@ function createFolderApi({
               return;
             }
             watch2(folder2);
-            const data = await readFile14(target.path);
+            const data = await readFile9(target.path);
             const baseHeaders = {
               "Accept-Ranges": "bytes",
               "Cache-Control": "private, max-age=0, must-revalidate",
@@ -90047,9 +87204,9 @@ function createFolderApi({
           }
           return;
         }
-        if (url3.pathname === "/api/session") {
+        if (url2.pathname === "/api/session") {
           try {
-            const sessionId = url3.searchParams.get("sessionId");
+            const sessionId = url2.searchParams.get("sessionId");
             if (!sessionId)
               throw new Error("No sessionId parameter");
             const session2 = await resolveSession.readSessionTranscript(sessionId);
@@ -90066,20 +87223,20 @@ function createFolderApi({
           }
           return;
         }
-        const pluginMatch = /^\/api\/plugins\/([^/]+)$/.exec(url3.pathname);
+        const pluginMatch = /^\/api\/plugins\/([^/]+)$/.exec(url2.pathname);
         if (pluginMatch) {
           try {
             const pluginId = pluginMatch[1];
             if (!pluginId)
               throw new Error("Unknown plugin");
-            const folder2 = folderPath(url3.searchParams.get("path"), root, lockedRoot);
+            const folder2 = folderPath(url2.searchParams.get("path"), root, lockedRoot);
             const pluginConfig = await folderPluginRegistryConfig(folder2);
             const plugins2 = configuredFolderServerRegistry(await basePlugins, pluginConfig);
             const plugin2 = plugins2.get(pluginId);
             if (!plugin2)
               throw new Error("Unknown plugin");
             watch2(folder2);
-            const subpath = url3.searchParams.get("subpath") ?? "";
+            const subpath = url2.searchParams.get("subpath") ?? "";
             if (!lockedRoot && !isMachineRoot(folder2) && request.headers["x-kennel-retry-linked"] === "1")
               linkedDiscovery.retry(folder2);
             const discovery = pluginId === "agents" || pluginId === "tasks" ? linkedState(folder2) : undefined;
@@ -90126,21 +87283,15 @@ function createFolderApi({
           }
           return;
         }
-        if (await handleMailApiRoutes(request, response, {
-          authorizeFolder: (value) => folderPath(value, root, lockedRoot),
-          mailDir,
-          mailos,
-          mailPreviewer,
-          watch: watch2
-        }))
-          return;
-        if (await handleTasksApiRoutes(request, response, {
-          authorizeFolder: (value) => folderPath(value, root, lockedRoot),
-          readOnly: remote,
-          watch: watch2
-        }))
-          return;
-        if (url3.pathname === "/api/create-agent-file") {
+        for (const handler of await baseExternalApiHandlers) {
+          if (await handler(request, response, {
+            authorizeFolder: (value) => folderPath(value, root, lockedRoot),
+            readOnly: remote,
+            watch: watch2
+          }))
+            return;
+        }
+        if (url2.pathname === "/api/create-agent-file") {
           if (remote) {
             response.writeHead(403, {
               "Content-Type": "text/plain; charset=utf-8"
@@ -90148,12 +87299,12 @@ function createFolderApi({
             response.end("Host actions are disabled for remote access");
             return;
           }
-          await runApiRoute(request, response, url3, createAgentFileRoute, {
+          await runApiRoute(request, response, url2, createAgentFileRoute, {
             resolve: (value) => folderPath(value, root, lockedRoot)
           });
           return;
         }
-        if (url3.pathname === "/api/open-path") {
+        if (url2.pathname === "/api/open-path") {
           if (remote) {
             response.writeHead(403, {
               "Content-Type": "text/plain; charset=utf-8"
@@ -90161,25 +87312,25 @@ function createFolderApi({
             response.end("Host actions are disabled for remote access");
             return;
           }
-          await runApiRoute(request, response, url3, openPathRoute, {
+          await runApiRoute(request, response, url2, openPathRoute, {
             resolve: (value) => folderPath(value, root, lockedRoot)
           });
           return;
         }
-        if (url3.pathname !== "/api/metadata") {
+        if (url2.pathname !== "/api/metadata") {
           next();
           return;
         }
         try {
-          const part = url3.searchParams.get("part");
-          const folder2 = folderPath(url3.searchParams.get("path"), root, lockedRoot);
+          const part = url2.searchParams.get("part");
+          const folder2 = folderPath(url2.searchParams.get("path"), root, lockedRoot);
           if (lockedTarget && part !== "workspace") {
             if (part === "collections") {
               response.writeHead(404, { "Content-Type": "application/json" });
               response.end(JSON.stringify({ error: "Collection not found" }));
               return;
             }
-            sendContract(response, url3, {
+            sendContract(response, url2, {
               assets: {},
               files: { items: [] },
               folder: folder2,
@@ -90195,30 +87346,30 @@ function createFolderApi({
             workspace2.breadcrumbs = await workspaceBreadcrumbIcons(workspace2.breadcrumbs ?? [], assetFiles);
             const files = [
               workspace2.configPath,
-              resolve18(workspace2.root, "raggle.json")
+              resolve12(workspace2.root, "raggle.json")
             ].filter((path) => Boolean(path));
             for (const path of files)
               contexts.add(path);
             server.watch(files);
-            sendContract(response, url3, { folder: folder2, workspace: workspace2 }, { "Cache-Control": "private, max-age=0, must-revalidate" });
+            sendContract(response, url2, { folder: folder2, workspace: workspace2 }, { "Cache-Control": "private, max-age=0, must-revalidate" });
             return;
           }
           watch2(folder2);
           if (part === "collections") {
-            const sort = url3.searchParams.get("sort");
+            const sort = url2.searchParams.get("sort");
             await collectionServer.handleMetadataPart({
               folder: folder2,
-              id: url3.searchParams.get("id"),
+              id: url2.searchParams.get("id"),
               response,
-              send: (body2, headers) => sendContract(response, url3, body2, headers),
+              send: (body2, headers) => sendContract(response, url2, body2, headers),
               sort: sort === "alpha" || sort === "recent" ? sort : undefined,
-              url: url3
+              url: url2
             });
             return;
           }
           const machine = isMachineRoot(folder2);
           if (part === "notes") {
-            const scope = url3.searchParams.get("notesScope");
+            const scope = url2.searchParams.get("notesScope");
             const localFiles = scope === "linked" ? Promise.resolve({ items: [] }) : (machine ? shallowMetadata(folder2).then((data) => data.files.items) : listLocalMarkdownFiles({ folder: folder2, limit: 200 })).then((files2) => notesFiles(folder2, files2));
             const linkedFiles = async () => {
               if (scope === "local" || machine || lockedRoot)
@@ -90240,7 +87391,7 @@ function createFolderApi({
               localFiles,
               linkedFiles()
             ]);
-            sendContract(response, url3, {
+            sendContract(response, url2, {
               files: {
                 items: [
                   ...files.items,
@@ -90256,14 +87407,14 @@ function createFolderApi({
             const registry2 = await basePlugins;
             const plugins2 = configuredFolderServerRegistry(registry2, pluginConfig);
             const configWarnings = pluginConfigWarnings(registry2, pluginConfig);
-            sendContract(response, url3, {
+            sendContract(response, url2, {
               configWarnings,
               folder: folder2,
               plugins: await pluginAvailability(plugins2, folder2, lockedRoot || isMachineRoot(folder2) ? [] : linkedDiscovery.peek(folder2).folders, configWarnings)
             }, { "Cache-Control": "private, max-age=0, must-revalidate" });
             return;
           }
-          const respond = (body2) => sendContract(response, url3, body2, {
+          const respond = (body2) => sendContract(response, url2, body2, {
             "Cache-Control": "private, max-age=0, must-revalidate"
           });
           if (part === "identity") {
@@ -90349,8 +87500,8 @@ class AcpProcessManager {
     const stderrRing = [];
     let exitResolver;
     let exitCalled = false;
-    const onExit = new Promise((resolve19) => {
-      exitResolver = resolve19;
+    const onExit = new Promise((resolve13) => {
+      exitResolver = resolve13;
     });
     const child = spawn(adapter.command, adapter.args, {
       env: process.env,
@@ -90378,8 +87529,8 @@ class AcpProcessManager {
       exitResolver
     };
     child.stderr.on("data", (chunk) => {
-      const text3 = chunk.toString("utf-8");
-      const lines = text3.split(`
+      const text2 = chunk.toString("utf-8");
+      const lines = text2.split(`
 `);
       for (const line of lines) {
         if (line.length === 0)
@@ -90428,11 +87579,11 @@ class AcpProcessManager {
     if (slot.state === "stopping" || slot.state === "stopped" || slot.state === "errored")
       return;
     slot.state = "stopping";
-    return new Promise((resolve19, reject) => {
-      slot.stopResolver = resolve19;
+    return new Promise((resolve13, reject) => {
+      slot.stopResolver = resolve13;
       const killed = slot.process.kill("SIGTERM");
       if (!killed) {
-        resolve19();
+        resolve13();
         return;
       }
       const escalate = setTimeout(() => {
@@ -92902,17 +90053,17 @@ function isResponseMessage(value) {
 function isNotificationMessage(value) {
   return isJsonRpcEnvelope(value) && !("id" in value) && typeof value["method"] === "string";
 }
-function isRecord3(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
 function isJsonRpcEnvelope(value) {
-  return isRecord3(value) && value["jsonrpc"] === "2.0";
+  return isRecord(value) && value["jsonrpc"] === "2.0";
 }
 function isJsonRpcId(value) {
   return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
 }
 function isResponseShapedMessage(value) {
-  return isRecord3(value) && !("method" in value) && (("id" in value) || ("result" in value) || ("error" in value));
+  return isRecord(value) && !("method" in value) && (("id" in value) || ("result" in value) || ("error" in value));
 }
 function isResponseBatch(batch) {
   let hasValidCall = false;
@@ -92922,7 +90073,7 @@ function isResponseBatch(batch) {
   for (const entry of batch) {
     hasValidCall ||= isRequestMessage(entry) || isNotificationMessage(entry);
     hasValidResponse ||= isResponseMessage(entry);
-    if (!isRecord3(entry)) {
+    if (!isRecord(entry)) {
       continue;
     }
     hasCallShape ||= "method" in entry;
@@ -92937,13 +90088,13 @@ function isResponseBatch(batch) {
   return hasResponseShape && !hasCallShape;
 }
 function cancelRequestId(params) {
-  if (!isRecord3(params) || !isJsonRpcId(params["requestId"])) {
+  if (!isRecord(params) || !isJsonRpcId(params["requestId"])) {
     return;
   }
   return params["requestId"];
 }
 function isErrorResponse(value) {
-  return isRecord3(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
+  return isRecord(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
 }
 var Handled = {
   yes() {
@@ -93225,11 +90376,11 @@ class Connection {
   prepareRequest(method, params, mapResponse, options = {}) {
     const id = this.nextRequestId++;
     let cancel = () => {};
-    const response = new Promise((resolve19, reject) => {
+    const response = new Promise((resolve13, reject) => {
       const pendingResponse = {
         resolve: (value) => {
           try {
-            resolve19(mapResponse ? mapResponse(value) : value);
+            resolve13(mapResponse ? mapResponse(value) : value);
           } catch (error51) {
             reject(error51);
           }
@@ -93280,8 +90431,8 @@ class Connection {
     this.stream = stream;
     this.staticHandlers = handlers;
     this.allowBatches = options?.allowBatches ?? true;
-    this.closedPromise = new Promise((resolve19) => {
-      this.abortController.signal.addEventListener("abort", () => resolve19());
+    this.closedPromise = new Promise((resolve13) => {
+      this.abortController.signal.addEventListener("abort", () => resolve13());
     });
     this.receive();
   }
@@ -93338,7 +90489,7 @@ class Connection {
       this.receiveBatch(message);
       return;
     }
-    if (!isRecord3(message)) {
+    if (!isRecord(message)) {
       console.error("Invalid message", { message });
       return;
     }
@@ -93399,7 +90550,7 @@ class Connection {
     if (this.abortController.signal.aborted) {
       return Promise.resolve();
     }
-    if (!isRecord3(message)) {
+    if (!isRecord(message)) {
       console.error("Invalid message", { message });
       return Promise.resolve();
     }
@@ -93706,7 +90857,7 @@ function ndJsonStream(output, input) {
         if (trimmedLine) {
           try {
             const message = JSON.parse(trimmedLine);
-            if (isRecord3(message) || Array.isArray(message)) {
+            if (isRecord(message) || Array.isArray(message)) {
               controller.enqueue(message);
             } else {
               console.warn("Skipping JSON line that is not an object:", trimmedLine);
@@ -94085,8 +91236,8 @@ class AsyncQueue {
     if (this.failed) {
       return Promise.reject(this.failure);
     }
-    return new Promise((resolve19, reject) => {
-      this.waiters.push({ resolve: resolve19, reject });
+    return new Promise((resolve13, reject) => {
+      this.waiters.push({ resolve: resolve13, reject });
     });
   }
 }
@@ -94639,8 +91790,8 @@ async function bodyJson(request) {
   const raw = Buffer.concat(chunks).toString("utf-8").trim();
   return raw ? JSON.parse(raw) : {};
 }
-function reply(response, status2, body, ct = "application/json; charset=utf-8") {
-  response.writeHead(status2, {
+function reply(response, status, body, ct = "application/json; charset=utf-8") {
+  response.writeHead(status, {
     "Content-Type": ct,
     "Cache-Control": "no-store"
   });
@@ -94742,19 +91893,19 @@ function createAcpApi({
     name: "kennel-acp-live",
     attach(server) {
       server.use(async (request, response, next) => {
-        const url3 = new URL(request.url ?? "/", "http://127.0.0.1");
+        const url2 = new URL(request.url ?? "/", "http://127.0.0.1");
         const method = request.method ?? "GET";
-        if (!url3.pathname.startsWith("/api/acp/"))
+        if (!url2.pathname.startsWith("/api/acp/"))
           return next();
         if (remoteAccess) {
           reply(response, 403, "ACP live sessions are disabled for remote access", "text/plain");
           return;
         }
-        if (url3.pathname.startsWith("/api/acp/") && !loopbackHost(request.headers.host)) {
+        if (url2.pathname.startsWith("/api/acp/") && !loopbackHost(request.headers.host)) {
           reply(response, 403, "Untrusted Host header", "text/plain");
           return;
         }
-        const streamMatch = /^\/api\/acp\/stream\/([a-f0-9-]+)$/.exec(url3.pathname);
+        const streamMatch = /^\/api\/acp\/stream\/([a-f0-9-]+)$/.exec(url2.pathname);
         if (streamMatch?.[1] && method === "GET") {
           const s = sessions.get(streamMatch[1]);
           if (!s)
@@ -94779,7 +91930,7 @@ function createAcpApi({
           });
           return;
         }
-        if (url3.pathname === "/api/acp/connect" && method === "POST") {
+        if (url2.pathname === "/api/acp/connect" && method === "POST") {
           if (guardMutation(request, response))
             return;
           try {
@@ -94795,18 +91946,18 @@ function createAcpApi({
             });
           }
         }
-        if (url3.pathname === "/api/acp/send" && method === "POST") {
+        if (url2.pathname === "/api/acp/send" && method === "POST") {
           if (guardMutation(request, response))
             return;
-          const { sessionId, text: text3 } = await bodyJson(request);
-          if (!sessionId || !text3)
+          const { sessionId, text: text2 } = await bodyJson(request);
+          if (!sessionId || !text2)
             return reply(response, 400, "Missing sessionId or text", "text/plain");
           const s = sessions.get(String(sessionId));
           if (!s?.transport || !s.acpId)
             return reply(response, 404, "Session not found", "text/plain");
           s.transport.agent.request("session/prompt", {
             sessionId: s.acpId,
-            prompt: [{ type: "text", text: text3 }]
+            prompt: [{ type: "text", text: text2 }]
           }).then((result) => {
             const data = result;
             if (data?.content) {
@@ -94840,7 +91991,7 @@ function createAcpApi({
           });
           return reply(response, 202, { accepted: true });
         }
-        if (url3.pathname === "/api/acp/cancel" && method === "POST") {
+        if (url2.pathname === "/api/acp/cancel" && method === "POST") {
           if (guardMutation(request, response))
             return;
           const { sessionId } = await bodyJson(request);
@@ -94853,7 +92004,7 @@ function createAcpApi({
           broadcast(s, { type: "cancelled" });
           return reply(response, 200, { cancelled: true });
         }
-        if (url3.pathname === "/api/acp/disconnect" && method === "POST") {
+        if (url2.pathname === "/api/acp/disconnect" && method === "POST") {
           if (guardMutation(request, response))
             return;
           const { sessionId } = await bodyJson(request);
@@ -94863,7 +92014,7 @@ function createAcpApi({
           await destroySession(s);
           return reply(response, 200, { disconnected: true });
         }
-        if (url3.pathname === "/api/acp/resume" && method === "POST") {
+        if (url2.pathname === "/api/acp/resume" && method === "POST") {
           if (guardMutation(request, response))
             return;
           const { sessionId, resumeId } = await bodyJson(request);
@@ -94884,7 +92035,7 @@ function createAcpApi({
             });
           }
         }
-        if (url3.pathname === "/api/acp/reconnect" && method === "POST") {
+        if (url2.pathname === "/api/acp/reconnect" && method === "POST") {
           if (guardMutation(request, response))
             return;
           const { sessionId } = await bodyJson(request);
@@ -94943,7 +92094,6 @@ data: ${JSON.stringify(event.data)}
     }
   };
   const folder2 = createFolderApi({
-    mailDir: process.env.KENNEL_MAIL_DIR || undefined,
     ...options,
     remoteAccess: remote
   });
@@ -94967,8 +92117,8 @@ data: ${JSON.stringify(event.data)}
         response.end("Untrusted Host header");
         return;
       }
-      const url3 = new URL(request.url ?? "/", "http://localhost");
-      if (url3.pathname === "/api/events") {
+      const url2 = new URL(request.url ?? "/", "http://localhost");
+      if (url2.pathname === "/api/events") {
         if (request.method !== "GET") {
           response.writeHead(405);
           response.end();
@@ -94994,26 +92144,26 @@ data: ${JSON.stringify(event.data)}
         if (!pass)
           return;
       }
-      if (url3.pathname.startsWith("/api/")) {
+      if (url2.pathname.startsWith("/api/")) {
         response.writeHead(404);
         response.end("Unknown API endpoint");
         return;
       }
       if (options.webRoot && (request.method === "GET" || request.method === "HEAD")) {
-        const root = await realpath8(options.webRoot);
-        let target = resolve19(root, `.${decodeURIComponent(url3.pathname)}`);
+        const root = await realpath6(options.webRoot);
+        let target = resolve13(root, `.${decodeURIComponent(url2.pathname)}`);
         const inside5 = (path) => {
-          const local2 = relative15(root, path);
-          return local2 !== ".." && !local2.startsWith("../") && !isAbsolute10(local2);
+          const local2 = relative11(root, path);
+          return local2 !== ".." && !local2.startsWith("../") && !isAbsolute7(local2);
         };
         if (!inside5(target)) {
           response.writeHead(403);
           response.end();
           return;
         }
-        if (!(await stat10(target).catch(() => null))?.isFile())
-          target = resolve19(root, "index.html");
-        target = await realpath8(target);
+        if (!(await stat9(target).catch(() => null))?.isFile())
+          target = resolve13(root, "index.html");
+        target = await realpath6(target);
         if (!inside5(target)) {
           response.writeHead(403);
           response.end();
@@ -95033,7 +92183,7 @@ data: ${JSON.stringify(event.data)}
           "Content-Type": types[extname7(target)] ?? "application/octet-stream",
           "X-Content-Type-Options": "nosniff"
         });
-        response.end(request.method === "HEAD" ? undefined : await readFile15(target));
+        response.end(request.method === "HEAD" ? undefined : await readFile10(target));
         return;
       }
       next();