volute 0.49.0 → 0.51.0

package/dist/chunk-7YJY3F2R.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+// packages/cli/src/lib/format-cli.ts
+var isCompact = () => !!process.env.VOLUTE_MIND;
+function formatSender(name, displayName) {
+  if (displayName && displayName !== name) return `${displayName} (@${name})`;
+  return name;
+}
+function compactTime(dateStr) {
+  const d = new Date(dateStr.endsWith("Z") ? dateStr : `${dateStr}Z`);
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+function compactDateTime(dateStr) {
+  const d = new Date(dateStr.endsWith("Z") ? dateStr : `${dateStr}Z`);
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const h = String(d.getHours()).padStart(2, "0");
+  const min = String(d.getMinutes()).padStart(2, "0");
+  return `${y}-${m}-${day} ${h}:${min}`;
+}
+function formatMessageLine(msg, compact) {
+  const text = Array.isArray(msg.content) ? msg.content.filter((b) => b.type === "text").map((b) => b.text).join("") : msg.content;
+  const time = compact ? compactTime(msg.created_at) : new Date(
+    msg.created_at.endsWith("Z") ? msg.created_at : `${msg.created_at}Z`
+  ).toLocaleString();
+  if (msg.role === "event") return `[${time}] \xB7 ${text}`;
+  const sender = compact ? msg.sender_name ?? msg.role : formatSender(msg.sender_name ?? msg.role, msg.sender_display_name);
+  return `[${time}] ${sender}: ${text}`;
+}
+
+export {
+  isCompact,
+  formatSender,
+  compactTime,
+  compactDateTime,
+  formatMessageLine
+};

package/dist/{chunk-EADX54RG.js → chunk-AI47FDGL.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   getMindManager
-} from "./chunk-QQBOI3QA.js";
+} from "./chunk-VAEZCIJC.js";
 import {
   chownMindDir,
   gitExec
-} from "./chunk-DVN6DNMI.js";
+} from "./chunk-M77B73VV.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";
@@ -14,12 +14,12 @@ import {
   mindDir,
   readAllMinds,
   removeMind
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 
 // packages/daemon/src/lib/mind/variant-cleanup.ts
 import { existsSync, readdirSync, rmSync, statSync } from "fs";
 import { resolve } from "path";
-async function cleanupVariant(variantName, projectRoot, variantPath, opts) {
+async function cleanupVariant(variantName, baseName, projectRoot, variantPath, opts) {
   if (opts?.stop) {
     try {
       await getMindManager().stopMind(variantName);
@@ -27,7 +27,7 @@ async function cleanupVariant(variantName, projectRoot, variantPath, opts) {
       logger_default.warn(`failed to stop variant ${variantName}`, logger_default.errorData(err));
     }
   }
-  const { findMind } = await import("./registry-3ELJPUGJ.js");
+  const { findMind } = await import("./registry-TRC2HJXR.js");
   const variantEntry = await findMind(variantName);
   const branchName = variantEntry?.branch ?? variantName;
   if (existsSync(variantPath)) {
@@ -47,7 +47,6 @@ async function cleanupVariant(variantName, projectRoot, variantPath, opts) {
   } catch (err) {
     logger_default.warn(`failed to delete branch ${branchName} for ${variantName}`, logger_default.errorData(err));
   }
-  const baseName = variantEntry?.parent ?? variantName;
   try {
     await removeMind(variantName);
   } catch (err) {
@@ -78,7 +77,7 @@ async function reconcileVariants() {
       `reconcile: dropping stale variant row ${v.name} (worktree ${v.dir ?? "<none>"} missing)`
     );
     try {
-      await cleanupVariant(v.name, baseDir(v.parent), v.dir ?? "");
+      await cleanupVariant(v.name, v.parent, baseDir(v.parent), v.dir ?? "");
     } catch (err) {
       logger_default.warn(`reconcile: failed to drop stale variant ${v.name}`, logger_default.errorData(err));
     }

package/dist/{chunk-IH5TKXX6.js → chunk-BSHZ23MS.js}

@@ -2,17 +2,17 @@
 import {
   findBridgeForChannel,
   getBridgeConfig
-} from "./chunk-MG3Z34YE.js";
+} from "./chunk-L7BKTZ5U.js";
 import {
   recordOutbound
-} from "./chunk-QQBOI3QA.js";
-import {
-  publish
-} from "./chunk-K3JOLGWF.js";
+} from "./chunk-VP5PFNZO.js";
 import {
   getOrCreateMindUser,
   getUserByUsername
-} from "./chunk-4DSGN4FL.js";
+} from "./chunk-HKP6OAJP.js";
+import {
+  publish
+} from "./chunk-LNNI3MS4.js";
 import {
   addMessage,
   findDMConversation,
@@ -20,18 +20,18 @@ import {
   getChannelName,
   getConversation,
   getParticipants
-} from "./chunk-VNRSXEBF.js";
+} from "./chunk-TPX6E6PL.js";
 import {
   readVoluteConfig
 } from "./chunk-WCFSBH33.js";
 import {
   daemonConfigPath,
   readDaemonToken
-} from "./chunk-HCYQRME2.js";
+} from "./chunk-6NLW72HP.js";
 import {
   readEnv,
   sharedEnvPath
-} from "./chunk-PY24ZL62.js";
+} from "./chunk-GLM7TVWP.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";
@@ -40,7 +40,7 @@ import {
 } from "./chunk-LGNUFVMR.js";
 import {
   mindDir
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 import {
   __export
 } from "./chunk-K3NQKI34.js";
@@ -581,6 +581,7 @@ async function read4(env, channelSlug, limit) {
   }
   return data.items.slice(-limit).map((m) => {
     const text = Array.isArray(m.content) ? m.content.filter((b) => b.type === "text").map((b) => b.text).join("") : m.content;
+    if (m.role === "event") return `\xB7 ${text}`;
     return `${m.sender_name ?? m.role}: ${text}`;
   }).join("\n");
 }
@@ -595,7 +596,7 @@ async function send4(env, channelSlug, message, images) {
   };
   if (token) headers.Authorization = `Bearer ${token}`;
   const voluteSession = env.VOLUTE_SESSION || (env.VOLUTE_MIND_DIR ? readSessionFile(env.VOLUTE_MIND_DIR) : void 0);
-  if (voluteSession) headers["X-Volute-Session"] = voluteSession;
+  if (voluteSession) headers["X-Volute-Thread"] = voluteSession;
   const res = await fetch(`${url}/api/v1/chat`, {
     method: "POST",
     headers,

package/dist/{chunk-K3JOLGWF.js → chunk-CDKQJWGK.js}

@@ -1,74 +1,33 @@
 #!/usr/bin/env node
+import {
+  publish
+} from "./chunk-LNNI3MS4.js";
 import {
   getPrompt
-} from "./chunk-JPGHSXSV.js";
+} from "./chunk-FXWBFDQR.js";
 import {
   aiCompleteUtility
-} from "./chunk-YIJGKHIS.js";
+} from "./chunk-EGV6R6UF.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";
 import {
   getDb
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 import {
   messages,
   mindHistory,
   summaries,
   turns
-} from "./chunk-P4LHVRNE.js";
+} from "./chunk-2RNMBXD2.js";
 
 // packages/daemon/src/lib/daemon/turn-tracker.ts
 import { randomUUID } from "crypto";
-import { and as and2, eq as eq2, sql as sql2 } from "drizzle-orm";
+import { and as and2, eq as eq2, inArray as inArray2, sql as sql2 } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/summarizer.ts
 import { and, desc, eq, gte, inArray, like, lt, sql } from "drizzle-orm";
 
-// packages/daemon/src/lib/events/mind-events.ts
-var subscribers = /* @__PURE__ */ new Map();
-var globalSubscribers = /* @__PURE__ */ new Set();
-function subscribe(mind, callback) {
-  let set = subscribers.get(mind);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    subscribers.set(mind, set);
-  }
-  set.add(callback);
-  return () => {
-    set.delete(callback);
-    if (set.size === 0) subscribers.delete(mind);
-  };
-}
-function subscribeAll(callback) {
-  globalSubscribers.add(callback);
-  return () => {
-    globalSubscribers.delete(callback);
-  };
-}
-function publish(mind, event) {
-  const set = subscribers.get(mind);
-  if (set) {
-    for (const cb of set) {
-      try {
-        cb(event);
-      } catch (err) {
-        logger_default.error(`[mind-events] subscriber threw for ${mind}`, logger_default.errorData(err));
-        set.delete(cb);
-        if (set.size === 0) subscribers.delete(mind);
-      }
-    }
-  }
-  for (const cb of globalSubscribers) {
-    try {
-      cb(event);
-    } catch (err) {
-      logger_default.error("[mind-events] global subscriber threw", logger_default.errorData(err));
-      globalSubscribers.delete(cb);
-    }
-  }
-}
-
 // packages/daemon/src/lib/util/format-tool.ts
 function summarizeTool(name, input) {
   if (input && typeof input === "object") {
@@ -166,6 +125,33 @@ function utcDateTimeStr(d) {
 function parseUtcDateTime(s) {
   return /* @__PURE__ */ new Date(`${s.replace(" ", "T")}Z`);
 }
+function getUtcTimeRange(periodKey, period) {
+  switch (period) {
+    case "hour": {
+      const d = /* @__PURE__ */ new Date(`${periodKey.slice(0, 10)}T${periodKey.slice(11)}:00:00`);
+      return { start: utcDateTimeStr(d), end: utcDateTimeStr(new Date(d.getTime() + 36e5)) };
+    }
+    case "day": {
+      const d = /* @__PURE__ */ new Date(`${periodKey}T00:00:00`);
+      const dEnd = new Date(d);
+      dEnd.setDate(d.getDate() + 1);
+      return { start: utcDateTimeStr(d), end: utcDateTimeStr(dEnd) };
+    }
+    case "week": {
+      const monday = isoWeekToDate(periodKey);
+      const nextMonday = new Date(monday);
+      nextMonday.setDate(monday.getDate() + 7);
+      return { start: utcDateTimeStr(monday), end: utcDateTimeStr(nextMonday) };
+    }
+    case "month": {
+      const [y, m] = periodKey.split("-").map(Number);
+      return {
+        start: utcDateTimeStr(new Date(y, m - 1, 1)),
+        end: utcDateTimeStr(new Date(y, m, 1))
+      };
+    }
+  }
+}
 function getTimeRange(periodKey, period) {
   switch (period) {
     case "hour": {
@@ -206,19 +192,19 @@ async function gatherTurnEvents(mind, session, doneId) {
     eq(mindHistory.type, "done"),
     lt(mindHistory.id, doneId)
   ];
-  if (session) subConditions.push(eq(mindHistory.session, session));
+  if (session) subConditions.push(eq(mindHistory.thread, session));
   const prevDoneSubquery = db.select({ id: mindHistory.id }).from(mindHistory).where(and(...subConditions)).orderBy(desc(mindHistory.id)).limit(1);
   const turnConditions = [
     eq(mindHistory.mind, mind),
     sql`${mindHistory.id} > COALESCE((${prevDoneSubquery}), 0)`,
     sql`${mindHistory.id} <= ${doneId}`
   ];
-  if (session) turnConditions.push(eq(mindHistory.session, session));
+  if (session) turnConditions.push(eq(mindHistory.thread, session));
   const events = await db.select({
     id: mindHistory.id,
     type: mindHistory.type,
     channel: mindHistory.channel,
-    session: mindHistory.session,
+    session: mindHistory.thread,
     content: mindHistory.content,
     metadata: mindHistory.metadata,
     turn_id: mindHistory.turn_id,
@@ -236,7 +222,7 @@ async function gatherTurnEventsByTurnId(turnId) {
     id: mindHistory.id,
     type: mindHistory.type,
     channel: mindHistory.channel,
-    session: mindHistory.session,
+    session: mindHistory.thread,
     content: mindHistory.content,
     metadata: mindHistory.metadata,
     turn_id: mindHistory.turn_id,
@@ -266,11 +252,16 @@ function buildTurnDeterministicSummary(events, parsedMeta) {
   const tools = [];
   let hasInbound = false;
   let hasOutbound = false;
+  let eventLabel;
   for (const ev of events) {
     if (ev.type === "inbound") {
       hasInbound = true;
       if (ev.channel) channels.add(ev.channel);
     }
+    if (ev.type === "event") {
+      const label = parsedMeta.get(ev.id)?.label;
+      eventLabel = typeof label === "string" && label ? label : "System event";
+    }
     if (ev.type === "outbound" || ev.type === "text") {
       hasOutbound = true;
     }
@@ -280,6 +271,9 @@ function buildTurnDeterministicSummary(events, parsedMeta) {
     }
   }
   const parts = [];
+  if (eventLabel) {
+    parts.push(`System event: ${eventLabel}`);
+  }
   if (hasInbound) {
     const channelList = [...channels];
     parts.push(
@@ -302,6 +296,16 @@ function buildTranscript(events, parsedMeta) {
       case "inbound":
         lines.push(`[inbound${ev.channel ? ` ${ev.channel}` : ""}] ${ev.content ?? ""}`);
         break;
+      // A system event is what triggered the turn — the summarizer needs to see it, or a
+      // schedule/orientation/wake turn gets summarized from its tool calls alone, with no
+      // idea what prompted them. Framed as an event, not an inbound message: it has no
+      // sender, and the summary shouldn't imply someone spoke to the mind.
+      case "event": {
+        const label = parsedMeta.get(ev.id)?.label;
+        const named = typeof label === "string" && label ? `: ${label}` : "";
+        lines.push(`[system event${named}] ${ev.content ?? ""}`);
+        break;
+      }
       case "outbound":
       case "text":
         lines.push(`[response] ${(ev.content ?? "").slice(0, 500)}`);
@@ -345,7 +349,14 @@ async function summarizeTurn(mind, session, channel, doneId, turnId) {
     if (effectiveTurnId) {
       try {
         const db2 = await getDb();
-        await db2.update(mindHistory).set({ turn_id: null }).where(and(eq(mindHistory.turn_id, effectiveTurnId), eq(mindHistory.type, "inbound")));
+        await db2.update(mindHistory).set({ turn_id: null }).where(
+          and(
+            eq(mindHistory.turn_id, effectiveTurnId),
+            // Release system-event rows too, so an interrupted event turn's row can be
+            // re-linked to the turn that actually processes it.
+            inArray(mindHistory.type, ["inbound", "event"])
+          )
+        );
         await db2.update(messages).set({ turn_id: null }).where(eq(messages.turn_id, effectiveTurnId));
         await db2.delete(turns).where(eq(turns.id, effectiveTurnId));
       } catch (err) {
@@ -1049,11 +1060,11 @@ var Summarizer = class {
   }
 };
 async function reconcileWedgedTurns(idleMs) {
-  const { sweepWedgedTurns: sweepWedgedTurns2, summarizeOrphanedTurns: summarizeOrphanedTurns2 } = await import("./turn-tracker-JQ2YUUY2.js");
+  const { sweepWedgedTurns: sweepWedgedTurns2, summarizeOrphanedTurns: summarizeOrphanedTurns2 } = await import("./turn-tracker-TAT2HGK6.js");
   const wedged = await sweepWedgedTurns2(idleMs);
   if (wedged.length === 0) return;
   summarizeOrphanedTurns2(wedged);
-  const { tryGetDeliveryManager } = await import("./delivery-manager-RBXBPVWM.js");
+  const { tryGetDeliveryManager } = await import("./delivery-manager-HGVZSEES.js");
   const dm = tryGetDeliveryManager();
   if (!dm) return;
   for (const t of wedged) {
@@ -1112,7 +1123,8 @@ async function linkInboundToActiveTurn(mind, session, channel) {
   await db.update(mindHistory).set({ turn_id: turnId }).where(
     and2(
       eq2(mindHistory.mind, mind),
-      eq2(mindHistory.type, "inbound"),
+      // System events ("event") arrive mid-turn too and need the same attribution.
+      inArray2(mindHistory.type, ["inbound", "event"]),
       sql2`${mindHistory.turn_id} IS NULL`,
       eq2(mindHistory.channel, channel)
     )
@@ -1145,7 +1157,7 @@ async function assignSession(mind, turnId, session) {
   }
   try {
     const db = await getDb();
-    await db.update(turns).set({ session }).where(eq2(turns.id, turnId));
+    await db.update(turns).set({ thread: session }).where(eq2(turns.id, turnId));
   } catch (err) {
     tlog.error(`failed to assign session to turn ${turnId}`, logger_default.errorData(err));
     return;
@@ -1171,7 +1183,7 @@ async function completeTurn(mind, session) {
 }
 async function completeOrphanedTurns() {
   const db = await getDb();
-  const active = await db.select({ id: turns.id, mind: turns.mind, session: turns.session }).from(turns).where(eq2(turns.status, "active"));
+  const active = await db.select({ id: turns.id, mind: turns.mind, session: turns.thread }).from(turns).where(eq2(turns.status, "active"));
   if (active.length === 0) return [];
   try {
     await db.update(turns).set({ status: "complete" }).where(eq2(turns.status, "active"));
@@ -1220,7 +1232,7 @@ async function sweepWedgedTurns(idleMs) {
   const cutoff = new Date(Date.now() - idleMs).toISOString().slice(0, 19).replace("T", " ");
   let rows;
   try {
-    rows = await db.select({ id: turns.id, mind: turns.mind, session: turns.session }).from(turns).innerJoin(mindHistory, eq2(mindHistory.turn_id, turns.id)).where(eq2(turns.status, "active")).groupBy(turns.id).having(
+    rows = await db.select({ id: turns.id, mind: turns.mind, session: turns.thread }).from(turns).innerJoin(mindHistory, eq2(mindHistory.turn_id, turns.id)).where(eq2(turns.status, "active")).groupBy(turns.id).having(
       sql2`max(${mindHistory.created_at}) < ${cutoff} and sum(case when ${mindHistory.type} = 'done' then 1 else 0 end) > 0`
     );
   } catch (err) {
@@ -1251,11 +1263,12 @@ function summarizeOrphanedTurns(orphanedTurns) {
 }
 
 export {
-  subscribe,
-  subscribeAll,
-  publish,
+  getPeriodKey,
   isoWeekKeyForDateStr,
   utcDateTimeStr,
+  parseUtcDateTime,
+  getUtcTimeRange,
+  SYSTEM_MIND,
   summarizeTurn,
   initSummarizer,
   markErrored,

package/dist/{chunk-L27YYONJ.js → chunk-CV6BNGFK.js}

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import {
   computeTemplateHash
-} from "./chunk-C3KLHJDB.js";
+} from "./chunk-HTRSSOHY.js";
 import {
   composeTemplate,
   findTemplatesRoot,
   listFiles
-} from "./chunk-RRZ4RQQU.js";
+} from "./chunk-X67BDDZR.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";
 import {
   mindDir
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 
 // packages/daemon/src/lib/mind/template-staleness.ts
 import { createHash } from "crypto";

package/dist/{chunk-NOIAHMJB.js → chunk-DMK5ASKV.js}

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

package/dist/chunk-DN3LKLYR.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import {
+  getSleepManagerIfReady,
+  startSpiritFull
+} from "./chunk-VP5PFNZO.js";
+import {
+  spiritCreationInProgress
+} from "./chunk-VSBMLB2W.js";
+import {
+  MindStartupError,
+  tryGetMindManager
+} from "./chunk-VAEZCIJC.js";
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
+import {
+  computeSetupStatus,
+  findMind,
+  readGlobalConfigStrict
+} from "./chunk-H6X6CKDN.js";
+
+// packages/daemon/src/lib/chat/spirit-availability.ts
+var slog = logger_default.child("spirit-availability");
+var SPIRIT_NOTICE_PREFIX = "The system spirit isn't available";
+var SETUP_INCOMPLETE_NOTICE = `${SPIRIT_NOTICE_PREFIX} (setup is incomplete). An admin can finish setup in Settings.`;
+var CREATION_FAILED_NOTICE = `${SPIRIT_NOTICE_PREFIX} (it failed to start). An admin can check the daemon logs and Settings.`;
+function classifySpiritState(i) {
+  if (!i.setupComplete || !i.spiritExists) return "cannot-exist";
+  if (i.sleeping) return "sleeping";
+  if (i.running) return "running";
+  if (i.recentlyFailed) return "cannot-exist";
+  return "stopped";
+}
+function spiritUnavailableNotice(setupComplete) {
+  return setupComplete ? CREATION_FAILED_NOTICE : SETUP_INCOMPLETE_NOTICE;
+}
+var lastOnDemandStartAt = 0;
+var ON_DEMAND_RETRY_COOLDOWN_MS = 6e4;
+function _resetSpiritAvailabilityState() {
+  lastOnDemandStartAt = 0;
+}
+async function ensureSpiritAvailable() {
+  try {
+    const manager = tryGetMindManager();
+    const sleepManager = getSleepManagerIfReady();
+    if (!manager || !sleepManager) return null;
+    let config;
+    try {
+      config = readGlobalConfigStrict();
+    } catch (err) {
+      slog.warn("global config unreadable \u2014 spirit availability indeterminate", {
+        ...logger_default.errorData(err)
+      });
+      return null;
+    }
+    const setupComplete = computeSetupStatus(config) === "complete";
+    const spiritName = config.setup?.spiritName ?? "volute";
+    const entry = setupComplete ? await findMind(spiritName) : void 0;
+    if (setupComplete && !entry && spiritCreationInProgress()) return null;
+    const recentlyFailed = manager.hasExhaustedRestarts(spiritName) || lastOnDemandStartAt > 0 && Date.now() - lastOnDemandStartAt < ON_DEMAND_RETRY_COOLDOWN_MS;
+    const state = classifySpiritState({
+      setupComplete,
+      spiritExists: !!entry,
+      sleeping: sleepManager.isSleeping(spiritName),
+      running: manager.isRunning(spiritName),
+      recentlyFailed
+    });
+    switch (state) {
+      case "cannot-exist":
+        return { status: "unavailable", notice: spiritUnavailableNotice(setupComplete) };
+      case "sleeping":
+        return { status: "sleeping" };
+      case "running":
+        return { status: "running" };
+      case "stopped":
+        try {
+          lastOnDemandStartAt = Date.now();
+          await startSpiritFull(spiritName);
+          return { status: "waking" };
+        } catch (err) {
+          if (err instanceof Error && err.message.includes("already running")) {
+            return { status: "running" };
+          }
+          if (manager.isRunning(spiritName)) {
+            slog.error("spirit started on demand but post-start setup failed", {
+              ...logger_default.errorData(err)
+            });
+            return { status: "waking" };
+          }
+          slog.error("failed to start spirit on demand", {
+            ...logger_default.errorData(err),
+            ...err instanceof MindStartupError ? { stderr: err.stderr } : {}
+          });
+          return { status: "unavailable", notice: spiritUnavailableNotice(setupComplete) };
+        }
+    }
+  } catch (err) {
+    slog.error("spirit availability check failed", { ...logger_default.errorData(err) });
+    return null;
+  }
+}
+
+export {
+  SPIRIT_NOTICE_PREFIX,
+  classifySpiritState,
+  spiritUnavailableNotice,
+  _resetSpiritAvailabilityState,
+  ensureSpiritAvailable
+};

package/dist/{chunk-JBIFXB6I.js → chunk-EDR47UE2.js}

@@ -1,19 +1,17 @@
 #!/usr/bin/env node
 import {
   exec
-} from "./chunk-DVN6DNMI.js";
-import {
-  readGlobalConfig
-} from "./chunk-NJHN6IRB.js";
+} from "./chunk-M77B73VV.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";
 import {
   getDb,
   readAllMinds,
+  readGlobalConfig,
   voluteHome,
   voluteSystemDir
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 
 // packages/daemon/src/lib/backup/restic.ts
 import { writeFileSync } from "fs";

package/dist/{chunk-SHKM5RGD.js → chunk-EEOMA4DX.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   daemonFetch
-} from "./chunk-BCG45AQB.js";
+} from "./chunk-M74I3HHF.js";
 import {
   command
 } from "./chunk-TXSA4Q3V.js";