@askexenow/exe-os 0.9.292 → 0.9.293

package/dist/chunk-VRFO3H3R.js

@@ -0,0 +1,76 @@
+import {
+  fastDbInit
+} from "./chunk-QAK47LG3.js";
+import {
+  sessionScopeFilter
+} from "./chunk-2ZXMXFGH.js";
+import {
+  formatStatusAll,
+  formatStatusDeep,
+  getEmployeeStatuses,
+  inTmux
+} from "./chunk-SSTLTIF3.js";
+import {
+  getClient,
+  isCoordinatorRole,
+  loadEmployees
+} from "./chunk-TM2GZWIT.js";
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+
+// src/bin/exe-status.ts
+async function status(targetEmployee) {
+  if (!inTmux()) {
+    return "Not in a tmux session. Start tmux first: tmux new-session -s work";
+  }
+  const employees = await loadEmployees();
+  const names = employees.filter((e) => !isCoordinatorRole(e.role)).map((e) => e.name);
+  const roles = new Map(employees.map((e) => [e.name, e.role ?? ""]));
+  await fastDbInit();
+  const client = getClient();
+  const taskMap = /* @__PURE__ */ new Map();
+  try {
+    const esScope = sessionScopeFilter();
+    const result = await client.execute({
+      sql: `SELECT assigned_to, title, priority FROM tasks
+            WHERE status = 'in_progress'${esScope.sql}
+            ORDER BY priority ASC, created_at ASC`,
+      args: [...esScope.args]
+    });
+    for (const row of result.rows) {
+      const assignee = String(row.assigned_to);
+      if (!taskMap.has(assignee)) {
+        taskMap.set(assignee, {
+          title: String(row.title),
+          priority: String(row.priority)
+        });
+      }
+    }
+  } catch {
+  }
+  if (targetEmployee) {
+    if (!names.includes(targetEmployee)) {
+      return `Employee "${targetEmployee}" not found. Available: ${names.join(", ")}`;
+    }
+    const statuses2 = getEmployeeStatuses([targetEmployee]);
+    const s = statuses2[0];
+    return formatStatusDeep(s, taskMap.get(targetEmployee), roles.get(targetEmployee) ?? "");
+  }
+  const statuses = getEmployeeStatuses(names);
+  return formatStatusAll(statuses, taskMap, roles);
+}
+if (isMainModule(import.meta.url)) {
+  const target = process.argv[2];
+  status(target).then((output) => {
+    process.stdout.write(output + "\n");
+  }).catch((err) => {
+    process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
+
+export {
+  status
+};

package/dist/chunk-VRZS4KWF.js

@@ -0,0 +1,122 @@
+import {
+  getActiveAgent
+} from "./chunk-NMJSZ5FC.js";
+import {
+  listTasks
+} from "./chunk-2ZXMXFGH.js";
+import {
+  getAgentContext
+} from "./chunk-GJV3WDWM.js";
+import {
+  isCoordinatorName
+} from "./chunk-TM2GZWIT.js";
+
+// src/mcp/tools/list-tasks.ts
+import { z } from "zod";
+function registerListTasks(server) {
+  server.registerTool(
+    "list_tasks",
+    {
+      title: "List Tasks",
+      description: "Query tasks by assignee, status, project, or priority. Defaults to current project. Pass project_name='all' for all projects. When querying your own tasks, project filter is skipped automatically.",
+      inputSchema: {
+        assigned_to: z.string().optional().describe("Filter by employee name"),
+        status: z.enum(["open", "in_progress", "done", "needs_review", "blocked", "cancelled", "closed"]).optional().describe("Filter by status. Default: active tasks only (excludes closed/cancelled)"),
+        project_name: z.string().optional().describe("Project name. Defaults to current project. Pass 'all' for all projects."),
+        priority: z.enum(["p0", "p1", "p2"]).optional().describe("Filter by priority"),
+        cross_session: z.boolean().optional().describe("When true, return tasks from ALL coordinator sessions (read-only). Default: false.")
+      }
+    },
+    async ({ assigned_to, status, project_name, priority, cross_session }) => {
+      try {
+        const { agentId } = getActiveAgent();
+        const isReviewQueue = status === "needs_review";
+        const shouldDefaultToOwnQueue = !assigned_to && !isReviewQueue && !isCoordinatorName(agentId);
+        const effectiveAssignedTo = assigned_to ?? (shouldDefaultToOwnQueue ? agentId : void 0);
+        const effectiveReviewer = !assigned_to && isReviewQueue ? agentId : void 0;
+        const isOwnQuery = effectiveAssignedTo === agentId;
+        const callerSession = getAgentContext()?.sessionHint || process.env.EXE_SESSION_NAME || process.env.EXE_SESSION || null;
+        const resolvedProject = project_name && project_name !== "all" ? project_name : null;
+        const effectiveCrossSession = cross_session === true;
+        const identityAmbiguous = !callerSession && (agentId === "default" || !agentId);
+        let tasks = await listTasks({
+          assignedTo: effectiveAssignedTo,
+          reviewer: effectiveReviewer,
+          status,
+          projectName: resolvedProject,
+          priority,
+          crossSession: effectiveCrossSession,
+          isOwnQuery: !!isOwnQuery,
+          callerSession
+        });
+        let recoveredCrossSession = false;
+        if (tasks.length === 0 && identityAmbiguous && !effectiveCrossSession) {
+          const crossTasks = await listTasks({
+            // Drop the own-queue assignee default — identity is unreliable here.
+            assignedTo: assigned_to,
+            reviewer: effectiveReviewer,
+            status,
+            projectName: resolvedProject,
+            priority,
+            crossSession: true,
+            isOwnQuery: false,
+            callerSession: null
+          });
+          if (crossTasks.length > 0) {
+            tasks = crossTasks;
+            recoveredCrossSession = true;
+          }
+        }
+        if (tasks.length === 0) {
+          if (identityAmbiguous) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "Could not resolve your session identity (multiple coordinator sessions are live and no per-session MCP header was provided). Task scoping is unreliable, and a cross-session read also returned no rows. If you expect tasks to exist, retry with cross_session=true and an explicit project_name='all', or configure a per-session MCP header (X-Exe-Session). Treat this as 'unknown', NOT 'empty'."
+                }
+              ],
+              isError: true
+            };
+          }
+          return {
+            content: [{ type: "text", text: "No tasks found." }]
+          };
+        }
+        const lines = tasks.map((t) => {
+          const cpIndicator = t.checkpointCount && t.checkpointCount > 0 ? ` [cp:${t.checkpointCount}]` : "";
+          let budgetNote = "";
+          if (t.budgetTokens !== null) {
+            const pct = Math.round(t.tokensUsed / t.budgetTokens * 100);
+            budgetNote = ` [${t.tokensUsed}/${t.budgetTokens} tokens, ${pct}%]`;
+          }
+          const shortId = t.id.slice(0, 8);
+          const showSession = cross_session || recoveredCrossSession;
+          const sessionNote = showSession && t.sessionScope ? ` [session:${t.sessionScope}]` : "";
+          return `- [${t.priority.toUpperCase()}] ${t.title} (${t.projectName}) \u2014 ${t.status}${cpIndicator}${budgetNote}${sessionNote} \u2192 ${t.assignedTo} [id:${shortId}]`;
+        });
+        const header = recoveredCrossSession ? `WARNING: session identity was ambiguous (multiple coordinator sessions, no per-session MCP header) \u2014 showing tasks ACROSS ALL sessions. Configure a per-session X-Exe-Session header for scoped results.
+${tasks.length} task(s) (cross-session):` : `${tasks.length} task(s):`;
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${header}
+${lines.join("\n")}`
+            }
+          ]
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Failed to list tasks: ${msg}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+export {
+  registerListTasks
+};

package/dist/chunk-WOXY76VV.js

@@ -0,0 +1,33 @@
+import {
+  completeReminder
+} from "./chunk-XWVCURC2.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-X6VOKECC.js

@@ -0,0 +1,348 @@
+import {
+  getIdentity,
+  loadEmployeesSync
+} from "./chunk-TM2GZWIT.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
+};