opencode-swarm 7.77.0 → 7.77.2

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.77.0",
+    version: "7.77.2",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -682,6 +682,10 @@ var init_tool_metadata = __esm(() => {
         "test_engineer"
       ]
     },
+    dispatch_lanes: {
+      description: "dispatch multiple read-only exploration/review lanes concurrently and return a structured join result",
+      agents: ["architect"]
+    },
     summarize_work: {
       description: "emit a short structured summary of completed work (key decisions, assumptions, risks, constraints) at task completion; rolls up per phase for architecture-supervisor review. Advisory, never blocks.",
       agents: [
@@ -85407,10 +85411,37 @@ function stringHash(str) {
   h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16);
 }
+function buildErrnoPatternPair(errno, contextPattern) {
+  return [
+    new RegExp(`(?:^|\\n)\\s*${errno}\\b`, "i"),
+    new RegExp(`\\b(?:${contextPattern})\\b[^\\n]{0,${MAX_INFRA_CONTEXT_CHARS}}\\b${errno}\\b`, "i")
+  ];
+}
+function isInfrastructureFailure(currentResult) {
+  const errorMessage = currentResult.errorMessage || "";
+  const stackPrefix = currentResult.stackPrefix || "";
+  if (/\bassertionerror\b/i.test(errorMessage)) {
+    return false;
+  }
+  const combinedText = `${errorMessage}
+${stackPrefix}`;
+  return INFRASTRUCTURE_FAILURE_PATTERNS.some((pattern) => pattern.test(combinedText));
+}
 function classifyFailure(currentResult, history) {
   const normalizedFile = currentResult.testFile.toLowerCase();
   const normalizedName = currentResult.testName.toLowerCase();
   const testHistory = history.filter((r) => r.testFile.toLowerCase() === normalizedFile && r.testName.toLowerCase() === normalizedName).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+  if (isInfrastructureFailure(currentResult)) {
+    return {
+      testFile: currentResult.testFile,
+      testName: currentResult.testName,
+      classification: "infrastructure_failure",
+      errorMessage: currentResult.errorMessage,
+      stackPrefix: currentResult.stackPrefix,
+      durationMs: currentResult.durationMs,
+      confidence: computeConfidence2(testHistory.length)
+    };
+  }
   const lastThree = testHistory.slice(0, 3);
   const lastTen = testHistory.slice(0, 10);
   const normalizedTestFile = currentResult.testFile.toLowerCase();
@@ -85510,6 +85541,26 @@ function classifyAndCluster(testResults, history) {
   const clusters = clusterFailures(classified);
   return { classified, clusters };
 }
+var MAX_INFRA_CONTEXT_CHARS = 80, INFRASTRUCTURE_FAILURE_PATTERNS;
+var init_failure_classifier = __esm(() => {
+  INFRASTRUCTURE_FAILURE_PATTERNS = [
+    /\boutofmemoryerror\b/i,
+    /\ballocation failed - javascript heap out of memory\b/i,
+    /\bcannot allocate memory\b/i,
+    /\bout of memory:\s*killed process\b/i,
+    /\boom-kill\b/i,
+    /(?:^|\n|\bcommand failed:\s*)\s*killed(?:\s*(?:[-:]\s*)?(?:by signal|signal|sigkill).*)?\s*(?:\n|$)/i,
+    ...buildErrnoPatternPair("ETIMEDOUT", "connect|connection|request|socket|network"),
+    ...buildErrnoPatternPair("ECONNREFUSED", "connect|connection|socket"),
+    ...buildErrnoPatternPair("ENOTFOUND", "getaddrinfo|dns|lookup"),
+    ...buildErrnoPatternPair("ECONNRESET", "connect|connection|request|socket|network|stream|read"),
+    ...buildErrnoPatternPair("EPIPE", "pipe|stream|write|socket|stdout|stderr"),
+    /\bbroken pipe\b/i,
+    /\bexit(?:ed)?(?:\s+with)?(?:\s+code)?\s*[:=]?\s*137\b/i,
+    /\bsig(?:segv|abrt|bus)\b/i,
+    /\bsegmentation fault(?:\s*\(core dumped\))?\b/i
+  ];
+});
 
 // src/test-impact/flaky-detector.ts
 function computeCombinedFlakyScore(recent) {
@@ -87720,6 +87771,7 @@ var init_test_runner = __esm(() => {
   init_zod();
   init_discovery();
   init_analyzer();
+  init_failure_classifier();
   init_history_store();
   init_bun_compat();
   init_path_security();
@@ -92631,7 +92683,7 @@ Subcommands:
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handlePrReviewCommand),
       description: "Launch deep PR review with multi-lane analysis [url] [--council]",
       args: "<pr-url|owner/repo#N|N> [--council]",
-      details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, runs 6 parallel explorer lanes (correctness, security, dependencies, docs-intent-vs-actual, tests, performance-architecture), validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, synthesizes structured report. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).",
+      details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, runs 6 parallel explorer lanes through the deterministic dispatch_lanes join barrier (correctness, security, dependencies, docs-intent-vs-actual, tests, performance-architecture), validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, synthesizes structured report. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).",
       category: "agent"
     },
     "pr-feedback": {
@@ -103386,7 +103438,7 @@ var init_curator_drift = __esm(() => {
 var exports_design_doc_drift = {};
 __export(exports_design_doc_drift, {
   runDesignDocDriftCheck: () => runDesignDocDriftCheck,
-  _internals: () => _internals93
+  _internals: () => _internals94
 });
 import * as fs109 from "node:fs";
 import * as path164 from "node:path";
@@ -103519,7 +103571,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     return null;
   }
 }
-var DOC_DRIFT_REPORT_PREFIX = "doc-drift-phase-", MAX_TRACEABILITY_BYTES, DESIGN_DOC_FILES, TRACEABILITY_REL, _internals93;
+var DOC_DRIFT_REPORT_PREFIX = "doc-drift-phase-", MAX_TRACEABILITY_BYTES, DESIGN_DOC_FILES, TRACEABILITY_REL, _internals94;
 var init_design_doc_drift = __esm(() => {
   init_event_bus();
   init_effective_spec();
@@ -103534,7 +103586,7 @@ var init_design_doc_drift = __esm(() => {
     "idiom-notes": path164.join("reference", "idiom-notes.md")
   };
   TRACEABILITY_REL = path164.join("reference", "traceability.json");
-  _internals93 = {
+  _internals94 = {
     mtimeMsOrNull,
     resolveAnchorWithin,
     DESIGN_DOC_FILES
@@ -103545,7 +103597,7 @@ var init_design_doc_drift = __esm(() => {
 var exports_project_context = {};
 __export(exports_project_context, {
   buildProjectContext: () => buildProjectContext,
-  _internals: () => _internals106,
+  _internals: () => _internals107,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs133 from "node:fs";
@@ -103629,7 +103681,7 @@ function selectLintCommand(backend, directory) {
   return null;
 }
 async function buildProjectContext(directory) {
-  const backend = await _internals106.pickBackend(directory);
+  const backend = await _internals107.pickBackend(directory);
   if (!backend)
     return null;
   const ctx = emptyProjectContext();
@@ -103668,17 +103720,17 @@ async function buildProjectContext(directory) {
   if (backend.prompts.reviewerChecklist.length > 0) {
     ctx.REVIEWER_CHECKLIST = bulletList(backend.prompts.reviewerChecklist);
   }
-  const profiles = _internals106.pickedProfiles(directory);
+  const profiles = _internals107.pickedProfiles(directory);
   if (profiles.length > 1) {
     ctx.PROJECT_CONTEXT_SECONDARY_LANGUAGES = profiles.slice(1).map((p) => p.id).join(", ");
   }
   return ctx;
 }
-var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals106;
+var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals107;
 var init_project_context = __esm(() => {
   init_dispatch();
   init_framework_detector();
-  _internals106 = {
+  _internals107 = {
     pickBackend,
     pickedProfiles
   };
@@ -124398,6 +124450,594 @@ var diff_summary = createSwarmTool({
   }
 });
 
+// node_modules/yocto-queue/index.js
+class Node2 {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class Queue {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node2(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    if (!this.#head) {
+      this.#tail = undefined;
+    }
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = undefined;
+    this.#tail = undefined;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (this.#head) {
+      yield this.dequeue();
+    }
+  }
+}
+
+// node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  let rejectOnClear = false;
+  if (typeof concurrency === "object") {
+    ({ concurrency, rejectOnClear = false } = concurrency);
+  }
+  validateConcurrency(concurrency);
+  if (typeof rejectOnClear !== "boolean") {
+    throw new TypeError("Expected `rejectOnClear` to be a boolean");
+  }
+  const queue = new Queue;
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      activeCount++;
+      queue.dequeue().run();
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run2 = async (function_, resolve55, arguments_2) => {
+    const result = (async () => function_(...arguments_2))();
+    resolve55(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+  const enqueue = (function_, resolve55, reject, arguments_2) => {
+    const queueItem = { reject };
+    new Promise((internalResolve) => {
+      queueItem.run = internalResolve;
+      queue.enqueue(queueItem);
+    }).then(run2.bind(undefined, function_, resolve55, arguments_2));
+    if (activeCount < concurrency) {
+      resumeNext();
+    }
+  };
+  const generator = (function_, ...arguments_2) => new Promise((resolve55, reject) => {
+    enqueue(function_, resolve55, reject, arguments_2);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        if (!rejectOnClear) {
+          queue.clear();
+          return;
+        }
+        const abortError = AbortSignal.abort().reason;
+        while (queue.size > 0) {
+          queue.dequeue().reject(abortError);
+        }
+      }
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) {
+            resumeNext();
+          }
+        });
+      }
+    },
+    map: {
+      async value(iterable, function_) {
+        const promises10 = Array.from(iterable, (value, index) => this(function_, value, index));
+        return Promise.all(promises10);
+      }
+    }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+}
+
+// src/tools/dispatch-lanes.ts
+init_zod();
+init_constants();
+init_schema();
+
+// src/parallel/dispatcher/parallel-dispatcher.ts
+function createParallelDispatcher(config3) {
+  const limit = pLimit(config3.maxConcurrentTasks);
+  const activeSlots = new Map;
+  let slotCounter = 0;
+  let shutdownCalled = false;
+  return {
+    config: config3,
+    dispatch(taskId) {
+      if (!config3.enabled) {
+        return { action: "reject", reason: "dispatcher_disabled" };
+      }
+      if (shutdownCalled) {
+        return { action: "reject", reason: "dispatcher_shutdown" };
+      }
+      if (activeSlots.size >= config3.maxConcurrentTasks) {
+        return { action: "defer", reason: "max_concurrent_tasks_reached" };
+      }
+      const slotId = `slot-${++slotCounter}`;
+      const runId = `run-${taskId}-${slotId}`;
+      const slot = {
+        slotId,
+        taskId,
+        runId,
+        startedAt: Date.now()
+      };
+      activeSlots.set(slotId, slot);
+      limit(async () => {});
+      return { action: "dispatch", reason: "slot_available", slot };
+    },
+    handles() {
+      return [...activeSlots.values()].map((slot) => ({
+        slotId: slot.slotId,
+        taskId: slot.taskId,
+        runId: slot.runId,
+        cancel: () => {
+          activeSlots.delete(slot.slotId);
+        }
+      }));
+    },
+    releaseSlot(slotId) {
+      activeSlots.delete(slotId);
+    },
+    shutdown() {
+      shutdownCalled = true;
+      activeSlots.clear();
+      limit.clearQueue();
+    }
+  };
+}
+
+// src/tools/dispatch-lanes.ts
+init_state();
+init_create_tool();
+var MAX_LANES = 8;
+var MAX_PROMPT_CHARS = 80000;
+var DEFAULT_TIMEOUT_MS3 = 300000;
+var MAX_TIMEOUT_MS2 = 1800000;
+var MAX_LANE_OUTPUT_CHARS = 20000;
+var MAX_ERROR_CHARS = 200;
+var ERROR_TRUNCATION_SUFFIX = "...";
+var AGENT_NAME_SEPARATORS = ["_", "-", " "];
+var READ_ONLY_LANE_ROLES = new Set([
+  "explorer",
+  "reviewer",
+  "critic",
+  "critic_oversight",
+  "critic_sounding_board",
+  "critic_drift_verifier",
+  "critic_hallucination_verifier",
+  "critic_architecture_supervisor",
+  "sme",
+  "researcher",
+  "council_generalist",
+  "council_skeptic",
+  "council_domain_expert"
+]);
+var READ_ONLY_TOOL_DENYLIST = [
+  ...new Set([
+    ...WRITE_TOOL_NAMES,
+    "extract_code_blocks",
+    "multiedit",
+    "multi_edit",
+    "todo_write",
+    "save_plan",
+    "update_task_status",
+    "phase_complete",
+    "declare_scope",
+    "declare_council_criteria",
+    "submit_council_verdicts",
+    "submit_phase_council_verdicts",
+    "set_qa_gates",
+    "write_retro",
+    "write_drift_evidence",
+    "write_hallucination_evidence",
+    "write_mutation_evidence",
+    "knowledge_add",
+    "knowledge_remove",
+    "summarize_work",
+    "doc_scan"
+  ])
+];
+var LaneSchema = exports_external.object({
+  id: exports_external.string().min(1).max(80).regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*$/).describe("Stable lane identifier, unique within this dispatch batch"),
+  agent: exports_external.string().min(1).max(120).describe("Read-only swarm agent name, including any generated swarm prefix"),
+  prompt: exports_external.string().min(1).max(MAX_PROMPT_CHARS).describe("Full lane prompt to send to the requested agent")
+});
+var DispatchLanesArgsSchema = exports_external.object({
+  lanes: exports_external.array(LaneSchema).min(1).max(MAX_LANES).describe("Read-only lane specs to dispatch concurrently"),
+  max_concurrent: exports_external.number().int().min(1).max(MAX_LANES).optional().describe("Maximum lanes in flight at once; defaults to lane count"),
+  timeout_ms: exports_external.number().int().min(10).max(MAX_TIMEOUT_MS2).optional().describe("Per-lane session create/prompt timeout in milliseconds")
+});
+var _internals79 = {
+  getSessionOps: () => swarmState.opencodeClient?.session ?? null,
+  getGeneratedAgentNames: () => swarmState.generatedAgentNames,
+  createParallelDispatcher,
+  now: () => Date.now()
+};
+async function executeDispatchLanes(args2, directory, context = {}) {
+  const parsed = DispatchLanesArgsSchema.safeParse(args2);
+  if (!parsed.success) {
+    return failureResult({
+      failure_class: "invalid_args",
+      message: "Invalid dispatch_lanes arguments",
+      errors: parsed.error.issues.map((issue3) => `${issue3.path.join(".")}: ${issue3.message}`)
+    });
+  }
+  const duplicateLaneIds = findDuplicateLaneIds(parsed.data.lanes);
+  if (duplicateLaneIds.length > 0) {
+    return failureResult({
+      failure_class: "invalid_args",
+      message: "Lane IDs must be unique within one dispatch_lanes batch",
+      errors: duplicateLaneIds.map((id) => `Duplicate lane id: ${id}`)
+    });
+  }
+  const session = _internals79.getSessionOps();
+  if (!session) {
+    return failureResult({
+      failure_class: "no_client",
+      message: "OpenCode session client is not available"
+    });
+  }
+  const lanes = parsed.data.lanes;
+  const maxConcurrent = Math.min(parsed.data.max_concurrent ?? lanes.length, lanes.length, MAX_LANES);
+  const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_TIMEOUT_MS3;
+  const dispatcher = _internals79.createParallelDispatcher({
+    enabled: true,
+    maxConcurrentTasks: maxConcurrent,
+    evidenceLockTimeoutMs: 0
+  });
+  const limit = pLimit(maxConcurrent);
+  try {
+    const laneResults = await Promise.all(lanes.map((lane) => limit(() => runLane(session, dispatcher, lane, directory, timeoutMs, context))));
+    return buildResult(laneResults, maxConcurrent, timeoutMs);
+  } finally {
+    dispatcher.shutdown();
+  }
+}
+async function runLane(session, dispatcher, lane, directory, timeoutMs, context) {
+  const validation2 = validateLaneAgent(lane.agent, context);
+  const role = validation2.role;
+  const startedAt = isoNow();
+  if (!validation2.ok) {
+    return {
+      id: lane.id,
+      agent: lane.agent,
+      role,
+      status: "rejected",
+      started_at: startedAt,
+      completed_at: isoNow(),
+      error: validation2.error
+    };
+  }
+  const decision = dispatcher.dispatch(lane.id);
+  if (decision.action !== "dispatch") {
+    return {
+      id: lane.id,
+      agent: lane.agent,
+      role,
+      status: "failed",
+      started_at: startedAt,
+      completed_at: isoNow(),
+      error: `dispatcher ${decision.action}: ${decision.reason}`
+    };
+  }
+  let sessionId;
+  try {
+    const createTimeoutMessage = `Lane "${lane.id}" session.create timed out after ${timeoutMs}ms`;
+    const createPromise = session.create({ query: { directory } });
+    let createTimedOut = false;
+    createPromise.then((createResult2) => {
+      if (createTimedOut && createResult2.data?.id) {
+        scheduleSessionCleanup(session, createResult2.data.id);
+      }
+    }).catch(() => {
+      return;
+    });
+    const createResult = await withTimeout2(createPromise, timeoutMs, createTimeoutMessage).catch((error93) => {
+      if (formatError3(error93) === createTimeoutMessage) {
+        createTimedOut = true;
+      }
+      throw error93;
+    });
+    if (!createResult.data?.id) {
+      return failedLane(lane, role, startedAt, `session.create failed: ${formatError3(createResult.error)}`, decision.slot.slotId, decision.slot.runId);
+    }
+    sessionId = createResult.data.id;
+    const promptResult = await withTimeout2(session.prompt({
+      path: { id: sessionId },
+      body: {
+        agent: lane.agent,
+        tools: buildReadOnlyTools(),
+        parts: [{ type: "text", text: lane.prompt }]
+      }
+    }), timeoutMs, `Lane "${lane.id}" session.prompt timed out after ${timeoutMs}ms`);
+    if (!promptResult.data) {
+      return failedLane(lane, role, startedAt, `session.prompt failed: ${formatError3(promptResult.error)}`, decision.slot.slotId, decision.slot.runId, sessionId);
+    }
+    const boundedOutput = boundLaneOutput(extractText3(promptResult.data.parts));
+    return {
+      id: lane.id,
+      agent: lane.agent,
+      role,
+      status: "completed",
+      session_id: sessionId,
+      slot_id: decision.slot.slotId,
+      run_id: decision.slot.runId,
+      started_at: startedAt,
+      completed_at: isoNow(),
+      ...boundedOutput
+    };
+  } catch (error93) {
+    return failedLane(lane, role, startedAt, formatError3(error93), decision.slot.slotId, decision.slot.runId, sessionId);
+  } finally {
+    dispatcher.releaseSlot(decision.slot.slotId);
+    if (sessionId) {
+      scheduleSessionCleanup(session, sessionId);
+    }
+  }
+}
+function buildResult(laneResults, maxConcurrent, timeoutMs) {
+  const completed = laneResults.filter((lane) => lane.status === "completed");
+  const failed = laneResults.filter((lane) => lane.status === "failed");
+  const rejected = laneResults.filter((lane) => lane.status === "rejected");
+  return {
+    success: failed.length === 0 && rejected.length === 0,
+    dispatched: laneResults.length,
+    completed: completed.length,
+    failed: failed.length,
+    rejected: rejected.length,
+    max_concurrent: maxConcurrent,
+    timeout_ms: timeoutMs,
+    lane_results: laneResults
+  };
+}
+function failedLane(lane, role, startedAt, error93, slotId, runId, sessionId) {
+  return {
+    id: lane.id,
+    agent: lane.agent,
+    role,
+    status: "failed",
+    session_id: sessionId,
+    slot_id: slotId,
+    run_id: runId,
+    started_at: startedAt,
+    completed_at: isoNow(),
+    error: error93
+  };
+}
+function validateLaneAgent(agent, context) {
+  const generatedAgentNames = _internals79.getGeneratedAgentNames();
+  const role = resolveGeneratedAgentRole(agent, generatedAgentNames);
+  if (!isKnownCanonicalRole(role)) {
+    return {
+      ok: false,
+      role,
+      error: `Agent "${agent}" is not registered as a generated swarm agent or canonical role`
+    };
+  }
+  if (!READ_ONLY_LANE_ROLES.has(role)) {
+    return {
+      ok: false,
+      role,
+      error: `Agent role "${role}" is not allowed for read-only lane dispatch`
+    };
+  }
+  const callerPrefix = context.callerAgent ? getGeneratedAgentPrefix(context.callerAgent, generatedAgentNames) : null;
+  if (callerPrefix) {
+    const lanePrefix = getGeneratedAgentPrefix(agent, generatedAgentNames);
+    if (lanePrefix !== callerPrefix) {
+      return {
+        ok: false,
+        role,
+        error: `Agent "${agent}" does not match caller swarm prefix "${callerPrefix}"`
+      };
+    }
+  }
+  return { ok: true, role };
+}
+function getGeneratedAgentPrefix(agent, generatedAgentNames) {
+  const role = resolveGeneratedAgentRole(agent, generatedAgentNames);
+  if (!isKnownCanonicalRole(role))
+    return null;
+  const normalized = agent.toLowerCase();
+  if (normalized === role)
+    return null;
+  for (const separator of AGENT_NAME_SEPARATORS) {
+    const suffix = `${separator}${role}`;
+    if (normalized.endsWith(suffix)) {
+      return normalized.slice(0, -suffix.length);
+    }
+  }
+  return null;
+}
+function buildReadOnlyTools() {
+  const tools = {};
+  for (const toolName of READ_ONLY_TOOL_DENYLIST) {
+    tools[toolName] = false;
+  }
+  tools.write = false;
+  tools.edit = false;
+  tools.patch = false;
+  return tools;
+}
+function boundLaneOutput(output) {
+  if (output.length <= MAX_LANE_OUTPUT_CHARS) {
+    return {
+      output,
+      output_chars: output.length,
+      output_truncated: false
+    };
+  }
+  const omitted = output.length - MAX_LANE_OUTPUT_CHARS;
+  const suffix = `
+[... ${omitted} chars truncated by dispatch_lanes ...]`;
+  const maxContent = Math.max(0, MAX_LANE_OUTPUT_CHARS - suffix.length);
+  return {
+    output: `${output.slice(0, maxContent)}${suffix}`,
+    output_chars: output.length,
+    output_truncated: true
+  };
+}
+function failureResult(args2) {
+  return {
+    success: false,
+    failure_class: args2.failure_class,
+    message: args2.message,
+    dispatched: 0,
+    completed: 0,
+    failed: 0,
+    rejected: 0,
+    max_concurrent: 0,
+    timeout_ms: 0,
+    lane_results: [],
+    errors: args2.errors
+  };
+}
+function findDuplicateLaneIds(lanes) {
+  const seen = new Set;
+  const duplicates = new Set;
+  for (const lane of lanes) {
+    if (seen.has(lane.id))
+      duplicates.add(lane.id);
+    seen.add(lane.id);
+  }
+  return [...duplicates];
+}
+function scheduleSessionCleanup(session, sessionId) {
+  session.delete({ path: { id: sessionId } }).catch(() => {
+    return;
+  });
+}
+async function withTimeout2(promise3, timeoutMs, message) {
+  let timeout;
+  try {
+    return await Promise.race([
+      promise3,
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new Error(message)), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+  }
+}
+function extractText3(parts2) {
+  if (!Array.isArray(parts2))
+    return "";
+  return parts2.filter((part) => part.type === "text").map((part) => part.text ?? "").join(`
+`);
+}
+function formatError3(error93) {
+  if (error93 instanceof Error)
+    return error93.message;
+  const text = typeof error93 === "string" ? error93 : String(error93);
+  return boundErrorString(text);
+}
+function boundErrorString(text) {
+  if (text.length <= MAX_ERROR_CHARS)
+    return text;
+  return `${text.slice(0, MAX_ERROR_CHARS)}${ERROR_TRUNCATION_SUFFIX}`;
+}
+function isoNow() {
+  return new Date(_internals79.now()).toISOString();
+}
+var dispatch_lanes = createSwarmTool({
+  description: "Dispatch multiple read-only exploration/review lanes concurrently through OpenCode sessions and return a structured join result.",
+  args: {
+    lanes: DispatchLanesArgsSchema.shape.lanes,
+    max_concurrent: DispatchLanesArgsSchema.shape.max_concurrent,
+    timeout_ms: DispatchLanesArgsSchema.shape.timeout_ms
+  },
+  execute: async (args2, directory, ctx) => {
+    const result = await executeDispatchLanes(args2, directory, {
+      callerAgent: getContextAgent(ctx)
+    });
+    return JSON.stringify(result, null, 2);
+  }
+});
+function getContextAgent(ctx) {
+  if (!ctx || typeof ctx !== "object")
+    return;
+  const value = ctx.agent;
+  return typeof value === "string" ? value : undefined;
+}
+
 // src/tools/manifest.ts
 init_doc_scan();
 
@@ -124838,7 +125478,7 @@ function candidateFilePath(storePath3, id) {
   }
   return path146.join(storePath3, `${id}.json`);
 }
-var _internals79 = {
+var _internals80 = {
   randomUUID: crypto11.randomUUID.bind(crypto11),
   fs: {
     mkdir: fs93.mkdir,
@@ -124851,11 +125491,11 @@ var _internals79 = {
 function createExternalSkillStore(directory, config3) {
   const storePath3 = path146.join(directory, ".swarm", "skills", "candidates");
   async function add2(candidate) {
-    const id = _internals79.randomUUID();
+    const id = _internals80.randomUUID();
     const full = { ...candidate, id };
     const filePath = path146.join(storePath3, `${id}.json`);
-    await _internals79.fs.mkdir(storePath3, { recursive: true });
-    await _internals79.atomicWriteFile(filePath, JSON.stringify(full, null, "\t"));
+    await _internals80.fs.mkdir(storePath3, { recursive: true });
+    await _internals80.atomicWriteFile(filePath, JSON.stringify(full, null, "\t"));
     return full;
   }
   async function get2(id) {
@@ -124865,7 +125505,7 @@ function createExternalSkillStore(directory, config3) {
     }
     let raw;
     try {
-      raw = await _internals79.fs.readFile(filePath, "utf-8");
+      raw = await _internals80.fs.readFile(filePath, "utf-8");
     } catch (err2) {
       if (err2.code === "ENOENT") {
         return null;
@@ -124881,7 +125521,7 @@ function createExternalSkillStore(directory, config3) {
   async function list(filter) {
     let entries;
     try {
-      entries = await _internals79.fs.readdir(storePath3);
+      entries = await _internals80.fs.readdir(storePath3);
     } catch (err2) {
       if (err2.code === "ENOENT") {
         return [];
@@ -124896,7 +125536,7 @@ function createExternalSkillStore(directory, config3) {
       const filePath = path146.join(storePath3, entry);
       let raw;
       try {
-        raw = await _internals79.fs.readFile(filePath, "utf-8");
+        raw = await _internals80.fs.readFile(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -124963,7 +125603,7 @@ function createExternalSkillStore(directory, config3) {
         ...patch.evaluation_history
       ];
     }
-    await _internals79.atomicWriteFile(filePath, JSON.stringify(updated, null, "\t"));
+    await _internals80.atomicWriteFile(filePath, JSON.stringify(updated, null, "\t"));
     return updated;
   }
   async function deleteCandidate(id) {
@@ -124972,7 +125612,7 @@ function createExternalSkillStore(directory, config3) {
       return false;
     }
     try {
-      await _internals79.fs.unlink(filePath);
+      await _internals80.fs.unlink(filePath);
       return true;
     } catch (err2) {
       if (err2.code === "ENOENT") {
@@ -125010,7 +125650,7 @@ function createExternalSkillStore(directory, config3) {
 
 // src/tools/external-skill-delete.ts
 init_create_tool();
-var _internals80 = {
+var _internals81 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -125032,7 +125672,7 @@ var external_skill_delete = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals80.loadConfig(directory);
+      config3 = _internals81.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -125500,7 +126140,7 @@ function scanProvenanceIntegrity(candidate, trustLevel = "low", ttlDays) {
     });
   }
   fieldsScanned.push("fetched_at");
-  const now = new Date(_internals81.getTimestamp()).getTime();
+  const now = new Date(_internals82.getTimestamp()).getTime();
   const fetchedAtMs = new Date(candidate.fetched_at).getTime();
   if (Number.isNaN(fetchedAtMs)) {
     findings.push({
@@ -125564,7 +126204,7 @@ function scanProvenanceIntegrity(candidate, trustLevel = "low", ttlDays) {
     });
   }
   fieldsScanned.push("skill_body");
-  const computedHash = _internals81.computeSha256(candidate.skill_body);
+  const computedHash = _internals82.computeSha256(candidate.skill_body);
   if (computedHash !== candidate.sha256) {
     findings.push({
       pattern: "content_hash_mismatch",
@@ -125614,7 +126254,7 @@ function evaluateCandidate(candidate, options) {
     risk_flags: riskFlags
   };
 }
-var _internals81 = {
+var _internals82 = {
   getTimestamp: () => new Date().toISOString(),
   computeSha256: (content) => createHash14("sha256").update(content).digest("hex"),
   stripMarkdownCodeForUnsafeScan
@@ -125622,7 +126262,7 @@ var _internals81 = {
 
 // src/tools/external-skill-discover.ts
 init_create_tool();
-var _internals82 = {
+var _internals83 = {
   fetchContent: async (_url3, _timeoutMs) => {
     const parsed = new URL(_url3);
     if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
@@ -125783,7 +126423,7 @@ var external_skill_discover = createSwarmTool({
       resolvedContent = content;
     } else {
       try {
-        const fetched = await _internals82.fetchContent(resolvedUrl, config3.fetch_timeout_ms);
+        const fetched = await _internals83.fetchContent(resolvedUrl, config3.fetch_timeout_ms);
         if (fetched.finalUrl !== resolvedUrl && matchedSource && !isSubpathUrl(fetched.finalUrl, matchedSource.location)) {
           return JSON.stringify({
             success: false,
@@ -125805,14 +126445,14 @@ var external_skill_discover = createSwarmTool({
         error: `Content too large: ${resolvedContent.length} bytes exceeds max_bytes_per_candidate (${config3.max_bytes_per_candidate})`
       });
     }
-    const sha256 = _internals82.computeSha256(resolvedContent);
+    const sha256 = _internals83.computeSha256(resolvedContent);
     const candidate = {
-      id: _internals82.uuid(),
+      id: _internals83.uuid(),
       source_url: resolvedUrl,
       source_type: sourceType,
       publisher,
       sha256,
-      fetched_at: _internals82.getTimestamp(),
+      fetched_at: _internals83.getTimestamp(),
       skill_name: typeof skillName === "string" ? skillName : undefined,
       skill_description: typeof skillDescription === "string" ? skillDescription : undefined,
       skill_body: resolvedContent,
@@ -125830,7 +126470,7 @@ var external_skill_discover = createSwarmTool({
     candidate.evaluation_history = [
       {
         verdict: result.overall_verdict,
-        timestamp: _internals82.getTimestamp(),
+        timestamp: _internals83.getTimestamp(),
         actor: "system",
         reason: `Validation: ${result.gate_results.length} gates, ${result.all_findings.length} findings`,
         gate_results: result.gate_results.map((gr) => ({
@@ -125875,7 +126515,7 @@ var external_skill_discover = createSwarmTool({
 init_zod();
 init_loader();
 init_create_tool();
-var _internals83 = {
+var _internals84 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -125897,7 +126537,7 @@ var external_skill_inspect = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals83.loadConfig(directory);
+      config3 = _internals84.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -125939,7 +126579,7 @@ var external_skill_inspect = createSwarmTool({
 init_zod();
 init_loader();
 init_create_tool();
-var _internals84 = {
+var _internals85 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -125975,7 +126615,7 @@ var external_skill_list = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals84.loadConfig(directory);
+      config3 = _internals85.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -126028,7 +126668,7 @@ import { createHash as createHash16 } from "node:crypto";
 import * as fs94 from "node:fs/promises";
 import * as path147 from "node:path";
 init_create_tool();
-var _internals85 = {
+var _internals86 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -126098,7 +126738,7 @@ var external_skill_promote = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals85.loadConfig(directory);
+      config3 = _internals86.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -126168,8 +126808,8 @@ var external_skill_promote = createSwarmTool({
       }
       const targetDir = path147.join(directory, ".opencode", "skills", "generated", sanitizedSlug);
       const targetPath = path147.join(targetDir, "SKILL.md");
-      const timestamp = _internals85.getTimestamp();
-      const alreadyExists = await _internals85.fileExists(targetPath);
+      const timestamp = _internals86.getTimestamp();
+      const alreadyExists = await _internals86.fileExists(targetPath);
       if (alreadyExists) {
         return JSON.stringify({
           success: false,
@@ -126178,7 +126818,7 @@ var external_skill_promote = createSwarmTool({
       }
       const skillMarkdown = buildSkillMarkdown(candidate, sanitizedSlug, timestamp);
       try {
-        await _internals85.writeSkillFile(targetPath, skillMarkdown);
+        await _internals86.writeSkillFile(targetPath, skillMarkdown);
       } catch (writeErr) {
         const writeError = writeErr;
         if (writeError?.code === "EEXIST") {
@@ -126255,7 +126895,7 @@ var external_skill_promote = createSwarmTool({
 init_zod();
 init_loader();
 init_create_tool();
-var _internals86 = {
+var _internals87 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -126280,7 +126920,7 @@ var external_skill_reject = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals86.loadConfig(directory);
+      config3 = _internals87.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -126343,7 +126983,7 @@ init_zod();
 init_loader();
 import * as path148 from "node:path";
 init_create_tool();
-var _internals87 = {
+var _internals88 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -126394,7 +127034,7 @@ var external_skill_revoke = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals87.loadConfig(directory);
+      config3 = _internals88.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -126441,8 +127081,8 @@ var external_skill_revoke = createSwarmTool({
         });
       }
       const skillPath = path148.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
-      const skillFileRemoved = await _internals87.retireSkillFile(skillPath);
-      const timestamp = _internals87.getTimestamp();
+      const skillFileRemoved = await _internals88.retireSkillFile(skillPath);
+      const timestamp = _internals88.getTimestamp();
       const historyEntry = {
         verdict: "revoked",
         timestamp,
@@ -130011,7 +130651,7 @@ ${fileList}
   async _withStateLock(fn2) {
     const timeoutMs = 1e4;
     let timeoutId;
-    const withTimeout2 = new Promise((_resolve, reject) => {
+    const withTimeout3 = new Promise((_resolve, reject) => {
       timeoutId = setTimeout(() => {
         reject(new Error(`_withStateLock timed out after ${timeoutMs}ms — state update will not block subsequent operations`));
       }, timeoutMs);
@@ -130020,7 +130660,7 @@ ${fileList}
       if (timeoutId)
         clearTimeout(timeoutId);
     });
-    const promise3 = Promise.race([chain, withTimeout2]).finally(() => {
+    const promise3 = Promise.race([chain, withTimeout3]).finally(() => {
       if (timeoutId)
         clearTimeout(timeoutId);
     });
@@ -130100,7 +130740,7 @@ ${fileList}
 
 // src/tools/lean-turbo-run-phase.ts
 init_create_tool();
-var _internals88 = {
+var _internals89 = {
   LeanTurboRunner,
   loadPluginConfigWithMeta
 };
@@ -130110,9 +130750,9 @@ async function executeLeanTurboRunPhase(args2) {
   let runError = null;
   let runner = null;
   try {
-    const { config: config3 } = _internals88.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals89.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.strategy === "lean" ? config3.turbo.lean : undefined;
-    runner = new _internals88.LeanTurboRunner({
+    runner = new _internals89.LeanTurboRunner({
       directory,
       sessionID,
       opencodeClient: swarmState.opencodeClient ?? null,
@@ -130448,7 +131088,7 @@ function isStaticallyEquivalent(originalCode, mutatedCode) {
   const strippedMutated = stripCode(mutatedCode);
   return strippedOriginal === strippedMutated;
 }
-var _internals89 = {
+var _internals90 = {
   isStaticallyEquivalent,
   checkEquivalence,
   batchCheckEquivalence
@@ -130488,7 +131128,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
   const results = [];
   for (const { patch, originalCode, mutatedCode } of patches) {
     try {
-      const result = await _internals89.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
+      const result = await _internals90.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
       results.push(result);
     } catch (err2) {
       results.push({
@@ -130548,7 +131188,7 @@ function validateTestCommand(testCommand) {
 var MUTATION_TIMEOUT_MS = 30000;
 var TOTAL_BUDGET_MS = 300000;
 var GIT_APPLY_TIMEOUT_MS = 5000;
-var _internals90 = {
+var _internals91 = {
   executeMutation,
   computeReport,
   executeMutationSuite,
@@ -130580,7 +131220,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
       };
     }
     try {
-      const applyResult = _internals90.spawnSync("git", ["apply", "--", patchFile], {
+      const applyResult = _internals91.spawnSync("git", ["apply", "--", patchFile], {
         cwd: workingDir,
         timeout: GIT_APPLY_TIMEOUT_MS,
         stdio: "pipe"
@@ -130611,7 +131251,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
     try {
       const safeTestFiles = testFiles.filter((f) => !f.startsWith("-"));
       const testArgs = safeTestFiles.length > 0 ? [...testCommand.slice(1), ...safeTestFiles] : testCommand.slice(1);
-      const spawnResult = _internals90.spawnSync(testCommand[0], testArgs, {
+      const spawnResult = _internals91.spawnSync(testCommand[0], testArgs, {
         cwd: workingDir,
         timeout: MUTATION_TIMEOUT_MS,
         stdio: "pipe"
@@ -130644,7 +131284,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
   } finally {
     if (patchFile) {
       try {
-        const revertResult = _internals90.spawnSync("git", ["apply", "-R", "--", patchFile], {
+        const revertResult = _internals91.spawnSync("git", ["apply", "-R", "--", patchFile], {
           cwd: workingDir,
           timeout: GIT_APPLY_TIMEOUT_MS,
           stdio: "pipe"
@@ -130841,7 +131481,7 @@ async function executeMutationSuite(patches, testCommand, testFiles, workingDir,
 }
 
 // src/mutation/gate.ts
-var _internals91 = {
+var _internals92 = {
   evaluateMutationGate,
   buildTestImprovementPrompt,
   buildMessage
@@ -130862,8 +131502,8 @@ function evaluateMutationGate(report, passThreshold = PASS_THRESHOLD, warnThresh
   } else {
     verdict = "fail";
   }
-  const testImprovementPrompt = _internals91.buildTestImprovementPrompt(report, passThreshold, verdict);
-  const message = _internals91.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
+  const testImprovementPrompt = _internals92.buildTestImprovementPrompt(report, passThreshold, verdict);
+  const message = _internals92.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
   return {
     verdict,
     killRate: report.killRate,
@@ -131380,7 +132020,7 @@ function listLaneEvidenceSync(directory, phase) {
   }
   return laneIds;
 }
-var _internals92 = {
+var _internals93 = {
   listActiveLocks,
   readPersisted: readPersisted2,
   readPlanJson: defaultReadPlanJson,
@@ -131441,7 +132081,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
       reason: "Lean Turbo state unreadable or missing"
     };
   }
-  const persisted = _internals92.readPersisted(directory);
+  const persisted = _internals93.readPersisted(directory);
   if (!persisted) {
     return {
       ok: false,
@@ -131505,7 +132145,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (runState.lanes.length > 0) {
-    const evidenceLaneIds = new Set(_internals92.listLaneEvidenceSync(directory, phase));
+    const evidenceLaneIds = new Set(_internals93.listLaneEvidenceSync(directory, phase));
     for (const lane of runState.lanes) {
       if ((lane.status === "completed" || lane.status === "failed") && !evidenceLaneIds.has(lane.laneId)) {
         return {
@@ -131515,7 +132155,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
       }
     }
   }
-  const activeLocks = _internals92.listActiveLocks(directory);
+  const activeLocks = _internals93.listActiveLocks(directory);
   const phaseLaneIds = new Set(laneIds);
   for (const lock of activeLocks) {
     if (lock.laneId && phaseLaneIds.has(lock.laneId)) {
@@ -131535,7 +132175,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   const serialDegradedTasks = runState.degradedTasks.filter((dt) => !laneTaskIds.has(dt.taskId));
   if (serialDegradedTasks.length > 0) {
-    const plan = _internals92.readPlanJson(directory);
+    const plan = _internals93.readPlanJson(directory);
     if (!plan) {
       return {
         ok: false,
@@ -131579,7 +132219,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   const serializedTasks = runState.serializedTasks;
   if (Array.isArray(serializedTasks) && serializedTasks.length > 0) {
-    const plan = _internals92.readPlanJson(directory);
+    const plan = _internals93.readPlanJson(directory);
     if (!plan) {
       return {
         ok: false,
@@ -131638,7 +132278,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   let reviewerVerdict = runState.lastReviewerVerdict;
   if (!reviewerVerdict) {
-    const evidence = _internals92.readReviewerEvidence(directory, phase);
+    const evidence = _internals93.readReviewerEvidence(directory, phase);
     reviewerVerdict = evidence?.verdict ?? undefined;
   }
   if (mergedConfig.phase_reviewer) {
@@ -131651,7 +132291,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   let criticVerdict = runState.lastCriticVerdict;
   if (!criticVerdict) {
-    const evidence = _internals92.readCriticEvidence(directory, phase);
+    const evidence = _internals93.readCriticEvidence(directory, phase);
     criticVerdict = evidence?.verdict ?? undefined;
   }
   if (mergedConfig.phase_critic) {
@@ -132808,7 +133448,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
       phase_critic: leanConfig.phase_critic,
       integrated_diff_required: leanConfig.integrated_diff_required
     } : undefined;
-    const leanCheck = _internals92.verifyLeanTurboPhaseReady(dir, phase, sessionID, leanPhaseReadyConfig);
+    const leanCheck = _internals93.verifyLeanTurboPhaseReady(dir, phase, sessionID, leanPhaseReadyConfig);
     if (!leanCheck.ok) {
       return JSON.stringify({
         success: false,
@@ -135033,164 +135673,6 @@ var placeholder_scan = createSwarmTool({
 // src/tools/pre-check-batch.ts
 import * as fs116 from "node:fs";
 import * as path171 from "node:path";
-
-// node_modules/yocto-queue/index.js
-class Node2 {
-  value;
-  next;
-  constructor(value) {
-    this.value = value;
-  }
-}
-
-class Queue {
-  #head;
-  #tail;
-  #size;
-  constructor() {
-    this.clear();
-  }
-  enqueue(value) {
-    const node = new Node2(value);
-    if (this.#head) {
-      this.#tail.next = node;
-      this.#tail = node;
-    } else {
-      this.#head = node;
-      this.#tail = node;
-    }
-    this.#size++;
-  }
-  dequeue() {
-    const current = this.#head;
-    if (!current) {
-      return;
-    }
-    this.#head = this.#head.next;
-    this.#size--;
-    if (!this.#head) {
-      this.#tail = undefined;
-    }
-    return current.value;
-  }
-  peek() {
-    if (!this.#head) {
-      return;
-    }
-    return this.#head.value;
-  }
-  clear() {
-    this.#head = undefined;
-    this.#tail = undefined;
-    this.#size = 0;
-  }
-  get size() {
-    return this.#size;
-  }
-  *[Symbol.iterator]() {
-    let current = this.#head;
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
-  }
-  *drain() {
-    while (this.#head) {
-      yield this.dequeue();
-    }
-  }
-}
-
-// node_modules/p-limit/index.js
-function pLimit(concurrency) {
-  let rejectOnClear = false;
-  if (typeof concurrency === "object") {
-    ({ concurrency, rejectOnClear = false } = concurrency);
-  }
-  validateConcurrency(concurrency);
-  if (typeof rejectOnClear !== "boolean") {
-    throw new TypeError("Expected `rejectOnClear` to be a boolean");
-  }
-  const queue = new Queue;
-  let activeCount = 0;
-  const resumeNext = () => {
-    if (activeCount < concurrency && queue.size > 0) {
-      activeCount++;
-      queue.dequeue().run();
-    }
-  };
-  const next = () => {
-    activeCount--;
-    resumeNext();
-  };
-  const run2 = async (function_, resolve61, arguments_2) => {
-    const result = (async () => function_(...arguments_2))();
-    resolve61(result);
-    try {
-      await result;
-    } catch {}
-    next();
-  };
-  const enqueue = (function_, resolve61, reject, arguments_2) => {
-    const queueItem = { reject };
-    new Promise((internalResolve) => {
-      queueItem.run = internalResolve;
-      queue.enqueue(queueItem);
-    }).then(run2.bind(undefined, function_, resolve61, arguments_2));
-    if (activeCount < concurrency) {
-      resumeNext();
-    }
-  };
-  const generator = (function_, ...arguments_2) => new Promise((resolve61, reject) => {
-    enqueue(function_, resolve61, reject, arguments_2);
-  });
-  Object.defineProperties(generator, {
-    activeCount: {
-      get: () => activeCount
-    },
-    pendingCount: {
-      get: () => queue.size
-    },
-    clearQueue: {
-      value() {
-        if (!rejectOnClear) {
-          queue.clear();
-          return;
-        }
-        const abortError = AbortSignal.abort().reason;
-        while (queue.size > 0) {
-          queue.dequeue().reject(abortError);
-        }
-      }
-    },
-    concurrency: {
-      get: () => concurrency,
-      set(newConcurrency) {
-        validateConcurrency(newConcurrency);
-        concurrency = newConcurrency;
-        queueMicrotask(() => {
-          while (activeCount < concurrency && queue.size > 0) {
-            resumeNext();
-          }
-        });
-      }
-    },
-    map: {
-      async value(iterable, function_) {
-        const promises11 = Array.from(iterable, (value, index) => this(function_, value, index));
-        return Promise.all(promises11);
-      }
-    }
-  });
-  return generator;
-}
-function validateConcurrency(concurrency) {
-  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-  }
-}
-
-// src/tools/pre-check-batch.ts
 init_zod();
 init_manager2();
 init_utils();
@@ -135318,11 +135800,11 @@ var quality_budget = createSwarmTool({
     }).optional().describe("Quality budget thresholds")
   },
   async execute(args2, directory) {
-    const result = await _internals94.qualityBudget(args2, directory);
+    const result = await _internals95.qualityBudget(args2, directory);
     return JSON.stringify(result);
   }
 });
-var _internals94 = {
+var _internals95 = {
   qualityBudget
 };
 
@@ -136044,10 +136526,10 @@ import * as fs113 from "node:fs";
 import * as path168 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
-var DEFAULT_TIMEOUT_MS3 = 30000;
+var DEFAULT_TIMEOUT_MS4 = 30000;
 var MAX_OUTPUT_BYTES8 = 10 * 1024 * 1024;
 var KILL_GRACE_MS = 2000;
-var _internals95 = {
+var _internals96 = {
   isSemgrepAvailable,
   checkSemgrepAvailable,
   resetSemgrepCache,
@@ -136073,7 +136555,7 @@ function isSemgrepAvailable() {
   }
 }
 async function checkSemgrepAvailable() {
-  return _internals95.isSemgrepAvailable();
+  return _internals96.isSemgrepAvailable();
 }
 function resetSemgrepCache() {
   semgrepAvailableCache = null;
@@ -136227,15 +136709,15 @@ async function executeWithTimeout(command, args2, options) {
 async function runSemgrep(options) {
   const files = options.files || [];
   const rulesDir = options.rulesDir || DEFAULT_RULES_DIR;
-  const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS3;
+  const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS4;
   if (files.length === 0) {
     return {
-      available: _internals95.isSemgrepAvailable(),
+      available: _internals96.isSemgrepAvailable(),
       findings: [],
       engine: "tier_a"
     };
   }
-  if (!_internals95.isSemgrepAvailable()) {
+  if (!_internals96.isSemgrepAvailable()) {
     return {
       available: false,
       findings: [],
@@ -136402,7 +136884,7 @@ function assignOccurrenceIndices(findings, directory) {
     }
     const occIdx = countMap.get(baseKey) ?? 0;
     countMap.set(baseKey, occIdx + 1);
-    const fp = _internals96.fingerprintFinding(finding, directory, occIdx);
+    const fp = _internals97.fingerprintFinding(finding, directory, occIdx);
     return {
       finding,
       index: occIdx,
@@ -136471,7 +136953,7 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       }
     } catch {}
     const scannedRelFiles = new Set(scannedFiles.map((f) => normalizeFindingPath(directory, f)));
-    const indexed = _internals96.assignOccurrenceIndices(findings, directory);
+    const indexed = _internals97.assignOccurrenceIndices(findings, directory);
     if (existing && !opts?.force) {
       const prunedFingerprints = existing.fingerprints.filter((fp) => {
         const relFile = fp.slice(0, fp.indexOf("|"));
@@ -136611,7 +137093,7 @@ function loadBaseline(directory, phase) {
     };
   }
 }
-var _internals96 = {
+var _internals97 = {
   fingerprintFinding,
   assignOccurrenceIndices,
   captureOrMergeBaseline,
@@ -137021,11 +137503,11 @@ var sast_scan = createSwarmTool({
       capture_baseline: safeArgs.capture_baseline,
       phase: safeArgs.phase
     };
-    const result = await _internals97.sastScan(input, directory);
+    const result = await _internals98.sastScan(input, directory);
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals97 = {
+var _internals98 = {
   sastScan,
   sast_scan
 };
@@ -141899,7 +142381,7 @@ init_schema3();
 init_store();
 init_create_tool();
 init_resolve_working_directory();
-function getContextAgent(ctx) {
+function getContextAgent2(ctx) {
   if (!ctx || typeof ctx !== "object")
     return;
   const value = ctx.agent;
@@ -141954,7 +142436,7 @@ var summarize_work = createSwarmTool({
     }
     const workingDir = dirResult.directory;
     const sessionId = ctx?.sessionID ?? "unknown-session";
-    const agent = getContextAgent(ctx) ?? "unknown-agent";
+    const agent = getContextAgent2(ctx) ?? "unknown-agent";
     let maxWords = MAX_AGENT_SUMMARY_WORDS;
     try {
       const config3 = loadPluginConfig(workingDir);
@@ -142060,7 +142542,7 @@ var swarm_memory_propose = createSwarmTool({
     evidenceRefs: exports_external.array(exports_external.string().min(1).max(500)).max(20).optional().describe("Evidence refs such as files, commits, test outputs, or URLs")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals98.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals99.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -142075,8 +142557,8 @@ var swarm_memory_propose = createSwarmTool({
         error: parsed.error.issues.map((issue3) => issue3.message).join("; ")
       });
     }
-    const agent = getContextAgent2(ctx);
-    const gateway = _internals98.createMemoryGateway({
+    const agent = getContextAgent3(ctx);
+    const gateway = _internals99.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -142101,11 +142583,11 @@ var swarm_memory_propose = createSwarmTool({
     }
   }
 });
-var _internals98 = {
+var _internals99 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
-function getContextAgent2(ctx) {
+function getContextAgent3(ctx) {
   if (!ctx || typeof ctx !== "object")
     return;
   const value = ctx.agent;
@@ -142139,7 +142621,7 @@ var swarm_memory_recall = createSwarmTool({
     maxItems: exports_external.number().int().min(1).max(20).optional().describe("Maximum memories to return")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals99.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals100.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -142154,8 +142636,8 @@ var swarm_memory_recall = createSwarmTool({
         error: parsed.error.issues.map((issue3) => issue3.message).join("; ")
       });
     }
-    const agent = getContextAgent3(ctx);
-    const gateway = _internals99.createMemoryGateway({
+    const agent = getContextAgent4(ctx);
+    const gateway = _internals100.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -142188,11 +142670,11 @@ var RecallArgsSchema = exports_external.object({
   kinds: exports_external.array(exports_external.enum(MEMORY_KINDS2)).optional(),
   maxItems: exports_external.number().int().min(1).max(20).optional()
 });
-var _internals99 = {
+var _internals100 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
-function getContextAgent3(ctx) {
+function getContextAgent4(ctx) {
   if (!ctx || typeof ctx !== "object")
     return;
   const value = ctx.agent;
@@ -142714,7 +143196,7 @@ import * as path184 from "node:path";
 init_bun_compat();
 import * as fs125 from "node:fs";
 import * as path183 from "node:path";
-var _internals100 = { bunSpawn };
+var _internals101 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
   for (const rawLine of content.split(`
@@ -142747,7 +143229,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
       checkIgnoreExitCode
     ] = await Promise.all([
       (async () => {
-        const proc = _internals100.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
+        const proc = _internals101.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -142757,7 +143239,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals100.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
+        const proc = _internals101.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -142767,7 +143249,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals100.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
+        const proc = _internals101.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
         try {
           return await proc.exited;
         } finally {
@@ -142806,7 +143288,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       } catch {}
     }
-    const trackedProc = _internals100.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
+    const trackedProc = _internals101.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
     let trackedExitCode;
     let trackedOutput;
     try {
@@ -142831,7 +143313,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 }
 
 // src/hooks/diff-scope.ts
-var _internals101 = { bunSpawn };
+var _internals102 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
     const planPath = path184.join(directory, ".swarm", "plan.json");
@@ -142866,7 +143348,7 @@ var GIT_DIFF_SPAWN_OPTIONS = {
 };
 async function getChangedFiles2(directory) {
   try {
-    const proc = _internals101.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
+    const proc = _internals102.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -142883,7 +143365,7 @@ async function getChangedFiles2(directory) {
       return stdout.trim().split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
     }
-    const proc2 = _internals101.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
+    const proc2 = _internals102.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -142941,7 +143423,7 @@ init_telemetry();
 init_file_locks();
 import * as fs127 from "node:fs";
 import * as path185 from "node:path";
-var _internals102 = {
+var _internals103 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
 };
@@ -143083,7 +143565,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  const activeLocks = _internals102.listActiveLocks(directory);
+  const activeLocks = _internals103.listActiveLocks(directory);
   const laneLocks = activeLocks.filter((lock) => lock.laneId === lane.laneId);
   if (laneLocks.length > 0) {
     return {
@@ -143150,7 +143632,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
 init_task_id();
 init_create_tool();
 init_resolve_working_directory();
-var _internals103 = {
+var _internals104 = {
   tryAcquireLock,
   updateTaskStatus,
   resolveWorkingDirectory
@@ -143247,7 +143729,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     let resolvedDir;
     if (fallbackDir) {
-      const resolveResult = _internals103.resolveWorkingDirectory(workingDirectory, fallbackDir);
+      const resolveResult = _internals104.resolveWorkingDirectory(workingDirectory, fallbackDir);
       if (resolveResult.success) {
         resolvedDir = resolveResult.directory;
       } else {
@@ -143594,7 +144076,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     }
   }
   let directory;
-  const resolveResult = _internals103.resolveWorkingDirectory(args2.working_directory, fallbackDir);
+  const resolveResult = _internals104.resolveWorkingDirectory(args2.working_directory, fallbackDir);
   if (!resolveResult.success) {
     return {
       success: false,
@@ -143687,7 +144169,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   let lockResult;
   try {
-    lockResult = await _internals103.tryAcquireLock(directory, planFilePath, agentName, lockTaskId);
+    lockResult = await _internals104.tryAcquireLock(directory, planFilePath, agentName, lockTaskId);
   } catch (error93) {
     return {
       success: false,
@@ -143706,7 +144188,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   try {
-    const updatedPlan = await _internals103.updateTaskStatus(directory, args2.task_id, args2.status);
+    const updatedPlan = await _internals104.updateTaskStatus(directory, args2.task_id, args2.status);
     if (args2.status === "completed") {
       for (const [_sessionId, session] of swarmState.agentSessions) {
         if (!(session.taskWorkflowStates instanceof Map)) {
@@ -143847,14 +144329,14 @@ init_create_tool();
 init_resolve_working_directory();
 var DEFAULT_MAX_BYTES = 1e6;
 var MAX_BYTES_HARD_CAP = 5000000;
-var DEFAULT_TIMEOUT_MS4 = 15000;
-var MAX_TIMEOUT_MS2 = 30000;
+var DEFAULT_TIMEOUT_MS5 = 15000;
+var MAX_TIMEOUT_MS3 = 30000;
 var MAX_REDIRECTS = 5;
 var MAX_TEXT_LENGTH2 = 50000;
 var ArgsSchema6 = exports_external.object({
   url: exports_external.string().min(1).max(2048),
   max_bytes: exports_external.number().int().min(1024).max(MAX_BYTES_HARD_CAP).optional(),
-  timeout_ms: exports_external.number().int().min(1000).max(MAX_TIMEOUT_MS2).optional(),
+  timeout_ms: exports_external.number().int().min(1000).max(MAX_TIMEOUT_MS3).optional(),
   working_directory: exports_external.string().optional()
 });
 function isBlockedAddress(address) {
@@ -144339,7 +144821,7 @@ var web_fetch = createSwarmTool({
   args: {
     url: exports_external.string().min(1).max(2048).describe("Absolute http(s) URL to fetch (1–2048 chars)."),
     max_bytes: exports_external.number().int().min(1024).max(MAX_BYTES_HARD_CAP).optional().describe(`Max decoded response bytes to read (1024..${MAX_BYTES_HARD_CAP}, default ${DEFAULT_MAX_BYTES}).`),
-    timeout_ms: exports_external.number().int().min(1000).max(MAX_TIMEOUT_MS2).optional().describe(`Request timeout in ms (1000..${MAX_TIMEOUT_MS2}, default ${DEFAULT_TIMEOUT_MS4}).`),
+    timeout_ms: exports_external.number().int().min(1000).max(MAX_TIMEOUT_MS3).optional().describe(`Request timeout in ms (1000..${MAX_TIMEOUT_MS3}, default ${DEFAULT_TIMEOUT_MS5}).`),
     working_directory: exports_external.string().optional().describe("Project root for config resolution and evidence storage. Optional.")
   },
   execute: async (args2, directory) => {
@@ -144361,7 +144843,7 @@ var web_fetch = createSwarmTool({
       };
       return JSON.stringify(fail, null, 2);
     }
-    const config3 = _internals104.loadPluginConfig(dirResult.directory);
+    const config3 = _internals105.loadPluginConfig(dirResult.directory);
     const generalConfig = config3.council?.general;
     if (!generalConfig || generalConfig.enabled !== true) {
       const fail = {
@@ -144371,7 +144853,7 @@ var web_fetch = createSwarmTool({
       };
       return JSON.stringify(fail, null, 2);
     }
-    const validated = await validateFetchUrl(parsed.data.url, _internals104.dnsLookup);
+    const validated = await validateFetchUrl(parsed.data.url, _internals105.dnsLookup);
     if (!validated.ok) {
       const fail = {
         success: false,
@@ -144381,8 +144863,8 @@ var web_fetch = createSwarmTool({
       return JSON.stringify(fail, null, 2);
     }
     const maxBytes = parsed.data.max_bytes ?? DEFAULT_MAX_BYTES;
-    const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_TIMEOUT_MS4;
-    const result = await boundedFetch({ url: validated.url, address: validated.address }, maxBytes, timeoutMs, _internals104);
+    const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_TIMEOUT_MS5;
+    const result = await boundedFetch({ url: validated.url, address: validated.address }, maxBytes, timeoutMs, _internals105);
     if (!result.ok) {
       const fail = {
         success: false,
@@ -144417,7 +144899,7 @@ var web_fetch = createSwarmTool({
 });
 async function captureFetchEvidence(directory, url3, title, text) {
   try {
-    const written = await _internals104.writeEvidenceDocuments(directory, [
+    const written = await _internals105.writeEvidenceDocuments(directory, [
       {
         sourceType: "crawl",
         url: url3,
@@ -144438,7 +144920,7 @@ async function captureFetchEvidence(directory, url3, title, text) {
     };
   }
 }
-var _internals104 = {
+var _internals105 = {
   httpRequest: performHttpRequest,
   dnsLookup: lookup,
   loadPluginConfig,
@@ -144752,7 +145234,7 @@ var web_search = createSwarmTool({
 });
 async function captureSearchEvidence(directory, query, results) {
   try {
-    const written = await _internals105.writeEvidenceDocuments(directory, results.map((result) => ({
+    const written = await _internals106.writeEvidenceDocuments(directory, results.map((result) => ({
       sourceType: "web_search",
       query,
       title: result.title,
@@ -144780,7 +145262,7 @@ async function captureSearchEvidence(directory, query, results) {
     };
   }
 }
-var _internals105 = {
+var _internals106 = {
   writeEvidenceDocuments
 };
 
@@ -145600,6 +146082,7 @@ var TOOL_MANIFEST = defineHandlers({
   swarm_memory_recall: () => swarm_memory_recall,
   swarm_memory_propose: () => swarm_memory_propose,
   swarm_command: () => swarm_command,
+  dispatch_lanes: () => dispatch_lanes,
   summarize_work: () => summarize_work,
   write_architecture_supervisor_evidence: () => write_architecture_supervisor_evidence,
   lean_turbo_plan_lanes: () => lean_turbo_plan_lanes,