@askexenow/exe-os 0.9.279 → 0.9.280

package/dist/chunk-6OFFJSL5.js

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

@@ -0,0 +1,240 @@
+import {
+  getClient,
+  isCoordinatorName,
+  loadEmployeesSync
+} from "./chunk-ZJP3ZONM.js";
+
+// src/lib/steward-gate.ts
+import crypto from "crypto";
+var ROLE_PERMISSIONS = {
+  coordinator: /* @__PURE__ */ new Set([
+    "close_task",
+    "cancel_task",
+    "merge_entities",
+    "purge_document",
+    "deactivate_behavior",
+    "override"
+  ]),
+  manager: /* @__PURE__ */ new Set([
+    "close_task",
+    // their team only — enforced contextually
+    "deactivate_behavior"
+    // their team's behaviors
+  ]),
+  specialist: /* @__PURE__ */ new Set([
+    "deactivate_behavior_own",
+    // own behaviors only
+    "delete_own_memory"
+  ])
+};
+var UNIVERSAL_OPS = /* @__PURE__ */ new Set([
+  "update_own_task",
+  "store_memory",
+  "store_behavior"
+]);
+var MANAGER_ROLES = /* @__PURE__ */ new Set(["CTO", "CMO"]);
+var StewardGate = class {
+  /**
+   * Check whether an agent has authority for a destructive operation.
+   */
+  async checkAuthority(agent, operation, target) {
+    const role = await this.resolveRole(agent);
+    if (UNIVERSAL_OPS.has(operation)) {
+      const decision2 = {
+        allowed: true,
+        reason: `Operation "${operation}" is universally permitted.`,
+        confidence: 1,
+        requires_override: false
+      };
+      await this.logDecision(agent, operation, target, decision2);
+      return decision2;
+    }
+    const permissions = ROLE_PERMISSIONS[role];
+    let allowed = permissions.has(operation);
+    let reason;
+    if (!allowed && role === "specialist" && operation === "deactivate_behavior") {
+      const isOwn = await this.isOwnBehavior(agent, target);
+      if (isOwn) {
+        allowed = true;
+        reason = `Specialist "${agent}" can deactivate their own behavior.`;
+      } else {
+        reason = `Specialist "${agent}" cannot deactivate behaviors belonging to other agents.`;
+      }
+    } else if (allowed) {
+      reason = `Role "${role}" has authority for "${operation}".`;
+    } else {
+      reason = `Role "${role}" does not have authority for "${operation}". Requires coordinator override.`;
+    }
+    let requiresOverride = !allowed;
+    let confidence = allowed ? 0.95 : 0.9;
+    try {
+      const dreamingPath = "./dreaming.js";
+      const dreaming = await import(
+        /* @vite-ignore */
+        dreamingPath
+      );
+      if (typeof dreaming.calculateDrift === "function") {
+        const driftScore = await dreaming.calculateDrift(agent);
+        if (typeof driftScore === "number" && driftScore > 0.8) {
+          requiresOverride = true;
+          confidence = Math.max(0.5, confidence - 0.3);
+          reason += ` (\u26A0\uFE0F High drift score: ${driftScore.toFixed(2)} \u2014 requires override.)`;
+        }
+      }
+    } catch {
+    }
+    const decision = {
+      allowed: allowed && !requiresOverride,
+      reason,
+      confidence,
+      requires_override: requiresOverride
+    };
+    await this.logDecision(agent, operation, target, decision);
+    return decision;
+  }
+  /**
+   * Record an explicit coordinator override that bypasses the gate.
+   */
+  async override(agent, operation, target, reason) {
+    const role = await this.resolveRole(agent);
+    if (role !== "coordinator") {
+      const decision2 = {
+        allowed: false,
+        reason: `Only coordinators can issue overrides. "${agent}" is a ${role}.`,
+        confidence: 1,
+        requires_override: false
+      };
+      await this.logDecision(agent, `override:${operation}`, target, decision2);
+      return decision2;
+    }
+    const decision = {
+      allowed: true,
+      reason: `Coordinator override: ${reason}`,
+      confidence: 1,
+      requires_override: false
+    };
+    await this.logDecision(agent, `override:${operation}`, target, decision);
+    return decision;
+  }
+  /**
+   * Query the audit trail.
+   */
+  async getAuditLog(opts) {
+    await this.ensureAuditTable();
+    const client = getClient();
+    const conditions = [];
+    const args = [];
+    if (opts?.agent) {
+      conditions.push("agent = ?");
+      args.push(opts.agent);
+    }
+    if (opts?.operation) {
+      conditions.push("operation = ?");
+      args.push(opts.operation);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = opts?.limit ?? 50;
+    const result = await client.execute({
+      sql: `SELECT * FROM steward_audit ${where} ORDER BY created_at DESC LIMIT ?`,
+      args: [...args, limit]
+    });
+    return result.rows.map((row) => ({
+      id: String(row.id),
+      agent: String(row.agent),
+      operation: String(row.operation),
+      target: String(row.target),
+      decision: {
+        allowed: Number(row.allowed) === 1,
+        reason: String(row.reason),
+        confidence: Number(row.confidence),
+        requires_override: Number(row.requires_override) === 1
+      },
+      timestamp: String(row.created_at)
+    }));
+  }
+  // -------------------------------------------------------------------------
+  // Internal methods
+  // -------------------------------------------------------------------------
+  /**
+   * Resolve an agent name to a role category.
+   */
+  async resolveRole(agent) {
+    if (isCoordinatorName(agent)) return "coordinator";
+    try {
+      const employees = loadEmployeesSync();
+      const employee = employees.find((e) => e.name === agent);
+      if (employee && MANAGER_ROLES.has(employee.role)) return "manager";
+    } catch {
+    }
+    return "specialist";
+  }
+  /**
+   * Check if a behavior belongs to the given agent.
+   */
+  async isOwnBehavior(agent, behaviorId) {
+    try {
+      const client = getClient();
+      const result = await client.execute({
+        sql: "SELECT agent_id FROM behaviors WHERE id = ? LIMIT 1",
+        args: [behaviorId]
+      });
+      if (result.rows.length === 0) return false;
+      return String(result.rows[0].agent_id) === agent;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Ensure the steward_audit table exists.
+   */
+  async ensureAuditTable() {
+    const client = getClient();
+    await client.execute({
+      sql: `CREATE TABLE IF NOT EXISTS steward_audit (
+        id                TEXT PRIMARY KEY,
+        agent             TEXT NOT NULL,
+        operation         TEXT NOT NULL,
+        target            TEXT NOT NULL,
+        allowed           INTEGER NOT NULL,
+        reason            TEXT NOT NULL,
+        confidence        REAL NOT NULL,
+        requires_override INTEGER NOT NULL DEFAULT 0,
+        created_at        TEXT NOT NULL
+      )`,
+      args: []
+    });
+  }
+  /**
+   * Log a gate decision to the audit trail.
+   */
+  async logDecision(agent, operation, target, decision) {
+    try {
+      await this.ensureAuditTable();
+      const client = getClient();
+      await client.execute({
+        sql: `INSERT INTO steward_audit (id, agent, operation, target, allowed, reason, confidence, requires_override, created_at)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          crypto.randomUUID(),
+          agent,
+          operation,
+          target,
+          decision.allowed ? 1 : 0,
+          decision.reason,
+          decision.confidence,
+          decision.requires_override ? 1 : 0,
+          (/* @__PURE__ */ new Date()).toISOString()
+        ]
+      });
+    } catch {
+      process.stderr.write(
+        `[steward-gate] Audit log write failed for ${agent}:${operation}
+`
+      );
+    }
+  }
+};
+
+export {
+  StewardGate
+};

package/dist/chunk-6WFUH2B4.js

@@ -0,0 +1,345 @@
+import {
+  employeeSessionName,
+  isEmployeeAlive,
+  resolveExeSession,
+  sendIntercom,
+  strictSessionScopeFilter
+} from "./chunk-UKVPGFD4.js";
+import {
+  parseMessage,
+  serializeMessage
+} from "./chunk-4JERP7NT.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-X46O77S4.js";
+import {
+  getClient
+} from "./chunk-ZJP3ZONM.js";
+
+// src/lib/messaging.ts
+import crypto from "crypto";
+function generateUlid() {
+  const timestamp = Date.now().toString(36).padStart(10, "0");
+  const random = crypto.randomBytes(10).toString("hex").slice(0, 16);
+  return (timestamp + random).toUpperCase();
+}
+function rowToMessage(row) {
+  return {
+    id: row.id,
+    fromAgent: row.from_agent,
+    fromDevice: row.from_device,
+    targetAgent: row.target_agent,
+    targetProject: row.target_project ?? null,
+    targetDevice: row.target_device,
+    sessionScope: row.session_scope ?? null,
+    content: row.content,
+    priority: row.priority ?? "normal",
+    status: row.status ?? "pending",
+    serverSeq: row.server_seq != null ? Number(row.server_seq) : null,
+    retryCount: Number(row.retry_count ?? 0),
+    createdAt: row.created_at,
+    deliveredAt: row.delivered_at ?? null,
+    processedAt: row.processed_at ?? null,
+    failedAt: row.failed_at ?? null,
+    failureReason: row.failure_reason ?? null
+  };
+}
+var MAX_RETRIES = 10;
+async function countUnreadMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT COUNT(*) AS count FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}`,
+    args: [targetAgent, ...scope.args]
+  });
+  return Number(result.rows[0]?.count ?? 0);
+}
+async function sendMessage(input) {
+  const client = getClient();
+  const id = generateUlid();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const targetDevice = input.targetDevice ?? "local";
+  const sessionScope = input.sessionScope === void 0 ? resolveExeSession() : input.sessionScope;
+  await client.execute({
+    sql: `INSERT INTO messages (id, from_agent, from_device, target_agent, target_project, target_device, session_scope, content, priority, status, founder_id, created_at)
+          VALUES (?, ?, 'local', ?, ?, ?, ?, ?, ?, 'pending', ?, ?)`,
+    args: [
+      id,
+      input.fromAgent,
+      input.targetAgent,
+      input.targetProject ?? null,
+      targetDevice,
+      sessionScope,
+      input.content,
+      input.priority ?? "normal",
+      input.founderId ?? null,
+      now
+    ]
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "message.sent",
+    source: "messaging.sendMessage",
+    agentId: input.fromAgent,
+    payload: { targetAgent: input.targetAgent, priority: input.priority ?? "normal", targetDevice },
+    sessionScope: sessionScope ?? null
+  });
+  try {
+    if (targetDevice !== "local") {
+      await deliverCrossMachineMessage(id, targetDevice);
+    } else {
+      await deliverLocalMessage(id);
+    }
+  } catch {
+  }
+  const sentScope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages WHERE id = ?${sentScope.sql}`,
+    args: [id, ...sentScope.args]
+  });
+  return rowToMessage(result.rows[0]);
+}
+var _wsClientSend = null;
+function setWsClientSend(fn) {
+  _wsClientSend = fn;
+}
+async function deliverCrossMachineMessage(messageId, targetDevice) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  if (!_wsClientSend) {
+    return false;
+  }
+  const payload = JSON.stringify({
+    id: msg.id,
+    fromAgent: msg.fromAgent,
+    targetAgent: msg.targetAgent,
+    targetProject: msg.targetProject,
+    sessionScope: msg.sessionScope,
+    content: msg.content,
+    priority: msg.priority,
+    createdAt: msg.createdAt
+  });
+  const sent = _wsClientSend(targetDevice, payload);
+  if (sent) {
+    await client.execute({
+      sql: "UPDATE messages SET status = 'synced' WHERE id = ?",
+      args: [messageId]
+    });
+    return true;
+  }
+  return false;
+}
+async function deliverLocalMessage(messageId) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  const targetAgent = msg.targetAgent;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      throw new Error("No coordinator session found");
+    }
+    process.stderr.write(`[messaging] ENTER deliverLocal: target=${targetAgent} exeSession=${exeSession}
+`);
+    const { isCoordinatorName: isCoord } = await import("./lib/employees.js");
+    const isCOO = isCoord(targetAgent);
+    process.stderr.write(`[messaging] COO check: targetAgent="${targetAgent}" isCOO=${isCOO}
+`);
+    const sessionName = isCOO ? exeSession : employeeSessionName(targetAgent, exeSession);
+    process.stderr.write(`[messaging] delivery attempt: target=${targetAgent} session=${sessionName} isCOO=${isCOO}
+`);
+    if (!isCOO && !isEmployeeAlive(sessionName)) {
+      throw new Error("Session not running \u2014 message stays queued");
+    }
+    const unreadCount = await countUnreadMessages(targetAgent, msg.sessionScope);
+    if (unreadCount <= 0) {
+      return false;
+    }
+    const intercomResult = sendIntercom(sessionName, { force: true, reason: "message" });
+    process.stderr.write(`[messaging] intercom result for ${sessionName}: ${intercomResult}
+`);
+    await client.execute({
+      sql: "UPDATE messages SET status = 'delivered', delivered_at = ? WHERE id = ?",
+      args: [now, messageId]
+    });
+    recordOrchestrationEventBestEffort({
+      eventType: "message.delivered",
+      source: "messaging.deliverLocalMessage",
+      agentId: msg.targetAgent,
+      payload: { fromAgent: msg.fromAgent, priority: msg.priority }
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[messaging] delivery failed for message ${messageId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    const newRetryCount = msg.retryCount + 1;
+    if (newRetryCount >= MAX_RETRIES) {
+      await markFailed(messageId, "session unavailable after 10 retries", msg.sessionScope);
+    } else {
+      await client.execute({
+        sql: "UPDATE messages SET retry_count = ? WHERE id = ?",
+        args: [newRetryCount, messageId]
+      });
+    }
+    return false;
+  }
+}
+async function getPendingMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function markRead(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'read'
+          WHERE id = ? AND status IN ('pending', 'delivered')${scope.sql}`,
+    args: [messageId, ...scope.args]
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "message.read",
+    source: "messaging.markRead",
+    payload: { messageId }
+  });
+}
+async function markAcknowledged(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'acknowledged', processed_at = ?
+          WHERE id = ? AND status = 'read'${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId, ...scope.args]
+  });
+}
+async function markProcessed(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'processed', processed_at = ?
+          WHERE id = ?${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId, ...scope.args]
+  });
+}
+async function getMessageStatus(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT status FROM messages WHERE id = ?${scope.sql}`,
+    args: [messageId, ...scope.args]
+  });
+  return result.rows[0]?.status ?? null;
+}
+async function getUnacknowledgedMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered', 'read')${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function getReadMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status = 'read'${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function markFailed(messageId, reason, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'failed', failed_at = ?, failure_reason = ?
+          WHERE id = ?${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), reason, messageId, ...scope.args]
+  });
+}
+async function getFailedMessages(sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages WHERE status = 'failed'${scope.sql} ORDER BY created_at DESC`,
+    args: [...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function retryPendingMessages(sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE status = 'pending' AND retry_count < ?${scope.sql}
+          ORDER BY id`,
+    args: [MAX_RETRIES, ...scope.args]
+  });
+  let delivered = 0;
+  for (const row of result.rows) {
+    const msg = rowToMessage(row);
+    try {
+      const success = await deliverLocalMessage(msg.id);
+      if (success) delivered++;
+    } catch {
+    }
+  }
+  return delivered;
+}
+async function sendTypedMessage(envelope, targetAgent, opts) {
+  return sendMessage({
+    fromAgent: envelope.from,
+    targetAgent,
+    targetProject: opts?.targetProject,
+    targetDevice: opts?.targetDevice,
+    content: serializeMessage(envelope),
+    priority: opts?.priority,
+    sessionScope: opts?.sessionScope
+  });
+}
+function parseIncomingMessage(content) {
+  return parseMessage(content);
+}
+
+export {
+  countUnreadMessages,
+  sendMessage,
+  setWsClientSend,
+  deliverLocalMessage,
+  getPendingMessages,
+  markRead,
+  markAcknowledged,
+  markProcessed,
+  getMessageStatus,
+  getUnacknowledgedMessages,
+  getReadMessages,
+  markFailed,
+  getFailedMessages,
+  retryPendingMessages,
+  sendTypedMessage,
+  parseIncomingMessage
+};