volute 0.46.0 → 0.47.0

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

@@ -1,22 +1,22 @@
 #!/usr/bin/env node
 import {
   getPrompt
-} from "./chunk-4YU7HF4L.js";
+} 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,
   turns
-} from "./chunk-ZV7MFISX.js";
+} from "./chunk-2MJ7EOMT.js";
 
 // packages/daemon/src/lib/daemon/turn-tracker.ts
 import { randomUUID } from "crypto";
@@ -82,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": {
@@ -117,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`);
@@ -141,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");
@@ -160,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": {
@@ -188,6 +194,11 @@ 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 = [
@@ -210,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 {
@@ -227,6 +239,7 @@ 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(eq(mindHistory.turn_id, turnId)).orderBy(mindHistory.id);
   return {
@@ -321,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(eq(mindHistory.turn_id, turnId), eq(mindHistory.type, "inbound")));
-        await db2.update(messages).set({ turn_id: null }).where(eq(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;
@@ -374,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 {
@@ -403,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, {
@@ -415,7 +431,7 @@ async function summarizeTurn(mind, session, channel, doneId, turnId) {
     channel,
     content: summaryText,
     metadata,
-    turnId
+    turnId: effectiveTurnId
   });
 }
 async function setSummaryId(turnId, summaryId) {
@@ -439,31 +455,86 @@ 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(
         eq(summaries.mind, mind),
         eq(summaries.period, childPeriod),
@@ -473,11 +544,12 @@ async function gatherChildSummaries(mind, period, periodKey) {
     ).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(
         eq(summaries.mind, mind),
         eq(summaries.period, childPeriod),
@@ -486,13 +558,14 @@ async function gatherChildSummaries(mind, period, 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(
       eq(summaries.mind, mind),
       eq(summaries.period, childPeriod),
@@ -502,15 +575,24 @@ async function gatherChildSummaries(mind, period, periodKey) {
   ).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,
@@ -534,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})`,
@@ -573,9 +661,17 @@ 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(
       eq(summaries.period, period),
@@ -585,33 +681,69 @@ async function summarizeSystem(period, periodKey) {
   ).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(
@@ -756,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;
@@ -777,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) {
@@ -799,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-FOIBNUUA.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-JINZRG2W.js");
+  const { tryGetDeliveryManager } = await import("./delivery-manager-TN5KK2AP.js");
   const dm = tryGetDeliveryManager();
   if (!dm) return;
   for (const t of wedged) {
@@ -1010,6 +1233,7 @@ export {
   subscribe,
   subscribeAll,
   publish,
+  isoWeekKeyForDateStr,
   summarizeTurn,
   initSummarizer,
   markErrored,

package/dist/{chunk-ZNMCCHCP.js → chunk-LTLFOSA4.js}

@@ -4,10 +4,10 @@ import {
 } from "./chunk-T2TP6ZC6.js";
 import {
   getDb
-} from "./chunk-ALKYQULU.js";
+} from "./chunk-WW6C3PLV.js";
 import {
   activity
-} from "./chunk-ZV7MFISX.js";
+} from "./chunk-2MJ7EOMT.js";
 
 // packages/daemon/src/lib/events/event-sequencer.ts
 var BUFFER_SIZE = 1e3;

package/dist/{chunk-IHKGWTGT.js → chunk-LWDTP6DH.js}

@@ -2,7 +2,7 @@
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-F7H6ATM4.js";
+} from "./chunk-SKNXMUIU.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";

package/dist/{chunk-JZ62SYWR.js → chunk-M3XDVS5Q.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   readGlobalConfig
-} from "./chunk-F7H6ATM4.js";
+} from "./chunk-SKNXMUIU.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";