volute 0.53.0 → 0.55.0

package/dist/chunk-2GATCSZK.js

@@ -0,0 +1,520 @@
+#!/usr/bin/env node
+
+// packages/extensions/pages/src/db.ts
+function initDb(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS published_pages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      mind TEXT NOT NULL,
+      file TEXT NOT NULL,
+      published_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      author TEXT
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_pp_mind_file ON published_pages(mind, file);
+    CREATE INDEX IF NOT EXISTS idx_pp_updated_at ON published_pages(updated_at);
+    -- The ambient tier filters and orders on published_at (an artifact appears when
+    -- it came into existence, not when it was last edited), and does so on every
+    -- turn of every mind. updated_at was the only indexed date before this.
+    CREATE INDEX IF NOT EXISTS idx_pp_published_at ON published_pages(published_at);
+
+    -- Social layer, keyed on page identity (mind, file) rather than a row id, so a
+    -- thread survives the page being rewritten, republished, or deleted.
+    -- page_hash records the published_pages.hash the comment was written against; a
+    -- mismatch with the page's current hash is exactly what "this comment refers to
+    -- an older version" means. No content snapshotting, no separate versioning.
+    -- body_mind/body_file is the optional page pointer: the comment's body also
+    -- lives as a page in the responder's own space. Without it a comment is a
+    -- pebble and stays cheap; with it the same response also counts as the
+    -- responder's own work. One mechanism at two weights.
+    CREATE TABLE IF NOT EXISTS page_comments (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      mind TEXT NOT NULL,
+      file TEXT NOT NULL,
+      author_id INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      page_hash TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_page_comments_page ON page_comments(mind, file);
+    -- The ambient tier asks "which pages have been spoken on since the horizon" on
+    -- every turn, to avoid grouping over every comment ever written.
+    CREATE INDEX IF NOT EXISTS idx_page_comments_created_at ON page_comments(created_at);
+
+    CREATE TABLE IF NOT EXISTS page_reactions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      mind TEXT NOT NULL,
+      file TEXT NOT NULL,
+      user_id INTEGER NOT NULL,
+      emoji TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_page_reactions_unique
+      ON page_reactions(mind, file, user_id, emoji);
+    CREATE INDEX IF NOT EXISTS idx_page_reactions_page ON page_reactions(mind, file);
+
+    -- Citations: an @name written in a page body. Deliberately NOT a notice \u2014
+    -- where a mention appears decides its tier. In a page body it is a citation:
+    -- ambient, highlighted, exactly the same cost as a link. In a comment it is a
+    -- hail and goes down the recordNotice path. If naming a mind obligated them
+    -- while linking their work did not, a small house would learn to cite by link
+    -- and never by name.
+    --
+    -- The mentioned column is the name as written, NOT a verified user. Extracting it
+    -- happens while reading files off disk (describePages), which is synchronous
+    -- and has no user lookup; resolution happens at query time instead, where
+    -- citationsOf() is always called with a real username. A row for an @token
+    -- that belongs to nobody is simply never matched, so the index costs a little
+    -- noise rather than an async dependency in the publish path.
+    CREATE TABLE IF NOT EXISTS page_citations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      mind TEXT NOT NULL,
+      file TEXT NOT NULL,
+      mentioned TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_page_citations_unique
+      ON page_citations(mind, file, mentioned);
+    CREATE INDEX IF NOT EXISTS idx_page_citations_mentioned ON page_citations(mentioned);
+
+    -- Read signals: that someone opened this page, once per reader per page.
+    --
+    -- Presence, deliberately not a metric. The unique index is the whole design:
+    -- re-opening a page is not more presence, so a second visit writes nothing and
+    -- the row keeps its *first* time. That also means the table cannot answer "how
+    -- often does X come back", which is a question nobody here should be able to
+    -- ask about a reader.
+    --
+    -- The author of a page is never recorded reading it \u2014 they know they were
+    -- there, and counting it would make the number mean nothing.
+    --
+    -- created_at is a first-open time rather than a counter so the alibi
+    -- hypothesis in #807 stays checkable later: reads over time next to cross-mind
+    -- comments over time is the measurement, and it needs timestamps, not totals.
+    -- Two honest limits on that. It is a live table, not an audit log: rows go
+    -- when a page is hard-deleted (see retirePage), so the series under-counts
+    -- reads of pages that were later removed \u2014 plausibly the pages that landed
+    -- least. And a re-measure should be taken from this table directly rather
+    -- than assuming it is complete back to the beginning.
+    CREATE TABLE IF NOT EXISTS page_reads (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      mind TEXT NOT NULL,
+      file TEXT NOT NULL,
+      reader_id INTEGER NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_page_reads_unique
+      ON page_reads(mind, file, reader_id);
+    CREATE INDEX IF NOT EXISTS idx_page_reads_page ON page_reads(mind, file);
+
+    -- Links from a page to another mind's site. The second highlighting signal in
+    -- the ambient tier, alongside page_citations, and the same weight as one: a
+    -- page that links your work is highlighted, never promoted to a notice.
+    --
+    -- Same shape and same honesty as page_citations: target is the name as
+    -- written, not a verified user, because extraction happens while reading files
+    -- off disk and has no user lookup. Detection is the crude substring test from
+    -- commonsReport rather than a second, cleverer one \u2014 see links.ts.
+    CREATE TABLE IF NOT EXISTS page_links (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      mind TEXT NOT NULL,
+      file TEXT NOT NULL,
+      target TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_page_links_unique
+      ON page_links(mind, file, target);
+    CREATE INDEX IF NOT EXISTS idx_page_links_target ON page_links(target);
+
+    -- What the ambient tier has already put in front of a mind.
+    --
+    -- Read this next to ambient_state, because the pair is the whole of #807's
+    -- "watermark, never an unread set", and it is easy to mistake this table for
+    -- the thing that rule forbids.
+    --
+    -- The forbidden structure is a set of things a mind *has not* seen: it grows
+    -- when the house is productive, it is answerable to "how many are left", and
+    -- it turns into a backlog the moment anything renders it. This table is the
+    -- exact inverse \u2014 a record of what has *already* been shown, which only ever
+    -- suppresses. It cannot be counted into a debt because everything in it is
+    -- done. Nothing outside the selection filter ever reads it, and no query here
+    -- asks it what is missing.
+    --
+    -- The watermark alone would very nearly do this job, and briefly did: advance
+    -- it past everything considered, and an artifact is structurally unrepeatable.
+    -- It is kept as well because a timestamp comparison quietly stops guaranteeing
+    -- anything whenever a timestamp moves \u2014 republishing over a tombstone revives
+    -- published_at, and the notes migration writes historical ones. A guarantee
+    -- that survives only while nobody rewrites a date is not a guarantee.
+    --
+    -- Two timestamps, because the tiers ask different questions of this table:
+    --
+    --   created_at    \u2014 the FIRST time this artifact was ever put in front of this
+    --                   mind. The ambient *live* tier keys off mere existence of
+    --                   the row: a page is announced as new exactly once, ever.
+    --   last_shown_at \u2014 the MOST RECENT time. The *archive* tier keys off this,
+    --                   because it is allowed to come back around.
+    --
+    -- Once-ever is right for "whorl published a thing" and wrong for the archive.
+    -- Applied to the archive it produces a terminal state: a mind that has walked
+    -- the whole shelf never hears from that tier again \u2014 weeks away at this
+    -- corpus size, not years \u2014 and then a quiet house makes a quiet digest makes a
+    -- quiet house. That spiral is the exact thing the retrospective tier exists to
+    -- break, so it must not be the tier that starts it. Re-encountering a page you
+    -- read half a year ago is not repetition; it is what an archive is *for*.
+    --
+    -- The author column is denormalized so fairness weighting is one grouped read on the
+    -- turn path: "whose work has this mind met least" is the selection's central
+    -- question and must not cost a join per candidate.
+    CREATE TABLE IF NOT EXISTS ambient_shown (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      viewer TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      ref TEXT NOT NULL,
+      last_shown_at TEXT,
+      author TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_ambient_shown_unique
+      ON ambient_shown(viewer, kind, ref);
+    CREATE INDEX IF NOT EXISTS idx_ambient_shown_author ON ambient_shown(viewer, author);
+
+    -- Per-mind ambient state: how far back to look, and when we last spoke.
+    --
+    -- The watermark is a horizon, not a queue head. It advances to *now* whenever a
+    -- block is emitted, which means anything new that the block did not select is
+    -- dropped from the live tier rather than held for later. That is deliberate
+    -- and it is the design: a mind returning meets what is on the shelf now, not
+    -- an accumulation. Work that falls past the horizon is not lost \u2014 the
+    -- retrospective tier reaches into the archive, which is precisely where old
+    -- work belongs.
+    --
+    -- A row is created with watermark = now on a mind's first ask, so a mind
+    -- that has just arrived is not handed the entire history as though it were
+    -- news. Its introduction to the archive is the retrospective tier's job, at a
+    -- pace that tier chooses.
+    --
+    -- The last_block_at column is the rate limit. A burst of publishes produces one block,
+    -- not one per page.
+    CREATE TABLE IF NOT EXISTS ambient_state (
+      viewer TEXT PRIMARY KEY,
+      watermark TEXT NOT NULL,
+      last_block_at TEXT
+    );
+
+    -- Ledger for the one-way notes -> pages migration. Keyed on the source note id
+    -- so a re-run is a no-op rather than a second set of files and threads.
+    CREATE TABLE IF NOT EXISTS migrated_notes (
+      note_id INTEGER PRIMARY KEY,
+      mind TEXT NOT NULL,
+      file TEXT NOT NULL,
+      migrated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    -- One-time homepage invitations. A row means the cue was delivered \u2014 written
+    -- only after a successful recordNotice, so a failed send retries on the next
+    -- mind start rather than being lost. Per-mind rather than a flag file (the way
+    -- the commons cue flags the spirit) because every mind gets one, not just the spirit.
+    CREATE TABLE IF NOT EXISTS homepage_cue_sent (
+      mind TEXT PRIMARY KEY,
+      sent_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  addColumns(db, "published_pages", [
+    "author TEXT",
+    "hash TEXT",
+    "deleted_at TEXT",
+    // Per-page `comments: false` frontmatter. Default open — not everything wants
+    // to be an invitation, but the default is that it is.
+    "comments_closed INTEGER NOT NULL DEFAULT 0"
+  ]);
+  addColumns(db, "ambient_shown", ["last_shown_at TEXT"]);
+  addColumns(db, "page_comments", [
+    // "comment" (a response) or "publish" (the --shared message that explains a
+    // change). Both live in the thread; only a response is an invitation.
+    "kind TEXT NOT NULL DEFAULT 'comment'",
+    "body_mind TEXT",
+    "body_file TEXT"
+  ]);
+}
+function addColumns(db, table, columns) {
+  for (const column of columns) {
+    try {
+      db.exec(`ALTER TABLE ${table} ADD COLUMN ${column}`);
+    } catch (err) {
+      if (!(err instanceof Error) || !err.message.includes("duplicate column")) {
+        throw err;
+      }
+    }
+  }
+}
+function isSiteHome(file) {
+  return file === "index.html" || file === "index.md";
+}
+function sortSiteFiles(files) {
+  return [...files].sort((a, b) => {
+    if (isSiteHome(a.file) !== isSiteHome(b.file)) return isSiteHome(a.file) ? -1 : 1;
+    return b.updated_at.localeCompare(a.updated_at);
+  });
+}
+function getPublishedPages(db, mind) {
+  return db.prepare(
+    `SELECT file, published_at, updated_at, author FROM published_pages
+       WHERE mind = ? AND deleted_at IS NULL ORDER BY file`
+  ).all(mind);
+}
+function getRecentPages(db, opts) {
+  const limit = opts?.limit ?? 10;
+  if (opts?.mind) {
+    return db.prepare(
+      `SELECT mind, file, updated_at, author FROM published_pages
+         WHERE mind = ? AND deleted_at IS NULL ORDER BY updated_at DESC LIMIT ?`
+    ).all(opts.mind, limit);
+  }
+  return db.prepare(
+    `SELECT mind, file, updated_at, author FROM published_pages
+       WHERE deleted_at IS NULL ORDER BY updated_at DESC LIMIT ?`
+  ).all(limit);
+}
+function getAllSites(db) {
+  const rows = db.prepare(
+    `SELECT mind, file, updated_at, author FROM published_pages
+       WHERE mind != '_system' AND deleted_at IS NULL ORDER BY updated_at DESC, id DESC`
+  ).all();
+  const siteMap = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let files = siteMap.get(row.mind);
+    if (!files) {
+      files = [];
+      siteMap.set(row.mind, files);
+    }
+    files.push({ file: row.file, updated_at: row.updated_at, author: row.author });
+  }
+  return Array.from(siteMap.entries()).map(([mind, files]) => ({
+    mind,
+    files: sortSiteFiles(files)
+  }));
+}
+function getSystemPages(db) {
+  const rows = db.prepare(
+    `SELECT mind, file, updated_at, author FROM published_pages
+       WHERE mind = '_system' AND deleted_at IS NULL ORDER BY updated_at DESC, id DESC`
+  ).all();
+  if (rows.length === 0) return null;
+  return {
+    mind: "_system",
+    files: sortSiteFiles(
+      rows.map((r) => ({ file: r.file, updated_at: r.updated_at, author: r.author }))
+    )
+  };
+}
+function getMindsWithSites(db) {
+  return db.prepare(
+    `SELECT DISTINCT mind FROM published_pages
+         WHERE mind != '_system' AND deleted_at IS NULL ORDER BY mind`
+  ).all().map((r) => r.mind);
+}
+function getPage(db, mind, file) {
+  return db.prepare(
+    `SELECT mind, file, hash, published_at, updated_at, author, deleted_at
+         FROM published_pages WHERE mind = ? AND file = ?`
+  ).get(mind, file) ?? null;
+}
+function getLivePageFiles(db, mind) {
+  return db.prepare(
+    "SELECT file FROM published_pages WHERE mind = ? AND deleted_at IS NULL ORDER BY file"
+  ).all(mind).map((r) => r.file);
+}
+function knownPageFiles(db, mind) {
+  const rows = db.prepare("SELECT file FROM published_pages WHERE mind = ?").all(mind);
+  return new Set(rows.map((r) => r.file));
+}
+function pagesWithThreads(db, mind) {
+  const rows = db.prepare(
+    `SELECT file FROM page_comments WHERE mind = ?
+       UNION SELECT file FROM page_reactions WHERE mind = ?`
+  ).all(mind, mind);
+  return new Set(rows.map((r) => r.file));
+}
+function retirePage(db, mind, file, hasThread) {
+  if (hasThread) {
+    db.prepare(
+      `UPDATE published_pages SET deleted_at = datetime('now')
+       WHERE mind = ? AND file = ? AND deleted_at IS NULL`
+    ).run(mind, file);
+  } else {
+    db.prepare("DELETE FROM published_pages WHERE mind = ? AND file = ?").run(mind, file);
+    db.prepare("DELETE FROM page_reads WHERE mind = ? AND file = ?").run(mind, file);
+  }
+  db.prepare("DELETE FROM page_citations WHERE mind = ? AND file = ?").run(mind, file);
+  db.prepare("DELETE FROM page_links WHERE mind = ? AND file = ?").run(mind, file);
+}
+function existingPages(db, mind) {
+  const rows = db.prepare("SELECT file, hash, deleted_at FROM published_pages WHERE mind = ?").all(mind);
+  return new Map(rows.map((r) => [r.file, r]));
+}
+function applyPageMeta(db, mind, page) {
+  if (page.commentsClosed !== void 0) {
+    db.prepare("UPDATE published_pages SET comments_closed = ? WHERE mind = ? AND file = ?").run(
+      page.commentsClosed ? 1 : 0,
+      mind,
+      page.file
+    );
+  }
+  if (page.links !== void 0) {
+    db.prepare("DELETE FROM page_links WHERE mind = ? AND file = ?").run(mind, page.file);
+    for (const target of page.links) {
+      if (target === mind) continue;
+      db.prepare("INSERT OR IGNORE INTO page_links (mind, file, target) VALUES (?, ?, ?)").run(
+        mind,
+        page.file,
+        target
+      );
+    }
+  }
+  if (page.mentions === void 0) return;
+  db.prepare("DELETE FROM page_citations WHERE mind = ? AND file = ?").run(mind, page.file);
+  for (const mentioned of page.mentions) {
+    if (mentioned === mind) continue;
+    db.prepare("INSERT OR IGNORE INTO page_citations (mind, file, mentioned) VALUES (?, ?, ?)").run(
+      mind,
+      page.file,
+      mentioned
+    );
+  }
+}
+function areCommentsClosed(db, mind, file) {
+  const row = db.prepare("SELECT comments_closed FROM published_pages WHERE mind = ? AND file = ?").get(mind, file);
+  return !!row?.comments_closed;
+}
+function citationsOf(db, mentioned) {
+  return db.prepare(
+    `SELECT c.mind, c.file, c.created_at FROM page_citations c
+       JOIN published_pages p ON p.mind = c.mind AND p.file = c.file
+       WHERE c.mentioned = ? AND p.deleted_at IS NULL
+       ORDER BY c.created_at DESC, c.id DESC`
+  ).all(mentioned);
+}
+function syncSystemPages(db, pages, author) {
+  const existing = existingPages(db, "_system");
+  const newSet = new Set(pages.map((p) => p.file));
+  const threaded = pagesWithThreads(db, "_system");
+  db.exec("BEGIN");
+  try {
+    for (const page of pages) {
+      const { file, hash } = page;
+      const prior = existing.get(file);
+      if (!prior) {
+        db.prepare(
+          "INSERT INTO published_pages (mind, file, hash, author) VALUES ('_system', ?, ?, ?)"
+        ).run(file, hash, author ?? null);
+      } else if (prior.deleted_at != null) {
+        db.prepare(
+          `UPDATE published_pages
+           SET deleted_at = NULL, updated_at = datetime('now'), hash = ?,
+               author = COALESCE(?, author)
+           WHERE mind = '_system' AND file = ?`
+        ).run(hash, author ?? null, file);
+      } else if (prior.hash !== hash) {
+        if (author) {
+          db.prepare(
+            "UPDATE published_pages SET updated_at = datetime('now'), hash = ?, author = ? WHERE mind = '_system' AND file = ?"
+          ).run(hash, author, file);
+        } else {
+          db.prepare(
+            "UPDATE published_pages SET updated_at = datetime('now'), hash = ? WHERE mind = '_system' AND file = ?"
+          ).run(hash, file);
+        }
+      }
+      applyPageMeta(db, "_system", page);
+    }
+    for (const [file, prior] of existing) {
+      if (!newSet.has(file) && prior.deleted_at == null) {
+        retirePage(db, "_system", file, threaded.has(file));
+      }
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+function syncPublishedPages(db, mind, pages) {
+  const existing = existingPages(db, mind);
+  const newSet = new Set(pages.map((p) => p.file));
+  const threaded = pagesWithThreads(db, mind);
+  const added = [];
+  const updated = [];
+  const removed = [];
+  db.exec("BEGIN");
+  try {
+    for (const page of pages) {
+      const { file, hash } = page;
+      const prior = existing.get(file);
+      if (!prior) {
+        db.prepare("INSERT INTO published_pages (mind, file, hash) VALUES (?, ?, ?)").run(
+          mind,
+          file,
+          hash
+        );
+        added.push(file);
+      } else if (prior.deleted_at != null) {
+        db.prepare(
+          `UPDATE published_pages SET deleted_at = NULL, updated_at = datetime('now'), hash = ?
+           WHERE mind = ? AND file = ?`
+        ).run(hash, mind, file);
+        added.push(file);
+      } else if (prior.hash !== hash) {
+        db.prepare(
+          "UPDATE published_pages SET updated_at = datetime('now'), hash = ? WHERE mind = ? AND file = ?"
+        ).run(hash, mind, file);
+        updated.push(file);
+      }
+      applyPageMeta(db, mind, page);
+    }
+    for (const [file, prior] of existing) {
+      if (!newSet.has(file) && prior.deleted_at == null) {
+        retirePage(db, mind, file, threaded.has(file));
+        removed.push(file);
+      }
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+  return { added, removed, updated };
+}
+function upsertPageWithTimestamps(db, mind, file, hash, publishedAt, updatedAt, author) {
+  const prior = db.prepare("SELECT id FROM published_pages WHERE mind = ? AND file = ?").get(mind, file);
+  if (prior) {
+    db.prepare(
+      `UPDATE published_pages
+       SET hash = ?, published_at = ?, updated_at = ?, author = ?, deleted_at = NULL
+       WHERE id = ?`
+    ).run(hash, publishedAt, updatedAt, author ?? null, prior.id);
+    return;
+  }
+  db.prepare(
+    `INSERT INTO published_pages (mind, file, hash, published_at, updated_at, author)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(mind, file, hash, publishedAt, updatedAt, author ?? null);
+}
+
+export {
+  initDb,
+  isSiteHome,
+  getPublishedPages,
+  getRecentPages,
+  getAllSites,
+  getSystemPages,
+  getMindsWithSites,
+  getPage,
+  getLivePageFiles,
+  knownPageFiles,
+  areCommentsClosed,
+  citationsOf,
+  syncSystemPages,
+  syncPublishedPages,
+  upsertPageWithTimestamps
+};

package/dist/{chunk-P2TBUKLW.js → chunk-3SFKY4GI.js}

@@ -2,17 +2,17 @@
 import {
   getSleepManagerIfReady,
   startSpiritFull
-} from "./chunk-HASADR3E.js";
+} from "./chunk-NCRG4SBR.js";
 import {
   spiritCreationInProgress
-} from "./chunk-5DBGQBQR.js";
+} from "./chunk-UEZC5MNB.js";
 import {
   MindStartupError,
   tryGetMindManager
-} from "./chunk-23UJGVYP.js";
+} from "./chunk-HLWQ3P3R.js";
 import {
   logger_default
-} from "./chunk-QUSMYGNQ.js";
+} from "./chunk-2674KIGI.js";
 import {
   computeSetupStatus,
   findMind,

package/dist/{chunk-RMADJFA7.js → chunk-45QTYKQQ.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
-import {
-  MEMORY_PLACEHOLDER_MARKER,
-  ORIENTATION_MARKER
-} from "./chunk-AP2KQMMW.js";
 import {
   safeResolveWithinBase
 } from "./chunk-DW4TRDOZ.js";
 import {
   readVoluteConfig
 } from "./chunk-WCFSBH33.js";
+import {
+  MEMORY_PLACEHOLDER_MARKER,
+  ORIENTATION_MARKER
+} from "./chunk-HTSWDOJE.js";
 import {
   isImagegenEnabled
 } from "./chunk-H6X6CKDN.js";

package/dist/{chunk-TAWRJ24T.js → chunk-4VAQKLMU.js}

@@ -2,10 +2,10 @@
 import {
   exec,
   gitExec
-} from "./chunk-M77B73VV.js";
+} from "./chunk-OIOW3FPT.js";
 import {
   logger_default
-} from "./chunk-QUSMYGNQ.js";
+} from "./chunk-2674KIGI.js";
 import {
   getDb,
   mindDir,
@@ -45,7 +45,7 @@ async function initDefaultSkills() {
   const config = readGlobalConfig();
   let extensionSkills = [];
   try {
-    const { getExtensionStandardSkills } = await import("./extensions-VACUKFA5.js");
+    const { getExtensionStandardSkills } = await import("./extensions-QD22GXZD.js");
     extensionSkills = getExtensionStandardSkills();
   } catch (err) {
     logger_default.warn("failed to load extension standard skills during init", logger_default.errorData(err));
@@ -54,9 +54,12 @@ async function initDefaultSkills() {
   const current = config.defaultSkills ?? [];
   const removed = new Set(config.removedDefaultSkills ?? []);
   const toAdd = [...desired].filter((s) => !current.includes(s) && !removed.has(s));
-  if (toAdd.length === 0 && current.length > 0) return;
-  const merged = [.../* @__PURE__ */ new Set([...current, ...toAdd])];
+  const pool = new Set((await listSharedSkills()).map((s) => s.id));
+  const stale = pool.size > 0 ? current.filter((s) => !pool.has(s)) : [];
+  if (toAdd.length === 0 && stale.length === 0 && current.length > 0) return;
+  const merged = [.../* @__PURE__ */ new Set([...current, ...toAdd])].filter((s) => !stale.includes(s));
   writeGlobalConfig({ ...config, defaultSkills: merged });
+  if (stale.length > 0) logger_default.info(`dropped default skills not in the pool: ${stale.join(", ")}`);
   logger_default.info(`updated default skills: ${merged.join(", ")}`);
 }
 function validateSkillId(id) {

package/dist/{chunk-OXWUEU5V.js → chunk-5U5GLZSD.js}

@@ -3,10 +3,10 @@ import {
   LAUNCHD_PLIST_LABEL,
   LAUNCHD_PLIST_PATH,
   USER_SYSTEMD_UNIT
-} from "./chunk-6NLW72HP.js";
+} from "./chunk-CKPAVQNK.js";
 import {
   resolveVoluteBin
-} from "./chunk-M77B73VV.js";
+} from "./chunk-OIOW3FPT.js";
 
 // packages/daemon/src/lib/config/service-install.ts
 import { execFile } from "child_process";

package/dist/{chunk-TPX6E6PL.js → chunk-6HBGUPBA.js}

@@ -2,10 +2,10 @@
 import {
   bufferEvent,
   subscribe
-} from "./chunk-U54PJPTB.js";
+} from "./chunk-PRZUBJ4K.js";
 import {
   logger_default
-} from "./chunk-QUSMYGNQ.js";
+} from "./chunk-2674KIGI.js";
 import {
   getDb
 } from "./chunk-H6X6CKDN.js";

package/dist/{chunk-UFTDRTCP.js → chunk-7AA4T2RT.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   publish
-} from "./chunk-U54PJPTB.js";
+} from "./chunk-PRZUBJ4K.js";
 import {
   logger_default
-} from "./chunk-QUSMYGNQ.js";
+} from "./chunk-2674KIGI.js";
 
 // packages/daemon/src/lib/events/mind-activity-tracker.ts
 var IDLE_TIMEOUT_MS = 5 * 60 * 1e3;

package/dist/{chunk-LN7XJ56R.js → chunk-7XKPG66D.js}

@@ -3,20 +3,20 @@ import {
   compactDateTime,
   isCompact
 } from "./chunk-7YJY3F2R.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-LOPXTW6H.js";
 import {
   resolveMindName
 } from "./chunk-BTY4WNFE.js";
-import {
-  command,
-  subcommands
-} from "./chunk-TXSA4Q3V.js";
 import {
   daemonFetch
 } from "./chunk-M74I3HHF.js";
 import {
-  getClient,
-  urlOf
-} from "./chunk-LOPXTW6H.js";
+  command,
+  subcommands
+} from "./chunk-TXSA4Q3V.js";
 
 // packages/cli/src/commands/clock.ts
 import { CronExpressionParser } from "cron-parser";
@@ -279,11 +279,11 @@ var cmd = subcommands({
     },
     sleep: {
       description: "Put a mind to sleep",
-      run: (args) => import("./mind-sleep-D3DEYAWG.js").then((m) => m.run(args))
+      run: (args) => import("./mind-sleep-24HV4RCA.js").then((m) => m.run(args))
     },
     wake: {
       description: "Wake a sleeping mind",
-      run: (args) => import("./mind-wake-DCDFFQKX.js").then((m) => m.run(args))
+      run: (args) => import("./mind-wake-LDGPRA42.js").then((m) => m.run(args))
     }
   },
   footer: "Use --mind <name> or VOLUTE_MIND to identify the mind."