botinabox 1.5.0 → 1.7.0

package/dist/index.js

@@ -774,6 +774,147 @@ var MessagePipeline = class {
   }
 };
 
+// src/core/chat/triage-router.ts
+var TriageRouter = class {
+  constructor(db, hooks, config) {
+    this.db = db;
+    this.hooks = hooks;
+    this.rules = config.rules;
+    this.fallbackAgent = config.fallbackAgent;
+    this.llmFallback = config.llmFallback ?? true;
+    this.persist = config.persist ?? true;
+    this.compiledRules = this.rules.sort((a, b) => (a.priority ?? 50) - (b.priority ?? 50)).map((rule) => ({
+      rule,
+      regexes: (rule.patterns ?? []).map((p) => new RegExp(p, "i")),
+      keywordSet: new Set((rule.keywords ?? []).map((k) => k.toLowerCase()))
+    }));
+  }
+  db;
+  hooks;
+  rules;
+  fallbackAgent;
+  llmFallback;
+  persist;
+  compiledRules;
+  /**
+   * Route an inbound message to the best agent.
+   * Returns the agent slug and the routing decision.
+   */
+  async route(msg) {
+    const body = msg.body.toLowerCase();
+    const words = new Set(body.split(/\s+/));
+    for (const { rule, regexes, keywordSet } of this.compiledRules) {
+      for (const keyword of keywordSet) {
+        if (words.has(keyword) || body.includes(keyword)) {
+          const decision2 = this.buildDecision(
+            rule.agentSlug,
+            `keyword: '${keyword}'`,
+            "deterministic",
+            msg
+          );
+          await this.logDecision(decision2);
+          return { agentSlug: rule.agentSlug, decision: decision2 };
+        }
+      }
+      for (const regex of regexes) {
+        if (regex.test(msg.body)) {
+          const decision2 = this.buildDecision(
+            rule.agentSlug,
+            `pattern: ${regex.source}`,
+            "deterministic",
+            msg
+          );
+          await this.logDecision(decision2);
+          return { agentSlug: rule.agentSlug, decision: decision2 };
+        }
+      }
+    }
+    if (this.llmFallback) {
+      const agentSlugs = this.rules.map((r) => r.agentSlug);
+      const classified = await this.classifyWithLLM(msg, agentSlugs);
+      if (classified) {
+        const decision2 = this.buildDecision(
+          classified.agentSlug,
+          `llm: ${classified.reason}`,
+          "llm",
+          msg
+        );
+        await this.logDecision(decision2);
+        return { agentSlug: classified.agentSlug, decision: decision2 };
+      }
+    }
+    const decision = this.buildDecision(
+      this.fallbackAgent,
+      "fallback: no rule matched",
+      "deterministic",
+      msg
+    );
+    await this.logDecision(decision);
+    return { agentSlug: this.fallbackAgent, decision };
+  }
+  /**
+   * Query the ownership chain for a given message or channel.
+   */
+  async getDecisionHistory(filter) {
+    const rows = await this.db.query("activity_log", {
+      where: { event_type: "triage_decision" }
+    });
+    let decisions = rows.map((r) => {
+      try {
+        return JSON.parse(r["payload"]);
+      } catch {
+        return null;
+      }
+    }).filter((d) => d !== null);
+    if (filter?.channel) {
+      decisions = decisions.filter((d) => d.channel === filter.channel);
+    }
+    decisions.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    if (filter?.limit) {
+      decisions = decisions.slice(0, filter.limit);
+    }
+    return decisions;
+  }
+  /**
+   * LLM classification — emits a hook for external LLM integration.
+   * Returns agent slug + reason, or undefined if LLM is unavailable.
+   */
+  async classifyWithLLM(msg, agentSlugs) {
+    const result = {};
+    await this.hooks.emit("triage.classify", {
+      message: msg,
+      candidates: agentSlugs,
+      respond: (slug, reason) => {
+        result.agentSlug = slug;
+        result.reason = reason;
+      }
+    });
+    if (result.agentSlug && result.reason) {
+      return { agentSlug: result.agentSlug, reason: result.reason };
+    }
+    return void 0;
+  }
+  buildDecision(target, reason, method, msg) {
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "triage",
+      target: target ?? "none",
+      reason,
+      method,
+      messageId: msg.id,
+      channel: msg.channel
+    };
+  }
+  async logDecision(decision) {
+    if (!this.persist) return;
+    await this.db.insert("activity_log", {
+      event_type: "triage_decision",
+      payload: JSON.stringify(decision)
+    });
+    await this.hooks.emit("triage.routed", { decision });
+  }
+};
+
 // src/core/chat/session-key.ts
 var SessionKey = class _SessionKey {
   constructor(agentId, channel, scope) {
@@ -1018,6 +1159,441 @@ var NotificationQueue = class {
   }
 };
 
+// src/core/chat/message-store.ts
+var MessageStore = class {
+  constructor(db, hooks) {
+    this.db = db;
+    this.hooks = hooks;
+  }
+  db;
+  hooks;
+  /**
+   * Store an inbound message and its attachments.
+   * Must complete successfully before any bot response is generated.
+   */
+  async storeInbound(msg) {
+    const row = await this.db.insert("messages", {
+      channel: msg.channel,
+      direction: "inbound",
+      from_user: msg.from,
+      user_id: msg.userId,
+      body: msg.body,
+      thread_id: msg.threadId
+    });
+    const messageId = row["id"];
+    const attachmentIds = [];
+    if (msg.attachments && msg.attachments.length > 0) {
+      for (const att of msg.attachments) {
+        const attId = await this.storeAttachment(messageId, {
+          fileType: att.type,
+          filename: att.filename,
+          mimeType: att.mimeType,
+          sizeBytes: att.size,
+          url: att.url
+        });
+        attachmentIds.push(attId);
+      }
+    }
+    await this.hooks.emit("message.stored", {
+      messageId,
+      direction: "inbound",
+      channel: msg.channel,
+      from: msg.from,
+      attachmentCount: attachmentIds.length
+    });
+    return { messageId, attachmentIds };
+  }
+  /**
+   * Store an outbound message BEFORE sending it.
+   * Returns the message ID for confirmation tracking.
+   */
+  async storeOutbound(opts) {
+    const row = await this.db.insert("messages", {
+      channel: opts.channel,
+      direction: "outbound",
+      from_agent: opts.agentSlug,
+      agent_id: opts.agentId,
+      body: opts.text,
+      thread_id: opts.threadId,
+      task_id: opts.taskId
+    });
+    const messageId = row["id"];
+    await this.hooks.emit("message.stored", {
+      messageId,
+      direction: "outbound",
+      channel: opts.channel
+    });
+    return messageId;
+  }
+  /**
+   * Store an attachment linked to a message.
+   */
+  async storeAttachment(messageId, att) {
+    const row = await this.db.insert("message_attachments", {
+      message_id: messageId,
+      file_type: att.fileType,
+      filename: att.filename,
+      mime_type: att.mimeType,
+      size_bytes: att.sizeBytes,
+      contents: att.contents,
+      summary: att.summary,
+      url: att.url
+    });
+    return row["id"];
+  }
+  /**
+   * Get recent messages in a thread for context building.
+   */
+  async getThreadHistory(threadId, limit = 20) {
+    const messages = await this.db.query("messages", {
+      where: { thread_id: threadId },
+      orderBy: "created_at",
+      limit
+    });
+    return messages;
+  }
+  /**
+   * Get recent outbound messages in a thread for redundancy checking.
+   */
+  async getRecentOutbound(threadId, limit = 10) {
+    const messages = await this.db.query("messages", {
+      where: { thread_id: threadId, direction: "outbound" },
+      orderBy: "created_at",
+      limit
+    });
+    return messages;
+  }
+  /**
+   * Get attachments for a message.
+   */
+  async getAttachments(messageId) {
+    return this.db.query("message_attachments", {
+      where: { message_id: messageId }
+    });
+  }
+};
+
+// src/core/chat/chat-responder.ts
+var DEFAULT_SYSTEM_PROMPT = `You are a helpful, enthusiastic AI digital assistant. Your job is to:
+- Acknowledge the user's message and relay what you understand
+- Let them know what will happen next (if a task is being worked on)
+- Answer conversational questions directly
+- Be honest when you need to look something up \u2014 say "let me find out"
+- Keep responses concise and friendly
+
+You are aware of tools and capabilities in the system but you do NOT execute anything.
+You cannot run code, search databases, or take actions. You are purely conversational.
+If the user asks you to DO something, acknowledge it and say it will be handled.`;
+var DEFAULT_CONTEXT_TOKENS = 4e3;
+var DEFAULT_REDUNDANCY_WINDOW = 10;
+var APPROX_CHARS_PER_TOKEN = 4;
+var ChatResponder = class {
+  constructor(db, hooks, messageStore, config) {
+    this.db = db;
+    this.hooks = hooks;
+    this.messageStore = messageStore;
+    this.systemPrompt = config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    this.contextWindowTokens = config.contextWindowTokens ?? DEFAULT_CONTEXT_TOKENS;
+    this.redundancyWindow = config.redundancyWindow ?? DEFAULT_REDUNDANCY_WINDOW;
+    this.model = config.model ?? "fast";
+    this.llmCall = config.llmCall;
+  }
+  db;
+  hooks;
+  messageStore;
+  systemPrompt;
+  contextWindowTokens;
+  redundancyWindow;
+  model;
+  llmCall;
+  /**
+   * Generate a fast conversational response to an inbound message.
+   * Uses rolling context window from thread history.
+   */
+  async respond(opts) {
+    const history = await this.messageStore.getThreadHistory(
+      opts.threadId,
+      50
+      // get more, trim by tokens
+    );
+    const messages = this.buildContextWindow(history, opts.messageBody);
+    let system = this.systemPrompt;
+    if (opts.capabilities) {
+      system += `
+
+System capabilities you are aware of:
+${opts.capabilities}`;
+    }
+    if (opts.userName) {
+      system += `
+
+You are talking to: ${opts.userName}`;
+    }
+    const result = await this.llmCall({
+      model: this.model,
+      messages,
+      system,
+      maxTokens: 500
+    });
+    return result.content;
+  }
+  /**
+   * Filter any outbound message through the LLM for human readability.
+   * This is the single funnel ALL responses pass through.
+   */
+  async filterResponse(text, context) {
+    if (text.length < 100) return text;
+    const result = await this.llmCall({
+      model: this.model,
+      messages: [
+        {
+          role: "user",
+          content: `Rewrite this agent/system message to be human-friendly and conversational. Keep the substance, remove jargon, make it feel like a helpful assistant talking to a person. If it's already readable, return it as-is. Do not add preamble like "Here's the rewritten version". Just output the rewritten text.
+
+---
+${text}`
+        }
+      ],
+      maxTokens: 1e3
+    });
+    return result.content;
+  }
+  /**
+   * Check if a candidate outbound message is redundant with recent messages.
+   * Returns true if the message should be suppressed.
+   */
+  async isRedundant(text, threadId) {
+    const recent = await this.messageStore.getRecentOutbound(threadId, this.redundancyWindow);
+    if (recent.length === 0) return false;
+    const recentTexts = recent.map((m) => m["body"] ?? "").filter((t) => t.length > 0).slice(-5).join("\n---\n");
+    const result = await this.llmCall({
+      model: this.model,
+      messages: [
+        {
+          role: "user",
+          content: `Does this NEW message duplicate or substantially overlap the RECENT messages already sent? Answer with just "redundant" or "not redundant". If the new message has meaningful new information or updates, it is NOT redundant.
+
+RECENT MESSAGES:
+${recentTexts}
+
+NEW MESSAGE:
+${text}`
+        }
+      ],
+      maxTokens: 10
+    });
+    return result.content.toLowerCase().includes("redundant") && !result.content.toLowerCase().includes("not redundant");
+  }
+  /**
+   * Full send pipeline: check redundancy → filter → store → deliver.
+   * Returns the message ID, or undefined if suppressed as redundant.
+   */
+  async sendResponse(opts) {
+    if (!opts.skipRedundancyCheck) {
+      const redundant = await this.isRedundant(opts.text, opts.threadId);
+      if (redundant) {
+        await this.hooks.emit("response.suppressed", {
+          channel: opts.channel,
+          threadId: opts.threadId,
+          reason: "redundant"
+        });
+        return void 0;
+      }
+    }
+    const filtered = opts.skipFilter ? opts.text : await this.filterResponse(opts.text, {
+      channel: opts.channel,
+      threadId: opts.threadId,
+      source: opts.source
+    });
+    const messageId = await this.messageStore.storeOutbound({
+      channel: opts.channel,
+      text: filtered,
+      threadId: opts.threadId,
+      agentId: opts.agentId,
+      agentSlug: opts.agentSlug,
+      taskId: opts.taskId
+    });
+    await this.hooks.emit("response.ready", {
+      messageId,
+      channel: opts.channel,
+      threadId: opts.threadId,
+      text: filtered,
+      taskId: opts.taskId
+    });
+    return messageId;
+  }
+  /**
+   * Build a context window from thread history, trimmed to token limit.
+   */
+  buildContextWindow(history, currentMessage) {
+    const maxChars = this.contextWindowTokens * APPROX_CHARS_PER_TOKEN;
+    let charCount = currentMessage.length;
+    const messages = [];
+    for (let i = history.length - 1; i >= 0; i--) {
+      const msg = history[i];
+      const body = msg["body"] ?? "";
+      const direction = msg["direction"];
+      if (charCount + body.length > maxChars) break;
+      messages.unshift({
+        role: direction === "inbound" ? "user" : "assistant",
+        content: body
+      });
+      charCount += body.length;
+    }
+    messages.push({ role: "user", content: currentMessage });
+    return messages;
+  }
+};
+
+// src/core/chat/message-interpreter.ts
+var INTERPRET_SYSTEM = `You are a message parser. Extract structured data from the user's message.
+
+Return a JSON object with these fields:
+{
+  "tasks": [{ "title": "...", "description": "...", "priority": 1-10 }],
+  "memories": [{ "summary": "one-line", "contents": "full text", "tags": ["tag1"], "category": "..." }],
+  "user_context": [{ "trait": "...", "value": "..." }],
+  "is_task_request": true/false
+}
+
+Rules:
+- "tasks": actionable requests the user wants done. NOT conversational messages.
+- "memories": information, notes, random thoughts to remember. Parse thematically \u2014 one message can have multiple memories.
+- "user_context": personality traits, preferences, or learnings about the user.
+- "is_task_request": true if the message contains at least one actionable task.
+- If the message is just a greeting or conversation, return empty arrays and is_task_request: false.
+- Return ONLY valid JSON, no markdown or explanation.`;
+var MessageInterpreter = class {
+  constructor(db, hooks, config) {
+    this.db = db;
+    this.hooks = hooks;
+    this.extractors = config.extractors ?? [];
+    this.model = config.model ?? "fast";
+    this.llmCall = config.llmCall;
+    this.autoCreateTasks = config.autoCreateTasks ?? false;
+  }
+  db;
+  hooks;
+  extractors;
+  model;
+  llmCall;
+  autoCreateTasks;
+  /**
+   * Interpret a stored message asynchronously.
+   * Extracts tasks, memories, files, user context, and custom types.
+   */
+  async interpret(messageId) {
+    const message = await this.db.get("messages", { id: messageId });
+    if (!message) throw new Error(`Message not found: ${messageId}`);
+    const body = message["body"];
+    const userId = message["user_id"];
+    const attachments = await this.db.query("message_attachments", {
+      where: { message_id: messageId }
+    });
+    const parsed = await this.extractWithLLM(body);
+    for (const memory of parsed.memories) {
+      await this.db.insert("memories", {
+        message_id: messageId,
+        user_id: userId,
+        summary: memory.summary,
+        contents: memory.contents,
+        tags: JSON.stringify(memory.tags ?? []),
+        category: memory.category
+      });
+    }
+    for (const ctx of parsed.userContext) {
+      await this.db.insert("memories", {
+        message_id: messageId,
+        user_id: userId,
+        summary: ctx.trait,
+        contents: ctx.value,
+        tags: JSON.stringify(["user_context"]),
+        category: "user_context"
+      });
+    }
+    const files = [];
+    for (const att of attachments) {
+      if (att["contents"]) {
+        files.push({
+          filename: att["filename"] ?? "unknown",
+          fileType: att["file_type"] ?? "file",
+          contents: att["contents"],
+          summary: att["summary"] ?? ""
+        });
+      }
+    }
+    const custom = {};
+    for (const extractor of this.extractors) {
+      try {
+        const results = await extractor.extract(
+          { body, attachments },
+          this.llmCall
+        );
+        if (results.length > 0) {
+          custom[extractor.type] = results;
+        }
+      } catch {
+      }
+    }
+    const result = {
+      messageId,
+      tasks: parsed.tasks,
+      memories: parsed.memories,
+      files,
+      userContext: parsed.userContext,
+      custom,
+      isTaskRequest: parsed.isTaskRequest
+    };
+    await this.hooks.emit("interpretation.completed", {
+      messageId,
+      taskCount: result.tasks.length,
+      memoryCount: result.memories.length,
+      fileCount: result.files.length,
+      isTaskRequest: result.isTaskRequest
+    });
+    return result;
+  }
+  /**
+   * Extract structured data from message text using LLM.
+   */
+  async extractWithLLM(body) {
+    try {
+      const result = await this.llmCall({
+        model: this.model,
+        messages: [{ role: "user", content: body }],
+        system: INTERPRET_SYSTEM,
+        maxTokens: 1e3
+      });
+      const parsed = JSON.parse(result.content);
+      return {
+        tasks: (parsed.tasks ?? []).map((t) => ({
+          title: t.title,
+          description: t.description,
+          priority: t.priority
+        })),
+        memories: (parsed.memories ?? []).map((m) => ({
+          summary: m.summary,
+          contents: m.contents,
+          tags: m.tags,
+          category: m.category
+        })),
+        userContext: (parsed.user_context ?? []).map((u) => ({
+          trait: u.trait,
+          value: u.value
+        })),
+        isTaskRequest: parsed.is_task_request ?? false
+      };
+    } catch {
+      return {
+        tasks: [],
+        memories: [],
+        userContext: [],
+        isTaskRequest: false
+      };
+    }
+  }
+};
+
 // src/core/chat/text-chunker.ts
 function chunkText(text, maxLen) {
   if (maxLen <= 0) throw new Error("maxLen must be > 0");
@@ -1639,6 +2215,88 @@ function defineCoreTables(db) {
       "CREATE UNIQUE INDEX IF NOT EXISTS idx_secrets_name_env ON secrets(name, environment, org_id) WHERE deleted_at IS NULL"
     ]
   });
+  db.define("feedback", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      agent_id: "TEXT NOT NULL",
+      task_id: "TEXT",
+      issue: "TEXT NOT NULL",
+      root_cause: "TEXT",
+      severity: "TEXT NOT NULL DEFAULT 'medium'",
+      repeatable: "INTEGER NOT NULL DEFAULT 0",
+      accuracy_score: "REAL",
+      efficiency_score: "REAL",
+      tags: "TEXT NOT NULL DEFAULT '[]'",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP"
+    },
+    tableConstraints: [
+      "CREATE INDEX IF NOT EXISTS idx_feedback_agent ON feedback(agent_id, created_at)",
+      "CREATE INDEX IF NOT EXISTS idx_feedback_issue ON feedback(issue)"
+    ]
+  });
+  db.define("playbooks", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      pattern: "TEXT NOT NULL",
+      rule: "TEXT NOT NULL",
+      feedback_ids: "TEXT NOT NULL DEFAULT '[]'",
+      project_scoped: "INTEGER NOT NULL DEFAULT 1",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      updated_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      deleted_at: "TEXT"
+    },
+    tableConstraints: [
+      "CREATE INDEX IF NOT EXISTS idx_playbooks_pattern ON playbooks(pattern)"
+    ]
+  });
+  db.define("agent_playbooks", {
+    columns: {
+      agent_id: "TEXT NOT NULL",
+      playbook_id: "TEXT NOT NULL",
+      assigned_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP"
+    },
+    primaryKey: ["agent_id", "playbook_id"],
+    tableConstraints: [
+      "FOREIGN KEY (agent_id) REFERENCES agents(id)",
+      "FOREIGN KEY (playbook_id) REFERENCES playbooks(id)"
+    ]
+  });
+  db.define("message_attachments", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      message_id: "TEXT NOT NULL",
+      file_type: "TEXT NOT NULL DEFAULT 'file'",
+      filename: "TEXT",
+      mime_type: "TEXT",
+      size_bytes: "INTEGER",
+      contents: "TEXT",
+      summary: "TEXT",
+      url: "TEXT",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP"
+    },
+    tableConstraints: [
+      "CREATE INDEX IF NOT EXISTS idx_message_attachments_message ON message_attachments(message_id)",
+      "FOREIGN KEY (message_id) REFERENCES messages(id)"
+    ]
+  });
+  db.define("memories", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      message_id: "TEXT",
+      user_id: "TEXT",
+      summary: "TEXT NOT NULL",
+      contents: "TEXT NOT NULL",
+      tags: "TEXT NOT NULL DEFAULT '[]'",
+      category: "TEXT",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      updated_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      deleted_at: "TEXT"
+    },
+    tableConstraints: [
+      "CREATE INDEX IF NOT EXISTS idx_memories_user ON memories(user_id, created_at)",
+      "CREATE INDEX IF NOT EXISTS idx_memories_message ON memories(message_id)"
+    ]
+  });
 }
 
 // src/core/data/core-migrations.ts
@@ -1704,12 +2362,55 @@ function defineCoreEntityContexts(db) {
             `# ${a.name}`,
             "",
             a.role ? `**Role:** ${a.role}` : null,
+            a.adapter ? `**Adapter:** ${a.adapter}` : null,
             a.status ? `**Status:** ${a.status}` : null,
             a.cwd ? `**Working Directory:** ${a.cwd}` : null,
             a.reports_to ? `**Reports To:** ${a.reports_to}` : null,
             ""
           ].filter(Boolean).join("\n");
         }
+      },
+      "SKILLS.md": {
+        source: {
+          type: "manyToMany",
+          junctionTable: "agent_skills",
+          localKey: "agent_id",
+          remoteKey: "skill_id",
+          remoteTable: "skills"
+        },
+        omitIfEmpty: true,
+        render: (rows) => {
+          if (!rows.length) return "";
+          const lines = [`# Skills (${rows.length})`, ""];
+          for (const s of rows) {
+            lines.push(`## ${s.name}`);
+            if (s.category) lines.push(`**Category:** ${s.category}`);
+            if (s.description) lines.push("", s.description);
+            if (s.definition) lines.push("", "```", s.definition, "```");
+            lines.push("");
+          }
+          return lines.join("\n");
+        }
+      },
+      "PLAYBOOKS.md": {
+        source: {
+          type: "manyToMany",
+          junctionTable: "agent_playbooks",
+          localKey: "agent_id",
+          remoteKey: "playbook_id",
+          remoteTable: "playbooks"
+        },
+        omitIfEmpty: true,
+        render: (rows) => {
+          if (!rows.length) return "";
+          const lines = [`# Playbooks (${rows.length})`, ""];
+          for (const pb of rows) {
+            lines.push(`## ${pb.pattern ?? pb.name ?? "Unnamed"}`);
+            if (pb.rule) lines.push("", pb.rule);
+            lines.push("");
+          }
+          return lines.join("\n");
+        }
       }
     }
   });
@@ -3097,6 +3798,13 @@ var RunManager = class {
   // agentId → runId
   orphanTimer = null;
   staleThresholdMs;
+  circuitBreaker;
+  /**
+   * Attach a CircuitBreaker to prevent retries on broken agents.
+   */
+  setCircuitBreaker(cb) {
+    this.circuitBreaker = cb;
+  }
   isLocked(agentId) {
     return this.locks.has(agentId);
   }
@@ -3134,11 +3842,15 @@ var RunManager = class {
     this.locks.delete(agentId);
     const taskId = run["task_id"];
     if (!succeeded) {
+      if (this.circuitBreaker) {
+        await this.circuitBreaker.recordFailure(agentId, result.output);
+      }
       const task = await this.db.get("tasks", { id: taskId });
       if (task) {
         const retryCount = task["retry_count"] ?? 0;
         const maxRetries = task["max_retries"] ?? 0;
-        if (retryCount < maxRetries) {
+        const circuitOpen = this.circuitBreaker ? !this.circuitBreaker.canExecute(agentId) : false;
+        if (retryCount < maxRetries && !circuitOpen) {
           const maxBackoff = this.config?.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
           const backoffMs = Math.min(BASE_BACKOFF_MS * Math.pow(2, retryCount), maxBackoff);
           const nextRetryAt = new Date(Date.now() + backoffMs).toISOString();
@@ -3157,6 +3869,9 @@ var RunManager = class {
         }
       }
     } else {
+      if (this.circuitBreaker) {
+        await this.circuitBreaker.recordSuccess(agentId);
+      }
       await this.db.update("tasks", { id: taskId }, {
         status: "done",
         result: result.output,
@@ -4096,6 +4811,803 @@ var CliExecutionAdapter = class {
   }
 };
 
+// src/core/orchestrator/adapters/deterministic-adapter.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DeterministicAdapter = class {
+  type = "deterministic";
+  async execute(ctx) {
+    const cwd = ctx.agent.cwd ?? process.cwd();
+    let config = { command: "echo" };
+    if (ctx.agent.adapter_config) {
+      try {
+        config = JSON.parse(ctx.agent.adapter_config);
+      } catch {
+        throw new Error("Invalid adapter_config for deterministic adapter");
+      }
+    }
+    if (!config.command) {
+      throw new Error("Deterministic adapter requires a command");
+    }
+    const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const payload = JSON.stringify({
+      taskId: ctx.task.title,
+      description: ctx.task.description ?? "",
+      context: ctx.task.context ?? ""
+    });
+    const args = [...config.args ?? []];
+    if (config.inputMode === "arg") {
+      args.push(payload);
+    }
+    const child = spawnProcess(config.command, args, {
+      cwd,
+      extraEnv: config.env
+    });
+    if (config.inputMode !== "arg" && child.stdin) {
+      child.stdin.write(payload);
+      child.stdin.end();
+    }
+    const stdoutChunks = [];
+    child.stdout?.on("data", (chunk) => {
+      stdoutChunks.push(chunk);
+      ctx.onLog?.("stdout", chunk.toString("utf8"));
+    });
+    child.stderr?.on("data", (chunk) => {
+      ctx.onLog?.("stderr", chunk.toString("utf8"));
+    });
+    const abortHandler = () => {
+      if (child.pid != null) killProcessGroup(child.pid);
+    };
+    ctx.abortSignal?.addEventListener("abort", abortHandler);
+    const timeout = setTimeout(() => {
+      if (child.pid != null) killProcessGroup(child.pid);
+    }, timeoutMs);
+    const exitCode = await new Promise((resolve) => {
+      child.on("close", (code) => resolve(code ?? 1));
+      child.on("error", () => resolve(1));
+    });
+    clearTimeout(timeout);
+    ctx.abortSignal?.removeEventListener("abort", abortHandler);
+    const output = Buffer.concat(stdoutChunks).toString("utf8");
+    return { output, exitCode };
+  }
+};
+
+// src/core/orchestrator/loop-detector.ts
+var LoopType = /* @__PURE__ */ ((LoopType2) => {
+  LoopType2["SELF_LOOP"] = "self_loop";
+  LoopType2["PING_PONG"] = "ping_pong";
+  LoopType2["BLOCKED_REENTRY"] = "blocked_reentry";
+  return LoopType2;
+})(LoopType || {});
+var DEFAULT_WINDOW = 10;
+var DEFAULT_PING_PONG_THRESHOLD = 2;
+var LoopDetector = class {
+  constructor(db, config) {
+    this.db = db;
+    this.windowSize = config?.windowSize ?? DEFAULT_WINDOW;
+    this.pingPongThreshold = config?.pingPongThreshold ?? DEFAULT_PING_PONG_THRESHOLD;
+  }
+  db;
+  windowSize;
+  pingPongThreshold;
+  /**
+   * Check for loops before creating a followup task.
+   * Returns a LoopDetection if a loop pattern is found, undefined otherwise.
+   */
+  async check(sourceAgentId, targetAgentId, taskId, chainOriginId) {
+    const selfLoop = this.checkSelfLoop(sourceAgentId, targetAgentId, taskId);
+    if (selfLoop) return selfLoop;
+    const blocked = await this.checkBlockedReentry(targetAgentId, taskId, chainOriginId);
+    if (blocked) return blocked;
+    const pingPong = await this.checkPingPong(sourceAgentId, targetAgentId, chainOriginId);
+    if (pingPong) return pingPong;
+    return void 0;
+  }
+  /**
+   * Check if an agent is routing to itself.
+   */
+  checkSelfLoop(sourceAgentId, targetAgentId, taskId) {
+    if (sourceAgentId === targetAgentId) {
+      return {
+        type: "self_loop" /* SELF_LOOP */,
+        agents: [sourceAgentId],
+        taskId,
+        message: `Self-loop detected: agent ${sourceAgentId} is routing to itself`
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Check if a previously blocked task is being re-entered.
+   */
+  async checkBlockedReentry(targetAgentId, taskId, chainOriginId) {
+    const originId = chainOriginId ?? taskId;
+    const chainTasks = await this.db.query("tasks", {
+      where: { chain_origin_id: originId }
+    });
+    const blockedInChain = chainTasks.filter(
+      (t) => (t["status"] === "blocked" || t["status"] === "failed") && t["assignee_id"] === targetAgentId
+    );
+    if (blockedInChain.length > 0) {
+      return {
+        type: "blocked_reentry" /* BLOCKED_REENTRY */,
+        agents: [targetAgentId],
+        taskId,
+        chainOriginId: originId,
+        message: `Blocked re-entry: agent ${targetAgentId} already has a blocked/failed task in chain ${originId}`
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Check for A→B→A→B ping-pong by scanning recent tasks in the chain.
+   */
+  async checkPingPong(sourceAgentId, targetAgentId, chainOriginId) {
+    if (!chainOriginId) return void 0;
+    const chainTasks = await this.db.query("tasks", {
+      where: { chain_origin_id: chainOriginId }
+    });
+    const sorted = chainTasks.sort((a, b) => {
+      const depthDiff = (a["chain_depth"] ?? 0) - (b["chain_depth"] ?? 0);
+      if (depthDiff !== 0) return depthDiff;
+      return (a["created_at"] ?? "").localeCompare(b["created_at"] ?? "");
+    }).slice(-this.windowSize);
+    const agentSequence = sorted.map((t) => t["assignee_id"]).filter(Boolean);
+    agentSequence.push(targetAgentId);
+    if (agentSequence.length >= this.pingPongThreshold * 2) {
+      const tail = agentSequence.slice(-this.pingPongThreshold * 2);
+      const a = tail[0];
+      const b = tail[1];
+      if (a && b && a !== b) {
+        let isPingPong = true;
+        for (let i = 0; i < tail.length; i++) {
+          if (tail[i] !== (i % 2 === 0 ? a : b)) {
+            isPingPong = false;
+            break;
+          }
+        }
+        if (isPingPong) {
+          return {
+            type: "ping_pong" /* PING_PONG */,
+            agents: [a, b],
+            taskId: sorted[sorted.length - 1]?.["id"] ?? "",
+            chainOriginId,
+            message: `Ping-pong detected: agents ${a} and ${b} are bouncing tasks in chain ${chainOriginId}`
+          };
+        }
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/core/orchestrator/circuit-breaker.ts
+var BreakerState = /* @__PURE__ */ ((BreakerState2) => {
+  BreakerState2["CLOSED"] = "closed";
+  BreakerState2["OPEN"] = "open";
+  BreakerState2["HALF_OPEN"] = "half_open";
+  return BreakerState2;
+})(BreakerState || {});
+var DEFAULT_FAILURE_THRESHOLD = 3;
+var DEFAULT_RESET_TIMEOUT_MS = 5 * 60 * 1e3;
+var CircuitBreaker = class {
+  constructor(db, hooks, config) {
+    this.db = db;
+    this.hooks = hooks;
+    this.failureThreshold = config?.failureThreshold ?? DEFAULT_FAILURE_THRESHOLD;
+    this.resetTimeoutMs = config?.resetTimeoutMs ?? DEFAULT_RESET_TIMEOUT_MS;
+    this.persist = config?.persist ?? true;
+  }
+  db;
+  hooks;
+  breakers = /* @__PURE__ */ new Map();
+  failureThreshold;
+  resetTimeoutMs;
+  persist;
+  /**
+   * Check if an agent is allowed to execute.
+   * Returns true if execution is allowed, false if circuit is open.
+   */
+  canExecute(agentId) {
+    const breaker = this.breakers.get(agentId);
+    if (!breaker) return true;
+    switch (breaker.state) {
+      case "closed" /* CLOSED */:
+        return true;
+      case "open" /* OPEN */: {
+        const elapsed = Date.now() - (breaker.trippedAt ?? 0);
+        if (elapsed >= this.resetTimeoutMs) {
+          breaker.state = "half_open" /* HALF_OPEN */;
+          return true;
+        }
+        return false;
+      }
+      case "half_open" /* HALF_OPEN */:
+        return true;
+    }
+  }
+  /**
+   * Record a successful execution. Resets the breaker to CLOSED.
+   */
+  async recordSuccess(agentId) {
+    const breaker = this.breakers.get(agentId);
+    if (!breaker) return;
+    const previousState = breaker.state;
+    breaker.state = "closed" /* CLOSED */;
+    breaker.failureCount = 0;
+    if (previousState === "half_open" /* HALF_OPEN */) {
+      await this.logEvent(agentId, "circuit_recovered", {
+        previousState
+      });
+      await this.hooks.emit("circuit_breaker.recovered", {
+        agentId,
+        previousState
+      });
+    }
+  }
+  /**
+   * Record a failed execution. Increments failure count and may trip breaker.
+   */
+  async recordFailure(agentId, reason) {
+    let breaker = this.breakers.get(agentId);
+    if (!breaker) {
+      breaker = {
+        state: "closed" /* CLOSED */,
+        failureCount: 0,
+        lastFailureAt: Date.now()
+      };
+      this.breakers.set(agentId, breaker);
+    }
+    breaker.failureCount++;
+    breaker.lastFailureAt = Date.now();
+    if (breaker.state === "half_open" /* HALF_OPEN */) {
+      await this.trip(agentId, reason ?? "Probe execution failed during half-open state");
+      return;
+    }
+    if (breaker.failureCount >= this.failureThreshold) {
+      await this.trip(agentId, reason ?? `Failure threshold reached (${this.failureThreshold})`);
+    }
+  }
+  /**
+   * Trip the breaker to OPEN state and escalate to human.
+   */
+  async trip(agentId, reason) {
+    let breaker = this.breakers.get(agentId);
+    if (!breaker) {
+      breaker = {
+        state: "closed" /* CLOSED */,
+        failureCount: 0,
+        lastFailureAt: Date.now()
+      };
+      this.breakers.set(agentId, breaker);
+    }
+    breaker.state = "open" /* OPEN */;
+    breaker.trippedAt = Date.now();
+    await this.logEvent(agentId, "circuit_tripped", {
+      reason,
+      failureCount: breaker.failureCount
+    });
+    await this.hooks.emit("circuit_breaker.tripped", {
+      agentId,
+      reason,
+      failureCount: breaker.failureCount,
+      action: "escalate_to_human"
+    });
+  }
+  /**
+   * Manually reset a breaker (e.g. after human review).
+   */
+  async reset(agentId) {
+    this.breakers.delete(agentId);
+    await this.logEvent(agentId, "circuit_reset", {});
+    await this.hooks.emit("circuit_breaker.reset", { agentId });
+  }
+  /**
+   * Get the current state of a breaker.
+   */
+  getState(agentId) {
+    return this.breakers.get(agentId)?.state ?? "closed" /* CLOSED */;
+  }
+  /**
+   * Get failure count for an agent.
+   */
+  getFailureCount(agentId) {
+    return this.breakers.get(agentId)?.failureCount ?? 0;
+  }
+  async logEvent(agentId, eventType, payload) {
+    if (!this.persist) return;
+    await this.db.insert("activity_log", {
+      agent_id: agentId,
+      event_type: eventType,
+      payload: JSON.stringify(payload)
+    });
+  }
+};
+
+// src/core/orchestrator/learning-pipeline.ts
+var DEFAULT_PLAYBOOK_THRESHOLD = 3;
+var DEFAULT_SKILL_THRESHOLD = 3;
+var LearningPipeline = class {
+  constructor(db, hooks, config) {
+    this.db = db;
+    this.hooks = hooks;
+    this.playbookThreshold = config?.playbookThreshold ?? DEFAULT_PLAYBOOK_THRESHOLD;
+    this.skillThreshold = config?.skillThreshold ?? DEFAULT_SKILL_THRESHOLD;
+    this.autoPromote = config?.autoPromote ?? false;
+  }
+  db;
+  hooks;
+  playbookThreshold;
+  skillThreshold;
+  autoPromote;
+  // --- Feedback Layer ---
+  /**
+   * Capture a structured feedback record from an execution.
+   */
+  async captureFeedback(entry) {
+    const row = await this.db.insert("feedback", {
+      agent_id: entry.agentId,
+      task_id: entry.taskId,
+      issue: entry.issue,
+      root_cause: entry.rootCause,
+      severity: entry.severity,
+      repeatable: entry.repeatable ? 1 : 0,
+      accuracy_score: entry.accuracyScore,
+      efficiency_score: entry.efficiencyScore,
+      tags: JSON.stringify(entry.tags ?? [])
+    });
+    const feedbackId = row["id"];
+    await this.hooks.emit("learning.feedback_captured", {
+      feedbackId,
+      agentId: entry.agentId,
+      issue: entry.issue,
+      severity: entry.severity
+    });
+    if (this.autoPromote) {
+      await this.checkPlaybookPromotion(entry.issue);
+    }
+    return feedbackId;
+  }
+  /**
+   * Get all feedback records, optionally filtered.
+   */
+  async listFeedback(filter) {
+    const where = {};
+    if (filter?.agentId) where["agent_id"] = filter.agentId;
+    if (filter?.severity) where["severity"] = filter.severity;
+    if (filter?.repeatable !== void 0) where["repeatable"] = filter.repeatable ? 1 : 0;
+    return this.db.query("feedback", Object.keys(where).length ? { where } : void 0);
+  }
+  // --- Playbook Layer ---
+  /**
+   * Check if feedback records with similar issues should be promoted to a playbook.
+   * Groups by issue text similarity (exact match for now).
+   */
+  async checkPlaybookPromotion(issue) {
+    const allFeedback = await this.db.query("feedback", {
+      where: { issue }
+    });
+    if (allFeedback.length < this.playbookThreshold) {
+      return void 0;
+    }
+    const existingPlaybooks = await this.db.query("playbooks", {
+      where: { pattern: issue }
+    });
+    if (existingPlaybooks.length > 0) {
+      return existingPlaybooks[0]["id"];
+    }
+    const feedbackIds = allFeedback.map((f) => f["id"]);
+    const rootCauses = allFeedback.map((f) => f["root_cause"]).filter(Boolean);
+    const rule = rootCauses.length > 0 ? `When encountering "${issue}": ${rootCauses[0]}` : `Pattern detected: "${issue}" \u2014 review and add specific guidance.`;
+    const playbookId = await this.promoteToPlaybook({
+      pattern: issue,
+      rule,
+      feedbackIds,
+      projectScoped: true
+    });
+    return playbookId;
+  }
+  /**
+   * Manually create a playbook from a set of feedback records.
+   */
+  async promoteToPlaybook(entry) {
+    const row = await this.db.insert("playbooks", {
+      pattern: entry.pattern,
+      rule: entry.rule,
+      feedback_ids: JSON.stringify(entry.feedbackIds),
+      project_scoped: entry.projectScoped ? 1 : 0
+    });
+    const playbookId = row["id"];
+    if (entry.agentIds) {
+      for (const agentId of entry.agentIds) {
+        await this.db.insert("agent_playbooks", {
+          agent_id: agentId,
+          playbook_id: playbookId
+        });
+      }
+    }
+    await this.hooks.emit("learning.playbook_promoted", {
+      playbookId,
+      pattern: entry.pattern,
+      feedbackCount: entry.feedbackIds.length
+    });
+    return playbookId;
+  }
+  /**
+   * List playbooks, optionally filtered.
+   */
+  async listPlaybooks(filter) {
+    const where = {};
+    if (filter?.projectScoped !== void 0) {
+      where["project_scoped"] = filter.projectScoped ? 1 : 0;
+    }
+    return this.db.query("playbooks", Object.keys(where).length ? { where } : void 0);
+  }
+  // --- Skill Layer ---
+  /**
+   * Check if a playbook should be promoted to a skill.
+   * A playbook becomes a skill when it works across multiple projects
+   * (indicated by being referenced by agents in different contexts).
+   */
+  async checkSkillPromotion(playbookId) {
+    const playbook = await this.db.get("playbooks", { id: playbookId });
+    if (!playbook) return void 0;
+    const links = await this.db.query("agent_playbooks", {
+      where: { playbook_id: playbookId }
+    });
+    if (links.length < this.skillThreshold) {
+      return void 0;
+    }
+    const pattern = playbook["pattern"];
+    const existingSkills = await this.db.query("skills", {
+      where: { name: pattern }
+    });
+    if (existingSkills.length > 0) {
+      return existingSkills[0]["id"];
+    }
+    const slug = pattern.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 64);
+    const skillId = await this.promoteToSkill({
+      name: pattern,
+      slug,
+      description: `Auto-promoted from playbook: ${pattern}`,
+      behavior: playbook["rule"],
+      sourcePlaybookIds: [playbookId]
+    });
+    return skillId;
+  }
+  /**
+   * Manually promote a playbook to a reusable skill.
+   */
+  async promoteToSkill(entry) {
+    const row = await this.db.insert("skills", {
+      name: entry.name,
+      slug: entry.slug,
+      description: entry.description,
+      category: entry.category ?? "learned",
+      definition: JSON.stringify({
+        behavior: entry.behavior,
+        source_playbook_ids: entry.sourcePlaybookIds
+      })
+    });
+    const skillId = row["id"];
+    await this.hooks.emit("learning.skill_promoted", {
+      skillId,
+      name: entry.name,
+      slug: entry.slug,
+      sourcePlaybookCount: entry.sourcePlaybookIds.length
+    });
+    return skillId;
+  }
+  /**
+   * Assign a skill to an agent.
+   */
+  async assignSkill(agentId, skillId) {
+    await this.db.link("agent_skills", {
+      agent_id: agentId,
+      skill_id: skillId
+    });
+    await this.hooks.emit("learning.skill_assigned", { agentId, skillId });
+  }
+  /**
+   * Get learning metrics for an agent.
+   */
+  async getMetrics(agentId) {
+    const feedback = await this.db.query("feedback", { where: { agent_id: agentId } });
+    const accuracyScores = feedback.map((f) => f["accuracy_score"]).filter((s) => s !== null && s !== void 0);
+    const efficiencyScores = feedback.map((f) => f["efficiency_score"]).filter((s) => s !== null && s !== void 0);
+    let playbookCount = 0;
+    try {
+      const links = await this.db.query("agent_playbooks", { where: { agent_id: agentId } });
+      playbookCount = links.length;
+    } catch {
+    }
+    const skillLinks = await this.db.query("agent_skills", { where: { agent_id: agentId } });
+    return {
+      feedbackCount: feedback.length,
+      avgAccuracy: accuracyScores.length > 0 ? accuracyScores.reduce((a, b) => a + b, 0) / accuracyScores.length : null,
+      avgEfficiency: efficiencyScores.length > 0 ? efficiencyScores.reduce((a, b) => a + b, 0) / efficiencyScores.length : null,
+      playbookCount,
+      skillCount: skillLinks.length
+    };
+  }
+};
+
+// src/core/orchestrator/permission-relay.ts
+var DEFAULT_POLL_INTERVAL_MS = 5e3;
+var DEFAULT_TIMEOUT_MS2 = 5 * 60 * 1e3;
+var PermissionRelay = class {
+  constructor(hooks, config) {
+    this.hooks = hooks;
+    this.providers = config.providers;
+    this.pollIntervalMs = config.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  }
+  hooks;
+  providers;
+  pollIntervalMs;
+  timeoutMs;
+  pending = /* @__PURE__ */ new Map();
+  /**
+   * Request approval from all configured providers.
+   * Returns when the first provider responds (approve or deny).
+   */
+  async requestApproval(prompt) {
+    const expiresAt = new Date(Date.now() + this.timeoutMs).toISOString();
+    const promptWithExpiry = { ...prompt, expiresAt };
+    await this.hooks.emit("permission.requested", {
+      promptId: prompt.id,
+      agentId: prompt.agentId,
+      action: prompt.action
+    });
+    const handles = /* @__PURE__ */ new Map();
+    for (const provider of this.providers) {
+      try {
+        const handle = await provider.sendPrompt(promptWithExpiry);
+        handles.set(provider.id, handle);
+      } catch {
+      }
+    }
+    if (handles.size === 0) {
+      throw new Error("No permission providers available");
+    }
+    return new Promise((resolve, reject) => {
+      const entry = {
+        prompt: promptWithExpiry,
+        handles,
+        resolve,
+        reject
+      };
+      this.pending.set(prompt.id, entry);
+      const pollTimer = setInterval(async () => {
+        for (const [providerId, handle] of handles) {
+          const provider = this.providers.find((p) => p.id === providerId);
+          if (!provider) continue;
+          try {
+            const response = await provider.pollResponse(handle);
+            if (response) {
+              clearInterval(pollTimer);
+              clearTimeout(timeoutTimer);
+              this.pending.delete(prompt.id);
+              await this.cancelOtherProviders(handles, providerId);
+              await this.hooks.emit("permission.responded", {
+                promptId: prompt.id,
+                status: response.status,
+                respondedBy: response.respondedBy
+              });
+              resolve(response);
+              return;
+            }
+          } catch {
+          }
+        }
+      }, this.pollIntervalMs);
+      const timeoutTimer = setTimeout(async () => {
+        clearInterval(pollTimer);
+        this.pending.delete(prompt.id);
+        for (const [providerId, handle] of handles) {
+          const provider = this.providers.find((p) => p.id === providerId);
+          if (provider) {
+            try {
+              await provider.cancelPrompt(handle);
+            } catch {
+            }
+          }
+        }
+        await this.hooks.emit("permission.expired", {
+          promptId: prompt.id,
+          agentId: prompt.agentId
+        });
+        reject(new Error(`Permission request expired after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+    });
+  }
+  /**
+   * Provide a local approval (from terminal).
+   * Resolves the pending request and cancels remote providers.
+   */
+  async approveLocally(promptId, approved) {
+    const entry = this.pending.get(promptId);
+    if (!entry) return;
+    const response = {
+      promptId,
+      status: approved ? "approved" : "denied",
+      respondedBy: "local",
+      respondedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.pending.delete(promptId);
+    for (const [providerId, handle] of entry.handles) {
+      const provider = this.providers.find((p) => p.id === providerId);
+      if (provider) {
+        try {
+          await provider.cancelPrompt(handle);
+        } catch {
+        }
+      }
+    }
+    await this.hooks.emit("permission.responded", {
+      promptId,
+      status: response.status,
+      respondedBy: "local"
+    });
+    entry.resolve(response);
+  }
+  /**
+   * Get all pending approval requests.
+   */
+  getPending() {
+    return Array.from(this.pending.values()).map((e) => e.prompt);
+  }
+  async cancelOtherProviders(handles, excludeProviderId) {
+    for (const [providerId, handle] of handles) {
+      if (providerId === excludeProviderId) continue;
+      const provider = this.providers.find((p) => p.id === providerId);
+      if (provider) {
+        try {
+          await provider.cancelPrompt(handle);
+        } catch {
+        }
+      }
+    }
+  }
+};
+
+// src/core/orchestrator/governance-gate.ts
+var GovernanceGate = class {
+};
+var QAGate = class extends GovernanceGate {
+  constructor(validators = []) {
+    super();
+    this.validators = validators;
+  }
+  validators;
+  id = "qa";
+  name = "Quality Assurance";
+  dimension = "data_correctness";
+  async check(input) {
+    const start = Date.now();
+    const findings = [];
+    for (const validator of this.validators) {
+      const results = validator.validate(input.output, input.metadata);
+      findings.push(...results);
+    }
+    const hasErrors = findings.some((f) => f.severity === "error" || f.severity === "critical");
+    const hasWarnings = findings.some((f) => f.severity === "warning");
+    return {
+      gateId: this.id,
+      verdict: hasErrors ? "fail" : hasWarnings ? "warn" : "pass",
+      findings,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Date.now() - start
+    };
+  }
+};
+var QualityGate = class extends GovernanceGate {
+  constructor(checks = []) {
+    super();
+    this.checks = checks;
+  }
+  checks;
+  id = "quality";
+  name = "Code Quality";
+  dimension = "code_quality";
+  async check(input) {
+    const start = Date.now();
+    const findings = [];
+    for (const chk of this.checks) {
+      const results = await chk.check(input.output, input.metadata);
+      findings.push(...results);
+    }
+    const hasErrors = findings.some((f) => f.severity === "error" || f.severity === "critical");
+    const hasWarnings = findings.some((f) => f.severity === "warning");
+    return {
+      gateId: this.id,
+      verdict: hasErrors ? "fail" : hasWarnings ? "warn" : "pass",
+      findings,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Date.now() - start
+    };
+  }
+};
+var DriftGate = class extends GovernanceGate {
+  constructor(rules = []) {
+    super();
+    this.rules = rules;
+  }
+  rules;
+  id = "drift";
+  name = "Architectural Drift";
+  dimension = "architecture";
+  async check(input) {
+    const start = Date.now();
+    const findings = [];
+    for (const rule of this.rules) {
+      const results = rule.detect(input.output, input.metadata);
+      findings.push(...results);
+    }
+    const hasErrors = findings.some((f) => f.severity === "error" || f.severity === "critical");
+    const hasWarnings = findings.some((f) => f.severity === "warning");
+    return {
+      gateId: this.id,
+      verdict: hasErrors ? "fail" : hasWarnings ? "warn" : "pass",
+      findings,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Date.now() - start
+    };
+  }
+};
+var GateRunner = class {
+  constructor(gates, hooks) {
+    this.gates = gates;
+    this.hooks = hooks;
+  }
+  gates;
+  hooks;
+  /**
+   * Run all gates on the given input.
+   * Gates run independently — one failure doesn't block others.
+   */
+  async runAll(input) {
+    const results = [];
+    for (const gate of this.gates) {
+      try {
+        const result = await gate.check(input);
+        results.push(result);
+        await this.hooks.emit("governance.gate_completed", {
+          gateId: gate.id,
+          gateName: gate.name,
+          verdict: result.verdict,
+          findingCount: result.findings.length,
+          agentId: input.agentId,
+          taskId: input.taskId
+        });
+      } catch (err) {
+        results.push({
+          gateId: gate.id,
+          verdict: "fail",
+          findings: [{
+            severity: "error",
+            message: `Gate error: ${err instanceof Error ? err.message : String(err)}`
+          }],
+          checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: 0
+        });
+      }
+    }
+    const passed = results.every((r) => r.verdict !== "fail");
+    await this.hooks.emit("governance.review_completed", {
+      passed,
+      agentId: input.agentId,
+      taskId: input.taskId,
+      results: results.map((r) => ({
+        gateId: r.gateId,
+        verdict: r.verdict,
+        findingCount: r.findings.length
+      }))
+    });
+    return { passed, results };
+  }
+};
+
 // src/core/orchestrator/user-registry.ts
 import { v4 as uuidv4 } from "uuid";
 var UserRegistry = class {
@@ -4427,25 +5939,40 @@ export {
   ApiExecutionAdapter,
   AuditEmitter,
   BackupManager,
+  BreakerState,
   BudgetController,
   CORE_MIGRATIONS,
   ChannelRegistry,
   ChannelRegistryError,
+  ChatResponder,
   ChatSessionManager,
+  CircuitBreaker,
   CliExecutionAdapter,
   ColumnValidatorImpl,
   DEFAULTS,
   DEFAULT_CONFIG,
   DataStore,
   DataStoreError,
+  DeterministicAdapter,
+  DriftGate,
   EVENTS,
+  GateRunner,
+  GovernanceGate,
   HookBus,
+  LearningPipeline,
+  LoopDetector,
+  LoopType,
   MAX_CHAIN_DEPTH,
+  MessageInterpreter,
   MessagePipeline,
+  MessageStore,
   ModelRouter,
   NdjsonLogger,
   NotificationQueue,
+  PermissionRelay,
   ProviderRegistry,
+  QAGate,
+  QualityGate,
   RUN_STATUSES,
   RunManager,
   Scheduler,
@@ -4454,6 +5981,7 @@ export {
   SessionManager,
   TASK_STATUSES,
   TaskQueue,
+  TriageRouter,
   UpdateChecker,
   UpdateManager,
   UserRegistry,