@askexenow/exe-os 0.9.289 → 0.9.290

package/dist/chunk-ZYEOHGU5.js

@@ -0,0 +1,362 @@
+import {
+  recordSessionKill
+} from "./chunk-SL6WJP2Q.js";
+import {
+  sessionScopeFilter,
+  verifyPaneAtCapacity,
+  writeNotification
+} from "./chunk-6TLURATK.js";
+import {
+  listSessions
+} from "./chunk-QKDRYZ2N.js";
+import {
+  getTransport
+} from "./chunk-MVW62NIZ.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-6IPJF5QD.js";
+import {
+  getClient,
+  isCoordinatorName
+} from "./chunk-DBQ6I6K2.js";
+
+// src/lib/capacity-monitor.ts
+var CAPACITY_PATTERNS = [
+  /conversation is too long/i,
+  /maximum context length/i,
+  /context window.*(?:limit|exceed|full)/i,
+  /reached.*(?:token|context).*limit/i
+];
+var CONTENT_LINE_PREFIX = /^[\s>#\-*[]/;
+var CONTENT_LINE_MARKERS = [
+  "RESUME:",
+  "intercom",
+  "capacity-monitor",
+  "CAPACITY_PATTERNS",
+  "isAtCapacity",
+  "CONTENT_LINE_MARKERS",
+  "pollCapacityDead",
+  "confirmCapacityKill",
+  "session_kills",
+  "capacity-monitor.test"
+];
+var SOURCE_CODE_MARKERS = [
+  /["'`/].*(?:maximum context length|conversation is too long)/i,
+  /(?:maximum context length|conversation is too long).*["'`/]/i
+];
+var RELAUNCH_COOLDOWN_MS = 5 * 60 * 1e3;
+var _lastRelaunch = /* @__PURE__ */ new Map();
+var RESUME_TITLE_PREFIX = "RESUME:";
+var RESUME_TITLE_LIKE_PATTERN = `${RESUME_TITLE_PREFIX} % hit context capacity%`;
+var RESUME_ACTIVE_STATUSES = ["open", "in_progress"];
+function resumeTaskTitle(agentId) {
+  return `${RESUME_TITLE_PREFIX} ${agentId} hit context capacity \u2014 continue open tasks`;
+}
+function buildResumeContext(agentId, openTasks) {
+  const taskList = openTasks.map(
+    (r, i) => `${i + 1}. [${String(r.priority).toUpperCase()}] ${String(r.title)} (${String(r.task_file)})`
+  ).join("\n");
+  return [
+    "## Context",
+    "",
+    `${agentId} hit context capacity and was auto-relaunched by the capacity monitor.`,
+    "Call recall_my_memory first \u2014 search for 'CONTEXT CHECKPOINT'. Pick up where the previous session stopped.",
+    "",
+    `You have ${openTasks.length} open task(s). Work through them in priority order:`,
+    "",
+    taskList,
+    "",
+    "Read each task file and chain through them. Build and commit after each one."
+  ].join("\n");
+}
+var CONFIRMATION_WINDOW_MS = 3 * 60 * 1e3;
+var _pendingCapacityKill = /* @__PURE__ */ new Map();
+function filterPaneContent(paneOutput) {
+  return paneOutput.split("\n").filter((line) => {
+    if (CONTENT_LINE_PREFIX.test(line)) return false;
+    for (const marker of CONTENT_LINE_MARKERS) {
+      if (line.includes(marker)) return false;
+    }
+    for (const re of SOURCE_CODE_MARKERS) {
+      if (re.test(line)) return false;
+    }
+    return true;
+  }).join("\n");
+}
+var CC_CONTEXT_BAR_RE = /([\u2588\u2591\u2592\u2593]{10})\s+(\d+)%/;
+var CTX_FLOOR_PERCENT = 50;
+function extractContextPercent(paneOutput) {
+  const match = paneOutput.match(CC_CONTEXT_BAR_RE);
+  if (!match) return null;
+  const parsed = Number.parseInt(match[2], 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isAtCapacity(paneOutput) {
+  const filtered = filterPaneContent(paneOutput);
+  return CAPACITY_PATTERNS.some((p) => p.test(filtered));
+}
+function confirmCapacityKill(agentId, now = Date.now()) {
+  const pendingSince = _pendingCapacityKill.get(agentId);
+  if (pendingSince === void 0) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  if (now - pendingSince > CONFIRMATION_WINDOW_MS) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  _pendingCapacityKill.delete(agentId);
+  return true;
+}
+function _resetPendingCapacityKills() {
+  _pendingCapacityKill.clear();
+}
+function _resetLastRelaunchCache() {
+  _lastRelaunch.clear();
+}
+async function lastResumeCreatedAtMs(agentId, sessionScope) {
+  const client = getClient();
+  const cmScope = sessionScopeFilter(sessionScope ?? null);
+  const result = await client.execute({
+    sql: `SELECT MAX(created_at) AS last_created_at
+          FROM tasks
+          WHERE assigned_to = ? AND title LIKE ?${cmScope.sql}`,
+    args: [agentId, `${RESUME_TITLE_PREFIX} %`, ...cmScope.args]
+  });
+  const raw = result.rows[0]?.last_created_at;
+  if (raw === null || raw === void 0) return null;
+  const parsed = Date.parse(String(raw));
+  return Number.isNaN(parsed) ? null : parsed;
+}
+async function isWithinRelaunchCooldown(agentId, now = Date.now(), sessionScope) {
+  const cacheKey = sessionScope ? `${agentId}::${sessionScope}` : agentId;
+  const cached = _lastRelaunch.get(cacheKey);
+  if (cached !== void 0) return now - cached < RELAUNCH_COOLDOWN_MS;
+  const persisted = await lastResumeCreatedAtMs(agentId, sessionScope);
+  if (persisted === null) return false;
+  if (now - persisted >= RELAUNCH_COOLDOWN_MS) return false;
+  _lastRelaunch.set(cacheKey, persisted);
+  return true;
+}
+async function createOrRefreshResumeTask(agentId, projectDir, openTasks, sessionScope) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const context = buildResumeContext(agentId, openTasks);
+  const rdScope = sessionScopeFilter(sessionScope ?? null);
+  const existing = await client.execute({
+    sql: `SELECT id FROM tasks
+          WHERE assigned_to = ?
+            AND title LIKE ?
+            AND status IN (${RESUME_ACTIVE_STATUSES.map(() => "?").join(", ")})${rdScope.sql}
+          ORDER BY created_at DESC
+          LIMIT 1`,
+    args: [agentId, RESUME_TITLE_LIKE_PATTERN, ...RESUME_ACTIVE_STATUSES, ...rdScope.args]
+  });
+  if (existing.rows.length > 0) {
+    const taskId = String(existing.rows[0].id);
+    await client.execute({
+      sql: `UPDATE tasks SET context = ?, updated_at = ? WHERE id = ?`,
+      args: [context, now, taskId]
+    });
+    recordOrchestrationEventBestEffort({
+      eventType: "session.resumed",
+      source: "capacity-monitor.createOrRefreshResumeTask",
+      agentId,
+      taskId,
+      payload: { created: false, action: "refreshed" }
+    });
+    return { created: false, taskId };
+  }
+  try {
+    const staleResumes = await client.execute({
+      sql: `SELECT id FROM tasks
+            WHERE assigned_to = ?
+              AND title LIKE ?
+              AND status IN (${RESUME_ACTIVE_STATUSES.map(() => "?").join(", ")})`,
+      args: [agentId, RESUME_TITLE_LIKE_PATTERN, ...RESUME_ACTIVE_STATUSES]
+    });
+    for (const row of staleResumes.rows) {
+      await client.execute({
+        sql: `UPDATE tasks SET status = 'cancelled', result = ?, updated_at = ? WHERE id = ?`,
+        args: ["Auto-cancelled: superseded by new RESUME task.", now, String(row.id)]
+      });
+    }
+  } catch {
+  }
+  const { createTask } = await import("./lib/tasks.js");
+  const task = await createTask({
+    title: resumeTaskTitle(agentId),
+    assignedTo: agentId,
+    assignedBy: "system",
+    projectName: projectDir.split("/").pop() ?? "unknown",
+    priority: "p0",
+    context,
+    baseDir: projectDir
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "session.resumed",
+    source: "capacity-monitor.createOrRefreshResumeTask",
+    agentId,
+    taskId: task.id,
+    payload: { created: true, action: "created", openTaskCount: openTasks.length }
+  });
+  return { created: true, taskId: task.id };
+}
+async function pollCapacityDead() {
+  const transport = getTransport();
+  const relaunched = [];
+  const registered = listSessions();
+  if (registered.length === 0) return [];
+  let liveSessions;
+  try {
+    liveSessions = transport.listSessions();
+  } catch {
+    return [];
+  }
+  for (const entry of registered) {
+    const { windowName, agentId, projectDir } = entry;
+    if (!liveSessions.includes(windowName)) continue;
+    const cmDashIdx = windowName.indexOf("-");
+    const cmDerivedScope = cmDashIdx >= 0 ? windowName.slice(cmDashIdx + 1) : null;
+    if (await isWithinRelaunchCooldown(agentId, Date.now(), cmDerivedScope)) continue;
+    let pane;
+    try {
+      pane = transport.capturePane(windowName, 15);
+    } catch {
+      continue;
+    }
+    if (!isAtCapacity(pane)) continue;
+    const ctxPct = extractContextPercent(pane);
+    if (ctxPct !== null && ctxPct < CTX_FLOOR_PERCENT) {
+      process.stderr.write(
+        `[capacity-monitor] ctx-floor: ${agentId} at ${ctxPct}% in ${windowName} \u2014 below ${CTX_FLOOR_PERCENT}%. Skipping capacity kill (likely self-referential content or false positive).
+`
+      );
+      continue;
+    }
+    if (!confirmCapacityKill(agentId)) {
+      process.stderr.write(
+        `[capacity-monitor] ${agentId} matched capacity pattern once in ${windowName}. Awaiting confirmation on next tick.
+`
+      );
+      continue;
+    }
+    const verify = await verifyPaneAtCapacity(windowName);
+    if (!verify.atCapacity) {
+      process.stderr.write(
+        `[capacity-monitor] verifyPaneAtCapacity rejected kill for ${agentId} in ${windowName} (reason: ${verify.reason}). Skipping.
+`
+      );
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity_false_positive_blocked"
+      });
+      continue;
+    }
+    process.stderr.write(
+      `[capacity-monitor] Detected ${agentId} at capacity in session ${windowName} (confirmed). Auto-relaunching.
+`
+    );
+    if (isCoordinatorName(agentId)) {
+      try {
+        const { loadConfigSync } = await import("./lib/config.js");
+        const cfg = loadConfigSync();
+        if (cfg.sessionLifecycle.autoRelaunchCoordinator !== false) {
+          const fs = await import("fs");
+          const path = await import("path");
+          const os = await import("os");
+          const markerDir = path.join(os.homedir(), ".exe-os", "session-cache");
+          fs.mkdirSync(markerDir, { recursive: true });
+          const markerPath = path.join(markerDir, `relaunch-${windowName}.json`);
+          fs.writeFileSync(markerPath, JSON.stringify({
+            reason: "context_full",
+            agentId,
+            projectDir,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+          process.stderr.write(
+            `[capacity-monitor] Coordinator relaunch marker written: ${markerPath}
+`
+          );
+        }
+        transport.kill(windowName);
+        void recordSessionKill({ sessionName: windowName, agentId, reason: "capacity" });
+        const coordCacheKey = cmDerivedScope ? `${agentId}::${cmDerivedScope}` : agentId;
+        _lastRelaunch.set(coordCacheKey, Date.now());
+        relaunched.push(agentId);
+      } catch (err) {
+        process.stderr.write(
+          `[capacity-monitor] Coordinator relaunch marker write failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+      continue;
+    }
+    try {
+      transport.kill(windowName);
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity"
+      });
+      const client = getClient();
+      const dashIdx = windowName.indexOf("-");
+      const derivedScope = dashIdx >= 0 ? windowName.slice(dashIdx + 1) : null;
+      const rlScope = sessionScopeFilter(derivedScope);
+      const openTasks = await client.execute({
+        sql: `SELECT id, title, priority, task_file, status
+              FROM tasks
+              WHERE assigned_to = ? AND status IN ('open', 'in_progress')${rlScope.sql}
+              ORDER BY
+                CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 WHEN 'p2' THEN 2 ELSE 3 END,
+                created_at ASC
+              LIMIT 10`,
+        args: [agentId, ...rlScope.args]
+      });
+      if (openTasks.rows.length === 0) {
+        process.stderr.write(
+          `[capacity-monitor] ${agentId} has no open tasks \u2014 skipping relaunch.
+`
+        );
+        continue;
+      }
+      const { created } = await createOrRefreshResumeTask(
+        agentId,
+        projectDir,
+        openTasks.rows,
+        derivedScope
+      );
+      if (created) {
+        await writeNotification({
+          agentId: "system",
+          agentRole: "daemon",
+          event: "capacity_relaunch",
+          project: projectDir.split("/").pop() ?? "unknown",
+          summary: `${agentId} hit context capacity. Auto-relaunched with ${openTasks.rows.length} open task(s).`
+        });
+      }
+      const cacheKey = derivedScope ? `${agentId}::${derivedScope}` : agentId;
+      _lastRelaunch.set(cacheKey, Date.now());
+      if (created) relaunched.push(agentId);
+    } catch (err) {
+      process.stderr.write(
+        `[capacity-monitor] Failed to relaunch ${agentId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return relaunched;
+}
+
+export {
+  CTX_FLOOR_PERCENT,
+  extractContextPercent,
+  isAtCapacity,
+  confirmCapacityKill,
+  _resetPendingCapacityKills,
+  _resetLastRelaunchCache,
+  isWithinRelaunchCooldown,
+  createOrRefreshResumeTask,
+  pollCapacityDead
+};

package/dist/co-activation-WJTFJOTK.js

@@ -0,0 +1,73 @@
+import {
+  getClient
+} from "./chunk-DBQ6I6K2.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-XCPVYQVK.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-5P3HOBZX.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/co-activation.ts
+async function recordCoActivations(entityIds) {
+  if (entityIds.length < 2) return;
+  const unique = [...new Set(entityIds)].slice(0, 20);
+  const client = getClient();
+  const pairs = [];
+  for (let i = 0; i < unique.length; i++) {
+    for (let j = i + 1; j < unique.length; j++) {
+      const idI = unique[i];
+      const idJ = unique[j];
+      const pair = idI < idJ ? [idI, idJ] : [idJ, idI];
+      pairs.push(pair);
+    }
+  }
+  for (const [a, b] of pairs) {
+    await client.execute({
+      sql: `INSERT INTO co_activations (entity_a_id, entity_b_id, count, last_activated_at)
+            VALUES (?, ?, 1, datetime('now'))
+            ON CONFLICT (entity_a_id, entity_b_id)
+            DO UPDATE SET count = count + 1, last_activated_at = datetime('now')`,
+      args: [a, b]
+    });
+  }
+}
+async function getHotPairs(limit = 20) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT entity_a_id, entity_b_id, count, last_activated_at
+          FROM co_activations
+          ORDER BY count DESC
+          LIMIT ?`,
+    args: [limit]
+  });
+  return result.rows.map((r) => ({
+    entity_a_id: String(r.entity_a_id),
+    entity_b_id: String(r.entity_b_id),
+    count: Number(r.count),
+    last_activated_at: String(r.last_activated_at)
+  }));
+}
+async function getCoActivationNeighbors(entityId, limit = 20) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT entity_a_id, entity_b_id, count, last_activated_at
+          FROM co_activations
+          WHERE entity_a_id = ? OR entity_b_id = ?
+          ORDER BY count DESC
+          LIMIT ?`,
+    args: [entityId, entityId, limit]
+  });
+  return result.rows.map((r) => ({
+    entity_a_id: String(r.entity_a_id),
+    entity_b_id: String(r.entity_b_id),
+    count: Number(r.count),
+    last_activated_at: String(r.last_activated_at)
+  }));
+}
+export {
+  getCoActivationNeighbors,
+  getHotPairs,
+  recordCoActivations
+};

package/dist/co-occurrence-KFP6ZS7G.js

@@ -0,0 +1,94 @@
+import {
+  entityId,
+  normalizeEntityName
+} from "./chunk-KBNMVPDE.js";
+import "./chunk-GUMRIUI5.js";
+import "./chunk-I7AW4237.js";
+import {
+  getClient
+} from "./chunk-DBQ6I6K2.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-XCPVYQVK.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-5P3HOBZX.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/co-occurrence.ts
+var SPECIFICITY = {
+  file: 5,
+  function: 4,
+  error: 3,
+  tool: 2,
+  agent: 1,
+  project: 0
+};
+function getSpecificity(type) {
+  return SPECIFICITY[type] ?? 1;
+}
+function coOccurrenceId(entityId1, entityId2) {
+  const sorted = [entityId1, entityId2].sort();
+  return `cooccur:${sorted[0]}:${sorted[1]}`;
+}
+async function actualEntityId(name, type, fallbackId) {
+  try {
+    const result = await getClient().execute({
+      sql: "SELECT id FROM entities WHERE LOWER(name) = LOWER(?) AND type = ? LIMIT 1",
+      args: [name, type]
+    });
+    return result.rows[0]?.id ? String(result.rows[0].id) : fallbackId;
+  } catch {
+    return fallbackId;
+  }
+}
+async function createCoOccurrenceEdges(entities, _memoryId) {
+  if (entities.length < 2) return 0;
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = entities.filter((e) => {
+    const key = `${e.type.toLowerCase()}:${normalizeEntityName(e.name)}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const sorted = deduped.sort((a, b) => getSpecificity(b.type) - getSpecificity(a.type));
+  const MAX_PAIRS = 10;
+  const pairs = [];
+  for (let i = 0; i < sorted.length && pairs.length < MAX_PAIRS; i++) {
+    for (let j = i + 1; j < sorted.length && pairs.length < MAX_PAIRS; j++) {
+      pairs.push([sorted[i], sorted[j]]);
+    }
+  }
+  let created = 0;
+  for (const [a, b] of pairs) {
+    const aName = normalizeEntityName(a.name);
+    const bName = normalizeEntityName(b.name);
+    const aType = a.type.toLowerCase();
+    const bType = b.type.toLowerCase();
+    const aId = await actualEntityId(aName, aType, entityId(aName, aType));
+    const bId = await actualEntityId(bName, bType, entityId(bName, bType));
+    if (aId === bId) continue;
+    const relId = coOccurrenceId(aId, bId);
+    const sortedIds = [aId, bId].sort();
+    const sourceId = sortedIds[0];
+    const targetId = sortedIds[1];
+    try {
+      await client.execute({
+        sql: `INSERT INTO relationships (id, source_entity_id, target_entity_id, type, weight, timestamp, properties)
+              VALUES (?, ?, ?, 'co_occurs_with', 1.0, ?, '{}')
+              ON CONFLICT(source_entity_id, target_entity_id, type) DO UPDATE SET
+                weight = MIN(weight + 0.1, 10.0),
+                timestamp = ?`,
+        args: [relId, sourceId, targetId, now, now]
+      });
+      created++;
+    } catch {
+    }
+  }
+  return created;
+}
+export {
+  createCoOccurrenceEdges
+};

package/dist/core-memory-DBZJ72TV.js

@@ -0,0 +1,110 @@
+import "./chunk-MLKGABMK.js";
+
+// src/lib/core-memory.ts
+var MAX_CORE_ENTRIES = 10;
+var MAX_ENTRY_LENGTH = 500;
+var MAX_TOTAL_CHARS = 5e3;
+async function getCoreMemory(agentId) {
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT key, value, updated_at FROM core_memory
+            WHERE agent_id = ? ORDER BY key ASC`,
+      args: [agentId]
+    });
+    return result.rows.map((r) => ({
+      key: String(r.key),
+      value: String(r.value),
+      updatedAt: String(r.updated_at)
+    }));
+  } catch {
+    return [];
+  }
+}
+async function setCoreMemory(agentId, key, value) {
+  if (value.length > MAX_ENTRY_LENGTH) {
+    throw new Error(`Core memory value too long (${value.length}/${MAX_ENTRY_LENGTH} chars). Core memory is for key facts, not documents.`);
+  }
+  const { getClient } = await import("./lib/database.js");
+  const client = getClient();
+  const countResult = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM core_memory WHERE agent_id = ?`,
+    args: [agentId]
+  });
+  const count = Number(countResult.rows[0]?.cnt ?? 0);
+  const existing = await client.execute({
+    sql: `SELECT key FROM core_memory WHERE agent_id = ? AND key = ?`,
+    args: [agentId, key]
+  });
+  if (existing.rows.length === 0 && count >= MAX_CORE_ENTRIES) {
+    const oldest = await client.execute({
+      sql: `SELECT key, value, updated_at FROM core_memory
+            WHERE agent_id = ? ORDER BY updated_at ASC LIMIT 1`,
+      args: [agentId]
+    });
+    if (oldest.rows.length > 0) {
+      const oldKey = String(oldest.rows[0].key);
+      const oldValue = String(oldest.rows[0].value);
+      try {
+        const { randomUUID } = await import("crypto");
+        const { writeMemory } = await import("./lib/store.js");
+        await writeMemory({
+          id: randomUUID(),
+          agent_id: agentId,
+          agent_role: "core-demotion",
+          session_id: "core-memory-demotion",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          tool_name: "core_memory_demotion",
+          project_name: "exe-os",
+          has_error: false,
+          raw_text: `[Demoted from core memory] ${oldKey}: ${oldValue}`,
+          vector: null
+        });
+      } catch {
+      }
+      await client.execute({
+        sql: `DELETE FROM core_memory WHERE agent_id = ? AND key = ?`,
+        args: [agentId, oldKey]
+      });
+      process.stderr.write(`[core-memory] Auto-demoted "${oldKey}" to regular memory (core full at ${MAX_CORE_ENTRIES})
+`);
+    }
+  }
+  const sizeResult = await client.execute({
+    sql: `SELECT COALESCE(SUM(LENGTH(value)), 0) as total FROM core_memory WHERE agent_id = ? AND key != ?`,
+    args: [agentId, key]
+  });
+  const currentSize = Number(sizeResult.rows[0]?.total ?? 0);
+  if (currentSize + value.length > MAX_TOTAL_CHARS) {
+    throw new Error(`Core memory would exceed ${MAX_TOTAL_CHARS} char limit. Delete entries or shorten values.`);
+  }
+  await client.execute({
+    sql: `INSERT OR REPLACE INTO core_memory (agent_id, key, value, updated_at)
+          VALUES (?, ?, ?, ?)`,
+    args: [agentId, key, value, (/* @__PURE__ */ new Date()).toISOString()]
+  });
+}
+async function deleteCoreMemory(agentId, key) {
+  const { getClient } = await import("./lib/database.js");
+  const client = getClient();
+  const result = await client.execute({
+    sql: `DELETE FROM core_memory WHERE agent_id = ? AND key = ?`,
+    args: [agentId, key]
+  });
+  return (result.rowsAffected ?? 0) > 0;
+}
+function formatCoreMemoryBlock(entries) {
+  if (entries.length === 0) return null;
+  const lines = ["## Core Memory (always in context)", ""];
+  for (const e of entries) {
+    lines.push(`- **${e.key}:** ${e.value}`);
+  }
+  return lines.join("\n");
+}
+export {
+  deleteCoreMemory,
+  formatCoreMemoryBlock,
+  getCoreMemory,
+  setCoreMemory
+};

package/dist/crdt-sync-6DVGRMTV.js

@@ -0,0 +1,33 @@
+import {
+  _setStatePath,
+  applyRemoteUpdate,
+  destroyCrdtDoc,
+  getDiffUpdate,
+  getFullState,
+  getStateVector,
+  importExistingBehaviors,
+  importExistingMemories,
+  initCrdtDoc,
+  isCrdtSyncEnabled,
+  onUpdate,
+  readAllBehaviors,
+  readAllMemories,
+  rebuildFromDb
+} from "./chunk-BTDPLFGK.js";
+import "./chunk-MLKGABMK.js";
+export {
+  _setStatePath,
+  applyRemoteUpdate,
+  destroyCrdtDoc,
+  getDiffUpdate,
+  getFullState,
+  getStateVector,
+  importExistingBehaviors,
+  importExistingMemories,
+  initCrdtDoc,
+  isCrdtSyncEnabled,
+  onUpdate,
+  readAllBehaviors,
+  readAllMemories,
+  rebuildFromDb
+};

package/dist/crm-webhook-55T4Z6XJ.js

@@ -0,0 +1,10 @@
+import {
+  createCRMWebhookHandler,
+  parseTwentyWebhook
+} from "./chunk-Z772TGD2.js";
+import "./chunk-FI5Q6F5S.js";
+import "./chunk-MLKGABMK.js";
+export {
+  createCRMWebhookHandler,
+  parseTwentyWebhook
+};