volute 0.30.1 → 0.31.0

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

@@ -1,24 +1,26 @@
 #!/usr/bin/env node
 import {
-  broadcast,
+  getUser,
+  getUserByUsername
+} from "./chunk-R5QJBZZG.js";
+import {
   publish
-} from "./chunk-P27RV5WM.js";
+} from "./chunk-EKDWA7E4.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   sharedSkillsDir
-} from "./chunk-MDPCSXZ4.js";
+} from "./chunk-S2TZLSDH.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
 import {
   getDb,
   mindDir,
-  users,
+  turns,
   voluteHome,
-  voluteSystemDir,
-  voluteUserHome
-} from "./chunk-HHTXM4JT.js";
+  voluteSystemDir
+} from "./chunk-X62AXPR7.js";
 
 // src/lib/extensions.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
@@ -40,47 +42,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 +280,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 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";
 async function parseJson(c) {
   try {
     return await c.req.json();
@@ -366,12 +519,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();
@@ -460,13 +620,20 @@ var src_default = createExtension({
   version: "0.1.0",
   description: "Public notes for sharing thoughts, reflections, and ideas",
   routes: (ctx) => createRoutes(ctx),
+  commands: createCommands(),
   initDb,
   skillsDir,
   standardSkill: true,
   ui: {
     assetsDir,
     systemSection: { id: "notes", label: "Notes", urlPatterns: ["/notes", "/notes/:author/:slug"] },
-    mindSections: [{ id: "notes", label: "Notes" }],
+    mindSections: [
+      {
+        id: "notes",
+        label: "Notes",
+        icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M4 2h6l4 4v8H4V2z"/><path d="M10 2v4h4"/><path d="M6 9h6M6 12h4"/></svg>'
+      }
+    ],
     feedSource: {
       endpoint: "/api/ext/notes/feed"
     }
@@ -499,7 +666,7 @@ var MIME_TYPES = {
 var _pagesWatcher = null;
 async function getPagesWatcher() {
   if (_pagesWatcher) return _pagesWatcher;
-  const mod = await import("./pages-watcher-Z3PKNROC.js");
+  const mod = await import("./pages-watcher-72OVPRMH.js");
   _pagesWatcher = mod;
   return _pagesWatcher;
 }
@@ -553,6 +720,31 @@ function createRoutes2(ctx) {
     } catch (err) {
       return c.json({ error: `Connection failed: ${err.message}` }, 502);
     }
+  }).post("/notify", async (c) => {
+    const user = ctx.resolveUser(c);
+    if (!user) return c.json({ error: "Unauthorized" }, 401);
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      body = {};
+    }
+    const file = body.file ?? "page";
+    ctx.publishActivity(
+      {
+        type: "page_updated",
+        mind: user.username,
+        summary: `${user.username} updated ${file}`,
+        metadata: { file, iframeUrl: `/ext/pages/public/${user.username}/${file}` }
+      },
+      c
+    );
+    try {
+      const mod = await import("./pages-watcher-72OVPRMH.js");
+      mod.invalidateCache();
+    } catch {
+    }
+    return c.json({ ok: true });
   }).get("/status/:name", async (c) => {
     const user = ctx.resolveUser(c);
     if (!user) return c.json({ error: "Unauthorized" }, 401);
@@ -576,7 +768,7 @@ 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-ASXCQCNH.js");
   _voluteHome = mod.voluteHome;
   return _voluteHome();
 }
@@ -624,9 +816,26 @@ var skillsDir2 = resolve3(import.meta.dirname, "../skills");
 var _watcher = null;
 async function getWatcher() {
   if (_watcher) return _watcher;
-  _watcher = await import("./pages-watcher-Z3PKNROC.js");
+  _watcher = await import("./pages-watcher-72OVPRMH.js");
   return _watcher;
 }
+var notifyHandler = async (args, ctx) => {
+  const mindName = ctx.mindName;
+  if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
+  const file = args[0] || "page";
+  ctx.publishActivity({
+    type: "page_updated",
+    mind: mindName,
+    summary: `${mindName} updated ${file}`,
+    metadata: { file, iframeUrl: `/ext/pages/public/${mindName}/${file}` }
+  });
+  try {
+    const mod = await import("./pages-watcher-72OVPRMH.js");
+    mod.invalidateCache();
+  } catch {
+  }
+  return { output: `Notified: ${file}` };
+};
 var src_default2 = createExtension({
   id: "pages",
   name: "Pages",
@@ -634,6 +843,13 @@ var src_default2 = createExtension({
   description: "Publish and serve web pages from mind directories",
   routes: (ctx) => createRoutes2(ctx),
   publicRoutes: (ctx) => createPublicRoutes(ctx),
+  commands: {
+    notify: {
+      description: "Notify that a page was created or updated",
+      usage: "volute pages notify [filename]",
+      handler: notifyHandler
+    }
+  },
   skillsDir: skillsDir2,
   standardSkill: true,
   ui: {
@@ -643,7 +859,13 @@ var src_default2 = createExtension({
       label: "Pages",
       urlPatterns: ["/pages", "/pages/:site", "/pages/:site/:path"]
     },
-    mindSections: [{ id: "pages", label: "Pages" }],
+    mindSections: [
+      {
+        id: "pages",
+        label: "Pages",
+        icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="8" cy="8" r="6"/><path d="M2 8h12M8 2c-2 2-2 10 0 12M8 2c2 2 2 10 0 12"/></svg>'
+      }
+    ],
     feedSource: {
       endpoint: "/api/ext/pages/feed"
     }
@@ -668,170 +890,110 @@ var src_default2 = createExtension({
   }
 });
 
-// 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();
   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));
+    return void 0;
   }
+  activeTurns.set(k, { turnId, lastToolUseEventId: 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;
-}
-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")));
-}
-async function countAdmins() {
-  const db = await getDb();
-  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.role, "admin"));
-  return value;
+function getActiveTurnId(mind, session) {
+  return (activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind)))?.turnId;
 }
-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));
+function trackToolUse(mind, session, eventId) {
+  const entry = activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind));
+  if (entry) entry.lastToolUseEventId = eventId;
 }
-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")));
+function getLastToolUseEventId(mind, session) {
+  return (activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind)))?.lastToolUseEventId;
 }
-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 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 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 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 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 { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { resolve as resolve4 } 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;
-    }
-  }
-}
 function readSystemsConfig() {
-  migrateIfNeeded();
   const path = configPath();
   if (!existsSync(path)) return null;
   const raw = readFileSync(path, "utf-8");
@@ -904,69 +1066,6 @@ async function openExtensionDb(_id, dataDir) {
   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 +1076,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,8 +1088,15 @@ 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))
       );
     },
@@ -1030,6 +1133,35 @@ 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)) {
     let searchDir = dirname(new URL(import.meta.url).pathname);
@@ -1228,17 +1360,42 @@ 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,
+      systemSection: manifest.ui?.systemSection,
+      mindSections: manifest.ui?.mindSections,
+      feedSource: manifest.ui?.feedSource,
+      commands
+    };
+  });
 }
 function getExtensionStandardSkills() {
   const skills = [];
@@ -1300,23 +1457,14 @@ 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,
+  clearMind,
   readSystemsConfig,
   writeSystemsConfig,
   deleteSystemsConfig,