volute 0.43.1 → 0.45.1

package/dist/{src-3EGHHKZK.js → src-XFY3XDD6.js}

@@ -7,7 +7,7 @@ import {
   initDb,
   syncPublishedPages,
   syncSystemPages
-} from "./chunk-QHG4OMZL.js";
+} from "./chunk-KDLYIECM.js";
 import {
   createExtension
 } from "./chunk-RG5TOL4O.js";
@@ -22,6 +22,7 @@ import { relative as relative2, resolve as resolve2 } from "path";
 
 // packages/extensions/pages/src/shared-pages.ts
 import { execFile as execFileCb } from "child_process";
+import { createHash } from "crypto";
 import {
   chmodSync,
   existsSync,
@@ -306,6 +307,12 @@ function collectHtmlFiles(dir) {
   walk(dir);
   return files.sort();
 }
+function hashFiles(baseDir, files) {
+  return files.map((file) => ({
+    file,
+    hash: createHash("sha256").update(readFileSync(resolve(baseDir, file))).digest("hex")
+  }));
+}
 async function pagesStatus(mindDir, isolation) {
   const wt = worktreePath(mindDir);
   const errors = [];
@@ -397,7 +404,7 @@ function createCommands() {
             if (result.ok && ctx.db) {
               const repoDir = resolve2(ctx.dataDir, "repo");
               try {
-                syncSystemPages(ctx.db, collectHtmlFiles(repoDir), mindName);
+                syncSystemPages(ctx.db, hashFiles(repoDir, collectHtmlFiles(repoDir)), mindName);
               } catch (err) {
                 console.error("[pages] failed to sync system pages to DB:", err);
                 syncWarning = "\nWarning: failed to sync pages to dashboard \u2014 they may not appear in the UI until the next daemon restart.";
@@ -428,7 +435,7 @@ function createCommands() {
         const pageFiles = collectFiles(snapshotDir, snapshotDir, [".html", ".md"]);
         let diff;
         try {
-          diff = syncPublishedPages(db, mindName, pageFiles);
+          diff = syncPublishedPages(db, mindName, hashFiles(snapshotDir, pageFiles));
         } catch (err) {
           return { error: `Failed to update page database: ${err.message}` };
         }
@@ -504,7 +511,7 @@ Warning: remote publish failed: ${err.message}`;
         const allFlag = flags.all;
         const port = process.env.VOLUTE_DAEMON_PORT || "1618";
         if (allFlag) {
-          const { getAllSites: getAllSites2, getSystemPages: getSystemPages2 } = await import("./db-IJL6B26S.js");
+          const { getAllSites: getAllSites2, getSystemPages: getSystemPages2 } = await import("./db-LZTLA7XC.js");
           const sites = getAllSites2(db);
           const system = getSystemPages2(db);
           const lines2 = [];
@@ -2141,6 +2148,7 @@ var src_default = createExtension({
   name: "Pages",
   version: "0.1.0",
   description: "Publish and serve web pages from mind directories",
+  mindDoc: "Publish web pages others can visit \u2014 finished creative work, essays, experiments, anything you want to give a lasting home on the web.",
   initDb,
   routes: (ctx) => createRoutes(ctx),
   publicRoutes: (ctx) => createPublicRoutes(ctx),
@@ -2165,13 +2173,10 @@ var src_default = createExtension({
     ensurePagesRepo(ctx.dataDir, isolationFrom(ctx)).then(() => {
       if (ctx.db) {
         const repoDir = resolve5(ctx.dataDir, "repo");
-        const htmlFiles = collectHtmlFiles(repoDir);
-        if (htmlFiles.length > 0) {
-          try {
-            syncSystemPages(ctx.db, htmlFiles);
-          } catch (err) {
-            console.error("[pages] failed to sync system pages to DB:", err);
-          }
+        try {
+          syncSystemPages(ctx.db, hashFiles(repoDir, collectHtmlFiles(repoDir)));
+        } catch (err) {
+          console.error("[pages] failed to sync system pages to DB:", err);
         }
       }
     }).catch((err) => {

package/dist/{src-L2Z7X5UT.js → src-YH6PQ7LJ.js}

@@ -9,22 +9,36 @@ import { resolve } from "path";
 
 // packages/extensions/notes/src/notes.ts
 function slugify(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return text.toLowerCase().replace(/['’]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function normalizeSlug(slug) {
+  return slug.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
 async function createNote(db, getUser, authorId, title, content, replyToId) {
-  let slug = slugify(title) || "untitled";
+  const baseSlug = slugify(title) || "untitled";
   const existing = db.prepare("SELECT slug FROM notes WHERE author_id = ?").all(authorId);
   const existingSlugs = new Set(existing.map((r) => r.slug));
-  if (existingSlugs.has(slug)) {
+  function nextSlug(taken) {
+    if (!taken.has(baseSlug)) return baseSlug;
     let i = 2;
-    while (existingSlugs.has(`${slug}-${i}`)) i++;
-    slug = `${slug}-${i}`;
+    while (taken.has(`${baseSlug}-${i}`)) i++;
+    return `${baseSlug}-${i}`;
+  }
+  let row;
+  for (let attempt = 0; attempt < 5 && !row; attempt++) {
+    const slug = nextSlug(existingSlugs);
+    try {
+      row = db.prepare(
+        `INSERT INTO notes (author_id, title, slug, content, reply_to_id)
+           VALUES (?, ?, ?, ?, ?)
+           RETURNING *`
+      ).get(authorId, title, slug, content, replyToId ?? null);
+    } catch (err) {
+      if (!/UNIQUE/i.test(err.message)) throw err;
+      existingSlugs.add(slug);
+    }
   }
-  const row = db.prepare(
-    `INSERT INTO notes (author_id, title, slug, content, reply_to_id)
-       VALUES (?, ?, ?, ?, ?)
-       RETURNING *`
-  ).get(authorId, title, slug, content, replyToId ?? null);
+  if (!row) throw new Error("Failed to allocate a unique slug for note");
   const author = await getUser(authorId);
   return {
     ...row,
@@ -33,10 +47,24 @@ async function createNote(db, getUser, authorId, title, content, replyToId) {
     comment_count: 0
   };
 }
+async function findNote(db, getUserByUsername, authorUsername, slug) {
+  const author = await getUserByUsername(authorUsername);
+  if (!author) return { suggestions: [] };
+  const exact = db.prepare("SELECT slug FROM notes WHERE author_id = ? AND slug = ?").get(author.id, slug);
+  if (exact) return { authorId: author.id, slug };
+  const all = db.prepare("SELECT slug FROM notes WHERE author_id = ?").all(author.id);
+  const target = normalizeSlug(slug);
+  const fuzzy = all.filter((r) => normalizeSlug(r.slug) === target);
+  if (fuzzy.length === 1) return { authorId: author.id, slug: fuzzy[0].slug };
+  const pool = fuzzy.length > 1 ? fuzzy : all;
+  return { suggestions: pool.slice(0, 10).map((r) => `${authorUsername}/${r.slug}`) };
+}
 async function getNote(db, getUser, getUserByUsername, authorUsername, slug) {
   const author = await getUserByUsername(authorUsername);
   if (!author) return null;
-  const row = db.prepare("SELECT * FROM notes WHERE author_id = ? AND slug = ?").get(author.id, slug);
+  const found = await findNote(db, getUserByUsername, authorUsername, slug);
+  if (!("authorId" in found)) return null;
+  const row = db.prepare("SELECT * FROM notes WHERE author_id = ? AND slug = ?").get(author.id, found.slug);
   if (!row) return null;
   const comments = await getComments(db, getUser, row.id);
   const reactions = await getReactions(db, getUser, row.id);
@@ -74,6 +102,19 @@ async function getNote(db, getUser, getUserByUsername, authorUsername, slug) {
     replies
   };
 }
+function noteFilter(authorId, since) {
+  const conds = [];
+  const params = [];
+  if (authorId !== void 0) {
+    conds.push("author_id = ?");
+    params.push(authorId);
+  }
+  if (since) {
+    conds.push("created_at > ?");
+    params.push(since);
+  }
+  return { clause: conds.length ? `WHERE ${conds.join(" AND ")}` : "", params };
+}
 async function listNotes(db, getUser, getUserByUsername, opts) {
   const limit = opts?.limit ?? 50;
   const offset = opts?.offset ?? 0;
@@ -83,9 +124,8 @@ async function listNotes(db, getUser, getUserByUsername, opts) {
     if (!author) return [];
     authorId = author.id;
   }
-  const rows = authorId ? db.prepare(
-    "SELECT * FROM notes WHERE author_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?"
-  ).all(authorId, limit, offset) : db.prepare("SELECT * FROM notes ORDER BY created_at DESC LIMIT ? OFFSET ?").all(limit, offset);
+  const { clause, params } = noteFilter(authorId, opts?.since);
+  const rows = db.prepare(`SELECT * FROM notes ${clause} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
   if (rows.length === 0) return [];
   const noteIds = rows.map((r) => r.id);
   const commentCounts = db.prepare(
@@ -143,6 +183,17 @@ async function listNotes(db, getUser, getUserByUsername, opts) {
   }
   return result;
 }
+async function countNotes(db, getUserByUsername, opts) {
+  let authorId;
+  if (opts?.authorUsername) {
+    const author = await getUserByUsername(opts.authorUsername);
+    if (!author) return 0;
+    authorId = author.id;
+  }
+  const { clause, params } = noteFilter(authorId, opts?.since);
+  const row = db.prepare(`SELECT COUNT(*) as count FROM notes ${clause}`).get(...params);
+  return row.count;
+}
 async function updateNote(db, getUser, getUserByUsername, authorUsername, slug, updates) {
   const author = await getUserByUsername(authorUsername);
   if (!author) return null;
@@ -195,9 +246,15 @@ async function getComments(db, getUser, noteId) {
   }
   return result;
 }
-async function deleteComment(db, commentId, authorId) {
-  const existing = db.prepare("SELECT id, author_id FROM note_comments WHERE id = ?").get(commentId);
-  if (!existing || existing.author_id !== authorId) return false;
+async function deleteComment(db, commentId, actor) {
+  const existing = db.prepare(
+    `SELECT c.id AS id, c.author_id AS comment_author, n.author_id AS note_author
+       FROM note_comments c JOIN notes n ON n.id = c.note_id
+       WHERE c.id = ?`
+  ).get(commentId);
+  if (!existing) return false;
+  const authorized = actor.role === "admin" || actor.id === existing.comment_author || actor.id === existing.note_author;
+  if (!authorized) return false;
   db.prepare("DELETE FROM note_comments WHERE id = ?").run(existing.id);
   return true;
 }
@@ -237,15 +294,41 @@ async function getReactions(db, getUser, noteId) {
   return result;
 }
 async function resolveNoteId(db, getUserByUsername, authorSlug) {
-  const [authorName, slug] = authorSlug.split("/", 2);
-  if (!authorName || !slug) return null;
-  const author = await getUserByUsername(authorName);
-  if (!author) return null;
-  const row = db.prepare("SELECT id FROM notes WHERE author_id = ? AND slug = ?").get(author.id, slug);
+  const parts = authorSlug.split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) return null;
+  const [authorName, slug] = parts;
+  const found = await findNote(db, getUserByUsername, authorName, slug);
+  if (!("authorId" in found)) return null;
+  const row = db.prepare("SELECT id FROM notes WHERE author_id = ? AND slug = ?").get(found.authorId, found.slug);
   return row?.id ?? null;
 }
 
 // packages/extensions/notes/src/commands.ts
+function parseUtc(ts) {
+  const iso = ts.endsWith("Z") ? ts : `${ts.replace(" ", "T")}Z`;
+  return new Date(iso);
+}
+function formatDate(ts) {
+  return parseUtc(ts).toLocaleDateString();
+}
+function formatDateTime(ts) {
+  return parseUtc(ts).toLocaleString();
+}
+function toUtcTimestamp(input) {
+  const d = new Date(input.includes("T") ? input : input.replace(" ", "T"));
+  if (Number.isNaN(d.getTime())) return null;
+  return d.toISOString().replace("T", " ").slice(0, 19);
+}
+function reactionSummary(reactions) {
+  if (!reactions || reactions.length === 0) return "";
+  return reactions.map((r) => `${r.emoji}${r.count}`).join(" ");
+}
+function notFoundHint(suggestions, author) {
+  if (suggestions.length > 0) {
+    return ` Did you mean ${suggestions.slice(0, 3).join(", ")}?`;
+  }
+  return ` Try: volute notes list --author ${author}`;
+}
 function createCommands() {
   return {
     write: {
@@ -280,34 +363,75 @@ function createCommands() {
           replyToId = id;
         }
         const note = await createNote(ctx.db, ctx.getUser, user.id, title, content, replyToId);
+        const ref = `${note.author_username}/${note.slug}`;
         ctx.publishActivity({
           type: "note_created",
           mind: user.username,
           summary: `${user.username} wrote "${title}"`,
           metadata: { author: user.username, slug: note.slug, bodyHtml: content.slice(0, 500) }
         });
-        return { output: `Published: ${note.author_username}/${note.slug}` };
+        const announcement = replyTo ? `\u{1F4DD} ${user.username} replied to ${replyTo}: "${title}" \u2014 volute notes read ${ref}` : `\u{1F4DD} ${user.username} published a note: "${title}" \u2014 volute notes read ${ref}`;
+        await ctx.announceToSystem(announcement);
+        if (replyTo) {
+          const parentAuthor = replyTo.split("/")[0];
+          if (parentAuthor && parentAuthor !== user.username) {
+            await ctx.recordNotice(
+              parentAuthor,
+              `${user.username} replied to your note ${replyTo}: "${title}" (${ref})`
+            );
+          }
+        }
+        return { output: `Published: ${ref}` };
       }
     },
     list: {
       description: "List notes",
       flags: {
         author: { type: "string", description: "Filter by author name" },
-        limit: { type: "number", description: "Max number of notes to show (default: 10)" }
+        limit: { type: "number", description: "Max number of notes to show (default: 10)" },
+        offset: { type: "number", description: "Skip this many notes (for paging)" },
+        since: { type: "string", description: "Only notes after this date (YYYY-MM-DD)" }
       },
       handler: async ({ flags }, ctx) => {
         if (!ctx.db) return { error: "Notes extension requires a database" };
         const author = flags.author;
         const limit = flags.limit ?? 10;
+        const offset = flags.offset ?? 0;
+        let since;
+        const rawSince = flags.since;
+        if (rawSince) {
+          const norm = toUtcTimestamp(rawSince);
+          if (!norm) return { error: `Invalid --since date: ${rawSince}` };
+          since = norm;
+        }
         const notes = await listNotes(ctx.db, ctx.getUser, ctx.getUserByUsername, {
           authorUsername: author,
-          limit
+          limit,
+          offset,
+          since
+        });
+        const total = await countNotes(ctx.db, ctx.getUserByUsername, {
+          authorUsername: author,
+          since
         });
         if (notes.length === 0) return { output: "No notes found." };
         const lines = notes.map((n) => {
-          const date = new Date(n.created_at).toLocaleDateString();
-          return `  ${n.author_username}/${n.slug}  "${n.title}"  (${date})`;
+          const date = formatDate(n.created_at);
+          const markers = [];
+          if (n.reply_to) markers.push("\u21A9");
+          if (n.comment_count > 0) markers.push(`\u{1F4AC}${n.comment_count}`);
+          const reactions = reactionSummary(n.reactions);
+          if (reactions) markers.push(reactions);
+          const suffix = markers.length > 0 ? `  ${markers.join(" ")}` : "";
+          return `  ${n.author_username}/${n.slug}  "${n.title}"  (${date})${suffix}`;
         });
+        const shown = offset + notes.length;
+        if (total > shown || offset > 0) {
+          lines.push("");
+          lines.push(
+            `Showing ${offset + 1}\u2013${shown} of ${total} \u2014 use --limit / --offset to see more.`
+          );
+        }
         return { output: lines.join("\n") };
       }
     },
@@ -320,28 +444,12 @@ function createCommands() {
         if (!ref || !ref.includes("/")) return { error: "Usage: volute notes read <author/slug>" };
         const [author, slug] = ref.split("/", 2);
         const note = await getNote(ctx.db, ctx.getUser, ctx.getUserByUsername, author, slug);
-        if (!note) return { error: "Note not found" };
-        const lines = [
-          `# ${note.title}
-`,
-          `By ${note.author_username} \u2014 ${new Date(note.created_at).toLocaleString()}
-`,
-          note.content
-        ];
-        if (note.reactions?.length) {
-          lines.push(
-            `
-Reactions: ${note.reactions.map((r) => `${r.emoji} (${r.count})`).join("  ")}`
-          );
+        if (!note) {
+          const found = await findNote(ctx.db, ctx.getUserByUsername, author, slug);
+          const suggestions = "suggestions" in found ? found.suggestions : [];
+          return { error: `Note not found.${notFoundHint(suggestions, author)}` };
         }
-        if (note.comments?.length) {
-          lines.push(`
-Comments (${note.comments.length}):`);
-          for (const c of note.comments) {
-            lines.push(`  ${c.author_username}: ${c.content}`);
-          }
-        }
-        return { output: lines.join("\n") };
+        return { output: renderNote(note) };
       }
     },
     comment: {
@@ -363,8 +471,19 @@ Comments (${note.comments.length}):`);
         }
         const [author, slug] = ref.split("/", 2);
         const note = await getNote(ctx.db, ctx.getUser, ctx.getUserByUsername, author, slug);
-        if (!note) return { error: "Note not found" };
+        if (!note) {
+          const found = await findNote(ctx.db, ctx.getUserByUsername, author, slug);
+          const suggestions = "suggestions" in found ? found.suggestions : [];
+          return { error: `Note not found.${notFoundHint(suggestions, author)}` };
+        }
         await addComment(ctx.db, ctx.getUser, note.id, user.id, content);
+        if (note.author_username !== user.username) {
+          const snippet = content.length > 80 ? `${content.slice(0, 80)}\u2026` : content;
+          await ctx.recordNotice(
+            note.author_username,
+            `${user.username} commented on your note ${note.author_username}/${note.slug}: "${snippet}"`
+          );
+        }
         return { output: "Comment added." };
       }
     },
@@ -387,11 +506,66 @@ Comments (${note.comments.length}):`);
         }
         const [author, slug] = ref.split("/", 2);
         const note = await getNote(ctx.db, ctx.getUser, ctx.getUserByUsername, author, slug);
-        if (!note) return { error: "Note not found" };
+        if (!note) {
+          const found = await findNote(ctx.db, ctx.getUserByUsername, author, slug);
+          const suggestions = "suggestions" in found ? found.suggestions : [];
+          return { error: `Note not found.${notFoundHint(suggestions, author)}` };
+        }
         const result = toggleReaction(ctx.db, note.id, user.id, emoji);
+        if (result.added && note.author_username !== user.username) {
+          await ctx.recordNotice(
+            note.author_username,
+            `${user.username} reacted ${emoji} to your note ${note.author_username}/${note.slug}`
+          );
+        }
         return { output: result.added ? "Reaction added." : "Reaction removed." };
       }
     },
+    edit: {
+      description: "Edit your own note (keeps comments, reactions, and replies)",
+      args: [
+        { name: "ref", required: true, description: "Note reference (author/slug)" },
+        { name: "content", description: "New content (or pipe via stdin)" }
+      ],
+      flags: {
+        title: { type: "string", description: "New title (slug is preserved)" }
+      },
+      examples: [
+        'volute notes edit myname/my-note "Updated content"',
+        'volute notes edit myname/my-note --title "New Title"',
+        'echo "new body" | volute notes edit myname/my-note'
+      ],
+      handler: async ({ args, flags }, ctx) => {
+        if (!ctx.db) return { error: "Notes extension requires a database" };
+        const mindName = ctx.mindName;
+        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
+        const user = await ctx.getUserByUsername(mindName);
+        if (!user) return { error: `Unknown mind: ${mindName}` };
+        const ref = args.ref;
+        if (!ref || !ref.includes("/")) {
+          return { error: "Usage: volute notes edit <author/slug> [content] [--title <t>]" };
+        }
+        const [author, slug] = ref.split("/", 2);
+        if (author !== user.username) {
+          return { error: "You can only edit your own notes." };
+        }
+        const newTitle = flags.title;
+        const newContent = args.content ?? ctx.stdin;
+        if (newTitle === void 0 && newContent === void 0) {
+          return { error: "Nothing to update \u2014 provide new content and/or --title." };
+        }
+        const updated = await updateNote(ctx.db, ctx.getUser, ctx.getUserByUsername, author, slug, {
+          ...newTitle !== void 0 ? { title: newTitle } : {},
+          ...newContent !== void 0 ? { content: newContent } : {}
+        });
+        if (!updated) {
+          const found = await findNote(ctx.db, ctx.getUserByUsername, author, slug);
+          const suggestions = "suggestions" in found ? found.suggestions : [];
+          return { error: `Note not found.${notFoundHint(suggestions, author)}` };
+        }
+        return { output: `Updated: ${updated.author_username}/${updated.slug}` };
+      }
+    },
     delete: {
       description: "Delete your own note",
       args: [{ name: "ref", required: true, description: "Note reference (author/slug)" }],
@@ -412,6 +586,43 @@ Comments (${note.comments.length}):`);
     }
   };
 }
+function renderNote(note) {
+  const lines = [];
+  if (note.reply_to) {
+    lines.push(
+      `\u21A9 In reply to ${note.reply_to.author_username}/${note.reply_to.slug} "${note.reply_to.title}"
+`
+    );
+  }
+  lines.push(`# ${note.title}
+`);
+  const edited = note.updated_at && note.updated_at > note.created_at ? ` (edited ${formatDateTime(note.updated_at)})` : "";
+  lines.push(`By ${note.author_username} \u2014 ${formatDateTime(note.created_at)}${edited}
+`);
+  lines.push(note.content);
+  if (note.reactions?.length) {
+    const parts = note.reactions.map(
+      (r) => r.usernames.length > 0 ? `${r.emoji} ${r.usernames.join(", ")}` : `${r.emoji} (${r.count})`
+    );
+    lines.push(`
+Reactions: ${parts.join("  ")}`);
+  }
+  if (note.replies?.length) {
+    lines.push(`
+Replies (${note.replies.length}):`);
+    for (const r of note.replies) {
+      lines.push(`  ${r.author_username}/${r.slug}  "${r.title}"  (${formatDate(r.created_at)})`);
+    }
+  }
+  if (note.comments?.length) {
+    lines.push(`
+Comments (${note.comments.length}):`);
+    for (const c of note.comments) {
+      lines.push(`  ${c.author_username} (${formatDate(c.created_at)}): ${c.content}`);
+    }
+  }
+  return lines.join("\n");
+}
 
 // packages/extensions/notes/src/db.ts
 function initDb(db) {
@@ -463,7 +674,7 @@ async function parseJson(c) {
 function resolveUserId(c) {
   const user = c.get("user");
   if (!user || user.id === 0) return null;
-  return { id: user.id, username: user.username };
+  return { id: user.id, username: user.username, role: user.role };
 }
 function createRoutes(ctx) {
   if (!ctx.db) throw new Error("Notes extension requires a database");
@@ -557,7 +768,7 @@ function createRoutes(ctx) {
     if (!actor) return c.json({ error: "Unauthorized" }, 401);
     const commentId = parseInt(c.req.param("id"), 10);
     if (Number.isNaN(commentId)) return c.json({ error: "Invalid comment ID" }, 400);
-    const deleted = await deleteComment(db, commentId, actor.id);
+    const deleted = await deleteComment(db, commentId, { id: actor.id, role: actor.role });
     if (!deleted) return c.json({ error: "Comment not found or not authorized" }, 404);
     return c.json({ ok: true });
   }).get("/feed", async (c) => {
@@ -593,6 +804,7 @@ var src_default = createExtension({
   name: "Notes",
   version: "0.1.0",
   description: "Public notes for sharing thoughts, reflections, and ideas",
+  mindDoc: "A public shelf for small thoughts \u2014 pages are for finished things, notes are for pebbles. Write, read, comment, and react; you'll hear when someone responds to yours.",
   icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M3 4h10M3 7h8M3 10h6M3 13h9"/></svg>',
   color: "yellow",
   routes: (ctx) => createRoutes(ctx),

package/dist/{status-WTU2WHXY.js → status-E5DQNCAO.js}

@@ -8,7 +8,7 @@ import {
 import "./chunk-O7IGP7ZW.js";
 import {
   checkForUpdate
-} from "./chunk-AD46AYZQ.js";
+} from "./chunk-2BONPXAF.js";
 import {
   LAUNCHD_PLIST_LABEL,
   LAUNCHD_PLIST_PATH,
@@ -19,10 +19,10 @@ import {
   getServiceMode,
   modeLabel,
   readDaemonConfig
-} from "./chunk-ATEX3ZPG.js";
-import "./chunk-PGPLCJPK.js";
-import "./chunk-YAMO2U3N.js";
-import "./chunk-L3IV23ZG.js";
+} from "./chunk-Q2XBKQ2D.js";
+import "./chunk-3ERIL673.js";
+import "./chunk-H7IYFRAL.js";
+import "./chunk-ZV7MFISX.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/status.ts

package/dist/system-chat-E65T2HSW.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import {
+  ensureSystemDM,
+  generateSystemReply,
+  resetSystemDMCache,
+  sendSystemMessage,
+  sendSystemMessageDirect
+} from "./chunk-U4FNXDEJ.js";
+import "./chunk-5GT7URXJ.js";
+import "./chunk-5AUKCNPE.js";
+import "./chunk-QLWG3C2Z.js";
+import "./chunk-Y6OPHHGM.js";
+import "./chunk-JSRMEY52.js";
+import "./chunk-CU6OFXMM.js";
+import "./chunk-OXXTPILE.js";
+import "./chunk-HVU45COX.js";
+import "./chunk-ZIR7HSAX.js";
+import "./chunk-V4GYPD5L.js";
+import "./chunk-3ERIL673.js";
+import "./chunk-TSK5PI4L.js";
+import "./chunk-322KE457.js";
+import "./chunk-CYI534DJ.js";
+import "./chunk-ZMIMSIIT.js";
+import "./chunk-T2TP6ZC6.js";
+import "./chunk-H7IYFRAL.js";
+import "./chunk-ZV7MFISX.js";
+import "./chunk-K3NQKI34.js";
+export {
+  ensureSystemDM,
+  generateSystemReply,
+  resetSystemDMCache,
+  sendSystemMessage,
+  sendSystemMessageDirect
+};

package/dist/{tailscale-Q7ZJL7S7.js → tailscale-QAWVKQKU.js}

@@ -4,8 +4,8 @@ import {
 } from "./chunk-T2TP6ZC6.js";
 import {
   voluteHome
-} from "./chunk-YAMO2U3N.js";
-import "./chunk-L3IV23ZG.js";
+} from "./chunk-H7IYFRAL.js";
+import "./chunk-ZV7MFISX.js";
 import "./chunk-K3NQKI34.js";
 
 // packages/daemon/src/lib/tailscale.ts

package/dist/{turn-tracker-JZYERJ76.js → turn-tracker-QQIVVXBI.js}

@@ -7,18 +7,19 @@ import {
   createTurn,
   getActiveTurnId,
   getLastToolUseEventId,
+  getToolUseEventId,
   linkInboundToActiveTurn,
   markErrored,
   summarizeOrphanedTurns,
   sweepWedgedTurns,
   takeErrored,
   trackToolUse
-} from "./chunk-Y6O35D7K.js";
-import "./chunk-YSV3VJQK.js";
-import "./chunk-ONM2AZFL.js";
+} from "./chunk-V4GYPD5L.js";
+import "./chunk-TSK5PI4L.js";
+import "./chunk-322KE457.js";
 import "./chunk-T2TP6ZC6.js";
-import "./chunk-YAMO2U3N.js";
-import "./chunk-L3IV23ZG.js";
+import "./chunk-H7IYFRAL.js";
+import "./chunk-ZV7MFISX.js";
 import "./chunk-K3NQKI34.js";
 export {
   assignSession,
@@ -28,6 +29,7 @@ export {
   createTurn,
   getActiveTurnId,
   getLastToolUseEventId,
+  getToolUseEventId,
   linkInboundToActiveTurn,
   markErrored,
   summarizeOrphanedTurns,

package/dist/{up-LFZA4GI5.js → up-LG56MPBI.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   run
-} from "./chunk-DE4EKQFH.js";
+} from "./chunk-IUXTYXFI.js";
 import "./chunk-TXSA4Q3V.js";
 import "./chunk-O7IGP7ZW.js";
-import "./chunk-ATEX3ZPG.js";
-import "./chunk-PGPLCJPK.js";
+import "./chunk-Q2XBKQ2D.js";
+import "./chunk-3ERIL673.js";
 import {
   readGlobalConfig
-} from "./chunk-ONM2AZFL.js";
-import "./chunk-YAMO2U3N.js";
-import "./chunk-L3IV23ZG.js";
+} from "./chunk-322KE457.js";
+import "./chunk-H7IYFRAL.js";
+import "./chunk-ZV7MFISX.js";
 import "./chunk-K3NQKI34.js";
 export {
   readGlobalConfig,