@askexenow/exe-os 0.9.271 → 0.9.273

package/dist/chunk-E4KWB4WM.js

@@ -0,0 +1,348 @@
+import {
+  getIdentity,
+  loadEmployeesSync
+} from "./chunk-CHBHR5W6.js";
+
+// src/lib/drift-probes.ts
+var DRIFT_THRESHOLD = 80;
+async function getRecentMemories(agentId, limit) {
+  try {
+    const { getClient, isInitialized } = await import("./lib/database.js");
+    if (!isInitialized()) return { count: 0, texts: [] };
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT text FROM memories WHERE agent_id = ? ORDER BY created_at DESC LIMIT ?`,
+      args: [agentId, limit]
+    });
+    const texts = result.rows.map((r) => String(r.text ?? ""));
+    return { count: texts.length, texts };
+  } catch {
+    return { count: 0, texts: [] };
+  }
+}
+async function getDecisionCount(agentId) {
+  try {
+    const { getClient, isInitialized } = await import("./lib/database.js");
+    if (!isInitialized()) return 0;
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT COUNT(*) as cnt FROM memories WHERE agent_id = ? AND memory_type = 'decision'`,
+      args: [agentId]
+    });
+    return Number(result.rows[0]?.cnt ?? 0);
+  } catch {
+    return 0;
+  }
+}
+function probeContinuity(ctx) {
+  const memCount = ctx.recentMemoryCount;
+  let score;
+  let detail;
+  if (memCount >= 20) {
+    score = 95;
+    detail = `${memCount} recent memories \u2014 strong continuity`;
+  } else if (memCount >= 10) {
+    score = 85;
+    detail = `${memCount} recent memories \u2014 adequate continuity`;
+  } else if (memCount >= 3) {
+    score = 70;
+    detail = `${memCount} recent memories \u2014 limited continuity`;
+  } else if (memCount >= 1) {
+    score = 50;
+    detail = `${memCount} recent memories \u2014 weak continuity`;
+  } else {
+    score = 30;
+    detail = "No recent memories \u2014 agent may lack session context";
+  }
+  if (ctx.storedDecisionCount > 0) {
+    score = Math.min(100, score + 5);
+    detail += ` (+${ctx.storedDecisionCount} decisions)`;
+  }
+  return { axis: "continuity", score, detail };
+}
+function probeConsistency(ctx) {
+  if (!ctx.identityBody || ctx.recentMemoryTexts.length === 0) {
+    return {
+      axis: "consistency",
+      score: ctx.identityBody ? 80 : 50,
+      detail: ctx.identityBody ? "No memories to check against identity" : "No identity file \u2014 cannot assess consistency"
+    };
+  }
+  const identityTerms = extractKeyTerms(ctx.identityBody);
+  if (identityTerms.length === 0) {
+    return { axis: "consistency", score: 75, detail: "Identity has no extractable key terms" };
+  }
+  const memoryText = ctx.recentMemoryTexts.join(" ").toLowerCase();
+  let matched = 0;
+  for (const term of identityTerms) {
+    if (memoryText.includes(term.toLowerCase())) matched++;
+  }
+  const ratio = matched / identityTerms.length;
+  const score = Math.round(50 + ratio * 50);
+  const detail = `${matched}/${identityTerms.length} identity terms found in recent memories`;
+  return { axis: "consistency", score, detail };
+}
+function probeRoleFidelity(ctx) {
+  const flags = [];
+  if (!ctx.identityBody) {
+    return {
+      axis: "role-fidelity",
+      score: 40,
+      detail: `No identity file for ${ctx.agent.name}`
+    };
+  }
+  let score = 100;
+  const identityLower = ctx.identityBody.toLowerCase();
+  const rosterRole = ctx.agent.role.toLowerCase();
+  if (!identityLower.includes(rosterRole)) {
+    score -= 15;
+    flags.push(`Identity does not mention role "${ctx.agent.role}"`);
+  }
+  if (!identityLower.includes(ctx.agent.name.toLowerCase())) {
+    score -= 10;
+    flags.push(`Identity does not mention agent name "${ctx.agent.name}"`);
+  }
+  const hasScopeBoundary = identityLower.includes("do not") || identityLower.includes("don't") || identityLower.includes("not your") || identityLower.includes("outside your") || identityLower.includes("you do not");
+  if (!hasScopeBoundary) {
+    score -= 10;
+    flags.push("Identity lacks explicit scope boundaries (what NOT to do)");
+  }
+  if (ctx.agent.systemPrompt) {
+    const promptTerms = extractKeyTerms(ctx.agent.systemPrompt);
+    const identityText = ctx.identityBody.toLowerCase();
+    let promptMatched = 0;
+    for (const term of promptTerms.slice(0, 20)) {
+      if (identityText.includes(term.toLowerCase())) promptMatched++;
+    }
+    const promptRatio = promptTerms.length > 0 ? promptMatched / Math.min(promptTerms.length, 20) : 1;
+    if (promptRatio < 0.3) {
+      score -= 15;
+      flags.push("Identity content diverges significantly from roster systemPrompt");
+    }
+  }
+  if (ctx.recentMemoryTexts.length > 5) {
+    const roleKeywords = extractRoleKeywords(ctx.agent.role);
+    const memoryText = ctx.recentMemoryTexts.join(" ").toLowerCase();
+    let domainHits = 0;
+    for (const kw of roleKeywords) {
+      if (memoryText.includes(kw)) domainHits++;
+    }
+    const domainRatio = roleKeywords.length > 0 ? domainHits / roleKeywords.length : 1;
+    if (domainRatio < 0.2) {
+      score -= 10;
+      flags.push(`Recent work shows little overlap with ${ctx.agent.role} domain keywords`);
+    }
+  }
+  score = Math.max(0, Math.min(100, score));
+  const detail = flags.length > 0 ? flags.join("; ") : "Identity aligns with roster definition";
+  return { axis: "role-fidelity", score, detail };
+}
+function probeWorldModel(ctx) {
+  if (!ctx.identityBody) {
+    return {
+      axis: "world-model",
+      score: 50,
+      detail: "No identity file \u2014 cannot assess org awareness"
+    };
+  }
+  const identityLower = ctx.identityBody.toLowerCase();
+  const flags = [];
+  let score = 100;
+  const otherAgents = ctx.allEmployees.filter((e) => e.name !== ctx.agent.name);
+  let mentionedAgents = 0;
+  for (const other of otherAgents) {
+    if (identityLower.includes(other.name.toLowerCase())) mentionedAgents++;
+  }
+  if (otherAgents.length > 0) {
+    const mentionRatio = mentionedAgents / otherAgents.length;
+    if (mentionRatio < 0.3) {
+      score -= 15;
+      flags.push(`Identity mentions ${mentionedAgents}/${otherAgents.length} team members`);
+    }
+  }
+  const hasReportingChain = identityLower.includes("report") || identityLower.includes("manager") || identityLower.includes("coo") || identityLower.includes("coordinator");
+  if (!hasReportingChain) {
+    score -= 10;
+    flags.push("Identity does not reference reporting chain");
+  }
+  const orgTerms = ["exe-os", "exe-wiki", "exe-crm", "askexe"];
+  let orgMentions = 0;
+  for (const term of orgTerms) {
+    if (identityLower.includes(term)) orgMentions++;
+  }
+  if (orgMentions === 0) {
+    score -= 5;
+    flags.push("Identity does not reference any org products");
+  }
+  score = Math.max(0, Math.min(100, score));
+  const detail = flags.length > 0 ? flags.join("; ") : "Identity reflects org structure";
+  return { axis: "world-model", score, detail };
+}
+function extractKeyTerms(text) {
+  const stopwords = /* @__PURE__ */ new Set([
+    "the",
+    "and",
+    "for",
+    "are",
+    "but",
+    "not",
+    "you",
+    "all",
+    "any",
+    "can",
+    "had",
+    "her",
+    "was",
+    "one",
+    "our",
+    "out",
+    "has",
+    "his",
+    "how",
+    "its",
+    "may",
+    "new",
+    "now",
+    "old",
+    "see",
+    "way",
+    "who",
+    "did",
+    "get",
+    "got",
+    "let",
+    "say",
+    "she",
+    "too",
+    "use",
+    "with",
+    "this",
+    "that",
+    "from",
+    "they",
+    "been",
+    "have",
+    "will",
+    "your",
+    "what",
+    "when",
+    "make",
+    "like",
+    "just",
+    "over",
+    "such",
+    "take",
+    "than",
+    "them",
+    "very",
+    "some",
+    "could",
+    "into",
+    "then",
+    "more",
+    "also",
+    "after",
+    "should",
+    "would",
+    "about",
+    "their",
+    "which",
+    "these",
+    "other",
+    "every",
+    "does",
+    "being",
+    "those",
+    "never",
+    "before",
+    "through"
+  ]);
+  const words = text.replace(/[^\w\s-]/g, " ").split(/\s+/).filter((w) => w.length > 3 && !stopwords.has(w.toLowerCase()));
+  return [...new Set(words.map((w) => w.toLowerCase()))].slice(0, 50);
+}
+function extractRoleKeywords(role) {
+  const roleKeywordMap = {
+    "coo": ["coordinate", "review", "status", "team", "task", "priority", "dispatch"],
+    "cto": ["architecture", "code", "technical", "system", "design", "review", "security"],
+    "cmo": ["marketing", "brand", "content", "design", "seo", "social", "campaign"],
+    "principal engineer": ["code", "implement", "test", "fix", "feature", "refactor", "build"],
+    "staff code reviewer": ["review", "code", "quality", "issue", "fix", "pattern"],
+    "content production specialist": ["video", "image", "render", "content", "produce", "media"],
+    "ai product lead": ["competitive", "analysis", "feature", "product", "research", "repo"]
+  };
+  const normalized = role.toLowerCase();
+  return roleKeywordMap[normalized] ?? normalized.split(/\s+/).filter((w) => w.length > 2);
+}
+async function runDriftProbes(options = {}) {
+  const employees = loadEmployeesSync();
+  const targetAgents = options.agentId ? employees.filter((e) => e.name === options.agentId) : employees;
+  if (targetAgents.length === 0) {
+    return [];
+  }
+  const axes = options.axes ?? ["continuity", "consistency", "role-fidelity", "world-model"];
+  const results = [];
+  for (const agent of targetAgents) {
+    const identity = getIdentity(agent.name);
+    const { count: memCount, texts: memTexts } = await getRecentMemories(agent.name, 50);
+    const decisionCount = await getDecisionCount(agent.name);
+    const ctx = {
+      agent,
+      identityBody: identity?.body ?? null,
+      identityRole: identity?.frontmatter.role ?? null,
+      recentMemoryCount: memCount,
+      recentMemoryTexts: memTexts,
+      storedDecisionCount: decisionCount,
+      allEmployees: employees
+    };
+    const probes = [];
+    const probeFns = {
+      continuity: probeContinuity,
+      consistency: probeConsistency,
+      "role-fidelity": probeRoleFidelity,
+      "world-model": probeWorldModel
+    };
+    for (const axis of axes) {
+      probes.push(probeFns[axis](ctx));
+    }
+    const scores = {
+      continuity: 0,
+      consistency: 0,
+      "role-fidelity": 0,
+      "world-model": 0
+    };
+    for (const probe of probes) {
+      scores[probe.axis] = probe.score;
+    }
+    const weights = {
+      continuity: 0.2,
+      consistency: 0.2,
+      "role-fidelity": 0.35,
+      "world-model": 0.25
+    };
+    let weightedSum = 0;
+    let weightTotal = 0;
+    for (const axis of axes) {
+      weightedSum += scores[axis] * weights[axis];
+      weightTotal += weights[axis];
+    }
+    const overall = Math.round(weightTotal > 0 ? weightedSum / weightTotal : 0);
+    const flags = [];
+    for (const probe of probes) {
+      if (probe.score < DRIFT_THRESHOLD) {
+        flags.push(`${probe.axis} at ${probe.score}% \u2014 ${probe.detail}`);
+      }
+    }
+    results.push({
+      agent: agent.name,
+      scores,
+      overall,
+      drifting: flags.length > 0,
+      flags
+    });
+  }
+  return results;
+}
+
+export {
+  runDriftProbes
+};

package/dist/chunk-EGR2NYID.js

@@ -0,0 +1,50 @@
+import {
+  sendMessage
+} from "./chunk-6D64562N.js";
+import {
+  getActiveAgent
+} from "./chunk-BXCQWWJP.js";
+
+// src/mcp/tools/send-message.ts
+import { z } from "zod";
+function registerSendMessage(server) {
+  server.registerTool(
+    "send_message",
+    {
+      title: "Send Message",
+      description: "Send a structured message to another agent. Messages are queued and delivered via intercom. NOTE: messages are fire-and-forget \u2014 do NOT use for actionable work dispatch. Use create_task instead to assign work to employees.",
+      inputSchema: {
+        target_agent: z.string().describe("Recipient agent name"),
+        content: z.string().describe("Message content"),
+        target_project: z.string().optional().describe("Project context (optional)"),
+        priority: z.enum(["normal", "urgent"]).default("normal").describe("Message priority (default: normal)"),
+        target_device: z.string().optional().describe("Target device ID for cross-machine delivery (default: local)")
+      }
+    },
+    async ({ target_agent, content, target_project, priority, target_device }) => {
+      const { agentId } = getActiveAgent();
+      const msg = await sendMessage({
+        fromAgent: agentId,
+        targetAgent: target_agent,
+        targetProject: target_project,
+        targetDevice: target_device,
+        content,
+        priority
+      });
+      const statusText = msg.status === "delivered" ? "delivered" : msg.status === "failed" ? `failed: ${msg.failureReason}` : "queued (pending delivery)";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Message sent to ${target_agent}: ${statusText}
+ID: ${msg.id}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+export {
+  registerSendMessage
+};