@askexenow/exe-os 0.9.272 → 0.9.274

package/dist/chunk-D24ANCWY.js

@@ -0,0 +1,204 @@
+import {
+  getClient
+} from "./chunk-CHBHR5W6.js";
+
+// src/lib/pipeline-router.ts
+import crypto from "crypto";
+async function sinkConversationStore(msg, agentResponse, agentName) {
+  try {
+    const client = getClient();
+    const id = crypto.randomUUID();
+    const mediaJson = msg.media ? JSON.stringify(msg.media) : null;
+    await client.execute({
+      sql: `INSERT INTO conversations
+            (id, platform, external_id, sender_id, sender_name, sender_phone, sender_email,
+             recipient_id, channel_id, thread_id, reply_to_id,
+             content_text, content_media, agent_response, agent_name,
+             timestamp, ingested_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        id,
+        msg.platform,
+        msg.messageId,
+        msg.senderId,
+        msg.senderName ?? null,
+        msg.senderPhone ?? null,
+        msg.senderEmail ?? null,
+        msg.accountId ?? null,
+        msg.channelId,
+        msg.threadId ?? `${msg.platform}:${msg.channelId}`,
+        msg.replyTo?.messageId ?? null,
+        msg.text ?? null,
+        mediaJson,
+        agentResponse ?? null,
+        agentName ?? null,
+        msg.timestamp,
+        (/* @__PURE__ */ new Date()).toISOString()
+      ]
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] conversation-store error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkMemory(msg, agentResponse, agentName) {
+  try {
+    const { embed } = await import("./lib/embedder.js");
+    const { writeMemory, flushBatch } = await import("./lib/store.js");
+    const direction = agentResponse ? "conversation" : "inbound";
+    const rawText = [
+      `[${msg.platform}] ${direction} from ${msg.senderName ?? msg.senderId}`,
+      msg.text ? `Message: ${msg.text}` : null,
+      agentResponse ? `Agent (${agentName ?? "unknown"}): ${agentResponse}` : null
+    ].filter(Boolean).join("\n");
+    const vector = await embed(rawText);
+    await writeMemory({
+      id: crypto.randomUUID(),
+      agent_id: agentName ?? "gateway",
+      agent_role: "gateway",
+      session_id: `gateway-${msg.platform}`,
+      timestamp: msg.timestamp,
+      tool_name: `gateway-${msg.platform}`,
+      project_name: "exe-os",
+      has_error: false,
+      raw_text: rawText,
+      vector,
+      importance: 4,
+      confidence: 0.8
+    });
+    await flushBatch();
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] memory-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkCRM(msg, agentResponse, agentName) {
+  try {
+    const { isCRMBridgeEnabled, pushConversationToCRM, pushInboundMessageToCRM } = await import("./crm-bridge-BVTB6LZK.js");
+    if (!isCRMBridgeEnabled()) return false;
+    if (agentResponse) {
+      await pushConversationToCRM({
+        platform: msg.platform,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        messageText: msg.text,
+        agentResponse,
+        agentName: agentName ?? "unknown",
+        timestamp: msg.timestamp,
+        accountId: msg.accountId
+      });
+    } else {
+      await pushInboundMessageToCRM({
+        platform: msg.platform,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        messageText: msg.text,
+        timestamp: msg.timestamp,
+        accountId: msg.accountId
+      });
+    }
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] crm-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkWiki(msg, agentResponse) {
+  try {
+    const { createWikiClient } = await import("./wiki-client-GBPR45BQ.js");
+    const client = await createWikiClient();
+    if (!client) return false;
+    const content = msg.text ?? "";
+    if (content.length < 50) return false;
+    const { chatInWorkspace } = await import("./wiki-client-GBPR45BQ.js");
+    const ingestText = [
+      `[${msg.platform}] Message from ${msg.senderName ?? msg.senderId} (${msg.timestamp}):`,
+      content,
+      agentResponse ? `
+Agent response: ${agentResponse}` : ""
+    ].join("\n");
+    await chatInWorkspace(client, "conversations", ingestText, "chat");
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] wiki-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkEntityExtraction(msg, agentResponse, agentName) {
+  try {
+    const { extractFromConversation } = await import("./conversation-entity-extractor-EYSI4DKM.js");
+    const { storeExtraction } = await import("./graph-rag-G3EG5Q6L.js");
+    if ((msg.text?.length ?? 0) < 20) return false;
+    if (msg.isHistorical) return false;
+    const extraction = await extractFromConversation(msg, agentResponse, agentName);
+    if (extraction.entities.length === 0) return false;
+    const client = getClient();
+    const memoryId = `conv:${msg.messageId}`;
+    await storeExtraction(client, extraction, memoryId, msg.timestamp);
+    import("./conversation-wiki-populator-L7O6F3BB.js").then(
+      ({ populateWikiFromExtraction }) => populateWikiFromExtraction(extraction, msg, agentResponse, agentName)
+    ).catch((err) => {
+      process.stderr.write(
+        `[pipeline] wiki-population error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] entity-extraction-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function ingest(msg, agentResponse, agentName) {
+  const errors = [];
+  const [conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted] = await Promise.all([
+    sinkConversationStore(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`conversation: ${e}`);
+      return false;
+    }),
+    sinkMemory(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`memory: ${e}`);
+      return false;
+    }),
+    sinkCRM(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`crm: ${e}`);
+      return false;
+    }),
+    sinkWiki(msg, agentResponse).catch((e) => {
+      errors.push(`wiki: ${e}`);
+      return false;
+    }),
+    sinkEntityExtraction(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`entity-extraction: ${e}`);
+      return false;
+    })
+  ]);
+  if (errors.length > 0) {
+    process.stderr.write(
+      `[pipeline] ${errors.length} sink error(s): ${errors.join("; ")}
+`
+    );
+  }
+  return { conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted, errors };
+}
+
+export {
+  ingest
+};

package/dist/chunk-DBJCWK6T.js

@@ -0,0 +1,377 @@
+import {
+  extractMemoryGraph
+} from "./chunk-X2WBH2IO.js";
+import {
+  flushBatch,
+  writeMemory
+} from "./chunk-PXXHKWDH.js";
+import {
+  extractKeywords
+} from "./chunk-CHCA3ZM2.js";
+import {
+  getActiveAgent
+} from "./chunk-BXCQWWJP.js";
+
+// src/mcp/tools/import-conversations.ts
+import { z } from "zod";
+import crypto from "crypto";
+import { readdir, readFile, stat } from "fs/promises";
+import path, { resolve, normalize } from "path";
+import os from "os";
+
+// src/lib/conversation-parser.ts
+function detectFormat(content, filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".md") || lower.endsWith(".markdown")) return "markdown";
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("[") && !trimmed.startsWith("{")) return "markdown";
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed) && parsed.length > 0) {
+      const first = parsed[0];
+      if (first && typeof first === "object") {
+        if ("mapping" in first && typeof first.mapping === "object") return "chatgpt";
+        if ("chat_messages" in first) return "claude";
+        if ("uuid" in first && "name" in first) return "claude";
+      }
+    }
+    return "generic";
+  } catch {
+    return "markdown";
+  }
+}
+function extractChatGPTContent(node) {
+  const parts = node.message?.content?.parts;
+  if (!Array.isArray(parts)) return "";
+  return parts.filter((p) => typeof p === "string").join("\n").trim();
+}
+function parseChatGPT(content, sourceFile = "conversations.json") {
+  const data = JSON.parse(content);
+  if (!Array.isArray(data)) return [];
+  return data.map((conv) => {
+    const title = conv.title ?? "Untitled";
+    const messages = [];
+    if (conv.mapping) {
+      const nodes = Object.values(conv.mapping).filter((n) => n.message?.content?.parts && extractChatGPTContent(n).length > 0).sort((a, b) => (a.message?.create_time ?? 0) - (b.message?.create_time ?? 0));
+      for (const node of nodes) {
+        const role = node.message?.author?.role ?? "unknown";
+        const text = extractChatGPTContent(node);
+        if (!text) continue;
+        const createTime = node.message?.create_time;
+        messages.push({
+          role,
+          content: text,
+          timestamp: createTime ? new Date(createTime * 1e3).toISOString() : void 0
+        });
+      }
+    }
+    return { title, messages, sourceFile };
+  }).filter((c) => c.messages.length > 0);
+}
+function parseClaude(content, sourceFile = "conversations.json") {
+  const data = JSON.parse(content);
+  if (!Array.isArray(data)) return [];
+  return data.map((conv) => {
+    const title = conv.name ?? conv.uuid ?? "Untitled";
+    const messages = [];
+    if (conv.chat_messages) {
+      for (const msg of conv.chat_messages) {
+        let text = msg.text ?? "";
+        if (!text && Array.isArray(msg.content)) {
+          text = msg.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+        }
+        if (!text.trim()) continue;
+        messages.push({
+          role: msg.sender ?? "unknown",
+          content: text.trim(),
+          timestamp: msg.created_at
+        });
+      }
+    }
+    return { title, messages, sourceFile };
+  }).filter((c) => c.messages.length > 0);
+}
+function parseGeneric(content, sourceFile = "conversations.json") {
+  const trimmed = content.trimStart();
+  try {
+    const data = JSON.parse(trimmed);
+    if (Array.isArray(data)) {
+      if (data.length > 0 && typeof data[0] === "object" && ("role" in data[0] || "content" in data[0])) {
+        const messages = data.map((msg) => ({
+          role: msg.role ?? "unknown",
+          content: (msg.content ?? msg.text ?? "").trim(),
+          timestamp: msg.timestamp ?? msg.created_at
+        })).filter((m) => m.content.length > 0);
+        if (messages.length > 0) {
+          return [{ title: sourceFile, messages, sourceFile }];
+        }
+      }
+    }
+  } catch {
+  }
+  return parseMarkdown(content, sourceFile);
+}
+function parseMarkdown(content, sourceFile = "conversation.md") {
+  const lines = content.split("\n");
+  const conversations = [];
+  let currentTitle = sourceFile;
+  let currentMessages = [];
+  let currentRole = "user";
+  let currentContent = [];
+  function flushMessage() {
+    const text = currentContent.join("\n").trim();
+    if (text) {
+      currentMessages.push({ role: currentRole, content: text });
+    }
+    currentContent = [];
+  }
+  function flushConversation() {
+    flushMessage();
+    if (currentMessages.length > 0) {
+      conversations.push({ title: currentTitle, messages: [...currentMessages], sourceFile });
+    }
+    currentMessages = [];
+  }
+  for (const line of lines) {
+    const h1Match = line.match(/^# (.+)$/);
+    if (h1Match) {
+      flushConversation();
+      currentTitle = h1Match[1];
+      continue;
+    }
+    const roleMatch = line.match(/^(?:##\s+|\*\*)(user|assistant|human|system|ai|claude|gpt)(?:\*\*)?:?\s*/i);
+    if (roleMatch) {
+      flushMessage();
+      const raw = roleMatch[1].toLowerCase();
+      currentRole = raw === "human" || raw === "user" ? "user" : raw === "assistant" || raw === "ai" || raw === "claude" || raw === "gpt" ? "assistant" : raw;
+      continue;
+    }
+    currentContent.push(line);
+  }
+  flushConversation();
+  return conversations;
+}
+function conversationsToMemories(convos, format = "generic") {
+  const memories = [];
+  for (const convo of convos) {
+    for (const msg of convo.messages) {
+      if (msg.content.length < 10) continue;
+      memories.push({
+        text: msg.content,
+        kind: "conversation",
+        metadata: {
+          source_type: "import",
+          source_format: format,
+          source_path: convo.sourceFile,
+          conversation_title: convo.title,
+          role: msg.role,
+          original_timestamp: msg.timestamp
+        }
+      });
+    }
+  }
+  return memories;
+}
+
+// src/mcp/tools/import-conversations.ts
+var DEFAULT_CAP = 5e4;
+var YIELD_INTERVAL = 50;
+async function readInputFiles(inputPath) {
+  const files = [];
+  const info = await stat(inputPath);
+  if (info.isDirectory()) {
+    const entries = await readdir(inputPath);
+    for (const entry of entries) {
+      const fullPath = path.join(inputPath, entry);
+      const entryStat = await stat(fullPath);
+      if (entryStat.isFile() && (entry.endsWith(".json") || entry.endsWith(".md") || entry.endsWith(".txt"))) {
+        files.push({ path: fullPath, content: await readFile(fullPath, "utf-8") });
+      }
+    }
+  } else {
+    files.push({ path: inputPath, content: await readFile(inputPath, "utf-8") });
+  }
+  return files;
+}
+function parseFile(content, filePath, requestedFormat) {
+  const format = requestedFormat && requestedFormat !== "auto" ? requestedFormat : detectFormat(content, filePath);
+  let conversations;
+  switch (format) {
+    case "chatgpt":
+      conversations = parseChatGPT(content, filePath);
+      break;
+    case "claude":
+      conversations = parseClaude(content, filePath);
+      break;
+    case "markdown":
+      conversations = parseMarkdown(content, filePath);
+      break;
+    case "generic":
+    default:
+      conversations = parseGeneric(content, filePath);
+      break;
+  }
+  return { format, conversations };
+}
+function registerImportConversations(server) {
+  server.registerTool(
+    "import_conversations",
+    {
+      title: "Import Conversations",
+      description: "Import ChatGPT, Claude, or generic conversation exports into memory. Parses, extracts keywords + graph entities, stores with proper metadata. Deduplicates via content_hash. Supports JSON, markdown, and directory input.",
+      inputSchema: {
+        path: z.string().describe("File or directory path to import"),
+        format: z.enum(["chatgpt", "claude", "generic", "markdown", "auto"]).default("auto").describe("Source format (default: auto-detect)"),
+        project_name: z.string().optional().describe("Project name for imported memories"),
+        dry_run: z.boolean().default(false).describe("Parse and report counts without storing"),
+        force: z.boolean().default(false).describe("Override 50K memory cap"),
+        agent_id: z.string().optional().describe("Agent to attribute memories to (default: current agent)")
+      }
+    },
+    async ({ path: inputPath, format: requestedFormat, project_name, dry_run, force, agent_id: overrideAgentId }) => {
+      const { agentId: currentAgentId, agentRole } = getActiveAgent();
+      const agentId = overrideAgentId ?? currentAgentId;
+      const projectName = project_name ?? "imported";
+      const resolvedPath = resolve(normalize(inputPath));
+      const home = process.env.HOME || os.homedir();
+      const blocked = ["/etc", "/root", "/var", "/usr", "/sys", "/proc"];
+      const sensitiveHome = [".ssh", ".gnupg", ".aws", ".config/gcloud"];
+      for (const dir of blocked) {
+        if (resolvedPath.startsWith(dir + "/") || resolvedPath === dir) {
+          return {
+            content: [{ type: "text", text: `Access denied: cannot read files from ${dir}` }],
+            isError: true
+          };
+        }
+      }
+      for (const rel of sensitiveHome) {
+        const full = resolve(home, rel);
+        if (resolvedPath.startsWith(full + "/") || resolvedPath === full) {
+          return {
+            content: [{ type: "text", text: `Access denied: cannot read files from ~/${rel}` }],
+            isError: true
+          };
+        }
+      }
+      let files;
+      try {
+        files = await readInputFiles(inputPath);
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error reading ${inputPath}: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
+      if (files.length === 0) {
+        return {
+          content: [{ type: "text", text: `No importable files found at ${inputPath}` }],
+          isError: true
+        };
+      }
+      const allMemories = [];
+      let conversationCount = 0;
+      const formatCounts = {};
+      for (const file of files) {
+        const { format, conversations } = parseFile(file.content, file.path, requestedFormat);
+        formatCounts[format] = (formatCounts[format] ?? 0) + conversations.length;
+        conversationCount += conversations.length;
+        const memories = conversationsToMemories(conversations, format);
+        allMemories.push(...memories);
+      }
+      if (allMemories.length > DEFAULT_CAP && !force) {
+        return {
+          content: [{
+            type: "text",
+            text: `Import would create ${allMemories.length} memories (cap: ${DEFAULT_CAP}). Use force=true to override. Files: ${files.length}, Conversations: ${conversationCount}`
+          }],
+          isError: true
+        };
+      }
+      if (dry_run) {
+        const formatSummary2 = Object.entries(formatCounts).map(([f, c]) => `${f}: ${c}`).join(", ");
+        return {
+          content: [{
+            type: "text",
+            text: `[DRY RUN] Would import:
+  Files: ${files.length}
+  Conversations: ${conversationCount} (${formatSummary2})
+  Memories: ${allMemories.length}
+  Agent: ${agentId}
+  Project: ${projectName}`
+          }]
+        };
+      }
+      let stored = 0;
+      let skipped = 0;
+      for (let i = 0; i < allMemories.length; i++) {
+        const memory = allMemories[i];
+        try {
+          const keywords = extractKeywords(memory.text);
+          const keywordsStr = keywords.length > 0 ? keywords.join(" ") : null;
+          let entities = null;
+          try {
+            const graph = extractMemoryGraph(memory.text, agentId, projectName, "import_conversations");
+            if (graph.entities.length > 0) {
+              entities = JSON.stringify(graph.entities.map((e) => e.name));
+            }
+          } catch {
+          }
+          const id = crypto.randomUUID();
+          await writeMemory({
+            id,
+            agent_id: agentId,
+            agent_role: agentRole,
+            session_id: process.env.SESSION_ID ?? "import",
+            timestamp: memory.metadata.original_timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+            tool_name: "import_conversations",
+            project_name: projectName,
+            has_error: false,
+            raw_text: memory.text,
+            vector: null,
+            // Backfill later
+            source_path: memory.metadata.source_path,
+            source_type: "import",
+            memory_type: "conversation",
+            tier: 3,
+            // Passive ingestion
+            importance: memory.metadata.role === "assistant" ? 5 : 4,
+            intent: "observation",
+            domain: projectName,
+            referenced_entities: entities,
+            keywords: keywordsStr,
+            valid_from: memory.metadata.original_timestamp ?? void 0
+          });
+          stored++;
+        } catch {
+          skipped++;
+        }
+        if ((i + 1) % YIELD_INTERVAL === 0) {
+          await flushBatch();
+          await new Promise((r) => setTimeout(r, 0));
+          if ((i + 1) % (YIELD_INTERVAL * 10) === 0) {
+            process.stderr.write(`[import] ${i + 1}/${allMemories.length} memories processed, ${stored} stored
+`);
+          }
+        }
+      }
+      await flushBatch();
+      const formatSummary = Object.entries(formatCounts).map(([f, c]) => `${f}: ${c}`).join(", ");
+      return {
+        content: [{
+          type: "text",
+          text: `Import complete.
+  Files: ${files.length}
+  Conversations: ${conversationCount} (${formatSummary})
+  Memories stored: ${stored}
+  Duplicates skipped: ${skipped}
+  Agent: ${agentId}
+  Project: ${projectName}`
+        }]
+      };
+    }
+  );
+}
+
+export {
+  registerImportConversations
+};

package/dist/chunk-DF4SM6ZX.js

@@ -0,0 +1,128 @@
+import {
+  getCurrentSessionScope,
+  strictSessionScopeFilter
+} from "./chunk-IDCLPPIM.js";
+import {
+  getProjectName
+} from "./chunk-OPU3NYOO.js";
+
+// src/lib/session-events.ts
+import { randomUUID } from "crypto";
+async function ensureSessionEventsTable(client) {
+  await client.execute(`
+    CREATE TABLE IF NOT EXISTS session_events (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      session_scope TEXT,
+      project_name  TEXT NOT NULL,
+      event_index   INTEGER NOT NULL,
+      event_type    TEXT NOT NULL,
+      tool_name     TEXT,
+      tool_use_id   TEXT,
+      content       TEXT NOT NULL,
+      payload_json  TEXT,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL
+    )
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_agent_time
+      ON session_events(agent_id, created_at DESC)
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_session_index
+      ON session_events(session_id, event_index)
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_scope_agent_time
+      ON session_events(session_scope, agent_id, created_at DESC)
+  `);
+}
+async function recordSessionEvent(client, input) {
+  if (!input.content || input.content.trim().length === 0) return;
+  await ensureSessionEventsTable(client);
+  const maxResult = await client.execute({
+    sql: "SELECT COALESCE(MAX(event_index), 0) AS max_index FROM session_events WHERE session_id = ?",
+    args: [input.sessionId]
+  });
+  const currentMax = Number(maxResult.rows[0]?.max_index ?? 0);
+  const eventIndex = Number.isFinite(currentMax) ? currentMax + 1 : 1;
+  await client.execute({
+    sql: `INSERT INTO session_events (
+            id, agent_id, agent_role, session_id, session_scope, project_name,
+            event_index, event_type, tool_name, tool_use_id, content,
+            payload_json, has_error, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      randomUUID(),
+      input.agentId,
+      input.agentRole,
+      input.sessionId,
+      input.sessionScope ?? getCurrentSessionScope(),
+      input.projectName ?? getProjectName(input.cwd),
+      eventIndex,
+      input.eventType,
+      input.toolName ?? null,
+      input.toolUseId ?? null,
+      input.content,
+      input.payloadJson ?? null,
+      input.hasError ? 1 : 0,
+      input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    ]
+  });
+}
+async function listRecentSessionEvents(client, options) {
+  await ensureSessionEventsTable(client);
+  const conditions = ["agent_id = ?"];
+  const args = [options.agentId];
+  if (options.sessionId) {
+    conditions.push("session_id = ?");
+    args.push(options.sessionId);
+  }
+  if (options.eventType) {
+    conditions.push("event_type = ?");
+    args.push(options.eventType);
+  }
+  if (options.projectName && options.projectName !== "all") {
+    conditions.push("project_name = ?");
+    args.push(options.projectName);
+  }
+  const scope = strictSessionScopeFilter(options.sessionScope);
+  const where = `WHERE ${conditions.join(" AND ")}${scope.sql}`;
+  args.push(...scope.args);
+  args.push(Math.min(Math.max(options.limit ?? 20, 1), 100));
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, agent_role, session_id, session_scope,
+                 project_name, event_index, event_type, tool_name, tool_use_id,
+                 content, payload_json, has_error, created_at
+          FROM session_events
+          ${where}
+          ORDER BY created_at DESC, event_index DESC
+          LIMIT ?`,
+    args
+  });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    agentId: String(row.agent_id),
+    agentRole: String(row.agent_role),
+    sessionId: String(row.session_id),
+    sessionScope: row.session_scope == null ? null : String(row.session_scope),
+    projectName: String(row.project_name),
+    eventIndex: Number(row.event_index),
+    eventType: String(row.event_type),
+    toolName: row.tool_name == null ? null : String(row.tool_name),
+    toolUseId: row.tool_use_id == null ? null : String(row.tool_use_id),
+    content: String(row.content),
+    payloadJson: row.payload_json == null ? null : String(row.payload_json),
+    hasError: Number(row.has_error) === 1,
+    createdAt: String(row.created_at)
+  }));
+}
+
+export {
+  ensureSessionEventsTable,
+  recordSessionEvent,
+  listRecentSessionEvents
+};