volute 0.31.0 → 0.33.0

package/dist/{chunk-NOWVQ7AL.js → chunk-A2A4KLFE.js}

@@ -1,30 +1,35 @@
 #!/usr/bin/env node
+import {
+  getAllSites,
+  getPublishedPages,
+  getRecentPages,
+  initDb,
+  syncPublishedPages
+} from "./chunk-PB65JZK2.js";
 import {
   getUser,
   getUserByUsername
-} from "./chunk-R5QJBZZG.js";
+} from "./chunk-JYVGHWEJ.js";
 import {
   publish
-} from "./chunk-EKDWA7E4.js";
+} from "./chunk-KVK2DLWI.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   sharedSkillsDir
-} from "./chunk-S2TZLSDH.js";
+} from "./chunk-C7I35G4R.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
 import {
-  getDb,
   mindDir,
-  turns,
   voluteHome,
   voluteSystemDir
-} from "./chunk-X62AXPR7.js";
+} from "./chunk-LRCG2JLP.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";
@@ -290,7 +295,7 @@ function createCommands() {
   return {
     write: {
       description: "Write a new note",
-      usage: 'volute notes write "title" "content" [--reply-to author/slug]',
+      usage: 'volute notes write "title" ["content"] [--reply-to author/slug]  (content can be piped via stdin)',
       handler: async (args, ctx) => {
         if (!ctx.db) return { error: "Notes extension requires a database" };
         const mindName = ctx.mindName;
@@ -298,7 +303,7 @@ function createCommands() {
         const user = await ctx.getUserByUsername(mindName);
         if (!user) return { error: `Unknown mind: ${mindName}` };
         const title = args[0];
-        const content = args[1];
+        const content = args[1] ?? ctx.stdin;
         if (!title || !content)
           return { error: 'Usage: volute notes write "title" "content" [--reply-to author/slug]' };
         let replyToId;
@@ -372,7 +377,7 @@ Comments (${note.comments.length}):`);
     },
     comment: {
       description: "Comment on a note",
-      usage: 'volute notes comment <author/slug> "content"',
+      usage: 'volute notes comment <author/slug> ["content"]  (content can be piped via stdin)',
       handler: async (args, ctx) => {
         if (!ctx.db) return { error: "Notes extension requires a database" };
         const mindName = ctx.mindName;
@@ -380,7 +385,7 @@ Comments (${note.comments.length}):`);
         const user = await ctx.getUserByUsername(mindName);
         if (!user) return { error: `Unknown mind: ${mindName}` };
         const ref = args[0];
-        const content = args[1];
+        const content = args[1] ?? ctx.stdin;
         if (!ref || !ref.includes("/") || !content) {
           return { error: 'Usage: volute notes comment <author/slug> "content"' };
         }
@@ -434,7 +439,7 @@ Comments (${note.comments.length}):`);
 }
 
 // packages/extensions/notes/src/db.ts
-function initDb(db) {
+function initDb2(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS notes (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -519,19 +524,16 @@ function createRoutes(ctx) {
       replyToId = id;
     }
     const note = await createNote(db, getUser2, actor.id, body.title, body.content, replyToId);
-    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
-    );
+    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)
+      }
+    });
     return c.json(note, 201);
   }).get("/:author/:slug", async (c) => {
     const { author, slug } = c.req.param();
@@ -619,21 +621,17 @@ 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>',
+  color: "yellow",
   routes: (ctx) => createRoutes(ctx),
   commands: createCommands(),
-  initDb,
+  initDb: initDb2,
   skillsDir,
   standardSkill: true,
   ui: {
     assetsDir,
     systemSection: { id: "notes", label: "Notes", urlPatterns: ["/notes", "/notes/:author/:slug"] },
-    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>'
-      }
-    ],
+    mindSections: [{ id: "notes", label: "Notes" }],
     feedSource: {
       endpoint: "/api/ext/notes/feed"
     }
@@ -641,12 +639,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",
@@ -663,28 +870,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-72OVPRMH.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}`,
@@ -720,31 +919,6 @@ 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);
@@ -768,90 +942,71 @@ function createRoutes2(ctx) {
 var _voluteHome = null;
 async function getVoluteHome() {
   if (_voluteHome) return _voluteHome();
-  const mod = await import("./registry-ASXCQCNH.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-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 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: {
-    notify: {
-      description: "Notify that a page was created or updated",
-      usage: "volute pages notify [filename]",
-      handler: notifyHandler
-    }
-  },
+  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>',
+  color: "purple",
   ui: {
     assetsDir: assetsDir2,
     systemSection: {
@@ -859,144 +1014,24 @@ var src_default2 = createExtension({
       label: "Pages",
       urlPatterns: ["/pages", "/pages/:site", "/pages/:site/:path"]
     },
-    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>'
-      }
-    ],
+    mindSections: [{ id: "pages", label: "Pages" }],
     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/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 db = await getDb();
-    await db.insert(turns).values({ id: turnId, mind, status: "active" });
-  } catch (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;
-}
-function getActiveTurnId(mind, session) {
-  return (activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind)))?.turnId;
-}
-function trackToolUse(mind, session, eventId) {
-  const entry = activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind));
-  if (entry) entry.lastToolUseEventId = eventId;
-}
-function getLastToolUseEventId(mind, session) {
-  return (activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind)))?.lastToolUseEventId;
-}
-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 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 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, 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");
+  return resolve5(voluteSystemDir(), "systems.json");
 }
 function readSystemsConfig() {
   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);
@@ -1032,19 +1067,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", {
@@ -1062,7 +1097,7 @@ 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);
 }
@@ -1088,22 +1123,23 @@ async function buildContext(manifest, dataDir, authMw) {
     },
     getUser: async (id) => getUser(id),
     getUserByUsername: async (username) => getUserByUsername(username),
-    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({
+    publishActivity: (event) => {
+      const enriched = {
         ...event,
-        turn_id: turnId,
-        source_event_id: sourceEventId
-      }).catch(
+        metadata: {
+          ...event.metadata,
+          ...manifest.icon && !event.metadata?.icon ? { icon: manifest.icon } : {},
+          ...manifest.color && !event.metadata?.color ? { color: manifest.color } : {}
+        }
+      };
+      publish(enriched).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}`,
@@ -1146,15 +1182,36 @@ async function loadExtension(manifest, app, authMw) {
         const mindName = body.mind || user?.username;
         const session = c.get("mindSession");
         try {
+          const activityPromises = [];
           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),
+            publishActivity: (rawEvent) => {
+              const event = {
+                ...rawEvent,
+                metadata: {
+                  ...rawEvent.metadata,
+                  ...manifest.icon && !rawEvent.metadata?.icon ? { icon: manifest.icon } : {},
+                  ...manifest.color && !rawEvent.metadata?.color ? { color: manifest.color } : {}
+                }
+              };
+              activityPromises.push(
+                publish(event).catch((err) => {
+                  logger_default.error(
+                    `extension ${manifest.id}: failed to publish activity`,
+                    logger_default.errorData(err)
+                  );
+                  return 0;
+                })
+              );
+            },
             mindName,
-            session
+            session,
+            stdin: body.stdin
           });
-          return c.json(result);
+          const activityIds = (await Promise.all(activityPromises)).filter((id) => id > 0);
+          const markers = activityIds.map((id) => `[volute:activity:${id}]`).join("");
+          const output = result && typeof result === "object" && "output" in result ? { ...result, output: `${result.output}${markers}` } : markers ? { ...result, output: markers } : result;
+          return c.json(output);
         } catch (err) {
           logger_default.error(`extension command ${manifest.id}/${cmdName} failed`, logger_default.errorData(err));
           return c.json({ error: err.message }, 500);
@@ -1163,18 +1220,18 @@ async function loadExtension(manifest, app, authMw) {
     }
   }
   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");
@@ -1191,11 +1248,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);
@@ -1204,7 +1261,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);
       }
@@ -1217,7 +1274,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 = [];
@@ -1225,10 +1282,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;
         }
@@ -1252,11 +1309,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;
 }
@@ -1266,14 +1323,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);
@@ -1316,19 +1373,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);
@@ -1390,6 +1447,7 @@ function getLoadedExtensions() {
       name: manifest.name,
       version: manifest.version,
       description: manifest.description,
+      icon: manifest.icon,
       systemSection: manifest.ui?.systemSection,
       mindSections: manifest.ui?.mindSections,
       feedSource: manifest.ui?.feedSource,
@@ -1404,7 +1462,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) {
@@ -1457,14 +1515,6 @@ function notifyExtensionsMindStop(mindName) {
 }
 
 export {
-  createTurn,
-  getActiveTurnId,
-  trackToolUse,
-  getLastToolUseEventId,
-  assignSession,
-  completeTurn,
-  setSummaryEventId,
-  clearMind,
   readSystemsConfig,
   writeSystemsConfig,
   deleteSystemsConfig,