@askexenow/exe-os 0.9.299 → 0.9.301

package/dist/chunk-ZP6T5K6I.js

@@ -0,0 +1,535 @@
+import {
+  cleanupGraphLinksForMemories
+} from "./chunk-6OAAN25C.js";
+import {
+  resolveAnthropicAuth
+} from "./chunk-EJIF4FNT.js";
+import {
+  vectorToBlob
+} from "./chunk-4Z3FWLOE.js";
+import {
+  extractKeywords,
+  keywordsToString
+} from "./chunk-CHCA3ZM2.js";
+import {
+  isCoordinatorName
+} from "./chunk-XABJRAUW.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.`;
+}
+var resolveAnthropicAuth2 = resolveAnthropicAuth;
+async function consolidateCluster(cluster, model, agentRole) {
+  const auth = resolveAnthropicAuth2();
+  if (!auth) {
+    throw new Error(
+      "Could not resolve authentication method for consolidation model: set ANTHROPIC_API_KEY (API key) or ANTHROPIC_AUTH_TOKEN (Claude subscription/OAuth) in the daemon environment."
+    );
+  }
+  const Anthropic = (await import("@anthropic-ai/sdk")).default;
+  const client = new Anthropic(auth);
+  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) {
+  if (!resolveAnthropicAuth2()) {
+    throw new Error(
+      "[consolidation] No Anthropic credentials resolvable (ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN). Consolidation/dreaming layer cannot run. Skipping run."
+    );
+  }
+  const memories = await selectUnconsolidated(client);
+  if (memories.length < 20) {
+    return { clustersProcessed: 0, memoriesConsolidated: 0, clustersFailed: 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;
+  let clustersFailed = 0;
+  let attemptedSynthesis = 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;
+      attemptedSynthesis++;
+      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) {
+      clustersFailed++;
+      process.stderr.write(
+        `[consolidation] Cluster failed (${cluster.projectName}/${cluster.dateRange}): ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  if (attemptedSynthesis > 0 && clustersFailed >= attemptedSynthesis) {
+    throw new Error(
+      `[consolidation] All ${clustersFailed} synthesis cluster(s) failed \u2014 consolidation is non-functional. Check ANTHROPIC_API_KEY/ANTHROPIC_AUTH_TOKEN and consolidationModel (${options.model}).`
+    );
+  }
+  return { clustersProcessed, memoriesConsolidated, clustersFailed };
+}
+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,
+  resolveAnthropicAuth2 as resolveAnthropicAuth,
+  consolidateCluster,
+  storeConsolidation,
+  pushToWiki,
+  runConsolidation,
+  isUserIdle,
+  countUnconsolidated,
+  deduplicateIntercomMemories,
+  sweepExpiredTraces
+};

package/dist/chunk-ZR6ZJT32.js

@@ -0,0 +1,123 @@
+import {
+  getClient
+} from "./chunk-XABJRAUW.js";
+
+// src/lib/session-kill-telemetry.ts
+import crypto from "crypto";
+import { appendFileSync } from "fs";
+import path from "path";
+import os from "os";
+var KILL_FILE_LOG = path.join(os.homedir(), ".exe-os", "logs", "session-kills.jsonl");
+var TOKENS_PER_IDLE_MINUTE = 50;
+async function recordSessionKill(input) {
+  const killedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const id = crypto.randomUUID();
+  try {
+    const logEntry = JSON.stringify({
+      id,
+      timestamp: killedAt,
+      session: input.sessionName,
+      agent: input.agentId,
+      reason: input.reason,
+      ticksIdle: input.ticksIdle ?? null,
+      tokensSaved: input.estimatedTokensSaved ?? null
+    });
+    appendFileSync(KILL_FILE_LOG, logEntry + "\n");
+  } catch {
+    process.stderr.write(
+      `[session-kill-telemetry] file log write failed for ${input.sessionName}
+`
+    );
+  }
+  try {
+    const client = getClient();
+    await client.execute({
+      sql: `INSERT INTO session_kills
+              (id, session_name, agent_id, killed_at, reason,
+               ticks_idle, estimated_tokens_saved)
+            VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        id,
+        input.sessionName,
+        input.agentId,
+        killedAt,
+        input.reason,
+        input.ticksIdle ?? null,
+        input.estimatedTokensSaved ?? null
+      ]
+    });
+  } catch (err) {
+    process.stderr.write(
+      `[session-kill-telemetry] DB write failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+async function countKillsSince(sinceISO) {
+  try {
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT COUNT(*) AS n FROM session_kills WHERE killed_at >= ?`,
+      args: [sinceISO]
+    });
+    const row = result.rows[0];
+    return row ? Number(row.n) : 0;
+  } catch {
+    return 0;
+  }
+}
+var IDLE_KILL_STREAK_META_KEY = "idle_kill_suspect_streak";
+var IDLE_KILL_SUSPECT_DAY_THRESHOLD = 3;
+var IDLE_KILL_MIN_LIVE_SESSIONS = 5;
+function parseStreakState(raw) {
+  if (!raw) return { lastDate: null, streak: 0 };
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      lastDate: typeof parsed.lastDate === "string" ? parsed.lastDate : null,
+      streak: typeof parsed.streak === "number" ? parsed.streak : 0
+    };
+  } catch {
+    return { lastDate: null, streak: 0 };
+  }
+}
+function nextStreakState(prev, qualifiesToday, todayDate) {
+  if (!qualifiesToday) return { lastDate: todayDate, streak: 0 };
+  if (prev.lastDate === todayDate) return prev;
+  return { lastDate: todayDate, streak: prev.streak + 1 };
+}
+function computeIdleKillSuspectStreak(prev, killsToday, liveSessions, todayDate) {
+  const qualifies = killsToday === 0 && liveSessions >= IDLE_KILL_MIN_LIVE_SESSIONS;
+  const state = nextStreakState(prev, qualifies, todayDate);
+  return {
+    state,
+    suspect: state.streak >= IDLE_KILL_SUSPECT_DAY_THRESHOLD
+  };
+}
+async function sumTokensSavedSince(sinceISO) {
+  try {
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT COALESCE(SUM(estimated_tokens_saved), 0) AS total
+            FROM session_kills
+            WHERE killed_at >= ?`,
+      args: [sinceISO]
+    });
+    const row = result.rows[0];
+    return row ? Number(row.total) : 0;
+  } catch {
+    return 0;
+  }
+}
+
+export {
+  TOKENS_PER_IDLE_MINUTE,
+  recordSessionKill,
+  countKillsSince,
+  IDLE_KILL_STREAK_META_KEY,
+  IDLE_KILL_SUSPECT_DAY_THRESHOLD,
+  IDLE_KILL_MIN_LIVE_SESSIONS,
+  parseStreakState,
+  computeIdleKillSuspectStreak,
+  sumTokensSavedSince
+};