volute 0.30.1 → 0.32.0

package/dist/{chunk-2NDZC3S7.js → chunk-WKF5FEFK.js}

@@ -1,28 +1,39 @@
 #!/usr/bin/env node
 import {
-  broadcast,
+  getAllSites,
+  getPublishedPages,
+  getRecentPages,
+  initDb,
+  syncPublishedPages
+} from "./chunk-PB65JZK2.js";
+import {
+  getUser,
+  getUserByUsername
+} from "./chunk-TDRYEPH4.js";
+import {
   publish
-} from "./chunk-P27RV5WM.js";
+} from "./chunk-QZANELPX.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   sharedSkillsDir
-} from "./chunk-MDPCSXZ4.js";
+} from "./chunk-D5G5YOPL.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
 import {
   getDb,
   mindDir,
-  users,
   voluteHome,
-  voluteSystemDir,
-  voluteUserHome
-} from "./chunk-HHTXM4JT.js";
+  voluteSystemDir
+} from "./chunk-LRCG2JLP.js";
+import {
+  turns
+} from "./chunk-RPZZSXV3.js";
 
 // src/lib/extensions.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
-import { dirname, resolve as resolve5 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { dirname, resolve as resolve6 } from "path";
 
 // packages/extensions/notes/src/index.ts
 import { resolve } from "path";
@@ -40,47 +51,6 @@ function createExtension(manifest) {
   return manifest;
 }
 
-// packages/extensions/notes/src/db.ts
-function initDb(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS notes (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      author_id INTEGER NOT NULL,
-      title TEXT NOT NULL,
-      slug TEXT NOT NULL,
-      content TEXT NOT NULL,
-      reply_to_id INTEGER,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_notes_author_slug ON notes(author_id, slug);
-    CREATE INDEX IF NOT EXISTS idx_notes_created_at ON notes(created_at);
-    CREATE INDEX IF NOT EXISTS idx_notes_reply_to ON notes(reply_to_id);
-
-    CREATE TABLE IF NOT EXISTS note_comments (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      note_id INTEGER NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
-      author_id INTEGER NOT NULL,
-      content TEXT NOT NULL,
-      created_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_note_comments_note_id ON note_comments(note_id);
-
-    CREATE TABLE IF NOT EXISTS note_reactions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      note_id INTEGER NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
-      user_id INTEGER NOT NULL,
-      emoji TEXT NOT NULL,
-      created_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_note_reactions_unique ON note_reactions(note_id, user_id, emoji);
-    CREATE INDEX IF NOT EXISTS idx_note_reactions_note_id ON note_reactions(note_id);
-  `);
-}
-
-// packages/extensions/notes/src/routes.ts
-import { Hono } from "hono";
-
 // packages/extensions/notes/src/notes.ts
 function slugify(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -319,7 +289,199 @@ async function resolveNoteId(db, getUserByUsername2, authorSlug) {
   return row?.id ?? null;
 }
 
+// packages/extensions/notes/src/commands.ts
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx !== -1 && args[idx + 1]) return args[idx + 1];
+  return void 0;
+}
+function createCommands() {
+  return {
+    write: {
+      description: "Write a new note",
+      usage: 'volute notes write "title" "content" [--reply-to author/slug]',
+      handler: async (args, 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 title = args[0];
+        const content = args[1];
+        if (!title || !content)
+          return { error: 'Usage: volute notes write "title" "content" [--reply-to author/slug]' };
+        let replyToId;
+        const replyTo = getFlag(args, "--reply-to");
+        if (replyTo) {
+          const id = await resolveNoteId(ctx.db, ctx.getUserByUsername, replyTo);
+          if (id === null) return { error: `Reply target not found: ${replyTo}` };
+          replyToId = id;
+        }
+        const note = await createNote(ctx.db, ctx.getUser, user.id, title, content, replyToId);
+        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}` };
+      }
+    },
+    list: {
+      description: "List notes",
+      usage: "volute notes list [--author name] [--limit N]",
+      handler: async (args, ctx) => {
+        if (!ctx.db) return { error: "Notes extension requires a database" };
+        const author = getFlag(args, "--author");
+        const limit = parseInt(getFlag(args, "--limit") ?? "10", 10);
+        const notes = await listNotes(ctx.db, ctx.getUser, ctx.getUserByUsername, {
+          authorUsername: author,
+          limit
+        });
+        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})`;
+        });
+        return { output: lines.join("\n") };
+      }
+    },
+    read: {
+      description: "Read a note",
+      usage: "volute notes read <author/slug>",
+      handler: async (args, ctx) => {
+        if (!ctx.db) return { error: "Notes extension requires a database" };
+        const ref = args[0];
+        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.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") };
+      }
+    },
+    comment: {
+      description: "Comment on a note",
+      usage: 'volute notes comment <author/slug> "content"',
+      handler: async (args, 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[0];
+        const content = args[1];
+        if (!ref || !ref.includes("/") || !content) {
+          return { error: 'Usage: volute notes comment <author/slug> "content"' };
+        }
+        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" };
+        await addComment(ctx.db, ctx.getUser, note.id, user.id, content);
+        return { output: "Comment added." };
+      }
+    },
+    react: {
+      description: "React to a note",
+      usage: 'volute notes react <author/slug> "emoji"',
+      handler: async (args, 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[0];
+        const emoji = args[1];
+        if (!ref || !ref.includes("/") || !emoji) {
+          return { error: 'Usage: volute notes react <author/slug> "emoji"' };
+        }
+        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 result = toggleReaction(ctx.db, note.id, user.id, emoji);
+        return { output: result.added ? "Reaction added." : "Reaction removed." };
+      }
+    },
+    delete: {
+      description: "Delete your own note",
+      usage: "volute notes delete <author/slug>",
+      handler: async (args, 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[0];
+        if (!ref || !ref.includes("/"))
+          return { error: "Usage: volute notes delete <author/slug>" };
+        const [author, slug] = ref.split("/", 2);
+        const deleted = await deleteNote(ctx.db, ctx.getUserByUsername, author, slug, user.id);
+        if (!deleted) return { error: "Note not found or not authorized" };
+        return { output: "Note deleted." };
+      }
+    }
+  };
+}
+
+// packages/extensions/notes/src/db.ts
+function initDb2(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS notes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      author_id INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      content TEXT NOT NULL,
+      reply_to_id INTEGER,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_notes_author_slug ON notes(author_id, slug);
+    CREATE INDEX IF NOT EXISTS idx_notes_created_at ON notes(created_at);
+    CREATE INDEX IF NOT EXISTS idx_notes_reply_to ON notes(reply_to_id);
+
+    CREATE TABLE IF NOT EXISTS note_comments (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      note_id INTEGER NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
+      author_id INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_note_comments_note_id ON note_comments(note_id);
+
+    CREATE TABLE IF NOT EXISTS note_reactions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      note_id INTEGER NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
+      user_id INTEGER NOT NULL,
+      emoji TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_note_reactions_unique ON note_reactions(note_id, user_id, emoji);
+    CREATE INDEX IF NOT EXISTS idx_note_reactions_note_id ON note_reactions(note_id);
+  `);
+}
+
 // packages/extensions/notes/src/routes.ts
+import { Hono } from "hono";
 async function parseJson(c) {
   try {
     return await c.req.json();
@@ -366,12 +528,19 @@ function createRoutes(ctx) {
       replyToId = id;
     }
     const note = await createNote(db, getUser2, actor.id, body.title, body.content, replyToId);
-    ctx.publishActivity({
-      type: "note_created",
-      mindName: actor.username,
-      title: body.title,
-      data: { author: actor.username, slug: note.slug }
-    });
+    ctx.publishActivity(
+      {
+        type: "note_created",
+        mind: actor.username,
+        summary: `${actor.username} wrote "${body.title}"`,
+        metadata: {
+          author: actor.username,
+          slug: note.slug,
+          bodyHtml: body.content.slice(0, 500)
+        }
+      },
+      c
+    );
     return c.json(note, 201);
   }).get("/:author/:slug", async (c) => {
     const { author, slug } = c.req.param();
@@ -459,8 +628,10 @@ var src_default = createExtension({
   name: "Notes",
   version: "0.1.0",
   description: "Public notes for sharing thoughts, reflections, and ideas",
+  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>',
   routes: (ctx) => createRoutes(ctx),
-  initDb,
+  commands: createCommands(),
+  initDb: initDb2,
   skillsDir,
   standardSkill: true,
   ui: {
@@ -474,12 +645,221 @@ var src_default = createExtension({
 });
 
 // packages/extensions/pages/src/index.ts
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
+
+// packages/extensions/pages/src/commands.ts
+import { cpSync, existsSync, readdirSync, readFileSync, rmSync, statSync } from "fs";
+import { relative, resolve as resolve2 } from "path";
+function createCommands2() {
+  return {
+    publish: {
+      description: "Publish all pages (copy to public snapshot)",
+      usage: "volute pages publish [--remote]",
+      handler: async (args, ctx) => {
+        const mindName = ctx.mindName;
+        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
+        const remote = args.includes("--remote");
+        const mindDir2 = ctx.getMindDir(mindName);
+        if (!mindDir2) return { error: `Mind not found: ${mindName}` };
+        const sourceDir = resolve2(mindDir2, "home", "public", "pages");
+        if (!existsSync(sourceDir))
+          return { error: "No pages directory found (home/public/pages/)" };
+        const db = ctx.db;
+        if (!db) return { error: "Database not available" };
+        const snapshotDir = resolve2(ctx.dataDir, "sites", mindName);
+        try {
+          if (existsSync(snapshotDir)) rmSync(snapshotDir, { recursive: true });
+          cpSync(sourceDir, snapshotDir, { recursive: true });
+        } catch (err) {
+          return { error: `Failed to publish snapshot: ${err.message}` };
+        }
+        const htmlFiles = collectHtmlFiles(snapshotDir, snapshotDir);
+        let diff;
+        try {
+          diff = syncPublishedPages(db, mindName, htmlFiles);
+        } catch (err) {
+          return { error: `Failed to update page database: ${err.message}` };
+        }
+        for (const file of diff.added) {
+          ctx.publishActivity({
+            type: "page_published",
+            mind: mindName,
+            summary: `${mindName} published ${file}`,
+            metadata: { file, iframeUrl: `/ext/pages/public/${mindName}/${file}` }
+          });
+        }
+        for (const file of diff.removed) {
+          ctx.publishActivity({
+            type: "page_removed",
+            mind: mindName,
+            summary: `${mindName} removed ${file}`,
+            metadata: { file }
+          });
+        }
+        let output = `Published ${htmlFiles.length} files`;
+        const parts = [];
+        if (diff.added.length > 0) parts.push(`${diff.added.length} new`);
+        if (diff.updated.length > 0) parts.push(`${diff.updated.length} updated`);
+        if (diff.removed.length > 0) parts.push(`${diff.removed.length} removed`);
+        if (parts.length > 0) output += ` (${parts.join(", ")})`;
+        if (remote) {
+          const config = ctx.getSystemsConfig();
+          if (!config)
+            return {
+              error: "Not connected to volute.systems. Run volute systems register or login first."
+            };
+          const allFiles = collectAllFiles(snapshotDir, snapshotDir);
+          const files = {};
+          for (const f of allFiles) {
+            const fp = resolve2(snapshotDir, f);
+            files[f] = readFileSync(fp).toString("base64");
+          }
+          try {
+            const res = await fetch(`${config.apiUrl}/api/pages/publish/${mindName}`, {
+              method: "PUT",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.apiKey}`
+              },
+              body: JSON.stringify({ files })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok) {
+              const errMsg = data.error || `HTTP ${res.status}`;
+              output += `
+Warning: remote publish failed: ${errMsg}`;
+            } else if (data.url) {
+              output += `
+Remote: ${data.url}`;
+            }
+          } catch (err) {
+            output += `
+Warning: remote publish failed: ${err.message}`;
+          }
+        }
+        return { output };
+      }
+    },
+    list: {
+      description: "List pages with publish status",
+      usage: "volute pages list [--all]",
+      handler: async (args, ctx) => {
+        const mindName = ctx.mindName;
+        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
+        const db = ctx.db;
+        if (!db) return { error: "Database not available" };
+        const allFlag = args.includes("--all");
+        const port = process.env.VOLUTE_DAEMON_PORT || "1618";
+        if (allFlag) {
+          const { getAllSites: getAllSites2 } = await import("./db-RA45JBFG.js");
+          const sites = getAllSites2(db);
+          const lines2 = [];
+          for (const site of sites) {
+            for (const f of site.files) {
+              const url = `http://localhost:${port}/ext/pages/public/${site.mind}/${f.file}`;
+              lines2.push(`${site.mind.padEnd(15)} ${f.file.padEnd(25)} ${url}`);
+            }
+          }
+          return { output: lines2.length > 0 ? lines2.join("\n") : "No published pages found." };
+        }
+        const mindDir2 = ctx.getMindDir(mindName);
+        if (!mindDir2) return { error: `Mind not found: ${mindName}` };
+        const sourceDir = resolve2(mindDir2, "home", "public", "pages");
+        const published = new Set(getPublishedPages(db, mindName).map((p) => p.file));
+        const draftFiles = existsSync(sourceDir) ? collectHtmlFiles(sourceDir, sourceDir) : [];
+        const allFiles = /* @__PURE__ */ new Set([...published, ...draftFiles]);
+        if (allFiles.size === 0) return { output: "No pages found." };
+        const lines = [...allFiles].sort().map((file) => {
+          const isPublished = published.has(file);
+          const status = isPublished ? "published" : "draft";
+          const url = isPublished ? `http://localhost:${port}/ext/pages/public/${mindName}/${file}` : "";
+          return `${status.padEnd(11)} ${file.padEnd(25)} ${url}`;
+        });
+        return { output: lines.join("\n") };
+      }
+    }
+  };
+}
+function collectHtmlFiles(dir, baseDir) {
+  const files = [];
+  let items;
+  try {
+    items = readdirSync(dir);
+  } catch (err) {
+    console.error(`[pages] failed to read directory ${dir}: ${err.message}`);
+    return files;
+  }
+  for (const item of items) {
+    if (item.startsWith(".")) continue;
+    const fullPath = resolve2(dir, item);
+    try {
+      const s = statSync(fullPath);
+      if (s.isFile() && item.endsWith(".html")) {
+        files.push(relative(baseDir, fullPath));
+      } else if (s.isDirectory()) {
+        files.push(...collectHtmlFiles(fullPath, baseDir));
+      }
+    } catch (err) {
+      console.error(`[pages] failed to stat ${fullPath}: ${err.message}`);
+    }
+  }
+  return files.sort();
+}
+function collectAllFiles(dir, baseDir) {
+  const files = [];
+  let items;
+  try {
+    items = readdirSync(dir);
+  } catch (err) {
+    console.error(`[pages] failed to read directory ${dir}: ${err.message}`);
+    return files;
+  }
+  for (const item of items) {
+    if (item.startsWith(".")) continue;
+    const fullPath = resolve2(dir, item);
+    try {
+      const s = statSync(fullPath);
+      if (s.isFile()) {
+        files.push(relative(baseDir, fullPath));
+      } else if (s.isDirectory()) {
+        files.push(...collectAllFiles(fullPath, baseDir));
+      }
+    } catch (err) {
+      console.error(`[pages] failed to stat ${fullPath}: ${err.message}`);
+    }
+  }
+  return files.sort();
+}
 
 // packages/extensions/pages/src/routes.ts
 import { readFile, stat } from "fs/promises";
-import { extname, resolve as resolve2 } from "path";
+import { extname, resolve as resolve3 } from "path";
 import { Hono as Hono2 } from "hono";
+
+// packages/extensions/pages/src/cache.ts
+function getSites(db) {
+  const sites = getAllSites(db);
+  return sites.map((site) => ({
+    name: site.mind,
+    label: site.mind,
+    pages: site.files.map((f) => ({
+      file: f.file,
+      modified: f.updated_at,
+      url: `/ext/pages/public/${site.mind}/${f.file}`
+    }))
+  }));
+}
+function getRecentPagesList(db, opts) {
+  const rows = getRecentPages(db, opts);
+  return rows.map((r) => ({
+    mind: r.mind,
+    file: r.file,
+    modified: r.updated_at,
+    url: `/ext/pages/public/${r.mind}/${r.file}`
+  }));
+}
+
+// packages/extensions/pages/src/routes.ts
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
@@ -496,28 +876,20 @@ var MIME_TYPES = {
   ".txt": "text/plain",
   ".xml": "application/xml"
 };
-var _pagesWatcher = null;
-async function getPagesWatcher() {
-  if (_pagesWatcher) return _pagesWatcher;
-  const mod = await import("./pages-watcher-Z3PKNROC.js");
-  _pagesWatcher = mod;
-  return _pagesWatcher;
-}
 function createRoutes2(ctx) {
   return new Hono2().get("/", async (c) => {
-    const pw = await getPagesWatcher();
-    const sites = await pw.getCachedSites();
-    const recentPages = await pw.getCachedRecentPages();
+    if (!ctx.db) return c.json({ error: "Pages database not available" }, 503);
+    const sites = getSites(ctx.db);
+    const recentPages = getRecentPagesList(ctx.db);
     return c.json({ sites, recentPages });
   }).get("/feed", async (c) => {
-    const pw = await getPagesWatcher();
-    let recentPages = await pw.getCachedRecentPages();
+    if (!ctx.db) return c.json({ error: "Pages database not available" }, 503);
     const mind = c.req.query("mind");
-    if (mind) recentPages = recentPages.filter((p) => p.mind === mind);
     const rawLimit = c.req.query("limit");
-    const limit = rawLimit ? parseInt(rawLimit, 10) : 8;
+    const limit = rawLimit ? parseInt(rawLimit, 10) || 8 : 8;
+    const recentPages = getRecentPagesList(ctx.db, { mind: mind || void 0, limit });
     return c.json(
-      recentPages.slice(0, limit).map((p) => ({
+      recentPages.map((p) => ({
         id: `page-${p.mind}-${p.file}`,
         title: `${p.mind}/${p.file}`,
         url: p.url ?? `/minds/${p.mind}/pages/${p.file}`,
@@ -576,66 +948,70 @@ function createRoutes2(ctx) {
 var _voluteHome = null;
 async function getVoluteHome() {
   if (_voluteHome) return _voluteHome();
-  const mod = await import("./registry-ODSALQQL.js");
+  const mod = await import("./registry-PJ4S5PHQ.js");
   _voluteHome = mod.voluteHome;
   return _voluteHome();
 }
 function createPublicRoutes(ctx) {
   return new Hono2().get("/:name/*", async (c) => {
     const name = c.req.param("name");
+    if (name.includes("/") || name.includes("\\") || name === "." || name === "..")
+      return c.text("Not found", 404);
     let pagesRoot;
     if (name === "_system") {
       const home = await getVoluteHome();
-      pagesRoot = resolve2(home, "shared", "pages");
+      pagesRoot = resolve3(home, "shared", "pages");
     } else {
-      const mindDirPath = ctx.getMindDir(name);
-      if (!mindDirPath) return c.text("Not found", 404);
-      pagesRoot = resolve2(mindDirPath, "home", "public", "pages");
+      pagesRoot = resolve3(ctx.dataDir, "sites", name);
     }
     const prefix = `/public/${name}`;
     const idx = c.req.path.indexOf(prefix);
     const wildcard = idx >= 0 ? c.req.path.slice(idx + prefix.length) : "/";
-    const requestedPath = resolve2(pagesRoot, wildcard.slice(1));
-    if (requestedPath !== pagesRoot && !requestedPath.startsWith(pagesRoot + "/"))
+    const requestedPath = resolve3(pagesRoot, wildcard.slice(1));
+    if (requestedPath !== pagesRoot && !requestedPath.startsWith(`${pagesRoot}/`))
       return c.text("Forbidden", 403);
+    let fileToServe = requestedPath;
     let fileStat = await stat(requestedPath).catch(() => null);
     if (fileStat?.isDirectory()) {
-      const indexPath = resolve2(requestedPath, "index.html");
+      const indexPath = resolve3(requestedPath, "index.html");
       fileStat = await stat(indexPath).catch(() => null);
       if (fileStat?.isFile()) {
-        const body = await readFile(indexPath);
-        return c.body(body, 200, { "Content-Type": "text/html" });
+        fileToServe = indexPath;
+      } else {
+        return c.text("Not found", 404);
       }
+    } else if (!fileStat?.isFile()) {
       return c.text("Not found", 404);
     }
-    if (fileStat?.isFile()) {
-      const ext = extname(requestedPath);
-      const mime = MIME_TYPES[ext] || "application/octet-stream";
-      const body = await readFile(requestedPath);
+    const ext = extname(fileToServe);
+    const mime = MIME_TYPES[ext] || "application/octet-stream";
+    try {
+      const body = await readFile(fileToServe);
       return c.body(body, 200, { "Content-Type": mime });
+    } catch (err) {
+      const code = err.code;
+      if (code === "EACCES") return c.text("Forbidden", 403);
+      if (code === "ENOENT") return c.text("Not found", 404);
+      return c.text("Internal server error", 500);
     }
-    return c.text("Not found", 404);
   });
 }
 
 // packages/extensions/pages/src/index.ts
-var assetsDir2 = resolve3(import.meta.dirname, "../dist/ui");
-var skillsDir2 = resolve3(import.meta.dirname, "../skills");
-var _watcher = null;
-async function getWatcher() {
-  if (_watcher) return _watcher;
-  _watcher = await import("./pages-watcher-Z3PKNROC.js");
-  return _watcher;
-}
+var assetsDir2 = resolve4(import.meta.dirname, "../dist/ui");
+var skillsDir2 = resolve4(import.meta.dirname, "../skills");
 var src_default2 = createExtension({
   id: "pages",
   name: "Pages",
   version: "0.1.0",
   description: "Publish and serve web pages from mind directories",
+  initDb,
   routes: (ctx) => createRoutes2(ctx),
   publicRoutes: (ctx) => createPublicRoutes(ctx),
+  commands: createCommands2(),
   skillsDir: skillsDir2,
   standardSkill: true,
+  icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="1" y="2" width="14" height="12" rx="1.5"/><path d="M1 5h14"/><circle cx="3" cy="3.5" r="0.5" fill="currentColor" stroke="none"/><circle cx="5" cy="3.5" r="0.5" fill="currentColor" stroke="none"/></svg>',
   ui: {
     assetsDir: assetsDir2,
     systemSection: {
@@ -647,194 +1023,129 @@ var src_default2 = createExtension({
     feedSource: {
       endpoint: "/api/ext/pages/feed"
     }
-  },
-  onDaemonStart: () => {
-    getWatcher().then((w) => w.startSystemWatcher()).catch(
-      (err) => console.error("[pages] failed to start system watcher:", err.message)
-    );
-  },
-  onDaemonStop: () => {
-    getWatcher().then((w) => w.stopAllWatchers()).catch((err) => console.error("[pages] failed to stop watchers:", err.message));
-  },
-  onMindStart: (mindName) => {
-    getWatcher().then((w) => w.startWatcher(mindName)).catch(
-      (err) => console.error(`[pages] failed to start watcher for ${mindName}:`, err.message)
-    );
-  },
-  onMindStop: (mindName) => {
-    getWatcher().then((w) => w.stopWatcher(mindName)).catch(
-      (err) => console.error(`[pages] failed to stop watcher for ${mindName}:`, err.message)
-    );
   }
 });
 
-// src/lib/auth.ts
-import { compareSync, hashSync } from "bcryptjs";
-import { and, count, eq, inArray } from "drizzle-orm";
-var userSelectFields = {
-  id: users.id,
-  username: users.username,
-  role: users.role,
-  user_type: users.user_type,
-  display_name: users.display_name,
-  description: users.description,
-  avatar: users.avatar,
-  created_at: users.created_at
-};
-async function createUser(username, password) {
-  const db = await getDb();
-  const hash = hashSync(password, 10);
-  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.user_type, "brain"));
-  const role = value === 0 ? "admin" : "pending";
-  const [result] = await db.insert(users).values({ username, password_hash: hash, role }).returning(userSelectFields);
-  return result;
-}
-async function verifyUser(username, password) {
-  const db = await getDb();
-  const row = await db.select().from(users).where(eq(users.username, username)).get();
-  if (!row) return null;
-  if (row.user_type === "mind") return null;
-  if (!compareSync(password, row.password_hash)) return null;
-  const { password_hash: _, ...user } = row;
-  return user;
-}
-async function getUser(id) {
-  const db = await getDb();
-  const row = await db.select(userSelectFields).from(users).where(eq(users.id, id)).get();
-  return row ?? null;
-}
-async function getUserByUsername(username) {
-  const db = await getDb();
-  const row = await db.select(userSelectFields).from(users).where(eq(users.username, username)).get();
-  return row ?? null;
-}
-async function listUsers() {
-  const db = await getDb();
-  return db.select(userSelectFields).from(users).orderBy(users.created_at).all();
-}
-async function listPendingUsers() {
-  const db = await getDb();
-  return db.select(userSelectFields).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
-}
-async function listUsersByType(userType) {
-  const db = await getDb();
-  return db.select(userSelectFields).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
-}
-async function getOrCreateMindUser(mindName) {
-  const db = await getDb();
-  const existing = await db.select(userSelectFields).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
-  if (existing) return existing;
+// src/lib/daemon/turn-tracker.ts
+import { randomUUID } from "crypto";
+import { eq } from "drizzle-orm";
+var tlog = logger_default.child("turn-tracker");
+var activeTurns = /* @__PURE__ */ new Map();
+function key(mind, session) {
+  return `${mind}:${session ?? "*"}`;
+}
+async function createTurn(mind) {
+  const k = key(mind);
+  const existing = activeTurns.get(k);
+  if (existing) return existing.turnId;
+  const turnId = randomUUID();
+  const entry = { turnId, lastToolUseEventId: void 0 };
+  activeTurns.set(k, entry);
   try {
-    const [result] = await db.insert(users).values({
-      username: mindName,
-      password_hash: "!mind",
-      role: "user",
-      user_type: "mind"
-    }).returning(userSelectFields);
-    return result;
+    const db = await getDb();
+    await db.insert(turns).values({ id: turnId, mind, status: "active" });
   } catch (err) {
-    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-      const retried = await db.select(userSelectFields).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
-      if (retried) return retried;
-    }
-    throw err;
+    tlog.error(`failed to create turn for ${mind}`, logger_default.errorData(err));
+    if (activeTurns.get(k) === entry) activeTurns.delete(k);
+    return void 0;
   }
+  return turnId;
 }
-async function deleteMindUser(mindName) {
-  const db = await getDb();
-  await db.delete(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind")));
-}
-async function changePassword(userId, currentPassword, newPassword) {
-  const db = await getDb();
-  const row = await db.select().from(users).where(eq(users.id, userId)).get();
-  if (!row) return false;
-  if (!compareSync(currentPassword, row.password_hash)) return false;
-  const hash = hashSync(newPassword, 10);
-  await db.update(users).set({ password_hash: hash }).where(eq(users.id, userId));
-  return true;
+function getActiveTurnId(mind, session) {
+  return (activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind)))?.turnId;
 }
-async function approveUser(id) {
-  const db = await getDb();
-  await db.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
+function trackToolUse(mind, session, eventId) {
+  const entry = activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind));
+  if (entry) entry.lastToolUseEventId = eventId;
 }
-async function countAdmins() {
-  const db = await getDb();
-  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.role, "admin"));
-  return value;
+function getLastToolUseEventId(mind, session) {
+  return (activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind)))?.lastToolUseEventId;
 }
-async function setUserRole(id, role) {
-  const db = await getDb();
-  const target = await db.select({ id: users.id }).from(users).where(eq(users.id, id)).get();
-  if (!target) throw new Error("User not found");
-  await db.update(users).set({ role }).where(eq(users.id, id));
-}
-async function deleteUser(id) {
-  const db = await getDb();
-  const target = await db.select({ id: users.id }).from(users).where(and(eq(users.id, id), eq(users.user_type, "brain"))).get();
-  if (!target) throw new Error("User not found");
-  await db.delete(users).where(and(eq(users.id, id), eq(users.user_type, "brain")));
+async function assignSession(mind, turnId, session) {
+  const wildcardKey = key(mind);
+  const entry = activeTurns.get(wildcardKey);
+  if (!entry || entry.turnId !== turnId) {
+    tlog.warn(`assignSession: no matching turn for ${mind} (turnId=${turnId}, session=${session})`);
+    return;
+  }
+  try {
+    const db = await getDb();
+    await db.update(turns).set({ session }).where(eq(turns.id, turnId));
+  } catch (err) {
+    tlog.error(`failed to assign session to turn ${turnId}`, logger_default.errorData(err));
+    return;
+  }
+  activeTurns.delete(wildcardKey);
+  activeTurns.set(key(mind, session), entry);
+}
+async function completeTurn(mind, session) {
+  const k = key(mind, session);
+  const wildcardKey = key(mind);
+  const entry = activeTurns.get(k) ?? activeTurns.get(wildcardKey);
+  if (!entry) return void 0;
+  try {
+    const db = await getDb();
+    await db.update(turns).set({ status: "complete" }).where(eq(turns.id, entry.turnId));
+  } catch (err) {
+    tlog.error(`failed to complete turn ${entry.turnId}`, logger_default.errorData(err));
+    return void 0;
+  }
+  activeTurns.delete(k);
+  activeTurns.delete(wildcardKey);
+  return entry.turnId;
 }
-async function updateUserProfile(userId, profile) {
-  const db = await getDb();
-  const target = await db.select({ id: users.id }).from(users).where(eq(users.id, userId)).get();
-  if (!target) throw new Error("User not found");
-  await db.update(users).set(profile).where(eq(users.id, userId));
+async function setSummaryEventId(turnId, summaryEventId) {
+  try {
+    const db = await getDb();
+    await db.update(turns).set({ summary_event_id: summaryEventId }).where(eq(turns.id, turnId));
+  } catch (err) {
+    tlog.error(`failed to set summary event for turn ${turnId}`, logger_default.errorData(err));
+  }
 }
-async function syncMindProfile(mindName, config) {
-  const user = await getOrCreateMindUser(mindName);
-  const newProfile = {
-    display_name: config.displayName ?? null,
-    description: config.description ?? null,
-    avatar: config.avatar ?? null
-  };
-  const changed = user.display_name !== newProfile.display_name || user.description !== newProfile.description || user.avatar !== newProfile.avatar;
-  if (!changed) return;
-  const db = await getDb();
-  await db.update(users).set(newProfile).where(eq(users.id, user.id));
-  broadcast({ type: "profile_updated", mind: mindName, summary: `${mindName} profile updated` });
+async function completeOrphanedTurns() {
+  try {
+    const db = await getDb();
+    const active = await db.select({ id: turns.id }).from(turns).where(eq(turns.status, "active"));
+    if (active.length === 0) return;
+    await db.update(turns).set({ status: "complete" }).where(eq(turns.status, "active"));
+    tlog.info(`completed ${active.length} orphaned active turn(s) from previous daemon session`);
+  } catch (err) {
+    tlog.error("failed to complete orphaned turns on startup", logger_default.errorData(err));
+  }
 }
-async function migrateMindRoles() {
-  const db = await getDb();
-  await db.update(users).set({ role: "user" }).where(and(eq(users.user_type, "mind"), inArray(users.role, ["mind", "agent"])));
+async function clearMind(mind) {
+  const toDelete = [];
+  const turnIds = [];
+  for (const [k, entry] of activeTurns.entries()) {
+    if (k.startsWith(`${mind}:`)) {
+      turnIds.push(entry.turnId);
+      toDelete.push(k);
+    }
+  }
+  for (const k of toDelete) activeTurns.delete(k);
+  if (turnIds.length > 0) {
+    try {
+      const db = await getDb();
+      for (const id of turnIds) {
+        await db.update(turns).set({ status: "complete" }).where(eq(turns.id, id));
+      }
+    } catch (err) {
+      tlog.error(`failed to complete orphaned turns for ${mind}`, logger_default.errorData(err));
+    }
+  }
 }
 
 // src/lib/systems-config.ts
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync
-} from "fs";
-import { resolve as resolve4 } from "path";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { resolve as resolve5 } from "path";
 var DEFAULT_API_URL = "https://volute.systems";
 function configPath() {
-  return resolve4(voluteSystemDir(), "systems.json");
-}
-function migrateIfNeeded() {
-  const target = configPath();
-  if (existsSync(target)) return;
-  const oldPaths = [
-    resolve4(voluteUserHome(), "systems.json"),
-    resolve4(voluteHome(), "systems.json")
-  ];
-  for (const old of oldPaths) {
-    if (old !== target && existsSync(old)) {
-      try {
-        mkdirSync(voluteSystemDir(), { recursive: true });
-        renameSync(old, target);
-      } catch {
-      }
-      return;
-    }
-  }
+  return resolve5(voluteSystemDir(), "systems.json");
 }
 function readSystemsConfig() {
-  migrateIfNeeded();
   const path = configPath();
-  if (!existsSync(path)) return null;
-  const raw = readFileSync(path, "utf-8");
+  if (!existsSync2(path)) return null;
+  const raw = readFileSync2(path, "utf-8");
   let data;
   try {
     data = JSON.parse(raw);
@@ -870,19 +1181,19 @@ function deleteSystemsConfig() {
 var VALID_EXTENSION_ID2 = /^[a-z0-9][a-z0-9_-]*$/;
 var loaded = [];
 function extensionsBaseDir() {
-  return resolve5(voluteHome(), "extensions");
+  return resolve6(voluteHome(), "extensions");
 }
 function extensionDataDir(id) {
-  return resolve5(voluteSystemDir(), "extension-data", id);
+  return resolve6(voluteSystemDir(), "extension-data", id);
 }
 function extensionsConfigPath() {
-  return resolve5(voluteHome(), "system", "extensions.json");
+  return resolve6(voluteHome(), "system", "extensions.json");
 }
 function readExtensionsConfig() {
   const configPath2 = extensionsConfigPath();
-  if (!existsSync2(configPath2)) return [];
+  if (!existsSync3(configPath2)) return [];
   try {
-    const data = JSON.parse(readFileSync2(configPath2, "utf-8"));
+    const data = JSON.parse(readFileSync3(configPath2, "utf-8"));
     return Array.isArray(data) ? data : [];
   } catch (err) {
     logger_default.warn("failed to read extensions config, ignoring installed extensions", {
@@ -900,73 +1211,10 @@ async function getLibsqlDatabase() {
   return _LibsqlDatabase;
 }
 async function openExtensionDb(_id, dataDir) {
-  const dbPath = resolve5(dataDir, "data.db");
+  const dbPath = resolve6(dataDir, "data.db");
   const Database = await getLibsqlDatabase();
   return new Database(dbPath);
 }
-async function migrateNotesFromCoreDb(extDb) {
-  const coreDbPath = process.env.VOLUTE_DB_PATH || resolve5(voluteSystemDir(), "volute.db");
-  if (!existsSync2(coreDbPath)) return;
-  const existing = extDb.prepare("SELECT COUNT(*) as c FROM notes").get();
-  if (existing.c > 0) return;
-  const Database = await getLibsqlDatabase();
-  const coreDb = new Database(coreDbPath);
-  try {
-    const tableExists = coreDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='notes'").get();
-    if (!tableExists) return;
-    const coreNotes = coreDb.prepare(
-      "SELECT id, author_id, title, slug, content, reply_to_id, created_at, updated_at FROM notes ORDER BY id"
-    ).all();
-    if (coreNotes.length === 0) return;
-    logger_default.info(`migrating ${coreNotes.length} notes from core DB to extension DB`);
-    const coreComments = coreDb.prepare("SELECT id, note_id, author_id, content, created_at FROM note_comments ORDER BY id").all();
-    const coreReactions = coreDb.prepare("SELECT id, note_id, user_id, emoji, created_at FROM note_reactions ORDER BY id").all();
-    extDb.exec("BEGIN TRANSACTION");
-    try {
-      for (const note of coreNotes) {
-        extDb.prepare(
-          "INSERT OR IGNORE INTO notes (id, author_id, title, slug, content, reply_to_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
-        ).run(
-          note.id,
-          note.author_id,
-          note.title,
-          note.slug,
-          note.content,
-          note.reply_to_id,
-          note.created_at,
-          note.updated_at
-        );
-      }
-      for (const comment of coreComments) {
-        extDb.prepare(
-          "INSERT OR IGNORE INTO note_comments (id, note_id, author_id, content, created_at) VALUES (?, ?, ?, ?, ?)"
-        ).run(comment.id, comment.note_id, comment.author_id, comment.content, comment.created_at);
-      }
-      for (const reaction of coreReactions) {
-        extDb.prepare(
-          "INSERT OR IGNORE INTO note_reactions (id, note_id, user_id, emoji, created_at) VALUES (?, ?, ?, ?, ?)"
-        ).run(
-          reaction.id,
-          reaction.note_id,
-          reaction.user_id,
-          reaction.emoji,
-          reaction.created_at
-        );
-      }
-      extDb.exec("COMMIT");
-    } catch (txErr) {
-      extDb.exec("ROLLBACK");
-      throw txErr;
-    }
-    logger_default.info(
-      `migrated ${coreNotes.length} notes, ${coreComments.length} comments, ${coreReactions.length} reactions`
-    );
-  } catch (err) {
-    logger_default.error("failed to migrate notes from core DB", logger_default.errorData(err));
-  } finally {
-    coreDb.close();
-  }
-}
 async function buildContext(manifest, dataDir, authMw) {
   let db = null;
   if (manifest.initDb) {
@@ -977,9 +1225,6 @@ async function buildContext(manifest, dataDir, authMw) {
       realDb.close();
       throw new Error(`initDb failed for extension ${manifest.id}: ${err.message}`);
     }
-    if (manifest.id === "notes") {
-      await migrateNotesFromCoreDb(realDb);
-    }
     db = realDb;
   }
   return {
@@ -992,15 +1237,22 @@ async function buildContext(manifest, dataDir, authMw) {
     },
     getUser: async (id) => getUser(id),
     getUserByUsername: async (username) => getUserByUsername(username),
-    publishActivity: (event) => {
-      publish(event).catch(
+    publishActivity: (event, sessionOrContext) => {
+      const session = typeof sessionOrContext === "string" ? sessionOrContext : sessionOrContext?.get("mindSession");
+      const turnId = getActiveTurnId(event.mind, session);
+      const sourceEventId = getLastToolUseEventId(event.mind, session);
+      publish({
+        ...event,
+        turn_id: turnId,
+        source_event_id: sourceEventId
+      }).catch(
         (err) => logger_default.error(`extension ${manifest.id}: failed to publish activity`, logger_default.errorData(err))
       );
     },
     getMindDir: (name) => {
       try {
         const dir = mindDir(name);
-        return existsSync2(dir) ? dir : null;
+        return existsSync3(dir) ? dir : null;
       } catch (err) {
         logger_default.warn(
           `extension ${manifest.id}: failed to resolve mind dir for ${name}`,
@@ -1030,19 +1282,48 @@ async function loadExtension(manifest, app, authMw) {
     const publicApp = manifest.publicRoutes(context);
     app.route(`/ext/${manifest.id}/public`, publicApp);
   }
+  if (manifest.commands) {
+    for (const [cmdName, cmd] of Object.entries(manifest.commands)) {
+      app.post(`${extApiPath}/commands/${cmdName}`, async (c) => {
+        let body;
+        try {
+          body = await c.req.json();
+        } catch {
+          return c.json({ error: "Invalid JSON in request body" }, 400);
+        }
+        const user = c.get("user");
+        const mindName = body.mind || user?.username;
+        const session = c.get("mindSession");
+        try {
+          const result = await cmd.handler(body.args ?? [], {
+            ...context,
+            // Bind publishActivity to the session so command handlers
+            // don't need to pass it explicitly
+            publishActivity: (event, sc) => context.publishActivity(event, sc ?? session),
+            mindName,
+            session
+          });
+          return c.json(result);
+        } catch (err) {
+          logger_default.error(`extension command ${manifest.id}/${cmdName} failed`, logger_default.errorData(err));
+          return c.json({ error: err.message }, 500);
+        }
+      });
+    }
+  }
   let resolvedAssetsDir = manifest.ui?.assetsDir ?? "";
-  if (resolvedAssetsDir && !existsSync2(resolvedAssetsDir)) {
+  if (resolvedAssetsDir && !existsSync3(resolvedAssetsDir)) {
     let searchDir = dirname(new URL(import.meta.url).pathname);
     for (let i = 0; i < 5; i++) {
-      const candidate = resolve5(searchDir, "packages", "extensions", manifest.id, "dist", "ui");
-      if (existsSync2(candidate)) {
+      const candidate = resolve6(searchDir, "packages", "extensions", manifest.id, "dist", "ui");
+      if (existsSync3(candidate)) {
         resolvedAssetsDir = candidate;
         break;
       }
       searchDir = dirname(searchDir);
     }
   }
-  if (resolvedAssetsDir && existsSync2(resolvedAssetsDir)) {
+  if (resolvedAssetsDir && existsSync3(resolvedAssetsDir)) {
     const assetsDir3 = resolvedAssetsDir;
     const { readFile: readFile2, stat: fsStat } = await import("fs/promises");
     const { extname: ext } = await import("path");
@@ -1059,11 +1340,11 @@ async function loadExtension(manifest, app, authMw) {
       ".woff2": "font/woff2"
     };
     const prefix = `/ext/${manifest.id}`;
-    const indexPath = resolve5(assetsDir3, "index.html");
+    const indexPath = resolve6(assetsDir3, "index.html");
     const serveExtAssets = async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       const relativePath = urlPath.slice(prefix.length).replace(/^\//, "") || "index.html";
-      const filePath = resolve5(assetsDir3, relativePath);
+      const filePath = resolve6(assetsDir3, relativePath);
       if (filePath !== assetsDir3 && !filePath.startsWith(assetsDir3 + "/"))
         return c.text("Forbidden", 403);
       const s = await fsStat(filePath).catch(() => null);
@@ -1072,7 +1353,7 @@ async function loadExtension(manifest, app, authMw) {
         const body = await readFile2(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      if (existsSync2(indexPath)) {
+      if (existsSync3(indexPath)) {
         const body = await readFile2(indexPath, "utf-8");
         return c.html(body);
       }
@@ -1085,7 +1366,7 @@ async function loadExtension(manifest, app, authMw) {
   if (skillsDir3) {
     let entries;
     try {
-      entries = readdirSync(skillsDir3, { withFileTypes: true });
+      entries = readdirSync2(skillsDir3, { withFileTypes: true });
     } catch (err) {
       logger_default.error(`failed to read skills dir for extension ${manifest.id}`, logger_default.errorData(err));
       entries = [];
@@ -1093,10 +1374,10 @@ async function loadExtension(manifest, app, authMw) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       try {
-        const skillPath = resolve5(skillsDir3, entry.name);
+        const skillPath = resolve6(skillsDir3, entry.name);
         const sourceHash = hashSkillDir(skillPath);
-        const destDir = resolve5(sharedSkillsDir(), entry.name);
-        if (existsSync2(destDir)) {
+        const destDir = resolve6(sharedSkillsDir(), entry.name);
+        if (existsSync3(destDir)) {
           const destHash = hashSkillDir(destDir);
           if (sourceHash === destHash) continue;
         }
@@ -1120,11 +1401,11 @@ function resolveSkillsDir(manifest) {
   if (!manifest.skillsDir) return null;
   let searchDir = dirname(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve5(searchDir, "packages", "extensions", manifest.id, "skills");
-    if (existsSync2(candidate)) return candidate;
+    const candidate = resolve6(searchDir, "packages", "extensions", manifest.id, "skills");
+    if (existsSync3(candidate)) return candidate;
     searchDir = dirname(searchDir);
   }
-  if (existsSync2(manifest.skillsDir)) return manifest.skillsDir;
+  if (existsSync3(manifest.skillsDir)) return manifest.skillsDir;
   logger_default.warn(`skills dir not found for extension ${manifest.id}: ${manifest.skillsDir}`);
   return null;
 }
@@ -1134,14 +1415,14 @@ function discoverBuiltinExtensions() {
 async function discoverInstalledExtensions() {
   const manifests = [];
   const packages = readExtensionsConfig();
-  const npmDir = resolve5(voluteHome(), "extensions", "_npm");
+  const npmDir = resolve6(voluteHome(), "extensions", "_npm");
   const { createRequire } = await import("module");
   for (const pkg of packages) {
     try {
       let resolved = pkg;
-      const npmPkgDir = resolve5(npmDir, "node_modules", pkg);
-      if (existsSync2(npmPkgDir)) {
-        const require2 = createRequire(resolve5(npmDir, "noop.js"));
+      const npmPkgDir = resolve6(npmDir, "node_modules", pkg);
+      if (existsSync3(npmPkgDir)) {
+        const require2 = createRequire(resolve6(npmDir, "noop.js"));
         resolved = require2.resolve(pkg);
       }
       const mod = await import(resolved);
@@ -1184,19 +1465,19 @@ function validateManifest(manifest, source) {
 }
 async function discoverLocalExtensions() {
   const baseDir = extensionsBaseDir();
-  if (!existsSync2(baseDir)) return [];
+  if (!existsSync3(baseDir)) return [];
   const manifests = [];
   let entries;
   try {
-    entries = readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name !== "_npm").map((d) => d.name);
+    entries = readdirSync2(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name !== "_npm").map((d) => d.name);
   } catch (err) {
     logger_default.error("failed to read local extensions directory", logger_default.errorData(err));
     return [];
   }
   for (const dir of entries) {
-    const extDir = resolve5(baseDir, dir);
-    const candidates = [resolve5(extDir, "src", "index.js"), resolve5(extDir, "index.js")];
-    const entryPoint = candidates.find((p) => existsSync2(p));
+    const extDir = resolve6(baseDir, dir);
+    const candidates = [resolve6(extDir, "src", "index.js"), resolve6(extDir, "index.js")];
+    const entryPoint = candidates.find((p) => existsSync3(p));
     if (!entryPoint) continue;
     try {
       const mod = await import(entryPoint);
@@ -1228,17 +1509,43 @@ async function loadAllExtensions(app, authMw) {
       logger_default.error(`failed to load extension: ${manifest.id}`, logger_default.errorData(err));
     }
   }
+  app.get("/api/extensions/commands", (c) => {
+    const result = {};
+    for (const { manifest } of loaded) {
+      if (!manifest.commands) continue;
+      const cmds = {};
+      for (const [name, cmd] of Object.entries(manifest.commands)) {
+        cmds[name] = { description: cmd.description, ...cmd.usage ? { usage: cmd.usage } : {} };
+      }
+      result[manifest.id] = { commands: cmds };
+    }
+    return c.json(result);
+  });
 }
 function getLoadedExtensions() {
-  return loaded.map(({ manifest }) => ({
-    id: manifest.id,
-    name: manifest.name,
-    version: manifest.version,
-    description: manifest.description,
-    systemSection: manifest.ui?.systemSection,
-    mindSections: manifest.ui?.mindSections,
-    feedSource: manifest.ui?.feedSource
-  }));
+  return loaded.map(({ manifest }) => {
+    let commands;
+    if (manifest.commands) {
+      commands = {};
+      for (const [name, cmd] of Object.entries(manifest.commands)) {
+        commands[name] = {
+          description: cmd.description,
+          ...cmd.usage ? { usage: cmd.usage } : {}
+        };
+      }
+    }
+    return {
+      id: manifest.id,
+      name: manifest.name,
+      version: manifest.version,
+      description: manifest.description,
+      icon: manifest.icon,
+      systemSection: manifest.ui?.systemSection,
+      mindSections: manifest.ui?.mindSections,
+      feedSource: manifest.ui?.feedSource,
+      commands
+    };
+  });
 }
 function getExtensionStandardSkills() {
   const skills = [];
@@ -1247,7 +1554,7 @@ function getExtensionStandardSkills() {
     const dir = resolveSkillsDir(manifest);
     if (!dir) continue;
     try {
-      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      for (const entry of readdirSync2(dir, { withFileTypes: true })) {
         if (entry.isDirectory()) skills.push(entry.name);
       }
     } catch (err) {
@@ -1300,23 +1607,15 @@ function notifyExtensionsMindStop(mindName) {
 }
 
 export {
-  createUser,
-  verifyUser,
-  getUser,
-  getUserByUsername,
-  listUsers,
-  listPendingUsers,
-  listUsersByType,
-  getOrCreateMindUser,
-  deleteMindUser,
-  changePassword,
-  approveUser,
-  countAdmins,
-  setUserRole,
-  deleteUser,
-  updateUserProfile,
-  syncMindProfile,
-  migrateMindRoles,
+  createTurn,
+  getActiveTurnId,
+  trackToolUse,
+  getLastToolUseEventId,
+  assignSession,
+  completeTurn,
+  setSummaryEventId,
+  completeOrphanedTurns,
+  clearMind,
   readSystemsConfig,
   writeSystemsConfig,
   deleteSystemsConfig,