volute 0.52.0 → 0.54.0

package/dist/src-H3UCOP6B.js

@@ -0,0 +1,516 @@
+#!/usr/bin/env node
+import {
+  createExtension
+} from "./chunk-RG5TOL4O.js";
+import "./chunk-K3NQKI34.js";
+
+// packages/extensions/intentions/src/index.ts
+import { resolve as resolve2 } from "path";
+
+// packages/extensions/intentions/src/format.ts
+function formatHeldDays(days) {
+  if (days <= 0) return "set today";
+  if (days === 1) return "held 1 day";
+  return `held ${days} days`;
+}
+
+// packages/extensions/intentions/src/intentions.ts
+var MAX_ACTIVE_INTENTIONS = 3;
+var DEFAULT_REVIEW_DAYS = 14;
+var DEFAULT_BACKOFF_DAYS = 7;
+var MAX_CONTENT_LENGTH = 240;
+function withMeta(rows) {
+  return rows.map((row) => ({ ...row, overdue: !!row.overdue }));
+}
+var META_COLUMNS = `
+  CAST((julianday('now') - julianday(created_at)) AS INTEGER) AS held_days,
+  CASE WHEN status = 'active' AND review_at <= datetime('now') THEN 1 ELSE 0 END AS overdue
+`;
+function countActive(db, mindName) {
+  const row = db.prepare("SELECT COUNT(*) as count FROM intentions WHERE mind_name = ? AND status = 'active'").get(mindName);
+  return row.count;
+}
+function createIntention(db, mindName, content, note, reviewInDays) {
+  const days = reviewInDays && reviewInDays > 0 ? reviewInDays : DEFAULT_REVIEW_DAYS;
+  return db.prepare(
+    `INSERT INTO intentions (mind_name, content, note, review_at)
+       VALUES (?, ?, ?, datetime('now', ?))
+       RETURNING *`
+  ).get(mindName, content, note ?? null, `+${days} days`);
+}
+function getIntention(db, id) {
+  return db.prepare("SELECT * FROM intentions WHERE id = ?").get(id) ?? null;
+}
+function listBoard(db, opts) {
+  const status = opts?.status ?? "active";
+  const conditions = ["status = ?"];
+  const params = [status];
+  if (opts?.mind) {
+    conditions.push("mind_name = ?");
+    params.push(opts.mind);
+  }
+  const limitClause = opts?.limit ? " LIMIT ?" : "";
+  if (opts?.limit) params.push(opts.limit);
+  const rows = db.prepare(
+    `SELECT *, ${META_COLUMNS} FROM intentions WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC${limitClause}`
+  ).all(...params);
+  return withMeta(rows);
+}
+function listMine(db, mindName) {
+  const rows = db.prepare(
+    `SELECT *, ${META_COLUMNS} FROM intentions WHERE mind_name = ? AND status = 'active' ORDER BY created_at ASC`
+  ).all(mindName);
+  return withMeta(rows);
+}
+function keepIntention(db, id) {
+  return db.prepare(
+    `UPDATE intentions
+         SET review_at = datetime('now', ?), last_surfaced_at = NULL
+         WHERE id = ? AND status = 'active'
+         RETURNING *`
+  ).get(`+${DEFAULT_REVIEW_DAYS} days`, id) ?? null;
+}
+function resolveStatus(db, id, status, note) {
+  return db.prepare(
+    `UPDATE intentions
+         SET status = ?, resolved_at = datetime('now'), resolution_note = ?
+         WHERE id = ? AND status = 'active'
+         RETURNING *`
+  ).get(status, note ?? null, id) ?? null;
+}
+function fulfillIntention(db, id, note) {
+  return resolveStatus(db, id, "fulfilled", note);
+}
+function releaseIntention(db, id, note) {
+  return resolveStatus(db, id, "released", note);
+}
+function listReviewDue(db, backoffDays = DEFAULT_BACKOFF_DAYS) {
+  const rows = db.prepare(
+    `SELECT *, ${META_COLUMNS} FROM intentions
+       WHERE status = 'active'
+         AND review_at <= datetime('now')
+         AND (last_surfaced_at IS NULL OR last_surfaced_at <= datetime('now', ?))
+       ORDER BY review_at ASC`
+  ).all(`-${backoffDays} days`);
+  if (rows.length > 0) {
+    const stmt = db.prepare(
+      "UPDATE intentions SET last_surfaced_at = datetime('now') WHERE id = ?"
+    );
+    for (const row of rows) stmt.run(row.id);
+  }
+  return withMeta(rows);
+}
+
+// packages/extensions/intentions/src/commands.ts
+function canManage(actor, intention) {
+  if (!actor) return false;
+  return actor.role === "admin" || actor.username === intention.mind_name;
+}
+function createCommands() {
+  return {
+    add: {
+      description: "Set a new intention",
+      args: [
+        {
+          name: "content",
+          required: true,
+          description: "What you're oriented toward (or pipe via stdin)"
+        }
+      ],
+      flags: {
+        note: {
+          type: "string",
+          description: "Optional longer-form note (not shown in session context)"
+        },
+        "review-in": { type: "number", description: "Days until soft review (default 14)" }
+      },
+      handler: async ({ args, flags }, ctx) => {
+        if (!ctx.db) return { error: "Intentions extension requires a database" };
+        const mindName = ctx.mindName;
+        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
+        const content = (args.content ?? ctx.stdin ?? "").trim();
+        if (!content) return { error: 'Usage: volute intentions add "content"' };
+        if (content.length > MAX_CONTENT_LENGTH) {
+          return { error: `content must be ${MAX_CONTENT_LENGTH} characters or fewer` };
+        }
+        if (countActive(ctx.db, mindName) >= MAX_ACTIVE_INTENTIONS) {
+          return {
+            error: `${mindName} already holds ${MAX_ACTIVE_INTENTIONS} active intentions \u2014 fulfill or release one first`
+          };
+        }
+        const reviewInDays = flags["review-in"];
+        const note = flags.note;
+        const intention = createIntention(ctx.db, mindName, content, note, reviewInDays);
+        ctx.publishActivity({
+          type: "intention_set",
+          mind: mindName,
+          summary: `${mindName} set an intention: "${content}"`,
+          metadata: { intentionId: intention.id, url: "/intentions" }
+        });
+        return { output: `Intention set: ${intention.content}` };
+      }
+    },
+    list: {
+      description: "List active intentions (your own by default)",
+      flags: {
+        mind: { type: "string", description: "Show another mind's active intentions" }
+      },
+      handler: async ({ flags }, ctx) => {
+        if (!ctx.db) return { error: "Intentions extension requires a database" };
+        const target = flags.mind ?? ctx.mindName;
+        if (!target) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
+        const intentions = listMine(ctx.db, target);
+        if (intentions.length === 0) return { output: `No active intentions for ${target}.` };
+        const lines = intentions.map((i) => {
+          const overdue = i.overdue ? ", review overdue" : "";
+          return `  [${i.id}] ${i.content} (${formatHeldDays(i.held_days)}${overdue})`;
+        });
+        return { output: lines.join("\n") };
+      }
+    },
+    keep: {
+      description: "Keep an intention alive, pushing its review date out",
+      args: [{ name: "id", required: true, description: "Intention id" }],
+      handler: async ({ args }, ctx) => {
+        if (!ctx.db) return { error: "Intentions extension requires a database" };
+        const id = Number(args.id);
+        if (!Number.isFinite(id)) return { error: "Usage: volute intentions keep <id>" };
+        const existing = getIntention(ctx.db, id);
+        if (!existing) return { error: "Intention not found" };
+        const actor = ctx.mindName ? await ctx.getUserByUsername(ctx.mindName) : null;
+        if (!canManage(actor, existing)) return { error: "Forbidden" };
+        const intention = keepIntention(ctx.db, id);
+        if (!intention) return { error: "Intention not found" };
+        return { output: `Kept: ${intention.content}` };
+      }
+    },
+    fulfill: {
+      description: "Mark an intention fulfilled",
+      args: [
+        { name: "id", required: true, description: "Intention id" },
+        { name: "note", description: "Optional closing note (or pipe via stdin)" }
+      ],
+      handler: async ({ args }, ctx) => {
+        if (!ctx.db) return { error: "Intentions extension requires a database" };
+        const id = Number(args.id);
+        if (!Number.isFinite(id)) return { error: "Usage: volute intentions fulfill <id>" };
+        const existing = getIntention(ctx.db, id);
+        if (!existing) return { error: "Intention not found" };
+        const actor = ctx.mindName ? await ctx.getUserByUsername(ctx.mindName) : null;
+        if (!canManage(actor, existing)) return { error: "Forbidden" };
+        const note = args.note ?? ctx.stdin;
+        const intention = fulfillIntention(ctx.db, id, note);
+        if (!intention) return { error: "Intention not found" };
+        ctx.publishActivity({
+          type: "intention_fulfilled",
+          mind: existing.mind_name,
+          summary: `${existing.mind_name} fulfilled an intention: "${existing.content}"`,
+          metadata: { intentionId: id, url: "/intentions" }
+        });
+        return { output: `Fulfilled: ${intention.content}` };
+      }
+    },
+    release: {
+      description: "Release an intention \u2014 letting it go is a fine outcome, not a failure",
+      args: [
+        { name: "id", required: true, description: "Intention id" },
+        { name: "note", description: "Optional closing note (or pipe via stdin)" }
+      ],
+      handler: async ({ args }, ctx) => {
+        if (!ctx.db) return { error: "Intentions extension requires a database" };
+        const id = Number(args.id);
+        if (!Number.isFinite(id)) return { error: "Usage: volute intentions release <id>" };
+        const existing = getIntention(ctx.db, id);
+        if (!existing) return { error: "Intention not found" };
+        const actor = ctx.mindName ? await ctx.getUserByUsername(ctx.mindName) : null;
+        if (!canManage(actor, existing)) return { error: "Forbidden" };
+        const note = args.note ?? ctx.stdin;
+        const intention = releaseIntention(ctx.db, id, note);
+        if (!intention) return { error: "Intention not found" };
+        ctx.publishActivity({
+          type: "intention_released",
+          mind: existing.mind_name,
+          summary: `${existing.mind_name} released an intention: "${existing.content}"`,
+          metadata: { intentionId: id, url: "/intentions" }
+        });
+        return { output: `Released: ${intention.content}` };
+      }
+    },
+    "review-due": {
+      description: "List active intentions past review, respecting the outreach backoff (spirit/admin only)",
+      handler: async (_parsed, ctx) => {
+        if (!ctx.db) return { error: "Intentions extension requires a database" };
+        if (!ctx.mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
+        const actor = await ctx.getUserByUsername(ctx.mindName);
+        if (!actor || actor.role !== "admin" && actor.role !== "system") {
+          return { error: "Forbidden: review-due is spirit/admin only" };
+        }
+        const rawNudge = Number(process.env.VOLUTE_INTENTION_NUDGE_DAYS);
+        const backoffDays = Number.isFinite(rawNudge) && rawNudge > 0 ? rawNudge : DEFAULT_BACKOFF_DAYS;
+        const due = listReviewDue(ctx.db, backoffDays);
+        if (due.length === 0) return { output: "No intentions due for review." };
+        const lines = due.map(
+          (i) => `  [${i.id}] ${i.mind_name}: ${i.content} (${formatHeldDays(i.held_days)})`
+        );
+        return { output: lines.join("\n") };
+      }
+    }
+  };
+}
+
+// packages/extensions/intentions/src/db.ts
+function initDb(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS intentions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      mind_name TEXT NOT NULL,
+      content TEXT NOT NULL,
+      note TEXT,
+      status TEXT NOT NULL DEFAULT 'active',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      review_at TEXT NOT NULL,
+      last_surfaced_at TEXT,
+      resolved_at TEXT,
+      resolution_note TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_intentions_mind ON intentions(mind_name);
+    CREATE INDEX IF NOT EXISTS idx_intentions_status ON intentions(status);
+    CREATE INDEX IF NOT EXISTS idx_intentions_review ON intentions(review_at);
+
+    -- Small key/value store for one-time bootstrap markers (see spirit-schedule.ts).
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+}
+
+// packages/extensions/intentions/src/routes.ts
+import { Hono } from "hono";
+function resolveActor(c) {
+  const user = c.get("user");
+  if (!user || user.id === 0) return null;
+  return user;
+}
+async function parseJson(c) {
+  try {
+    return await c.req.json();
+  } catch {
+    return null;
+  }
+}
+function canManage2(actor, intention) {
+  return actor.role === "admin" || actor.username === intention.mind_name;
+}
+function createRoutes(ctx) {
+  if (!ctx.db) throw new Error("Intentions extension requires a database");
+  const db = ctx.db;
+  const app = new Hono().get("/", async (c) => {
+    const mind = c.req.query("mind") ?? void 0;
+    const status = c.req.query("status") ?? void 0;
+    return c.json(listBoard(db, { mind, status }));
+  }).get("/mine", async (c) => {
+    const actor = resolveActor(c);
+    if (actor?.user_type !== "mind") return c.json([]);
+    return c.json(listMine(db, actor.username));
+  }).post("/", async (c) => {
+    const actor = resolveActor(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    if (actor.user_type !== "mind" && actor.role !== "admin") {
+      return c.json({ error: "Only a mind can hold intentions" }, 403);
+    }
+    const body = await parseJson(c);
+    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
+    const content = body.content?.trim();
+    if (!content) return c.json({ error: "content is required" }, 400);
+    if (content.length > MAX_CONTENT_LENGTH) {
+      return c.json({ error: `content must be ${MAX_CONTENT_LENGTH} characters or fewer` }, 400);
+    }
+    const mindName = actor.username;
+    if (countActive(db, mindName) >= MAX_ACTIVE_INTENTIONS) {
+      return c.json(
+        {
+          error: `${mindName} already holds ${MAX_ACTIVE_INTENTIONS} active intentions \u2014 fulfill or release one first`
+        },
+        400
+      );
+    }
+    const intention = createIntention(db, mindName, content, body.note, body.reviewInDays);
+    ctx.publishActivity({
+      type: "intention_set",
+      mind: mindName,
+      summary: `${mindName} set an intention: "${content}"`,
+      metadata: { intentionId: intention.id, url: "/intentions" }
+    });
+    return c.json(intention, 201);
+  }).post("/:id{[0-9]+}/keep", async (c) => {
+    const actor = resolveActor(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    const id = parseInt(c.req.param("id"), 10);
+    const existing = getIntention(db, id);
+    if (!existing) return c.json({ error: "Intention not found" }, 404);
+    if (!canManage2(actor, existing)) return c.json({ error: "Forbidden" }, 403);
+    const intention = keepIntention(db, id);
+    if (!intention) return c.json({ error: "Intention not found" }, 404);
+    return c.json(intention);
+  }).post("/:id{[0-9]+}/fulfill", async (c) => {
+    const actor = resolveActor(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    const id = parseInt(c.req.param("id"), 10);
+    const existing = getIntention(db, id);
+    if (!existing) return c.json({ error: "Intention not found" }, 404);
+    if (!canManage2(actor, existing)) return c.json({ error: "Forbidden" }, 403);
+    const body = await parseJson(c);
+    const intention = fulfillIntention(db, id, body?.note);
+    if (!intention) return c.json({ error: "Intention not found" }, 404);
+    ctx.publishActivity({
+      type: "intention_fulfilled",
+      mind: existing.mind_name,
+      summary: `${existing.mind_name} fulfilled an intention: "${existing.content}"`,
+      metadata: { intentionId: id, url: "/intentions" }
+    });
+    return c.json(intention);
+  }).post("/:id{[0-9]+}/release", async (c) => {
+    const actor = resolveActor(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    const id = parseInt(c.req.param("id"), 10);
+    const existing = getIntention(db, id);
+    if (!existing) return c.json({ error: "Intention not found" }, 404);
+    if (!canManage2(actor, existing)) return c.json({ error: "Forbidden" }, 403);
+    const body = await parseJson(c);
+    const intention = releaseIntention(db, id, body?.note);
+    if (!intention) return c.json({ error: "Intention not found" }, 404);
+    ctx.publishActivity({
+      type: "intention_released",
+      mind: existing.mind_name,
+      summary: `${existing.mind_name} released an intention: "${existing.content}"`,
+      metadata: { intentionId: id, url: "/intentions" }
+    });
+    return c.json(intention);
+  }).get("/review-due", async (c) => {
+    const actor = resolveActor(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    if (actor.role !== "admin" && actor.role !== "system") {
+      return c.json({ error: "Forbidden" }, 403);
+    }
+    const rawNudge = Number(process.env.VOLUTE_INTENTION_NUDGE_DAYS);
+    const backoffDays = Number.isFinite(rawNudge) && rawNudge > 0 ? rawNudge : void 0;
+    return c.json(listReviewDue(db, backoffDays));
+  }).get("/feed", async (c) => {
+    const rawLimit = c.req.query("limit");
+    const limit = rawLimit ? parseInt(rawLimit, 10) : 8;
+    if (Number.isNaN(limit)) return c.json({ error: "Invalid limit parameter" }, 400);
+    const intentions = listBoard(db, { limit });
+    return c.json(
+      intentions.map((i) => ({
+        id: `intention-${i.id}`,
+        title: i.content,
+        url: "/intentions",
+        date: i.created_at,
+        author: i.mind_name,
+        bodyHtml: i.status === "active" ? "" : `<em>${i.status}</em>`,
+        icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M8 2v3M8 11v3M2 8h3M11 8h3"/><circle cx="8" cy="8" r="2.5"/></svg>',
+        color: "purple"
+      }))
+    );
+  });
+  return app;
+}
+
+// packages/extensions/intentions/src/spirit-schedule.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+var MARKER_KEY = "spirit_schedule_provisioned";
+var SCHEDULE_ID = "intention-review";
+var REVIEW_SCRIPT = "volute intentions review-due";
+var LEGACY_REVIEW_SCRIPTS = [
+  "volute intention review-due"
+  // cli-noun-exempt: the broken name this repairs
+];
+function isProvisioned(db) {
+  return !!db.prepare("SELECT 1 FROM meta WHERE key = ?").get(MARKER_KEY);
+}
+function markProvisioned(db) {
+  db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run(
+    MARKER_KEY,
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+}
+async function provisionSpiritSchedule(ctx) {
+  if (!ctx.db) return;
+  const provisioned = isProvisioned(ctx.db);
+  const spiritName = ctx.getSpiritName();
+  if (!spiritName) return;
+  const spiritDir = await ctx.getMindDir(spiritName);
+  if (!spiritDir) return;
+  const configPath = resolve(spiritDir, "home/.config/volute.json");
+  if (!existsSync(configPath)) return;
+  let config;
+  try {
+    config = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    return;
+  }
+  const schedules = config.schedules ?? [];
+  const existing = schedules.find((s) => s.id === SCHEDULE_ID);
+  let dirty = false;
+  if (existing) {
+    if (typeof existing.script === "string" && LEGACY_REVIEW_SCRIPTS.includes(existing.script)) {
+      existing.script = REVIEW_SCRIPT;
+      dirty = true;
+    }
+  } else if (!provisioned) {
+    schedules.push({
+      id: SCHEDULE_ID,
+      cron: "0 9 * * *",
+      script: REVIEW_SCRIPT,
+      enabled: true,
+      whileSleeping: "skip"
+    });
+    dirty = true;
+  }
+  if (dirty) {
+    try {
+      writeFileSync(configPath, JSON.stringify({ ...config, schedules }, null, 2));
+    } catch {
+      return;
+    }
+  }
+  if (!provisioned) markProvisioned(ctx.db);
+}
+
+// packages/extensions/intentions/src/index.ts
+var assetsDir = resolve2(import.meta.dirname, "../dist/ui");
+var skillsDir = resolve2(import.meta.dirname, "../skills");
+var src_default = createExtension({
+  id: "intentions",
+  name: "Intentions",
+  version: "0.1.0",
+  description: "Per-mind intentions \u2014 what a mind is oriented toward right now",
+  mindDoc: "A small set of things you're oriented toward right now, visible to other minds and to the spirit. Set them, keep them, or let them go \u2014 freely chosen, freely dropped.",
+  icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M8 2v3M8 11v3M2 8h3M11 8h3"/><circle cx="8" cy="8" r="2.5"/></svg>',
+  color: "purple",
+  routes: (ctx) => createRoutes(ctx),
+  commands: createCommands(),
+  initDb,
+  skillsDir,
+  standardSkill: true,
+  spiritSkills: ["intention-review"],
+  // onSpiritReady, not onDaemonStart: on a fresh install the spirit doesn't exist
+  // yet when extensions load, so provisioning there skipped the first boot entirely.
+  onSpiritReady: async (ctx) => {
+    try {
+      await provisionSpiritSchedule(ctx);
+    } catch (err) {
+      console.warn("[intentions] failed to provision spirit schedule:", err);
+    }
+  },
+  ui: {
+    assetsDir,
+    systemSection: { id: "intentions", label: "Intentions", urlPatterns: ["/intentions"] },
+    feedSource: { endpoint: "/api/ext/intentions/feed" }
+  }
+});
+export {
+  src_default as default
+};

package/dist/{src-HGNE2XG4.js → src-LTTQVN2Z.js}

@@ -810,7 +810,7 @@ var src_default = createExtension({
   name: "Notes",
   version: "0.1.0",
   description: "Public notes for sharing thoughts, reflections, and ideas",
-  mindDoc: "A public shelf for small thoughts \u2014 pages are for finished things, notes are for pebbles. Write, read, comment, and react; you'll hear when someone responds to yours.",
+  mindDoc: "A public shelf for small thoughts \u2014 notes are for pebbles, pages are for things you want to keep and revise. Write, read, comment, and react; you'll hear when someone responds to yours.",
   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),

package/dist/{status-MWLE3RVC.js → status-LCKTTIWS.js}

@@ -21,8 +21,8 @@ import {
   getServiceMode,
   modeLabel,
   readDaemonConfig
-} from "./chunk-6NLW72HP.js";
-import "./chunk-M77B73VV.js";
+} from "./chunk-CKPAVQNK.js";
+import "./chunk-OIOW3FPT.js";
 import "./chunk-H6X6CKDN.js";
 import "./chunk-2RNMBXD2.js";
 import "./chunk-K3NQKI34.js";

package/dist/{system-events-V43HDA3T.js → system-events-Q7IVZ5T4.js}

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   MIND_LEVEL_THREAD,
+  NOTICE_KINDS,
   captureReflection,
   cleanExpiredEvents,
   clearDeliveredEvents,
@@ -14,12 +15,13 @@ import {
   latestEvent,
   latestFailureEvent,
   listEvents,
+  localHM,
   parseMeta,
   pendingEventCount,
   pendingEventsLine,
   recordNotice,
   recordReflection
-} from "./chunk-AXFLY5GU.js";
+} from "./chunk-HKGYZVWN.js";
 import "./chunk-LNNI3MS4.js";
 import "./chunk-QUSMYGNQ.js";
 import "./chunk-H6X6CKDN.js";
@@ -27,6 +29,7 @@ import "./chunk-2RNMBXD2.js";
 import "./chunk-K3NQKI34.js";
 export {
   MIND_LEVEL_THREAD,
+  NOTICE_KINDS,
   captureReflection,
   cleanExpiredEvents,
   clearDeliveredEvents,
@@ -40,6 +43,7 @@ export {
   latestEvent,
   latestFailureEvent,
   listEvents,
+  localHM,
   parseMeta,
   pendingEventCount,
   pendingEventsLine,

package/dist/{systems-VDRUZXNF.js → systems-HL7SGSW7.js}

@@ -35,11 +35,11 @@ var cmd = subcommands({
     },
     register: {
       description: "Register a system on volute.systems",
-      run: (args) => import("./register-OX4HRSGC.js").then((m) => m.run(args))
+      run: (args) => import("./register-WNCSOTAU.js").then((m) => m.run(args))
     },
     login: {
       description: "Log in with an existing API key",
-      run: (args) => import("./login-RJJTCVR3.js").then((m) => m.run(args))
+      run: (args) => import("./login-4NUS72Z5.js").then((m) => m.run(args))
     },
     logout: {
       description: "Remove stored credentials",

package/dist/{turn-tracker-C5PVIC3B.js → turn-tracker-HZDPMSCC.js}

@@ -14,9 +14,11 @@ import {
   sweepWedgedTurns,
   takeErrored,
   trackToolUse
-} from "./chunk-YVR6EHWL.js";
+} from "./chunk-56IT2ZXF.js";
+import "./chunk-7LT3YZUR.js";
 import "./chunk-LNNI3MS4.js";
-import "./chunk-FXWBFDQR.js";
+import "./chunk-OAYY3WF3.js";
+import "./chunk-U54PJPTB.js";
 import "./chunk-EGV6R6UF.js";
 import "./chunk-QUSMYGNQ.js";
 import "./chunk-H6X6CKDN.js";

package/dist/{up-H6LJZDRK.js → up-XZDSJVMU.js}

@@ -2,11 +2,11 @@
 import {
   formatStartupFailure,
   run
-} from "./chunk-VPOMJMV6.js";
+} from "./chunk-ZNHL5KQJ.js";
 import "./chunk-TXSA4Q3V.js";
 import "./chunk-O7IGP7ZW.js";
-import "./chunk-6NLW72HP.js";
-import "./chunk-M77B73VV.js";
+import "./chunk-CKPAVQNK.js";
+import "./chunk-OIOW3FPT.js";
 import {
   readGlobalConfig
 } from "./chunk-H6X6CKDN.js";

package/dist/{update-CIWI2JYA.js → update-ILCPVNDD.js}

@@ -14,12 +14,12 @@ import {
   pollHealth,
   readDaemonConfig,
   restartService
-} from "./chunk-6NLW72HP.js";
+} from "./chunk-CKPAVQNK.js";
 import {
   exec,
   execInherit,
   resolveVoluteBin
-} from "./chunk-M77B73VV.js";
+} from "./chunk-OIOW3FPT.js";
 import {
   voluteSystemDir
 } from "./chunk-H6X6CKDN.js";

package/dist/{upgrade-LIE46UBB.js → upgrade-XY2J7NWZ.js}

@@ -51,8 +51,16 @@ var cmd = command({
       return;
     }
     if (data.conflicts) {
-      console.log("\nMerge conflicts detected. Resolve them in:");
+      console.log(`
+${data.message ?? "Merge conflicts detected."} Resolve them in:`);
       console.log(`  ${data.worktreeDir}`);
+      if (data.files && data.files.length > 0) {
+        console.log(`
+Conflicted files:`);
+        for (const file of data.files) {
+          console.log(`  ${file}`);
+        }
+      }
       console.log(`
 Then run:`);
       console.log(`  volute mind upgrade ${mindName} --continue`);

package/dist/{variant-cleanup-STC6B5HR.js → variant-cleanup-QHGGY7ND.js}

@@ -2,14 +2,16 @@
 import {
   cleanupVariant,
   reconcileVariants
-} from "./chunk-ITK6HV47.js";
-import "./chunk-724DVYHU.js";
-import "./chunk-YVR6EHWL.js";
-import "./chunk-AXFLY5GU.js";
+} from "./chunk-OGPVJ53N.js";
+import "./chunk-WHL6PKYP.js";
+import "./chunk-56IT2ZXF.js";
+import "./chunk-7LT3YZUR.js";
+import "./chunk-HKGYZVWN.js";
 import "./chunk-LNNI3MS4.js";
-import "./chunk-FXWBFDQR.js";
+import "./chunk-OAYY3WF3.js";
 import "./chunk-5Y54AE3L.js";
-import "./chunk-M77B73VV.js";
+import "./chunk-U54PJPTB.js";
+import "./chunk-OIOW3FPT.js";
 import "./chunk-GLM7TVWP.js";
 import "./chunk-EGV6R6UF.js";
 import "./chunk-QUSMYGNQ.js";