@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-O377P7GM.js

@@ -0,0 +1,100 @@
+// src/runtime/hooks.ts
+function createDefaultHooks() {
+  return {};
+}
+function composeHooks(...pipelines) {
+  return {
+    async onSessionStart(context) {
+      for (const p of pipelines) {
+        if (p.onSessionStart) await p.onSessionStart(context);
+      }
+    },
+    async onSessionEnd(context, summary) {
+      for (const p of pipelines) {
+        if (p.onSessionEnd) await p.onSessionEnd(context, summary);
+      }
+    },
+    async beforeToolUse(block, context) {
+      for (const p of pipelines) {
+        if (p.beforeToolUse) {
+          const result = await p.beforeToolUse(block, context);
+          if (result) return result;
+        }
+      }
+      return null;
+    },
+    async afterToolUse(block, result, context) {
+      for (const p of pipelines) {
+        if (p.afterToolUse) await p.afterToolUse(block, result, context);
+      }
+    },
+    async onError(error, context) {
+      for (const p of pipelines) {
+        if (p.onError) await p.onError(error, context);
+      }
+    },
+    async onCompact(removedMessages, summaryLength) {
+      for (const p of pipelines) {
+        if (p.onCompact) await p.onCompact(removedMessages, summaryLength);
+      }
+    },
+    async onPostCompact(removedMessages, injectedSummary) {
+      for (const p of pipelines) {
+        if (p.onPostCompact) await p.onPostCompact(removedMessages, injectedSummary);
+      }
+    },
+    async onSubagentStop(reason) {
+      for (const p of pipelines) {
+        if (p.onSubagentStop) {
+          const result = await p.onSubagentStop(reason);
+          if (result.block) return result;
+        }
+      }
+      return { block: false };
+    },
+    async onNotification(message) {
+      for (const p of pipelines) {
+        if (p.onNotification) await p.onNotification(message);
+      }
+    },
+    async onPermissionRequest(toolName, reason) {
+      for (const p of pipelines) {
+        if (p.onPermissionRequest) {
+          const result = await p.onPermissionRequest(toolName, reason);
+          if (result.autoApprove) return result;
+        }
+      }
+      return { autoApprove: false };
+    },
+    async onTaskAssigned(event) {
+      for (const p of pipelines) {
+        if (p.onTaskAssigned) await p.onTaskAssigned(event);
+      }
+    },
+    async onReviewReceived(event) {
+      for (const p of pipelines) {
+        if (p.onReviewReceived) await p.onReviewReceived(event);
+      }
+    },
+    async onContextPressure(event) {
+      for (const p of pipelines) {
+        if (p.onContextPressure) await p.onContextPressure(event);
+      }
+    },
+    async onCrossAgentMessage(event) {
+      for (const p of pipelines) {
+        if (p.onCrossAgentMessage) await p.onCrossAgentMessage(event);
+      }
+    },
+    async onTokenBudgetExceeded(ctx, fallback) {
+      for (const p of pipelines) {
+        if (p.onTokenBudgetExceeded) await p.onTokenBudgetExceeded(ctx, fallback);
+      }
+    }
+  };
+}
+
+export {
+  createDefaultHooks,
+  composeHooks
+};

package/dist/chunk-OE6SYHTC.js

@@ -0,0 +1,157 @@
+import {
+  clean,
+  stableId
+} from "./chunk-WWPX2LLP.js";
+
+// src/lib/reflection-checkpoints.ts
+function parsePayload(payload) {
+  if (!payload) return {};
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return {};
+  }
+}
+function semanticArray(event, key) {
+  const payload = parsePayload(event.payload);
+  const semantic = payload.semantic;
+  const value = semantic?.[key];
+  return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
+}
+function buildReflectionCheckpoint(events) {
+  if (!events.length) return null;
+  const sorted = [...events].sort((a, b) => a.occurred_at.localeCompare(b.occurred_at));
+  const first = sorted[0];
+  const last = sorted[sorted.length - 1];
+  const goals = /* @__PURE__ */ new Set();
+  const successes = [];
+  const failures = [];
+  const risks = [];
+  const nextActions = [];
+  const decisions = [];
+  for (const event of sorted) {
+    for (const goal of semanticArray(event, "goals")) goals.add(goal);
+    for (const item of semanticArray(event, "successSignals")) successes.push(item);
+    for (const item of semanticArray(event, "failureSignals")) failures.push(item);
+    for (const item of semanticArray(event, "nextActions")) nextActions.push(item);
+    for (const item of semanticArray(event, "decisions")) decisions.push(item);
+    if (event.impact === "negative" || event.outcome === "failure_signal" || event.event_type === "problem" || event.event_type === "error") {
+      failures.push(event.outcome || event.intention || event.event_type);
+    }
+    if (event.outcome === "risk_signal") risks.push(event.intention || event.outcome);
+    if (event.impact === "positive" || event.outcome === "success_signal" || event.event_type === "milestone") {
+      successes.push(event.outcome || event.intention || event.event_type);
+    }
+  }
+  const uniqueGoals = [...goals].slice(0, 6);
+  const uniqueSuccesses = [...new Set(successes.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueFailures = [...new Set(failures.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueRisks = [...new Set(risks.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueNext = [...new Set(nextActions.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueDecisions = [...new Set(decisions.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const learnings = [
+    uniqueSuccesses.length ? `Working: ${uniqueSuccesses.slice(0, 3).join("; ")}` : "Working: no strong success signal yet",
+    uniqueFailures.length ? `Improve: ${uniqueFailures.slice(0, 3).join("; ")}` : "Improve: no strong failure signal in this window",
+    uniqueDecisions.length ? `Decision context: ${uniqueDecisions.slice(0, 2).join("; ")}` : "Decision context: no explicit decision signal"
+  ];
+  const summary = clean([
+    `Window ${first.occurred_at} \u2192 ${last.occurred_at}`,
+    `${sorted.length} events`,
+    uniqueGoals.length ? `goals: ${uniqueGoals.join("; ")}` : "goals: inferred from event trajectory",
+    uniqueSuccesses.length ? `successes: ${uniqueSuccesses.slice(0, 2).join("; ")}` : "successes: none explicit",
+    uniqueFailures.length ? `failures: ${uniqueFailures.slice(0, 2).join("; ")}` : "failures: none explicit"
+  ].join(". "), 1200);
+  return {
+    id: stableId("reflection", first.project_name ?? "", first.session_id ?? "", first.occurred_at, last.occurred_at, sorted.length),
+    projectName: first.project_name ?? null,
+    sessionId: first.session_id ?? null,
+    windowStartAt: first.occurred_at,
+    windowEndAt: last.occurred_at,
+    eventCount: sorted.length,
+    goalCount: uniqueGoals.length,
+    successCount: uniqueSuccesses.length,
+    failureCount: uniqueFailures.length,
+    riskCount: uniqueRisks.length,
+    summary,
+    learnings,
+    nextActions: uniqueNext.length ? uniqueNext : ["Continue from latest successful event and resolve highest-impact failure/risk first."],
+    evidenceEventIds: sorted.slice(-25).map((e) => e.id),
+    confidence: Math.min(0.95, 0.5 + Math.min(sorted.length, 100) / 250 + uniqueGoals.length * 0.03)
+  };
+}
+async function resolveClient(client) {
+  if (client) return client;
+  const { getClient } = await import("./lib/database.js");
+  return getClient();
+}
+async function insertReflectionCheckpoint(checkpoint, client) {
+  const db = await resolveClient(client);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await db.execute({
+    sql: `INSERT INTO agent_reflection_checkpoints
+      (id, project_name, session_id, window_start_at, window_end_at, event_count, goal_count,
+       success_count, failure_count, risk_count, summary, learnings, next_actions, evidence_event_ids,
+       confidence, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET summary = excluded.summary, learnings = excluded.learnings,
+        next_actions = excluded.next_actions, confidence = excluded.confidence`,
+    args: [
+      checkpoint.id,
+      checkpoint.projectName,
+      checkpoint.sessionId,
+      checkpoint.windowStartAt,
+      checkpoint.windowEndAt,
+      checkpoint.eventCount,
+      checkpoint.goalCount,
+      checkpoint.successCount,
+      checkpoint.failureCount,
+      checkpoint.riskCount,
+      checkpoint.summary,
+      JSON.stringify(checkpoint.learnings),
+      JSON.stringify(checkpoint.nextActions),
+      JSON.stringify(checkpoint.evidenceEventIds),
+      checkpoint.confidence,
+      now
+    ]
+  });
+}
+async function generateReflectionCheckpoints(opts = {}) {
+  const db = await resolveClient(opts.client);
+  const windowSize = opts.windowSize ?? 100;
+  const minEvents = opts.minEvents ?? 20;
+  const limit = opts.limit ?? 5e3;
+  const where = opts.projectName ? "WHERE project_name = ?" : "";
+  const args = opts.projectName ? [opts.projectName] : [];
+  const result = await db.execute({
+    sql: `SELECT id, event_type, occurred_at, actor_agent_id, project_name, session_id, intention, outcome, impact, evidence_memory_id, payload
+          FROM agent_events ${where}
+          ORDER BY project_name, session_id, occurred_at, sequence_index
+          LIMIT ?`,
+    args: [...args, limit]
+  });
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const event = row;
+    const key = `${event.project_name ?? ""}::${event.session_id ?? ""}`;
+    const bucket = groups.get(key) ?? [];
+    bucket.push(event);
+    groups.set(key, bucket);
+  }
+  let inserted = 0;
+  for (const events of groups.values()) {
+    for (let i = 0; i < events.length; i += windowSize) {
+      const window = events.slice(i, i + windowSize);
+      if (window.length < minEvents) continue;
+      const checkpoint = buildReflectionCheckpoint(window);
+      if (!checkpoint) continue;
+      await insertReflectionCheckpoint(checkpoint, db);
+      inserted++;
+    }
+  }
+  return inserted;
+}
+
+export {
+  buildReflectionCheckpoint,
+  generateReflectionCheckpoints
+};

package/dist/chunk-OHPRXEUA.js

@@ -0,0 +1,75 @@
+import {
+  PLATFORM_PROCEDURES,
+  PLATFORM_PROCEDURE_TITLES
+} from "./chunk-5NFBE376.js";
+import {
+  getClient
+} from "./chunk-UJOSFVWG.js";
+
+// src/lib/global-procedures.ts
+import { randomUUID } from "crypto";
+var _customerCache = "";
+var _cacheLoaded = false;
+var _platformCache = PLATFORM_PROCEDURES.map((p) => `### ${p.title}
+${p.content}`).join("\n\n");
+async function loadGlobalProcedures() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM company_procedures WHERE active = 1 ORDER BY priority ASC, created_at ASC",
+    args: []
+  });
+  const allRows = result.rows;
+  const customerOnly = allRows.filter((p) => !PLATFORM_PROCEDURE_TITLES.has(p.title));
+  const values = customerOnly.filter((p) => p.kind === "value");
+  const procedures = customerOnly.filter((p) => p.kind !== "value");
+  const parts = [];
+  if (values.length > 0) {
+    parts.push("### Company Values\n" + values.map((v) => `- **${v.title}:** ${v.content}`).join("\n"));
+  }
+  if (procedures.length > 0) {
+    parts.push(procedures.map((p) => `### ${p.title}
+${p.content}`).join("\n\n"));
+  }
+  _customerCache = parts.join("\n\n");
+  _cacheLoaded = true;
+  return customerOnly;
+}
+function getGlobalProceduresBlock() {
+  const sections = [];
+  if (_platformCache) sections.push(_platformCache);
+  if (_cacheLoaded && _customerCache) sections.push(_customerCache);
+  if (sections.length === 0) return "";
+  return `## Organization-Wide Procedures (MANDATORY \u2014 supersedes all other rules)
+
+${sections.join("\n\n")}
+`;
+}
+async function storeGlobalProcedure(input) {
+  const id = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  await client.execute({
+    sql: `INSERT INTO company_procedures (id, title, content, priority, domain, kind, active, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
+    args: [id, input.title, input.content, input.priority ?? "p0", input.domain ?? null, input.kind ?? "procedure", now, now]
+  });
+  await loadGlobalProcedures();
+  return id;
+}
+async function deactivateGlobalProcedure(id) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  const result = await client.execute({
+    sql: "UPDATE company_procedures SET active = 0, updated_at = ? WHERE id = ?",
+    args: [now, id]
+  });
+  await loadGlobalProcedures();
+  return result.rowsAffected > 0;
+}
+
+export {
+  loadGlobalProcedures,
+  getGlobalProceduresBlock,
+  storeGlobalProcedure,
+  deactivateGlobalProcedure
+};

package/dist/chunk-OI6MVDSY.js

@@ -0,0 +1,33 @@
+import {
+  completeReminder
+} from "./chunk-R2E4TV5V.js";
+
+// src/mcp/tools/complete-reminder.ts
+import { z } from "zod";
+function registerCompleteReminder(server) {
+  server.registerTool(
+    "complete_reminder",
+    {
+      title: "Complete Reminder",
+      description: "Mark a reminder as done. Accepts UUID or text substring.",
+      inputSchema: {
+        reminder_id: z.string().describe("Reminder UUID or text substring to match")
+      }
+    },
+    async ({ reminder_id }) => {
+      const reminder = await completeReminder(reminder_id);
+      if (!reminder) {
+        return {
+          content: [{ type: "text", text: `No active reminder matching "${reminder_id}".` }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Reminder completed: "${reminder.text}"` }]
+      };
+    }
+  );
+}
+
+export {
+  registerCompleteReminder
+};

package/dist/chunk-ONKIWA3R.js

@@ -0,0 +1,249 @@
+// src/gateway/crm-bridge.ts
+var config = null;
+var disabledLogged = false;
+function initCRMBridge() {
+  const apiToken = process.env.EXE_CRM_ADMIN_TOKEN || process.env.CRM_API_TOKEN;
+  if (!apiToken) {
+    if (!disabledLogged) {
+      console.log("[crm-bridge] Disabled \u2014 EXE_CRM_ADMIN_TOKEN not set");
+      disabledLogged = true;
+    }
+    config = null;
+    return false;
+  }
+  const graphqlUrl = process.env.CRM_GRAPHQL_URL || "http://localhost:3000";
+  config = { graphqlUrl, apiToken };
+  console.log(`[crm-bridge] Enabled \u2014 pushing to ${graphqlUrl}`);
+  return true;
+}
+function isCRMBridgeEnabled() {
+  return config !== null;
+}
+async function gqlRequest(query, variables) {
+  const res = await fetch(`${config.graphqlUrl}/api`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiToken}`
+    },
+    body: JSON.stringify({ query, variables }),
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!res.ok) {
+    throw new Error(`CRM GraphQL request failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function findPersonByContact(platform, senderId) {
+  const isEmail = platform === "email";
+  const query = isEmail ? `query FindPerson($value: String!) {
+        people(filter: { emails: { primaryEmail: { eq: $value } } }, first: 1) {
+          edges { node { id } }
+        }
+      }` : `query FindPerson($value: String!) {
+        people(filter: { phones: { primaryPhoneNumber: { eq: $value } } }, first: 1) {
+          edges { node { id } }
+        }
+      }`;
+  const res = await gqlRequest(query, { value: senderId });
+  if (res.errors && res.errors.length > 0) {
+    console.error("[crm-bridge] findPerson error:", res.errors[0].message);
+    return null;
+  }
+  const edges = res.data?.people?.edges;
+  return edges && edges.length > 0 ? edges[0].node.id : null;
+}
+async function createPerson(platform, senderId, senderName) {
+  const firstName = senderName?.split(" ")[0] || "";
+  const lastName = senderName?.split(" ").slice(1).join(" ") || "";
+  const isEmail = platform === "email";
+  const input = {
+    name: { firstName, lastName }
+  };
+  if (isEmail) {
+    input.emails = { primaryEmail: senderId, additionalEmails: [] };
+  } else {
+    input.phones = {
+      primaryPhoneNumber: senderId,
+      primaryPhoneCountryCode: "",
+      primaryPhoneCallingCode: "",
+      additionalPhones: []
+    };
+  }
+  const query = `
+    mutation CreatePerson($input: PersonCreateInput!) {
+      createPerson(data: $input) {
+        id
+      }
+    }
+  `;
+  const res = await gqlRequest(query, {
+    input
+  });
+  if (res.errors && res.errors.length > 0) {
+    console.error("[crm-bridge] createPerson error:", res.errors[0].message);
+    return null;
+  }
+  return res.data?.createPerson?.id ?? null;
+}
+async function createTimelineActivity(personId, params) {
+  const channelLabel = params.platform.charAt(0).toUpperCase() + params.platform.slice(1);
+  const label = params.direction === "inbound" ? "message from" : "conversation with";
+  const input = {
+    name: `${channelLabel} ${label} ${params.senderName || params.senderId}`,
+    happensAt: params.timestamp,
+    properties: {
+      channel: params.platform,
+      senderId: params.senderId,
+      senderName: params.senderName || null,
+      messageText: params.messageText,
+      agentResponse: params.agentResponse || null,
+      agentName: params.agentName || null,
+      threadId: `${params.platform}:${params.senderId}`,
+      direction: params.direction,
+      accountId: params.accountId || null
+    },
+    targetPersonId: personId
+  };
+  const query = `
+    mutation CreateTimelineActivity($input: TimelineActivityCreateInput!) {
+      createTimelineActivity(data: $input) {
+        id
+      }
+    }
+  `;
+  const res = await gqlRequest(
+    query,
+    { input }
+  );
+  if (res.errors && res.errors.length > 0) {
+    console.error(
+      "[crm-bridge] createTimelineActivity error:",
+      res.errors[0].message
+    );
+    return false;
+  }
+  return true;
+}
+async function pushConversationToCRM(params) {
+  if (!config) return;
+  try {
+    let personId = await findPersonByContact(params.platform, params.senderId);
+    if (!personId) {
+      personId = await createPerson(
+        params.platform,
+        params.senderId,
+        params.senderName
+      );
+    }
+    if (!personId) {
+      console.error("[crm-bridge] Failed to find or create person for", params.senderId);
+      return;
+    }
+    const ok = await createTimelineActivity(personId, {
+      ...params,
+      direction: "conversation"
+    });
+    if (ok) {
+      console.log(
+        `[crm-bridge] Pushed ${params.platform}/${params.senderId} \u2192 person ${personId}`
+      );
+    }
+  } catch (err) {
+    console.error("[crm-bridge] Push failed:", err instanceof Error ? err.message : err);
+  }
+}
+async function pushInboundMessageToCRM(params) {
+  if (!config) return;
+  try {
+    let personId = await findPersonByContact(params.platform, params.senderId);
+    if (!personId) {
+      personId = await createPerson(
+        params.platform,
+        params.senderId,
+        params.senderName
+      );
+    }
+    if (!personId) {
+      console.error("[crm-bridge] Failed to find or create person for", params.senderId);
+      return;
+    }
+    const ok = await createTimelineActivity(personId, {
+      ...params,
+      direction: "inbound"
+    });
+    if (ok) {
+      console.log(
+        `[crm-bridge] Inbound ${params.platform}/${params.senderId} \u2192 person ${personId}`
+      );
+    }
+  } catch (err) {
+    console.error("[crm-bridge] Inbound push failed:", err instanceof Error ? err.message : err);
+  }
+}
+async function pushGatewayEventToCRM(params) {
+  if (!config) return;
+  try {
+    let personId = await findPersonByContact(params.platform, params.senderId);
+    if (!personId) {
+      personId = await createPerson(
+        params.platform,
+        params.senderId,
+        params.senderName
+      );
+    }
+    if (!personId) {
+      console.error("[crm-bridge] Failed to find or create person for", params.senderId);
+      return;
+    }
+    const channelLabel = params.platform.charAt(0).toUpperCase() + params.platform.slice(1);
+    const categoryLabel = params.dataCategory.replace(/_/g, " ");
+    const input = {
+      name: `${channelLabel} ${categoryLabel} \u2014 ${params.senderName || params.senderId}`,
+      happensAt: params.timestamp,
+      properties: {
+        channel: params.platform,
+        dataCategory: params.dataCategory,
+        senderId: params.senderId,
+        senderName: params.senderName || null,
+        accountId: params.accountId || null,
+        direction: "inbound",
+        ...params.eventData
+      },
+      targetPersonId: personId
+    };
+    const query = `
+      mutation CreateTimelineActivity($input: TimelineActivityCreateInput!) {
+        createTimelineActivity(data: $input) {
+          id
+        }
+      }
+    `;
+    const res = await gqlRequest(
+      query,
+      { input }
+    );
+    if (res.errors && res.errors.length > 0) {
+      console.error(
+        "[crm-bridge] pushGatewayEvent error:",
+        res.errors[0].message
+      );
+      return;
+    }
+    console.log(
+      `[crm-bridge] Event ${params.dataCategory} ${params.platform}/${params.senderId} \u2192 person ${personId}`
+    );
+  } catch (err) {
+    console.error("[crm-bridge] Event push failed:", err instanceof Error ? err.message : err);
+  }
+}
+
+export {
+  initCRMBridge,
+  isCRMBridgeEnabled,
+  findPersonByContact,
+  createPerson,
+  pushConversationToCRM,
+  pushInboundMessageToCRM,
+  pushGatewayEventToCRM
+};

package/dist/chunk-OPU3NYOO.js

@@ -0,0 +1,55 @@
+import {
+  getAgentContext
+} from "./chunk-GJV3WDWM.js";
+
+// src/lib/project-name.ts
+import { execSync } from "child_process";
+import path from "path";
+var _cached = null;
+var _cachedCwd = null;
+function getProjectName(cwd) {
+  if (!cwd) {
+    try {
+      const ctx = getAgentContext();
+      if (ctx?.projectName) return ctx.projectName;
+    } catch {
+    }
+  }
+  const dir = cwd ?? process.cwd();
+  if (_cached && _cachedCwd === dir) return _cached;
+  try {
+    let repoRoot;
+    try {
+      const gitCommonDir = execSync("git rev-parse --path-format=absolute --git-common-dir", {
+        cwd: dir,
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      repoRoot = path.dirname(gitCommonDir);
+    } catch {
+      repoRoot = execSync("git rev-parse --show-toplevel", {
+        cwd: dir,
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    }
+    _cached = path.basename(repoRoot);
+    _cachedCwd = dir;
+    return _cached;
+  } catch {
+    _cached = path.basename(dir);
+    _cachedCwd = dir;
+    return _cached;
+  }
+}
+function _resetCache() {
+  _cached = null;
+  _cachedCwd = null;
+}
+
+export {
+  getProjectName,
+  _resetCache
+};