@askexenow/exe-os 0.9.292 → 0.9.293

package/dist/catchup-brief-EPEKZKRA.js

@@ -0,0 +1,175 @@
+import {
+  lightweightSearch
+} from "./chunk-STOZKLK6.js";
+import "./chunk-AB4PAQYK.js";
+import "./chunk-NXCJWGAF.js";
+import "./chunk-CHCA3ZM2.js";
+import "./chunk-OTVEIJUQ.js";
+import "./chunk-XWRIBBYP.js";
+import "./chunk-Y25OJWOQ.js";
+import {
+  sessionScopeFilter,
+  strictSessionScopeFilter
+} from "./chunk-TWFTSIAI.js";
+import "./chunk-XADXYWPE.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-4FVVJ7ME.js";
+import "./chunk-YUIT7Z7I.js";
+import "./chunk-HN3HGFBL.js";
+import "./chunk-YNORJIBH.js";
+import "./chunk-SSTLTIF3.js";
+import "./chunk-B5ZCGIYB.js";
+import "./chunk-QRTJNSKU.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-HWY5ROLO.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-JLH273CW.js";
+import "./chunk-HYZV25LY.js";
+import {
+  getClient
+} from "./chunk-IDJCLLJF.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-Q326CKO3.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-Z42MXYWW.js";
+import "./chunk-YTKVJJSU.js";
+import "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/catchup-brief.ts
+import { execSync } from "child_process";
+var HEADER = "## Catchup Brief\nHere's what happened while you were offline:";
+var DEFAULT_LOOKBACK_MS = 60 * 60 * 1e3;
+var MAX_BRIEF_CHARS = 2e3;
+var MAX_CHECKPOINT_CHARS = 500;
+var MAX_MESSAGE_CHARS = 100;
+function clipText(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  if (maxChars <= 1) return "\u2026";
+  return `${text.slice(0, maxChars - 1).trimEnd()}\u2026`;
+}
+function clampSections(header, sections, maxChars) {
+  const bounded = [];
+  let remaining = Math.max(0, maxChars - header.length);
+  for (const section of sections) {
+    const separatorChars = 2;
+    if (remaining <= separatorChars) break;
+    remaining -= separatorChars;
+    if (section.length <= remaining) {
+      bounded.push(section);
+      remaining -= section.length;
+      continue;
+    }
+    const clipped = clipText(section, remaining);
+    if (clipped.trim().length > 0) bounded.push(clipped);
+    break;
+  }
+  return bounded;
+}
+async function buildCatchupBrief(agentId, projectName, cwd, sessionScope) {
+  const sections = [];
+  let lastTimestamp = new Date(Date.now() - DEFAULT_LOOKBACK_MS).toISOString();
+  try {
+    const checkpointMemories = await lightweightSearch(
+      "CONTEXT CHECKPOINT",
+      agentId,
+      { projectName, limit: 1 }
+    );
+    const checkpoint = checkpointMemories[0];
+    if (checkpoint?.timestamp) {
+      lastTimestamp = checkpoint.timestamp;
+    }
+    if (checkpoint?.raw_text) {
+      sections.push(
+        `### Last Checkpoint
+${clipText(checkpoint.raw_text, MAX_CHECKPOINT_CHARS)}`
+      );
+    }
+  } catch {
+  }
+  try {
+    const gitLog = execSync(
+      `git log --oneline --since=${JSON.stringify(lastTimestamp)} --format="%h %an: %s" | head -10`,
+      { cwd, timeout: 3e3, encoding: "utf-8" }
+    ).trim();
+    if (gitLog) {
+      sections.push(`### Git Activity Since You Left
+\`\`\`
+${gitLog}
+\`\`\``);
+    }
+  } catch {
+  }
+  try {
+    const client = getClient();
+    const taskScope = sessionScopeFilter(sessionScope);
+    const taskChanges = await client.execute({
+      sql: `SELECT title, status, priority FROM tasks
+            WHERE assigned_to = ? AND project_name = ?
+              AND updated_at > ? AND status IN ('open', 'in_progress')${taskScope.sql}
+            ORDER BY priority ASC, updated_at DESC LIMIT 5`,
+      args: [agentId, projectName, lastTimestamp, ...taskScope.args]
+    });
+    if (taskChanges.rows.length > 0) {
+      const taskLines = taskChanges.rows.map((row) => {
+        const record = row;
+        return `- [${String(record.priority).toUpperCase()}] ${String(record.title)} (${String(record.status)})`;
+      }).join("\n");
+      sections.push(`### Your Task Queue
+${taskLines}`);
+    }
+  } catch {
+  }
+  try {
+    const client = getClient();
+    const messageScope = strictSessionScopeFilter(sessionScope);
+    const messages = await client.execute({
+      sql: `SELECT from_agent, content, created_at FROM messages
+            WHERE target_agent = ? AND status = 'pending'${messageScope.sql}
+            ORDER BY created_at DESC LIMIT 3`,
+      args: [agentId, ...messageScope.args]
+    });
+    if (messages.rows.length > 0) {
+      const msgLines = messages.rows.map((row) => {
+        const record = row;
+        return `- From ${String(record.from_agent)}: ${clipText(String(record.content ?? ""), MAX_MESSAGE_CHARS)}`;
+      }).join("\n");
+      sections.push(`### Unread Messages
+${msgLines}`);
+    }
+  } catch {
+  }
+  try {
+    const { getPendingProspective, markSurfaced } = await import("./prospective-memory-WQSB2IPD.js");
+    const due = await getPendingProspective(agentId, { projectName, limit: 5 });
+    if (due.length > 0) {
+      const now = Date.now();
+      const lines = due.map((item) => {
+        const overdue = item.dueDate != null && new Date(item.dueDate).getTime() < now;
+        const when = item.dueDate ? `due ${item.dueDate}${overdue ? " \u2014 OVERDUE" : ""}` : "someday";
+        const recur = item.recurrence !== "once" ? `, ${item.recurrence}` : "";
+        return `- [P${item.priority}] ${clipText(item.content, MAX_CHECKPOINT_CHARS)} (${when}${recur})`;
+      });
+      sections.push(`### Reminders Due (Prospective Memory)
+${lines.join("\n")}`);
+      try {
+        await markSurfaced(due.map((d) => d.id));
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return {
+    header: HEADER,
+    sections: clampSections(HEADER, sections, MAX_BRIEF_CHARS)
+  };
+}
+export {
+  buildCatchupBrief
+};

package/dist/chunk-2EMOVUJR.js

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

package/dist/chunk-2JE7LJCZ.js

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