@askexenow/exe-os 0.9.270 → 0.9.272

package/dist/memory-cards-IPULSQFA.js

@@ -0,0 +1,174 @@
+import {
+  getClient
+} from "./chunk-CHBHR5W6.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-C6OYEJJI.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-VXIMSRTO.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/memory-cards.ts
+import { createHash } from "crypto";
+var MAX_CARDS_PER_MEMORY = 8;
+var MAX_SEGMENT_CHARS = 500;
+var MIN_SEGMENT_CHARS = 20;
+function stableId(memoryId, type, content) {
+  return createHash("sha256").update(`${memoryId}:${type}:${content}`).digest("hex").slice(0, 32);
+}
+function cleanText(text) {
+  let cleaned = text.replace(
+    /```(\w*)\n(.*?)(?:\n[\s\S]*?)```/g,
+    (_m, lang, firstLine) => `[code${lang ? `:${lang}` : ""}] ${firstLine.trim()}`
+  );
+  cleaned = cleaned.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  return cleaned;
+}
+function splitSegments(text) {
+  const cleaned = cleanText(text);
+  const segments = cleaned.split(/(?<=[.!?:;])\s+|\n{2,}|(?<=\))\s+(?=[A-Z])|\s*[|│]\s*/).map((s) => s.trim()).filter((s) => s.length >= MIN_SEGMENT_CHARS && s.length <= MAX_SEGMENT_CHARS);
+  if (segments.length === 0 && cleaned.length >= MIN_SEGMENT_CHARS) {
+    const lines = cleaned.split(/\n+/).map((l) => l.trim()).filter((l) => l.length >= MIN_SEGMENT_CHARS && l.length <= MAX_SEGMENT_CHARS);
+    if (lines.length > 0) return lines;
+    if (cleaned.length >= MIN_SEGMENT_CHARS) {
+      return [cleaned.slice(0, MAX_SEGMENT_CHARS)];
+    }
+  }
+  return segments;
+}
+function inferCardType(sentence, toolName) {
+  const lower = sentence.toLowerCase();
+  if (toolName === "store_decision" || /\b(decided|decision|adr|approved|rejected)\b/.test(lower)) return "decision";
+  if (/\b(prefers|preference|likes|dislikes|wants|doesn't want|does not want)\b/.test(lower)) return "preference";
+  if (/\b(changed|updated|replaced|now|no longer|instead|supersedes)\b/.test(lower)) return "belief_update";
+  if (toolName && ["Read", "Write", "Edit", "Bash"].includes(toolName)) return "code";
+  if (/\b(meeting|deadline|shipped|launched|completed|failed|blocked|assigned|created)\b/.test(lower)) return "event";
+  return "fact";
+}
+function extractSubject(sentence, agentId) {
+  const explicit = sentence.match(/\b([A-Z][a-zA-Z0-9_-]{2,}(?:\s+[A-Z][a-zA-Z0-9_-]{2,})?)\b/);
+  return explicit?.[1] ?? agentId;
+}
+function predicateFor(type) {
+  switch (type) {
+    case "preference":
+      return "prefers";
+    case "belief_update":
+      return "updated";
+    case "decision":
+      return "decided";
+    case "event":
+      return "happened";
+    case "code":
+      return "implemented";
+    default:
+      return "states";
+  }
+}
+function extractMemoryCards(row) {
+  const segments = splitSegments(row.raw_text);
+  const cards = [];
+  for (const sentence of segments) {
+    const type = inferCardType(sentence, row.tool_name);
+    const subject = extractSubject(sentence, row.agent_id);
+    const content = sentence.length > MAX_SEGMENT_CHARS ? `${sentence.slice(0, MAX_SEGMENT_CHARS - 1)}\u2026` : sentence;
+    cards.push({
+      id: stableId(row.id, type, content),
+      memory_id: row.id,
+      agent_id: row.agent_id,
+      session_id: row.session_id,
+      project_name: row.project_name ?? null,
+      timestamp: row.timestamp,
+      card_type: type,
+      subject,
+      predicate: predicateFor(type),
+      object: content,
+      content,
+      source_ref: row.id,
+      confidence: type === "fact" ? 0.55 : 0.65
+    });
+    if (cards.length >= MAX_CARDS_PER_MEMORY) break;
+  }
+  return cards;
+}
+async function insertMemoryCardsForBatch(rows) {
+  const cards = rows.flatMap(extractMemoryCards);
+  if (cards.length === 0) return 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  const stmts = cards.map((card) => ({
+    sql: `INSERT OR IGNORE INTO memory_cards
+          (id, memory_id, agent_id, session_id, project_name, timestamp, card_type,
+           subject, predicate, object, content, source_ref, confidence, active, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)`,
+    args: [
+      card.id,
+      card.memory_id,
+      card.agent_id,
+      card.session_id,
+      card.project_name,
+      card.timestamp,
+      card.card_type,
+      card.subject,
+      card.predicate,
+      card.object,
+      card.content,
+      card.source_ref,
+      card.confidence,
+      now
+    ]
+  }));
+  await client.batch(stmts, "write");
+  return cards.length;
+}
+function buildMatchExpr(queryText) {
+  const terms = queryText.toLowerCase().split(/\s+/).filter((t) => t.length >= 3).map((t) => t.replace(/[^a-z0-9_]/g, "")).filter((t) => t.length >= 3).slice(0, 12);
+  if (terms.length === 0) return null;
+  return terms.map((t) => `${t}*`).join(terms.length >= 3 ? " AND " : " OR ");
+}
+async function searchMemoryCards(queryText, agentId, options) {
+  const limit = options?.limit ?? 10;
+  const matchExpr = buildMatchExpr(queryText);
+  if (!matchExpr) return [];
+  let sql = `SELECT c.id, c.memory_id, c.agent_id, c.session_id, c.project_name,
+                    c.timestamp, c.card_type, c.content, c.source_ref, c.confidence
+             FROM memory_cards c
+             JOIN memory_cards_fts fts ON c.rowid = fts.rowid
+             WHERE memory_cards_fts MATCH ?
+               AND c.agent_id = ?
+               AND COALESCE(c.active, 1) = 1`;
+  const args = [matchExpr, agentId];
+  if (options?.projectName) {
+    sql += ` AND c.project_name = ?`;
+    args.push(options.projectName);
+  }
+  if (options?.since) {
+    sql += ` AND c.timestamp >= ?`;
+    args.push(options.since);
+  }
+  sql += ` ORDER BY rank LIMIT ?`;
+  args.push(limit);
+  const result = await getClient().execute({ sql, args });
+  return result.rows.map((row) => ({
+    id: `card:${String(row.id)}`,
+    agent_id: String(row.agent_id),
+    agent_role: "memory_card",
+    session_id: String(row.session_id),
+    timestamp: String(row.timestamp),
+    tool_name: `memory_card:${String(row.card_type)}`,
+    project_name: row.project_name == null ? "" : String(row.project_name),
+    has_error: false,
+    raw_text: `[${String(row.card_type)}] ${String(row.content)}
+Source memory: ${String(row.source_ref ?? row.memory_id)}`,
+    vector: [],
+    importance: 6,
+    status: "active",
+    confidence: Number(row.confidence ?? 0.6),
+    last_accessed: String(row.timestamp)
+  }));
+}
+export {
+  extractMemoryCards,
+  insertMemoryCardsForBatch,
+  searchMemoryCards
+};

package/dist/memory-graph-extractor-3TZZOKHY.js

@@ -0,0 +1,17 @@
+import {
+  extractGraphForBatch,
+  extractMemoryGraph,
+  upsertMemoryGraph
+} from "./chunk-X2WBH2IO.js";
+import "./chunk-CHBHR5W6.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-C6OYEJJI.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-VXIMSRTO.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  extractGraphForBatch,
+  extractMemoryGraph,
+  upsertMemoryGraph
+};

package/dist/memory-poisoning-defense-SGUGR5YJ.js

@@ -0,0 +1,225 @@
+import {
+  getClient
+} from "./chunk-CHBHR5W6.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-C6OYEJJI.js";
+import "./chunk-FXU7JOXK.js";
+import {
+  loadConfig
+} from "./chunk-VXIMSRTO.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/memory-poisoning-defense.ts
+var SYSTEM_TOOLS = /* @__PURE__ */ new Set([
+  "session-start",
+  "ingest",
+  "ingest-worker",
+  "consolidation",
+  "skill-learning",
+  "summary-worker",
+  "bug-report-worker",
+  "reflection",
+  "dreaming-engine",
+  "daemon"
+]);
+function computeTrustLevel(toolName, agentId) {
+  if (SYSTEM_TOOLS.has(toolName)) return "system";
+  if (agentId && (toolName.startsWith("mcp__exe") || toolName === "manual" || toolName === "store_memory")) {
+    return "agent";
+  }
+  if (toolName.includes("webhook") || toolName.includes("pipeline") || toolName.includes("ingest_raw")) {
+    return "external";
+  }
+  return "unknown";
+}
+function cosineDistance(a, b) {
+  if (a.length !== b.length || a.length === 0) return 1;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denom === 0) return 1;
+  const similarity = dotProduct / denom;
+  return 1 - similarity;
+}
+async function getAgentCentroid(agentId, projectName) {
+  const client = getClient();
+  try {
+    const result = await client.execute({
+      sql: `SELECT centroid_vector FROM agent_centroids WHERE agent_id = ? AND project_name = ?`,
+      args: [agentId, projectName]
+    });
+    if (result.rows.length === 0 || !result.rows[0].centroid_vector) return null;
+    const blob = result.rows[0].centroid_vector;
+    if (blob instanceof ArrayBuffer || ArrayBuffer.isView(blob)) {
+      return Array.from(new Float32Array(blob instanceof ArrayBuffer ? blob : blob.buffer));
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function checkAnomaly(vector, agentId, projectName, threshold) {
+  const centroid = await getAgentCentroid(agentId, projectName);
+  if (!centroid) return { anomalous: false, distance: 0 };
+  const distance = cosineDistance(vector, centroid);
+  const effectiveThreshold = threshold ?? 0.85;
+  return { anomalous: distance > effectiveThreshold, distance };
+}
+async function refreshAgentCentroid(agentId, projectName, sampleSize = 100) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT vector FROM memories
+          WHERE agent_id = ? AND project_name = ? AND vector IS NOT NULL
+            AND status = 'active' AND quarantined = 0
+          ORDER BY timestamp DESC LIMIT ?`,
+    args: [agentId, projectName, sampleSize]
+  });
+  if (result.rows.length < 5) return;
+  let dim = 0;
+  const vectors = [];
+  for (const row of result.rows) {
+    const blob = row.vector;
+    if (blob instanceof ArrayBuffer || ArrayBuffer.isView(blob)) {
+      const arr = Array.from(new Float32Array(blob instanceof ArrayBuffer ? blob : blob.buffer));
+      if (arr.length > 0) {
+        dim = arr.length;
+        vectors.push(arr);
+      }
+    }
+  }
+  if (vectors.length < 5 || dim === 0) return;
+  const centroid = new Float32Array(dim);
+  for (const v of vectors) {
+    for (let i = 0; i < dim; i++) {
+      centroid[i] += v[i] / vectors.length;
+    }
+  }
+  const centroidBlob = Buffer.from(centroid.buffer);
+  await client.execute({
+    sql: `INSERT OR REPLACE INTO agent_centroids (agent_id, project_name, centroid_vector, sample_count, updated_at)
+          VALUES (?, ?, ?, ?, ?)`,
+    args: [agentId, projectName, centroidBlob, vectors.length, (/* @__PURE__ */ new Date()).toISOString()]
+  });
+}
+async function quarantineMemory(memoryId, reason) {
+  const client = getClient();
+  await client.execute({
+    sql: `UPDATE memories SET quarantined = 1, quarantine_reason = ? WHERE id = ?`,
+    args: [reason, memoryId]
+  });
+}
+async function approveQuarantined(memoryId) {
+  const client = getClient();
+  await client.execute({
+    sql: `UPDATE memories SET quarantined = 0, quarantine_reason = NULL WHERE id = ?`,
+    args: [memoryId]
+  });
+}
+async function rejectQuarantined(memoryId) {
+  const client = getClient();
+  await client.execute({
+    sql: `UPDATE memories SET status = 'archived', quarantine_reason = COALESCE(quarantine_reason, '') || ' [REJECTED]' WHERE id = ?`,
+    args: [memoryId]
+  });
+}
+async function listQuarantined(limit = 20) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, raw_text, quarantine_reason, timestamp
+          FROM memories
+          WHERE quarantined = 1 AND status = 'active'
+          ORDER BY timestamp DESC LIMIT ?`,
+    args: [limit]
+  });
+  return result.rows.map((r) => ({
+    id: String(r.id),
+    agentId: String(r.agent_id),
+    rawText: String(r.raw_text).slice(0, 200),
+    reason: String(r.quarantine_reason ?? "unknown"),
+    createdAt: String(r.timestamp)
+  }));
+}
+var _writeCounters = /* @__PURE__ */ new Map();
+var _sessionCounters = /* @__PURE__ */ new Map();
+function checkRateLimit(agentId, sessionId, limits) {
+  const perMinute = limits?.perMinute ?? 50;
+  const perSession = limits?.perSession ?? 5e3;
+  const now = Date.now();
+  const minuteKey = `${agentId}:minute`;
+  const minuteCounter = _writeCounters.get(minuteKey);
+  if (minuteCounter && now - minuteCounter.windowStart < 6e4) {
+    if (minuteCounter.count >= perMinute) {
+      return { allowed: false, reason: `Rate limit: ${perMinute}/minute exceeded for ${agentId}` };
+    }
+    minuteCounter.count++;
+  } else {
+    _writeCounters.set(minuteKey, { count: 1, windowStart: now });
+  }
+  const sessionCount = (_sessionCounters.get(sessionId) ?? 0) + 1;
+  _sessionCounters.set(sessionId, sessionCount);
+  if (sessionCount > perSession) {
+    return { allowed: false, reason: `Session limit: ${perSession} memories exceeded for session ${sessionId}` };
+  }
+  return { allowed: true };
+}
+function resetRateLimits() {
+  _writeCounters.clear();
+  _sessionCounters.clear();
+}
+async function checkMemoryPoisoning(opts) {
+  const config = await loadConfig();
+  const defenseConfig = config.poisoningDefense;
+  if (!defenseConfig?.enabled) {
+    return { passed: true, trustLevel: computeTrustLevel(opts.toolName, opts.agentId), quarantined: false };
+  }
+  const trustLevel = computeTrustLevel(opts.toolName, opts.agentId);
+  const rateCheck = checkRateLimit(opts.agentId, opts.sessionId, defenseConfig.rateLimits);
+  if (!rateCheck.allowed) {
+    await quarantineMemory(opts.memoryId, rateCheck.reason);
+    return { passed: false, trustLevel, quarantined: true, reason: rateCheck.reason };
+  }
+  if (opts.importance >= 8 && trustLevel !== "system") {
+    const highImpLimit = defenseConfig.rateLimits?.highImportance ?? 20;
+    const sessionHighImp = (_sessionCounters.get(`${opts.sessionId}:highimp`) ?? 0) + 1;
+    _sessionCounters.set(`${opts.sessionId}:highimp`, sessionHighImp);
+    if (sessionHighImp > highImpLimit) {
+      await quarantineMemory(opts.memoryId, `High-importance inflation: ${sessionHighImp} importance>=8 memories in session`);
+      return { passed: false, trustLevel, quarantined: true, reason: "importance inflation" };
+    }
+  }
+  if (opts.vector && opts.vector.length > 0) {
+    const threshold = defenseConfig.anomalyThreshold ?? 0.85;
+    const anomaly = await checkAnomaly(opts.vector, opts.agentId, opts.projectName, threshold);
+    if (anomaly.anomalous) {
+      await quarantineMemory(opts.memoryId, `Anomalous vector: distance ${anomaly.distance.toFixed(3)} > threshold ${threshold}`);
+      return {
+        passed: false,
+        trustLevel,
+        anomalyDistance: anomaly.distance,
+        quarantined: true,
+        reason: `anomaly distance ${anomaly.distance.toFixed(3)}`
+      };
+    }
+  }
+  return { passed: true, trustLevel, quarantined: false };
+}
+export {
+  approveQuarantined,
+  checkAnomaly,
+  checkMemoryPoisoning,
+  checkRateLimit,
+  computeTrustLevel,
+  getAgentCentroid,
+  listQuarantined,
+  quarantineMemory,
+  refreshAgentCentroid,
+  rejectQuarantined,
+  resetRateLimits
+};

package/dist/memory-reflection-H3WGCEM6.js

@@ -0,0 +1,238 @@
+import {
+  getClient
+} from "./chunk-CHBHR5W6.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-C6OYEJJI.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-VXIMSRTO.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/memory-reflection.ts
+var REFLECTION_SCHEMA = `
+CREATE TABLE IF NOT EXISTS memory_reflections (
+  id TEXT PRIMARY KEY,
+  agent_id TEXT NOT NULL,
+  project_name TEXT,
+  insight_type TEXT NOT NULL CHECK (insight_type IN ('pattern', 'contradiction', 'evolution', 'summary')),
+  subject TEXT NOT NULL,
+  content TEXT NOT NULL,
+  source_card_ids TEXT NOT NULL DEFAULT '[]',
+  confidence REAL NOT NULL DEFAULT 0.7,
+  active INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL,
+  expires_at TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_memory_reflections_agent
+  ON memory_reflections(agent_id, insight_type, created_at DESC);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS memory_reflections_fts USING fts5(
+  content, subject,
+  content=memory_reflections, content_rowid=rowid
+);
+
+CREATE TRIGGER IF NOT EXISTS memory_reflections_ai AFTER INSERT ON memory_reflections BEGIN
+  INSERT INTO memory_reflections_fts(rowid, content, subject)
+  VALUES (new.rowid, new.content, new.subject);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memory_reflections_ad AFTER DELETE ON memory_reflections BEGIN
+  INSERT INTO memory_reflections_fts(memory_reflections_fts, rowid, content, subject)
+  VALUES ('delete', old.rowid, old.content, old.subject);
+END;
+`;
+async function detectContradictions(agentId, projectName) {
+  const client = getClient();
+  const insights = [];
+  let sql = `SELECT subject, GROUP_CONCAT(id) as card_ids,
+                    GROUP_CONCAT(content, '|||') as contents,
+                    GROUP_CONCAT(timestamp) as timestamps,
+                    COUNT(*) as cnt
+             FROM memory_cards
+             WHERE agent_id = ? AND active = 1 AND subject IS NOT NULL`;
+  const args = [agentId];
+  if (projectName) {
+    sql += " AND project_name = ?";
+    args.push(projectName);
+  }
+  sql += " GROUP BY subject HAVING cnt >= 2 ORDER BY cnt DESC LIMIT 100";
+  const result = await client.execute({ sql, args });
+  for (const row of result.rows) {
+    const subject = row.subject;
+    const cardIds = row.card_ids.split(",");
+    const contents = row.contents.split("|||");
+    const timestamps = row.timestamps.split(",");
+    if (contents.length < 2) continue;
+    const unique = new Set(contents.map((c) => c.toLowerCase().trim()));
+    if (unique.size < 2) continue;
+    const pairs = contents.map((c, i) => ({ content: c, ts: timestamps[i], id: cardIds[i] }));
+    pairs.sort((a, b) => (a.ts ?? "").localeCompare(b.ts ?? ""));
+    const earliest = pairs[0];
+    const latest = pairs[pairs.length - 1];
+    if (earliest.content.toLowerCase().trim() === latest.content.toLowerCase().trim()) continue;
+    const insightContent = `${subject}: changed from "${earliest.content.slice(0, 100)}" to "${latest.content.slice(0, 100)}"`;
+    const id = `reflect-evol-${subject.slice(0, 20)}-${Date.now()}`.replace(/[^a-zA-Z0-9-]/g, "_");
+    insights.push({
+      id,
+      agent_id: agentId,
+      project_name: projectName ?? null,
+      insight_type: "evolution",
+      subject,
+      content: insightContent,
+      source_card_ids: cardIds.slice(0, 10),
+      confidence: 0.7,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return insights;
+}
+async function detectPatterns(agentId, projectName) {
+  const client = getClient();
+  const insights = [];
+  let sql = `SELECT subject, card_type, COUNT(DISTINCT session_id) as sessions,
+                    COUNT(*) as total, GROUP_CONCAT(id) as card_ids,
+                    GROUP_CONCAT(content, '|||') as sample_contents
+             FROM memory_cards
+             WHERE agent_id = ? AND active = 1 AND subject IS NOT NULL`;
+  const args = [agentId];
+  if (projectName) {
+    sql += " AND project_name = ?";
+    args.push(projectName);
+  }
+  sql += " GROUP BY subject, card_type HAVING sessions >= 3 ORDER BY sessions DESC LIMIT 50";
+  const result = await client.execute({ sql, args });
+  for (const row of result.rows) {
+    const subject = row.subject;
+    const cardType = row.card_type;
+    const sessions = Number(row.sessions);
+    const total = Number(row.total);
+    const cardIds = row.card_ids.split(",");
+    const samples = row.sample_contents.split("|||").slice(0, 3);
+    const insightContent = `${subject} appears in ${sessions} sessions (${total} mentions) as ${cardType}. Examples: ${samples.map((s) => `"${s.slice(0, 80)}"`).join("; ")}`;
+    const id = `reflect-pattern-${subject.slice(0, 20)}-${Date.now()}`.replace(/[^a-zA-Z0-9-]/g, "_");
+    insights.push({
+      id,
+      agent_id: agentId,
+      project_name: projectName ?? null,
+      insight_type: "pattern",
+      subject,
+      content: insightContent,
+      source_card_ids: cardIds.slice(0, 10),
+      confidence: Math.min(0.5 + sessions * 0.1, 0.95),
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return insights;
+}
+async function generateSummaries(agentId, projectName) {
+  const client = getClient();
+  const insights = [];
+  let sql = `SELECT subject, COUNT(*) as cnt, GROUP_CONCAT(id) as card_ids,
+                    GROUP_CONCAT(content, '|||') as all_contents,
+                    MIN(timestamp) as first_seen, MAX(timestamp) as last_seen
+             FROM memory_cards
+             WHERE agent_id = ? AND active = 1 AND subject IS NOT NULL`;
+  const args = [agentId];
+  if (projectName) {
+    sql += " AND project_name = ?";
+    args.push(projectName);
+  }
+  sql += " GROUP BY subject HAVING cnt >= 5 ORDER BY cnt DESC LIMIT 30";
+  const result = await client.execute({ sql, args });
+  for (const row of result.rows) {
+    const subject = row.subject;
+    const cnt = Number(row.cnt);
+    const cardIds = row.card_ids.split(",");
+    const allContents = (row.sample_contents ?? row.all_contents ?? "").split("|||");
+    const firstSeen = row.first_seen;
+    const lastSeen = row.last_seen;
+    const unique = [...new Set(allContents.map((c) => c.trim()))].filter((c) => c.length > 10).slice(0, 5);
+    if (unique.length < 2) continue;
+    const insightContent = `${subject} (${cnt} facts, ${firstSeen?.slice(0, 10)} to ${lastSeen?.slice(0, 10)}): ${unique.map((u) => u.slice(0, 80)).join(". ")}`;
+    const id = `reflect-summary-${subject.slice(0, 20)}-${Date.now()}`.replace(/[^a-zA-Z0-9-]/g, "_");
+    insights.push({
+      id,
+      agent_id: agentId,
+      project_name: projectName ?? null,
+      insight_type: "summary",
+      subject,
+      content: insightContent,
+      source_card_ids: cardIds.slice(0, 10),
+      confidence: 0.6,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return insights;
+}
+async function runReflection(agentId, projectName) {
+  const [contradictions, patterns, summaries] = await Promise.all([
+    detectContradictions(agentId, projectName),
+    detectPatterns(agentId, projectName),
+    generateSummaries(agentId, projectName)
+  ]);
+  const all = [...contradictions, ...patterns, ...summaries];
+  if (all.length === 0) return { contradictions: 0, patterns: 0, summaries: 0 };
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const stmts = all.map((insight) => ({
+    sql: `INSERT OR IGNORE INTO memory_reflections
+          (id, agent_id, project_name, insight_type, subject, content,
+           source_card_ids, confidence, active, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?)`,
+    args: [
+      insight.id,
+      insight.agent_id,
+      insight.project_name,
+      insight.insight_type,
+      insight.subject,
+      insight.content,
+      JSON.stringify(insight.source_card_ids),
+      insight.confidence,
+      now
+    ]
+  }));
+  await client.batch(stmts, "write");
+  return {
+    contradictions: contradictions.length,
+    patterns: patterns.length,
+    summaries: summaries.length
+  };
+}
+async function searchReflections(queryText, agentId, limit = 5) {
+  const terms = queryText.toLowerCase().split(/\s+/).filter((t) => t.length >= 3).map((t) => t.replace(/[^a-z0-9_]/g, "")).filter((t) => t.length >= 3).slice(0, 8);
+  if (terms.length === 0) return [];
+  const matchExpr = terms.map((t) => `${t}*`).join(terms.length >= 3 ? " AND " : " OR ");
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT r.id, r.agent_id, r.project_name, r.insight_type, r.subject,
+                 r.content, r.source_card_ids, r.confidence, r.created_at
+          FROM memory_reflections r
+          JOIN memory_reflections_fts fts ON r.rowid = fts.rowid
+          WHERE memory_reflections_fts MATCH ?
+            AND r.agent_id = ?
+            AND r.active = 1
+          ORDER BY rank
+          LIMIT ?`,
+    args: [matchExpr, agentId, limit]
+  });
+  return result.rows.map((row) => ({
+    id: row.id,
+    agent_id: row.agent_id,
+    project_name: row.project_name,
+    insight_type: row.insight_type,
+    subject: row.subject,
+    content: row.content,
+    source_card_ids: JSON.parse(row.source_card_ids ?? "[]"),
+    confidence: Number(row.confidence),
+    created_at: row.created_at
+  }));
+}
+export {
+  REFLECTION_SCHEMA,
+  detectContradictions,
+  detectPatterns,
+  generateSummaries,
+  runReflection,
+  searchReflections
+};

package/dist/notifications-VWPO6NJF.js

@@ -0,0 +1,45 @@
+import {
+  cleanupOldNotifications,
+  formatNotifications,
+  markAsRead,
+  markAsReadByTaskFile,
+  markDoneTaskNotificationsAsRead,
+  migrateJsonNotifications,
+  readUnreadNotifications,
+  writeNotification
+} from "./chunk-5AS622MM.js";
+import "./chunk-KZNSOHCB.js";
+import "./chunk-5CHYEKMH.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-OBUV3W7L.js";
+import "./chunk-MVW62NIZ.js";
+import "./chunk-OYNKIAVW.js";
+import "./chunk-CX6GL3ZJ.js";
+import "./chunk-2NQQP3FF.js";
+import "./chunk-EZ7KAZMC.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-WQEUY7DC.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-G33BHQCO.js";
+import "./chunk-HYZV25LY.js";
+import "./chunk-CHBHR5W6.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-C6OYEJJI.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-MOZ2YQ54.js";
+import "./chunk-VXIMSRTO.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  cleanupOldNotifications,
+  formatNotifications,
+  markAsRead,
+  markAsReadByTaskFile,
+  markDoneTaskNotificationsAsRead,
+  migrateJsonNotifications,
+  readUnreadNotifications,
+  writeNotification
+};