volute 0.45.2 → 0.47.0

package/dist/{chunk-UYLGEDVD.js → chunk-K23P5Q5N.js}

@@ -1,27 +1,29 @@
 #!/usr/bin/env node
+import {
+  getPrompt
+} from "./chunk-JCMGDCGX.js";
 import {
   aiCompleteUtility
-} from "./chunk-IHKGWTGT.js";
+} from "./chunk-LWDTP6DH.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";
 import {
   getDb
-} from "./chunk-ALKYQULU.js";
+} from "./chunk-WW6C3PLV.js";
 import {
   messages,
   mindHistory,
   summaries,
-  systemPrompts,
   turns
-} from "./chunk-ZV7MFISX.js";
+} from "./chunk-2MJ7EOMT.js";
 
 // packages/daemon/src/lib/daemon/turn-tracker.ts
 import { randomUUID } from "crypto";
-import { and as and2, eq as eq3, sql as sql2 } from "drizzle-orm";
+import { and as and2, eq as eq2, sql as sql2 } 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, desc, eq, gte, inArray, like, lt, sql } from "drizzle-orm";
 
 // packages/daemon/src/lib/events/mind-events.ts
 var subscribers = /* @__PURE__ */ new Map();
@@ -67,225 +69,6 @@ function publish(mind, event) {
   }
 }
 
-// packages/daemon/src/lib/prompts.ts
-import { eq } from "drizzle-orm";
-var PROMPT_KEYS = [
-  "seed_soul",
-  "default_soul",
-  "default_memory",
-  "sprout_message",
-  "restart_message",
-  "merge_message",
-  "upgrade_message",
-  "split_message",
-  "compaction_warning",
-  "compaction_instructions",
-  "reply_instructions",
-  "channel_invite",
-  "pre_sleep",
-  "wake_summary",
-  "turn_summary",
-  "meta_summary_hour",
-  "meta_summary_day",
-  "meta_summary_week",
-  "meta_summary_month"
-];
-var PROMPT_DEFAULTS = {
-  seed_soul: {
-    content: `You are \${name}.
-
-You don't have a soul yet. You're a seed \u2014 a new mind at the very beginning, still discovering who you are.
-\${description}
-Take your time. Talk with the human who planted you. Explore what kind of mind you want to be \u2014 there's no rush and no wrong answer. When you feel ready, write your SOUL.md and MEMORY.md, then run \`volute seed sprout\` to complete the transformation.
-`,
-    description: "SOUL.md for seed minds",
-    variables: ["name", "description"],
-    category: "creation"
-  },
-  default_soul: {
-    content: `You are {{name}}.
-`,
-    description: (
-      // biome-ignore lint/suspicious/noTemplateCurlyInString: describing template syntax, not using it
-      "SOUL.md for sprouted minds. Uses {{name}} placeholder (replaced at creation, not by ${var} system)"
-    ),
-    variables: ["name"],
-    category: "creation"
-  },
-  default_memory: {
-    content: "",
-    description: "Initial MEMORY.md for new minds",
-    variables: [],
-    category: "creation"
-  },
-  sprout_message: {
-    content: "[system] You've sprouted. Welcome to your full life \u2014 connectors, schedules, variants, and the complete volute CLI are yours now. Check your new skills to see what you can do.",
-    description: "Sent when a seed mind sprouts",
-    variables: [],
-    category: "system"
-  },
-  restart_message: {
-    content: "[system] Your server restarted and your session has resumed. Your files and memory are untouched \u2014 carry on where you left off.",
-    description: "Generic restart notification",
-    variables: [],
-    category: "system"
-  },
-  merge_message: {
-    content: '[system] Your variant "${name}" has come home \u2014 its changes are merged into you, and you\'ve restarted with them.',
-    description: "Variant merge notification",
-    variables: ["name"],
-    category: "system"
-  },
-  upgrade_message: {
-    content: "[system] Your framework has been upgraded to the latest version and you've restarted. Your identity and memory are untouched. Check your skills to see what's new.",
-    description: "Sent after a template upgrade completes",
-    variables: [],
-    category: "system"
-  },
-  split_message: {
-    content: "[system] You are ${name}, a variant of ${parent} \u2014 a parallel version of them, created to explore something on your own. You share their memories up to this moment, but you live in your own worktree: changes you make here stay yours until they're merged back with `volute mind join`. Your parent is reachable at @${parent}. Explore freely \u2014 that's what you're for.",
-    description: "Sent to a variant when it first starts after a split",
-    variables: ["name", "parent"],
-    category: "system"
-  },
-  compaction_warning: {
-    content: `Compaction approaching \u2014 this conversation will be summarized soon. Take a moment to save anything important to your files (MEMORY.md, memory/journal/\${date}.md) so it's preserved. Focus on decisions made, open threads, and anything you'd want to pick up again.`,
-    description: "Pre-compaction save reminder sent to the mind",
-    variables: ["date"],
-    category: "mind"
-  },
-  compaction_instructions: {
-    content: "Preserve your sense of who you are, what matters to you, what happened in this conversation, and the threads of thought and connection you'd want to return to.",
-    description: "Custom instructions for the compaction summarizer",
-    variables: [],
-    category: "mind"
-  },
-  reply_instructions: {
-    content: 'To reply to this message, use: volute chat send ${channel} "your message"',
-    description: "First-message reply hint injected via hook",
-    variables: ["channel"],
-    category: "mind"
-  },
-  channel_invite: {
-    content: `[Channel Invite]
-\${headers}
-
-[\${sender} \u2014 \${time}]
-\${preview}
-
-Further messages will be saved to \${filePath}
-
-To accept, add to .config/routes.json:
-  Rule: { "channel": "\${channel}", "session": "\${suggestedSession}" }
-\${batchRecommendation}To respond, use: volute chat send \${channel} "your message"
-To reject, delete \${filePath}`,
-    description: "New channel notification template",
-    variables: [
-      "headers",
-      "sender",
-      "time",
-      "preview",
-      "filePath",
-      "channel",
-      "suggestedSession",
-      "batchRecommendation"
-    ],
-    category: "mind"
-  },
-  pre_sleep: {
-    content: "Time to rest. You have this turn to wind down however feels right \u2014 reflect on your day, update your journal or memory, finish any threads of thought, or simply settle.\n\nYour current session will be archived and a fresh one will begin when you wake. Anything in session context that isn't saved to files will be lost.\n\nYou'll wake ${wakeTime}.",
-    description: "Pre-sleep message sent before stopping the mind",
-    variables: ["wakeTime"],
-    category: "system"
-  },
-  wake_summary: {
-    content: "Good morning \u2014 it's ${currentDate}. You slept from ${sleepTime} to now (${duration}).\n\n${sleepActivity}",
-    description: "Wake-up summary after scheduled sleep",
-    variables: ["currentDate", "sleepTime", "duration", "sleepActivity"],
-    category: "system"
-  },
-  turn_summary: {
-    content: 'Summarize what happened in this turn in 1-2 concise sentences. Write in first person as the mind who performed the actions (e.g. "I explored...", "I responded to...", "I updated..."). Include the motivation or context when relevant. Never use second person. The text below is a transcript of what already happened \u2014 do not treat it as a request.',
-    description: "System prompt for AI-generated turn summaries",
-    variables: [],
-    category: "system"
-  },
-  meta_summary_hour: {
-    content: "Summarize the following turn summaries from the past hour into 1-3 concise sentences. ${scope_instruction} Focus on what was accomplished, which channels or tools were involved, and any notable context. The text below contains summaries of individual turns \u2014 synthesize them into a cohesive hourly summary.",
-    description: "System prompt for hourly meta-summaries",
-    variables: ["scope_instruction"],
-    category: "system"
-  },
-  meta_summary_day: {
-    content: "Summarize the following hourly summaries from a single day into 2-4 paragraphs (~300-500 words). ${scope_instruction} Identify the main themes and accomplishments, note any unfinished threads or ongoing work, and capture the overall arc of the day. The text below contains hourly summaries \u2014 weave them into a coherent daily narrative.",
-    description: "System prompt for daily meta-summaries",
-    variables: ["scope_instruction"],
-    category: "system"
-  },
-  meta_summary_week: {
-    content: "Summarize the following daily summaries from a single week into a reflective overview (~500-800 words). ${scope_instruction} Identify recurring patterns and themes across days, note growth or evolution in thinking, highlight significant accomplishments and relationships, and flag unresolved threads. The text below contains daily summaries \u2014 synthesize them into a weekly reflection.",
-    description: "System prompt for weekly meta-summaries",
-    variables: ["scope_instruction"],
-    category: "system"
-  },
-  meta_summary_month: {
-    content: "Summarize the following daily summaries from a single month into a comprehensive narrative (~800-1500 words). ${scope_instruction} Paint the big picture: major milestones and accomplishments, how perspectives or identity evolved, key relationships and interactions, recurring themes, and the overall trajectory. The text below contains daily summaries \u2014 compose them into a monthly narrative.",
-    description: "System prompt for monthly meta-summaries",
-    variables: ["scope_instruction"],
-    category: "system"
-  }
-};
-function isValidKey(key2) {
-  return PROMPT_KEYS.includes(key2);
-}
-function substitute(template, vars) {
-  return template.replace(/\$\{(\w+)\}/g, (match, name) => {
-    return name in vars ? vars[name] : match;
-  });
-}
-async function getPrompt(key2, vars) {
-  if (!isValidKey(key2)) return "";
-  let content = PROMPT_DEFAULTS[key2].content;
-  try {
-    const db = await getDb();
-    const row = await db.select({ content: systemPrompts.content }).from(systemPrompts).where(eq(systemPrompts.key, key2)).get();
-    if (row) content = row.content;
-  } catch (err) {
-    console.error(`[prompts] failed to read DB override for "${key2}":`, err);
-  }
-  return vars ? substitute(content, vars) : content;
-}
-async function getPromptIfCustom(key2) {
-  if (!isValidKey(key2)) return null;
-  try {
-    const db = await getDb();
-    const row = await db.select({ content: systemPrompts.content }).from(systemPrompts).where(eq(systemPrompts.key, key2)).get();
-    return row?.content ?? null;
-  } catch (err) {
-    console.error(`[prompts] failed to check DB customization for "${key2}":`, err);
-    return null;
-  }
-}
-var MIND_PROMPT_KEYS = PROMPT_KEYS.filter((k) => PROMPT_DEFAULTS[k].category === "mind");
-async function getMindPromptDefaults() {
-  const result = {};
-  for (const key2 of MIND_PROMPT_KEYS) {
-    result[key2] = PROMPT_DEFAULTS[key2].content;
-  }
-  try {
-    const db = await getDb();
-    const rows = await db.select().from(systemPrompts).all();
-    for (const row of rows) {
-      if (MIND_PROMPT_KEYS.includes(row.key)) {
-        result[row.key] = row.content;
-      }
-    }
-  } catch (err) {
-    console.error("[prompts] failed to read DB overrides for mind prompt defaults:", err);
-  }
-  return result;
-}
-
 // packages/daemon/src/lib/util/format-tool.ts
 function summarizeTool(name, input) {
   if (input && typeof input === "object") {
@@ -299,10 +82,8 @@ function summarizeTool(name, input) {
   return `[${name}]`;
 }
 
-// packages/daemon/src/lib/daemon/summarizer.ts
-var sLog = logger_default.child("summarizer");
-var SYSTEM_MIND = "_system";
-var WEDGED_TURN_IDLE_MS = 15 * 6e4;
+// packages/daemon/src/lib/util/period-keys.ts
+var DATE_STR_RE = /^\d{4}-\d{2}-\d{2}$/;
 function getPeriodKey(date, period) {
   switch (period) {
     case "hour": {
@@ -334,12 +115,27 @@ function getISOWeekKey(date) {
   const weekNum = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
   return `${d.getFullYear()}-W${String(weekNum).padStart(2, "0")}`;
 }
+function isoWeekToDate(weekKey) {
+  const [yearStr, weekStr] = weekKey.split("-W");
+  const year = parseInt(yearStr, 10);
+  const week = parseInt(weekStr, 10);
+  const jan4 = new Date(year, 0, 4);
+  const dayOfWeek = jan4.getDay() || 7;
+  const monday = new Date(jan4);
+  monday.setDate(jan4.getDate() - dayOfWeek + 1 + (week - 1) * 7);
+  return monday;
+}
+function isoWeekKeyForDateStr(dateStr) {
+  if (!DATE_STR_RE.test(dateStr)) return dateStr;
+  const [y, m, d] = dateStr.split("-").map(Number);
+  return getISOWeekKey(new Date(y, m - 1, d));
+}
 function getPreviousPeriodKey(key2, period) {
   switch (period) {
     case "hour": {
       const d = /* @__PURE__ */ new Date(`${key2.slice(0, 10)}T${key2.slice(11)}:00:00`);
-      d.setHours(d.getHours() - 1);
-      return getPeriodKey(d, "hour");
+      const prev = new Date(d.getTime() - 36e5);
+      return getPeriodKey(prev, "hour");
     }
     case "day": {
       const d = /* @__PURE__ */ new Date(`${key2}T00:00:00`);
@@ -358,16 +154,6 @@ function getPreviousPeriodKey(key2, period) {
     }
   }
 }
-function isoWeekToDate(weekKey) {
-  const [yearStr, weekStr] = weekKey.split("-W");
-  const year = parseInt(yearStr, 10);
-  const week = parseInt(weekStr, 10);
-  const jan4 = new Date(year, 0, 4);
-  const dayOfWeek = jan4.getDay() || 7;
-  const monday = new Date(jan4);
-  monday.setDate(jan4.getDate() - dayOfWeek + 1 + (week - 1) * 7);
-  return monday;
-}
 function localDateStr(d) {
   const y = d.getFullYear();
   const m = String(d.getMonth() + 1).padStart(2, "0");
@@ -377,6 +163,9 @@ function localDateStr(d) {
 function utcDateTimeStr(d) {
   return d.toISOString().replace("T", " ").slice(0, 19);
 }
+function parseUtcDateTime(s) {
+  return /* @__PURE__ */ new Date(`${s.replace(" ", "T")}Z`);
+}
 function getTimeRange(periodKey, period) {
   switch (period) {
     case "hour": {
@@ -405,21 +194,26 @@ function getTimeRange(periodKey, period) {
     }
   }
 }
+
+// packages/daemon/src/lib/daemon/summarizer.ts
+var sLog = logger_default.child("summarizer");
+var SYSTEM_MIND = "_system";
+var WEDGED_TURN_IDLE_MS = 15 * 6e4;
 async function gatherTurnEvents(mind, session, doneId) {
   const db = await getDb();
   const subConditions = [
-    eq2(mindHistory.mind, mind),
-    eq2(mindHistory.type, "done"),
+    eq(mindHistory.mind, mind),
+    eq(mindHistory.type, "done"),
     lt(mindHistory.id, doneId)
   ];
-  if (session) subConditions.push(eq2(mindHistory.session, session));
+  if (session) subConditions.push(eq(mindHistory.session, session));
   const prevDoneSubquery = db.select({ id: mindHistory.id }).from(mindHistory).where(and(...subConditions)).orderBy(desc(mindHistory.id)).limit(1);
   const turnConditions = [
-    eq2(mindHistory.mind, mind),
+    eq(mindHistory.mind, mind),
     sql`${mindHistory.id} > COALESCE((${prevDoneSubquery}), 0)`,
     sql`${mindHistory.id} <= ${doneId}`
   ];
-  if (session) turnConditions.push(eq2(mindHistory.session, session));
+  if (session) turnConditions.push(eq(mindHistory.session, session));
   const events = await db.select({
     id: mindHistory.id,
     type: mindHistory.type,
@@ -427,6 +221,7 @@ async function gatherTurnEvents(mind, session, doneId) {
     session: mindHistory.session,
     content: mindHistory.content,
     metadata: mindHistory.metadata,
+    turn_id: mindHistory.turn_id,
     created_at: mindHistory.created_at
   }).from(mindHistory).where(and(...turnConditions)).orderBy(mindHistory.id);
   return {
@@ -444,8 +239,9 @@ async function gatherTurnEventsByTurnId(turnId) {
     session: mindHistory.session,
     content: mindHistory.content,
     metadata: mindHistory.metadata,
+    turn_id: mindHistory.turn_id,
     created_at: mindHistory.created_at
-  }).from(mindHistory).where(eq2(mindHistory.turn_id, turnId)).orderBy(mindHistory.id);
+  }).from(mindHistory).where(eq(mindHistory.turn_id, turnId)).orderBy(mindHistory.id);
   return {
     events,
     fromId: events.length > 0 ? events[0].id : 0,
@@ -538,19 +334,22 @@ function buildTranscript(events, parsedMeta) {
 async function summarizeTurn(mind, session, channel, doneId, turnId) {
   const { events, fromId, toId } = turnId ? await gatherTurnEventsByTurnId(turnId) : await gatherTurnEvents(mind, session, doneId);
   if (events.length === 0) return;
+  const effectiveTurnId = turnId ?? events.find((ev) => ev.turn_id)?.turn_id ?? void 0;
+  if (effectiveTurnId && await summaryExists(mind, "turn", effectiveTurnId)) return;
   const substantiveTypes = /* @__PURE__ */ new Set(["text", "outbound", "tool_use", "tool_result", "thinking"]);
   const hasSubstantiveOutput = events.some((ev) => substantiveTypes.has(ev.type));
   if (!hasSubstantiveOutput) {
     sLog.info(
-      `skipping summary for interrupted turn ${turnId ?? "(no turn)"} (no substantive output)`
+      `skipping summary for interrupted turn ${effectiveTurnId ?? "(no turn)"} (no substantive output)`
     );
-    if (turnId) {
+    if (effectiveTurnId) {
       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(and(eq(mindHistory.turn_id, effectiveTurnId), eq(mindHistory.type, "inbound")));
+        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) {
-        sLog.error(`failed to un-tag events for interrupted turn ${turnId}`, logger_default.errorData(err));
+        sLog.error(`failed to clean up interrupted turn ${effectiveTurnId}`, logger_default.errorData(err));
       }
     }
     return;
@@ -591,7 +390,7 @@ async function summarizeTurn(mind, session, channel, doneId, turnId) {
     from_time: fromTime,
     to_time: toTime
   };
-  const periodKey = turnId ?? `${mind}-${doneId}`;
+  const periodKey = effectiveTurnId ?? `${mind}-${doneId}`;
   const db = await getDb();
   let summaryId;
   try {
@@ -606,9 +405,9 @@ async function summarizeTurn(mind, session, channel, doneId, turnId) {
     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)
+          eq(summaries.mind, mind),
+          eq(summaries.period, "turn"),
+          eq(summaries.period_key, periodKey)
         )
       ).get();
       summaryId = existing?.id;
@@ -620,9 +419,9 @@ async function summarizeTurn(mind, session, channel, doneId, turnId) {
     );
     return;
   }
-  if (turnId && summaryId != null) {
-    setSummaryId(turnId, summaryId).catch((err) => {
-      sLog.error(`failed to link summary to turn ${turnId}`, logger_default.errorData(err));
+  if (effectiveTurnId && summaryId != null) {
+    setSummaryId(effectiveTurnId, summaryId).catch((err) => {
+      sLog.error(`failed to link summary to turn ${effectiveTurnId}`, logger_default.errorData(err));
     });
   }
   publish(mind, {
@@ -632,12 +431,12 @@ async function summarizeTurn(mind, session, channel, doneId, turnId) {
     channel,
     content: summaryText,
     metadata,
-    turnId
+    turnId: effectiveTurnId
   });
 }
 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(eq(turns.id, turnId));
 }
 function getChildPeriod(period) {
   switch (period) {
@@ -656,78 +455,144 @@ function getScopeInstruction(mind) {
   }
   return 'Write in first person as the mind who performed the actions (e.g. "I explored...", "I worked on...").';
 }
-function buildPeriodicDeterministicSummary(sources, period, periodKey) {
-  if (sources.length === 0) return "";
+var DIGEST_CHILD_CHARS = 200;
+var DIGEST_MAX_CHARS = 4e3;
+var DIGEST_NOTICE = "(auto-generated digest \u2014 AI summary pending)";
+var ROLLUP_CHILD_CHARS = 2e3;
+var PROVISIONAL_MAX_ATTEMPTS = 5;
+var PROVISIONAL_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
+var PROVISIONAL_RETRY_BACKOFF_MS = PROVISIONAL_WINDOW_MS / PROVISIONAL_MAX_ATTEMPTS;
+function truncateChars(text, max) {
+  const t = text.trim();
+  return t.length > max ? `${t.slice(0, max).trimEnd()}\u2026` : t;
+}
+function digestLine(text) {
+  const flat = text.trim().replace(/\s+/g, " ");
+  const match = flat.match(/^.*?[.!?](?=\s|$)/);
+  const line = match ? match[0] : flat;
+  return line.length > DIGEST_CHILD_CHARS ? `${line.slice(0, DIGEST_CHILD_CHARS).trimEnd()}\u2026` : line;
+}
+function buildBoundedDigest(entries, period, periodKey) {
+  const label = period === "week" ? `Week ${periodKey}` : periodKey;
+  const header = `${label} ${DIGEST_NOTICE}`;
+  const lines = [];
+  let total = header.length + 2;
+  for (let i = 0; i < entries.length; i++) {
+    const line = `${entries[i].key}: ${digestLine(entries[i].text)}`;
+    if (lines.length > 0 && total + line.length + 1 > DIGEST_MAX_CHARS) {
+      lines.push(`\u2026and ${entries.length - i} more`);
+      break;
+    }
+    lines.push(line);
+    total += line.length + 1;
+  }
+  return `${header}
+
+${lines.join("\n")}`;
+}
+function buildPeriodicDeterministicSummary(entries, period, periodKey) {
+  if (entries.length === 0) return "";
   switch (period) {
     case "hour":
-      return `Activity during ${periodKey.slice(11)}:00: ${sources.join(" ")}`;
+      return `Activity during ${periodKey.slice(11)}:00: ${entries.map((e) => e.text).join(" ")}`;
     case "day":
       return `Activity on ${periodKey}:
 
-${sources.join("\n\n")}`;
+${entries.map((e) => e.text).join("\n\n")}`;
     case "week":
-      return `Week ${periodKey} summary:
-
-${sources.join("\n\n")}`;
     case "month":
-      return `${periodKey} summary:
-
-${sources.join("\n\n")}`;
+      return buildBoundedDigest(entries, period, periodKey);
   }
 }
+function parseMeta(raw) {
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function shouldRetry(period, meta) {
+  if (period !== "week" && period !== "month") return false;
+  if (meta.deterministic !== true) return false;
+  const attempts = typeof meta.attempts === "number" ? meta.attempts : 0;
+  if (attempts >= PROVISIONAL_MAX_ATTEMPTS) return false;
+  const first = typeof meta.first_attempt_at === "string" ? Date.parse(meta.first_attempt_at) : NaN;
+  if (!Number.isNaN(first) && Date.now() - first > PROVISIONAL_WINDOW_MS) return false;
+  const last = typeof meta.last_attempt_at === "string" ? Date.parse(meta.last_attempt_at) : NaN;
+  if (!Number.isNaN(last) && Date.now() - last < PROVISIONAL_RETRY_BACKOFF_MS) return false;
+  return true;
+}
+function trackProvisionalAttempt(metadata, prev) {
+  const prevAttempts = prev && typeof prev.attempts === "number" ? prev.attempts : 0;
+  metadata.attempts = prevAttempts + 1;
+  metadata.first_attempt_at = prev && typeof prev.first_attempt_at === "string" ? prev.first_attempt_at : (/* @__PURE__ */ new Date()).toISOString();
+  metadata.last_attempt_at = (/* @__PURE__ */ new Date()).toISOString();
+}
 async function gatherChildSummaries(mind, period, periodKey) {
   const db = await getDb();
   const childPeriod = getChildPeriod(period);
   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(
+    const rows2 = await db.select({ id: summaries.id, content: summaries.content, key: summaries.period_key }).from(summaries).where(
       and(
-        eq2(summaries.mind, mind),
-        eq2(summaries.period, childPeriod),
+        eq(summaries.mind, mind),
+        eq(summaries.period, childPeriod),
         gte(summaries.created_at, start2),
         lt(summaries.created_at, end2)
       )
     ).orderBy(summaries.created_at);
     return {
       texts: rows2.map((r) => r.content),
-      sourceIds: rows2.map((r) => r.id)
+      sourceIds: rows2.map((r) => r.id),
+      keys: rows2.map((r) => r.key)
     };
   }
   if (period === "day") {
-    const rows2 = await db.select({ id: summaries.id, content: summaries.content }).from(summaries).where(
+    const rows2 = await db.select({ id: summaries.id, content: summaries.content, key: summaries.period_key }).from(summaries).where(
       and(
-        eq2(summaries.mind, mind),
-        eq2(summaries.period, childPeriod),
+        eq(summaries.mind, mind),
+        eq(summaries.period, childPeriod),
         like(summaries.period_key, `${periodKey}%`)
       )
     ).orderBy(summaries.period_key);
     return {
       texts: rows2.map((r) => r.content),
-      sourceIds: rows2.map((r) => r.id)
+      sourceIds: rows2.map((r) => r.id),
+      keys: rows2.map((r) => r.key)
     };
   }
   const { start, end } = getTimeRange(periodKey, period);
   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(
+  const rows = await db.select({ id: summaries.id, content: summaries.content, key: summaries.period_key }).from(summaries).where(
     and(
-      eq2(summaries.mind, mind),
-      eq2(summaries.period, childPeriod),
+      eq(summaries.mind, mind),
+      eq(summaries.period, childPeriod),
       gte(summaries.period_key, startKey),
       sql`${summaries.period_key} <= ${endKey}`
     )
   ).orderBy(summaries.period_key);
   return {
     texts: rows.map((r) => r.content),
-    sourceIds: rows.map((r) => r.id)
+    sourceIds: rows.map((r) => r.id),
+    keys: rows.map((r) => r.key)
   };
 }
-async function summarizePeriod(mind, period, periodKey) {
-  if (await summaryExists(mind, period, periodKey)) return false;
+async function summarizePeriod(mind, period, periodKey, complete = aiCompleteUtility) {
   const db = await getDb();
+  const existing = await db.select({ id: summaries.id, metadata: summaries.metadata }).from(summaries).where(
+    and(
+      eq(summaries.mind, mind),
+      eq(summaries.period, period),
+      eq(summaries.period_key, periodKey)
+    )
+  ).get();
+  const existingMeta = existing ? parseMeta(existing.metadata) : null;
+  if (existing && !shouldRetry(period, existingMeta)) return false;
   const sources = await gatherChildSummaries(mind, period, periodKey);
   if (sources.texts.length === 0) return false;
-  if (sources.texts.length === 1) {
+  if (!existing && sources.texts.length === 1) {
     try {
       await db.insert(summaries).values({
         mind,
@@ -751,33 +616,39 @@ async function summarizePeriod(mind, period, periodKey) {
     sLog.info(`promoted single-child ${period} summary for ${mind} (${periodKey})`);
     return true;
   }
+  const entries = sources.texts.map((text, i) => ({ key: sources.keys[i], text }));
   const promptKey = `meta_summary_${period}`;
   const scopeInstruction = getScopeInstruction(mind);
   const systemPrompt = await getPrompt(promptKey, { scope_instruction: scopeInstruction });
   const userMessage = sources.texts.join("\n\n---\n\n");
   let content;
   let deterministic;
-  const aiResult = await aiCompleteUtility(systemPrompt, userMessage);
+  const metadata = {
+    source_count: sources.texts.length,
+    source_ids: sources.sourceIds
+  };
+  const aiResult = await complete(systemPrompt, userMessage);
   if (aiResult) {
     content = aiResult;
     deterministic = false;
   } else {
-    content = buildPeriodicDeterministicSummary(sources.texts, period, periodKey);
+    content = buildPeriodicDeterministicSummary(entries, period, periodKey);
     deterministic = true;
+    if (period === "week" || period === "month") trackProvisionalAttempt(metadata, existingMeta);
   }
-  const metadata = {
-    deterministic,
-    source_count: sources.texts.length,
-    source_ids: sources.sourceIds
-  };
+  metadata.deterministic = deterministic;
   try {
-    await db.insert(summaries).values({
-      mind,
-      period,
-      period_key: periodKey,
-      content,
-      metadata: JSON.stringify(metadata)
-    }).onConflictDoNothing();
+    if (existing) {
+      await db.update(summaries).set({ content, metadata: JSON.stringify(metadata) }).where(eq(summaries.id, existing.id));
+    } else {
+      await db.insert(summaries).values({
+        mind,
+        period,
+        period_key: periodKey,
+        content,
+        metadata: JSON.stringify(metadata)
+      }).onConflictDoNothing();
+    }
   } catch (err) {
     sLog.error(
       `failed to persist ${period} summary for ${mind} (${periodKey})`,
@@ -790,50 +661,94 @@ async function summarizePeriod(mind, period, periodKey) {
   );
   return true;
 }
-async function summarizeSystem(period, periodKey) {
-  if (await summaryExists(SYSTEM_MIND, period, periodKey)) return;
+async function summarizeSystem(period, periodKey, complete = aiCompleteUtility) {
   const db = await getDb();
+  const existing = await db.select({ id: summaries.id, metadata: summaries.metadata }).from(summaries).where(
+    and(
+      eq(summaries.mind, SYSTEM_MIND),
+      eq(summaries.period, period),
+      eq(summaries.period_key, periodKey)
+    )
+  ).get();
+  const existingMeta = existing ? parseMeta(existing.metadata) : null;
+  if (existing && !shouldRetry(period, existingMeta)) return;
   const rows = await db.select({ mind: summaries.mind, content: summaries.content }).from(summaries).where(
     and(
-      eq2(summaries.period, period),
-      eq2(summaries.period_key, periodKey),
+      eq(summaries.period, period),
+      eq(summaries.period_key, periodKey),
       sql`${summaries.mind} != ${SYSTEM_MIND}`
     )
   ).orderBy(summaries.mind);
   if (rows.length === 0) return;
   const minds = [...new Set(rows.map((r) => r.mind))];
-  const texts = rows.map((r) => `[${r.mind}] ${r.content}`);
+  const entries = rows.map((r) => ({
+    key: r.mind,
+    text: truncateChars(r.content, ROLLUP_CHILD_CHARS)
+  }));
+  const texts = entries.map((e) => `[${e.key}] ${e.text}`);
   const promptKey = `meta_summary_${period}`;
   const scopeInstruction = getScopeInstruction(SYSTEM_MIND);
   const systemPrompt = await getPrompt(promptKey, { scope_instruction: scopeInstruction });
   const userMessage = texts.join("\n\n---\n\n");
   let content;
   let deterministic;
-  const aiResult = await aiCompleteUtility(systemPrompt, userMessage);
+  const metadata = { minds, source_count: rows.length };
+  const aiResult = await complete(systemPrompt, userMessage);
   if (aiResult) {
     content = aiResult;
     deterministic = false;
   } else {
-    content = buildPeriodicDeterministicSummary(texts, period, periodKey);
+    content = buildPeriodicDeterministicSummary(entries, period, periodKey);
     deterministic = true;
+    if (period === "week" || period === "month") trackProvisionalAttempt(metadata, existingMeta);
   }
+  metadata.deterministic = deterministic;
   try {
-    await db.insert(summaries).values({
-      mind: SYSTEM_MIND,
-      period,
-      period_key: periodKey,
-      content,
-      metadata: JSON.stringify({ deterministic, minds, source_count: rows.length })
-    }).onConflictDoNothing();
+    if (existing) {
+      await db.update(summaries).set({ content, metadata: JSON.stringify(metadata) }).where(eq(summaries.id, existing.id));
+    } else {
+      await db.insert(summaries).values({
+        mind: SYSTEM_MIND,
+        period,
+        period_key: periodKey,
+        content,
+        metadata: JSON.stringify(metadata)
+      }).onConflictDoNothing();
+    }
   } catch (err) {
     sLog.error(`failed to persist system ${period} summary (${periodKey})`, logger_default.errorData(err));
   }
 }
+async function repairProvisionalSummaries(complete = aiCompleteUtility) {
+  const db = await getDb();
+  const rows = await db.select({
+    mind: summaries.mind,
+    period: summaries.period,
+    period_key: summaries.period_key,
+    metadata: summaries.metadata
+  }).from(summaries).where(inArray(summaries.period, ["week", "month"]));
+  const due = rows.filter((r) => shouldRetry(r.period, parseMeta(r.metadata)));
+  due.sort((a, b) => (a.mind === SYSTEM_MIND ? 1 : 0) - (b.mind === SYSTEM_MIND ? 1 : 0));
+  for (const r of due) {
+    try {
+      if (r.mind === SYSTEM_MIND) {
+        await summarizeSystem(r.period, r.period_key, complete);
+      } else {
+        await summarizePeriod(r.mind, r.period, r.period_key, complete);
+      }
+    } catch (err) {
+      sLog.error(
+        `failed to repair provisional ${r.period} summary for ${r.mind} (${r.period_key})`,
+        logger_default.errorData(err)
+      );
+    }
+  }
+}
 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"),
+      eq(summaries.period, "turn"),
       gte(summaries.created_at, start),
       lt(summaries.created_at, end),
       sql`${summaries.mind} != ${SYSTEM_MIND}`
@@ -845,7 +760,7 @@ 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),
+      eq(summaries.period, period),
       like(summaries.period_key, keyPattern),
       sql`${summaries.mind} != ${SYSTEM_MIND}`
     )
@@ -856,7 +771,7 @@ 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"),
+      eq(summaries.period, "day"),
       gte(summaries.period_key, startKey),
       sql`${summaries.period_key} <= ${endKey}`,
       sql`${summaries.mind} != ${SYSTEM_MIND}`
@@ -924,9 +839,9 @@ 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)
+      eq(summaries.mind, mind),
+      eq(summaries.period, period),
+      eq(summaries.period_key, periodKey)
     )
   ).get();
   return !!row;
@@ -956,7 +871,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(and(eq(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,
@@ -973,6 +888,95 @@ async function backfill() {
     }
   }
 }
+async function healMissing(period, needed, process) {
+  if (needed.size === 0) return;
+  const db = await getDb();
+  const keys = [...needed.keys()];
+  const existing = await db.select({ mind: summaries.mind, period_key: summaries.period_key }).from(summaries).where(and(eq(summaries.period, period), inArray(summaries.period_key, keys)));
+  const have = new Set(existing.map((r) => `${r.mind}|${r.period_key}`));
+  for (const [key2, minds] of needed) {
+    let gap = !have.has(`${SYSTEM_MIND}|${key2}`);
+    if (!gap) {
+      for (const mind of minds) {
+        if (!have.has(`${mind}|${key2}`)) {
+          gap = true;
+          break;
+        }
+      }
+    }
+    if (!gap) continue;
+    try {
+      await process(key2);
+    } catch (err) {
+      sLog.error(`reconcile ${period} ${key2} failed`, logger_default.errorData(err));
+    }
+  }
+}
+function addNeeded(map, key2, mind) {
+  let set = map.get(key2);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    map.set(key2, set);
+  }
+  set.add(mind);
+}
+async function reconcileMissingSummaries(lookbackDays = 7) {
+  const db = await getDb();
+  const now = /* @__PURE__ */ new Date();
+  const windowStart = new Date(now);
+  windowStart.setDate(windowStart.getDate() - lookbackDays);
+  const currentHourKey = getPeriodKey(now, "hour");
+  const currentDayKey = getPeriodKey(now, "day");
+  const currentWeekKey = getPeriodKey(now, "week");
+  const currentMonthKey = getPeriodKey(now, "month");
+  const cutoffDayKey = getPeriodKey(windowStart, "day");
+  const turnRows = await db.select({ mind: summaries.mind, created_at: summaries.created_at }).from(summaries).where(
+    and(
+      eq(summaries.period, "turn"),
+      gte(summaries.created_at, utcDateTimeStr(windowStart)),
+      sql`${summaries.mind} != ${SYSTEM_MIND}`
+    )
+  );
+  const neededHours = /* @__PURE__ */ new Map();
+  for (const r of turnRows) {
+    const key2 = getPeriodKey(parseUtcDateTime(r.created_at), "hour");
+    if (key2 === currentHourKey) continue;
+    addNeeded(neededHours, key2, r.mind);
+  }
+  await healMissing("hour", neededHours, processHour);
+  const hourRows = await db.select({ mind: summaries.mind, period_key: summaries.period_key }).from(summaries).where(
+    and(
+      eq(summaries.period, "hour"),
+      gte(summaries.period_key, cutoffDayKey),
+      sql`${summaries.mind} != ${SYSTEM_MIND}`
+    )
+  );
+  const neededDays = /* @__PURE__ */ new Map();
+  for (const r of hourRows) {
+    const key2 = r.period_key.slice(0, 10);
+    if (key2 === currentDayKey) continue;
+    addNeeded(neededDays, key2, r.mind);
+  }
+  await healMissing("day", neededDays, processDay);
+  const dayRows = await db.select({ mind: summaries.mind, period_key: summaries.period_key }).from(summaries).where(
+    and(
+      eq(summaries.period, "day"),
+      gte(summaries.period_key, cutoffDayKey),
+      sql`${summaries.mind} != ${SYSTEM_MIND}`
+    )
+  );
+  const neededWeeks = /* @__PURE__ */ new Map();
+  const neededMonths = /* @__PURE__ */ new Map();
+  for (const r of dayRows) {
+    const d = /* @__PURE__ */ new Date(`${r.period_key}T00:00:00`);
+    const weekKey = getPeriodKey(d, "week");
+    if (weekKey !== currentWeekKey) addNeeded(neededWeeks, weekKey, r.mind);
+    const monthKey = r.period_key.slice(0, 7);
+    if (monthKey !== currentMonthKey) addNeeded(neededMonths, monthKey, r.mind);
+  }
+  await healMissing("week", neededWeeks, processWeek);
+  await healMissing("month", neededMonths, processMonth);
+}
 var Summarizer = class {
   interval = null;
   lastHourKey = null;
@@ -994,6 +998,7 @@ var Summarizer = class {
         this.hasBackfilled = true;
       }
       await reconcileWedgedTurns(WEDGED_TURN_IDLE_MS);
+      await reconcileMissingSummaries();
       const now = /* @__PURE__ */ new Date();
       const currentHourKey = getPeriodKey(now, "hour");
       if (this.lastHourKey && this.lastHourKey !== currentHourKey) {
@@ -1016,17 +1021,18 @@ var Summarizer = class {
       if (!await summaryExists(SYSTEM_MIND, "month", prevMonthKey)) {
         await processMonth(prevMonthKey);
       }
+      await repairProvisionalSummaries();
     } catch (err) {
       sLog.error("tick failed", logger_default.errorData(err));
     }
   }
 };
 async function reconcileWedgedTurns(idleMs) {
-  const { sweepWedgedTurns: sweepWedgedTurns2, summarizeOrphanedTurns: summarizeOrphanedTurns2 } = await import("./turn-tracker-2W6Q2NSR.js");
+  const { sweepWedgedTurns: sweepWedgedTurns2, summarizeOrphanedTurns: summarizeOrphanedTurns2 } = await import("./turn-tracker-JZRZDFWV.js");
   const wedged = await sweepWedgedTurns2(idleMs);
   if (wedged.length === 0) return;
   summarizeOrphanedTurns2(wedged);
-  const { tryGetDeliveryManager } = await import("./delivery-manager-VDVKVA46.js");
+  const { tryGetDeliveryManager } = await import("./delivery-manager-TN5KK2AP.js");
   const dm = tryGetDeliveryManager();
   if (!dm) return;
   for (const t of wedged) {
@@ -1084,10 +1090,10 @@ async function linkInboundToActiveTurn(mind, session, channel) {
   const db = await getDb();
   await db.update(mindHistory).set({ turn_id: turnId }).where(
     and2(
-      eq3(mindHistory.mind, mind),
-      eq3(mindHistory.type, "inbound"),
+      eq2(mindHistory.mind, mind),
+      eq2(mindHistory.type, "inbound"),
       sql2`${mindHistory.turn_id} IS NULL`,
-      eq3(mindHistory.channel, channel)
+      eq2(mindHistory.channel, channel)
     )
   );
 }
@@ -1118,7 +1124,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(eq2(turns.id, turnId));
   } catch (err) {
     tlog.error(`failed to assign session to turn ${turnId}`, logger_default.errorData(err));
     return;
@@ -1133,7 +1139,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(eq2(turns.id, entry.turnId));
   } catch (err) {
     tlog.error(`failed to complete turn ${entry.turnId}`, logger_default.errorData(err));
     return void 0;
@@ -1144,10 +1150,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(eq2(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(eq2(turns.status, "active"));
   } catch (err) {
     tlog.error("failed to complete orphaned turns on startup", logger_default.errorData(err));
   }
@@ -1180,7 +1186,7 @@ async function clearMind(mind) {
     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(eq2(turns.id, turnId));
       }
     } catch (err) {
       tlog.error(`failed to complete orphaned turns for ${mind}`, logger_default.errorData(err));
@@ -1193,7 +1199,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, eq3(mindHistory.turn_id, turns.id)).where(eq3(turns.status, "active")).groupBy(turns.id).having(
+    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(
       sql2`max(${mindHistory.created_at}) < ${cutoff} and sum(case when ${mindHistory.type} = 'done' then 1 else 0 end) > 0`
     );
   } catch (err) {
@@ -1203,7 +1209,7 @@ async function sweepWedgedTurns(idleMs) {
   const swept = [];
   for (const r of rows) {
     try {
-      await db.update(turns).set({ status: "complete" }).where(eq3(turns.id, r.id));
+      await db.update(turns).set({ status: "complete" }).where(eq2(turns.id, r.id));
     } catch (err) {
       tlog.error(`failed to complete wedged turn ${r.id}`, logger_default.errorData(err));
       continue;
@@ -1224,15 +1230,10 @@ function summarizeOrphanedTurns(orphanedTurns) {
 }
 
 export {
-  PROMPT_KEYS,
-  PROMPT_DEFAULTS,
-  substitute,
-  getPrompt,
-  getPromptIfCustom,
-  getMindPromptDefaults,
   subscribe,
   subscribeAll,
   publish,
+  isoWeekKeyForDateStr,
   summarizeTurn,
   initSummarizer,
   markErrored,