botinabox 1.4.2 → 1.6.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) {
@@ -1639,6 +1780,52 @@ 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)"
+    ]
+  });
 }
 
 // src/core/data/core-migrations.ts
@@ -1704,12 +1891,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");
+        }
       }
     }
   });
@@ -2222,6 +2452,26 @@ ${r.rule_text}`
             return `# Project Rules
 
 ${lines.join("\n\n")}
+`;
+          },
+          omitIfEmpty: true
+        }
+      } : {},
+      ...opts.files ? {
+        "FILES.md": {
+          source: {
+            type: "hasMany",
+            table: "file",
+            foreignKey: "project_id"
+          },
+          render: (rows) => {
+            if (!rows.length) return "";
+            const lines = rows.map(
+              (r) => `- [${r.name}](files/${r.name}/)${r.mime_type ? ` (${r.mime_type})` : ""}`
+            );
+            return `# Files
+
+${lines.join("\n")}
 `;
           },
           omitIfEmpty: true
@@ -2243,7 +2493,8 @@ ${lines.join("\n\n")}
             const agent = r.from_agent ? ` [${r.from_agent}]` : "";
             const body = r.body ?? "";
             const preview = truncateAtWord(body, 150);
-            return `- ${dir} **${ts}**${agent} ${preview}`;
+            const link = `[${ts}](messages/${r.id}/)`;
+            return `- ${dir} **${link}**${agent} ${preview}`;
           });
           return `# Messages
 
@@ -3076,6 +3327,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);
   }
@@ -3113,11 +3371,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();
@@ -3136,6 +3398,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,
@@ -4075,6 +4340,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 {
@@ -4406,25 +5468,37 @@ export {
   ApiExecutionAdapter,
   AuditEmitter,
   BackupManager,
+  BreakerState,
   BudgetController,
   CORE_MIGRATIONS,
   ChannelRegistry,
   ChannelRegistryError,
   ChatSessionManager,
+  CircuitBreaker,
   CliExecutionAdapter,
   ColumnValidatorImpl,
   DEFAULTS,
   DEFAULT_CONFIG,
   DataStore,
   DataStoreError,
+  DeterministicAdapter,
+  DriftGate,
   EVENTS,
+  GateRunner,
+  GovernanceGate,
   HookBus,
+  LearningPipeline,
+  LoopDetector,
+  LoopType,
   MAX_CHAIN_DEPTH,
   MessagePipeline,
   ModelRouter,
   NdjsonLogger,
   NotificationQueue,
+  PermissionRelay,
   ProviderRegistry,
+  QAGate,
+  QualityGate,
   RUN_STATUSES,
   RunManager,
   Scheduler,
@@ -4433,6 +5507,7 @@ export {
   SessionManager,
   TASK_STATUSES,
   TaskQueue,
+  TriageRouter,
   UpdateChecker,
   UpdateManager,
   UserRegistry,