@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-CHCA3ZM2.js

@@ -0,0 +1,167 @@
+// src/lib/keyword-extractor.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "must",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "just",
+  "and",
+  "but",
+  "or",
+  "if",
+  "while",
+  "because",
+  "until",
+  "about",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "they",
+  "them",
+  "their",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "she",
+  "his",
+  "her"
+]);
+var FILE_PATH_RE = /(?:[\w@.-]+\/)+[\w@.-]+\.[\w]+/g;
+var DOTTED_ID_RE = /\b[a-zA-Z_][\w]*(?:\.[\w]+){1,5}\b/g;
+var CAMEL_CASE_RE = /\b[a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*\b/g;
+var PASCAL_CASE_RE = /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b/g;
+var UPPER_SNAKE_RE = /\b[A-Z][A-Z0-9_]{2,}\b/g;
+var SNAKE_CASE_RE = /\b[a-z]+_[a-z_]+\b/g;
+var KEBAB_FILE_RE = /\b[\w]+-[\w-]+\.[\w]+\b/g;
+var ERROR_CODE_RE = /\b(?:E[A-Z]+|ERR_[A-Z_]+|[0-9]{3})\b/g;
+function extractKeywords(text) {
+  if (!text || text.length === 0) return [];
+  const keywords = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(FILE_PATH_RE)) {
+    keywords.add(match[0]);
+  }
+  for (const match of text.matchAll(DOTTED_ID_RE)) {
+    if (match[0].length > 4) keywords.add(match[0]);
+  }
+  for (const match of text.matchAll(KEBAB_FILE_RE)) {
+    keywords.add(match[0]);
+  }
+  for (const match of text.matchAll(CAMEL_CASE_RE)) {
+    keywords.add(match[0]);
+  }
+  for (const match of text.matchAll(PASCAL_CASE_RE)) {
+    keywords.add(match[0]);
+  }
+  for (const match of text.matchAll(UPPER_SNAKE_RE)) {
+    if (!STOP_WORDS.has(match[0].toLowerCase())) {
+      keywords.add(match[0]);
+    }
+  }
+  for (const match of text.matchAll(SNAKE_CASE_RE)) {
+    if (match[0].length > 4 && !STOP_WORDS.has(match[0])) {
+      keywords.add(match[0]);
+    }
+  }
+  for (const match of text.matchAll(ERROR_CODE_RE)) {
+    keywords.add(match[0]);
+  }
+  const words = text.replace(/[^a-zA-Z0-9\s_.-]/g, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w.toLowerCase()));
+  for (const word of words) {
+    if (word.length >= 4 && !STOP_WORDS.has(word.toLowerCase())) {
+      keywords.add(word);
+    }
+  }
+  return [...keywords];
+}
+function keywordsToString(keywords) {
+  const unique = [...new Set(keywords)];
+  return unique.slice(0, 200).join(" ");
+}
+function stringToKeywords(stored) {
+  if (!stored) return [];
+  return stored.split(/\s+/).filter((k) => k.length > 0);
+}
+
+export {
+  extractKeywords,
+  keywordsToString,
+  stringToKeywords
+};

package/dist/chunk-CHT3THVG.js

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

@@ -0,0 +1,48 @@
+import {
+  extractSemanticText
+} from "./chunk-SUNYJ6YE.js";
+import {
+  detectError
+} from "./chunk-AHMUF6RO.js";
+import {
+  redactSecrets
+} from "./chunk-F7LU65PQ.js";
+import {
+  getProjectName
+} from "./chunk-OPU3NYOO.js";
+
+// src/lib/post-tool-memory.ts
+function buildPostToolMemoryEntry(data, agent) {
+  let rawText = extractSemanticText(data.tool_name, data.tool_input, data.tool_response);
+  if (rawText.trim().length < 10) {
+    const inputPreview = redactSecrets(JSON.stringify(data.tool_input ?? "").slice(0, 500)).text;
+    const outputPreview = redactSecrets(JSON.stringify(data.tool_response ?? "").slice(0, 500)).text;
+    rawText = `Tool call: ${data.tool_name}
+Input: ${inputPreview}
+Output: ${outputPreview}`;
+  }
+  if (rawText.trim().length < 10) return null;
+  const hasError = detectError(data);
+  const toolInputStr = redactSecrets(JSON.stringify(data.tool_input ?? "").slice(0, 200)).text;
+  const toolOutputStr = redactSecrets(JSON.stringify(data.tool_response ?? "").slice(0, 200)).text;
+  return {
+    raw_text: rawText,
+    agent_id: agent.agentId,
+    agent_role: agent.agentRole,
+    tool_name: data.tool_name,
+    project_name: getProjectName(data.cwd ?? process.cwd()),
+    session_id: data.session_id,
+    has_error: hasError,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    trajectory: JSON.stringify({
+      input: toolInputStr,
+      tool: data.tool_name,
+      output: toolOutputStr,
+      result_type: hasError ? "error" : "success"
+    })
+  };
+}
+
+export {
+  buildPostToolMemoryEntry
+};