@mrrlin-dev/mcp 0.3.27 → 0.3.34

package/dist/bin.cjs

@@ -20645,7 +20645,7 @@ var require_dist = __commonJS({
 
 // src/bin.ts
 var import_node_path19 = __toESM(require("node:path"), 1);
-var import_node_child_process9 = require("node:child_process");
+var import_node_child_process12 = require("node:child_process");
 var import_node_fs13 = require("node:fs");
 var import_node_os11 = require("node:os");
 var import_node_path20 = __toESM(require("node:path"), 1);
@@ -20747,6 +20747,9 @@ function mrrlinTable(binPath, distribution, serveEnv) {
   }
   return { ...base, startup_timeout_sec: 30 };
 }
+function externalAgentsTable() {
+  return { command: "external-agents-mcp", args: [], startup_timeout_sec: 30 };
+}
 function browserTable(binPath, distribution, homeDir) {
   const base = distribution === "npm" ? { command: "mrrlin-mcp", args: ["browser-serve"] } : { command: "node", args: [binPath, "browser-serve"] };
   return { ...base, startup_timeout_sec: 30, env: { PLAYWRIGHT_BROWSERS_PATH: browserPaths(homeDir).browsersPath } };
@@ -20767,6 +20770,11 @@ function managedBlocks(options, distribution) {
       id: "mrrlin-browser",
       expected: browserTable(options.binPath, distribution, homeDir),
       blockRe: blockRegex("mrrlin-browser")
+    },
+    {
+      id: "external-agents",
+      expected: externalAgentsTable(),
+      blockRe: blockRegex("external-agents")
     }
   ];
 }
@@ -20981,7 +20989,7 @@ var import_node_fs11 = __toESM(require("node:fs"), 1);
 var import_node_http = __toESM(require("node:http"), 1);
 var import_node_os7 = __toESM(require("node:os"), 1);
 var import_node_path13 = __toESM(require("node:path"), 1);
-var import_node_child_process7 = require("node:child_process");
+var import_node_child_process9 = require("node:child_process");
 var import_node_crypto7 = __toESM(require("node:crypto"), 1);
 
 // src/turn-replay-buffer.ts
@@ -36377,6 +36385,8 @@ var openApiOperationIds = {
   listArtifactFiles: "listArtifactFiles",
   getOperatorSettings: "getOperatorSettings",
   updateOperatorSettings: "updateOperatorSettings",
+  getAgentPool: "getAgentPool",
+  putAgentPool: "putAgentPool",
   getConsensusConfig: "getConsensusConfig",
   updateWikiPageCas: "updateWikiPageCas",
   promoteSpecReadyCas: "promoteSpecReadyCas",
@@ -36432,6 +36442,27 @@ var mrrlinOperatorSettingsUpdateSchema = external_exports.object({
 var operatorSettingsResponseSchema = external_exports.object({ data: mrrlinOperatorSettingsSchema });
 var mrrlinConsensusConfigSchema = external_exports.object({ consensusEnabled: external_exports.boolean() });
 var consensusConfigResponseSchema = external_exports.object({ data: mrrlinConsensusConfigSchema });
+var agentPoolSnapshotSchema = external_exports.object({
+  collected_at: external_exports.string(),
+  status: external_exports.enum(["ok", "unavailable"]),
+  agents: external_exports.array(external_exports.object({
+    id: external_exports.string(),
+    provider: external_exports.string(),
+    tier: external_exports.string(),
+    tags: external_exports.array(external_exports.string()),
+    state: external_exports.string(),
+    calls: external_exports.number(),
+    tokens_in: external_exports.number(),
+    tokens_out: external_exports.number(),
+    success_rate: external_exports.number(),
+    last_used_at: external_exports.string().nullable()
+  })),
+  totals: external_exports.object({ calls: external_exports.number(), tokens_in: external_exports.number(), tokens_out: external_exports.number() }),
+  estimated_savings_usd: external_exports.number()
+});
+var agentPoolResponseSchema = external_exports.object({
+  data: external_exports.object({ snapshot: agentPoolSnapshotSchema.nullable() })
+});
 
 // ../../packages/schemas/dist/specConsensusReview.js
 var mrrlinSpecConsensusReviewSchema = external_exports.object({
@@ -37615,7 +37646,8 @@ var mrrlinInboxItemDecideSchema = external_exports.object({
 var mrrlinInboxItemListFiltersSchema = external_exports.object({
   kind: mrrlinInboxItemKindSchema.optional(),
   readState: external_exports.enum(["read", "unread"]).optional(),
-  status: mrrlinInboxItemStatusSchema.optional()
+  status: mrrlinInboxItemStatusSchema.optional(),
+  taskId: mrrlinTaskIdSchema.optional()
 });
 var inboxItemReadResponseSchema = external_exports.object({
   data: external_exports.object({
@@ -38222,7 +38254,8 @@ function createMrrlinClient(config2) {
       const url2 = appendQuery(`${projectPath(projectSlug)}/inbox`, {
         kind: filters.kind,
         readState: filters.readState,
-        status: filters.status
+        status: filters.status,
+        taskId: filters.taskId
       });
       const body = await request(url2);
       return inboxItemListResponseSchema.parse(body).data;
@@ -38406,6 +38439,18 @@ function createMrrlinClient(config2) {
       });
       return operatorSettingsResponseSchema.parse(body).data;
     },
+    async getOperatorAgentPool() {
+      const body = await request(`/operator/agent-pool`);
+      return agentPoolResponseSchema.parse(body).data;
+    },
+    async putOperatorAgentPool(snapshot) {
+      const body = await request(`/operator/agent-pool`, {
+        body: JSON.stringify(snapshot),
+        headers: { "content-type": "application/json" },
+        method: "POST"
+      });
+      return agentPoolResponseSchema.parse(body).data;
+    },
     async getConsensusConfig(projectSlug) {
       const body = await request(`${projectPath(projectSlug)}/consensus-config`);
       return consensusConfigResponseSchema.parse(body).data;
@@ -38788,8 +38833,92 @@ Do NOT derail the current task - if the operator has an in-flight question, answ
   };
 }
 
+// src/codex-version.ts
+var import_node_child_process3 = require("node:child_process");
+var import_semver2 = __toESM(require_semver2(), 1);
+var SEMVER_RE = /\b\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?\b/;
+var CODEX_PACKAGE = process.env.MRRLIN_CODEX_PACKAGE?.trim() || "@openai/codex";
+var distTagsUrl = (pkg) => `https://registry.npmjs.org/-/package/${encodeURIComponent(pkg)}/dist-tags`;
+function parseCodexVersion(raw) {
+  const m = raw.match(SEMVER_RE);
+  return m ? m[0] : null;
+}
+var defaultRun = (args) => {
+  const r = (0, import_node_child_process3.spawnSync)("codex", args, { encoding: "utf8", timeout: 8e3, shell: true });
+  return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+};
+function getInstalledCodexVersion(run3) {
+  const r = run3(["--version"]);
+  if (r.status !== 0) return null;
+  return parseCodexVersion(r.stdout || r.stderr);
+}
+async function fetchLatestCodexVersion(fetchImpl = globalThis.fetch, pkg = CODEX_PACKAGE) {
+  try {
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), 5e3);
+    let res;
+    try {
+      res = await fetchImpl(distTagsUrl(pkg), {
+        headers: { Accept: "application/json" },
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(t);
+    }
+    if (!res.ok) return null;
+    const body = await res.json();
+    const latest = body?.latest;
+    return typeof latest === "string" && import_semver2.default.valid(latest) ? latest : null;
+  } catch {
+    return null;
+  }
+}
+async function computeCodexUpdateState(run3, fetchImpl = globalThis.fetch, pkg = CODEX_PACKAGE) {
+  const version2 = getInstalledCodexVersion(run3);
+  if (!version2 || !import_semver2.default.valid(version2)) return { version: version2, latestVersion: null, updateAvailable: false };
+  const latestVersion = await fetchLatestCodexVersion(fetchImpl, pkg);
+  if (!latestVersion) return { version: version2, latestVersion: null, updateAvailable: false };
+  return { version: version2, latestVersion, updateAvailable: import_semver2.default.gt(latestVersion, version2) };
+}
+function codexUpdateCommandFor(state) {
+  return state.updateAvailable ? "codex update" : null;
+}
+var DEFAULT_PROBE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+var DEFAULT_STARTUP_DELAY_MS = 1e4;
+function startCodexProbe(deps = {}) {
+  const run3 = deps.run ?? defaultRun;
+  const fetchImpl = deps.fetchImpl ?? globalThis.fetch;
+  const pkg = deps.pkg ?? CODEX_PACKAGE;
+  const intervalMs = deps.intervalMs ?? DEFAULT_PROBE_INTERVAL_MS;
+  const startupDelayMs = deps.startupDelayMs ?? DEFAULT_STARTUP_DELAY_MS;
+  const setIntervalFn = deps.setIntervalImpl ?? setInterval;
+  const clearIntervalFn = deps.clearIntervalImpl ?? clearInterval;
+  const setTimeoutFn = deps.setTimeoutImpl ?? setTimeout;
+  const clearTimeoutFn = deps.clearTimeoutImpl ?? clearTimeout;
+  let state = { version: null, latestVersion: null, updateAvailable: false };
+  const refreshNow = async () => {
+    try {
+      state = await computeCodexUpdateState(run3, fetchImpl, pkg);
+    } catch {
+    }
+  };
+  const startupTimer = setTimeoutFn(() => void refreshNow(), startupDelayMs);
+  startupTimer.unref?.();
+  const timer = setIntervalFn(() => void refreshNow(), intervalMs);
+  timer.unref?.();
+  return {
+    getState: () => state,
+    getUpdateCommand: () => codexUpdateCommandFor(state),
+    refreshNow,
+    stop: () => {
+      clearTimeoutFn(startupTimer);
+      clearIntervalFn(timer);
+    }
+  };
+}
+
 // src/_generated/version.ts
-var PKG_VERSION = "0.3.27";
+var PKG_VERSION = "0.3.34";
 
 // src/api-base-url.ts
 var DEFAULT_API_BASE_URL = "http://127.0.0.1:8787";
@@ -38967,8 +39096,192 @@ function startSchedulerTickLoop(deps) {
   };
 }
 
+// src/agent-pool-loop.ts
+var import_node_child_process4 = require("node:child_process");
+
+// src/agent-pool-snapshot.ts
+function buildAgentPoolSnapshot(statusRows, stats, opts) {
+  if (!opts.available) {
+    return {
+      collected_at: opts.collectedAt,
+      status: "unavailable",
+      agents: [],
+      totals: { calls: 0, tokens_in: 0, tokens_out: 0 },
+      estimated_savings_usd: 0
+    };
+  }
+  const costPer1M = opts.paidCostPer1MTokens ?? 3;
+  const agents = statusRows.map((row) => {
+    const agentStats = stats.by_agent[row.id];
+    const count2 = agentStats?.count ?? 0;
+    const tokensIn = agentStats?.tokens_in ?? 0;
+    const tokensOut = agentStats?.tokens_out ?? 0;
+    let successRate = 0;
+    if (count2 > 0) {
+      const successOutcomes = agentStats?.outcomes.success ?? 0;
+      successRate = Number((successOutcomes / count2 * 100).toFixed(2)) / 100;
+    }
+    return {
+      id: row.id,
+      provider: row.provider,
+      tier: row.tier,
+      tags: row.tags,
+      state: row.state ?? "unknown",
+      calls: count2,
+      tokens_in: tokensIn,
+      tokens_out: tokensOut,
+      success_rate: successRate,
+      last_used_at: row.last_used_at ?? null
+    };
+  });
+  let totalCalls = 0;
+  let totalTokensIn = 0;
+  let totalTokensOut = 0;
+  for (const entry of Object.values(stats.by_agent)) {
+    totalCalls += entry.count;
+    totalTokensIn += entry.tokens_in;
+    totalTokensOut += entry.tokens_out;
+  }
+  let savedTokens = 0;
+  for (const row of statusRows) {
+    if (row.tags.includes("free")) {
+      const agentStats = stats.by_agent[row.id];
+      if (agentStats) {
+        savedTokens += agentStats.tokens_in + agentStats.tokens_out;
+      }
+    }
+  }
+  const estimatedSavings = Number((savedTokens / 1e6 * costPer1M).toFixed(2));
+  return {
+    collected_at: opts.collectedAt,
+    status: "ok",
+    agents,
+    totals: {
+      calls: totalCalls,
+      tokens_in: totalTokensIn,
+      tokens_out: totalTokensOut
+    },
+    estimated_savings_usd: estimatedSavings
+  };
+}
+
+// src/agent-pool-collector.ts
+async function collectAgentPoolSnapshot(deps) {
+  let statusRows;
+  let stats;
+  try {
+    const statusResult = await deps.runCli(["status", "--json"]);
+    if (statusResult.code !== 0) throw new Error("non-zero exit on status");
+    let statusParsed;
+    try {
+      statusParsed = JSON.parse(statusResult.stdout);
+    } catch {
+      throw new Error("invalid status json");
+    }
+    if (!Array.isArray(statusParsed)) throw new Error("status not array");
+    statusRows = statusParsed;
+    const statsResult = await deps.runCli(["stats", "--json"]);
+    if (statsResult.code !== 0) throw new Error("non-zero exit on stats");
+    try {
+      stats = JSON.parse(statsResult.stdout);
+    } catch {
+      throw new Error("invalid stats json");
+    }
+  } catch {
+    return buildAgentPoolSnapshot(
+      [],
+      {},
+      { collectedAt: deps.now(), available: false }
+    );
+  }
+  return buildAgentPoolSnapshot(
+    statusRows,
+    stats,
+    { collectedAt: deps.now(), paidCostPer1MTokens: deps.paidCostPer1MTokens, available: true }
+  );
+}
+
+// src/agent-pool-loop.ts
+var DEFAULT_INTERVAL_MS2 = 6e4;
+function agentPoolLoopDisabled(env = process.env) {
+  return env["MRRLIN_BRIDGE_AGENT_POOL_DISABLE"] === "1";
+}
+function defaultRunCli(args) {
+  const cli = process.env["EXTERNAL_AGENTS_CLI"];
+  const [cmd, baseArgs] = cli ? ["node", [cli, ...args]] : ["external-agents", args];
+  return new Promise((resolve) => {
+    let stdout = "";
+    let settled = false;
+    const done = (code) => {
+      if (!settled) {
+        settled = true;
+        resolve({ stdout, code });
+      }
+    };
+    try {
+      const child = (0, import_node_child_process4.spawn)(cmd, baseArgs, { stdio: ["ignore", "pipe", "ignore"] });
+      const timer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        done(1);
+      }, 5e3);
+      timer.unref?.();
+      child.stdout.on("data", (d) => {
+        stdout += d.toString();
+        if (stdout.length > 2e5) stdout = stdout.slice(-2e5);
+      });
+      child.on("error", () => {
+        clearTimeout(timer);
+        done(1);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        done(code ?? 1);
+      });
+    } catch {
+      done(1);
+    }
+  });
+}
+async function runAgentPoolCycle(deps) {
+  try {
+    const snapshot = await collectAgentPoolSnapshot({
+      runCli: deps.runCli ?? defaultRunCli,
+      now: deps.now ?? (() => (/* @__PURE__ */ new Date()).toISOString())
+    });
+    await deps.push(snapshot);
+  } catch (err) {
+    deps.onError?.(err);
+  }
+}
+function startAgentPoolLoop(deps) {
+  const env = deps.env ?? process.env;
+  const intervalMs = deps.intervalMs ?? Number(env["MRRLIN_BRIDGE_AGENT_POOL_INTERVAL_MS"] ?? DEFAULT_INTERVAL_MS2);
+  let stopped = false;
+  let timer = null;
+  const schedule = () => {
+    if (stopped) return;
+    timer = setTimeout(() => {
+      void runAgentPoolCycle(deps).then(() => schedule());
+    }, intervalMs);
+    timer.unref?.();
+  };
+  timer = setTimeout(() => {
+    void runAgentPoolCycle(deps).then(() => schedule());
+  }, 1e3);
+  timer.unref?.();
+  return {
+    stop() {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    }
+  };
+}
+
 // src/execution-consumer.ts
-var import_node_child_process6 = require("node:child_process");
+var import_node_child_process8 = require("node:child_process");
 var import_node_crypto4 = __toESM(require("node:crypto"), 1);
 var import_node_path6 = __toESM(require("node:path"), 1);
 var import_node_util = require("node:util");
@@ -38991,6 +39304,9 @@ function normalizeDomain(value) {
 function resolveHeads(domain2) {
   return [...HEADS_BY_DOMAIN[normalizeDomain(domain2)]];
 }
+function allReviewHeads() {
+  return [...new Set(Object.values(HEADS_BY_DOMAIN).flat())];
+}
 var PERSONAS_BY_DOMAIN = {
   seo: "seo-writer",
   content: "content-author",
@@ -39009,7 +39325,7 @@ var import_node_path3 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 
 // src/consensus/codex-exec.ts
-var import_node_child_process3 = require("node:child_process");
+var import_node_child_process5 = require("node:child_process");
 function extractFinalMessage(stdout) {
   let last = null;
   for (const rawLine of stdout.split(/\r?\n/)) {
@@ -39054,7 +39370,7 @@ function firstString(...values) {
   return null;
 }
 function runCodexExec(input, deps) {
-  const spawn2 = deps?.spawn ?? import_node_child_process3.spawn;
+  const spawn3 = deps?.spawn ?? import_node_child_process5.spawn;
   const executable = input.codexExecutable ?? "codex";
   const sandbox = input.sandbox ?? "read-only";
   const fullPrompt = input.developerInstructions.trim() ? `${input.developerInstructions.trim()}
@@ -39086,7 +39402,7 @@ ${input.prompt}` : input.prompt;
     };
     let child;
     try {
-      child = spawn2(executable, args, options);
+      child = spawn3(executable, args, options);
     } catch (err) {
       finish({ ok: false, error: `Failed to spawn codex exec: ${errMessage(err)}` });
       return;
@@ -39193,7 +39509,7 @@ function parseAcceptanceCriteria(markdown) {
 }
 
 // src/consensus/code-gate-git.ts
-var import_node_child_process4 = require("node:child_process");
+var import_node_child_process6 = require("node:child_process");
 var DIFF_MAX_BYTES = 2e5;
 var FASTGATE_OUTPUT_MAX_BYTES = 16e3;
 var GIT_TIMEOUT_MS = 6e4;
@@ -39209,7 +39525,7 @@ var defaultRunCmd = (cmd, args, opts) => new Promise((resolve) => {
   };
   let child;
   try {
-    child = (0, import_node_child_process4.spawn)(cmd, args, {
+    child = (0, import_node_child_process6.spawn)(cmd, args, {
       cwd: opts.cwd,
       env: process.env,
       shell: false,
@@ -39455,7 +39771,7 @@ function reviserIdentityInstructions(taskId, title) {
 }
 function buildSpecGateDeps(args) {
   const { client, projectSlug, specPageId, cwd, codexExecutable, extraHeadCount = 0 } = args;
-  const rounds = Number(process.env["MRRLIN_CONSENSUS_ROUNDS"] ?? 3);
+  const rounds = Number(process.env["MRRLIN_CONSENSUS_ROUNDS"] ?? 5);
   const maxHeadCalls = rounds * (4 + extraHeadCount + 1);
   const timeoutMs = Number(process.env["MRRLIN_CONSENSUS_HEAD_TIMEOUT_MS"] ?? 15e4);
   let intentPromise = null;
@@ -39609,7 +39925,7 @@ ${artifact}`,
 }
 function buildCodeGateDeps(args) {
   const { client, projectSlug, baseRef, cwd, codexExecutable, extraHeads } = args;
-  const rounds = Number(process.env["MRRLIN_CONSENSUS_ROUNDS"] ?? 3);
+  const rounds = Number(process.env["MRRLIN_CONSENSUS_ROUNDS"] ?? 5);
   const heads = ["code-reviewer", ...extraHeads ?? []];
   const maxHeadCalls = rounds * (heads.length + 1);
   const headTimeoutMs = Number(process.env["MRRLIN_CONSENSUS_HEAD_TIMEOUT_MS"] ?? 15e4);
@@ -39690,7 +40006,7 @@ function renderCriteriaBlock(criteria) {
 }
 async function buildDeliverableGateDeps(args) {
   const { client, projectSlug, deliverablePageId, cwd, codexExecutable, runId } = args;
-  const rounds = Number(process.env["MRRLIN_CONSENSUS_ROUNDS"] ?? 3);
+  const rounds = Number(process.env["MRRLIN_CONSENSUS_ROUNDS"] ?? 5);
   const timeoutMs = Number(process.env["MRRLIN_CONSENSUS_HEAD_TIMEOUT_MS"] ?? 15e4);
   const page = await client.getWikiPage(projectSlug, deliverablePageId);
   const taskId = page.taskId ?? null;
@@ -40613,7 +40929,7 @@ async function awaitTurnWithDeadline(opts) {
 }
 
 // src/worktree.ts
-var import_node_child_process5 = require("node:child_process");
+var import_node_child_process7 = require("node:child_process");
 var import_node_fs4 = require("node:fs");
 var import_node_os3 = require("node:os");
 var import_node_path5 = require("node:path");
@@ -40641,9 +40957,9 @@ async function withCheckoutLock(locksDir, slug, fn) {
 function worktreeBranch(runId) {
   return `mrrlin/run-${runId}`;
 }
-var defaultGitExec = (args, env) => (0, import_node_child_process5.execFileSync)("git", args, { encoding: "utf8", timeout: 3e4, env });
+var defaultGitExec = (args, env) => (0, import_node_child_process7.execFileSync)("git", args, { encoding: "utf8", timeout: 3e4, env });
 function git(checkout, args) {
-  return (0, import_node_child_process5.execFileSync)("git", ["-C", checkout, ...args], {
+  return (0, import_node_child_process7.execFileSync)("git", ["-C", checkout, ...args], {
     encoding: "utf8",
     timeout: 3e4,
     env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
@@ -40848,6 +41164,38 @@ function isExecutionTurnTimeoutReason(reason) {
 function contextMaxArtifacts() {
   return readPositiveIntEnv("MRRLIN_DIRECTOR_BRIDGE_CONTEXT_MAX_ARTIFACTS", DEFAULT_CONTEXT_MAX_ARTIFACTS);
 }
+var DEFAULT_COMPLETION_TURN_BUDGET_MS = 6e4;
+var DEFAULT_COMPLETION_TURN_MIN_BUDGET_MS = 1e4;
+function completionTurnBudgetMs() {
+  return readPositiveIntEnv("MRRLIN_COMPLETION_TURN_BUDGET_MS", DEFAULT_COMPLETION_TURN_BUDGET_MS);
+}
+function completionTurnMinBudgetMs() {
+  return readPositiveIntEnv("MRRLIN_COMPLETION_TURN_MIN_BUDGET_MS", DEFAULT_COMPLETION_TURN_MIN_BUDGET_MS);
+}
+function isCompletionTurnDisabled() {
+  return (process.env.MRRLIN_COMPLETION_TURN_DISABLED ?? "").trim() === "1";
+}
+function buildCompletionTurnPrompt(taskId, currentStatus) {
+  return [
+    `Your work turn ended but task ${taskId} is still in status "${currentStatus}".`,
+    "",
+    "Decide honestly whether the work is complete:",
+    "",
+    "If the work IS genuinely complete:",
+    "1. Update the task notes with a markdown summary of what you accomplished",
+    "   (see the notes format contract in your base instructions).",
+    "2. Call update_task with status=closed_done.",
+    "3. Append a completion-evidence artifact (checkpoint or diff_summary)",
+    "   to the open run if you haven't already.",
+    "",
+    "If the work is NOT complete \u2014 be honest, do not close incomplete work:",
+    "1. Call update_task with the appropriate status (needs_human, awaiting_verification, etc.)",
+    "   and explain what remains in the notes.",
+    "2. Append a handoff_judgement artifact explaining what the operator needs to do.",
+    "",
+    "You must pick one of these paths \u2014 do not leave the task in_progress."
+  ].join("\n");
+}
 var BASE_INSTRUCTIONS_PREFIX = [
   "You are the Mrrlin Director driving a task toward completion autonomously.",
   "You can call MCP tools to read and write durable project state.",
@@ -40863,6 +41211,9 @@ var BASE_INSTRUCTIONS_PREFIX = [
   "- Close the task with `update_task` status=closed_done ONLY when it is genuinely complete",
   "  AND you appended at least one completion-evidence artifact. Otherwise leave the task",
   "  open so the run fails into an operator handoff instead of pretending success.",
+  "- For a CODE task the run opens a draft PR for you after your turn; opening that PR is NOT",
+  "  completion. Do NOT set closed_done for code work \u2014 leave the task open; the run parks at",
+  "  `pull_request` (waiting for merge) and the operator merges. Closure happens after merge.",
   "",
   "File artifacts:",
   "- When your output is a file (markdown report, HTML, screenshot), upload it with",
@@ -40882,6 +41233,23 @@ var BASE_INSTRUCTIONS_PREFIX = [
   "  and lose login/cookie state across runs.",
   "- If tool listings show duplicate names across servers, prefer the `mrrlin-browser` one",
   "  unconditionally. Do not switch mid-run.",
+  "",
+  "Task description quality contract \u2014 every task you create or update via create_task or update_task:",
+  "- Title: short, actionable, human-readable. Describe what needs to happen, not internal jargon.",
+  '  Good: "Audit crawled-not-indexed pages and fix 404 errors"',
+  '  Bad: "GSC coverage triage crawled-not-indexed + 404"',
+  "- Notes (markdown): write for a human operator scanning a task list.",
+  "  First line: one plain-text sentence summarizing the task (no heading).",
+  "  Then scale the structure to complexity:",
+  "  For simple tasks \u2014 the one-line summary may be enough. No headings required.",
+  "  For non-trivial tasks, use these sections as needed:",
+  "    ## Context \u2014 why this task exists; link to parent/trigger task if follow-up.",
+  "    ## Scope \u2014 concrete actions and acceptance criteria.",
+  "    ## References \u2014 links, data, relevant findings (omit if nothing to reference).",
+  "  When closing a task (update_task status=closed_done), APPEND a Result section:",
+  "    ## Result \u2014 what was accomplished, key findings or metrics, follow-up tasks created.",
+  "    Do NOT remove earlier sections \u2014 they remain useful for context.",
+  "  Adapt depth to the task: a one-line fix needs one sentence, not four headings.",
   ""
 ];
 var CONSUMER_BASE_INSTRUCTIONS = [
@@ -40896,7 +41264,23 @@ var EXECUTOR_BASE_INSTRUCTIONS = [
   "files and running git/build/test commands WITHIN this worktree. Keep all changes inside the",
   "worktree and do not read the operator's personal secrets or files outside it \u2014 this is a rule",
   "you must follow, not something the environment enforces. Be concise. When you have made the",
-  "next increment of progress, stop the turn."
+  "next increment of progress, stop the turn.",
+  // ADR 0022 Phase 3: the executor is the orchestrator, not the sole worker. It has the
+  // external-agents `pick`/`dispatch` MCP tools (a pool of cheap/free models) and should
+  // delegate the bulk substantive work to them in parallel, keeping itself as judge. This
+  // minimises the expensive default model's own token spend while the verify step preserves
+  // quality. If external-agents isn't installed the tools are simply absent — these lines then
+  // read as advice the model can't act on, and it does the work itself (graceful, no-op).
+  "You are the ORCHESTRATOR and JUDGE, not the sole worker. If the external-agents `pick` and",
+  "`dispatch` tools are available, delegate substantive, parallelizable subtasks \u2014 file edits,",
+  "boilerplate, tests, research, mechanical refactors \u2014 to pool subagents via `dispatch`, several",
+  "in parallel where possible, to minimise your own token spend. Keep for yourself only what needs",
+  "your judgment: decomposition, integration, hard reasoning, and final decisions. You MUST verify",
+  "every delegated result against the actual files and tests before it lands \u2014 pool models are",
+  "lower-reliability and a wrong delegated edit is YOUR responsibility; never commit unverified",
+  "delegated output. Delegation is the default for routine bulk work, but do trivial tasks yourself",
+  "when dispatch overhead exceeds the work. If dispatch fails or the pool is unavailable, do the",
+  "work yourself \u2014 never block the run on the pool."
 ].join("\n");
 function artifactKindForEvent(event) {
   switch (event.type) {
@@ -40935,7 +41319,7 @@ var BLAST_RADIUS_FLOOR_PATTERNS = [/^supabase\/migrations\//, /^packages\/db\/sr
 function isBlastRadiusFloorPath(path15) {
   return BLAST_RADIUS_FLOOR_PATTERNS.some((re) => re.test(path15));
 }
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process6.execFile);
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process8.execFile);
 async function defaultListRunDiffPaths(opts) {
   const parse5 = (stdout) => stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
   try {
@@ -41315,10 +41699,44 @@ Continue executing task ${task.id}. Make the next concrete increment of progress
       await failRun(deps, projectSlug, task, runId, leaseId, outcome.error);
       return;
     }
-    const readiness = await assertRunCompletionReady(deps, projectSlug, task.id, runId);
+    let readiness = await assertRunCompletionReady(deps, projectSlug, task.id, runId);
     if (!readiness.ok) {
-      await failRun(deps, projectSlug, readiness.task, runId, leaseId, readiness.reason);
-      return;
+      const completionBudget = Math.min(completionTurnBudgetMs(), remainingTurnBudgetMs());
+      if (isCompletionTurnDisabled() || completionBudget < completionTurnMinBudgetMs()) {
+        await failRun(deps, projectSlug, readiness.task, runId, leaseId, readiness.reason);
+        return;
+      }
+      console.warn(
+        JSON.stringify({
+          event: "completion_turn_triggered",
+          projectSlug,
+          runId,
+          taskId: task.id,
+          previousStatus: readiness.task.status
+        })
+      );
+      const completionPrompt = buildCompletionTurnPrompt(task.id, readiness.task.status);
+      const completionOutcome = await driveTurn(
+        deps,
+        codex,
+        projectSlug,
+        runId,
+        leaseId,
+        threadId,
+        completionPrompt,
+        completionBudget,
+        "completion"
+      );
+      if (!completionOutcome.ok) {
+        await resetWedgedThread(deps, projectSlug, task.id, completionOutcome.interruptFailed);
+        await failRun(deps, projectSlug, readiness.task, runId, leaseId, completionOutcome.error);
+        return;
+      }
+      readiness = await assertRunCompletionReady(deps, projectSlug, task.id, runId);
+      if (!readiness.ok) {
+        await failRun(deps, projectSlug, readiness.task, runId, leaseId, readiness.reason);
+        return;
+      }
     }
     if (useExecutor) {
       if (!worktreePath) {
@@ -41410,6 +41828,13 @@ Continue executing task ${task.id}. Make the next concrete increment of progress
           pullRequestUrl: pr.url,
           status: "pull_request"
         });
+        await reconcileTaskAwaitingMerge(
+          deps,
+          projectSlug,
+          readiness.task,
+          runId,
+          `PR opened (${pr.url}); autoDeploy is off \u2014 the operator merges when ready.`
+        );
         return;
       }
       if (deps.deployGate) {
@@ -41424,7 +41849,7 @@ Continue executing task ${task.id}. Make the next concrete increment of progress
           pullRequestUrl: pr.url,
           status: "pull_request"
         });
-        await notifyOperatorHandoff(
+        await reconcileTaskAwaitingMerge(
           deps,
           projectSlug,
           readiness.task,
@@ -41716,6 +42141,34 @@ async function failRun(deps, projectSlug, task, runId, leaseId, reason) {
     await notifyOperatorHandoff(deps, projectSlug, task, runId, reason);
   }
 }
+async function reconcileTaskAwaitingMerge(deps, projectSlug, task, runId, reason) {
+  if (task.status === "handoff_needed") return;
+  await deps.client.appendExecutionArtifact(projectSlug, runId, {
+    id: newArtifactId(),
+    kind: "handoff_judgement",
+    payload: {
+      verdict: "approved",
+      reason,
+      summary: `Execution run ${runId} opened a PR and is awaiting operator action.`,
+      operatorQuestion: `Task ${task.id} (${task.title}) has an open PR: ${reason}`,
+      source: "execution-consumer"
+    }
+  }).catch(() => {
+  });
+  try {
+    await deps.client.updateTask(projectSlug, task.id, { status: "handoff_needed" });
+  } catch (error51) {
+    console.warn(
+      JSON.stringify({
+        event: "reconcile_awaiting_merge_failed",
+        projectSlug,
+        taskId: task.id,
+        runId,
+        error: error51 instanceof Error ? error51.message : String(error51)
+      })
+    );
+  }
+}
 async function notifyOperatorHandoff(deps, projectSlug, task, runId, reason) {
   try {
     await deps.client.appendExecutionArtifact(projectSlug, runId, {
@@ -41915,13 +42368,15 @@ async function driveAsyncJob(deps, projectSlug, jobId) {
   }).catch(() => {
   });
   const delivery = descriptor2.onComplete(outcome, input);
-  await deps.client.createInboxItem(projectSlug, {
-    id: delivery.id ?? `II-${import_node_crypto5.default.randomUUID()}`,
-    kind: delivery.kind,
-    body: delivery.body,
-    ...delivery.taskId ? { taskId: delivery.taskId } : {}
-  }).catch(() => {
-  });
+  if (!delivery.suppressInbox) {
+    await deps.client.createInboxItem(projectSlug, {
+      id: delivery.id ?? `II-${import_node_crypto5.default.randomUUID()}`,
+      kind: delivery.kind,
+      body: delivery.body,
+      ...delivery.taskId ? { taskId: delivery.taskId } : {}
+    }).catch(() => {
+    });
+  }
   if (descriptor2.wakeDirector) deps.wake(projectSlug, claimed.directorSessionId, delivery.body, delivery.kind);
 }
 function deriveHash() {
@@ -46768,6 +47223,23 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     'or "let me call the \u2026 tool" in ANY language. The operator already sees tool calls in the',
     "transcript. Just call the tools and reply with the outcome \u2014 start your reply with the result.",
     "When creating or updating tasks, always provide `autonomyLevel` and `autonomyReason`.",
+    "",
+    "Task description quality contract \u2014 every task you create or update via create_task or update_task:",
+    "- Title: short, actionable, human-readable. Describe what needs to happen, not internal jargon.",
+    '  Good: "Audit crawled-not-indexed pages and fix 404 errors"',
+    '  Bad: "GSC coverage triage crawled-not-indexed + 404"',
+    "- Notes (markdown): write for a human operator scanning a task list.",
+    "  First line: one plain-text sentence summarizing the task (no heading).",
+    "  Then scale the structure to complexity:",
+    "  For simple tasks \u2014 the one-line summary may be enough. No headings required.",
+    "  For non-trivial tasks, use these sections as needed:",
+    "    ## Context \u2014 why this task exists; link to parent/trigger task if follow-up.",
+    "    ## Scope \u2014 concrete actions and acceptance criteria.",
+    "    ## References \u2014 links, data, relevant findings (omit if nothing to reference).",
+    "  When closing a task (update_task status=closed_done), APPEND a Result section:",
+    "    ## Result \u2014 what was accomplished, key findings or metrics, follow-up tasks created.",
+    "    Do NOT remove earlier sections \u2014 they remain useful for context.",
+    "  Adapt depth to the task: a one-line fix needs one sentence, not four headings.",
     "When you create a task out of an operator request, set `operatorSeedRequest` to the operator's",
     "VERBATIM words (their request as they wrote it \u2014 NOT your paraphrase or synthesized notes). It is",
     "the spec gate's independent record of intent; omit it only when there is genuinely no operator",
@@ -47017,7 +47489,7 @@ function resolveDefaultBranch(checkoutPath) {
   if (!checkoutPath) return "main";
   const runGit = (args) => {
     try {
-      return (0, import_node_child_process7.execFileSync)("git", ["-C", checkoutPath, ...args], {
+      return (0, import_node_child_process9.execFileSync)("git", ["-C", checkoutPath, ...args], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
         timeout: 15e3,
@@ -47176,7 +47648,7 @@ function sessionIdOf(msg) {
   return typeof id === "string" ? id : null;
 }
 function attachBridgeWss(server, opts) {
-  const { token, allowedOrigins, onReady, logger, onPaired, bridgeInstanceId, selfUpdate } = opts;
+  const { token, allowedOrigins, onReady, logger, onPaired, bridgeInstanceId, selfUpdate, codex } = opts;
   const wss = new import_websocket_server.default({ server, path: "/ws" });
   wss.on("connection", (socket, request) => {
     const origin = request.headers.origin;
@@ -47241,7 +47713,15 @@ function attachBridgeWss(server, opts) {
         version: selfUpdate.version,
         binSha: selfUpdate.binSha,
         latestVersion: selfUpdate.getLatestVersion()
-      } : {}
+      } : {},
+      ...codex ? (() => {
+        const st = codex.getState();
+        return {
+          codexVersion: st.version,
+          codexLatestVersion: st.latestVersion,
+          codexUpdateCommand: codex.getUpdateCommand()
+        };
+      })() : {}
     });
     onPaired?.();
     onReady?.(socket, request, send, logger ? { logger, span } : void 0);
@@ -47265,13 +47745,14 @@ async function waitFor(pred, timeoutMs) {
   return pred();
 }
 function attachSeqMetadata(msg, seq, turnId) {
-  if (msg.type === "event" || msg.type === "rateLimits" || msg.type === "error") {
+  if (msg.type === "event" || msg.type === "rateLimits" || msg.type === "error" || msg.type === "turn-executing") {
     return { ...msg, seq, turnId };
   }
   return msg;
 }
 function createBridgeMessageHandler(deps) {
   const tombstones = deps.tombstones ?? /* @__PURE__ */ new Map();
+  const pendingTurnSessions = /* @__PURE__ */ new Set();
   return (socket, _request, send, logCtx) => {
     const boundSessions = /* @__PURE__ */ new Set();
     socket.on("close", () => {
@@ -47523,6 +48004,14 @@ function createBridgeMessageHandler(deps) {
             interruptBuf.state = stopResult.next;
             recordInterrupted(interruptBuf, Date.now(), deps.suspendedMs?.() ?? 0);
           }
+        } else if (interruptBuf && interruptBuf.state === "live" && !existing.cancel) {
+          const stopResult = transition("live", { kind: "stop" });
+          if (stopResult.next !== "invalid") {
+            interruptBuf.state = stopResult.next;
+            recordInterrupted(interruptBuf, Date.now(), deps.suspendedMs?.() ?? 0);
+            existing.inFlight = false;
+            pendingTurnSessions.delete(directorSessionId2);
+          }
         }
         const codexClient2 = await deps.acquireCodex();
         try {
@@ -47581,6 +48070,18 @@ function createBridgeMessageHandler(deps) {
         sendForSpan({ type: "error", directorSessionId, error: "message is required." });
         return;
       }
+      const busyThread = deps.threads.get(directorSessionId);
+      if (msg.takeover !== true && (pendingTurnSessions.has(directorSessionId) || busyThread?.inFlight)) {
+        sendForSpan({
+          type: "error",
+          directorSessionId,
+          code: "busy",
+          ...busyThread?.replay ? { inFlightTurnId: busyThread.replay.turnId } : {},
+          error: "Director session is busy."
+        });
+        return;
+      }
+      pendingTurnSessions.add(directorSessionId);
       const codexClient = await deps.acquireCodex();
       let thread = deps.threads.get(directorSessionId);
       if (thread?.inFlight && msg.takeover === true) {
@@ -47666,6 +48167,7 @@ function createBridgeMessageHandler(deps) {
         if (/unauthor|not logged in|login|401|auth/i.test(acquireErrMsg)) {
           deps.setCodexAuth?.("expired");
         }
+        pendingTurnSessions.delete(directorSessionId);
         deps.releaseCodex();
         return;
       }
@@ -47677,10 +48179,12 @@ function createBridgeMessageHandler(deps) {
           ...thread.replay ? { inFlightTurnId: thread.replay.turnId } : {},
           error: "Director session is busy."
         });
+        pendingTurnSessions.delete(directorSessionId);
         deps.releaseCodex();
         return;
       }
       thread.inFlight = true;
+      pendingTurnSessions.delete(directorSessionId);
       thread.replay = createReplayBuffer({
         turnId: (0, import_node_crypto7.randomUUID)(),
         spanId,
@@ -47689,6 +48193,7 @@ function createBridgeMessageHandler(deps) {
       });
       thread.lastUsedAt = Date.now();
       const threadId = thread.threadId;
+      const currentReplayBuf = thread.replay;
       sendForSpan({
         type: "turn-started",
         directorSessionId,
@@ -47730,6 +48235,15 @@ function createBridgeMessageHandler(deps) {
       };
       try {
         await deps.runExclusive(async () => {
+          if (currentReplayBuf.state === "interrupted" || currentReplayBuf.state === "completed") {
+            logCtx?.logger.logOut({
+              spanId,
+              sessionId: directorSessionId,
+              type: "<queued-turn-cancelled-drained>",
+              payload: { sessionId: directorSessionId, turnId: currentReplayBuf.turnId }
+            });
+            return;
+          }
           let resolveTurn = null;
           let rejectTurn = null;
           const turnFinished = new Promise((resolve, reject) => {
@@ -47836,6 +48350,7 @@ ${effectiveText}` : effectiveText;
             if (imageDataUri) {
               turnInput.push({ type: "image", url: imageDataUri });
             }
+            sendInTurn({ type: "turn-executing", directorSessionId, turnId: currentReplayBuf.turnId });
             await codexClient.turn.start({
               threadId: thread.threadId,
               input: turnInput,
@@ -47891,7 +48406,9 @@ ${effectiveText}` : effectiveText;
           }
         }
       } finally {
-        thread.inFlight = false;
+        if (thread.replay === currentReplayBuf) {
+          thread.inFlight = false;
+        }
         thread.lastUsedAt = Date.now();
         deps.persistThreads();
         deps.releaseCodex();
@@ -47931,7 +48448,7 @@ function parseConfig() {
 }
 function scanForOtherBridges() {
   try {
-    const result = (0, import_node_child_process7.spawnSync)("pgrep", ["-f", "mrrlin-mcp director-bridge"], {
+    const result = (0, import_node_child_process9.spawnSync)("pgrep", ["-f", "mrrlin-mcp director-bridge"], {
       encoding: "utf8"
     });
     if (result.status !== 0) return [];
@@ -47984,6 +48501,7 @@ async function startDirectorBridge() {
       );
     }
   });
+  const codexProbeHandle = startCodexProbe();
   const consumerState = { inFlightRunId: null, lastClaimAt: null };
   const health = createServiceHealth();
   const apiBaseUrl = readConfiguredApiBaseUrl();
@@ -48341,6 +48859,10 @@ async function startDirectorBridge() {
       version: PKG_VERSION,
       binSha: bridgeBinShaShort,
       getLatestVersion: () => selfUpdateHandle.getLatestVersion()
+    },
+    codex: {
+      getState: () => codexProbeHandle.getState(),
+      getUpdateCommand: () => codexProbeHandle.getUpdateCommand()
     }
   });
   if (agentSecret && relayUrl) {
@@ -48512,6 +49034,16 @@ async function startDirectorBridge() {
       "[mrrlin-mcp director-bridge] scheduler tick loop disabled (MRRLIN_BRIDGE_SCHEDULER_TICK_DISABLE=1).\n"
     );
   }
+  let agentPoolLoopHandle = null;
+  if (tokenProvider && !agentPoolLoopDisabled(process.env)) {
+    agentPoolLoopHandle = startAgentPoolLoop({
+      push: (snapshot) => client.putOperatorAgentPool(snapshot),
+      onError: (err) => process.stderr.write(
+        `[mrrlin-mcp director-bridge] agent-pool snapshot push failed: ${err instanceof Error ? err.message : String(err)}
+`
+      )
+    });
+  }
   await new Promise((resolve, reject) => {
     server.on("error", (err) => {
       if (err.code === "EADDRINUSE") {
@@ -48553,8 +49085,10 @@ async function startDirectorBridge() {
         if (claimTimer) clearTimeout(claimTimer);
       },
       () => schedulerTickHandle?.stop(),
+      () => agentPoolLoopHandle?.stop(),
       () => codexKeepalive.dropNow(),
-      () => selfUpdateHandle.stop()
+      () => selfUpdateHandle.stop(),
+      () => codexProbeHandle.stop()
     ],
     shutdownCodex: () => codexServerManager.shutdown(),
     exit: (code) => process.exit(code),
@@ -52081,7 +52615,7 @@ var import_promises3 = require("node:fs/promises");
 var import_node_fs12 = require("node:fs");
 var import_node_path15 = __toESM(require("node:path"), 1);
 var import_node_os8 = __toESM(require("node:os"), 1);
-var import_node_child_process8 = require("node:child_process");
+var import_node_child_process11 = require("node:child_process");
 
 // ../../packages/wiki/dist/index.js
 var import_promises2 = __toESM(require("node:fs/promises"), 1);
@@ -52518,6 +53052,278 @@ async function runCodeGate(_target, deps) {
   }
 }
 
+// src/consensus/multi-llm-head.ts
+var import_node_child_process10 = require("node:child_process");
+function errMessage3(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function runExternalAgents(bin, args, timeoutMs, spawn3) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const timerRef = { id: void 0 };
+    const finish = (r) => {
+      if (settled) return;
+      settled = true;
+      if (timerRef.id) clearTimeout(timerRef.id);
+      resolve(r);
+    };
+    const options = {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env,
+      shell: false
+      // SECURITY: prompt is an argv element; never hand it to a shell.
+    };
+    let child;
+    try {
+      child = spawn3(bin, args, options);
+    } catch (err) {
+      finish({ code: null, stdout: "", error: `spawn ${bin} failed: ${errMessage3(err)}` });
+      return;
+    }
+    let stdout = "";
+    timerRef.id = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish({ code: null, stdout, error: `external-agents ${args[0]} timed out after ${timeoutMs}ms` });
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", () => {
+    });
+    child.on("error", (err) => finish({ code: null, stdout, error: `external-agents ${args[0]} error: ${errMessage3(err)}` }));
+    child.on("close", (code) => finish({ code, stdout }));
+  });
+}
+async function pickPanel(input, deps) {
+  const spawn3 = deps?.spawn ?? import_node_child_process10.spawn;
+  const bin = deps?.externalAgentsBin ?? "external-agents";
+  const args = [
+    "pick",
+    "--tier-prefer",
+    input.tierPrefer ?? "strong",
+    "--n",
+    String(input.n),
+    "--min-distinct-providers",
+    String(input.n),
+    "--exclude-providers",
+    input.excludeProvider
+  ];
+  const r = await runExternalAgents(bin, args, input.timeoutMs, spawn3);
+  if (r.error) return { ok: false, error: r.error };
+  if (r.code === 3) return { ok: true, agents: [] };
+  if (r.code !== 0) return { ok: false, error: `external-agents pick exited ${r.code}` };
+  const agents = r.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  return { ok: true, agents };
+}
+async function dispatchHead(agentId, prompt, timeoutMs, deps) {
+  const spawn3 = deps?.spawn ?? import_node_child_process10.spawn;
+  const bin = deps?.externalAgentsBin ?? "external-agents";
+  const args = ["dispatch", agentId, "--json", prompt];
+  const r = await runExternalAgents(bin, args, timeoutMs, spawn3);
+  if (r.error) return { ok: false, error: r.error };
+  const lines2 = r.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  const jsonLine = [...lines2].reverse().find((l) => l[0] === "{");
+  if (!jsonLine) return { ok: false, error: `dispatch ${agentId}: no JSON on stdout (exit ${r.code})` };
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonLine);
+  } catch (err) {
+    return { ok: false, error: `dispatch ${agentId}: unparseable JSON (${errMessage3(err)})` };
+  }
+  if (parsed.outcome !== "success") {
+    return { ok: false, error: `dispatch ${agentId}: outcome=${parsed.outcome} (exit ${parsed.exit_code})` };
+  }
+  if (typeof parsed.text !== "string" || parsed.text.trim() === "") {
+    return { ok: false, error: `dispatch ${agentId}: empty text on success` };
+  }
+  return { ok: true, text: parsed.text };
+}
+async function buildMultiHeadRunner(input, deps) {
+  const picked = await pickPanel(
+    { n: input.personas.length, excludeProvider: input.excludeProvider, tierPrefer: input.tierPrefer, timeoutMs: input.pickTimeoutMs },
+    deps
+  );
+  if (!picked.ok) return { ok: false, error: picked.error };
+  if (picked.agents.length === 0) return { ok: false, error: "pick returned no agents" };
+  const agents = picked.agents;
+  const assignment = {};
+  input.personas.forEach((persona, i) => {
+    const agent = agents[i % agents.length];
+    if (agent) assignment[persona] = agent;
+  });
+  const runHead = async (persona, artifact, dismissed) => {
+    const agentId = assignment[persona];
+    if (!agentId) return { ok: false, error: `no agent assigned for persona ${persona}` };
+    const instructions = input.personaInstructions[persona] ?? "";
+    const dismissedBlock = dismissed.trim() ? `
+
+${dismissed.trim()}` : "";
+    const prompt = instructions.trim() ? `${instructions.trim()}
+
+${artifact}${dismissedBlock}` : `${artifact}${dismissedBlock}`;
+    return dispatchHead(agentId, prompt, input.dispatchTimeoutMs, deps);
+  };
+  return { ok: true, runner: { agents, assignment, runHead } };
+}
+
+// src/consensus/multi-llm-shadow.ts
+var SHADOW_LOG_PREFIX = "__MULTI_LLM_SHADOW__";
+function rollUpVerdict(verdicts) {
+  if (verdicts.includes("REJECT")) return "REJECT";
+  if (verdicts.includes("REQUEST_CHANGES")) return "REQUEST_CHANGES";
+  return "APPROVE";
+}
+async function runShadowPanel(input, deps) {
+  const base = { ran: false, correlationId: input.correlationId, productionVerdict: input.productionVerdict };
+  const built = await buildMultiHeadRunner(
+    {
+      personas: input.heads,
+      personaInstructions: input.personaInstructions,
+      excludeProvider: input.excludeProvider,
+      tierPrefer: "strong",
+      pickTimeoutMs: input.pickTimeoutMs,
+      dispatchTimeoutMs: input.dispatchTimeoutMs
+    },
+    deps
+  );
+  if (!built.ok) return { ...base, reason: built.error };
+  const verdicts = [];
+  const perHead = await Promise.all(
+    input.heads.map(async (persona) => {
+      const agent = built.runner.assignment[persona] ?? "(unassigned)";
+      try {
+        const res = await built.runner.runHead(persona, input.artifact, "");
+        if (res.ok) {
+          const parsed = parseVerdict(res.text);
+          return { persona, agent, verdict: parsed.verdict, ok: true };
+        }
+      } catch {
+      }
+      return { persona, agent, verdict: "ERROR", ok: false };
+    })
+  );
+  for (const h of perHead) {
+    if (h.ok && h.verdict !== "ERROR") verdicts.push(h.verdict);
+  }
+  if (verdicts.length === 0) {
+    return { ...base, agents: built.runner.agents, perHead, reason: "no head produced a parseable verdict" };
+  }
+  const shadowVerdict = rollUpVerdict(verdicts);
+  return {
+    ran: true,
+    correlationId: input.correlationId,
+    agents: built.runner.agents,
+    perHead,
+    shadowVerdict,
+    productionVerdict: input.productionVerdict,
+    agrees: shadowVerdict === input.productionVerdict
+  };
+}
+async function runShadowPanelSafe(input, deps, logger = (line) => console.error(line)) {
+  let record2;
+  try {
+    record2 = await runShadowPanel(input, deps);
+  } catch (err) {
+    record2 = {
+      ran: false,
+      correlationId: input.correlationId,
+      productionVerdict: input.productionVerdict,
+      reason: `shadow panel threw: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  try {
+    logger(`${SHADOW_LOG_PREFIX} ${JSON.stringify(record2)}`);
+  } catch {
+  }
+  return record2;
+}
+
+// src/consensus/multi-llm-shadow-hook.ts
+var SHADOW_ENV_FLAG = "MRRLIN_CONSENSUS_MULTI_LLM_SHADOW";
+var ORCHESTRATOR_PROVIDER = "openai";
+var PICK_TIMEOUT_MS = 15e3;
+var DISPATCH_TIMEOUT_MS = 6e4;
+function productionVerdictFromOutcome(outcome) {
+  if (outcome === "CONVERGED") return "APPROVE";
+  if (outcome === "CONSENSUS_BLOCKED") return "REQUEST_CHANGES";
+  return null;
+}
+async function maybeRunShadow(input, deps, logger) {
+  const env = input.env ?? process.env;
+  if (!env[SHADOW_ENV_FLAG]) return false;
+  const productionVerdict = productionVerdictFromOutcome(input.outcome);
+  if (productionVerdict === null) return false;
+  try {
+    const heads = input.heads ?? [...resolveHeads(input.domain), ...input.extraHeads ?? []];
+    const personaInstructions = {};
+    for (const name of heads) {
+      try {
+        personaInstructions[name] = loadPersona(name);
+      } catch {
+        personaInstructions[name] = "";
+      }
+    }
+    await runShadowPanelSafe(
+      {
+        heads,
+        personaInstructions,
+        artifact: input.artifact,
+        productionVerdict,
+        excludeProvider: ORCHESTRATOR_PROVIDER,
+        pickTimeoutMs: PICK_TIMEOUT_MS,
+        dispatchTimeoutMs: DISPATCH_TIMEOUT_MS,
+        correlationId: input.correlationId
+      },
+      deps,
+      logger
+    );
+  } catch {
+  }
+  return true;
+}
+
+// src/consensus/multi-llm-activate.ts
+var MULTI_LLM_ENV_FLAG = "MRRLIN_CONSENSUS_MULTI_LLM";
+var ORCHESTRATOR_PROVIDER2 = "openai";
+var PICK_TIMEOUT_MS2 = 15e3;
+var DISPATCH_TIMEOUT_MS2 = 6e4;
+function multiLlmActive(env = process.env) {
+  if (env["NODE_ENV"] === "production") return false;
+  const flag = env[MULTI_LLM_ENV_FLAG];
+  if (flag === "0" || flag === "false" || flag === "off") return false;
+  return Boolean(flag) || env["MRRLIN_STAGING"] === "1";
+}
+async function resolveActiveRunHead(input, deps) {
+  if (!multiLlmActive(input.env ?? process.env)) return null;
+  try {
+    const heads = input.heads ?? [...resolveHeads(input.domain), ...input.extraHeads ?? []];
+    if (heads.length === 0) return null;
+    const personaInstructions = {};
+    for (const name of heads) {
+      try {
+        personaInstructions[name] = loadPersona(name);
+      } catch {
+        personaInstructions[name] = "";
+      }
+    }
+    const built = await buildMultiHeadRunner(
+      {
+        personas: heads,
+        personaInstructions,
+        excludeProvider: ORCHESTRATOR_PROVIDER2,
+        tierPrefer: "strong",
+        pickTimeoutMs: PICK_TIMEOUT_MS2,
+        dispatchTimeoutMs: DISPATCH_TIMEOUT_MS2
+      },
+      deps
+    );
+    if (!built.ok) return null;
+    return built.runner.runHead;
+  } catch {
+    return null;
+  }
+}
+
 // src/async-tools/consensus.ts
 var import_node_crypto8 = require("node:crypto");
 function buildGateQuestionOptions(category) {
@@ -52581,13 +53387,37 @@ async function run(ctx, input) {
     codexExecutable: ctx.codexExecutable,
     extraHeadCount: input.extraHeads?.length ?? 0
   });
+  const activeRunHead = await resolveActiveRunHead({
+    heads: [...allReviewHeads(), ...input.extraHeads ?? []]
+  });
+  if (activeRunHead) deps.runHead = activeRunHead;
   const result = await runSpecGate(
     { projectSlug: input.projectSlug, specPageId: input.pageId },
     deps,
     input.extraHeads && input.extraHeads.length > 0 ? { extraHeads: input.extraHeads } : void 0
   );
+  if (process.env[SHADOW_ENV_FLAG]) {
+    try {
+      const specPage = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
+      if (specPage) {
+        const shadowDomain = await resolveSpecDomain(ctx.client, input.projectSlug, {
+          id: specPage.id,
+          taskId: specPage.taskId ?? null
+        });
+        await maybeRunShadow({
+          outcome: result.outcome,
+          artifact: specPage.markdownBody,
+          domain: shadowDomain,
+          extraHeads: input.extraHeads,
+          correlationId: `Specs/${input.pageId}`
+        });
+      }
+    } catch {
+    }
+  }
   if (result.outcome === "CONSENSUS_BLOCKED") {
     const clarifications = result.clarifications ?? [];
+    let filedQuestionCount = 0;
     if (clarifications.length > 0) {
       const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
       const taskId = page?.taskId ?? null;
@@ -52612,6 +53442,7 @@ async function run(ctx, input) {
           } catch {
           }
         }
+        filedQuestionCount = clarifications.length;
       } else if (planId) {
         for (const clarification of clarifications) {
           const scopeId = planId;
@@ -52628,13 +53459,18 @@ async function run(ctx, input) {
           } catch {
           }
         }
+        filedQuestionCount = clarifications.length;
       }
     }
-    return {
-      kind: "failed",
-      failureReason: "consensus_blocked",
-      error: clarifications.length > 0 ? `Consensus blocked on ${clarifications.length} clarification(s); filed as operator question(s).` : "Consensus blocked: reviewers did not converge within budget."
-    };
+    let error51;
+    if (filedQuestionCount > 0) {
+      error51 = `Consensus blocked on ${filedQuestionCount} clarification(s); filed as operator question(s).`;
+    } else if (clarifications.length > 0) {
+      error51 = `Consensus blocked on ${clarifications.length} clarification(s), but the spec page is not linked to a task or plan, so none could be filed as questions.`;
+    } else {
+      error51 = "Consensus blocked: reviewers did not converge within budget.";
+    }
+    return { kind: "failed", failureReason: "consensus_blocked", error: error51, filedQuestionCount };
   }
   switch (result.outcome) {
     case "CONVERGED":
@@ -52670,6 +53506,14 @@ function onComplete2(outcome, input) {
       body: `Consensus CONVERGED for Specs/${input.pageId}; spec_ready set. Ready to create an execution run.`
     };
   }
+  if (outcome.kind === "failed" && (outcome.filedQuestionCount ?? 0) > 0) {
+    const n = outcome.filedQuestionCount ?? 0;
+    return {
+      kind: "info",
+      suppressInbox: true,
+      body: `Consensus blocked on Specs/${input.pageId}; filed ${n} clarifying question${n === 1 ? "" : "s"} \u2014 answer to unblock the run.`
+    };
+  }
   return {
     kind: "handoff",
     body: `Consensus could not complete for Specs/${input.pageId}: ${outcome.error} Needs operator attention.`
@@ -54170,7 +55014,24 @@ function createMrrlinTools(options) {
           codexExecutable: process.env.MRRLIN_DIRECTOR_BRIDGE_CODEX_BIN?.trim() || void 0,
           extraHeads
         });
-        return await runCodeGate({ projectSlug, baseRef }, deps);
+        const activeCodeRunHead = await resolveActiveRunHead({
+          heads: ["code-reviewer", ...extraHeads ?? []]
+        });
+        if (activeCodeRunHead) deps.runHead = activeCodeRunHead;
+        const codeGateResult = await runCodeGate({ projectSlug, baseRef }, deps);
+        if (process.env[SHADOW_ENV_FLAG]) {
+          try {
+            const diff = await readDiff({ cwd: process.cwd(), baseRef, run: defaultRunCmd });
+            await maybeRunShadow({
+              outcome: codeGateResult.outcome,
+              artifact: diff,
+              heads: ["code-reviewer", ...extraHeads ?? []],
+              correlationId: `code:${baseRef}`
+            });
+          } catch {
+          }
+        }
+        return codeGateResult;
       }
     ),
     [mcpToolNames.listExecutionRuns]: makeTool(
@@ -54421,7 +55282,7 @@ function createMrrlinTools(options) {
         }
         let remoteUrl;
         try {
-          remoteUrl = (0, import_node_child_process8.execFileSync)("git", ["-C", resolvedPath, "remote", "get-url", "origin"], {
+          remoteUrl = (0, import_node_child_process11.execFileSync)("git", ["-C", resolvedPath, "remote", "get-url", "origin"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
             timeout: 15e3,
@@ -54773,7 +55634,7 @@ async function pathExists3(target) {
     return false;
   }
 }
-var MRRLIN_BLOCK_RE = /(^|\n)\[mcp_servers\.mrrlin(?:-browser)?(?:\]|\.[^\]\n]*\])[\s\S]*?(?=\n\[|$)/g;
+var MRRLIN_BLOCK_RE = /(^|\n)\[mcp_servers\.(?:mrrlin(?:-browser)?|external-agents)(?:\]|\.[^\]\n]*\])[\s\S]*?(?=\n\[|$)/g;
 async function uninstallCodex(options = {}) {
   const codexHome = resolveCodexHome2(options);
   const configPath = import_node_path18.default.join(codexHome, "config.toml");
@@ -54795,7 +55656,7 @@ async function uninstallCodex(options = {}) {
     };
     throw Object.assign(new Error(err.detail), err);
   }
-  if (parsed?.mcp_servers?.["mrrlin"] === void 0 && parsed?.mcp_servers?.["mrrlin-browser"] === void 0) {
+  if (parsed?.mcp_servers?.["mrrlin"] === void 0 && parsed?.mcp_servers?.["mrrlin-browser"] === void 0 && parsed?.mcp_servers?.["external-agents"] === void 0) {
     return { action: "noop", configPath: realPath, prompts: await removePrompts() };
   }
   const stripped = existing.replace(MRRLIN_BLOCK_RE, (match) => match.startsWith("\n") ? "\n" : "").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
@@ -54825,13 +55686,13 @@ async function uninstallPrompts(codexHome, names) {
 
 // src/bin.ts
 function pm2Runner(args) {
-  const r = (0, import_node_child_process9.spawnSync)("pm2", args, { encoding: "utf8" });
+  const r = (0, import_node_child_process12.spawnSync)("pm2", args, { encoding: "utf8" });
   process.stderr.write(r.stdout ?? "");
   process.stderr.write(r.stderr ?? "");
   return { code: r.status ?? 1, stdout: r.stdout ?? "" };
 }
 function whichBin(bin) {
-  const r = (0, import_node_child_process9.spawnSync)("which", [bin], { encoding: "utf8" });
+  const r = (0, import_node_child_process12.spawnSync)("which", [bin], { encoding: "utf8" });
   const out = (r.stdout ?? "").trim();
   return r.status === 0 && out ? out.split("\n")[0] ?? null : null;
 }
@@ -55007,7 +55868,7 @@ async function main() {
     }
     case "browser-serve": {
       const { command: command2, args, env } = browserServeArgs();
-      const r = (0, import_node_child_process9.spawnSync)(command2, args, { stdio: "inherit", env: { ...process.env, ...env } });
+      const r = (0, import_node_child_process12.spawnSync)(command2, args, { stdio: "inherit", env: { ...process.env, ...env } });
       process.exitCode = r.status ?? 1;
       return;
     }