volute 0.43.0 → 0.44.0

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-4DQZOEZI.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import {
+  ensureSystemDM,
+  generateSystemReply,
+  resetSystemDMCache,
+  sendSystemMessage,
+  sendSystemMessageDirect
+} from "./chunk-OMETFX5H.js";
+import "./chunk-5GT7URXJ.js";
+import "./chunk-7FT24JBQ.js";
+import "./chunk-QLWG3C2Z.js";
+import "./chunk-I2Y2YHIO.js";
+import "./chunk-FZMEVCWC.js";
+import "./chunk-CU6OFXMM.js";
+import "./chunk-3GYVW2X3.js";
+import "./chunk-HVU45COX.js";
+import "./chunk-5AHYQHNT.js";
+import "./chunk-NF75HPNR.js";
+import "./chunk-3ERIL673.js";
+import "./chunk-J47TIYHA.js";
+import "./chunk-PNV24SEP.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-2GMKJQTN.js → turn-tracker-RWZMY7M6.js}

@@ -13,12 +13,12 @@ import {
   sweepWedgedTurns,
   takeErrored,
   trackToolUse
-} from "./chunk-3WLWKOGM.js";
-import "./chunk-YSV3VJQK.js";
-import "./chunk-ONM2AZFL.js";
+} from "./chunk-NF75HPNR.js";
+import "./chunk-J47TIYHA.js";
+import "./chunk-PNV24SEP.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,

package/dist/{up-7RSBEKW6.js → up-FLCDR2UB.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   run
-} from "./chunk-ZO7IQJKO.js";
+} from "./chunk-7KWANSLX.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-PNV24SEP.js";
+import "./chunk-H7IYFRAL.js";
+import "./chunk-ZV7MFISX.js";
 import "./chunk-K3NQKI34.js";
 export {
   readGlobalConfig,

package/dist/{update-EJ7Q77ZX.js → update-7TYVH5FM.js}

@@ -7,23 +7,23 @@ import {
   checkForUpdate,
   getResolvedVersion,
   resolveVoluteInstall
-} from "./chunk-AD46AYZQ.js";
+} from "./chunk-2BONPXAF.js";
 import {
   getServiceMode,
   modeLabel,
   pollHealth,
   readDaemonConfig,
   restartService
-} from "./chunk-ATEX3ZPG.js";
+} from "./chunk-Q2XBKQ2D.js";
 import {
   exec,
   execInherit,
   resolveVoluteBin
-} from "./chunk-PGPLCJPK.js";
+} from "./chunk-3ERIL673.js";
 import {
   voluteSystemDir
-} from "./chunk-YAMO2U3N.js";
-import "./chunk-L3IV23ZG.js";
+} from "./chunk-H7IYFRAL.js";
+import "./chunk-ZV7MFISX.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/update.ts

package/dist/{update-check-ACYYNKTW.js → update-check-VSCSJ7KX.js}

@@ -8,9 +8,9 @@ import {
   getResolvedVersion,
   isNewer,
   resolveVoluteInstall
-} from "./chunk-AD46AYZQ.js";
-import "./chunk-YAMO2U3N.js";
-import "./chunk-L3IV23ZG.js";
+} from "./chunk-2BONPXAF.js";
+import "./chunk-H7IYFRAL.js";
+import "./chunk-ZV7MFISX.js";
 import "./chunk-K3NQKI34.js";
 export {
   analyzeInstallPath,

package/dist/{version-notify-DCAIXXZB.js → version-notify-B67N35A3.js}

@@ -1,28 +1,28 @@
 #!/usr/bin/env node
 import {
   getCurrentVersion
-} from "./chunk-AD46AYZQ.js";
+} from "./chunk-2BONPXAF.js";
 import {
   computeTemplateHash
 } from "./chunk-QMJCNZ6C.js";
 import {
   sendSystemMessage
-} from "./chunk-PF2AB7VJ.js";
-import "./chunk-XDTKJNW5.js";
-import "./chunk-65OLHBCL.js";
+} from "./chunk-OMETFX5H.js";
+import "./chunk-5GT7URXJ.js";
+import "./chunk-7FT24JBQ.js";
 import "./chunk-QLWG3C2Z.js";
-import "./chunk-FSSUANZJ.js";
-import "./chunk-K4EHBHPE.js";
+import "./chunk-I2Y2YHIO.js";
+import "./chunk-FZMEVCWC.js";
 import "./chunk-CU6OFXMM.js";
-import "./chunk-C6ESRQZ7.js";
-import "./chunk-M3PGGSBH.js";
-import "./chunk-SPLPKBES.js";
-import "./chunk-3WLWKOGM.js";
-import "./chunk-PGPLCJPK.js";
-import "./chunk-YSV3VJQK.js";
-import "./chunk-ONM2AZFL.js";
-import "./chunk-EFL5UOY4.js";
-import "./chunk-7G2EEYXX.js";
+import "./chunk-3GYVW2X3.js";
+import "./chunk-HVU45COX.js";
+import "./chunk-5AHYQHNT.js";
+import "./chunk-NF75HPNR.js";
+import "./chunk-3ERIL673.js";
+import "./chunk-J47TIYHA.js";
+import "./chunk-PNV24SEP.js";
+import "./chunk-CYI534DJ.js";
+import "./chunk-ZMIMSIIT.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";
@@ -30,8 +30,8 @@ import {
   readRegistry,
   setMindTemplateHash,
   voluteSystemDir
-} from "./chunk-YAMO2U3N.js";
-import "./chunk-L3IV23ZG.js";
+} from "./chunk-H7IYFRAL.js";
+import "./chunk-ZV7MFISX.js";
 import "./chunk-K3NQKI34.js";
 
 // packages/daemon/src/lib/version-notify.ts