volute 0.54.0 → 0.56.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-I7U5EEZC.js → chunk-2LFTJNVH.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   setBridgeConfig
-} from "./chunk-L7BKTZ5U.js";
+} from "./chunk-2QLWAYIU.js";
 import {
   readEnv,
   sharedEnvPath,
   writeEnv
-} from "./chunk-GLM7TVWP.js";
+} from "./chunk-OHHS5PSI.js";
 
 // packages/daemon/src/lib/template/import-utils.ts
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";

package/dist/{chunk-L7BKTZ5U.js → chunk-2QLWAYIU.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   logger_default
-} from "./chunk-QUSMYGNQ.js";
+} from "./chunk-2674KIGI.js";
 import {
   voluteSystemDir
-} from "./chunk-H6X6CKDN.js";
+} from "./chunk-TAVIVN2I.js";
 
 // packages/daemon/src/lib/bridges/bridges.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-F6D766VQ.js → chunk-45MCH4G4.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   logger_default
-} from "./chunk-QUSMYGNQ.js";
+} from "./chunk-2674KIGI.js";
 import {
   stateDir
-} from "./chunk-H6X6CKDN.js";
+} from "./chunk-TAVIVN2I.js";
 
 // packages/daemon/src/lib/chat/file-sharing.ts
 import { randomBytes } from "crypto";

package/dist/{chunk-OGPVJ53N.js → chunk-4RZS7XCV.js}

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
 import {
   getMindManager
-} from "./chunk-WHL6PKYP.js";
+} from "./chunk-PAO7JZNW.js";
 import {
   chownMindDir,
   gitExec
-} from "./chunk-OIOW3FPT.js";
+} from "./chunk-NA2NJXY4.js";
 import {
   logger_default
-} from "./chunk-QUSMYGNQ.js";
+} from "./chunk-2674KIGI.js";
 import {
   deleteMindDbFootprint,
   mindDir,
   readAllMinds,
   removeMind
-} from "./chunk-H6X6CKDN.js";
+} from "./chunk-TAVIVN2I.js";
 
 // packages/daemon/src/lib/mind/variant-cleanup.ts
 import { existsSync, readdirSync, rmSync, statSync } from "fs";
@@ -29,7 +29,7 @@ async function cleanupVariant(variantName, baseName, projectRoot, variantPath, o
   }
   let branchName = opts?.branch;
   if (!branchName) {
-    const { findMind } = await import("./registry-TRC2HJXR.js");
+    const { findMind } = await import("./registry-BTQXLDW6.js");
     const variantEntry = await findMind(variantName);
     branchName = variantEntry?.branch ?? variantName;
   }

package/dist/{chunk-HKGYZVWN.js → chunk-6LICEQGP.js}

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
 import {
+  parseDbTimestamp,
   publish
-} from "./chunk-LNNI3MS4.js";
+} from "./chunk-MNKPAAQF.js";
 import {
   logger_default
-} from "./chunk-QUSMYGNQ.js";
+} from "./chunk-2674KIGI.js";
 import {
   findMind,
   getBaseName,
   getDb
-} from "./chunk-H6X6CKDN.js";
+} from "./chunk-TAVIVN2I.js";
 import {
   mindHistory,
   systemEvents,
@@ -257,7 +258,7 @@ async function deliverEvent(mind, input) {
       return { id: eventId, delivered: false };
     }
     const baseName = await getBaseName(mind);
-    const { getSleepManagerIfReady } = await import("./sleep-manager-KHI65FEX.js");
+    const { getSleepManagerIfReady } = await import("./sleep-manager-25P44HAO.js");
     const sleepManager = getSleepManagerIfReady();
     const sleeping = !input.force && sleepManager?.isSleeping(baseName);
     const behavior = input.whileSleeping ?? "queue";
@@ -523,6 +524,38 @@ async function hasUndeliveredEvent(mind, reason) {
   ).limit(1).get();
   return row != null;
 }
+var STRANDED_EVENT_TURN_THRESHOLD = 10;
+async function findStrandedEventMinds(turnThreshold = STRANDED_EVENT_TURN_THRESHOLD) {
+  const db = await getDb();
+  const groups = await db.select({
+    mind: systemEvents.mind,
+    pending: sql`count(*)`,
+    oldestId: sql`min(${systemEvents.id})`
+  }).from(systemEvents).where(and(eq(systemEvents.delivery, "next-turn"), isNull(systemEvents.delivered_at))).groupBy(systemEvents.mind);
+  const stranded = [];
+  for (const group of groups) {
+    const oldest = await db.select({ created_at: systemEvents.created_at }).from(systemEvents).where(eq(systemEvents.id, group.oldestId)).get();
+    if (!oldest) continue;
+    const turnCount = await db.select({ n: sql`count(*)` }).from(turns).where(
+      and(
+        eq(turns.mind, group.mind),
+        eq(turns.status, "complete"),
+        gt(turns.created_at, oldest.created_at)
+      )
+    ).get();
+    const turnsSince = turnCount?.n ?? 0;
+    if (turnsSince < turnThreshold) continue;
+    stranded.push({
+      mind: group.mind,
+      pending: group.pending,
+      turnsSince,
+      ageHours: Math.round(
+        (Date.now() - parseDbTimestamp(oldest.created_at).getTime()) / (60 * 60 * 1e3)
+      )
+    });
+  }
+  return stranded;
+}
 async function listEvents(mind, limit = 100, before) {
   const db = await getDb();
   const conditions = [eq(systemEvents.mind, mind)];
@@ -580,6 +613,7 @@ export {
   latestFailureEvent,
   latestEvent,
   hasUndeliveredEvent,
+  findStrandedEventMinds,
   listEvents,
   recordReflection,
   captureReflection

package/dist/{chunk-LAUCO2HC.js → chunk-APDEUAIE.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteSystemDir
-} from "./chunk-H6X6CKDN.js";
+} from "./chunk-TAVIVN2I.js";
 
 // packages/daemon/src/lib/update-check.ts
 import { execFile as execFileCb, execFileSync } from "child_process";