@askexenow/exe-os 0.9.271 → 0.9.272

package/dist/chunk-AIRJTKDK.js

@@ -0,0 +1,204 @@
+import {
+  getClient
+} from "./chunk-UNCGZXPU.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-ATJ3NXDP.js

@@ -0,0 +1,244 @@
+import {
+  employeeSessionName,
+  ensureEmployee,
+  markAsReadByTaskFile,
+  notifyParentExe,
+  resolveExeSession,
+  sendIntercom
+} from "./chunk-57UAFTO2.js";
+import {
+  getTransport
+} from "./chunk-MVW62NIZ.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-JP45GCVR.js";
+import {
+  getAgentRuntime
+} from "./chunk-XJUUWHVN.js";
+import {
+  getSessionKey
+} from "./chunk-CVYC6DUW.js";
+import {
+  isCoordinatorName,
+  isMultiInstance,
+  shouldAutoInstance
+} from "./chunk-UNCGZXPU.js";
+
+// src/lib/tasks-notify.ts
+var VERIFY_DELAY_MS = 1e4;
+var ACK_PATTERNS = [
+  /New task assigned/,
+  /START WORKING NOW/,
+  /marked in_progress/,
+  /Reading.*\.md/
+];
+function resolveDispatchRuntime(agentId, override) {
+  if (override) return override;
+  try {
+    return getAgentRuntime(agentId).runtime ?? null;
+  } catch {
+    return null;
+  }
+}
+async function verifyDispatch(sessionName, delayMs = VERIFY_DELAY_MS) {
+  const transport = getTransport();
+  await new Promise((r) => setTimeout(r, delayMs));
+  if (!transport.isAlive(sessionName)) {
+    return "session_dead";
+  }
+  try {
+    const output = transport.capturePane(sessionName, 20);
+    const acked = ACK_PATTERNS.some((p) => p.test(output));
+    return acked ? "verified" : "sent_unverified";
+  } catch {
+    return "sent_unverified";
+  }
+}
+async function dispatchTaskToEmployee(input) {
+  if (isCoordinatorName(input.assignedTo)) return { dispatched: "skipped" };
+  const dispatchRuntime = resolveDispatchRuntime(input.assignedTo, input.spawnRuntime);
+  recordOrchestrationEventBestEffort({
+    eventType: "dispatch.attempted",
+    source: "tasks-notify.dispatchTaskToEmployee",
+    taskId: input.taskId ?? null,
+    agentId: input.assignedTo,
+    runtime: dispatchRuntime,
+    payload: { priority: input.priority, projectName: input.projectName }
+  });
+  let crossProject = false;
+  if (input.projectName) {
+    try {
+      const { assertSessionScope } = await import("./session-scope-CQXB7VMH.js");
+      const check = assertSessionScope("dispatch_task", input.projectName);
+      if (check.reason === "cross_session_denied") {
+        crossProject = true;
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          runtime: dispatchRuntime,
+          errorCode: "cross_session_denied",
+          payload: { projectName: input.projectName }
+        });
+        return { dispatched: "skipped", crossProject: true };
+      }
+    } catch {
+    }
+  }
+  try {
+    const transport = getTransport();
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.failed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        runtime: dispatchRuntime,
+        errorCode: "no_exe_session"
+      });
+      return { dispatched: "session_missing" };
+    }
+    const multiInstance = isMultiInstance(input.assignedTo);
+    if (multiInstance) {
+      const projectDir = input.projectDir ?? process.cwd();
+      const autoOpts = shouldAutoInstance(input.assignedTo);
+      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
+        ...autoOpts,
+        runtimeOverride: input.spawnRuntime,
+        modelOverride: input.spawnModel
+      });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result.error}
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          sessionScope: exeSession,
+          runtime: dispatchRuntime,
+          errorCode: "spawn_failed",
+          payload: { path: "multi_instance", error: result.error }
+        });
+        return { dispatched: "session_missing" };
+      }
+      const dispatched = result.status === "intercom_sent" || result.status === "intercom_unprocessed" ? "sent_unverified" : "spawned";
+      process.stderr.write(
+        `[dispatch-audit] ${dispatched === "spawned" ? "SPAWNED" : "INTERCOM"} \u2192 ${result.sessionName} | task="${input.title}" [${input.priority}]
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: result.sessionName,
+        runtime: dispatchRuntime,
+        result: dispatched,
+        payload: { path: "multi_instance", priority: input.priority }
+      });
+      return { dispatched, session: result.sessionName, crossProject };
+    }
+    const sessionName = employeeSessionName(input.assignedTo, exeSession);
+    if (transport.isAlive(sessionName)) {
+      const result = sendIntercom(sessionName, { force: true });
+      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
+      process.stderr.write(
+        `[dispatch-audit] intercom \u2192 ${sessionName} | task="${input.title}" [${input.priority}] | result=${dispatched} (sendIntercom=${result})
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: sessionName,
+        runtime: dispatchRuntime,
+        result: dispatched,
+        payload: { path: "single_instance_intercom", priority: input.priority }
+      });
+      return { dispatched, session: sessionName, crossProject };
+    } else {
+      const projectDir = input.projectDir ?? process.cwd();
+      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
+        runtimeOverride: input.spawnRuntime,
+        modelOverride: input.spawnModel
+      });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result.error}
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          sessionScope: exeSession,
+          runtime: dispatchRuntime,
+          errorCode: "spawn_failed",
+          payload: { path: "single_instance_spawn", error: result.error }
+        });
+        return { dispatched: "session_missing" };
+      }
+      process.stderr.write(
+        `[dispatch-audit] SPAWNED \u2192 ${result.sessionName} | task="${input.title}" [${input.priority}]
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: result.sessionName,
+        runtime: dispatchRuntime,
+        result: "spawned",
+        payload: { path: "single_instance_spawn", priority: input.priority }
+      });
+      return { dispatched: "spawned", session: result.sessionName, crossProject };
+    }
+  } catch {
+    recordOrchestrationEventBestEffort({
+      eventType: "dispatch.failed",
+      source: "tasks-notify.dispatchTaskToEmployee",
+      taskId: input.taskId ?? null,
+      agentId: input.assignedTo,
+      runtime: dispatchRuntime,
+      errorCode: "exception"
+    });
+    return { dispatched: "session_missing" };
+  }
+}
+function notifyTaskDone() {
+  try {
+    const key = getSessionKey();
+    if (key && !process.env.VITEST) {
+      notifyParentExe(key);
+      process.stderr.write(
+        `[dispatch-audit] notifyTaskDone \u2192 parent coordinator (session=${key})
+`
+      );
+    }
+  } catch {
+  }
+}
+async function markTaskNotificationsRead(taskFile) {
+  try {
+    await markAsReadByTaskFile(taskFile);
+  } catch {
+  }
+}
+
+export {
+  verifyDispatch,
+  dispatchTaskToEmployee,
+  notifyTaskDone,
+  markTaskNotificationsRead
+};

package/dist/chunk-B5IS7LE4.js

@@ -0,0 +1,128 @@
+import {
+  getCurrentSessionScope,
+  strictSessionScopeFilter
+} from "./chunk-57UAFTO2.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
+};