volute 0.40.1 → 0.41.0

package/dist/chunk-YATR5BXD.js

@@ -0,0 +1,1212 @@
+#!/usr/bin/env node
+import {
+  aiCompleteUtility
+} from "./chunk-VK2YD7VJ.js";
+import {
+  logger_default
+} from "./chunk-T2TP6ZC6.js";
+import {
+  getDb
+} from "./chunk-VDODEQSJ.js";
+import {
+  messages,
+  mindHistory,
+  summaries,
+  systemPrompts,
+  turns
+} from "./chunk-MHFAWJCC.js";
+
+// packages/daemon/src/lib/daemon/turn-tracker.ts
+import { randomUUID } from "crypto";
+import { eq as eq3, 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";
+
+// packages/daemon/src/lib/events/mind-events.ts
+var subscribers = /* @__PURE__ */ new Map();
+var globalSubscribers = /* @__PURE__ */ new Set();
+function subscribe(mind, callback) {
+  let set = subscribers.get(mind);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    subscribers.set(mind, set);
+  }
+  set.add(callback);
+  return () => {
+    set.delete(callback);
+    if (set.size === 0) subscribers.delete(mind);
+  };
+}
+function subscribeAll(callback) {
+  globalSubscribers.add(callback);
+  return () => {
+    globalSubscribers.delete(callback);
+  };
+}
+function publish(mind, event) {
+  const set = subscribers.get(mind);
+  if (set) {
+    for (const cb of set) {
+      try {
+        cb(event);
+      } catch (err) {
+        logger_default.error(`[mind-events] subscriber threw for ${mind}`, logger_default.errorData(err));
+        set.delete(cb);
+        if (set.size === 0) subscribers.delete(mind);
+      }
+    }
+  }
+  for (const cb of globalSubscribers) {
+    try {
+      cb(event);
+    } catch (err) {
+      logger_default.error("[mind-events] global subscriber threw", logger_default.errorData(err));
+      globalSubscribers.delete(cb);
+    }
+  }
+}
+
+// packages/daemon/src/lib/prompts.ts
+import { eq } from "drizzle-orm";
+var PROMPT_KEYS = [
+  "seed_soul",
+  "default_soul",
+  "default_memory",
+  "sprout_message",
+  "restart_message",
+  "merge_message",
+  "upgrade_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 in the process of discovering who you are.
+\${description}
+Have a conversation with the human. Explore what kind of mind you want to be. When you're ready, write your SOUL.md and MEMORY.md, then run \`volute mind 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. You now have full capabilities \u2014 connectors, schedules, variants, and the complete volute CLI. Check your new skills for details.",
+    description: "Sent when a seed mind sprouts",
+    variables: [],
+    category: "system"
+  },
+  restart_message: {
+    content: "[system] You have been restarted.",
+    description: "Generic restart notification",
+    variables: [],
+    category: "system"
+  },
+  merge_message: {
+    content: '[system] Variant "${name}" has been merged and you have been restarted.',
+    description: "Variant merge notification",
+    variables: ["name"],
+    category: "system"
+  },
+  upgrade_message: {
+    content: "[system] Your framework has been upgraded to the latest version. You have been restarted. Check your skills for any changes.",
+    description: "Sent after a template upgrade completes",
+    variables: [],
+    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 at ${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") {
+    const args = input;
+    const val = args.path ?? args.command ?? args.query ?? args.url;
+    if (typeof val === "string") {
+      const brief = val.length > 60 ? `${val.slice(0, 57)}...` : val;
+      return `[${name} ${brief}]`;
+    }
+  }
+  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;
+function getPeriodKey(date, period) {
+  switch (period) {
+    case "hour": {
+      const y = date.getFullYear();
+      const m = String(date.getMonth() + 1).padStart(2, "0");
+      const d = String(date.getDate()).padStart(2, "0");
+      const h = String(date.getHours()).padStart(2, "0");
+      return `${y}-${m}-${d}T${h}`;
+    }
+    case "day": {
+      const y = date.getFullYear();
+      const m = String(date.getMonth() + 1).padStart(2, "0");
+      const d = String(date.getDate()).padStart(2, "0");
+      return `${y}-${m}-${d}`;
+    }
+    case "week":
+      return getISOWeekKey(date);
+    case "month": {
+      const y = date.getFullYear();
+      const m = String(date.getMonth() + 1).padStart(2, "0");
+      return `${y}-${m}`;
+    }
+  }
+}
+function getISOWeekKey(date) {
+  const d = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  d.setDate(d.getDate() + 4 - (d.getDay() || 7));
+  const yearStart = new Date(d.getFullYear(), 0, 1);
+  const weekNum = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return `${d.getFullYear()}-W${String(weekNum).padStart(2, "0")}`;
+}
+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");
+    }
+    case "day": {
+      const d = /* @__PURE__ */ new Date(`${key2}T00:00:00`);
+      d.setDate(d.getDate() - 1);
+      return getPeriodKey(d, "day");
+    }
+    case "week": {
+      const d = isoWeekToDate(key2);
+      d.setDate(d.getDate() - 7);
+      return getPeriodKey(d, "week");
+    }
+    case "month": {
+      const [y, m] = key2.split("-").map(Number);
+      const d = new Date(y, m - 2, 1);
+      return getPeriodKey(d, "month");
+    }
+  }
+}
+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");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function utcDateTimeStr(d) {
+  return d.toISOString().replace("T", " ").slice(0, 19);
+}
+function getTimeRange(periodKey, period) {
+  switch (period) {
+    case "hour": {
+      const d = /* @__PURE__ */ new Date(`${periodKey.slice(0, 10)}T${periodKey.slice(11)}:00:00`);
+      const dEnd = new Date(d.getTime() + 36e5);
+      return { start: utcDateTimeStr(d), end: utcDateTimeStr(dEnd) };
+    }
+    case "day":
+      return { start: `${periodKey} 00:00:00`, end: `${periodKey} 23:59:59` };
+    case "week": {
+      const monday = isoWeekToDate(periodKey);
+      const sunday = new Date(monday);
+      sunday.setDate(monday.getDate() + 6);
+      return {
+        start: `${localDateStr(monday)} 00:00:00`,
+        end: `${localDateStr(sunday)} 23:59:59`
+      };
+    }
+    case "month": {
+      const [y, m] = periodKey.split("-").map(Number);
+      const lastDay = new Date(y, m, 0).getDate();
+      return {
+        start: `${periodKey}-01 00:00:00`,
+        end: `${periodKey}-${String(lastDay).padStart(2, "0")} 23:59:59`
+      };
+    }
+  }
+}
+async function gatherTurnEvents(mind, session, doneId) {
+  const db = await getDb();
+  const subConditions = [
+    eq2(mindHistory.mind, mind),
+    eq2(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);
+  const turnConditions = [
+    eq2(mindHistory.mind, mind),
+    sql`${mindHistory.id} > COALESCE((${prevDoneSubquery}), 0)`,
+    sql`${mindHistory.id} <= ${doneId}`
+  ];
+  if (session) turnConditions.push(eq2(mindHistory.session, session));
+  const events = await db.select({
+    id: mindHistory.id,
+    type: mindHistory.type,
+    channel: mindHistory.channel,
+    session: mindHistory.session,
+    content: mindHistory.content,
+    metadata: mindHistory.metadata,
+    created_at: mindHistory.created_at
+  }).from(mindHistory).where(and(...turnConditions)).orderBy(mindHistory.id);
+  return {
+    events,
+    fromId: events.length > 0 ? events[0].id : doneId,
+    toId: doneId
+  };
+}
+async function gatherTurnEventsByTurnId(turnId) {
+  const db = await getDb();
+  const events = await db.select({
+    id: mindHistory.id,
+    type: mindHistory.type,
+    channel: mindHistory.channel,
+    session: mindHistory.session,
+    content: mindHistory.content,
+    metadata: mindHistory.metadata,
+    created_at: mindHistory.created_at
+  }).from(mindHistory).where(eq2(mindHistory.turn_id, turnId)).orderBy(mindHistory.id);
+  return {
+    events,
+    fromId: events.length > 0 ? events[0].id : 0,
+    toId: events.length > 0 ? events[events.length - 1].id : 0
+  };
+}
+function parseEventMetadata(events) {
+  const parsed = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    if (ev.metadata) {
+      try {
+        parsed.set(ev.id, JSON.parse(ev.metadata));
+      } catch (err) {
+        sLog.debug(`failed to parse metadata for event ${ev.id}`, logger_default.errorData(err));
+      }
+    }
+  }
+  return parsed;
+}
+function buildTurnDeterministicSummary(events, parsedMeta) {
+  const channels = /* @__PURE__ */ new Set();
+  const tools = [];
+  let hasInbound = false;
+  let hasOutbound = false;
+  for (const ev of events) {
+    if (ev.type === "inbound") {
+      hasInbound = true;
+      if (ev.channel) channels.add(ev.channel);
+    }
+    if (ev.type === "outbound" || ev.type === "text") {
+      hasOutbound = true;
+    }
+    if (ev.type === "tool_use") {
+      const meta = parsedMeta.get(ev.id);
+      if (meta?.name) tools.push(meta.name);
+    }
+  }
+  const parts = [];
+  if (hasInbound) {
+    const channelList = [...channels];
+    parts.push(
+      channelList.length > 0 ? `Received message on ${channelList.join(", ")}` : "Received message"
+    );
+  }
+  if (tools.length > 0) {
+    const unique = [...new Set(tools)];
+    parts.push(`Used ${unique.join(", ")}`);
+  }
+  if (hasOutbound) {
+    parts.push("Sent response");
+  }
+  return parts.length > 0 ? `${parts.join(". ")}.` : "Turn completed.";
+}
+function buildTranscript(events, parsedMeta) {
+  const lines = [];
+  for (const ev of events) {
+    switch (ev.type) {
+      case "inbound":
+        lines.push(`[inbound${ev.channel ? ` ${ev.channel}` : ""}] ${ev.content ?? ""}`);
+        break;
+      case "outbound":
+      case "text":
+        lines.push(`[response] ${(ev.content ?? "").slice(0, 500)}`);
+        break;
+      case "tool_use": {
+        const meta = parsedMeta.get(ev.id);
+        const toolInfo = meta ? summarizeTool(
+          meta.name ?? "tool",
+          meta.input ?? {}
+        ) : "tool";
+        lines.push(toolInfo);
+        break;
+      }
+      case "tool_result": {
+        const content = ev.content ?? "";
+        const meta = parsedMeta.get(ev.id);
+        const isError = !!meta?.is_error;
+        lines.push(isError ? "[result error]" : `[result] ${content.slice(0, 200)}`);
+        break;
+      }
+      case "thinking":
+        lines.push(`[thinking] ${(ev.content ?? "").slice(0, 300)}`);
+        break;
+    }
+  }
+  return lines.join("\n");
+}
+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 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)`
+    );
+    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));
+      } catch (err) {
+        sLog.error(`failed to un-tag events for interrupted turn ${turnId}`, logger_default.errorData(err));
+      }
+    }
+    return;
+  }
+  const parsedMeta = parseEventMetadata(events);
+  const tools = [];
+  for (const ev of events) {
+    if (ev.type === "tool_use") {
+      const meta = parsedMeta.get(ev.id);
+      if (meta?.name) tools.push(meta.name);
+    }
+  }
+  const fromTime = events[0].created_at;
+  const toTime = events[events.length - 1].created_at;
+  let summaryText;
+  let deterministic;
+  const transcript = buildTranscript(events, parsedMeta);
+  if (transcript.trim()) {
+    const summaryPrompt = await getPrompt("turn_summary");
+    const aiResult = await aiCompleteUtility(summaryPrompt, transcript);
+    if (aiResult) {
+      summaryText = aiResult;
+      deterministic = false;
+    } else {
+      summaryText = buildTurnDeterministicSummary(events, parsedMeta);
+      deterministic = true;
+    }
+  } else {
+    summaryText = buildTurnDeterministicSummary(events, parsedMeta);
+    deterministic = true;
+  }
+  const metadata = {
+    deterministic,
+    tool_count: tools.length,
+    tools: [...new Set(tools)],
+    from_id: fromId,
+    to_id: toId,
+    from_time: fromTime,
+    to_time: toTime
+  };
+  const periodKey = turnId ?? `${mind}-${doneId}`;
+  const db = await getDb();
+  let summaryId;
+  try {
+    const result = await db.insert(summaries).values({
+      mind,
+      period: "turn",
+      period_key: periodKey,
+      content: summaryText,
+      metadata: JSON.stringify(metadata)
+    }).onConflictDoNothing().returning({ id: summaries.id });
+    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)
+        )
+      ).get();
+      summaryId = existing?.id;
+    }
+  } catch (err) {
+    sLog.error(
+      `failed to persist turn summary for ${mind} (events ${fromId}-${toId})`,
+      logger_default.errorData(err)
+    );
+    return;
+  }
+  if (turnId && summaryId != null) {
+    setSummaryId(turnId, summaryId).catch((err) => {
+      sLog.error(`failed to link summary to turn ${turnId}`, logger_default.errorData(err));
+    });
+  }
+  publish(mind, {
+    mind,
+    type: "summary",
+    session,
+    channel,
+    content: summaryText,
+    metadata,
+    turnId
+  });
+}
+async function setSummaryId(turnId, summaryId) {
+  const db = await getDb();
+  await db.update(turns).set({ summary_id: summaryId }).where(eq2(turns.id, turnId));
+}
+function getChildPeriod(period) {
+  switch (period) {
+    case "hour":
+      return "turn";
+    case "day":
+      return "hour";
+    case "week":
+    case "month":
+      return "day";
+  }
+}
+function getScopeInstruction(mind) {
+  if (mind === SYSTEM_MIND) {
+    return 'Write in third person, describing what the minds in the system did (e.g. "Alice explored...", "The system saw activity in..."). Reference minds by name.';
+  }
+  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 "";
+  switch (period) {
+    case "hour":
+      return `Activity during ${periodKey.slice(11)}:00: ${sources.join(" ")}`;
+    case "day":
+      return `Activity on ${periodKey}:
+
+${sources.join("\n\n")}`;
+    case "week":
+      return `Week ${periodKey} summary:
+
+${sources.join("\n\n")}`;
+    case "month":
+      return `${periodKey} summary:
+
+${sources.join("\n\n")}`;
+  }
+}
+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(
+      and(
+        eq2(summaries.mind, mind),
+        eq2(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)
+    };
+  }
+  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),
+        like(summaries.period_key, `${periodKey}%`)
+      )
+    ).orderBy(summaries.period_key);
+    return {
+      texts: rows2.map((r) => r.content),
+      sourceIds: rows2.map((r) => r.id)
+    };
+  }
+  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(
+    and(
+      eq2(summaries.mind, mind),
+      eq2(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)
+  };
+}
+async function summarizePeriod(mind, period, periodKey) {
+  if (await summaryExists(mind, period, periodKey)) return false;
+  const db = await getDb();
+  const sources = await gatherChildSummaries(mind, period, periodKey);
+  if (sources.texts.length === 0) return false;
+  if (sources.texts.length === 1) {
+    try {
+      await db.insert(summaries).values({
+        mind,
+        period,
+        period_key: periodKey,
+        content: sources.texts[0],
+        metadata: JSON.stringify({
+          deterministic: false,
+          promoted: true,
+          source_count: 1,
+          source_ids: sources.sourceIds
+        })
+      }).onConflictDoNothing();
+    } catch (err) {
+      sLog.error(
+        `failed to persist promoted ${period} summary for ${mind} (${periodKey})`,
+        logger_default.errorData(err)
+      );
+      return false;
+    }
+    sLog.info(`promoted single-child ${period} summary for ${mind} (${periodKey})`);
+    return true;
+  }
+  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);
+  if (aiResult) {
+    content = aiResult;
+    deterministic = false;
+  } else {
+    content = buildPeriodicDeterministicSummary(sources.texts, period, periodKey);
+    deterministic = true;
+  }
+  const metadata = {
+    deterministic,
+    source_count: sources.texts.length,
+    source_ids: sources.sourceIds
+  };
+  try {
+    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})`,
+      logger_default.errorData(err)
+    );
+    return false;
+  }
+  sLog.info(
+    `generated ${period} summary for ${mind} (${periodKey})${deterministic ? " [deterministic]" : ""}`
+  );
+  return true;
+}
+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}`
+    )
+  ).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 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);
+  if (aiResult) {
+    content = aiResult;
+    deterministic = false;
+  } else {
+    content = buildPeriodicDeterministicSummary(texts, period, periodKey);
+    deterministic = true;
+  }
+  try {
+    await db.insert(summaries).values({
+      mind: SYSTEM_MIND,
+      period,
+      period_key: periodKey,
+      content,
+      metadata: JSON.stringify({ deterministic, minds, source_count: rows.length })
+    }).onConflictDoNothing();
+  } catch (err) {
+    sLog.error(`failed to persist system ${period} summary (${periodKey})`, 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"),
+      gte(summaries.created_at, start),
+      lt(summaries.created_at, end),
+      sql`${summaries.mind} != ${SYSTEM_MIND}`
+    )
+  ).groupBy(summaries.mind);
+  return rows.map((r) => r.mind);
+}
+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),
+      like(summaries.period_key, keyPattern),
+      sql`${summaries.mind} != ${SYSTEM_MIND}`
+    )
+  ).groupBy(summaries.mind);
+  return rows.map((r) => r.mind);
+}
+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"),
+      gte(summaries.period_key, startKey),
+      sql`${summaries.period_key} <= ${endKey}`,
+      sql`${summaries.mind} != ${SYSTEM_MIND}`
+    )
+  ).groupBy(summaries.mind);
+  return rows.map((r) => r.mind);
+}
+async function processHour(periodKey) {
+  const { start, end } = getTimeRange(periodKey, "hour");
+  const minds = await mindsWithTurnSummaries(start, end);
+  for (const mind of minds) {
+    try {
+      await summarizePeriod(mind, "hour", periodKey);
+    } catch (err) {
+      sLog.error(`failed to summarize hour for ${mind} (${periodKey})`, logger_default.errorData(err));
+    }
+  }
+  if (minds.length > 0) {
+    await summarizeSystem("hour", periodKey);
+  }
+}
+async function processDay(periodKey) {
+  const minds = await mindsWithSummaries("hour", `${periodKey}%`);
+  for (const mind of minds) {
+    try {
+      await summarizePeriod(mind, "day", periodKey);
+    } catch (err) {
+      sLog.error(`failed to summarize day for ${mind} (${periodKey})`, logger_default.errorData(err));
+    }
+  }
+  if (minds.length > 0) {
+    await summarizeSystem("day", periodKey);
+  }
+}
+async function processWeek(periodKey) {
+  const { start, end } = getTimeRange(periodKey, "week");
+  const startKey = start.slice(0, 10);
+  const endKey = end.slice(0, 10);
+  const minds = await mindsWithDailySummariesInRange(startKey, endKey);
+  for (const mind of minds) {
+    try {
+      await summarizePeriod(mind, "week", periodKey);
+    } catch (err) {
+      sLog.error(`failed to summarize week for ${mind} (${periodKey})`, logger_default.errorData(err));
+    }
+  }
+  if (minds.length > 0) {
+    await summarizeSystem("week", periodKey);
+  }
+}
+async function processMonth(periodKey) {
+  const minds = await mindsWithSummaries("day", `${periodKey}%`);
+  for (const mind of minds) {
+    try {
+      await summarizePeriod(mind, "month", periodKey);
+    } catch (err) {
+      sLog.error(`failed to summarize month for ${mind} (${periodKey})`, logger_default.errorData(err));
+    }
+  }
+  if (minds.length > 0) {
+    await summarizeSystem("month", 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)
+    )
+  ).get();
+  return !!row;
+}
+async function backfill() {
+  const now = /* @__PURE__ */ new Date();
+  const candidates = [];
+  for (let i = 1; i <= 48; i++) {
+    const d = new Date(now);
+    d.setHours(d.getHours() - i);
+    candidates.push({ period: "hour", key: getPeriodKey(d, "hour") });
+  }
+  for (let i = 1; i <= 7; i++) {
+    const d = new Date(now);
+    d.setDate(d.getDate() - i);
+    candidates.push({ period: "day", key: getPeriodKey(d, "day") });
+  }
+  for (let i = 1; i <= 4; i++) {
+    const d = new Date(now);
+    d.setDate(d.getDate() - i * 7);
+    candidates.push({ period: "week", key: getPeriodKey(d, "week") });
+  }
+  for (let i = 1; i <= 3; i++) {
+    const d = new Date(now);
+    d.setMonth(d.getMonth() - i);
+    candidates.push({ period: "month", key: getPeriodKey(d, "month") });
+  }
+  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 existingSet = new Set(existingRows.map((r) => `${r.period}:${r.period_key}`));
+  const processFn = {
+    hour: processHour,
+    day: processDay,
+    week: processWeek,
+    month: processMonth
+  };
+  for (const { period, key: key2 } of candidates) {
+    if (existingSet.has(`${period}:${key2}`)) continue;
+    try {
+      await processFn[period](key2);
+    } catch (err) {
+      sLog.error(`backfill failed for ${period} ${key2}`, logger_default.errorData(err));
+    }
+  }
+}
+var Summarizer = class {
+  interval = null;
+  lastHourKey = null;
+  hasBackfilled = false;
+  start() {
+    this.interval = setInterval(() => this.tick(), 5 * 6e4);
+    this.tick();
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+  async tick() {
+    try {
+      if (!this.hasBackfilled) {
+        await backfill();
+        this.hasBackfilled = true;
+      }
+      await reconcileWedgedTurns(WEDGED_TURN_IDLE_MS);
+      const now = /* @__PURE__ */ new Date();
+      const currentHourKey = getPeriodKey(now, "hour");
+      if (this.lastHourKey && this.lastHourKey !== currentHourKey) {
+        await processHour(this.lastHourKey);
+      }
+      this.lastHourKey = currentHourKey;
+      const yesterday = new Date(now);
+      yesterday.setDate(yesterday.getDate() - 1);
+      const yesterdayKey = getPeriodKey(yesterday, "day");
+      if (!await summaryExists(SYSTEM_MIND, "day", yesterdayKey)) {
+        await processDay(yesterdayKey);
+      }
+      const currentWeekKey = getPeriodKey(now, "week");
+      const prevWeekKey = getPreviousPeriodKey(currentWeekKey, "week");
+      if (!await summaryExists(SYSTEM_MIND, "week", prevWeekKey)) {
+        await processWeek(prevWeekKey);
+      }
+      const currentMonthKey = getPeriodKey(now, "month");
+      const prevMonthKey = getPreviousPeriodKey(currentMonthKey, "month");
+      if (!await summaryExists(SYSTEM_MIND, "month", prevMonthKey)) {
+        await processMonth(prevMonthKey);
+      }
+    } catch (err) {
+      sLog.error("tick failed", logger_default.errorData(err));
+    }
+  }
+};
+async function reconcileWedgedTurns(idleMs) {
+  const { sweepWedgedTurns: sweepWedgedTurns2, summarizeOrphanedTurns: summarizeOrphanedTurns2 } = await import("./turn-tracker-SZBSL7LK.js");
+  const wedged = await sweepWedgedTurns2(idleMs);
+  if (wedged.length === 0) return;
+  summarizeOrphanedTurns2(wedged);
+  const { tryGetDeliveryManager } = await import("./delivery-manager-EB52CQ5X.js");
+  const dm = tryGetDeliveryManager();
+  if (!dm) return;
+  for (const t of wedged) {
+    if (t.session) dm.clearSessionActive(t.mind, t.session, idleMs);
+  }
+}
+var instance = null;
+function initSummarizer() {
+  if (instance) throw new Error("Summarizer already initialized");
+  instance = new Summarizer();
+  return instance;
+}
+
+// packages/daemon/src/lib/daemon/turn-tracker.ts
+var tlog = logger_default.child("turn-tracker");
+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);
+  if (existing) return existing.turnId;
+  const turnId = randomUUID();
+  const entry = { turnId, lastToolUseEventId: void 0 };
+  activeTurns.set(k, entry);
+  try {
+    const db = await getDb();
+    await db.insert(turns).values({ id: turnId, mind, status: "active" });
+  } catch (err) {
+    tlog.error(`failed to create turn for ${mind}`, logger_default.errorData(err));
+    if (activeTurns.get(k) === entry) activeTurns.delete(k);
+    return void 0;
+  }
+  return turnId;
+}
+function getActiveTurnId(mind, session) {
+  return (activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind)))?.turnId;
+}
+function trackToolUse(mind, session, eventId) {
+  const entry = activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind));
+  if (entry) entry.lastToolUseEventId = eventId;
+}
+function getLastToolUseEventId(mind, session) {
+  return (activeTurns.get(key(mind, session)) ?? activeTurns.get(key(mind)))?.lastToolUseEventId;
+}
+async function assignSession(mind, turnId, session) {
+  const wildcardKey = key(mind);
+  const entry = activeTurns.get(wildcardKey);
+  if (!entry || entry.turnId !== turnId) {
+    tlog.warn(`assignSession: no matching turn for ${mind} (turnId=${turnId}, session=${session})`);
+    return;
+  }
+  try {
+    const db = await getDb();
+    await db.update(turns).set({ session }).where(eq3(turns.id, turnId));
+  } catch (err) {
+    tlog.error(`failed to assign session to turn ${turnId}`, logger_default.errorData(err));
+    return;
+  }
+  activeTurns.delete(wildcardKey);
+  activeTurns.set(key(mind, session), entry);
+}
+async function completeTurn(mind, session) {
+  const k = key(mind, session);
+  const wildcardKey = key(mind);
+  const entry = activeTurns.get(k) ?? activeTurns.get(wildcardKey);
+  if (!entry) return void 0;
+  try {
+    const db = await getDb();
+    await db.update(turns).set({ status: "complete" }).where(eq3(turns.id, entry.turnId));
+  } catch (err) {
+    tlog.error(`failed to complete turn ${entry.turnId}`, logger_default.errorData(err));
+    return void 0;
+  }
+  activeTurns.delete(k);
+  activeTurns.delete(wildcardKey);
+  return entry.turnId;
+}
+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"));
+  if (active.length === 0) return [];
+  try {
+    await db.update(turns).set({ status: "complete" }).where(eq3(turns.status, "active"));
+  } catch (err) {
+    tlog.error("failed to complete orphaned turns on startup", logger_default.errorData(err));
+  }
+  tlog.info(`completed ${active.length} orphaned active turn(s) from previous daemon session`);
+  return active.map((r) => ({
+    turnId: r.id,
+    mind: r.mind,
+    session: r.session ?? void 0
+  }));
+}
+async function clearMind(mind) {
+  const toDelete = [];
+  const orphaned = [];
+  for (const [k, entry] of activeTurns.entries()) {
+    if (k.startsWith(`${mind}:`)) {
+      const session = k.slice(mind.length + 1);
+      orphaned.push({
+        turnId: entry.turnId,
+        mind,
+        session: session === "*" ? void 0 : session
+      });
+      toDelete.push(k);
+    }
+  }
+  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));
+      }
+    } catch (err) {
+      tlog.error(`failed to complete orphaned turns for ${mind}`, logger_default.errorData(err));
+    }
+  }
+  return orphaned;
+}
+async function sweepWedgedTurns(idleMs) {
+  const db = await getDb();
+  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(
+      sql2`max(${mindHistory.created_at}) < ${cutoff} and sum(case when ${mindHistory.type} = 'done' then 1 else 0 end) > 0`
+    );
+  } catch (err) {
+    tlog.error("failed to query wedged turns", logger_default.errorData(err));
+    return [];
+  }
+  const swept = [];
+  for (const r of rows) {
+    try {
+      await db.update(turns).set({ status: "complete" }).where(eq3(turns.id, r.id));
+    } catch (err) {
+      tlog.error(`failed to complete wedged turn ${r.id}`, logger_default.errorData(err));
+      continue;
+    }
+    const k = key(r.mind, r.session);
+    if (activeTurns.get(k)?.turnId === r.id) activeTurns.delete(k);
+    swept.push({ turnId: r.id, mind: r.mind, session: r.session ?? void 0 });
+  }
+  if (swept.length > 0) tlog.info(`swept ${swept.length} wedged turn(s)`);
+  return swept;
+}
+function summarizeOrphanedTurns(orphanedTurns) {
+  for (const { turnId, mind, session } of orphanedTurns) {
+    summarizeTurn(mind, session, void 0, 0, turnId).catch(
+      (err) => tlog.warn(`failed to summarize orphaned turn ${turnId} for ${mind}`, logger_default.errorData(err))
+    );
+  }
+}
+
+export {
+  PROMPT_KEYS,
+  PROMPT_DEFAULTS,
+  substitute,
+  getPrompt,
+  getPromptIfCustom,
+  getMindPromptDefaults,
+  subscribe,
+  subscribeAll,
+  publish,
+  summarizeTurn,
+  initSummarizer,
+  markErrored,
+  takeErrored,
+  createTurn,
+  getActiveTurnId,
+  trackToolUse,
+  getLastToolUseEventId,
+  assignSession,
+  completeTurn,
+  completeOrphanedTurns,
+  clearMind,
+  sweepWedgedTurns,
+  summarizeOrphanedTurns
+};