@askexenow/exe-os 0.9.276 → 0.9.277

package/dist/chunk-JM3W7VQF.js

@@ -0,0 +1,106 @@
+import {
+  loadConfig,
+  saveConfig
+} from "./chunk-LAAB5EOU.js";
+
+// src/lib/orchestration-phase.ts
+var ORCHESTRATION_PHASES = [
+  "phase_1_coo",
+  "phase_2_executives",
+  "phase_3_parallel_org"
+];
+var PHASE_INFO = {
+  phase_1_coo: {
+    phase: "phase_1_coo",
+    shortLabel: "Phase 1 \u2014 Coordinator mode",
+    label: "Phase 1 \u2014 Coordinator / Chief of Staff mode",
+    focus: "building company context before delegation",
+    nextSuggestion: "Unlock executives when technical, marketing, ops, legal, or finance work repeats."
+  },
+  phase_2_executives: {
+    phase: "phase_2_executives",
+    shortLabel: "Phase 2 \u2014 Executive bench",
+    label: "Phase 2 \u2014 Executive bench",
+    focus: "Coordinator works with domain executives like CTO/CMO before specialist fan-out",
+    nextSuggestion: "Unlock parallel execution when review gates, permissions, and workflows are ready."
+  },
+  phase_3_parallel_org: {
+    phase: "phase_3_parallel_org",
+    shortLabel: "Phase 3 \u2014 Parallel org",
+    label: "Phase 3 \u2014 Parallel execution org",
+    focus: "executives can delegate to specialists in parallel with review gates",
+    nextSuggestion: "Keep review/CI/permission gates healthy; downgrade anytime if you want simpler coordinator-only mode."
+  }
+};
+function normalizeOrchestrationPhase(input) {
+  if (typeof input !== "string") return "phase_1_coo";
+  const normalized = input.trim().toLowerCase().replace(/\s+/g, "_");
+  if (["1", "phase1", "phase_1", "coo", "coo_mode", "chief_of_staff", "phase_1_coo"].includes(normalized)) {
+    return "phase_1_coo";
+  }
+  if (["2", "phase2", "phase_2", "executives", "executive", "executive_bench", "phase_2_executives"].includes(normalized)) {
+    return "phase_2_executives";
+  }
+  if (["3", "phase3", "phase_3", "parallel", "parallel_org", "parallel_execution", "phase_3_parallel_org"].includes(normalized)) {
+    return "phase_3_parallel_org";
+  }
+  if (ORCHESTRATION_PHASES.includes(normalized)) return normalized;
+  return "phase_1_coo";
+}
+function getOrchestrationPhaseInfo(phase) {
+  return PHASE_INFO[normalizeOrchestrationPhase(phase)];
+}
+function getConfigOrchestrationPhase(config) {
+  const orchestration = config.orchestration;
+  return normalizeOrchestrationPhase(orchestration?.phase);
+}
+function applyDefaultOrchestrationPhase(config) {
+  if (!config.orchestration) {
+    config.orchestration = {
+      phase: "phase_1_coo",
+      phaseSetAt: (/* @__PURE__ */ new Date()).toISOString(),
+      phaseSetBy: "setup-default"
+    };
+    return config;
+  }
+  if (!config.orchestration.phase) {
+    config.orchestration = {
+      ...config.orchestration,
+      phase: "phase_1_coo",
+      phaseSetAt: config.orchestration.phaseSetAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      phaseSetBy: config.orchestration.phaseSetBy ?? "setup-default"
+    };
+  }
+  return config;
+}
+async function loadOrchestrationPhase() {
+  const config = await loadConfig();
+  return getOrchestrationPhaseInfo(config.orchestration?.phase);
+}
+async function setOrchestrationPhase(phaseInput, setBy = "user") {
+  const config = await loadConfig();
+  const phase = normalizeOrchestrationPhase(phaseInput);
+  config.orchestration = {
+    ...config.orchestration ?? {},
+    phase,
+    phaseSetAt: (/* @__PURE__ */ new Date()).toISOString(),
+    phaseSetBy: setBy
+  };
+  await saveConfig(config);
+  return getOrchestrationPhaseInfo(phase);
+}
+function phaseReminderLine(phase) {
+  const info = getOrchestrationPhaseInfo(phase);
+  return `${info.shortLabel}: ${info.focus}. ${info.nextSuggestion}`;
+}
+
+export {
+  ORCHESTRATION_PHASES,
+  normalizeOrchestrationPhase,
+  getOrchestrationPhaseInfo,
+  getConfigOrchestrationPhase,
+  applyDefaultOrchestrationPhase,
+  loadOrchestrationPhase,
+  setOrchestrationPhase,
+  phaseReminderLine
+};

package/dist/chunk-JNPJIC2C.js

@@ -0,0 +1,510 @@
+import {
+  cleanupGraphLinksForMemories
+} from "./chunk-KBNMVPDE.js";
+import {
+  vectorToBlob
+} from "./chunk-QC2P5DML.js";
+import {
+  extractKeywords,
+  keywordsToString
+} from "./chunk-CHCA3ZM2.js";
+import {
+  isCoordinatorName
+} from "./chunk-YBDREOVN.js";
+
+// src/lib/consolidation.ts
+import { randomUUID } from "crypto";
+async function selectUnconsolidated(client, limit = 200) {
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, project_name, tool_name, raw_text, timestamp, memory_type, session_scope
+          FROM memories
+          WHERE consolidated = 0
+            AND COALESCE(memory_type, 'raw') != 'procedure'
+          ORDER BY timestamp DESC
+          LIMIT ?`,
+    args: [limit]
+  });
+  return result.rows.map((row) => ({
+    id: row.id,
+    agent_id: row.agent_id,
+    project_name: row.project_name,
+    tool_name: row.tool_name,
+    raw_text: row.raw_text,
+    timestamp: row.timestamp,
+    memory_type: row.memory_type ?? null,
+    session_scope: row.session_scope ?? null
+  }));
+}
+function dominantMemoryType(memories) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const m of memories) {
+    const type = m.memory_type ?? "raw";
+    counts.set(type, (counts.get(type) ?? 0) + 1);
+  }
+  let best = "observation";
+  let bestCount = 0;
+  for (const [type, count] of counts) {
+    if (count > bestCount || count === bestCount && type !== "raw") {
+      best = type;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+function groupMemories(memories) {
+  const byProject = /* @__PURE__ */ new Map();
+  for (const mem of memories) {
+    const key = `${mem.agent_id}::${mem.project_name}`;
+    const list = byProject.get(key) ?? [];
+    list.push(mem);
+    byProject.set(key, list);
+  }
+  const clusters = [];
+  for (const [key, projectMemories] of byProject) {
+    const [agentId, projectName] = key.split("::");
+    const byDay = /* @__PURE__ */ new Map();
+    for (const mem of projectMemories) {
+      const day = mem.timestamp.slice(0, 10);
+      const list = byDay.get(day) ?? [];
+      list.push(mem);
+      byDay.set(day, list);
+    }
+    for (const [day, dayMemories] of byDay) {
+      if (dayMemories.length < 3) continue;
+      if (dayMemories.length <= 15) {
+        clusters.push({
+          agentId,
+          projectName,
+          dateRange: day,
+          memories: dayMemories
+        });
+      } else {
+        for (let i = 0; i < dayMemories.length; i += 12) {
+          const chunk = dayMemories.slice(i, i + 12);
+          clusters.push({
+            agentId,
+            projectName,
+            dateRange: day,
+            memories: chunk
+          });
+        }
+      }
+    }
+  }
+  return clusters;
+}
+var ROLE_PROMPTS = {
+  "COO": `Extract EXACTLY THREE types of insights:
+1. KEY DECISIONS \u2014 choices that were made and why (at most 3)
+2. RECURRING PATTERNS \u2014 actions or approaches that repeated (at most 3)
+3. OPEN QUESTIONS \u2014 things that seem unresolved or risky (at most 2)`,
+  "CTO": `Extract EXACTLY THREE types of insights:
+1. ARCHITECTURE DECISIONS \u2014 design choices, tradeoffs, delegation patterns (at most 3)
+2. REVIEW OUTCOMES \u2014 what was approved, rejected, or flagged during code review (at most 3)
+3. TECHNICAL DEBT \u2014 unresolved issues, deferred work, risks identified (at most 2)`,
+  "Principal Engineer": `Extract EXACTLY THREE types of insights:
+1. CODE DECISIONS \u2014 implementation choices, patterns used, bugs fixed (at most 3)
+2. FILE CHANGES \u2014 key files modified and why (at most 3)
+3. BLOCKERS \u2014 things that slowed down or prevented progress (at most 2)`,
+  "Staff Code Reviewer": `Extract EXACTLY THREE types of insights:
+1. AUDIT FINDINGS \u2014 issues found, severity, fix status (at most 3)
+2. RECURRING ISSUES \u2014 patterns that keep appearing across reviews (at most 3)
+3. QUALITY SIGNALS \u2014 areas of the codebase that are strong or weak (at most 2)`,
+  "CMO": `Extract EXACTLY THREE types of insights:
+1. DESIGN DECISIONS \u2014 brand, layout, typography, or content choices made (at most 3)
+2. CONTENT STRATEGY \u2014 messaging, SEO, platform-specific decisions (at most 3)
+3. BRAND ALIGNMENT \u2014 consistency issues or guidelines established (at most 2)`,
+  "AI Product Lead": `Extract EXACTLY THREE types of insights:
+1. RESEARCH FINDINGS \u2014 tools, repos, or models evaluated with conclusions (at most 3)
+2. COMPETITIVE GAPS \u2014 features or patterns worth adopting from competitors (at most 3)
+3. BUILD RECOMMENDATIONS \u2014 what to build, skip, or watch (at most 2)`
+};
+var DEFAULT_ROLE_PROMPT = `Extract EXACTLY THREE types of insights:
+1. KEY DECISIONS \u2014 choices that were made and why (at most 3)
+2. RECURRING PATTERNS \u2014 actions or approaches that repeated (at most 3)
+3. OPEN QUESTIONS \u2014 things that seem unresolved or risky (at most 2)`;
+function buildConsolidationPrompt(cluster, agentRole) {
+  const snippets = cluster.memories.map((m, i) => {
+    return `${i + 1}. [${m.tool_name}] ${m.raw_text}`;
+  }).join("\n");
+  const rolePrompt = agentRole && ROLE_PROMPTS[agentRole] || DEFAULT_ROLE_PROMPT;
+  return `You are reviewing a set of work memories from an AI coding agent.
+These are raw tool call records from ${cluster.dateRange}.
+
+Agent: ${cluster.agentId} | Project: ${cluster.projectName} | Date: ${cluster.dateRange}
+
+MEMORIES:
+${snippets}
+
+${rolePrompt}
+
+IMPORTANT: Preserve all specific names, file paths, technical terms, and proper nouns exactly as they appear. Front-load the most important terms in the first sentence of your summary. Never replace specific terms with generic descriptions (e.g. write "hybrid-search.ts" not "the search file", write "extractKeywords" not "the extraction function").
+
+Format each as a single sentence. Be specific \u2014 include file names,
+function names, and concrete details. Skip if no insight for a category.`;
+}
+async function consolidateCluster(cluster, model, agentRole) {
+  const Anthropic = (await import("@anthropic-ai/sdk")).default;
+  const client = new Anthropic();
+  const prompt = buildConsolidationPrompt(cluster, agentRole);
+  const response = await client.messages.create({
+    model,
+    max_tokens: 300,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const textBlock = response.content.find((b) => b.type === "text");
+  return textBlock?.text ?? "";
+}
+async function storeConsolidation(client, cluster, synthesisText, embedFn) {
+  const consolidatedId = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const rawText = `CONSOLIDATION [${cluster.dateRange}, ${cluster.projectName}]:
+
+${synthesisText}`;
+  let vector = null;
+  if (embedFn) {
+    try {
+      vector = await embedFn(rawText);
+    } catch {
+    }
+  }
+  const memoryType = dominantMemoryType(cluster.memories);
+  const scopes = new Set(cluster.memories.map((m) => m.session_scope ?? null));
+  const sessionScope = scopes.size === 1 ? cluster.memories[0]?.session_scope ?? null : null;
+  const keywords = keywordsToString(extractKeywords(rawText));
+  const insertSql = vector ? `INSERT INTO memories
+        (id, agent_id, agent_role, session_id, timestamp,
+         tool_name, project_name, has_error, raw_text, vector, version, consolidated, importance, memory_type, session_scope, keywords)
+        VALUES (?, ?, 'consolidation', 'daemon-consolidation', ?, 'consolidation', ?, 0, ?, vector32(?), 0, 1, 9, ?, ?, ?)` : `INSERT INTO memories
+        (id, agent_id, agent_role, session_id, timestamp,
+         tool_name, project_name, has_error, raw_text, vector, version, consolidated, importance, memory_type, session_scope, keywords)
+        VALUES (?, ?, 'consolidation', 'daemon-consolidation', ?, 'consolidation', ?, 0, ?, NULL, 0, 1, 9, ?, ?, ?)`;
+  const insertArgs = vector ? [consolidatedId, cluster.agentId, now, cluster.projectName, rawText, vectorToBlob(vector), memoryType, sessionScope, keywords] : [consolidatedId, cluster.agentId, now, cluster.projectName, rawText, memoryType, sessionScope, keywords];
+  await client.execute({ sql: insertSql, args: insertArgs });
+  const sourceIds = cluster.memories.map((m) => m.id);
+  const linkStmts = sourceIds.map((sourceId) => ({
+    sql: `INSERT INTO consolidations (id, consolidated_memory_id, source_memory_id, created_at)
+          VALUES (?, ?, ?, ?)`,
+    args: [randomUUID(), consolidatedId, sourceId, now]
+  }));
+  const placeholders = sourceIds.map(() => "?").join(",");
+  const markStmt = {
+    sql: `UPDATE memories SET consolidated = 1, status = 'archived' WHERE id IN (${placeholders})`,
+    args: sourceIds
+  };
+  await client.batch([...linkStmts, markStmt], "write");
+  return { consolidatedMemoryId: consolidatedId, sourceIds, rawText };
+}
+var WIKI_FETCH_TIMEOUT_MS = 1e4;
+async function pushToWiki(consolidation, config) {
+  if (!config.wikiEnabled || !config.wikiAutoUpdate) {
+    return { updated: false };
+  }
+  const apiUrl = config.wikiUrl || process.env.EXE_WIKI_API_URL;
+  const apiKey = config.wikiApiKey || process.env.EXE_WIKI_API_KEY;
+  if (!apiUrl || !apiKey) {
+    return { updated: false };
+  }
+  const workspace = config.wikiWorkspaceMapping[consolidation.projectName] ?? consolidation.projectName;
+  try {
+    const listRes = await fetch(
+      `${apiUrl}/v1/workspace/${encodeURIComponent(workspace)}/documents`,
+      {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: AbortSignal.timeout(WIKI_FETCH_TIMEOUT_MS)
+      }
+    );
+    if (!listRes.ok) {
+      return { updated: false, error: `Workspace "${workspace}" not accessible (${listRes.status})` };
+    }
+    const listJson = await listRes.json();
+    const docs = listJson.documents ?? listJson.localFiles?.items ?? [];
+    const contentLines = consolidation.rawText.split("\n").filter((l) => l.trim() && !l.startsWith("CONSOLIDATION") && !l.match(/^[A-Z\s]+:$/)).join(" ");
+    const keywords = contentLines.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3);
+    let bestMatch = null;
+    for (const doc of docs) {
+      if (!doc.id || !doc.title) continue;
+      const titleWords = doc.title.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3);
+      if (titleWords.length === 0) continue;
+      const matchCount = titleWords.filter(
+        (tw) => keywords.some((k) => k.includes(tw) || tw.includes(k))
+      ).length;
+      const score = matchCount / titleWords.length;
+      if (score > (bestMatch?.score ?? 0)) {
+        bestMatch = { id: doc.id, title: doc.title, score };
+      }
+    }
+    if (bestMatch && bestMatch.score >= config.wikiAutoUpdateThreshold) {
+      const updateRes = await fetch(`${apiUrl}/v1/document/raw-text`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          textContent: consolidation.rawText,
+          metadata: { title: bestMatch.title, appendTo: bestMatch.id },
+          workspaceSlugs: [workspace]
+        }),
+        signal: AbortSignal.timeout(WIKI_FETCH_TIMEOUT_MS)
+      });
+      if (updateRes.ok) {
+        process.stderr.write(
+          `[consolidation] Wiki auto-updated: ${workspace}/${bestMatch.title}
+`
+        );
+        return { updated: true, action: "updated", page: bestMatch.title };
+      }
+      return { updated: false, error: `Update failed (${updateRes.status})` };
+    }
+    if (config.wikiAutoUpdateCreateNew) {
+      const title = `Consolidated Insights \u2014 ${consolidation.projectName} (${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)})`;
+      const createRes = await fetch(`${apiUrl}/v1/document/raw-text`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          textContent: consolidation.rawText,
+          metadata: { title },
+          workspaceSlugs: [workspace]
+        }),
+        signal: AbortSignal.timeout(WIKI_FETCH_TIMEOUT_MS)
+      });
+      if (createRes.ok) {
+        process.stderr.write(
+          `[consolidation] Wiki page created: ${workspace}/${title}
+`
+        );
+        return { updated: true, action: "created", page: title };
+      }
+      return { updated: false, error: `Create failed (${createRes.status})` };
+    }
+    return { updated: false };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[consolidation] Wiki push failed: ${msg}
+`);
+    return { updated: false, error: msg };
+  }
+}
+async function runConsolidation(client, options) {
+  const memories = await selectUnconsolidated(client);
+  if (memories.length < 20) {
+    return { clustersProcessed: 0, memoriesConsolidated: 0 };
+  }
+  const roleMap = {};
+  try {
+    const { loadEmployeesSync } = await import("./lib/employees.js");
+    const employees = loadEmployeesSync();
+    for (const e of employees) {
+      roleMap[e.name] = e.role;
+    }
+  } catch {
+  }
+  const clusters = groupMemories(memories);
+  let clustersProcessed = 0;
+  let memoriesConsolidated = 0;
+  for (const cluster of clusters) {
+    if (clustersProcessed >= options.maxCalls) break;
+    if (cluster.memories.length < 3) continue;
+    try {
+      const isCoordinator = isCoordinatorName(cluster.agentId);
+      const agentRole = roleMap[cluster.agentId];
+      const dedupCount = await dedupCluster(client, cluster, options.embedFn);
+      memoriesConsolidated += dedupCount;
+      const synthesis = await consolidateCluster(cluster, options.model, agentRole);
+      if (!synthesis.trim()) {
+        if (dedupCount > 0) clustersProcessed++;
+        continue;
+      }
+      const result = await storeConsolidation(client, cluster, synthesis, options.embedFn);
+      if (isCoordinator && options.wikiConfig) {
+        await pushToWiki(
+          { ...result, projectName: cluster.projectName },
+          options.wikiConfig
+        ).catch((err) => {
+          process.stderr.write(
+            `[consolidation] Wiki push error (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        });
+      }
+      if (isCoordinator) {
+        const sourceIds = result.sourceIds;
+        if (sourceIds.length > 0) {
+          const placeholders = sourceIds.map(() => "?").join(",");
+          await client.execute({
+            sql: `UPDATE memories SET status = 'archived' WHERE id IN (${placeholders})`,
+            args: sourceIds
+          });
+        }
+      }
+      clustersProcessed++;
+      memoriesConsolidated += cluster.memories.length;
+    } catch (err) {
+      process.stderr.write(
+        `[consolidation] Cluster failed (${cluster.projectName}/${cluster.dateRange}): ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return { clustersProcessed, memoriesConsolidated };
+}
+async function dedupCluster(client, cluster, embedFn) {
+  if (!embedFn || cluster.memories.length < 2) return 0;
+  const vectors = [];
+  for (const mem of cluster.memories) {
+    try {
+      const v = await embedFn(mem.raw_text);
+      vectors.push({ id: mem.id, vector: v });
+    } catch {
+    }
+  }
+  if (vectors.length < 2) return 0;
+  const toArchive = /* @__PURE__ */ new Set();
+  for (let i = 0; i < vectors.length; i++) {
+    if (toArchive.has(vectors[i].id)) continue;
+    for (let j = i + 1; j < vectors.length; j++) {
+      if (toArchive.has(vectors[j].id)) continue;
+      const sim = cosineSimilarity(vectors[i].vector, vectors[j].vector);
+      if (sim > 0.95) {
+        toArchive.add(vectors[j].id);
+      }
+    }
+  }
+  if (toArchive.size === 0) return 0;
+  const ids = [...toArchive];
+  const placeholders = ids.map(() => "?").join(",");
+  await client.execute({
+    sql: `UPDATE memories SET status = 'archived', consolidated = 1 WHERE id IN (${placeholders})`,
+    args: ids
+  });
+  const survivors = vectors.filter((v) => !toArchive.has(v.id)).map((v) => v.id);
+  if (survivors.length > 0) {
+    const survivorPlaceholders = survivors.map(() => "?").join(",");
+    await client.execute({
+      sql: `UPDATE memories SET confidence = MIN(1.0, COALESCE(confidence, 0.7) + 0.1) WHERE id IN (${survivorPlaceholders})`,
+      args: survivors
+    });
+  }
+  return ids.length;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+async function isUserIdle(client, idleMinutes = 30) {
+  const result = await client.execute({
+    sql: `SELECT MAX(timestamp) as last_activity
+          FROM memories
+          WHERE tool_name != 'consolidation'
+            AND timestamp >= datetime('now', '-1 day')`,
+    args: []
+  });
+  const lastActivity = result.rows[0]?.last_activity;
+  if (!lastActivity) return true;
+  const lastMs = new Date(lastActivity).getTime();
+  const now = Date.now();
+  return now - lastMs >= idleMinutes * 60 * 1e3;
+}
+async function countUnconsolidated(client) {
+  const result = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM memories
+          WHERE consolidated = 0
+            AND COALESCE(memory_type, 'raw') != 'procedure'`,
+    args: []
+  });
+  return Number(result.rows[0]?.cnt ?? 0);
+}
+var INTERCOM_NOISE_PATTERNS = [
+  /^\/exe-intercom\b/i,
+  /^You have pending notifications\.\s*Run list_tasks/i,
+  /^You have open tasks\.\s*Run list_tasks/i,
+  /^You have a new P\d+ task/i,
+  /^You have more open tasks to dispatch/i,
+  /^No new tasks\.\s*(Standing by|Idle|Dashboard)/i,
+  /^You have pending tasks\.\s*Start your/i
+];
+async function deduplicateIntercomMemories(client) {
+  const noiseResult = await client.execute({
+    sql: `SELECT id, raw_text FROM memories
+          WHERE COALESCE(status, 'active') = 'active'
+            AND (
+              raw_text LIKE '/exe-intercom%'
+              OR raw_text LIKE 'You have pending notifications.%'
+              OR raw_text LIKE 'You have open tasks.%'
+              OR raw_text LIKE 'You have a new P_ task%'
+              OR raw_text LIKE 'You have more open tasks to dispatch%'
+              OR raw_text LIKE 'No new tasks.%'
+              OR raw_text LIKE 'You have pending tasks.%'
+            )`,
+    args: []
+  });
+  const toArchive = [];
+  for (const row of noiseResult.rows) {
+    const text = row.raw_text.trim();
+    if (INTERCOM_NOISE_PATTERNS.some((p) => p.test(text))) {
+      toArchive.push(row.id);
+    }
+  }
+  if (toArchive.length === 0) return 0;
+  const BATCH = 500;
+  for (let i = 0; i < toArchive.length; i += BATCH) {
+    const batch = toArchive.slice(i, i + BATCH);
+    const placeholders = batch.map(() => "?").join(",");
+    await client.execute({
+      sql: `UPDATE memories SET status = 'archived'
+            WHERE id IN (${placeholders})
+              AND COALESCE(status, 'active') = 'active'`,
+      args: batch
+    });
+  }
+  return toArchive.length;
+}
+var TRACE_TOOLS = ["Bash", "Read", "Edit", "Grep", "Write", "Glob", "apply_patch"];
+async function sweepExpiredTraces(client) {
+  const placeholders = TRACE_TOOLS.map(() => "?").join(",");
+  const idsResult = await client.execute({
+    sql: `SELECT id FROM memories
+          WHERE tool_name IN (${placeholders})
+            AND COALESCE(memory_type, 'raw') = 'raw'
+            AND timestamp < datetime('now', '-7 days')
+            AND COALESCE(importance, 0) < 7`,
+    args: TRACE_TOOLS
+  });
+  const memoryIds = idsResult.rows.map((r) => String(r.id)).filter(Boolean);
+  if (memoryIds.length > 0) {
+    await cleanupGraphLinksForMemories(client, memoryIds);
+  }
+  const result = await client.execute({
+    sql: `DELETE FROM memories
+          WHERE tool_name IN (${placeholders})
+            AND COALESCE(memory_type, 'raw') = 'raw'
+            AND timestamp < datetime('now', '-7 days')
+            AND COALESCE(importance, 0) < 7`,
+    args: TRACE_TOOLS
+  });
+  return result.rowsAffected;
+}
+
+export {
+  selectUnconsolidated,
+  groupMemories,
+  buildConsolidationPrompt,
+  consolidateCluster,
+  storeConsolidation,
+  pushToWiki,
+  runConsolidation,
+  isUserIdle,
+  countUnconsolidated,
+  deduplicateIntercomMemories,
+  sweepExpiredTraces
+};