@askexenow/exe-os 0.9.300 → 0.9.301

package/dist/chunk-DPOIJ5SM.js

@@ -0,0 +1,284 @@
+import {
+  routeTask
+} from "./chunk-DICIFTCS.js";
+import {
+  createTaskCore,
+  employeeSessionName,
+  ensureEmployee,
+  getSessionState,
+  isEmployeeAlive,
+  sessionScopeFilter,
+  updateTaskStatus
+} from "./chunk-ZSUACDQC.js";
+import {
+  DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  getCoordinatorName
+} from "./chunk-V6LOEOXG.js";
+
+// src/runtime/orchestrator.ts
+var STALE_THRESHOLD_MS = 2 * 60 * 60 * 1e3;
+var MultiAgentOrchestrator = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Route and dispatch a single task to the best-fit employee.
+   */
+  async dispatchTask(task) {
+    let targetEmployee;
+    let routingScore = 0;
+    if (task.assignTo) {
+      const found = this.config.employees.find((e) => e.name === task.assignTo);
+      if (!found) {
+        return {
+          employee: task.assignTo,
+          sessionName: "",
+          status: "failed",
+          routingScore: 0,
+          error: `Employee "${task.assignTo}" not found`
+        };
+      }
+      targetEmployee = found;
+      routingScore = 1;
+    } else {
+      const routed = await routeTask(
+        `${task.title}
+${task.context}`,
+        this.config.employees,
+        this.config.embedFn,
+        this.config.searchFn
+      );
+      targetEmployee = routed.employee;
+      routingScore = routed.score;
+    }
+    try {
+      await createTaskCore({
+        title: task.title,
+        assignedTo: targetEmployee.name,
+        assignedBy: getCoordinatorName(),
+        projectName: task.projectName,
+        priority: task.priority,
+        context: task.context,
+        baseDir: this.config.projectDir,
+        skipDispatch: true
+      });
+    } catch (err) {
+      return {
+        employee: targetEmployee.name,
+        sessionName: "",
+        status: "failed",
+        routingScore,
+        error: `Task creation failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const result = ensureEmployee(
+      targetEmployee.name,
+      this.config.exeSession,
+      this.config.projectDir,
+      task.spawnOpts
+    );
+    return {
+      employee: targetEmployee.name,
+      sessionName: result.sessionName,
+      status: result.status === "failed" ? "failed" : result.status === "spawned" ? "dispatched" : "already_running",
+      routingScore,
+      error: result.error
+    };
+  }
+  /**
+   * Check health of all employees. Detect stuck and idle agents.
+   */
+  async healthCheck() {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const employees = [];
+    const stuckAgents = [];
+    const idleAgents = [];
+    const crashedSessions = [];
+    let totalOpen = 0;
+    let totalInProgress = 0;
+    for (const emp of this.config.employees) {
+      const sessionName = employeeSessionName(emp.name, this.config.exeSession);
+      const alive = isEmployeeAlive(sessionName);
+      const state = alive ? getSessionState(sessionName) : "offline";
+      const oScope = sessionScopeFilter();
+      const tasks = await client.execute({
+        sql: `SELECT title, status, updated_at FROM tasks
+              WHERE assigned_to = ? AND status IN ('open', 'in_progress')${oScope.sql}
+              ORDER BY priority ASC`,
+        args: [emp.name, ...oScope.args]
+      });
+      const openCount = tasks.rows.filter((r) => r.status === "open").length;
+      const inProgressCount = tasks.rows.filter((r) => r.status === "in_progress").length;
+      totalOpen += openCount;
+      totalInProgress += inProgressCount;
+      const staleTasks = [];
+      for (const row of tasks.rows) {
+        if (row.status === "in_progress" && row.updated_at) {
+          const age = Date.now() - new Date(String(row.updated_at)).getTime();
+          if (age > STALE_THRESHOLD_MS) {
+            staleTasks.push(String(row.title));
+          }
+        }
+      }
+      const crashed = !alive && inProgressCount > 0;
+      if (staleTasks.length > 0) {
+        stuckAgents.push(emp.name);
+      }
+      if (crashed) {
+        crashedSessions.push(emp.name);
+      }
+      if (alive && state === "idle" && openCount + inProgressCount === 0) {
+        idleAgents.push(emp.name);
+      }
+      employees.push({
+        name: emp.name,
+        role: emp.role,
+        sessionName,
+        alive,
+        crashed,
+        state,
+        taskCount: openCount + inProgressCount,
+        inProgressCount,
+        staleTasks
+      });
+    }
+    return {
+      employees,
+      stuckAgents,
+      idleAgents,
+      crashedSessions,
+      totalOpenTasks: totalOpen,
+      totalInProgress
+    };
+  }
+  /**
+   * Process completed reviews. Auto-approve P2 tasks with passing results.
+   */
+  async processReviews() {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const autoApproved = [];
+    const needsReview = [];
+    const coordinatorName = getCoordinatorName();
+    const rScope = sessionScopeFilter();
+    const reviews = await client.execute({
+      sql: `SELECT id, title, assigned_to, priority, result, task_file FROM tasks
+            WHERE (assigned_to = ? OR assigned_to = ?)
+              AND status IN ('open', 'in_progress')
+              AND task_file LIKE '%review-%'${rScope.sql}
+            ORDER BY priority ASC
+            LIMIT 20`,
+      args: [coordinatorName, DEFAULT_COORDINATOR_TEMPLATE_NAME, ...rScope.args]
+    });
+    for (const row of reviews.rows) {
+      const item = {
+        taskId: String(row.id),
+        title: String(row.title),
+        assignedTo: String(row.assigned_to),
+        priority: String(row.priority),
+        result: String(row.result ?? ""),
+        taskFile: String(row.task_file)
+      };
+      if (this.config.autoApproveP2 && item.priority === "p2" && /tests?\s+pass/i.test(item.result)) {
+        try {
+          await updateTaskStatus({
+            taskId: item.taskId,
+            status: "done",
+            result: `[auto-approved] ${item.result}`,
+            skipReviewCreation: true
+          });
+        } catch {
+          await client.execute({
+            sql: `UPDATE tasks SET status = 'done', result = ? WHERE id = ?`,
+            args: [`[auto-approved] ${item.result}`, item.taskId]
+          });
+        }
+        autoApproved.push(item);
+      } else {
+        needsReview.push(item);
+      }
+    }
+    return {
+      autoApproved,
+      needsReview,
+      processed: autoApproved.length + needsReview.length
+    };
+  }
+  /**
+   * Run one full orchestration cycle: health check + process reviews.
+   * Does NOT dispatch tasks — call dispatchTask() explicitly.
+   */
+  async tick() {
+    const health = await this.healthCheck();
+    const reviews = await this.processReviews();
+    for (const stuck of health.stuckAgents) {
+      const sessionName = employeeSessionName(stuck, this.config.exeSession);
+      if (isEmployeeAlive(sessionName)) {
+        const { sendIntercom } = await import("./lib/tmux-routing.js");
+        sendIntercom(sessionName);
+      }
+    }
+    for (const crashed of health.crashedSessions) {
+      this.recoverSession(crashed);
+    }
+    return {
+      dispatched: [],
+      health,
+      reviews,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Recover a crashed session by spawning a fresh CC session.
+   * The new session boots with identity via --system-prompt, finds existing in_progress tasks, and resumes.
+   */
+  recoverSession(employeeName) {
+    const sessionName = employeeSessionName(employeeName, this.config.exeSession);
+    const result = ensureEmployee(
+      employeeName,
+      this.config.exeSession,
+      this.config.projectDir
+    );
+    if (result.status === "failed") {
+      return { status: "failed", sessionName, error: result.error };
+    }
+    return { status: "recovered", sessionName: result.sessionName };
+  }
+  /**
+   * Dispatch a batch of tasks, auto-routing each to the best employee.
+   */
+  async dispatchBatch(tasks) {
+    const results = [];
+    for (const task of tasks) {
+      const result = await this.dispatchTask(task);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Get a formatted status summary (matches exe boot brief style).
+   */
+  async getStatusSummary() {
+    const health = await this.healthCheck();
+    const lines = [];
+    lines.push("\u25B8 ORCHESTRATOR STATUS");
+    lines.push(`  Tasks:   ${health.totalOpenTasks} open, ${health.totalInProgress} in progress`);
+    lines.push(`  Crashed: ${health.crashedSessions.length > 0 ? health.crashedSessions.join(", ") : "none"}`);
+    lines.push(`  Stuck:   ${health.stuckAgents.length > 0 ? health.stuckAgents.join(", ") : "none"}`);
+    lines.push(`  Idle:    ${health.idleAgents.length > 0 ? health.idleAgents.join(", ") : "none"}`);
+    lines.push("");
+    for (const emp of health.employees) {
+      const stateIcon = emp.alive ? emp.state === "idle" ? "\u{1F7E2}" : emp.state === "thinking" ? "\u{1F7E1}" : emp.state === "tool" ? "\u{1F535}" : "\u26AA" : "\u{1F534}";
+      const taskInfo = emp.taskCount > 0 ? `${emp.taskCount} task${emp.taskCount > 1 ? "s" : ""} (${emp.inProgressCount} active)` : "idle";
+      const staleWarning = emp.staleTasks.length > 0 ? ` \u26A0 stale: ${emp.staleTasks[0]}` : "";
+      lines.push(`  ${stateIcon} ${emp.name} (${emp.role}): ${taskInfo}${staleWarning}`);
+    }
+    return lines.join("\n");
+  }
+};
+
+export {
+  MultiAgentOrchestrator
+};

package/dist/chunk-FAZNXNA5.js

@@ -0,0 +1,33 @@
+import {
+  completeReminder
+} from "./chunk-ZKHPZ6KN.js";
+
+// src/mcp/tools/complete-reminder.ts
+import { z } from "zod";
+function registerCompleteReminder(server) {
+  server.registerTool(
+    "complete_reminder",
+    {
+      title: "Complete Reminder",
+      description: "Mark a reminder as done. Accepts UUID or text substring.",
+      inputSchema: {
+        reminder_id: z.string().describe("Reminder UUID or text substring to match")
+      }
+    },
+    async ({ reminder_id }) => {
+      const reminder = await completeReminder(reminder_id);
+      if (!reminder) {
+        return {
+          content: [{ type: "text", text: `No active reminder matching "${reminder_id}".` }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Reminder completed: "${reminder.text}"` }]
+      };
+    }
+  );
+}
+
+export {
+  registerCompleteReminder
+};

package/dist/chunk-FCHG5RC4.js

@@ -0,0 +1,197 @@
+import {
+  initStore
+} from "./chunk-YHJPTIPR.js";
+import {
+  getClient,
+  isInitialized
+} from "./chunk-V6LOEOXG.js";
+
+// src/lib/schedules.ts
+import crypto from "crypto";
+import { execSync } from "child_process";
+var CRON_FIELD = /^[\d*/,\-]+$/;
+function isValidCron(cron) {
+  const fields = cron.trim().split(/\s+/);
+  if (fields.length !== 5) return false;
+  return fields.every((f) => CRON_FIELD.test(f));
+}
+var SAFE_ID = /^[a-zA-Z0-9_\-]+$/;
+function isValidScheduleId(id) {
+  return SAFE_ID.test(id) && id.length <= 128;
+}
+async function ensureDb() {
+  if (!isInitialized()) {
+    await initStore();
+  }
+}
+function parseHumanCron(input) {
+  const s = input.toLowerCase().trim();
+  if (/^[\d*\/,-]+\s+[\d*\/,-]+\s+[\d*\/,-]+\s+[\d*\/,-]+\s+[\d*\/,-]+$/.test(s)) {
+    return s;
+  }
+  const dayMap = {
+    sunday: "0",
+    sun: "0",
+    monday: "1",
+    mon: "1",
+    tuesday: "2",
+    tue: "2",
+    wednesday: "3",
+    wed: "3",
+    thursday: "4",
+    thu: "4",
+    friday: "5",
+    fri: "5",
+    saturday: "6",
+    sat: "6"
+  };
+  const everyMatch = s.match(/every\s+(\d+)\s*([mh])/);
+  if (everyMatch) {
+    const n = everyMatch[1];
+    const unit = everyMatch[2];
+    if (unit === "m") return `*/${n} * * * *`;
+    if (unit === "h") return `0 */${n} * * *`;
+  }
+  let hour = -1;
+  let minute = 0;
+  if (/midnight/.test(s)) {
+    hour = 0;
+  } else if (/noon/.test(s)) {
+    hour = 12;
+  } else {
+    const timeMatch = s.match(/(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/);
+    if (timeMatch) {
+      hour = parseInt(timeMatch[1], 10);
+      minute = timeMatch[2] ? parseInt(timeMatch[2], 10) : 0;
+      if (timeMatch[3] === "pm" && hour < 12) hour += 12;
+      if (timeMatch[3] === "am" && hour === 12) hour = 0;
+    }
+  }
+  if (hour === -1) hour = 0;
+  let dow = "*";
+  if (/weekday|weekdays/.test(s)) {
+    dow = "1-5";
+  } else if (/weekend|weekends/.test(s)) {
+    dow = "0,6";
+  } else {
+    for (const [name, val] of Object.entries(dayMap)) {
+      if (s.includes(name)) {
+        dow = val;
+        break;
+      }
+    }
+  }
+  return `${minute} ${hour} * * ${dow}`;
+}
+async function createSchedule(input) {
+  if (!isValidCron(input.cron)) {
+    throw new Error(`Invalid cron expression: ${input.cron}. Must be 5 fields with only digits, *, /, -, comma.`);
+  }
+  await ensureDb();
+  const client = getClient();
+  const id = crypto.randomUUID().slice(0, 8);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const prompt = input.prompt ?? input.description;
+  await client.execute({
+    sql: `INSERT INTO schedules (id, cron, description, job_type, prompt, assigned_to, project_name, active, use_crontab, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`,
+    args: [
+      id,
+      input.cron,
+      input.description,
+      input.jobType ?? "report",
+      prompt,
+      input.assignedTo ?? null,
+      input.projectName ?? null,
+      input.useCrontab ? 1 : 0,
+      now
+    ]
+  });
+  if (input.useCrontab) {
+    addToCrontab(id, input.cron, prompt, input.projectName);
+  }
+  return {
+    id,
+    cron: input.cron,
+    description: input.description,
+    jobType: input.jobType ?? "report",
+    prompt,
+    assignedTo: input.assignedTo,
+    projectName: input.projectName,
+    active: true,
+    useCrontab: input.useCrontab ?? false,
+    createdAt: now
+  };
+}
+async function listSchedules(activeOnly = true) {
+  await ensureDb();
+  const client = getClient();
+  const sql = activeOnly ? "SELECT * FROM schedules WHERE active = 1 ORDER BY created_at ASC" : "SELECT * FROM schedules ORDER BY created_at ASC";
+  const result = await client.execute({ sql, args: [] });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    cron: String(row.cron),
+    description: String(row.description),
+    jobType: String(row.job_type),
+    prompt: row.prompt ? String(row.prompt) : void 0,
+    assignedTo: row.assigned_to ? String(row.assigned_to) : void 0,
+    projectName: row.project_name ? String(row.project_name) : void 0,
+    active: Number(row.active) === 1,
+    useCrontab: Number(row.use_crontab) === 1,
+    createdAt: String(row.created_at)
+  }));
+}
+async function deleteSchedule(id) {
+  await ensureDb();
+  const client = getClient();
+  const existing = await client.execute({
+    sql: "SELECT use_crontab FROM schedules WHERE id = ?",
+    args: [id]
+  });
+  if (existing.rows.length === 0) return false;
+  const usesCrontab = Number(existing.rows[0].use_crontab) === 1;
+  await client.execute({
+    sql: "DELETE FROM schedules WHERE id = ?",
+    args: [id]
+  });
+  if (usesCrontab) {
+    removeFromCrontab(id);
+  }
+  return true;
+}
+function addToCrontab(id, cron, prompt, projectDir) {
+  if (!isValidCron(cron)) {
+    throw new Error(`Invalid cron expression: ${cron}`);
+  }
+  if (!isValidScheduleId(id)) {
+    throw new Error(`Invalid schedule ID: ${id}`);
+  }
+  try {
+    const cwd = projectDir ? `cd ${JSON.stringify(projectDir)} && ` : "";
+    const escapedPrompt = prompt.replace(/"/g, '\\"');
+    const entry = `${cron} ${cwd}claude -p --dangerously-skip-permissions "${escapedPrompt}" # exe-schedule:${id}`;
+    execSync(
+      `(crontab -l 2>/dev/null; echo ${JSON.stringify(entry)}) | crontab -`,
+      { timeout: 5e3, stdio: "ignore" }
+    );
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Invalid")) throw err;
+  }
+}
+function removeFromCrontab(id) {
+  if (!isValidScheduleId(id)) return;
+  try {
+    execSync(
+      `crontab -l 2>/dev/null | grep -v "exe-schedule:${id}" | crontab -`,
+      { timeout: 5e3, stdio: "ignore" }
+    );
+  } catch {
+  }
+}
+
+export {
+  parseHumanCron,
+  createSchedule,
+  listSchedules,
+  deleteSchedule
+};

package/dist/chunk-FFKSPZO2.js

@@ -0,0 +1,157 @@
+import {
+  clean,
+  stableId
+} from "./chunk-S73ZAJ2S.js";
+
+// src/lib/reflection-checkpoints.ts
+function parsePayload(payload) {
+  if (!payload) return {};
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return {};
+  }
+}
+function semanticArray(event, key) {
+  const payload = parsePayload(event.payload);
+  const semantic = payload.semantic;
+  const value = semantic?.[key];
+  return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
+}
+function buildReflectionCheckpoint(events) {
+  if (!events.length) return null;
+  const sorted = [...events].sort((a, b) => a.occurred_at.localeCompare(b.occurred_at));
+  const first = sorted[0];
+  const last = sorted[sorted.length - 1];
+  const goals = /* @__PURE__ */ new Set();
+  const successes = [];
+  const failures = [];
+  const risks = [];
+  const nextActions = [];
+  const decisions = [];
+  for (const event of sorted) {
+    for (const goal of semanticArray(event, "goals")) goals.add(goal);
+    for (const item of semanticArray(event, "successSignals")) successes.push(item);
+    for (const item of semanticArray(event, "failureSignals")) failures.push(item);
+    for (const item of semanticArray(event, "nextActions")) nextActions.push(item);
+    for (const item of semanticArray(event, "decisions")) decisions.push(item);
+    if (event.impact === "negative" || event.outcome === "failure_signal" || event.event_type === "problem" || event.event_type === "error") {
+      failures.push(event.outcome || event.intention || event.event_type);
+    }
+    if (event.outcome === "risk_signal") risks.push(event.intention || event.outcome);
+    if (event.impact === "positive" || event.outcome === "success_signal" || event.event_type === "milestone") {
+      successes.push(event.outcome || event.intention || event.event_type);
+    }
+  }
+  const uniqueGoals = [...goals].slice(0, 6);
+  const uniqueSuccesses = [...new Set(successes.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueFailures = [...new Set(failures.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueRisks = [...new Set(risks.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueNext = [...new Set(nextActions.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueDecisions = [...new Set(decisions.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const learnings = [
+    uniqueSuccesses.length ? `Working: ${uniqueSuccesses.slice(0, 3).join("; ")}` : "Working: no strong success signal yet",
+    uniqueFailures.length ? `Improve: ${uniqueFailures.slice(0, 3).join("; ")}` : "Improve: no strong failure signal in this window",
+    uniqueDecisions.length ? `Decision context: ${uniqueDecisions.slice(0, 2).join("; ")}` : "Decision context: no explicit decision signal"
+  ];
+  const summary = clean([
+    `Window ${first.occurred_at} \u2192 ${last.occurred_at}`,
+    `${sorted.length} events`,
+    uniqueGoals.length ? `goals: ${uniqueGoals.join("; ")}` : "goals: inferred from event trajectory",
+    uniqueSuccesses.length ? `successes: ${uniqueSuccesses.slice(0, 2).join("; ")}` : "successes: none explicit",
+    uniqueFailures.length ? `failures: ${uniqueFailures.slice(0, 2).join("; ")}` : "failures: none explicit"
+  ].join(". "), 1200);
+  return {
+    id: stableId("reflection", first.project_name ?? "", first.session_id ?? "", first.occurred_at, last.occurred_at, sorted.length),
+    projectName: first.project_name ?? null,
+    sessionId: first.session_id ?? null,
+    windowStartAt: first.occurred_at,
+    windowEndAt: last.occurred_at,
+    eventCount: sorted.length,
+    goalCount: uniqueGoals.length,
+    successCount: uniqueSuccesses.length,
+    failureCount: uniqueFailures.length,
+    riskCount: uniqueRisks.length,
+    summary,
+    learnings,
+    nextActions: uniqueNext.length ? uniqueNext : ["Continue from latest successful event and resolve highest-impact failure/risk first."],
+    evidenceEventIds: sorted.slice(-25).map((e) => e.id),
+    confidence: Math.min(0.95, 0.5 + Math.min(sorted.length, 100) / 250 + uniqueGoals.length * 0.03)
+  };
+}
+async function resolveClient(client) {
+  if (client) return client;
+  const { getClient } = await import("./lib/database.js");
+  return getClient();
+}
+async function insertReflectionCheckpoint(checkpoint, client) {
+  const db = await resolveClient(client);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await db.execute({
+    sql: `INSERT INTO agent_reflection_checkpoints
+      (id, project_name, session_id, window_start_at, window_end_at, event_count, goal_count,
+       success_count, failure_count, risk_count, summary, learnings, next_actions, evidence_event_ids,
+       confidence, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET summary = excluded.summary, learnings = excluded.learnings,
+        next_actions = excluded.next_actions, confidence = excluded.confidence`,
+    args: [
+      checkpoint.id,
+      checkpoint.projectName,
+      checkpoint.sessionId,
+      checkpoint.windowStartAt,
+      checkpoint.windowEndAt,
+      checkpoint.eventCount,
+      checkpoint.goalCount,
+      checkpoint.successCount,
+      checkpoint.failureCount,
+      checkpoint.riskCount,
+      checkpoint.summary,
+      JSON.stringify(checkpoint.learnings),
+      JSON.stringify(checkpoint.nextActions),
+      JSON.stringify(checkpoint.evidenceEventIds),
+      checkpoint.confidence,
+      now
+    ]
+  });
+}
+async function generateReflectionCheckpoints(opts = {}) {
+  const db = await resolveClient(opts.client);
+  const windowSize = opts.windowSize ?? 100;
+  const minEvents = opts.minEvents ?? 20;
+  const limit = opts.limit ?? 5e3;
+  const where = opts.projectName ? "WHERE project_name = ?" : "";
+  const args = opts.projectName ? [opts.projectName] : [];
+  const result = await db.execute({
+    sql: `SELECT id, event_type, occurred_at, actor_agent_id, project_name, session_id, intention, outcome, impact, evidence_memory_id, payload
+          FROM agent_events ${where}
+          ORDER BY project_name, session_id, occurred_at, sequence_index
+          LIMIT ?`,
+    args: [...args, limit]
+  });
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const event = row;
+    const key = `${event.project_name ?? ""}::${event.session_id ?? ""}`;
+    const bucket = groups.get(key) ?? [];
+    bucket.push(event);
+    groups.set(key, bucket);
+  }
+  let inserted = 0;
+  for (const events of groups.values()) {
+    for (let i = 0; i < events.length; i += windowSize) {
+      const window = events.slice(i, i + windowSize);
+      if (window.length < minEvents) continue;
+      const checkpoint = buildReflectionCheckpoint(window);
+      if (!checkpoint) continue;
+      await insertReflectionCheckpoint(checkpoint, db);
+      inserted++;
+    }
+  }
+  return inserted;
+}
+
+export {
+  buildReflectionCheckpoint,
+  generateReflectionCheckpoints
+};