volute 0.39.0 → 0.40.1

package/dist/{chunk-CHCISTH7.js → chunk-BLAXARBZ.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-WUH54G5S.js";
+} from "./chunk-ITH5ZLZJ.js";
 import {
   spiritDir
-} from "./chunk-Y4W3OS7Q.js";
+} from "./chunk-YTNBO7S6.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   removeSharedSkill,
   sharedSkillsDir
-} from "./chunk-IBOU6Q3Y.js";
+} from "./chunk-QV7P3TYO.js";
 import {
   addMessage,
   createChannel,
@@ -20,7 +20,7 @@ import {
   getParticipants,
   joinChannel,
   publish as publish2
-} from "./chunk-QDWPM73D.js";
+} from "./chunk-3Y7UDHO7.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
@@ -28,46 +28,46 @@ import {
 import {
   isSandboxEnabled,
   wrapForSandbox
-} from "./chunk-EVKGKQ2P.js";
+} from "./chunk-KMHC36CA.js";
 import {
   markIdle,
   onMindEvent
-} from "./chunk-DZ4LYU6J.js";
+} from "./chunk-ANSTTB55.js";
 import {
   extractTextContent,
   getRoutingConfig,
   resolveDeliveryMode,
   resolveRoute
-} from "./chunk-OS5MRIEP.js";
+} from "./chunk-NERYUSER.js";
 import {
   exec
-} from "./chunk-OEXOFBW5.js";
+} from "./chunk-AEAZRTEV.js";
 import {
   chownMindDir,
   isIsolationEnabled,
   mindUserName,
   wrapForIsolation
-} from "./chunk-6FSSMAXU.js";
+} from "./chunk-6SYHHEQ7.js";
+import {
+  aiCompleteUtility,
+  getAiConfig,
+  resolveApiKey
+} from "./chunk-S4SXBQ7F.js";
+import {
+  readGlobalConfig,
+  writeGlobalConfig
+} from "./chunk-DNU6XLE2.js";
 import {
   getOrCreateMindUser,
   getOrCreateSystemUser,
   getUser,
   getUserByUsername,
   syncMindProfile
-} from "./chunk-7W3UWCQD.js";
+} from "./chunk-E25SO3QW.js";
 import {
   publish,
   subscribe
-} from "./chunk-7GZB3ZJP.js";
-import {
-  aiCompleteUtility,
-  getAiConfig,
-  resolveApiKey
-} from "./chunk-B7MWXFAH.js";
-import {
-  readGlobalConfig,
-  writeGlobalConfig
-} from "./chunk-TCNCRDB5.js";
+} from "./chunk-QYI65HCL.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";
@@ -80,37 +80,38 @@ import {
   stateDir,
   voluteHome,
   voluteSystemDir
-} from "./chunk-QDWP435B.js";
+} from "./chunk-B4WPXYPI.js";
 import {
   activity,
   conversationParticipants,
   deliveryQueue,
   messages,
   mindHistory,
+  mindNotices,
   summaries,
   systemPrompts,
   turns,
   users
-} from "./chunk-CJ26DXZL.js";
+} from "./chunk-2HZRJ35V.js";
 
 // packages/daemon/src/lib/delivery/message-delivery.ts
-import { and as and4, desc as desc2, eq as eq6, inArray as inArray3, sql as sql3 } from "drizzle-orm";
+import { and as and5, desc as desc2, eq as eq7, inArray as inArray3, sql as sql4 } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/sleep-manager.ts
 import { execFile as execFile2, spawn as spawnChild } from "child_process";
 import {
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   readlinkSync,
   renameSync,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "fs";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 import { promisify as promisify2 } from "util";
 import { CronExpressionParser as CronExpressionParser2 } from "cron-parser";
-import { and as and2, eq as eq4, inArray as inArray2 } from "drizzle-orm";
+import { and as and3, eq as eq5, inArray as inArray2 } from "drizzle-orm";
 
 // packages/daemon/src/lib/prompts.ts
 import { eq } from "drizzle-orm";
@@ -326,8 +327,8 @@ async function getMindPromptDefaults() {
 
 // packages/daemon/src/lib/daemon/mind-manager.ts
 import { execFile, spawn } from "child_process";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve2 } from "path";
 import { promisify } from "util";
 
 // packages/daemon/src/lib/util/json-state.ts
@@ -436,6 +437,78 @@ var RotatingLog = class extends Writable {
   }
 };
 
+// packages/daemon/src/lib/daemon/credential-sync.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path";
+var slog = logger_default.child("cred-sync");
+function writeClaudeCredentials(homeDir, baseName, oauth) {
+  const claudeDir = resolve(homeDir, ".claude");
+  mkdirSync(claudeDir, { recursive: true });
+  writeFileSync2(
+    resolve(claudeDir, ".credentials.json"),
+    JSON.stringify({
+      claudeAiOauth: {
+        accessToken: oauth.access,
+        refreshToken: oauth.refresh,
+        expiresAt: oauth.expires ? new Date(oauth.expires).toISOString() : null,
+        scopes: ["user:inference", "user:profile"]
+      }
+    }),
+    { mode: 384 }
+  );
+  if (isIsolationEnabled()) {
+    chownMindDir(claudeDir, baseName);
+  }
+  return claudeDir;
+}
+function writePiProviderKey(piAgentDir, baseName, provider, key2) {
+  mkdirSync(piAgentDir, { recursive: true });
+  const authPath = resolve(piAgentDir, "auth.json");
+  const authData = existsSync3(authPath) ? JSON.parse(readFileSync2(authPath, "utf-8")) : {};
+  authData[provider] = { type: "api_key", key: key2 };
+  writeFileSync2(authPath, JSON.stringify(authData, null, 2), { mode: 384 });
+  if (isIsolationEnabled()) {
+    chownMindDir(piAgentDir, baseName);
+  }
+}
+function piUsesProvider(piAgentDir, provider) {
+  try {
+    const authPath = resolve(piAgentDir, "auth.json");
+    if (!existsSync3(authPath)) return false;
+    const data = JSON.parse(readFileSync2(authPath, "utf-8"));
+    return data[provider] != null;
+  } catch {
+    return false;
+  }
+}
+async function syncProviderToMinds(provider, deps = {}) {
+  if (provider !== "anthropic") return;
+  const getOauth = deps.getOauth ?? (() => getAiConfig()?.providers.anthropic?.oauth);
+  const oauth = getOauth();
+  if (!oauth?.access) return;
+  const listRunning = deps.listRunning ?? (() => []);
+  const lookup = deps.lookup ?? findMind;
+  for (const name of listRunning()) {
+    try {
+      const entry = await lookup(name);
+      if (!entry) continue;
+      const dir = entry.dir ?? mindDir(name);
+      const baseName = entry.parent ?? name;
+      const template = entry.template;
+      if (template === "claude" || !template) {
+        writeClaudeCredentials(resolve(dir, "home"), baseName, oauth);
+      } else if (template === "pi") {
+        const piAgentDir = resolve(dir, ".mind", "pi-agent");
+        if (piUsesProvider(piAgentDir, "anthropic")) {
+          writePiProviderKey(piAgentDir, baseName, "anthropic", oauth.access);
+        }
+      }
+    } catch (err) {
+      slog.warn(`failed to sync ${provider} credentials to mind ${name}`, logger_default.errorData(err));
+    }
+  }
+}
+
 // packages/daemon/src/lib/daemon/mind-tokens.ts
 import { randomUUID } from "crypto";
 var tokenToMind = /* @__PURE__ */ new Map();
@@ -458,6 +531,74 @@ function resolveMindToken(token) {
   return tokenToMind.get(token) ?? null;
 }
 
+// packages/daemon/src/lib/daemon/notices.ts
+import { and, asc, eq as eq2, lte, sql } from "drizzle-orm";
+var nlog = logger_default.child("notices");
+var MAX_NOTICES_PER_SESSION = 100;
+async function recordNotice(input) {
+  try {
+    const db = await getDb();
+    await db.insert(mindNotices).values({
+      mind: input.mind,
+      session: input.session,
+      kind: input.kind,
+      reason: input.reason,
+      detail: input.detail,
+      raw: input.raw ?? null
+    });
+    await db.run(
+      sql`DELETE FROM mind_notices WHERE mind = ${input.mind} AND session = ${input.session} AND id NOT IN (SELECT id FROM mind_notices WHERE mind = ${input.mind} AND session = ${input.session} ORDER BY id DESC LIMIT ${MAX_NOTICES_PER_SESSION})`
+    );
+  } catch (err) {
+    nlog.error(`failed to record notice for ${input.mind}:${input.session}`, logger_default.errorData(err));
+  }
+}
+async function drainNotices(mind, session, limit = MAX_NOTICES_PER_SESSION) {
+  const db = await getDb();
+  return db.select().from(mindNotices).where(and(eq2(mindNotices.mind, mind), eq2(mindNotices.session, session))).orderBy(asc(mindNotices.id)).limit(limit);
+}
+async function clearDeliveredNotices(mind, session, uptoId) {
+  try {
+    const db = await getDb();
+    await db.delete(mindNotices).where(
+      and(
+        eq2(mindNotices.mind, mind),
+        eq2(mindNotices.session, session),
+        lte(mindNotices.id, uptoId)
+      )
+    );
+  } catch (err) {
+    nlog.warn(`failed to clear delivered notices for ${mind}:${session}`, logger_default.errorData(err));
+  }
+}
+var NOTICE_HEADER = "[Notices] While you were unavailable, one or more turns failed. You're back now:";
+function formatNotices(notices) {
+  if (notices.length === 0) return null;
+  const groups = /* @__PURE__ */ new Map();
+  for (const n of notices) {
+    const time = localHM(n.created_at);
+    const g = groups.get(n.reason);
+    if (g) {
+      g.count += 1;
+      g.detail = n.detail;
+      g.last = time;
+    } else {
+      groups.set(n.reason, { count: 1, detail: n.detail, first: time, last: time });
+    }
+  }
+  const lines = [...groups.values()].map((g) => {
+    const span = g.first === g.last ? g.first : `${g.first}\u2013${g.last}`;
+    const plural = g.count === 1 ? "turn" : "turns";
+    return `- ${g.count} ${plural} failed (${span}): ${g.detail}`;
+  });
+  return `${NOTICE_HEADER}
+${lines.join("\n")}`;
+}
+function localHM(createdAt) {
+  const iso = createdAt.endsWith("Z") ? createdAt : `${createdAt.replace(" ", "T")}Z`;
+  return new Date(iso).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
+}
+
 // packages/daemon/src/lib/daemon/restart-tracker.ts
 var DEFAULT_MAX_ATTEMPTS = 5;
 var DEFAULT_BASE_DELAY = 3e3;
@@ -505,10 +646,10 @@ var RestartTracker = class {
 
 // packages/daemon/src/lib/daemon/turn-tracker.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { eq as eq3 } from "drizzle-orm";
+import { eq as eq4 } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/summarizer.ts
-import { and, desc, eq as eq2, gte, inArray, like, lt, sql } from "drizzle-orm";
+import { and as and2, desc, eq as eq3, gte, inArray, like, lt, sql as sql2 } from "drizzle-orm";
 
 // packages/daemon/src/lib/events/mind-events.ts
 var subscribers = /* @__PURE__ */ new Map();
@@ -675,18 +816,18 @@ function getTimeRange(periodKey, period) {
 async function gatherTurnEvents(mind, session, doneId) {
   const db = await getDb();
   const subConditions = [
-    eq2(mindHistory.mind, mind),
-    eq2(mindHistory.type, "done"),
+    eq3(mindHistory.mind, mind),
+    eq3(mindHistory.type, "done"),
     lt(mindHistory.id, doneId)
   ];
-  if (session) subConditions.push(eq2(mindHistory.session, session));
-  const prevDoneSubquery = db.select({ id: mindHistory.id }).from(mindHistory).where(and(...subConditions)).orderBy(desc(mindHistory.id)).limit(1);
+  if (session) subConditions.push(eq3(mindHistory.session, session));
+  const prevDoneSubquery = db.select({ id: mindHistory.id }).from(mindHistory).where(and2(...subConditions)).orderBy(desc(mindHistory.id)).limit(1);
   const turnConditions = [
-    eq2(mindHistory.mind, mind),
-    sql`${mindHistory.id} > COALESCE((${prevDoneSubquery}), 0)`,
-    sql`${mindHistory.id} <= ${doneId}`
+    eq3(mindHistory.mind, mind),
+    sql2`${mindHistory.id} > COALESCE((${prevDoneSubquery}), 0)`,
+    sql2`${mindHistory.id} <= ${doneId}`
   ];
-  if (session) turnConditions.push(eq2(mindHistory.session, session));
+  if (session) turnConditions.push(eq3(mindHistory.session, session));
   const events = await db.select({
     id: mindHistory.id,
     type: mindHistory.type,
@@ -695,7 +836,7 @@ async function gatherTurnEvents(mind, session, doneId) {
     content: mindHistory.content,
     metadata: mindHistory.metadata,
     created_at: mindHistory.created_at
-  }).from(mindHistory).where(and(...turnConditions)).orderBy(mindHistory.id);
+  }).from(mindHistory).where(and2(...turnConditions)).orderBy(mindHistory.id);
   return {
     events,
     fromId: events.length > 0 ? events[0].id : doneId,
@@ -712,7 +853,7 @@ async function gatherTurnEventsByTurnId(turnId) {
     content: mindHistory.content,
     metadata: mindHistory.metadata,
     created_at: mindHistory.created_at
-  }).from(mindHistory).where(eq2(mindHistory.turn_id, turnId)).orderBy(mindHistory.id);
+  }).from(mindHistory).where(eq3(mindHistory.turn_id, turnId)).orderBy(mindHistory.id);
   return {
     events,
     fromId: events.length > 0 ? events[0].id : 0,
@@ -812,8 +953,8 @@ async function summarizeTurn(mind, session, channel, doneId, turnId) {
     if (turnId) {
       try {
         const db2 = await getDb();
-        await db2.update(mindHistory).set({ turn_id: null }).where(and(eq2(mindHistory.turn_id, turnId), eq2(mindHistory.type, "inbound")));
-        await db2.update(messages).set({ turn_id: null }).where(eq2(messages.turn_id, turnId));
+        await db2.update(mindHistory).set({ turn_id: null }).where(and2(eq3(mindHistory.turn_id, turnId), eq3(mindHistory.type, "inbound")));
+        await db2.update(messages).set({ turn_id: null }).where(eq3(messages.turn_id, turnId));
       } catch (err) {
         sLog.error(`failed to un-tag events for interrupted turn ${turnId}`, logger_default.errorData(err));
       }
@@ -870,10 +1011,10 @@ async function summarizeTurn(mind, session, channel, doneId, turnId) {
     summaryId = result[0]?.id;
     if (summaryId == null) {
       const existing = await db.select({ id: summaries.id }).from(summaries).where(
-        and(
-          eq2(summaries.mind, mind),
-          eq2(summaries.period, "turn"),
-          eq2(summaries.period_key, periodKey)
+        and2(
+          eq3(summaries.mind, mind),
+          eq3(summaries.period, "turn"),
+          eq3(summaries.period_key, periodKey)
         )
       ).get();
       summaryId = existing?.id;
@@ -902,7 +1043,7 @@ async function summarizeTurn(mind, session, channel, doneId, turnId) {
 }
 async function setSummaryId(turnId, summaryId) {
   const db = await getDb();
-  await db.update(turns).set({ summary_id: summaryId }).where(eq2(turns.id, turnId));
+  await db.update(turns).set({ summary_id: summaryId }).where(eq3(turns.id, turnId));
 }
 function getChildPeriod(period) {
   switch (period) {
@@ -946,9 +1087,9 @@ async function gatherChildSummaries(mind, period, periodKey) {
   if (period === "hour") {
     const { start: start2, end: end2 } = getTimeRange(periodKey, "hour");
     const rows2 = await db.select({ id: summaries.id, content: summaries.content }).from(summaries).where(
-      and(
-        eq2(summaries.mind, mind),
-        eq2(summaries.period, childPeriod),
+      and2(
+        eq3(summaries.mind, mind),
+        eq3(summaries.period, childPeriod),
         gte(summaries.created_at, start2),
         lt(summaries.created_at, end2)
       )
@@ -960,9 +1101,9 @@ async function gatherChildSummaries(mind, period, periodKey) {
   }
   if (period === "day") {
     const rows2 = await db.select({ id: summaries.id, content: summaries.content }).from(summaries).where(
-      and(
-        eq2(summaries.mind, mind),
-        eq2(summaries.period, childPeriod),
+      and2(
+        eq3(summaries.mind, mind),
+        eq3(summaries.period, childPeriod),
         like(summaries.period_key, `${periodKey}%`)
       )
     ).orderBy(summaries.period_key);
@@ -975,11 +1116,11 @@ async function gatherChildSummaries(mind, period, periodKey) {
   const startKey = start.slice(0, 10);
   const endKey = end.slice(0, 10);
   const rows = await db.select({ id: summaries.id, content: summaries.content }).from(summaries).where(
-    and(
-      eq2(summaries.mind, mind),
-      eq2(summaries.period, childPeriod),
+    and2(
+      eq3(summaries.mind, mind),
+      eq3(summaries.period, childPeriod),
       gte(summaries.period_key, startKey),
-      sql`${summaries.period_key} <= ${endKey}`
+      sql2`${summaries.period_key} <= ${endKey}`
     )
   ).orderBy(summaries.period_key);
   return {
@@ -1059,10 +1200,10 @@ async function summarizeSystem(period, periodKey) {
   if (await summaryExists(SYSTEM_MIND, period, periodKey)) return;
   const db = await getDb();
   const rows = await db.select({ mind: summaries.mind, content: summaries.content }).from(summaries).where(
-    and(
-      eq2(summaries.period, period),
-      eq2(summaries.period_key, periodKey),
-      sql`${summaries.mind} != ${SYSTEM_MIND}`
+    and2(
+      eq3(summaries.period, period),
+      eq3(summaries.period_key, periodKey),
+      sql2`${summaries.mind} != ${SYSTEM_MIND}`
     )
   ).orderBy(summaries.mind);
   if (rows.length === 0) return;
@@ -1097,11 +1238,11 @@ async function summarizeSystem(period, periodKey) {
 async function mindsWithTurnSummaries(start, end) {
   const db = await getDb();
   const rows = await db.select({ mind: summaries.mind }).from(summaries).where(
-    and(
-      eq2(summaries.period, "turn"),
+    and2(
+      eq3(summaries.period, "turn"),
       gte(summaries.created_at, start),
       lt(summaries.created_at, end),
-      sql`${summaries.mind} != ${SYSTEM_MIND}`
+      sql2`${summaries.mind} != ${SYSTEM_MIND}`
     )
   ).groupBy(summaries.mind);
   return rows.map((r) => r.mind);
@@ -1109,10 +1250,10 @@ async function mindsWithTurnSummaries(start, end) {
 async function mindsWithSummaries(period, keyPattern) {
   const db = await getDb();
   const rows = await db.select({ mind: summaries.mind }).from(summaries).where(
-    and(
-      eq2(summaries.period, period),
+    and2(
+      eq3(summaries.period, period),
       like(summaries.period_key, keyPattern),
-      sql`${summaries.mind} != ${SYSTEM_MIND}`
+      sql2`${summaries.mind} != ${SYSTEM_MIND}`
     )
   ).groupBy(summaries.mind);
   return rows.map((r) => r.mind);
@@ -1120,11 +1261,11 @@ async function mindsWithSummaries(period, keyPattern) {
 async function mindsWithDailySummariesInRange(startKey, endKey) {
   const db = await getDb();
   const rows = await db.select({ mind: summaries.mind }).from(summaries).where(
-    and(
-      eq2(summaries.period, "day"),
+    and2(
+      eq3(summaries.period, "day"),
       gte(summaries.period_key, startKey),
-      sql`${summaries.period_key} <= ${endKey}`,
-      sql`${summaries.mind} != ${SYSTEM_MIND}`
+      sql2`${summaries.period_key} <= ${endKey}`,
+      sql2`${summaries.mind} != ${SYSTEM_MIND}`
     )
   ).groupBy(summaries.mind);
   return rows.map((r) => r.mind);
@@ -1188,10 +1329,10 @@ async function processMonth(periodKey) {
 async function summaryExists(mind, period, periodKey) {
   const db = await getDb();
   const row = await db.select({ id: summaries.id }).from(summaries).where(
-    and(
-      eq2(summaries.mind, mind),
-      eq2(summaries.period, period),
-      eq2(summaries.period_key, periodKey)
+    and2(
+      eq3(summaries.mind, mind),
+      eq3(summaries.period, period),
+      eq3(summaries.period_key, periodKey)
     )
   ).get();
   return !!row;
@@ -1221,7 +1362,7 @@ async function backfill() {
   }
   const allKeys = candidates.map((c) => c.key);
   const db = await getDb();
-  const existingRows = await db.select({ period: summaries.period, period_key: summaries.period_key }).from(summaries).where(and(eq2(summaries.mind, SYSTEM_MIND), inArray(summaries.period_key, allKeys)));
+  const existingRows = await db.select({ period: summaries.period, period_key: summaries.period_key }).from(summaries).where(and2(eq3(summaries.mind, SYSTEM_MIND), inArray(summaries.period_key, allKeys)));
   const existingSet = new Set(existingRows.map((r) => `${r.period}:${r.period_key}`));
   const processFn = {
     hour: processHour,
@@ -1298,6 +1439,13 @@ var activeTurns = /* @__PURE__ */ new Map();
 function key(mind, session) {
   return `${mind}:${session ?? "*"}`;
 }
+var erroredSessions = /* @__PURE__ */ new Set();
+function markErrored(mind, session) {
+  erroredSessions.add(key(mind, session));
+}
+function takeErrored(mind, session) {
+  return erroredSessions.delete(key(mind, session));
+}
 async function createTurn(mind) {
   const k = key(mind);
   const existing = activeTurns.get(k);
@@ -1334,7 +1482,7 @@ async function assignSession(mind, turnId, session) {
   }
   try {
     const db = await getDb();
-    await db.update(turns).set({ session }).where(eq3(turns.id, turnId));
+    await db.update(turns).set({ session }).where(eq4(turns.id, turnId));
   } catch (err) {
     tlog.error(`failed to assign session to turn ${turnId}`, logger_default.errorData(err));
     return;
@@ -1349,7 +1497,7 @@ async function completeTurn(mind, session) {
   if (!entry) return void 0;
   try {
     const db = await getDb();
-    await db.update(turns).set({ status: "complete" }).where(eq3(turns.id, entry.turnId));
+    await db.update(turns).set({ status: "complete" }).where(eq4(turns.id, entry.turnId));
   } catch (err) {
     tlog.error(`failed to complete turn ${entry.turnId}`, logger_default.errorData(err));
     return void 0;
@@ -1360,10 +1508,10 @@ 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(eq3(turns.status, "active"));
+  const active = await db.select({ id: turns.id, mind: turns.mind, session: turns.session }).from(turns).where(eq4(turns.status, "active"));
   if (active.length === 0) return [];
   try {
-    await db.update(turns).set({ status: "complete" }).where(eq3(turns.status, "active"));
+    await db.update(turns).set({ status: "complete" }).where(eq4(turns.status, "active"));
   } catch (err) {
     tlog.error("failed to complete orphaned turns on startup", logger_default.errorData(err));
   }
@@ -1389,11 +1537,14 @@ async function clearMind(mind) {
     }
   }
   for (const k of toDelete) activeTurns.delete(k);
+  for (const k of [...erroredSessions]) {
+    if (k.startsWith(`${mind}:`)) erroredSessions.delete(k);
+  }
   if (orphaned.length > 0) {
     try {
       const db = await getDb();
       for (const { turnId } of orphaned) {
-        await db.update(turns).set({ status: "complete" }).where(eq3(turns.id, turnId));
+        await db.update(turns).set({ status: "complete" }).where(eq4(turns.id, turnId));
       }
     } catch (err) {
       tlog.error(`failed to complete orphaned turns for ${mind}`, logger_default.errorData(err));
@@ -1413,7 +1564,7 @@ function summarizeOrphanedTurns(orphanedTurns) {
 var mlog = logger_default.child("minds");
 var execFileAsync = promisify(execFile);
 function mindPidPath(name) {
-  return resolve(stateDir(name), "mind.pid");
+  return resolve2(stateDir(name), "mind.pid");
 }
 var MindManager = class {
   minds = /* @__PURE__ */ new Map();
@@ -1429,7 +1580,7 @@ var MindManager = class {
       return { dir: entry.dir, port: entry.port, baseName: entry.parent, template: entry.template };
     }
     const dir = entry.dir ?? mindDir(name);
-    if (!existsSync3(dir)) throw new Error(`Mind directory missing: ${dir}`);
+    if (!existsSync4(dir)) throw new Error(`Mind directory missing: ${dir}`);
     return { dir, port: entry.port, baseName: name, template: entry.template };
   }
   async startMind(name) {
@@ -1441,8 +1592,8 @@ var MindManager = class {
     const port = target.port;
     const pidFile = mindPidPath(name);
     try {
-      if (existsSync3(pidFile)) {
-        const stalePid = parseInt(readFileSync2(pidFile, "utf-8").trim(), 10);
+      if (existsSync4(pidFile)) {
+        const stalePid = parseInt(readFileSync3(pidFile, "utf-8").trim(), 10);
         if (stalePid > 0) {
           try {
             process.kill(stalePid, 0);
@@ -1475,8 +1626,8 @@ var MindManager = class {
     } catch {
     }
     const mindStateDir = stateDir(name);
-    const logsDir = resolve(mindStateDir, "logs");
-    mkdirSync(logsDir, { recursive: true });
+    const logsDir = resolve2(mindStateDir, "logs");
+    mkdirSync2(logsDir, { recursive: true });
     if (isIsolationEnabled()) {
       try {
         chownMindDir(mindStateDir, baseName);
@@ -1486,10 +1637,10 @@ var MindManager = class {
         );
       }
     }
-    const logStream = new RotatingLog(resolve(logsDir, "mind.log"));
+    const logStream = new RotatingLog(resolve2(logsDir, "mind.log"));
     const mindToken = generateMindToken(name);
     const mindEnv = loadMergedEnv(name);
-    const mindLocalBin = resolve(dir, "home", ".local", "bin");
+    const mindLocalBin = resolve2(dir, "home", ".local", "bin");
     const currentPath = process.env.PATH ?? "";
     const env = {
       ...process.env,
@@ -1505,24 +1656,30 @@ var MindManager = class {
     };
     if (target.template === "pi") {
       try {
-        const configPath2 = resolve(dir, "home/.config/config.json");
-        if (existsSync3(configPath2)) {
-          const config = JSON.parse(readFileSync2(configPath2, "utf-8"));
+        const configPath2 = resolve2(dir, "home/.config/config.json");
+        if (existsSync4(configPath2)) {
+          const config = JSON.parse(readFileSync3(configPath2, "utf-8"));
           const modelStr = config.model;
           if (modelStr?.includes(":")) {
             const provider = modelStr.split(":")[0];
             const apiKey = await resolveApiKey(provider);
             if (apiKey) {
-              const piAgentDir = resolve(dir, ".mind", "pi-agent");
-              mkdirSync(piAgentDir, { recursive: true });
-              const authPath = resolve(piAgentDir, "auth.json");
-              const authData = existsSync3(authPath) ? JSON.parse(readFileSync2(authPath, "utf-8")) : {};
-              authData[provider] = { type: "api_key", key: apiKey };
-              writeFileSync2(authPath, JSON.stringify(authData, null, 2), { mode: 384 });
-              if (isIsolationEnabled()) {
-                chownMindDir(piAgentDir, baseName);
-              }
+              const piAgentDir = resolve2(dir, ".mind", "pi-agent");
+              writePiProviderKey(piAgentDir, baseName, provider, apiKey);
               env.PI_CODING_AGENT_DIR = piAgentDir;
+              const providerEnvVars = {
+                openrouter: "OPENROUTER_API_KEY",
+                openai: "OPENAI_API_KEY",
+                anthropic: "ANTHROPIC_API_KEY",
+                google: "GEMINI_API_KEY",
+                groq: "GROQ_API_KEY",
+                cerebras: "CEREBRAS_API_KEY",
+                xai: "XAI_API_KEY",
+                mistral: "MISTRAL_API_KEY",
+                zai: "ZAI_API_KEY"
+              };
+              const providerEnv = providerEnvVars[provider];
+              if (providerEnv) env[providerEnv] = apiKey;
             } else {
               mlog.warn(
                 `no API key found for provider "${provider}" \u2014 mind ${name} may fail to start`
@@ -1539,11 +1696,11 @@ var MindManager = class {
         const ai = getAiConfig();
         const codexConfig = ai?.providers["openai-codex"];
         if (codexConfig?.oauth) {
-          const codexDir = resolve(dir, ".mind", "codex");
-          mkdirSync(codexDir, { recursive: true });
+          const codexDir = resolve2(dir, ".mind", "codex");
+          mkdirSync2(codexDir, { recursive: true });
           env.CODEX_HOME = codexDir;
-          const authPath = resolve(codexDir, "auth.json");
-          writeFileSync2(
+          const authPath = resolve2(codexDir, "auth.json");
+          writeFileSync3(
             authPath,
             JSON.stringify({
               auth_mode: "chatgpt",
@@ -1556,9 +1713,9 @@ var MindManager = class {
             }),
             { mode: 384 }
           );
-          const configTomlPath = resolve(codexDir, "config.toml");
-          if (!existsSync3(configTomlPath)) {
-            writeFileSync2(configTomlPath, 'cli_auth_credentials_store = "file"\n');
+          const configTomlPath = resolve2(codexDir, "config.toml");
+          if (!existsSync4(configTomlPath)) {
+            writeFileSync3(configTomlPath, 'cli_auth_credentials_store = "file"\n');
           }
           if (isIsolationEnabled()) {
             chownMindDir(codexDir, baseName);
@@ -1577,10 +1734,10 @@ var MindManager = class {
           env.OPENAI_API_KEY = process.env.OPENAI_API_KEY;
         }
       }
-      const homeDir = resolve(dir, "home");
+      const homeDir = resolve2(dir, "home");
       const zshenvLines = Object.entries(env).filter(([k, v]) => k.startsWith("VOLUTE_") && v != null).map(([k, v]) => `export ${k}=${JSON.stringify(v)}`);
       zshenvLines.push(`export PATH=${JSON.stringify(env.PATH ?? "")}`);
-      writeFileSync2(resolve(homeDir, ".zshenv"), `${zshenvLines.join("\n")}
+      writeFileSync3(resolve2(homeDir, ".zshenv"), `${zshenvLines.join("\n")}
 `, { mode: 384 });
     }
     if (target.template === "claude" || !target.template) {
@@ -1589,27 +1746,10 @@ var MindManager = class {
         const anthropicConfig = ai?.providers.anthropic;
         if (anthropicConfig?.oauth) {
           const key2 = await resolveApiKey("anthropic");
-          if (key2) {
-            const homeDir = resolve(dir, "home");
-            const claudeDir = resolve(homeDir, ".claude");
-            mkdirSync(claudeDir, { recursive: true });
+          const oauth = getAiConfig()?.providers.anthropic?.oauth;
+          if (key2 && oauth) {
+            const claudeDir = writeClaudeCredentials(resolve2(dir, "home"), baseName, oauth);
             env.CLAUDE_CONFIG_DIR = claudeDir;
-            const credsPath = resolve(claudeDir, ".credentials.json");
-            writeFileSync2(
-              credsPath,
-              JSON.stringify({
-                claudeAiOauth: {
-                  accessToken: key2,
-                  refreshToken: anthropicConfig.oauth.refresh,
-                  expiresAt: anthropicConfig.oauth.expires ? new Date(anthropicConfig.oauth.expires).toISOString() : null,
-                  scopes: ["user:inference", "user:profile"]
-                }
-              }),
-              { mode: 384 }
-            );
-            if (isIsolationEnabled()) {
-              chownMindDir(claudeDir, baseName);
-            }
           }
         } else if (anthropicConfig?.apiKey) {
           env.ANTHROPIC_API_KEY = anthropicConfig.apiKey;
@@ -1619,7 +1759,7 @@ var MindManager = class {
       }
     }
     if (isIsolationEnabled()) {
-      env.HOME = resolve(dir, "home");
+      env.HOME = resolve2(dir, "home");
     }
     const customNode = process.env.VOLUTE_NODE_PATH;
     let baseBin;
@@ -1627,13 +1767,13 @@ var MindManager = class {
     if (customNode) {
       baseBin = customNode;
       baseArgs = [
-        resolve(dir, "node_modules", ".bin", "tsx"),
+        resolve2(dir, "node_modules", ".bin", "tsx"),
         "src/server.ts",
         "--port",
         String(port)
       ];
     } else {
-      baseBin = resolve(dir, "node_modules", ".bin", "tsx");
+      baseBin = resolve2(dir, "node_modules", ".bin", "tsx");
       baseArgs = ["src/server.ts", "--port", String(port)];
     }
     let spawnCmd;
@@ -1667,14 +1807,14 @@ var MindManager = class {
       while (recentStderr.length > 20) recentStderr.shift();
     });
     try {
-      await new Promise((resolve8, reject) => {
+      await new Promise((resolve9, reject) => {
         const timeout = setTimeout(() => {
           reject(new Error(`Mind ${name} did not start within 30s`));
         }, 3e4);
         function checkOutput(data) {
           if (data.toString().match(/listening on :\d+/)) {
             clearTimeout(timeout);
-            resolve8();
+            resolve9();
           }
         }
         child.stdout?.on("data", checkOutput);
@@ -1702,7 +1842,7 @@ var MindManager = class {
     }
     if (child.pid) {
       try {
-        writeFileSync2(pidFile, String(child.pid));
+        writeFileSync3(pidFile, String(child.pid));
       } catch (err) {
         mlog.warn(`failed to write PID file for ${name}`, logger_default.errorData(err));
       }
@@ -1770,7 +1910,7 @@ var MindManager = class {
       if (this.shuttingDown || this.stopping.has(name)) return;
       mlog.error(`mind ${name} exited with code ${code}`);
       try {
-        const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-6QRMUNHK.js");
+        const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-5277OBHI.js");
         const sleepState = getSleepManagerIfReady2()?.getState(name);
         if (sleepState?.sleeping) {
           mlog.info(`${name} is sleeping \u2014 skipping crash recovery`);
@@ -1779,19 +1919,30 @@ var MindManager = class {
       } catch (err) {
         mlog.warn(`failed to check sleep state for ${name}`, logger_default.errorData(err));
       }
-      clearMind(name).then((orphaned) => summarizeOrphanedTurns(orphaned)).catch(
+      clearMind(name).then((orphaned) => {
+        summarizeOrphanedTurns(orphaned);
+        for (const { session } of orphaned) {
+          void recordNotice({
+            mind: name,
+            session: session ?? "main",
+            kind: "crash",
+            reason: "process_crash",
+            detail: "Your process crashed mid-turn and was automatically restarted. That turn was interrupted before it finished \u2014 check whether you left anything incomplete."
+          });
+        }
+      }).catch(
         (err) => mlog.warn(`failed to clear turn state for ${name} after crash`, logger_default.errorData(err))
       );
       try {
-        const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-N34XKUGL.js");
+        const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-VNHLQTTO.js");
         getDeliveryManager2().clearMindSessions(name);
       } catch (err) {
         if (!(err instanceof Error && err.message.includes("not initialized"))) {
           mlog.warn(`failed to clear delivery state for ${name} after crash`, logger_default.errorData(err));
         }
       }
-      import("./mind-activity-tracker-Z3KBQTVU.js").then(({ markIdle: markIdle2 }) => markIdle2(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
-      import("./activity-events-CR4RIHJT.js").then(
+      import("./mind-activity-tracker-XFRVGXFS.js").then(({ markIdle: markIdle2 }) => markIdle2(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
+      import("./activity-events-DS4QRWBY.js").then(
         ({ publish: publish4 }) => publish4({ type: "mind_stopped", mind: name, summary: `${name} crashed (exit ${code})` })
       ).catch((err) => mlog.warn(`failed to publish crash event for ${name}`, logger_default.errorData(err)));
       const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(name);
@@ -1818,19 +1969,19 @@ var MindManager = class {
     this.stopping.add(name);
     const { child } = tracked;
     this.minds.delete(name);
-    await new Promise((resolve8) => {
-      child.on("exit", () => resolve8());
+    await new Promise((resolve9) => {
+      child.on("exit", () => resolve9());
       try {
         process.kill(-child.pid, "SIGTERM");
       } catch {
-        resolve8();
+        resolve9();
       }
       setTimeout(() => {
         try {
           process.kill(-child.pid, "SIGKILL");
         } catch {
         }
-        resolve8();
+        resolve9();
       }, 5e3);
     });
     this.stopping.delete(name);
@@ -1842,7 +1993,7 @@ var MindManager = class {
       mlog.warn(`failed to clear turn state for ${name} on stop`, logger_default.errorData(err));
     }
     try {
-      const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-N34XKUGL.js");
+      const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-VNHLQTTO.js");
       getDeliveryManager2().clearMindSessions(name);
     } catch (err) {
       if (!(err instanceof Error && err.message.includes("not initialized"))) {
@@ -1850,7 +2001,7 @@ var MindManager = class {
       }
     }
     try {
-      const { clearEchoTextCache } = await import("./echo-text-N3BC3WNX.js");
+      const { clearEchoTextCache } = await import("./echo-text-QFCH3H6G.js");
       clearEchoTextCache(name);
     } catch (err) {
       mlog.debug(`failed to clear echo-text cache for ${name}`, logger_default.errorData(err));
@@ -1878,7 +2029,7 @@ var MindManager = class {
     return [...this.minds.keys()];
   }
   get crashAttemptsPath() {
-    return resolve(voluteSystemDir(), "crash-attempts.json");
+    return resolve2(voluteSystemDir(), "crash-attempts.json");
   }
   loadCrashAttempts() {
     this.restartTracker.load(loadJsonMap(this.crashAttemptsPath));
@@ -1976,20 +2127,20 @@ async function announceToSystem(text) {
 }
 
 // packages/daemon/src/lib/extensions.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { dirname, resolve as resolve3 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { dirname, resolve as resolve4 } from "path";
 
 // packages/daemon/src/lib/config/systems-config.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve2 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve3 } from "path";
 var DEFAULT_API_URL = "https://volute.systems";
 function configPath() {
-  return resolve2(voluteSystemDir(), "systems.json");
+  return resolve3(voluteSystemDir(), "systems.json");
 }
 function readSystemsConfig() {
   const path = configPath();
-  if (!existsSync4(path)) return null;
-  const raw = readFileSync3(path, "utf-8");
+  if (!existsSync5(path)) return null;
+  const raw = readFileSync4(path, "utf-8");
   let data;
   try {
     data = JSON.parse(raw);
@@ -2007,8 +2158,8 @@ function readSystemsConfig() {
   };
 }
 function writeSystemsConfig(config) {
-  mkdirSync2(voluteSystemDir(), { recursive: true });
-  writeFileSync3(configPath(), `${JSON.stringify(config, null, 2)}
+  mkdirSync3(voluteSystemDir(), { recursive: true });
+  writeFileSync4(configPath(), `${JSON.stringify(config, null, 2)}
 `, { mode: 384 });
 }
 function deleteSystemsConfig() {
@@ -2067,19 +2218,19 @@ function parseCommandArgs(rawArgs, argDefs, flagDefs) {
   return { args: namedArgs, flags, rest };
 }
 function extensionsBaseDir() {
-  return resolve3(voluteHome(), "extensions");
+  return resolve4(voluteHome(), "extensions");
 }
 function extensionDataDir(id) {
-  return resolve3(voluteSystemDir(), "extension-data", id);
+  return resolve4(voluteSystemDir(), "extension-data", id);
 }
 function extensionsConfigPath() {
-  return resolve3(voluteHome(), "system", "extensions.json");
+  return resolve4(voluteHome(), "system", "extensions.json");
 }
 function readExtensionsConfig() {
   const configPath2 = extensionsConfigPath();
-  if (!existsSync5(configPath2)) return [];
+  if (!existsSync6(configPath2)) return [];
   try {
-    const data = JSON.parse(readFileSync4(configPath2, "utf-8"));
+    const data = JSON.parse(readFileSync5(configPath2, "utf-8"));
     return Array.isArray(data) ? data : [];
   } catch (err) {
     logger_default.warn("failed to read extensions config, ignoring installed extensions", {
@@ -2097,7 +2248,7 @@ async function getLibsqlDatabase() {
   return _LibsqlDatabase;
 }
 async function openExtensionDb(_id, dataDir) {
-  const dbPath = resolve3(dataDir, "data.db");
+  const dbPath = resolve4(dataDir, "data.db");
   const Database = await getLibsqlDatabase();
   return new Database(dbPath);
 }
@@ -2139,7 +2290,7 @@ async function buildContext(manifest, dataDir, authMw) {
     getMindDir: (name) => {
       try {
         const dir = mindDir(name);
-        return existsSync5(dir) ? dir : null;
+        return existsSync6(dir) ? dir : null;
       } catch (err) {
         logger_default.warn(
           `extension ${manifest.id}: failed to resolve mind dir for ${name}`,
@@ -2161,7 +2312,7 @@ async function loadExtension(manifest, app, authMw) {
     return;
   }
   const dataDir = extensionDataDir(manifest.id);
-  mkdirSync3(dataDir, { recursive: true });
+  mkdirSync4(dataDir, { recursive: true });
   const context = await buildContext(manifest, dataDir, authMw);
   const routesApp = manifest.routes(context);
   const extApiPath = `/api/ext/${manifest.id}`;
@@ -2224,18 +2375,18 @@ async function loadExtension(manifest, app, authMw) {
     }
   }
   let resolvedAssetsDir = manifest.ui?.assetsDir ?? "";
-  if (resolvedAssetsDir && !existsSync5(resolvedAssetsDir)) {
+  if (resolvedAssetsDir && !existsSync6(resolvedAssetsDir)) {
     let searchDir = dirname(new URL(import.meta.url).pathname);
     for (let i = 0; i < 5; i++) {
-      const candidate = resolve3(searchDir, "packages", "extensions", manifest.id, "dist", "ui");
-      if (existsSync5(candidate)) {
+      const candidate = resolve4(searchDir, "packages", "extensions", manifest.id, "dist", "ui");
+      if (existsSync6(candidate)) {
         resolvedAssetsDir = candidate;
         break;
       }
       searchDir = dirname(searchDir);
     }
   }
-  if (resolvedAssetsDir && existsSync5(resolvedAssetsDir)) {
+  if (resolvedAssetsDir && existsSync6(resolvedAssetsDir)) {
     const assetsDir = resolvedAssetsDir;
     const { readFile: readFile2, stat: fsStat } = await import("fs/promises");
     const { extname: ext } = await import("path");
@@ -2252,11 +2403,11 @@ async function loadExtension(manifest, app, authMw) {
       ".woff2": "font/woff2"
     };
     const prefix = `/ext/${manifest.id}`;
-    const indexPath = resolve3(assetsDir, "index.html");
+    const indexPath = resolve4(assetsDir, "index.html");
     const serveExtAssets = async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       const relativePath = urlPath.slice(prefix.length).replace(/^\//, "") || "index.html";
-      const filePath = resolve3(assetsDir, relativePath);
+      const filePath = resolve4(assetsDir, relativePath);
       if (filePath !== assetsDir && !filePath.startsWith(`${assetsDir}/`))
         return c.text("Forbidden", 403);
       const s = await fsStat(filePath).catch(() => null);
@@ -2265,7 +2416,7 @@ async function loadExtension(manifest, app, authMw) {
         const body = await readFile2(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      if (existsSync5(indexPath)) {
+      if (existsSync6(indexPath)) {
         const body = await readFile2(indexPath, "utf-8");
         return c.html(body);
       }
@@ -2286,10 +2437,10 @@ async function loadExtension(manifest, app, authMw) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       try {
-        const skillPath = resolve3(skillsDir, entry.name);
+        const skillPath = resolve4(skillsDir, entry.name);
         const sourceHash = hashSkillDir(skillPath);
-        const destDir = resolve3(sharedSkillsDir(), entry.name);
-        if (existsSync5(destDir)) {
+        const destDir = resolve4(sharedSkillsDir(), entry.name);
+        if (existsSync6(destDir)) {
           const destHash = hashSkillDir(destDir);
           if (sourceHash === destHash) continue;
         }
@@ -2316,14 +2467,14 @@ function resolveSkillsDir(manifest) {
   if (cached !== void 0) return cached;
   let searchDir = dirname(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve3(searchDir, "packages", "extensions", manifest.id, "skills");
-    if (existsSync5(candidate)) {
+    const candidate = resolve4(searchDir, "packages", "extensions", manifest.id, "skills");
+    if (existsSync6(candidate)) {
       skillsDirCache.set(manifest.id, candidate);
       return candidate;
     }
     searchDir = dirname(searchDir);
   }
-  if (existsSync5(manifest.skillsDir)) {
+  if (existsSync6(manifest.skillsDir)) {
     skillsDirCache.set(manifest.id, manifest.skillsDir);
     return manifest.skillsDir;
   }
@@ -2333,9 +2484,9 @@ function resolveSkillsDir(manifest) {
 }
 async function discoverBuiltinExtensions(disabledIds) {
   const builtins = [
-    { id: "notes", load: async () => (await import("./src-OYWRPLC6.js")).default },
-    { id: "pages", load: async () => (await import("./src-6Z4XYDH5.js")).default },
-    { id: "plan", load: async () => (await import("./src-O4PRLMKM.js")).default }
+    { id: "notes", load: async () => (await import("./src-2IMB3V27.js")).default },
+    { id: "pages", load: async () => (await import("./src-OS75U2O7.js")).default },
+    { id: "plan", load: async () => (await import("./src-XNUXP2FP.js")).default }
   ];
   const results = [];
   for (const { id, load } of builtins) {
@@ -2351,14 +2502,14 @@ async function discoverBuiltinExtensions(disabledIds) {
 async function discoverInstalledExtensions() {
   const results = [];
   const packages = readExtensionsConfig();
-  const npmDir = resolve3(voluteHome(), "extensions", "_npm");
+  const npmDir = resolve4(voluteHome(), "extensions", "_npm");
   const { createRequire } = await import("module");
   for (const pkg of packages) {
     try {
       let resolved = pkg;
-      const npmPkgDir = resolve3(npmDir, "node_modules", pkg);
-      if (existsSync5(npmPkgDir)) {
-        const require2 = createRequire(resolve3(npmDir, "noop.js"));
+      const npmPkgDir = resolve4(npmDir, "node_modules", pkg);
+      if (existsSync6(npmPkgDir)) {
+        const require2 = createRequire(resolve4(npmDir, "noop.js"));
         resolved = require2.resolve(pkg);
       }
       const mod = await import(resolved);
@@ -2401,7 +2552,7 @@ function validateManifest(manifest, source) {
 }
 async function discoverLocalExtensions() {
   const baseDir = extensionsBaseDir();
-  if (!existsSync5(baseDir)) return [];
+  if (!existsSync6(baseDir)) return [];
   const manifests = [];
   let entries;
   try {
@@ -2411,9 +2562,9 @@ async function discoverLocalExtensions() {
     return [];
   }
   for (const dir of entries) {
-    const extDir = resolve3(baseDir, dir);
-    const candidates = [resolve3(extDir, "src", "index.js"), resolve3(extDir, "index.js")];
-    const entryPoint = candidates.find((p) => existsSync5(p));
+    const extDir = resolve4(baseDir, dir);
+    const candidates = [resolve4(extDir, "src", "index.js"), resolve4(extDir, "index.js")];
+    const entryPoint = candidates.find((p) => existsSync6(p));
     if (!entryPoint) continue;
     try {
       const mod = await import(entryPoint);
@@ -2548,21 +2699,21 @@ function setExtensionEnabled(id, enabled) {
   writeGlobalConfig(config);
 }
 function extensionsNpmDir() {
-  return resolve3(voluteHome(), "extensions", "_npm");
+  return resolve4(voluteHome(), "extensions", "_npm");
 }
 function ensureExtensionsNpmDir() {
   const dir = extensionsNpmDir();
-  mkdirSync3(dir, { recursive: true });
-  const pkgPath = resolve3(dir, "package.json");
-  if (!existsSync5(pkgPath)) {
-    writeFileSync4(pkgPath, '{"private":true,"dependencies":{}}\n');
+  mkdirSync4(dir, { recursive: true });
+  const pkgPath = resolve4(dir, "package.json");
+  if (!existsSync6(pkgPath)) {
+    writeFileSync5(pkgPath, '{"private":true,"dependencies":{}}\n');
   }
   return dir;
 }
 function writeExtensionsConfig(packages) {
   const configPath2 = extensionsConfigPath();
-  mkdirSync3(resolve3(configPath2, ".."), { recursive: true });
-  writeFileSync4(configPath2, `${JSON.stringify(packages, null, 2)}
+  mkdirSync4(resolve4(configPath2, ".."), { recursive: true });
+  writeFileSync5(configPath2, `${JSON.stringify(packages, null, 2)}
 `);
 }
 var VALID_NPM_PACKAGE = /^(@[a-z0-9-~][a-z0-9._-~]*\/)?[a-z0-9-~][a-z0-9._-~]*(@[^\s]+)?$/;
@@ -2575,7 +2726,7 @@ async function installNpmExtension(pkg) {
     throw new Error(`Extension "${pkg}" is already installed`);
   }
   const dir = ensureExtensionsNpmDir();
-  const { exec: exec2 } = await import("./exec-2MFHTGOS.js");
+  const { exec: exec2 } = await import("./exec-5DGKQ5V3.js");
   try {
     await exec2("npm", ["install", pkg], { cwd: dir });
   } catch (err) {
@@ -2596,7 +2747,7 @@ async function uninstallNpmExtension(pkg) {
   packages.splice(idx, 1);
   writeExtensionsConfig(packages);
   try {
-    const { exec: exec2 } = await import("./exec-2MFHTGOS.js");
+    const { exec: exec2 } = await import("./exec-5DGKQ5V3.js");
     await exec2("npm", ["uninstall", pkg], { cwd: extensionsNpmDir() });
   } catch (err) {
     logger_default.warn(
@@ -2608,13 +2759,13 @@ async function uninstallNpmExtension(pkg) {
 }
 async function cleanupExtensionSkills(pkg) {
   try {
-    const pkgDir = resolve3(extensionsNpmDir(), "node_modules", pkg);
-    if (!existsSync5(pkgDir)) return;
+    const pkgDir = resolve4(extensionsNpmDir(), "node_modules", pkg);
+    if (!existsSync6(pkgDir)) return;
     const { createRequire } = await import("module");
-    const require2 = createRequire(resolve3(extensionsNpmDir(), "noop.js"));
+    const require2 = createRequire(resolve4(extensionsNpmDir(), "noop.js"));
     const mod = require2(pkg);
     const manifest = mod.default ?? mod.extension ?? mod;
-    if (!manifest?.skillsDir || !existsSync5(manifest.skillsDir)) return;
+    if (!manifest?.skillsDir || !existsSync6(manifest.skillsDir)) return;
     const skillDirs = readdirSync(manifest.skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     for (const skillId of skillDirs) {
       try {
@@ -2923,9 +3074,9 @@ async function ensureMailAddress(mindName) {
 }
 
 // packages/daemon/src/lib/daemon/scheduler.ts
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 import { CronExpressionParser } from "cron-parser";
-var slog = logger_default.child("scheduler");
+var slog2 = logger_default.child("scheduler");
 var Scheduler = class {
   schedules = /* @__PURE__ */ new Map();
   mindDirs = /* @__PURE__ */ new Map();
@@ -2934,12 +3085,12 @@ var Scheduler = class {
   lastFired = /* @__PURE__ */ new Map();
   // "mind:scheduleId" → epoch minute
   get statePath() {
-    return resolve4(voluteSystemDir(), "scheduler-state.json");
+    return resolve5(voluteSystemDir(), "scheduler-state.json");
   }
   start() {
     this.loadState();
     this.interval = setInterval(() => {
-      this.tick().catch((err) => slog.error("scheduler tick failed", logger_default.errorData(err)));
+      this.tick().catch((err) => slog2.error("scheduler tick failed", logger_default.errorData(err)));
     }, 6e4);
   }
   stop() {
@@ -3006,7 +3157,7 @@ var Scheduler = class {
         prevMinute = Math.floor(prev.getTime() / 6e4);
         cronCache.set(schedule.cron, prevMinute);
       } catch (err) {
-        slog.warn(`invalid cron "${schedule.cron}" for ${mind}:${schedule.id}`, logger_default.errorData(err));
+        slog2.warn(`invalid cron "${schedule.cron}" for ${mind}:${schedule.id}`, logger_default.errorData(err));
         return false;
       }
     }
@@ -3020,11 +3171,11 @@ var Scheduler = class {
     try {
       let text;
       if (schedule.script) {
-        const homeDir = resolve4(this.mindDirs.get(mindName) ?? mindDir(mindName), "home");
+        const homeDir = resolve5(this.mindDirs.get(mindName) ?? mindDir(mindName), "home");
         try {
           const output = await this.runScript(schedule.script, homeDir, mindName);
           if (!output.trim()) {
-            slog.info(`fired script "${schedule.id}" for ${mindName} (no output)`);
+            slog2.info(`fired script "${schedule.id}" for ${mindName} (no output)`);
             return;
           }
           text = output;
@@ -3032,24 +3183,24 @@ var Scheduler = class {
           const stderr = err.stderr ?? "";
           text = `[script error] ${err.message}${stderr ? `
 ${stderr}` : ""}`;
-          slog.warn(`script "${schedule.id}" failed for ${mindName}`, logger_default.errorData(err));
+          slog2.warn(`script "${schedule.id}" failed for ${mindName}`, logger_default.errorData(err));
         }
       } else if (schedule.message) {
         text = schedule.message;
       } else {
-        slog.warn(`schedule "${schedule.id}" for ${mindName} has no message or script`);
+        slog2.warn(`schedule "${schedule.id}" for ${mindName} has no message or script`);
         return;
       }
       await this.deliverSystem(mindName, `[${schedule.id}] ${text}`, {
         whileSleeping: schedule.whileSleeping,
         session: schedule.session
       });
-      slog.info(`fired "${schedule.id}" for ${mindName}`);
+      slog2.info(`fired "${schedule.id}" for ${mindName}`);
       if (schedule.fireAt) {
         this.removeSchedule(mindName, schedule.id);
       }
     } catch (err) {
-      slog.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
+      slog2.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
     }
   }
   removeSchedule(mindName, scheduleId) {
@@ -3069,9 +3220,9 @@ ${stderr}` : ""}`;
       config.schedules = config.schedules.filter((s) => s.id !== scheduleId);
       if (config.schedules.length === 0) config.schedules = void 0;
       writeVoluteConfig(dir, config);
-      slog.info(`removed one-time schedule "${scheduleId}" for ${mindName}`);
+      slog2.info(`removed one-time schedule "${scheduleId}" for ${mindName}`);
     } catch (err) {
-      slog.error(
+      slog2.error(
         `failed to persist removal of schedule "${scheduleId}" for ${mindName} (removed from memory)`,
         logger_default.errorData(err)
       );
@@ -3096,9 +3247,9 @@ function getScheduler() {
 }
 
 // packages/daemon/src/lib/daemon/token-budget.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 import { mkdir, writeFile as writeFile2 } from "fs/promises";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 var tlog2 = logger_default.child("token-budget");
 var DEFAULT_BUDGET_PERIOD_MINUTES = 60;
 var MAX_QUEUE_SIZE = 100;
@@ -3135,7 +3286,8 @@ var TokenBudget = class {
           periodMinutes,
           tokenLimit,
           queue: [],
-          warningInjected: false
+          warningInjected: false,
+          exceededNotified: false
         });
       }
     }
@@ -3163,6 +3315,20 @@ var TokenBudget = class {
     const state = this.budgets.get(mind);
     if (state) state.warningInjected = true;
   }
+  /**
+   * Returns true exactly once per budget period when the mind first crosses its limit,
+   * so callers can record a single "budget exceeded" notice without repeating it on
+   * every subsequent usage event. The flag resets when the period rolls over.
+   */
+  noteExceeded(mind) {
+    const state = this.budgets.get(mind);
+    if (!state) return false;
+    if (state.tokensUsed < state.tokenLimit) return false;
+    if (state.exceededNotified) return false;
+    state.exceededNotified = true;
+    this.dirty.add(mind);
+    return true;
+  }
   enqueue(mind, message) {
     const state = this.budgets.get(mind);
     if (!state) return;
@@ -3198,6 +3364,7 @@ var TokenBudget = class {
         state.tokensUsed = 0;
         state.periodStart = now;
         state.warningInjected = false;
+        state.exceededNotified = false;
         this.dirty.add(mind);
         const queued = this.drain(mind);
         if (queued.length > 0) {
@@ -3221,7 +3388,7 @@ var TokenBudget = class {
     await Promise.all(writes);
   }
   budgetStatePath(mind) {
-    return resolve5(stateDir(mind), "budget.json");
+    return resolve6(stateDir(mind), "budget.json");
   }
   async saveBudgetState(mind, state) {
     try {
@@ -3231,6 +3398,7 @@ var TokenBudget = class {
         periodStart: state.periodStart,
         tokensUsed: state.tokensUsed,
         warningInjected: state.warningInjected,
+        exceededNotified: state.exceededNotified,
         queue: state.queue
       };
       await writeFile2(this.budgetStatePath(mind), `${JSON.stringify(data)}
@@ -3242,13 +3410,14 @@ var TokenBudget = class {
   loadBudgetState(mind) {
     try {
       const path = this.budgetStatePath(mind);
-      if (!existsSync6(path)) return null;
-      const data = JSON.parse(readFileSync5(path, "utf-8"));
+      if (!existsSync7(path)) return null;
+      const data = JSON.parse(readFileSync6(path, "utf-8"));
       if (typeof data.periodStart !== "number" || typeof data.tokensUsed !== "number") return null;
       return {
         periodStart: data.periodStart,
         tokensUsed: data.tokensUsed,
         warningInjected: data.warningInjected ?? false,
+        exceededNotified: data.exceededNotified ?? false,
         queue: Array.isArray(data.queue) ? data.queue : [],
         periodMinutes: 0,
         // will be overwritten by caller
@@ -3371,7 +3540,7 @@ async function wakeMind(name) {
 async function startSpiritFull(name) {
   const entry = await findMind(name);
   if (entry?.dir) {
-    const { registerMindDir } = await import("./delivery-router-EUW4RIWG.js");
+    const { registerMindDir } = await import("./delivery-router-T6CYTS3M.js");
     registerMindDir(name, entry.dir);
   }
   await getMindManager().startMind(name);
@@ -3393,8 +3562,8 @@ async function stopSpiritFull(name) {
   }).catch((err) => logger_default.error("failed to publish spirit_stopped activity", logger_default.errorData(err)));
 }
 async function ensureCreatorDM(mindName, creatorUsername) {
-  const { getOrCreateMindUser: getOrCreateMindUser2, getUserByUsername: getUserByUsername2 } = await import("./auth-OJ2YW3NR.js");
-  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-EUXHBWJD.js");
+  const { getOrCreateMindUser: getOrCreateMindUser2, getUserByUsername: getUserByUsername2 } = await import("./auth-X6ZITZ7D.js");
+  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-AYLXPOGC.js");
   const mindUser = await getOrCreateMindUser2(mindName);
   const creatorUser = await getUserByUsername2(creatorUsername);
   if (!creatorUser) {
@@ -3426,7 +3595,7 @@ async function stopMindFull(name) {
 }
 
 // packages/daemon/src/lib/daemon/sleep-manager.ts
-var slog2 = logger_default.child("sleep");
+var slog3 = logger_default.child("sleep");
 function defaultState() {
   return {
     sleeping: false,
@@ -3469,7 +3638,7 @@ var SleepManager = class {
   transitioning = /* @__PURE__ */ new Set();
   sleepConfigs = /* @__PURE__ */ new Map();
   get statePath() {
-    return resolve6(voluteSystemDir(), "sleep-state.json");
+    return resolve7(voluteSystemDir(), "sleep-state.json");
   }
   start() {
     this.loadState();
@@ -3485,15 +3654,15 @@ var SleepManager = class {
   // --- State persistence ---
   loadState() {
     try {
-      if (existsSync7(this.statePath)) {
-        const data = JSON.parse(readFileSync6(this.statePath, "utf-8"));
+      if (existsSync8(this.statePath)) {
+        const data = JSON.parse(readFileSync7(this.statePath, "utf-8"));
         for (const [name, state] of Object.entries(data)) {
           state.triggerWakeHistory ??= [];
           this.states.set(name, state);
         }
       }
     } catch (err) {
-      slog2.warn("failed to load sleep state", logger_default.errorData(err));
+      slog3.warn("failed to load sleep state", logger_default.errorData(err));
     }
   }
   saveState() {
@@ -3502,10 +3671,10 @@ var SleepManager = class {
       if (state.sleeping) data[name] = state;
     }
     try {
-      writeFileSync5(this.statePath, `${JSON.stringify(data, null, 2)}
+      writeFileSync6(this.statePath, `${JSON.stringify(data, null, 2)}
 `);
     } catch (err) {
-      slog2.error("failed to save sleep state", logger_default.errorData(err));
+      slog3.error("failed to save sleep state", logger_default.errorData(err));
     }
   }
   // --- Public API ---
@@ -3526,7 +3695,7 @@ var SleepManager = class {
     const state = this.states.get(name);
     if (!state?.sleeping || !state.wokenByTrigger) return;
     this.markAwake(name);
-    slog2.info(`${name} trigger-wake converted to full wake`);
+    slog3.info(`${name} trigger-wake converted to full wake`);
   }
   getSleepConfig(name) {
     if (this.sleepConfigs.has(name)) {
@@ -3569,7 +3738,7 @@ var SleepManager = class {
         const result = await sendSystemMessageDirect(name, preSleepMsg);
         conversationId = result.conversationId;
       } catch (err) {
-        slog2.error(`failed to persist pre-sleep message for ${name}`, logger_default.errorData(err));
+        slog3.error(`failed to persist pre-sleep message for ${name}`, logger_default.errorData(err));
       }
       try {
         await fetch(`http://127.0.0.1:${entry.port}/message`, {
@@ -3586,7 +3755,7 @@ var SleepManager = class {
           })
         });
       } catch (err) {
-        slog2.warn(`failed to send pre-sleep message to ${name}`, logger_default.errorData(err));
+        slog3.warn(`failed to send pre-sleep message to ${name}`, logger_default.errorData(err));
       }
       await this.waitForIdle(name, 12e4);
       await new Promise((r) => setTimeout(r, 3e3));
@@ -3594,7 +3763,7 @@ var SleepManager = class {
       await this.killOrphanOnPort(entry.port);
       await this.archiveSessions(name);
       this.markSleeping(name, opts);
-      slog2.info(`${name} is now sleeping`);
+      slog3.info(`${name} is now sleeping`);
     } finally {
       this.transitioning.delete(name);
     }
@@ -3613,7 +3782,7 @@ var SleepManager = class {
         try {
           await wakeMind(name);
         } catch (err) {
-          slog2.error(`failed to wake ${name}`, logger_default.errorData(err));
+          slog3.error(`failed to wake ${name}`, logger_default.errorData(err));
           return;
         }
       }
@@ -3654,7 +3823,7 @@ var SleepManager = class {
           const result = await sendSystemMessageDirect(name, summaryText);
           wakeConvId = result.conversationId;
         } catch (err) {
-          slog2.error(`failed to persist wake summary for ${name}`, logger_default.errorData(err));
+          slog3.error(`failed to persist wake summary for ${name}`, logger_default.errorData(err));
         }
         try {
           await fetch(`http://127.0.0.1:${entry.port}/message`, {
@@ -3671,17 +3840,17 @@ var SleepManager = class {
             })
           });
         } catch (err) {
-          slog2.warn(`failed to deliver wake summary to ${name}`, logger_default.errorData(err));
+          slog3.warn(`failed to deliver wake summary to ${name}`, logger_default.errorData(err));
         }
       }
       const flushed = await this.flushQueuedMessages(name);
       if (flushed > 0) {
-        slog2.info(`flushed ${flushed} queued message(s) for ${name}`);
+        slog3.info(`flushed ${flushed} queued message(s) for ${name}`);
       }
       if (!opts?.trigger) {
         this.markAwake(name);
       }
-      slog2.info(`${name} is now awake${opts?.trigger ? " (trigger wake)" : ""}`);
+      slog3.info(`${name} is now awake${opts?.trigger ? " (trigger wake)" : ""}`);
     } finally {
       this.transitioning.delete(name);
     }
@@ -3736,16 +3905,16 @@ var SleepManager = class {
   async flushQueuedMessages(name) {
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(and2(eq4(deliveryQueue.mind, name), eq4(deliveryQueue.status, "sleep-queued"))).all();
+      const rows = await db.select().from(deliveryQueue).where(and3(eq5(deliveryQueue.mind, name), eq5(deliveryQueue.status, "sleep-queued"))).all();
       if (rows.length === 0) return 0;
-      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-X7MKA3TA.js");
+      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-7BCYJLH2.js");
       const delivered = [];
       for (const row of rows) {
         try {
           await deliverMessage2(name, JSON.parse(row.payload));
           delivered.push(row.id);
         } catch (err) {
-          slog2.warn(`failed to flush queued message ${row.id} for ${name}`, logger_default.errorData(err));
+          slog3.warn(`failed to flush queued message ${row.id} for ${name}`, logger_default.errorData(err));
         }
       }
       if (delivered.length > 0) {
@@ -3757,7 +3926,7 @@ var SleepManager = class {
       }
       return delivered.length;
     } catch (err) {
-      slog2.warn(`failed to flush queued messages for ${name}`, logger_default.errorData(err));
+      slog3.warn(`failed to flush queued messages for ${name}`, logger_default.errorData(err));
       return 0;
     }
   }
@@ -3786,7 +3955,7 @@ var SleepManager = class {
       const interval = CronExpressionParser2.parse(config.schedule.wake);
       return interval.next().toDate().toISOString();
     } catch (err) {
-      slog2.warn(`invalid wake cron "${config.schedule.wake}"`, logger_default.errorData(err));
+      slog3.warn(`invalid wake cron "${config.schedule.wake}"`, logger_default.errorData(err));
       return null;
     }
   }
@@ -3806,7 +3975,7 @@ var SleepManager = class {
         const wakeAt = new Date(state.voluntaryWakeAt);
         if (now >= wakeAt) {
           this.initiateWake(name).catch(
-            (err) => slog2.error(`failed voluntary wake for ${name}`, logger_default.errorData(err))
+            (err) => slog3.error(`failed voluntary wake for ${name}`, logger_default.errorData(err))
           );
           continue;
         }
@@ -3815,7 +3984,7 @@ var SleepManager = class {
         const wakeAt = new Date(state.scheduledWakeAt);
         if (now >= wakeAt) {
           this.initiateWake(name).catch(
-            (err) => slog2.error(`failed scheduled wake for ${name}`, logger_default.errorData(err))
+            (err) => slog3.error(`failed scheduled wake for ${name}`, logger_default.errorData(err))
           );
           continue;
         }
@@ -3823,7 +3992,7 @@ var SleepManager = class {
       if (!state?.sleeping) {
         if (this.shouldSleep(config.schedule.sleep, epochMinute)) {
           this.initiateSleep(name).catch(
-            (err) => slog2.error(`failed to initiate sleep for ${name}`, logger_default.errorData(err))
+            (err) => slog3.error(`failed to initiate sleep for ${name}`, logger_default.errorData(err))
           );
         }
       }
@@ -3836,22 +4005,22 @@ var SleepManager = class {
       const prevMinute = Math.floor(prev.getTime() / 6e4);
       return prevMinute === epochMinute;
     } catch (err) {
-      slog2.warn(`invalid sleep cron "${cronExpr}"`, logger_default.errorData(err));
+      slog3.warn(`invalid sleep cron "${cronExpr}"`, logger_default.errorData(err));
       return false;
     }
   }
   async waitForIdle(name, timeoutMs) {
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       const timeout = setTimeout(() => {
         unsub();
-        resolve8();
+        resolve9();
       }, timeoutMs);
       const unsub = subscribe((event) => {
         if (event.mind !== name) return;
         if (event.type === "mind_done" || event.type === "mind_idle") {
           clearTimeout(timeout);
           unsub();
-          resolve8();
+          resolve9();
         }
       });
     });
@@ -3859,41 +4028,41 @@ var SleepManager = class {
   async archiveSessions(name) {
     const dir = mindDir(name);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 16);
-    const sessionsDir = resolve6(dir, ".mind", "sessions");
-    if (existsSync7(sessionsDir)) {
-      const archiveDir = resolve6(sessionsDir, "archive");
-      mkdirSync4(archiveDir, { recursive: true });
+    const sessionsDir = resolve7(dir, ".mind", "sessions");
+    if (existsSync8(sessionsDir)) {
+      const archiveDir = resolve7(sessionsDir, "archive");
+      mkdirSync5(archiveDir, { recursive: true });
       for (const file of readdirSync2(sessionsDir)) {
         if (file === "archive" || !file.endsWith(".json")) continue;
-        const src = resolve6(sessionsDir, file);
+        const src = resolve7(sessionsDir, file);
         const base = file.replace(/\.json$/, "");
-        const dest = resolve6(archiveDir, `${base}-${timestamp}.json`);
+        const dest = resolve7(archiveDir, `${base}-${timestamp}.json`);
         try {
           renameSync(src, dest);
         } catch (err) {
-          slog2.warn(`failed to archive session ${file} for ${name}`, logger_default.errorData(err));
+          slog3.warn(`failed to archive session ${file} for ${name}`, logger_default.errorData(err));
         }
       }
     }
-    const piSessionsDir = resolve6(dir, ".mind", "pi-sessions");
-    if (existsSync7(piSessionsDir)) {
-      const archiveDir = resolve6(piSessionsDir, "archive");
-      mkdirSync4(archiveDir, { recursive: true });
+    const piSessionsDir = resolve7(dir, ".mind", "pi-sessions");
+    if (existsSync8(piSessionsDir)) {
+      const archiveDir = resolve7(piSessionsDir, "archive");
+      mkdirSync5(archiveDir, { recursive: true });
       for (const entry of readdirSync2(piSessionsDir, { withFileTypes: true })) {
         if (entry.name === "archive" || !entry.isDirectory()) continue;
-        const src = resolve6(piSessionsDir, entry.name);
-        const dest = resolve6(archiveDir, `${entry.name}-${timestamp}`);
+        const src = resolve7(piSessionsDir, entry.name);
+        const dest = resolve7(archiveDir, `${entry.name}-${timestamp}`);
         try {
           renameSync(src, dest);
         } catch (err) {
-          slog2.warn(`failed to archive pi-session ${entry.name} for ${name}`, logger_default.errorData(err));
+          slog3.warn(`failed to archive pi-session ${entry.name} for ${name}`, logger_default.errorData(err));
         }
       }
     }
   }
   async runWakeContextScript(name, sleepingSince, duration) {
-    const scriptPath = resolve6(mindDir(name), "home", ".local", "hooks", "wake-context.sh");
-    if (!existsSync7(scriptPath)) return "";
+    const scriptPath = resolve7(mindDir(name), "home", ".local", "hooks", "wake-context.sh");
+    if (!existsSync8(scriptPath)) return "";
     const input = JSON.stringify({
       sleepingSince,
       duration,
@@ -3929,7 +4098,7 @@ var SleepManager = class {
       });
       return result.trim();
     } catch (err) {
-      slog2.warn(`wake-context script failed for ${name}`, logger_default.errorData(err));
+      slog3.warn(`wake-context script failed for ${name}`, logger_default.errorData(err));
       return "";
     }
   }
@@ -3943,7 +4112,7 @@ var SleepManager = class {
   async buildQueuedSummary(name) {
     try {
       const db = await getDb();
-      const rows = await db.select({ channel: deliveryQueue.channel, sender: deliveryQueue.sender }).from(deliveryQueue).where(and2(eq4(deliveryQueue.mind, name), eq4(deliveryQueue.status, "sleep-queued"))).all();
+      const rows = await db.select({ channel: deliveryQueue.channel, sender: deliveryQueue.sender }).from(deliveryQueue).where(and3(eq5(deliveryQueue.mind, name), eq5(deliveryQueue.status, "sleep-queued"))).all();
       if (rows.length === 0) return "No messages arrived while you slept.";
       const channelCounts = /* @__PURE__ */ new Map();
       const senders = /* @__PURE__ */ new Set();
@@ -3956,7 +4125,7 @@ var SleepManager = class {
       const senderNote = senders.size > 0 ? ` from ${[...senders].join(", ")}` : "";
       return `${rows.length} message${rows.length === 1 ? "" : "s"} arrived while you slept${senderNote} (${parts.join(", ")}). They'll be delivered to your normal channels now.`;
     } catch (err) {
-      slog2.error(`failed to build queued summary for ${name}`, logger_default.errorData(err));
+      slog3.error(`failed to build queued summary for ${name}`, logger_default.errorData(err));
       return "Unable to check for queued messages \u2014 there may be messages waiting.";
     }
   }
@@ -3971,7 +4140,7 @@ var SleepManager = class {
     } catch {
       return;
     }
-    slog2.warn(`orphan process found on port ${port} after sleep, killing`);
+    slog3.warn(`orphan process found on port ${port} after sleep, killing`);
     const execFileAsync2 = promisify2(execFile2);
     try {
       const { stdout } = await execFileAsync2("lsof", ["-ti", `:${port}`, "-sTCP:LISTEN"]);
@@ -3982,7 +4151,7 @@ var SleepManager = class {
             process.kill(pid, "SIGTERM");
           } catch (err) {
             if (err.code !== "ESRCH") {
-              slog2.warn(`failed to kill orphan pid ${pid}`, logger_default.errorData(err));
+              slog3.warn(`failed to kill orphan pid ${pid}`, logger_default.errorData(err));
             }
           }
         }
@@ -3990,7 +4159,7 @@ var SleepManager = class {
     } catch {
       try {
         const portHex = port.toString(16).toUpperCase().padStart(4, "0");
-        const tcp6 = readFileSync6("/proc/net/tcp6", "utf-8");
+        const tcp6 = readFileSync7("/proc/net/tcp6", "utf-8");
         for (const line of tcp6.split("\n")) {
           if (!line.includes(`:${portHex} `)) continue;
           const fields = line.trim().split(/\s+/);
@@ -4014,7 +4183,7 @@ var SleepManager = class {
           }
         }
       } catch (err) {
-        slog2.warn(`failed to kill orphan on port ${port} via /proc`, logger_default.errorData(err));
+        slog3.warn(`failed to kill orphan on port ${port} via /proc`, logger_default.errorData(err));
       }
     }
     await new Promise((r) => setTimeout(r, 1e3));
@@ -4024,7 +4193,7 @@ var SleepManager = class {
     if (!state?.sleeping || !state.wokenByTrigger) return;
     if (this.transitioning.has(event.mind)) return;
     if (event.type === "mind_idle") {
-      slog2.info(`${event.mind} going back to sleep after trigger wake`);
+      slog3.info(`${event.mind} going back to sleep after trigger wake`);
       state.wokenByTrigger = false;
       this.transitioning.add(event.mind);
       sleepMind(event.mind).then(() => this.archiveSessions(event.mind)).then(() => {
@@ -4033,9 +4202,9 @@ var SleepManager = class {
         const sleepConfig = this.getSleepConfig(event.mind);
         state.scheduledWakeAt = this.getNextWakeTime(sleepConfig);
         this.saveState();
-        slog2.info(`${event.mind} returned to sleep`);
+        slog3.info(`${event.mind} returned to sleep`);
       }).catch((err) => {
-        slog2.error(`failed to return ${event.mind} to sleep`, logger_default.errorData(err));
+        slog3.error(`failed to return ${event.mind} to sleep`, logger_default.errorData(err));
       }).finally(() => {
         this.transitioning.delete(event.mind);
       });
@@ -4058,8 +4227,8 @@ function getSleepManagerIfReady() {
 
 // packages/daemon/src/lib/delivery/delivery-manager.ts
 import { readFile, realpath } from "fs/promises";
-import { extname, resolve as resolve7 } from "path";
-import { and as and3, eq as eq5, sql as sql2 } from "drizzle-orm";
+import { extname, resolve as resolve8 } from "path";
+import { and as and4, eq as eq6, sql as sql3 } from "drizzle-orm";
 
 // packages/daemon/src/lib/chat/typing.ts
 var DEFAULT_TTL_MS = 1e4;
@@ -4257,7 +4426,7 @@ var DeliveryManager = class {
   async restoreFromDb() {
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(eq5(deliveryQueue.status, "pending"));
+      const rows = await db.select().from(deliveryQueue).where(eq6(deliveryQueue.status, "pending"));
       for (const row of rows) {
         let payload;
         try {
@@ -4275,7 +4444,7 @@ var DeliveryManager = class {
           this.addToBatchBuffer(row.mind, row.session, payload, sessionConfig);
         } else {
           try {
-            await db.delete(deliveryQueue).where(eq5(deliveryQueue.id, row.id));
+            await db.delete(deliveryQueue).where(eq6(deliveryQueue.id, row.id));
           } catch (err) {
             dlog.warn(`failed to delete queue row ${row.id} for ${row.mind}`, logger_default.errorData(err));
           }
@@ -4296,7 +4465,7 @@ var DeliveryManager = class {
    */
   async getPending(mindName) {
     const db = await getDb();
-    const rows = await db.select().from(deliveryQueue).where(and3(eq5(deliveryQueue.mind, mindName), eq5(deliveryQueue.status, "gated")));
+    const rows = await db.select().from(deliveryQueue).where(and4(eq6(deliveryQueue.mind, mindName), eq6(deliveryQueue.status, "gated")));
     const byChannel = /* @__PURE__ */ new Map();
     for (const row of rows) {
       const ch = row.channel ?? "unknown";
@@ -4491,10 +4660,10 @@ var DeliveryManager = class {
         try {
           const db = await getDb();
           await db.delete(deliveryQueue).where(
-            and3(
-              eq5(deliveryQueue.mind, baseName),
-              eq5(deliveryQueue.session, session),
-              eq5(deliveryQueue.status, "pending")
+            and4(
+              eq6(deliveryQueue.mind, baseName),
+              eq6(deliveryQueue.session, session),
+              eq6(deliveryQueue.status, "pending")
             )
           );
         } catch (err) {
@@ -4620,11 +4789,11 @@ var DeliveryManager = class {
     await this.persistToQueue(baseName, session, payload, "gated");
     try {
       const db = await getDb();
-      const count = await db.select({ count: sql2`count(*)` }).from(deliveryQueue).where(
-        and3(
-          eq5(deliveryQueue.mind, baseName),
-          eq5(deliveryQueue.channel, payload.channel),
-          eq5(deliveryQueue.status, "gated")
+      const count = await db.select({ count: sql3`count(*)` }).from(deliveryQueue).where(
+        and4(
+          eq6(deliveryQueue.mind, baseName),
+          eq6(deliveryQueue.channel, payload.channel),
+          eq6(deliveryQueue.status, "gated")
         )
       );
       if ((count[0]?.count ?? 0) <= 1) {
@@ -4649,7 +4818,7 @@ var DeliveryManager = class {
       `To accept this channel, add a routing rule for "${channel}" to your routes.json.`,
       `Messages are being held until a route is configured.`
     ].filter((line) => line !== null).join("\n");
-    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-D343HYGR.js");
+    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-LQSJVY55.js");
     await sendSystemMessage2(mindName, notification);
   }
   async persistToQueue(mindName, session, payload, status = "pending") {
@@ -4723,8 +4892,8 @@ var DeliveryManager = class {
           const dir = mindDir(p.username);
           const config = readVoluteConfig(dir);
           if (!config?.profile?.avatar) continue;
-          filePath = resolve7(dir, "home", config.profile.avatar);
-          const homeDir = resolve7(dir, "home");
+          filePath = resolve8(dir, "home", config.profile.avatar);
+          const homeDir = resolve8(dir, "home");
           if (!filePath.startsWith(`${homeDir}/`)) {
             dlog.warn(`avatar path for ${p.username} escapes home directory, skipping`);
             continue;
@@ -4743,7 +4912,7 @@ var DeliveryManager = class {
             throw err;
           }
         } else {
-          filePath = resolve7(voluteHome(), "avatars", p.avatar);
+          filePath = resolve8(voluteHome(), "avatars", p.avatar);
         }
         const ext = extname(filePath).toLowerCase();
         const mimeMap = {
@@ -4885,18 +5054,18 @@ async function linkToolResultToTurn(mind, turnId, toolResultContent, toolUseEven
         channel: mindHistory.channel,
         content: mindHistory.content,
         message_id: mindHistory.message_id
-      }).from(mindHistory).where(and4(eq6(mindHistory.id, outboundId), eq6(mindHistory.mind, mind))).limit(1);
+      }).from(mindHistory).where(and5(eq7(mindHistory.id, outboundId), eq7(mindHistory.mind, mind))).limit(1);
       const row = rows[0];
       if (!row) {
         dlog2.warn(`outbound marker references missing record: mind=${mind} id=${outboundId}`);
         continue;
       }
-      await db.update(mindHistory).set({ turn_id: turnId }).where(eq6(mindHistory.id, outboundId));
+      await db.update(mindHistory).set({ turn_id: turnId }).where(eq7(mindHistory.id, outboundId));
       if (row.message_id) {
         await db.update(messages).set({
           turn_id: turnId,
           ...toolUseEventId != null ? { source_event_id: toolUseEventId } : {}
-        }).where(eq6(messages.id, Number(row.message_id)));
+        }).where(eq7(messages.id, Number(row.message_id)));
       }
       publish3(mind, {
         mind,
@@ -4940,19 +5109,19 @@ async function linkToolResultToTurn(mind, turnId, toolResultContent, toolUseEven
 async function tagUntaggedOutbound(mind, turnId) {
   const db = await getDb();
   const range = await db.select({
-    minId: sql3`MIN(${mindHistory.id})`,
-    maxId: sql3`MAX(${mindHistory.id})`
-  }).from(mindHistory).where(and4(eq6(mindHistory.mind, mind), eq6(mindHistory.turn_id, turnId)));
+    minId: sql4`MIN(${mindHistory.id})`,
+    maxId: sql4`MAX(${mindHistory.id})`
+  }).from(mindHistory).where(and5(eq7(mindHistory.mind, mind), eq7(mindHistory.turn_id, turnId)));
   const minId = range[0]?.minId;
   const maxId = range[0]?.maxId;
   if (minId == null || maxId == null) return;
   const orphans = await db.select({ id: mindHistory.id, message_id: mindHistory.message_id }).from(mindHistory).where(
-    and4(
-      eq6(mindHistory.mind, mind),
-      eq6(mindHistory.type, "outbound"),
-      sql3`${mindHistory.turn_id} IS NULL`,
-      sql3`${mindHistory.id} >= ${minId}`,
-      sql3`${mindHistory.id} <= ${maxId}`
+    and5(
+      eq7(mindHistory.mind, mind),
+      eq7(mindHistory.type, "outbound"),
+      sql4`${mindHistory.turn_id} IS NULL`,
+      sql4`${mindHistory.id} >= ${minId}`,
+      sql4`${mindHistory.id} <= ${maxId}`
     )
   );
   if (orphans.length === 0) return;
@@ -4961,10 +5130,10 @@ async function tagUntaggedOutbound(mind, turnId) {
   const orphansWithMessages = orphans.filter((o) => o.message_id);
   if (orphansWithMessages.length > 0) {
     const toolUseEvents = await db.select({ id: mindHistory.id }).from(mindHistory).where(
-      and4(
-        eq6(mindHistory.mind, mind),
-        eq6(mindHistory.turn_id, turnId),
-        eq6(mindHistory.type, "tool_use")
+      and5(
+        eq7(mindHistory.mind, mind),
+        eq7(mindHistory.turn_id, turnId),
+        eq7(mindHistory.type, "tool_use")
       )
     ).orderBy(mindHistory.id);
     for (const orphan of orphansWithMessages) {
@@ -4978,7 +5147,7 @@ async function tagUntaggedOutbound(mind, turnId) {
       await db.update(messages).set({
         turn_id: turnId,
         ...sourceEventId != null ? { source_event_id: sourceEventId } : {}
-      }).where(eq6(messages.id, Number(orphan.message_id)));
+      }).where(eq7(messages.id, Number(orphan.message_id)));
     }
   }
   dlog2.info(`tagged ${orphans.length} orphaned outbound record(s) for ${mind} with turn ${turnId}`);
@@ -4992,22 +5161,22 @@ async function tagUntaggedInbound(mind, turnId, {
   const tagHistoryPromise = (async () => {
     if (!channel) return;
     const historyConditions = [
-      eq6(mindHistory.mind, mind),
-      eq6(mindHistory.type, "inbound"),
-      sql3`${mindHistory.turn_id} IS NULL`,
-      sql3`${mindHistory.created_at} > datetime('now', '-60 seconds')`,
-      eq6(mindHistory.channel, channel)
+      eq7(mindHistory.mind, mind),
+      eq7(mindHistory.type, "inbound"),
+      sql4`${mindHistory.turn_id} IS NULL`,
+      sql4`${mindHistory.created_at} > datetime('now', '-60 seconds')`,
+      eq7(mindHistory.channel, channel)
     ];
-    const recentInbounds = await db.select({ id: mindHistory.id }).from(mindHistory).where(and4(...historyConditions)).orderBy(desc2(mindHistory.id)).limit(limit);
+    const recentInbounds = await db.select({ id: mindHistory.id }).from(mindHistory).where(and5(...historyConditions)).orderBy(desc2(mindHistory.id)).limit(limit);
     if (recentInbounds.length > 0) {
       const ids = recentInbounds.map((r) => r.id);
       await db.update(mindHistory).set({ turn_id: turnId }).where(inArray3(mindHistory.id, ids));
       if (setTrigger) {
-        await db.update(turns).set({ trigger_event_id: recentInbounds[0].id }).where(eq6(turns.id, turnId));
+        await db.update(turns).set({ trigger_event_id: recentInbounds[0].id }).where(eq7(turns.id, turnId));
       }
     }
   })();
-  const mindUserPromise = db.select({ id: users.id }).from(users).where(and4(eq6(users.username, mind), eq6(users.user_type, "mind"))).get();
+  const mindUserPromise = db.select({ id: users.id }).from(users).where(and5(eq7(users.username, mind), eq7(users.user_type, "mind"))).get();
   const [tagResult, mindUserResult] = await Promise.allSettled([
     tagHistoryPromise,
     mindUserPromise
@@ -5016,13 +5185,13 @@ async function tagUntaggedInbound(mind, turnId, {
     dlog2.error("failed to tag history inbound", logger_default.errorData(tagResult.reason));
   }
   const mindUser = mindUserResult.status === "fulfilled" ? mindUserResult.value : void 0;
-  const mindConvIds = mindUser ? (await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq6(conversationParticipants.user_id, mindUser.id))).map((r) => r.conversation_id) : [];
+  const mindConvIds = mindUser ? (await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq7(conversationParticipants.user_id, mindUser.id))).map((r) => r.conversation_id) : [];
   const recentMsgs = mindConvIds.length > 0 ? await db.select({ id: messages.id }).from(messages).where(
-    and4(
+    and5(
       inArray3(messages.conversation_id, mindConvIds),
-      sql3`${messages.turn_id} IS NULL`,
-      sql3`${messages.sender_name} != ${mind}`,
-      sql3`${messages.created_at} > datetime('now', '-60 seconds')`
+      sql4`${messages.turn_id} IS NULL`,
+      sql4`${messages.sender_name} != ${mind}`,
+      sql4`${messages.created_at} > datetime('now', '-60 seconds')`
     )
   ).orderBy(desc2(messages.id)).limit(limit) : [];
   if (recentMsgs.length > 0) {
@@ -5083,7 +5252,7 @@ async function deliverMessage(mindName, payload) {
 }
 
 // packages/daemon/src/lib/chat/system-chat.ts
-var slog3 = logger_default.child("system-chat");
+var slog4 = logger_default.child("system-chat");
 var dmCache = /* @__PURE__ */ new Map();
 function resetSystemDMCache() {
   dmCache.clear();
@@ -5151,7 +5320,7 @@ async function generateSystemReply(conversationId, mindName, message) {
       });
       return;
     } catch (err) {
-      slog3.warn(`failed to route to spirit, falling back to aiCompleteUtility`, logger_default.errorData(err));
+      slog4.warn(`failed to route to spirit, falling back to aiCompleteUtility`, logger_default.errorData(err));
     }
   }
   const entry = await findMind(mindName);
@@ -5172,7 +5341,7 @@ async function generateSystemReply(conversationId, mindName, message) {
     if (config.sleep.schedule?.wake) contextParts.push(`Wake cron: ${config.sleep.schedule.wake}`);
   }
   try {
-    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-6QRMUNHK.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-5277OBHI.js");
     const sm = getSleepManagerIfReady2();
     if (sm) {
       const state = sm.getState(mindName);
@@ -5181,7 +5350,7 @@ async function generateSystemReply(conversationId, mindName, message) {
       }
     }
   } catch (err) {
-    slog3.debug("could not retrieve sleep state for system reply", logger_default.errorData(err));
+    slog4.debug("could not retrieve sleep state for system reply", logger_default.errorData(err));
   }
   try {
     const schedules = config?.schedules;
@@ -5194,12 +5363,12 @@ async function generateSystemReply(conversationId, mindName, message) {
       }
     }
   } catch (err) {
-    slog3.debug("could not retrieve schedules for system reply", logger_default.errorData(err));
+    slog4.debug("could not retrieve schedules for system reply", logger_default.errorData(err));
   }
   const systemPrompt = contextParts.join("\n");
   const response = await aiCompleteUtility(systemPrompt, message);
   if (!response) {
-    slog3.warn(`no AI model available for system reply to ${mindName}`);
+    slog4.warn(`no AI model available for system reply to ${mindName}`);
     const fallback = "I can't reply right now \u2014 no AI model is configured for system responses. An admin can set one up in Settings.";
     await addMessage(conversationId, "assistant", "volute", [{ type: "text", text: fallback }]);
     return;
@@ -5229,13 +5398,20 @@ export {
   getPromptIfCustom,
   getMindPromptDefaults,
   RotatingLog,
+  syncProviderToMinds,
   resolveMindToken,
+  recordNotice,
+  drainNotices,
+  clearDeliveredNotices,
+  formatNotices,
   RestartTracker,
   subscribe2 as subscribe,
   subscribeAll,
   publish3 as publish,
   summarizeTurn,
   initSummarizer,
+  markErrored,
+  takeErrored,
   createTurn,
   getActiveTurnId,
   trackToolUse,