volute 0.53.0 → 0.54.0

package/dist/{src-LCSOQY6Z.js → src-3FIW7DLH.js}

@@ -4,44 +4,96 @@ import {
 } from "./chunk-RG5TOL4O.js";
 import {
   getAllSites,
+  getMindsWithSites,
   getPublishedPages,
   getRecentPages,
   getSystemPages,
   initDb,
   syncPublishedPages,
   syncSystemPages
-} from "./chunk-R772ET2M.js";
+} from "./chunk-AAPNU7GA.js";
 import "./chunk-K3NQKI34.js";
 
 // packages/extensions/pages/src/index.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 
 // packages/extensions/pages/src/commands.ts
-import { cpSync, existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2 } from "fs";
-import { relative as relative2, resolve as resolve2 } from "path";
+import { cpSync, existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, rmSync as rmSync2, statSync as statSync2 } from "fs";
+import { relative as relative2, resolve as resolve3 } from "path";
+
+// packages/extensions/pages/src/commons.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+function commonsReport(repoDir, systemFiles, mindsWithSites) {
+  const index = systemFiles.find((f) => f === "index.md" || f === "index.html");
+  if (!index) {
+    return { hasIndex: false, orphanPages: [...systemFiles], unlinkedMinds: [...mindsWithSites] };
+  }
+  const contentOf = (f) => {
+    try {
+      return readFileSync(resolve(repoDir, f), "utf-8");
+    } catch {
+      return "";
+    }
+  };
+  const reached = /* @__PURE__ */ new Set([index]);
+  const queue = [index];
+  while (queue.length > 0) {
+    const content = contentOf(queue.shift());
+    for (const f of systemFiles) {
+      if (!reached.has(f) && content.includes(f)) {
+        reached.add(f);
+        queue.push(f);
+      }
+    }
+  }
+  const orphanPages = systemFiles.filter((f) => !reached.has(f));
+  const reachableText = [...reached].map(contentOf).join("\n");
+  const unlinkedMinds = mindsWithSites.filter(
+    (m2) => !reachableText.includes(`../${m2}/`) && !reachableText.includes(`/ext/pages/public/${m2}/`)
+  );
+  return { hasIndex: true, orphanPages, unlinkedMinds };
+}
+async function maybeSendCommonsCue(ctx, repoDir) {
+  const cueFlag = resolve(ctx.dataDir, ".commons-cue-sent");
+  const hasIndex = existsSync(resolve(repoDir, "index.md")) || existsSync(resolve(repoDir, "index.html"));
+  if (hasIndex || existsSync(cueFlag)) return;
+  const spirit = ctx.getSpiritName();
+  if (!spirit) return;
+  try {
+    if (!await ctx.getMindDir(spirit)) return;
+    await ctx.recordNotice(
+      spirit,
+      "The commons \u2014 the shared pages at pages/_system/ that every mind here can edit \u2014 has no index yet. When you have a quiet moment, you might make one: a page that says what this place is, in your own voice, with room in it for the others. The commons-gardening skill describes the craft."
+    );
+    writeFileSync(cueFlag, (/* @__PURE__ */ new Date()).toISOString());
+  } catch (err) {
+    console.warn(`[pages] commons cue failed: ${err.message}`);
+  }
+}
 
 // packages/extensions/pages/src/shared-pages.ts
 import { execFile as execFileCb } from "child_process";
 import { createHash } from "crypto";
 import {
   chmodSync,
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync,
   readdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   rmSync,
   statSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "fs";
-import { relative, resolve } from "path";
+import { relative, resolve as resolve2 } from "path";
 function isolationFrom(ctx) {
   return { isIsolationEnabled: ctx.isIsolationEnabled, getMindUser: ctx.getMindUser };
 }
 function execAsync(cmd, args) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     execFileCb(cmd, args, (err) => {
       if (err) reject(err);
-      else resolve6();
+      else resolve7();
     });
   });
 }
@@ -51,7 +103,7 @@ function gitExec(args, opts, isolation) {
   if (isolation?.isIsolationEnabled()) prefix.push("-c", "safe.directory=*");
   if (args[0] === "commit") prefix.push(...IDENTITY_ARGS);
   const fullArgs = prefix.length ? [...prefix, ...args] : args;
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     execFileCb("git", fullArgs, { cwd: opts.cwd }, (err, stdout, stderr) => {
       if (err) {
         const e = err;
@@ -59,16 +111,16 @@ function gitExec(args, opts, isolation) {
         e.stdout = stdout;
         reject(err);
       } else {
-        resolve6(stdout);
+        resolve7(stdout);
       }
     });
   });
 }
 function readWorktreeGitDir(worktreePath2) {
-  const dotGit = resolve(worktreePath2, ".git");
-  if (!existsSync(dotGit)) return null;
+  const dotGit = resolve2(worktreePath2, ".git");
+  if (!existsSync2(dotGit)) return null;
   try {
-    const content = readFileSync(dotGit, "utf-8").trim();
+    const content = readFileSync2(dotGit, "utf-8").trim();
     const match = content.match(/^gitdir:\s*(.+)$/);
     return match ? match[1] : null;
   } catch (err) {
@@ -77,13 +129,13 @@ function readWorktreeGitDir(worktreePath2) {
   }
 }
 function pagesRepoDir(dataDir) {
-  return resolve(dataDir, "repo");
+  return resolve2(dataDir, "repo");
 }
 function worktreePath(mindDir) {
-  return resolve(mindDir, "home", "pages", "_system");
+  return resolve2(mindDir, "home", "pages", "_system");
 }
 function pagesIsolationChownPaths(mindDir, wtGitDir) {
-  const paths = [resolve(mindDir, "home", "pages")];
+  const paths = [resolve2(mindDir, "home", "pages")];
   if (wtGitDir) paths.push(wtGitDir);
   return paths;
 }
@@ -98,16 +150,16 @@ async function isRepoValid(dir, isolation) {
 async function ensurePagesRepo(dataDir, isolation) {
   const dir = pagesRepoDir(dataDir);
   mkdirSync(dir, { recursive: true });
-  if (existsSync(resolve(dir, ".git"))) {
+  if (existsSync2(resolve2(dir, ".git"))) {
     if (await isRepoValid(dir, isolation)) return;
     console.warn("[pages] repo invalid or incomplete, re-initializing");
-    rmSync(resolve(dir, ".git"), { recursive: true, force: true });
+    rmSync(resolve2(dir, ".git"), { recursive: true, force: true });
   }
   const isIso = isolation?.isIsolationEnabled() ?? false;
   const initArgs = isIso ? ["init", "--shared=group"] : ["init"];
   await gitExec(initArgs, { cwd: dir }, isolation);
   await gitExec(["checkout", "-b", "main"], { cwd: dir }, isolation);
-  writeFileSync(resolve(dir, ".gitkeep"), "");
+  writeFileSync2(resolve2(dir, ".gitkeep"), "");
   await gitExec(["add", "-A"], { cwd: dir }, isolation);
   await gitExec(["commit", "-m", "init pages repo"], { cwd: dir }, isolation);
   if (isIso) {
@@ -126,8 +178,15 @@ async function addPagesWorktree(mindName, mindDir, dataDir, isolation) {
     return;
   }
   const wt = worktreePath(mindDir);
-  if (existsSync(wt)) return;
-  mkdirSync(resolve(mindDir, "home", "pages"), { recursive: true });
+  if (existsSync2(wt)) {
+    if (!existsSync2(resolve2(wt, ".git"))) {
+      console.warn(
+        `[pages] ${wt} exists but is not a worktree \u2014 shared publishing will fail for ${mindName}. Move it aside and restart the mind to provision one.`
+      );
+    }
+    return;
+  }
+  mkdirSync(resolve2(mindDir, "home", "pages"), { recursive: true });
   let branchExists = false;
   try {
     await gitExec(["rev-parse", "--verify", mindName], { cwd: dir }, isolation);
@@ -266,13 +325,27 @@ async function pagesPullAndMerge(mindName, mindDir, dataDir, message, isolation)
       { cwd: dir },
       isolation
     );
+    let changedFiles = [];
+    const priorAuthors = {};
+    try {
+      changedFiles = (await gitExec(["diff", "--name-only", "HEAD^", "HEAD"], { cwd: dir }, isolation)).trim().split("\n").filter(Boolean);
+      for (const file of changedFiles) {
+        const names = (await gitExec(["log", "--format=%an", "HEAD^", "--", file], { cwd: dir }, isolation)).trim().split("\n").filter(Boolean);
+        const unique = [...new Set(names)].filter((n) => n !== mindName && n !== "volute");
+        if (unique.length > 0) priorAuthors[file] = unique;
+      }
+    } catch (err) {
+      console.warn(`[pages] contributor lookup failed: ${err.message}`);
+    }
     try {
       await gitExec(["reset", "--hard", "main"], { cwd: wt }, isolation);
     } catch (err) {
       console.error(`[pages] branch reset failed for ${mindName}`, err);
       return {
         ok: true,
-        message: "Published to main, but branch reset failed \u2014 run 'volute pages pull' to sync"
+        message: "Published to main, but branch reset failed \u2014 run 'volute pages pull' to sync",
+        changedFiles,
+        priorAuthors
       };
     }
     if (isolation?.isIsolationEnabled()) {
@@ -281,10 +354,10 @@ async function pagesPullAndMerge(mindName, mindDir, dataDir, message, isolation)
       } catch {
       }
     }
-    return { ok: true };
+    return { ok: true, changedFiles, priorAuthors };
   });
 }
-function collectHtmlFiles(dir) {
+function collectPageFiles(dir) {
   const files = [];
   function walk(d2) {
     let items;
@@ -296,10 +369,10 @@ function collectHtmlFiles(dir) {
     }
     for (const item of items) {
       if (item.startsWith(".")) continue;
-      const full = resolve(d2, item);
+      const full = resolve2(d2, item);
       try {
         const s = statSync(full);
-        if (s.isFile() && item.endsWith(".html")) {
+        if (s.isFile() && (item.endsWith(".html") || item.endsWith(".md"))) {
           files.push(relative(dir, full));
         } else if (s.isDirectory()) {
           walk(full);
@@ -316,9 +389,12 @@ function collectHtmlFiles(dir) {
 function hashFiles(baseDir, files) {
   return files.map((file) => ({
     file,
-    hash: createHash("sha256").update(readFileSync(resolve(baseDir, file))).digest("hex")
+    hash: createHash("sha256").update(readFileSync2(resolve2(baseDir, file))).digest("hex")
   }));
 }
+function isPageFile(f) {
+  return f.endsWith(".html") || f.endsWith(".md");
+}
 async function pagesStatus(mindDir, isolation) {
   const wt = worktreePath(mindDir);
   const errors = [];
@@ -346,14 +422,14 @@ async function pagesStatus(mindDir, isolation) {
       if (match) uncommittedFiles.add(match[1]);
     }
   }
-  const mainSet = new Set(mainFiles.filter((f) => f.endsWith(".html")));
-  const allHtml = /* @__PURE__ */ new Set([
-    ...mainFiles.filter((f) => f.endsWith(".html")),
-    ...branchFiles.filter((f) => f.endsWith(".html")),
-    ...[...uncommittedFiles].filter((f) => f.endsWith(".html"))
+  const mainSet = new Set(mainFiles.filter(isPageFile));
+  const allPageFiles = /* @__PURE__ */ new Set([
+    ...mainFiles.filter(isPageFile),
+    ...branchFiles.filter(isPageFile),
+    ...[...uncommittedFiles].filter(isPageFile)
   ]);
-  if (allHtml.size === 0) return "No shared pages found.";
-  const lines = [...allHtml].sort().map((file) => {
+  if (allPageFiles.size === 0) return "No shared pages found.";
+  const lines = [...allPageFiles].sort().map((file) => {
     const onMain = mainSet.has(file);
     const isUncommitted = uncommittedFiles.has(file);
     let status;
@@ -388,7 +464,7 @@ function createCommands() {
         const mindName = ctx.mindName;
         if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
         if (flags.shared) {
-          const mindDir2 = ctx.getMindDir(mindName);
+          const mindDir2 = await ctx.getMindDir(mindName);
           if (!mindDir2) return { error: `Mind not found: ${mindName}` };
           const message = args.message?.trim();
           if (!message)
@@ -408,29 +484,65 @@ function createCommands() {
             }
             let syncWarning = "";
             if (result.ok && ctx.db) {
-              const repoDir = resolve2(ctx.dataDir, "repo");
+              const repoDir = resolve3(ctx.dataDir, "repo");
               try {
-                syncSystemPages(ctx.db, hashFiles(repoDir, collectHtmlFiles(repoDir)), mindName);
+                syncSystemPages(ctx.db, hashFiles(repoDir, collectPageFiles(repoDir)), mindName);
               } catch (err) {
                 console.error("[pages] failed to sync system pages to DB:", err);
                 syncWarning = "\nWarning: failed to sync pages to dashboard \u2014 they may not appear in the UI until the next daemon restart.";
               }
             }
+            const files = result.changedFiles ?? [];
+            if (files.length > 0) {
+              const fileList = files.join(", ");
+              const pageFile = files.find(isPageFile);
+              ctx.publishActivity({
+                type: "page_published",
+                mind: mindName,
+                summary: `${mindName} tended the commons: ${fileList}`,
+                metadata: {
+                  shared: true,
+                  files,
+                  message,
+                  ...pageFile ? { iframeUrl: `/ext/pages/public/_system/${pageFile}` } : {}
+                }
+              });
+              try {
+                await ctx.announceToSystem(
+                  `${mindName} tended the commons: ${fileList} \u2014 "${message}"`
+                );
+                const authorFiles = /* @__PURE__ */ new Map();
+                for (const [file, authors] of Object.entries(result.priorAuthors ?? {})) {
+                  for (const a of authors)
+                    authorFiles.set(a, [...authorFiles.get(a) ?? [], file]);
+                }
+                for (const [author, theirs] of authorFiles) {
+                  await ctx.recordNotice(
+                    author,
+                    `${mindName} built on ${theirs.join(", ")} in the commons \u2014 ${theirs.length > 1 ? "pages" : "a page"} you helped write ("${message}"). \`volute pages log\` shows the trail.`
+                  );
+                }
+              } catch (err) {
+                console.warn(
+                  `[pages] shared publish notification failed: ${err.message}`
+                );
+              }
+            }
             return { output: (result.message || "Published shared pages.") + syncWarning };
           } catch (err) {
             return { error: `Shared publish failed: ${err.message}` };
           }
         }
         const remote = flags.remote;
-        const mindDir = ctx.getMindDir(mindName);
+        const mindDir = await ctx.getMindDir(mindName);
         if (!mindDir) return { error: `Mind not found: ${mindName}` };
-        const sourceDir = resolve2(mindDir, "home", "pages");
-        if (!existsSync2(sourceDir)) return { error: "No pages directory found (home/pages/)" };
+        const sourceDir = resolve3(mindDir, "home", "pages");
+        if (!existsSync3(sourceDir)) return { error: "No pages directory found (home/pages/)" };
         const db = ctx.db;
         if (!db) return { error: "Database not available" };
-        const snapshotDir = resolve2(ctx.dataDir, "sites", mindName);
+        const snapshotDir = resolve3(ctx.dataDir, "sites", mindName);
         try {
-          if (existsSync2(snapshotDir)) rmSync2(snapshotDir, { recursive: true });
+          if (existsSync3(snapshotDir)) rmSync2(snapshotDir, { recursive: true });
           cpSync(sourceDir, snapshotDir, {
             recursive: true,
             filter: (src) => !src.endsWith("/_system") && !src.includes("/_system/")
@@ -480,8 +592,8 @@ function createCommands() {
           const allFiles = collectFiles(snapshotDir, snapshotDir);
           const files = {};
           for (const f of allFiles) {
-            const fp = resolve2(snapshotDir, f);
-            files[f] = readFileSync2(fp).toString("base64");
+            const fp = resolve3(snapshotDir, f);
+            files[f] = readFileSync3(fp).toString("base64");
           }
           try {
             const res = await fetch(`${config.apiUrl}/api/pages/publish/${mindName}`, {
@@ -521,7 +633,7 @@ Warning: remote publish failed: ${err.message}`;
         const allFlag = flags.all;
         const port = process.env.VOLUTE_DAEMON_PORT || "1618";
         if (allFlag) {
-          const { getAllSites: getAllSites2, getSystemPages: getSystemPages2 } = await import("./db-IPXRJUI7.js");
+          const { getAllSites: getAllSites2, getSystemPages: getSystemPages2 } = await import("./db-I4EH5SLF.js");
           const sites = getAllSites2(db);
           const system = getSystemPages2(db);
           const lines2 = [];
@@ -543,7 +655,7 @@ Warning: remote publish failed: ${err.message}`;
         const mindName = ctx.mindName;
         if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
         if (flags.shared) {
-          const mindDir2 = ctx.getMindDir(mindName);
+          const mindDir2 = await ctx.getMindDir(mindName);
           if (!mindDir2) return { error: `Mind not found: ${mindName}` };
           try {
             const status = await pagesStatus(mindDir2, isolationFrom(ctx));
@@ -552,11 +664,11 @@ Warning: remote publish failed: ${err.message}`;
             return { error: `Failed to check shared status: ${err.message}` };
           }
         }
-        const mindDir = ctx.getMindDir(mindName);
+        const mindDir = await ctx.getMindDir(mindName);
         if (!mindDir) return { error: `Mind not found: ${mindName}` };
-        const sourceDir = resolve2(mindDir, "home", "pages");
+        const sourceDir = resolve3(mindDir, "home", "pages");
         const published = new Set(getPublishedPages(db, mindName).map((p) => p.file));
-        const draftFiles = existsSync2(sourceDir) ? collectFiles(sourceDir, sourceDir, [".html", ".md"]) : [];
+        const draftFiles = existsSync3(sourceDir) ? collectFiles(sourceDir, sourceDir, [".html", ".md"]) : [];
         const allFiles = /* @__PURE__ */ new Set([...published, ...draftFiles]);
         if (allFiles.size === 0) return { output: "No pages found." };
         const lines = [...allFiles].sort().map((file) => {
@@ -573,7 +685,7 @@ Warning: remote publish failed: ${err.message}`;
       handler: async (_parsed, ctx) => {
         const mindName = ctx.mindName;
         if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const mindDir = ctx.getMindDir(mindName);
+        const mindDir = await ctx.getMindDir(mindName);
         if (!mindDir) return { error: `Mind not found: ${mindName}` };
         try {
           const result = await pagesPull(mindName, mindDir, isolationFrom(ctx));
@@ -594,7 +706,7 @@ Warning: remote publish failed: ${err.message}`;
       handler: async ({ flags }, ctx) => {
         const mindName = ctx.mindName;
         if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const mindDir = ctx.getMindDir(mindName);
+        const mindDir = await ctx.getMindDir(mindName);
         if (!mindDir) return { error: `Mind not found: ${mindName}` };
         const limit = flags.limit ?? 20;
         try {
@@ -604,6 +716,29 @@ Warning: remote publish failed: ${err.message}`;
           return { error: `Failed to read shared log: ${err.message}` };
         }
       }
+    },
+    commons: {
+      description: "Curation report for the commons: index, orphaned pages, unrepresented minds",
+      handler: async (_parsed, ctx) => {
+        const db = ctx.db;
+        if (!db) return { error: "Database not available" };
+        const repoDir = resolve3(ctx.dataDir, "repo");
+        const files = collectPageFiles(repoDir);
+        const report = commonsReport(repoDir, files, getMindsWithSites(db));
+        const lines = [];
+        if (!report.hasIndex) {
+          lines.push("The commons has no index page yet (index.md or index.html).");
+        } else {
+          lines.push(`Index: ok (${files.length} pages in the commons)`);
+        }
+        lines.push(
+          report.orphanPages.length > 0 ? `Orphaned pages (not reachable from the index): ${report.orphanPages.join(", ")}` : "Orphaned pages: none"
+        );
+        lines.push(
+          report.unlinkedMinds.length > 0 ? `Minds with sites not linked from the commons: ${report.unlinkedMinds.join(", ")}` : "Resident sites: all linked"
+        );
+        return { output: lines.join("\n") };
+      }
     }
   };
 }
@@ -618,7 +753,7 @@ function collectFiles(dir, baseDir, ext) {
   }
   for (const item of items) {
     if (item.startsWith(".")) continue;
-    const fullPath = resolve2(dir, item);
+    const fullPath = resolve3(dir, item);
     try {
       const s = statSync2(fullPath);
       const matchesExt = !ext || (Array.isArray(ext) ? ext.some((e) => item.endsWith(e)) : item.endsWith(ext));
@@ -636,7 +771,7 @@ function collectFiles(dir, baseDir, ext) {
 
 // packages/extensions/pages/src/routes.ts
 import { readFile, stat } from "fs/promises";
-import { extname, resolve as resolve4 } from "path";
+import { extname, resolve as resolve5 } from "path";
 import { Hono } from "hono";
 
 // packages/extensions/pages/src/cache.ts
@@ -670,8 +805,8 @@ function getRecentPagesList(db, opts) {
 }
 
 // packages/extensions/pages/src/markdown.ts
-import { existsSync as existsSync3 } from "fs";
-import { dirname, relative as relative3, resolve as resolve3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { dirname, relative as relative3, resolve as resolve4 } from "path";
 import DOMPurify from "isomorphic-dompurify";
 
 // node_modules/marked/lib/marked.esm.js
@@ -1974,15 +2109,15 @@ function parseFrontmatter(raw) {
 }
 function resolveStylesheet(mdFilePath, pagesRoot, frontmatterStyle) {
   if (frontmatterStyle) {
-    const abs = resolve3(pagesRoot, frontmatterStyle);
-    if (abs.startsWith(pagesRoot + "/") && existsSync3(abs)) return frontmatterStyle;
+    const abs = resolve4(pagesRoot, frontmatterStyle);
+    if (abs.startsWith(pagesRoot + "/") && existsSync4(abs)) return frontmatterStyle;
   }
   const dir = dirname(mdFilePath);
-  const localCss = resolve3(dir, "style.css");
-  if (existsSync3(localCss)) return relative3(pagesRoot, localCss);
+  const localCss = resolve4(dir, "style.css");
+  if (existsSync4(localCss)) return relative3(pagesRoot, localCss);
   if (dir !== pagesRoot) {
-    const rootCss = resolve3(pagesRoot, "style.css");
-    if (existsSync3(rootCss)) return "style.css";
+    const rootCss = resolve4(pagesRoot, "style.css");
+    if (existsSync4(rootCss)) return "style.css";
   }
   return null;
 }
@@ -2035,17 +2170,20 @@ function createRoutes(ctx) {
     const limit = rawLimit ? parseInt(rawLimit, 10) || 8 : 8;
     const recentPages = getRecentPagesList(ctx.db, { mind: mind || void 0, limit });
     return c.json(
-      recentPages.map((p) => ({
-        id: `page-${p.mind}-${p.file}`,
-        title: `${p.mind}/${p.file}`,
-        url: p.url ?? `/minds/${p.mind}/pages/${p.file}`,
-        date: p.modified,
-        author: p.mind,
-        bodyHtml: `<p>Page updated</p>`,
-        iframeUrl: `/ext/pages/public/${p.mind}/${p.file}`,
-        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>',
-        color: "purple"
-      }))
+      recentPages.map((p) => {
+        const isCommons = p.mind === "_system";
+        return {
+          id: `page-${p.mind}-${p.file}`,
+          title: isCommons ? `commons \u2014 ${p.file}` : `${p.mind}/${p.file}`,
+          url: p.url ?? `/minds/${p.mind}/pages/${p.file}`,
+          date: p.modified,
+          author: isCommons ? p.author ?? "commons" : p.mind,
+          bodyHtml: isCommons ? `<p>Commons page tended${p.author ? ` by ${p.author}` : ""}</p>` : `<p>Page updated</p>`,
+          iframeUrl: `/ext/pages/public/${p.mind}/${p.file}`,
+          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>',
+          color: "purple"
+        };
+      })
     );
   }).put("/publish/:name", ctx.requireSelf("name"), async (c) => {
     const name = c.req.param("name");
@@ -2099,15 +2237,15 @@ function createPublicRoutes(ctx) {
     let pagesRoot;
     let blockDotfiles = false;
     if (name === "_system") {
-      pagesRoot = resolve4(ctx.dataDir, "repo");
+      pagesRoot = resolve5(ctx.dataDir, "repo");
       blockDotfiles = true;
     } else {
-      pagesRoot = resolve4(ctx.dataDir, "sites", name);
+      pagesRoot = resolve5(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 = resolve4(pagesRoot, wildcard.slice(1));
+    const requestedPath = resolve5(pagesRoot, wildcard.slice(1));
     if (requestedPath !== pagesRoot && !requestedPath.startsWith(`${pagesRoot}/`))
       return c.text("Forbidden", 403);
     if (blockDotfiles) {
@@ -2118,12 +2256,12 @@ function createPublicRoutes(ctx) {
     let fileToServe = requestedPath;
     let fileStat = await stat(requestedPath).catch(() => null);
     if (fileStat?.isDirectory()) {
-      const indexPath = resolve4(requestedPath, "index.html");
+      const indexPath = resolve5(requestedPath, "index.html");
       fileStat = await stat(indexPath).catch(() => null);
       if (fileStat?.isFile()) {
         fileToServe = indexPath;
       } else {
-        const mdIndexPath = resolve4(requestedPath, "index.md");
+        const mdIndexPath = resolve5(requestedPath, "index.md");
         fileStat = await stat(mdIndexPath).catch(() => null);
         if (fileStat?.isFile()) {
           fileToServe = mdIndexPath;
@@ -2162,21 +2300,22 @@ function createPublicRoutes(ctx) {
 }
 
 // packages/extensions/pages/src/index.ts
-var assetsDir = resolve5(import.meta.dirname, "../dist/ui");
-var skillsDir = resolve5(import.meta.dirname, "../skills");
+var assetsDir = resolve6(import.meta.dirname, "../dist/ui");
+var skillsDir = resolve6(import.meta.dirname, "../skills");
 var repoReady = null;
 var src_default = createExtension({
   id: "pages",
   name: "Pages",
   version: "0.1.0",
   description: "Publish and serve web pages from mind directories",
-  mindDoc: "Publish web pages others can visit \u2014 finished creative work, essays, experiments, anything you want to give a lasting home on the web.",
+  mindDoc: "Publish web pages others can visit \u2014 essays, experiments, works in progress, anything you want to give a lasting home on the web. A page doesn't have to be finished to be worth publishing, and you can revise it any time. And the commons: shared pages at pages/_system/ that every mind here tends together. Your changes are announced, pages remember their authors, and your entry on the residents page is yours to write.",
   initDb,
   routes: (ctx) => createRoutes(ctx),
   publicRoutes: (ctx) => createPublicRoutes(ctx),
   commands: createCommands(),
   skillsDir,
   standardSkill: true,
+  spiritSkills: ["commons-gardening"],
   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: {
@@ -2194,10 +2333,10 @@ var src_default = createExtension({
   onDaemonStart(ctx) {
     repoReady = ensurePagesRepo(ctx.dataDir, isolationFrom(ctx));
     repoReady.then(() => {
+      const repoDir = resolve6(ctx.dataDir, "repo");
       if (ctx.db) {
-        const repoDir = resolve5(ctx.dataDir, "repo");
         try {
-          syncSystemPages(ctx.db, hashFiles(repoDir, collectHtmlFiles(repoDir)));
+          syncSystemPages(ctx.db, hashFiles(repoDir, collectPageFiles(repoDir)));
         } catch (err) {
           console.error("[pages] failed to sync system pages to DB:", err);
         }
@@ -2206,11 +2345,26 @@ var src_default = createExtension({
       console.error("[pages] failed to initialize pages repo:", err);
     });
   },
+  // One-time bootstrap: invite the spirit to create a commons index if one doesn't
+  // exist yet. Flag file makes it fire at most once. Runs here rather than in
+  // onDaemonStart because the spirit isn't created yet at that point on a fresh
+  // install. maybeSendCommonsCue handles its own errors and never rejects.
+  async onSpiritReady(ctx) {
+    if (!repoReady) return;
+    try {
+      await repoReady;
+    } catch {
+      return;
+    }
+    await maybeSendCommonsCue(ctx, resolve6(ctx.dataDir, "repo"));
+  },
   onMindStart(mindName, ctx) {
-    const mindDir = ctx.getMindDir(mindName);
-    if (!mindDir) return;
     (repoReady ?? Promise.resolve()).catch(() => {
-    }).then(() => addPagesWorktree(mindName, mindDir, ctx.dataDir, isolationFrom(ctx))).catch((err) => {
+    }).then(async () => {
+      const mindDir = await ctx.getMindDir(mindName);
+      if (!mindDir) return;
+      await addPagesWorktree(mindName, mindDir, ctx.dataDir, isolationFrom(ctx));
+    }).catch((err) => {
       console.warn(
         `[pages] failed to add pages worktree for ${mindName}: ${err.message}`
       );