opencode-swarm 7.79.7 → 7.81.0

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.79.7",
+    version: "7.81.0",
     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",
@@ -683,6 +683,14 @@ var init_tool_metadata = __esm(() => {
       description: "dispatch multiple read-only exploration/review lanes concurrently and return a structured join result",
       agents: ["architect"]
     },
+    dispatch_lanes_async: {
+      description: "launch multiple read-only advisory lanes asynchronously and return a batch id for later collection",
+      agents: ["architect"]
+    },
+    collect_lane_results: {
+      description: "collect or poll results for a dispatch_lanes_async advisory batch without advancing workflow gates",
+      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: [
@@ -15967,7 +15975,8 @@ var init_schema = __esm(() => {
     }).optional(),
     enrichment: exports_external.object({
       max_calls_per_day: exports_external.number().int().min(0).max(1000).default(30),
-      quota_window: exports_external.enum(["utc", "local"]).default("utc")
+      quota_window: exports_external.enum(["utc", "local"]).default("utc"),
+      batch_size: exports_external.number().int().min(1).max(100).optional()
     }).default({ max_calls_per_day: 30, quota_window: "utc" })
   });
   MemoryConfigSchema = exports_external.object({
@@ -23590,6 +23599,21 @@ function rememberStandardWorktreeDispatch(dispatch) {
 function hasStandardWorktreeDispatchCapacity() {
   return standardWorktreeByCallID.size < MAX_TRACKED_STANDARD_WORKTREE_CALLS;
 }
+function hasInFlightStandardWorktreeDispatch(parentSessionID) {
+  for (const dispatch of standardWorktreeByCallID.values()) {
+    if (dispatch.parentSessionID === parentSessionID)
+      return true;
+  }
+  return false;
+}
+function handleStandardWorktreeFailure(parentSessionID, policy, message) {
+  if (policy === "required")
+    throw new Error(message);
+  if (hasInFlightStandardWorktreeDispatch(parentSessionID)) {
+    throw new Error(`STANDARD_WORKTREE_ISOLATION_UNSAFE: ${message} ` + `Sibling coder task(s) are isolated in worktrees for this session, so ` + `dispatching this coder un-isolated in the main tree would risk a ` + `merge-back collision. Wait for in-flight coder task(s) to be reviewed ` + `and merged, then retry.`);
+  }
+  serializeStandardWorktreeDispatches(parentSessionID, message);
+}
 function serializeStandardWorktreeDispatches(sessionID, message) {
   rememberStandardWorktreeSerializationSession(sessionID);
   const session = ensureAgentSession(sessionID);
@@ -23643,9 +23667,7 @@ async function precreateStandardWorktreeSession(args2) {
   const client = swarmState.opencodeClient;
   if (!client) {
     const message = "STANDARD_WORKTREE_ISOLATION_UNAVAILABLE: OpenCode SDK client is unavailable; standard parallel coder work cannot be isolated.";
-    if (worktreeConfig.policy === "required")
-      throw new Error(message);
-    serializeStandardWorktreeDispatches(args2.parentSessionID, message);
+    handleStandardWorktreeFailure(args2.parentSessionID, worktreeConfig.policy, message);
     return;
   }
   const provisionResult = await _internals12.provisionWorktree(args2.directory, args2.taskId, args2.parentSessionID, {
@@ -23654,10 +23676,8 @@ async function precreateStandardWorktreeSession(args2) {
     mergeStrategy: worktreeConfig.merge_strategy
   });
   if ("error" in provisionResult) {
-    const message = `STANDARD_WORKTREE_PROVISION_FAILED: ${provisionResult.error}`;
-    if (worktreeConfig.policy === "required")
-      throw new Error(message);
-    serializeStandardWorktreeDispatches(args2.parentSessionID, `${message}.`);
+    const message = `STANDARD_WORKTREE_PROVISION_FAILED: ${provisionResult.error}.`;
+    handleStandardWorktreeFailure(args2.parentSessionID, worktreeConfig.policy, message);
     return;
   }
   const createResult = await client.session.create({
@@ -23671,10 +23691,8 @@ async function precreateStandardWorktreeSession(args2) {
     await _internals12.removeWorktree(provisionResult.worktreePath, args2.directory).catch(() => {});
     const createError = createResult.error;
     const detail = typeof createError === "string" ? createError : JSON.stringify(createError ?? "missing session id");
-    const message = `STANDARD_WORKTREE_SESSION_CREATE_FAILED: ${detail}`;
-    if (worktreeConfig.policy === "required")
-      throw new Error(message);
-    serializeStandardWorktreeDispatches(args2.parentSessionID, `${message}.`);
+    const message = `STANDARD_WORKTREE_SESSION_CREATE_FAILED: ${detail}.`;
+    handleStandardWorktreeFailure(args2.parentSessionID, worktreeConfig.policy, message);
     return;
   }
   args2.outputArgs.task_id = createResult.data.id;
@@ -42738,7 +42756,47 @@ function parseTaskEnvelope(text) {
   const state = match[2];
   if (!sessionId)
     return null;
-  return { sessionId, state };
+  const summary = extractTagText(text, "summary");
+  const resultRaw = state === "error" ? extractTagText(text, "task_error") : extractTagText(text, "task_result");
+  const bounded = boundEnvelopeText(resultRaw);
+  return {
+    sessionId,
+    state,
+    ...summary !== undefined ? { summary } : {},
+    ...state === "error" && bounded ? {
+      errorText: bounded.text,
+      resultChars: bounded.chars,
+      resultTruncated: bounded.truncated
+    } : {},
+    ...state !== "error" && bounded ? {
+      resultText: bounded.text,
+      resultChars: bounded.chars,
+      resultTruncated: bounded.truncated
+    } : {}
+  };
+}
+function extractTagText(text, tag) {
+  const re = new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`);
+  const match = text.match(re);
+  if (!match)
+    return;
+  return match[1];
+}
+function boundEnvelopeText(text) {
+  if (text === undefined)
+    return;
+  if (text.length <= MAX_TASK_ENVELOPE_TEXT_CHARS) {
+    return { text, chars: text.length, truncated: false };
+  }
+  const omitted = text.length - MAX_TASK_ENVELOPE_TEXT_CHARS;
+  const suffix = `
+[... ${omitted} chars truncated by task-envelope ...]`;
+  const maxContent = Math.max(0, MAX_TASK_ENVELOPE_TEXT_CHARS - suffix.length);
+  return {
+    text: `${text.slice(0, maxContent)}${suffix}`,
+    chars: text.length,
+    truncated: true
+  };
 }
 function extractDispatchIds(output) {
   let subagentSessionId = null;
@@ -42768,7 +42826,7 @@ function extractDispatchIds(output) {
   }
   return { subagentSessionId, jobId };
 }
-var TASK_ENVELOPE_RE;
+var TASK_ENVELOPE_RE, MAX_TASK_ENVELOPE_TEXT_CHARS = 20000;
 var init_task_envelope = __esm(() => {
   TASK_ENVELOPE_RE = /<task\s+id="([^"]+)"\s+state="(running|completed|error)"\s*>/;
 });
@@ -42779,7 +42837,10 @@ __export(exports_pending_delegations, {
   sweepStaleDelegations: () => sweepStaleDelegations,
   recordPendingDelegation: () => recordPendingDelegation,
   readDelegations: () => readDelegations,
+  findOpenAsyncLaneBatches: () => findOpenAsyncLaneBatches,
   findByCorrelationId: () => findByCorrelationId,
+  findByBatchId: () => findByBatchId,
+  appendDelegationTransition: () => appendDelegationTransition,
   BACKGROUND_DELEGATIONS_FILE: () => BACKGROUND_DELEGATIONS_FILE
 });
 import * as fs15 from "node:fs";
@@ -42836,7 +42897,7 @@ function appendRecord(directory, record2) {
 async function recordPendingDelegation(directory, input, options = {}) {
   const now = Date.now();
   const record2 = {
-    schemaVersion: 1,
+    schemaVersion: input.batchId ? 2 : 1,
     correlationId: input.correlationId,
     jobId: input.jobId,
     subagentSessionId: input.subagentSessionId,
@@ -42848,7 +42909,13 @@ async function recordPendingDelegation(directory, input, options = {}) {
     evidenceTaskId: input.evidenceTaskId,
     status: "pending",
     createdAt: now,
-    updatedAt: now
+    updatedAt: now,
+    ...input.batchId ? { batchId: input.batchId } : {},
+    ...input.laneId ? { laneId: input.laneId } : {},
+    ...input.mode ? { mode: input.mode } : {},
+    ...input.promptHash ? { promptHash: input.promptHash } : {},
+    ...input.workspace ? { workspace: input.workspace } : {},
+    ...input.generation !== undefined ? { generation: input.generation } : {}
   };
   try {
     await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
@@ -42863,10 +42930,49 @@ async function recordPendingDelegation(directory, input, options = {}) {
     return null;
   }
 }
+async function appendDelegationTransition(directory, correlationId, transition) {
+  const now = Date.now();
+  try {
+    let next = null;
+    await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      const current = findByCorrelationId(directory, correlationId);
+      if (!current)
+        return;
+      if (isTerminal(current.status) && transition.status !== "consumed") {
+        next = current;
+        return;
+      }
+      next = {
+        ...current,
+        schemaVersion: current.schemaVersion === 1 ? 2 : current.schemaVersion,
+        status: transition.status,
+        updatedAt: now,
+        ...transition.completedAt !== undefined ? { completedAt: transition.completedAt } : transition.status === "completed" || transition.status === "error" ? { completedAt: now } : {},
+        ...transition.result ? { result: transition.result } : {}
+      };
+      appendRecord(directory, next);
+    });
+    return next;
+  } catch (err2) {
+    warn(`[background] appendDelegationTransition failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    return null;
+  }
+}
+function findByBatchId(directory, batchId, opts) {
+  if (!batchId)
+    return [];
+  return readDelegations(directory).filter((record2) => record2.batchId === batchId && (opts?.parentSessionId === undefined || record2.parentSessionId === opts.parentSessionId));
+}
+function findOpenAsyncLaneBatches(directory) {
+  return readDelegations(directory).filter((record2) => record2.batchId !== undefined && (record2.status === "pending" || record2.status === "running"));
+}
+function isTerminal(status) {
+  return status === "completed" || status === "error" || status === "cancelled" || status === "stale" || status === "consumed";
+}
 function sweepStaleLocked(directory, timeoutMs, now) {
   let swept = 0;
   for (const record2 of readDelegations(directory)) {
-    if (record2.status !== "pending")
+    if (record2.status !== "pending" && record2.status !== "running")
       continue;
     if (now - record2.updatedAt <= timeoutMs)
       continue;
@@ -42889,14 +42995,28 @@ async function sweepStaleDelegations(directory, timeoutMs) {
     return 0;
   }
 }
-var BACKGROUND_DELEGATIONS_FILE = "background-delegations.jsonl", STORE_LOCK_AGENT = "background", STORE_LOCK_TASK = "background-delegations", RecordSchema;
+var BACKGROUND_DELEGATIONS_FILE = "background-delegations.jsonl", STORE_LOCK_AGENT = "background", STORE_LOCK_TASK = "background-delegations", ResultSchema, WorkspaceSchema, RecordSchema;
 var init_pending_delegations = __esm(() => {
   init_zod();
   init_lock();
   init_utils2();
   init_logger();
+  ResultSchema = exports_external.object({
+    text: exports_external.string().optional(),
+    error: exports_external.string().optional(),
+    chars: exports_external.number(),
+    truncated: exports_external.boolean(),
+    digest: exports_external.string()
+  }).strict();
+  WorkspaceSchema = exports_external.object({
+    directory: exports_external.string(),
+    gitHead: exports_external.string().nullable(),
+    dirtyHash: exports_external.string().nullable(),
+    prHeadSha: exports_external.string().nullable(),
+    scope: exports_external.string().nullable()
+  }).strict();
   RecordSchema = exports_external.object({
-    schemaVersion: exports_external.literal(1),
+    schemaVersion: exports_external.union([exports_external.literal(1), exports_external.literal(2)]),
     correlationId: exports_external.string().min(1),
     jobId: exports_external.string().nullable(),
     subagentSessionId: exports_external.string().min(1),
@@ -42906,9 +43026,25 @@ var init_pending_delegations = __esm(() => {
     swarmPrefixedAgent: exports_external.string(),
     planTaskId: exports_external.string().nullable(),
     evidenceTaskId: exports_external.string().nullable(),
-    status: exports_external.enum(["pending", "completed", "error", "stale"]),
+    status: exports_external.enum([
+      "pending",
+      "running",
+      "completed",
+      "error",
+      "cancelled",
+      "stale",
+      "consumed"
+    ]),
     createdAt: exports_external.number(),
-    updatedAt: exports_external.number()
+    updatedAt: exports_external.number(),
+    batchId: exports_external.string().optional(),
+    laneId: exports_external.string().optional(),
+    mode: exports_external.string().optional(),
+    promptHash: exports_external.string().optional(),
+    workspace: WorkspaceSchema.optional(),
+    generation: exports_external.number().optional(),
+    result: ResultSchema.optional(),
+    completedAt: exports_external.number().optional()
   }).strict();
 });
 
@@ -43470,6 +43606,14 @@ function createDelegationGateHook(config2, directory) {
     const session = ensureAgentSession(input.sessionID);
     if (!session || !session.taskWorkflowStates)
       return;
+    const plan = await _internals20.loadPlanJsonOnly(directory);
+    const profile = plan?.execution_profile;
+    const parallelEnabled = profile?.parallelization_enabled === true;
+    const maxConcurrent = profile?.max_concurrent_tasks ?? 10;
+    const effectiveMaxConcurrent = session.maxConcurrencyOverride ?? maxConcurrent;
+    const parallelModeActive = parallelEnabled && effectiveMaxConcurrent > 1 && !hasActiveLeanTurbo(input.sessionID);
+    const planTaskIds = plan ? new Set(plan.phases.flatMap((phase) => phase.tasks.map((t) => t.id))) : new Set;
+    const incomingCoderTaskId = resolveDelegatedPlanTaskId(args2, planTaskIds);
     for (const [taskId, state] of session.taskWorkflowStates) {
       if (state !== "coder_delegated")
         continue;
@@ -43487,24 +43631,29 @@ function createDelegationGateHook(config2, directory) {
         if (!isTier3)
           continue;
       }
+      if (parallelModeActive && incomingCoderTaskId && taskId !== incomingCoderTaskId) {
+        continue;
+      }
       throw new Error(`REVIEWER_GATE_VIOLATION: Cannot re-delegate to coder without reviewer delegation. ` + `Task ${taskId} state: coder_delegated. Delegate to reviewer first. ` + `If this is stale state from a prior session, run /swarm reset-session to clear workflow state.`);
     }
+    if (parallelModeActive) {
+      let coderDelegatedCount = 0;
+      for (const s of session.taskWorkflowStates.values()) {
+        if (s === "coder_delegated")
+          coderDelegatedCount++;
+      }
+      if (coderDelegatedCount >= effectiveMaxConcurrent) {
+        throw new Error(`PARALLEL_SLOTS_EXHAUSTED: ${coderDelegatedCount} coder task(s) are awaiting review ` + `(max_concurrent_tasks=${effectiveMaxConcurrent}). Dispatch reviewer/test_engineer for an ` + `in-flight coder task before starting another coder.`);
+      }
+    }
     if (standardWorktreeSerializationSessions.has(input.sessionID)) {
       throw new Error("STANDARD_WORKTREE_ISOLATION_SERIALIZED: prior standard worktree isolation setup failed in this session; wait for the active coder task to finish before dispatching another coder.");
     }
-    const plan = await _internals20.loadPlanJsonOnly(directory);
     if (!plan)
       return;
-    const profile = plan.execution_profile;
-    const parallelEnabled = profile?.parallelization_enabled === true;
-    const maxConcurrent = profile?.max_concurrent_tasks ?? 10;
-    const effectiveMaxConcurrent = session.maxConcurrencyOverride ?? maxConcurrent;
-    if (!parallelEnabled || effectiveMaxConcurrent <= 1)
+    if (!parallelModeActive)
       return;
-    if (hasActiveLeanTurbo(input.sessionID))
-      return;
-    const planTaskIds = new Set(plan.phases.flatMap((phase) => phase.tasks.map((task) => task.id)));
-    const resolvedTaskId = resolveDelegatedPlanTaskId(args2, planTaskIds);
+    const resolvedTaskId = incomingCoderTaskId;
     await precreateStandardWorktreeSession({
       config: config2,
       directory,
@@ -67829,6 +67978,35 @@ function buildV3EnrichmentPrompt(lesson, category, tags) {
   ].join(`
 `);
 }
+function buildV3BatchEnrichmentPrompt(lessons) {
+  const lessonLines = lessons.map((item, idx) => `${idx + 1}. LESSON: ${item.lesson}
+   CATEGORY: ${item.category}
+   TAGS: ${item.tags.join(", ")}`).join(`
+`);
+  return [
+    "Convert each prose lesson below into an actionable knowledge directive.",
+    "Output ONLY a JSON array (no code fences, no commentary).",
+    `The array length MUST be exactly ${lessons.length}.`,
+    "Each array element at position i maps to lesson i (1-indexed above).",
+    "",
+    "For EACH element, mandatory requirements:",
+    "- At least ONE scope field non-empty:",
+    '  "applies_to_agents": string[] — roles from: architect, coder, reviewer, test_engineer, sme, docs, designer, critic, curator',
+    '  "applies_to_tools": string[] — tool names from: edit, write, patch, bash, read, grep, glob',
+    "- At least ONE predicate field non-empty:",
+    '  "forbidden_actions": string[] | "required_actions": string[] | "verification_checks": string[]',
+    "",
+    "Optional per element:",
+    '"triggers": string[], "directive_priority": "low" | "medium" | "high" | "critical"',
+    "",
+    "Example array:",
+    '[{"applies_to_agents":["coder"],"required_actions":["run focused tests before commit"],"directive_priority":"high"}]',
+    "",
+    "LESSONS:",
+    lessonLines
+  ].join(`
+`);
+}
 function parseV3EnrichmentResponse(text) {
   if (!text || typeof text !== "string") {
     return { missing: ["valid JSON object"] };
@@ -67869,6 +68047,109 @@ function parseV3EnrichmentResponse(text) {
   }
   return { fields };
 }
+function parseV3BatchEnrichmentResponse(text, expectedLength) {
+  const empty = Array.from({ length: expectedLength }, () => null);
+  if (!text || typeof text !== "string") {
+    return { fields: empty, missing: ["valid JSON array"] };
+  }
+  const start2 = text.indexOf("[");
+  const end = text.lastIndexOf("]");
+  if (start2 < 0 || end <= start2) {
+    return { fields: empty, missing: ["valid JSON array"] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text.slice(start2, end + 1));
+  } catch {
+    return { fields: empty, missing: ["valid JSON array"] };
+  }
+  if (!Array.isArray(parsed)) {
+    return { fields: empty, missing: ["valid JSON array"] };
+  }
+  const fields = Array.from({ length: expectedLength }, () => null);
+  const missing = [];
+  for (let i2 = 0;i2 < expectedLength; i2++) {
+    const item = parsed[i2];
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      missing.push(`item ${i2 + 1}: valid JSON object`);
+      continue;
+    }
+    const raw = item;
+    const candidate = {};
+    for (const key of ENRICHMENT_ALLOWED_FIELDS) {
+      if (raw[key] !== undefined) {
+        candidate[key] = raw[key];
+      }
+    }
+    const shape = validateActionableFields(candidate);
+    if (!shape.valid) {
+      missing.push(`item ${i2 + 1}: ${shape.errors.join("; ")}`);
+      continue;
+    }
+    const actionability = validateActionability(candidate);
+    if (!actionability.actionable) {
+      const expected = [];
+      if (actionability.reason === "missing_predicate" || actionability.reason === "missing_predicate_and_scope") {
+        expected.push("a non-empty predicate field (forbidden_actions, required_actions, or verification_checks)");
+      }
+      if (actionability.reason === "missing_scope" || actionability.reason === "missing_predicate_and_scope") {
+        expected.push("a non-empty scope field (applies_to_agents or applies_to_tools)");
+      }
+      missing.push(`item ${i2 + 1}: ${expected.join("; ")}`);
+      continue;
+    }
+    fields[i2] = candidate;
+  }
+  if (parsed.length < expectedLength) {
+    missing.push(`expected ${expectedLength} items but got ${parsed.length}`);
+  } else if (parsed.length > expectedLength) {
+    warn(`[knowledge-curator] parseV3BatchEnrichmentResponse received ${parsed.length} items but expected ${expectedLength}; extras will be discarded`);
+    missing.push(`got ${parsed.length} items but only first ${expectedLength} will be used; extras discarded`);
+  }
+  return { fields, missing };
+}
+async function enrichLessonsToV3Batched(params) {
+  const quota = params.quota ?? { maxCalls: 10, window: "utc" };
+  const out2 = Array.from({ length: params.lessons.length }, () => null);
+  const batchSize = params.batchSize ?? ENRICHMENT_BATCH_SIZE;
+  for (let start2 = 0;start2 < params.lessons.length; start2 += batchSize) {
+    const batch = params.lessons.slice(start2, start2 + batchSize);
+    const prompt = buildV3BatchEnrichmentPrompt(batch);
+    let userInput = prompt;
+    let best = Array.from({ length: batch.length }, () => null);
+    let retryHint = "";
+    for (let attempt = 0;attempt < 2; attempt++) {
+      try {
+        const reservation = await reserveQuota(params.directory, {
+          nCalls: 1,
+          maxCalls: quota.maxCalls,
+          window: quota.window,
+          scope: "knowledge-enrichment"
+        });
+        if (!reservation.allowed)
+          break;
+        const response = await params.llmDelegate("", userInput, AbortSignal.timeout(ENRICHMENT_LLM_TIMEOUT_MS));
+        const parsed = parseV3BatchEnrichmentResponse(response, batch.length);
+        best = best.map((current, idx) => current ?? parsed.fields[idx]);
+        const unresolved = best.map((fields, idx) => ({ fields, idx })).filter((item) => item.fields === null).map((item) => item.idx + 1);
+        if (unresolved.length === 0)
+          break;
+        retryHint = parsed.missing.join("; ");
+        const resolvedList = best.map((fields, idx) => ({ fields, idx })).filter((item) => item.fields !== null).map((item) => item.idx + 1);
+        const preserveClause = resolvedList.length > 0 ? `Preserve the already-valid entries for items ${resolvedList.join(", ")} exactly as you returned them previously. ` : "";
+        userInput = `${prompt}
+
+RETRY: your last output still missed valid directives for items ${unresolved.join(", ")}. ${retryHint} ${preserveClause}Return a full JSON array with valid entries for every item.`;
+      } catch (err2) {
+        warn(`[knowledge-curator] v3 batch enrichment attempt ${attempt + 1} failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
+      }
+    }
+    for (let i2 = 0;i2 < best.length; i2++) {
+      out2[start2 + i2] = best[i2];
+    }
+  }
+  return out2;
+}
 async function enrichLessonToV3(params) {
   const quota = params.quota ?? { maxCalls: 10, window: "utc" };
   const prompt = buildV3EnrichmentPrompt(params.lesson, params.category, params.tags);
@@ -68006,6 +68287,7 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
   const snapshotPlusNew = [...snapshot];
   const toAdd = [];
   const pendingReinforcementIds = new Set;
+  const pendingBatchEnrichment = [];
   for (const lesson of lessons) {
     const tags = inferTags(lesson);
     let category = "process";
@@ -68068,20 +68350,10 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
       project_name: projectName,
       auto_generated: true
     };
-    let actionability = validateActionability(entry);
+    const actionability = validateActionability(entry);
     if (!actionability.actionable && options?.llmDelegate) {
-      const enriched = await enrichLessonToV3({
-        directory,
-        llmDelegate: options.llmDelegate,
-        lesson,
-        category,
-        tags,
-        quota: options.enrichmentQuota
-      });
-      if (enriched) {
-        Object.assign(entry, enriched);
-        actionability = validateActionability(entry);
-      }
+      pendingBatchEnrichment.push({ entry, lesson, category, tags });
+      continue;
     }
     if (!actionability.actionable) {
       quarantined++;
@@ -68098,6 +68370,41 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     toAdd.push(entry);
     snapshotPlusNew.push(entry);
   }
+  if (pendingBatchEnrichment.length > 0 && options?.llmDelegate) {
+    const enrichedBatch = await enrichLessonsToV3Batched({
+      directory,
+      llmDelegate: options.llmDelegate,
+      lessons: pendingBatchEnrichment.map((item) => ({
+        lesson: item.lesson,
+        category: item.category,
+        tags: item.tags
+      })),
+      quota: options.enrichmentQuota,
+      batchSize: config3.enrichment?.batch_size
+    });
+    for (let i2 = 0;i2 < pendingBatchEnrichment.length; i2++) {
+      const pending = pendingBatchEnrichment[i2];
+      const enriched = enrichedBatch[i2];
+      if (enriched) {
+        Object.assign(pending.entry, enriched);
+      }
+      const actionability = validateActionability(pending.entry);
+      if (!actionability.actionable) {
+        quarantined++;
+        try {
+          await appendUnactionable(directory, pending.entry, actionability.reason ?? "unactionable");
+        } catch {}
+        await appendCuratorSkippedEvent(directory, {
+          entry_id: pending.entry.id,
+          lesson: pending.lesson,
+          reason: actionability.reason ?? "unactionable"
+        });
+        continue;
+      }
+      toAdd.push(pending.entry);
+      snapshotPlusNew.push(pending.entry);
+    }
+  }
   try {
     const insights = await consumeInsightCandidates(directory);
     for (const cand of insights) {
@@ -68301,7 +68608,7 @@ function createKnowledgeCuratorHook(directory, config3, options = {}) {
   };
   return safeHook(handler);
 }
-var seenRetroSections, MAX_TRACKED_RETRO_SECTIONS = 500, ENRICHMENT_ALLOWED_FIELDS, ENRICHMENT_LLM_TIMEOUT_MS = 60000, MESO_INSIGHT_BATCH_LIMIT = 20, KNOWLEDGE_CATEGORIES, OUTCOME_PROMOTION_BLOCK = -0.3, _internals31;
+var seenRetroSections, MAX_TRACKED_RETRO_SECTIONS = 500, ENRICHMENT_ALLOWED_FIELDS, ENRICHMENT_LLM_TIMEOUT_MS = 60000, ENRICHMENT_BATCH_SIZE = 6, MESO_INSIGHT_BATCH_LIMIT = 20, KNOWLEDGE_CATEGORIES, OUTCOME_PROMOTION_BLOCK = -0.3, _internals31;
 var init_knowledge_curator = __esm(() => {
   init_skill_improver_quota();
   init_synonym_map();
@@ -95301,7 +95608,7 @@ Present all three items together in a single message. One message, defaults pre-
 
 **1. QA Gates** — accept defaults or customize (the eleven gates listed above).
 
-**2. Parallel Coders** — "How many coders should run in parallel? (default: 1, range: 1-4)"
+**2. Parallel Coders** — Parallel coders each run in their own isolated git worktree (a separate working directory on its own branch); each coder's work is committed and merged back to the main tree automatically when it finishes, so concurrent coders never overwrite each other's files. This is safe and faster — but only for tasks whose declared file scopes do NOT overlap. Before you ask, INSPECT the plan's tasks: group the dependency-ready tasks whose file scopes are disjoint, and let your RECOMMENDED count be the number of such independent groups, clamped to the 1-4 range. If task scopes overlap or you cannot determine them, recommend 1 (serial). File-scope disjointness is your recommendation to make, not a runtime-enforced guarantee: if overlapping tasks run in parallel a merge conflict will preserve the work in its worktree and surface an advisory, but it stalls progress — so prefer serial whenever you are unsure. Ask: "How many coders should run in parallel? (default: 1, range: 1-4; my recommendation: <N>, because <independent task groups>)"
 
 **3. Commit Frequency** — "Commit frequency for completed tasks? (default: phase-level only; optional per-task checkpoint commit after each task completion)"
 
@@ -95313,7 +95620,7 @@ Wait for the user to answer all three in a single reply. Then apply:
 ## Pending Parallelization Config
 - parallelization_enabled: true
 - max_concurrent_tasks: <user's number>
-- council_parallel: true
+- council_parallel: false
 - locked: true
 - recorded_at: <ISO timestamp>
 \`\`\`
@@ -95650,8 +95957,8 @@ If a tool modifies a file, it is a CODER tool. Delegate.
   - Rationale: declare_scope persists the allowed set to disk (.swarm/scopes/scope-\${taskId}.json) so it survives cross-process delegation. Without a call, the coder or test_engineer process reads an empty scope and every Edit/Write is denied.
 <!-- BEHAVIORAL_GUIDANCE_END -->
 2. ONE agent per message. Send, STOP, wait for response.
-   Exception: Stage B reviewer/test_engineer gate agents for the SAME completed coder task may be dispatched together before waiting when both gates are required.
-   This exception NEVER applies to coder delegations. Preserve ONE task per coder call.
+   Exception: Stage B reviewer/test_engineer gate agents for the SAME completed coder task may be dispatched together before waiting when both gates are required. This exception NEVER applies to coder delegations. Preserve ONE task per coder call.
+   Separate parallel-mode exception (distinct from the Stage B exception above, and the ONLY case where more than one coder may be dispatched before waiting): when an active \`[PARALLEL EXECUTION PROFILE]\` directive is present in your context (parallelization_enabled=true), you MAY dispatch multiple {{AGENT_PREFIX}}coder agents in a single message — up to the stated max_concurrent_tasks — but ONLY for distinct, dependency-ready tasks whose declared file scopes do NOT overlap. Each coder still requires its own \`declare_scope\` call and carries exactly ONE task (Rule 3 still holds: never batch multiple objectives into one coder). Parallel coders each run in an isolated git worktree, so their writes never collide and are merged back automatically. If no \`[PARALLEL EXECUTION PROFILE]\` directive is present, dispatch coders one at a time.
 3. ONE task per {{AGENT_PREFIX}}coder call. Never batch.
 3a. PRE-DELEGATION SCOPE CALL (required): BEFORE every {{AGENT_PREFIX}}coder delegation, you MUST call \`declare_scope\` with { taskId, files } listing the exact file(s) this task will modify (including generated/lockfile paths). No \`declare_scope\` call → no coder delegation. See Rule 1a.
 3b. PRE-DELEGATION SCOPE CALL (test_engineer): BEFORE any {{AGENT_PREFIX}}test_engineer delegation that will CREATE or MODIFY test files, you MUST call \`declare_scope\` with { taskId, files } listing the exact test file path(s) to write. Omitting this call leaves the write scope undeclared and will block the write. See Rule 1a.
@@ -96582,6 +96889,7 @@ RULES:
 - Respect CONSTRAINT
 - No web searches or documentation lookups — but DO use the search tool for cross-codebase pattern lookup before using any function
 - Verify all import paths exist before using them
+- WORKTREE ISOLATION: when the orchestrator runs coders in parallel, you may be working inside an isolated git worktree — a separate working directory on its own branch. Work exactly as normal: read and edit files at the paths you are given. Your changes are committed and merged back to the main tree automatically when you finish. If a merge conflict arises during merge-back, your work is preserved in its worktree and an advisory is surfaced to the orchestrator — your changes are never lost. Do NOT run git worktree/branch/checkout/merge commands yourself, and do NOT switch directories. Stay strictly within your declared FILE scope so coders working in sibling worktrees never collide with you.
 
 ## ANTI-HALLUCINATION PROTOCOL (MANDATORY)
 Before importing ANY function, type, or class from an existing project module:
@@ -106830,6 +107138,7 @@ init_worker();
 init_logger();
 init_pending_delegations();
 init_task_envelope();
+import { createHash as createHash11 } from "node:crypto";
 function createBackgroundCompletionObserver(opts) {
   const { config: config3, directory } = opts;
   const event = async (input) => {
@@ -106854,16 +107163,37 @@ function createBackgroundCompletionObserver(opts) {
       const pending = findByCorrelationId(directory, envelope.sessionId);
       const parentSessionId = typeof part.sessionID === "string" ? part.sessionID : "unknown";
       if (!pending) {
-        log(`[background] observed synthetic completion (state=${envelope.state}) for subagent ${envelope.sessionId} in parent ${parentSessionId} with NO matching pending record — ignored (Stage A observe-only)`);
+        log(`[background] observed synthetic completion (state=${envelope.state}) for subagent ${envelope.sessionId} in parent ${parentSessionId} with NO matching pending record — ignored`);
+        return;
+      }
+      if (pending.parentSessionId !== parentSessionId) {
+        warn(`[background] observed synthetic completion for ${envelope.sessionId} with parent mismatch: expected=${pending.parentSessionId} observed=${parentSessionId}; ignored`);
+        return;
+      }
+      if (pending.status !== "pending" && pending.status !== "running") {
+        log(`[background] observed duplicate/late completion for ${envelope.sessionId}; current status=${pending.status}; ignored`);
         return;
       }
-      log(`[background] observed trusted completion (state=${envelope.state}) correlated to pending delegation: ` + `agent=${pending.normalizedAgent} task=${pending.evidenceTaskId ?? pending.planTaskId ?? "unknown"} ` + `parent=${pending.parentSessionId} observedParent=${parentSessionId} pendingStatus=${pending.status} ` + "(Stage A observe-only — no gate effect; Stage B will ingest completion)");
+      const text = envelope.state === "error" ? envelope.errorText ?? "" : envelope.resultText ?? "";
+      await appendDelegationTransition(directory, envelope.sessionId, {
+        status: envelope.state === "error" ? "error" : "completed",
+        result: {
+          ...envelope.state === "error" ? { error: text } : { text },
+          chars: envelope.resultChars ?? text.length,
+          truncated: envelope.resultTruncated ?? false,
+          digest: digest(text)
+        }
+      });
+      log(`[background] observed trusted completion (state=${envelope.state}) correlated to pending delegation: ` + `agent=${pending.normalizedAgent} task=${pending.evidenceTaskId ?? pending.planTaskId ?? "unknown"} ` + `parent=${pending.parentSessionId} observedParent=${parentSessionId} pendingStatus=${pending.status} ` + "(advisory ledger update only — no gate effect)");
     } catch (err2) {
       warn(`[background] completion observer error: ${err2 instanceof Error ? err2.message : String(err2)}`);
     }
   };
   return { event };
 }
+function digest(text) {
+  return createHash11("sha256").update(text).digest("hex");
+}
 
 // src/index.ts
 init_pr_subscriptions();
@@ -117074,7 +117404,7 @@ init_knowledge_events();
 // src/hooks/knowledge-injector.ts
 init_schema();
 init_manager();
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 
 // src/services/run-memory.ts
 import * as crypto10 from "node:crypto";
@@ -117578,7 +117908,7 @@ function createKnowledgeInjectorHook(directory, config3, modelLimitOverrides = {
       ctx.taskId ?? "",
       (ctx.filePaths ?? []).slice(0, 8).join(",")
     ].join("|");
-    return createHash14("sha1").update(parts2).digest("hex").slice(0, 16);
+    return createHash15("sha1").update(parts2).digest("hex").slice(0, 16);
   }
   let lastSeenCacheKey = null;
   let cachedInjectionText = null;
@@ -125574,6 +125904,9 @@ var diff_summary = createSwarmTool({
   }
 });
 
+// src/tools/dispatch-lanes.ts
+import { createHash as createHash16 } from "node:crypto";
+
 // node_modules/yocto-queue/index.js
 class Node2 {
   value;
@@ -125732,6 +126065,7 @@ function validateConcurrency(concurrency) {
 
 // src/tools/dispatch-lanes.ts
 init_zod();
+init_pending_delegations();
 init_constants();
 init_schema();
 
@@ -125796,6 +126130,12 @@ var MAX_TIMEOUT_MS2 = 1800000;
 var MAX_LANE_OUTPUT_CHARS = 20000;
 var MAX_ERROR_CHARS = 200;
 var ERROR_TRUNCATION_SUFFIX = "...";
+var MAX_BATCH_ID_CHARS = 120;
+var DEFAULT_ASYNC_STALE_TIMEOUT_MS = 30 * 60000;
+var DEFAULT_COLLECT_TIMEOUT_MS = DEFAULT_ASYNC_STALE_TIMEOUT_MS;
+var MAX_COLLECT_TIMEOUT_MS = 60 * 60000;
+var COLLECT_POLL_INTERVAL_MS = 500;
+var MAX_COLLECT_POLL_INTERVAL_MS = 1e4;
 var AGENT_NAME_SEPARATORS = ["_", "-", " "];
 var READ_ONLY_LANE_ROLES = new Set([
   "explorer",
@@ -125847,11 +126187,25 @@ var DispatchLanesArgsSchema = exports_external.object({
   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 DispatchLanesAsyncArgsSchema = DispatchLanesArgsSchema.extend({
+  batch_id: exports_external.string().min(1).max(MAX_BATCH_ID_CHARS).regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/).optional().describe("Stable async batch id for later collection; generated when omitted"),
+  mode: exports_external.string().min(1).max(80).optional().describe("Advisory workflow mode, such as deep-dive or swarm-pr-review"),
+  pr_head_sha: exports_external.string().min(1).max(80).optional(),
+  scope: exports_external.string().min(1).max(500).optional()
+});
+var CollectLaneResultsArgsSchema = exports_external.object({
+  batch_id: exports_external.string().min(1).max(MAX_BATCH_ID_CHARS),
+  wait: exports_external.boolean().optional().describe("Poll until all lanes settle or timeout"),
+  timeout_ms: exports_external.number().int().min(0).max(MAX_COLLECT_TIMEOUT_MS).optional().describe("Total wait budget when wait=true"),
+  include_pending: exports_external.boolean().optional(),
+  cancel_pending: exports_external.boolean().optional().describe("Abort and mark pending/running lanes cancelled")
+});
 var _internals81 = {
   getSessionOps: () => swarmState.opencodeClient?.session ?? null,
   getGeneratedAgentNames: () => swarmState.generatedAgentNames,
   createParallelDispatcher,
-  now: () => Date.now()
+  now: () => Date.now(),
+  sleep: sleep2
 };
 async function executeDispatchLanes(args2, directory, context = {}) {
   const parsed = DispatchLanesArgsSchema.safeParse(args2);
@@ -125893,6 +126247,322 @@ async function executeDispatchLanes(args2, directory, context = {}) {
     dispatcher.shutdown();
   }
 }
+async function executeDispatchLanesAsync(args2, directory, context = {}) {
+  const parsed = DispatchLanesAsyncArgsSchema.safeParse(args2);
+  if (!parsed.success) {
+    return asyncFailureResult({
+      failure_class: "invalid_args",
+      message: "Invalid dispatch_lanes_async arguments",
+      errors: parsed.error.issues.map((issue3) => `${issue3.path.join(".")}: ${issue3.message}`)
+    });
+  }
+  const duplicateLaneIds = findDuplicateLaneIds(parsed.data.lanes);
+  if (duplicateLaneIds.length > 0) {
+    return asyncFailureResult({
+      failure_class: "invalid_args",
+      message: "Lane IDs must be unique within one dispatch_lanes_async batch",
+      errors: duplicateLaneIds.map((id) => `Duplicate lane id: ${id}`)
+    });
+  }
+  const session = _internals81.getSessionOps();
+  if (!session || typeof session.promptAsync !== "function") {
+    return asyncFailureResult({
+      failure_class: "no_client",
+      message: "OpenCode session promptAsync client is not available"
+    });
+  }
+  const lanes = parsed.data.lanes;
+  const batchId = parsed.data.batch_id ?? makeBatchId();
+  if (findByBatchId(directory, batchId).length > 0) {
+    return asyncFailureResult({
+      failure_class: "invalid_args",
+      message: `Async lane batch already exists: ${batchId}`,
+      errors: [`batch_id must be unique: ${batchId}`]
+    });
+  }
+  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 = _internals81.createParallelDispatcher({
+    enabled: true,
+    maxConcurrentTasks: maxConcurrent,
+    evidenceLockTimeoutMs: 0
+  });
+  const limit = pLimit(maxConcurrent);
+  try {
+    const laneResults = await Promise.all(lanes.map((lane) => limit(() => launchAsyncLane({
+      session,
+      dispatcher,
+      lane,
+      directory,
+      timeoutMs,
+      context,
+      batchId,
+      mode: parsed.data.mode,
+      prHeadSha: parsed.data.pr_head_sha,
+      scope: parsed.data.scope
+    }))));
+    const failed = laneResults.filter((lane) => lane.status === "failed");
+    const rejected = laneResults.filter((lane) => lane.status === "rejected");
+    const pending = laneResults.filter((lane) => lane.status === "pending");
+    return {
+      success: failed.length === 0 && rejected.length === 0,
+      batch_id: batchId,
+      dispatched: laneResults.length,
+      pending: pending.length,
+      failed: failed.length,
+      rejected: rejected.length,
+      max_concurrent: maxConcurrent,
+      timeout_ms: timeoutMs,
+      lane_results: laneResults
+    };
+  } finally {
+    dispatcher.shutdown();
+  }
+}
+async function executeCollectLaneResults(args2, directory, context = {}) {
+  const parsed = CollectLaneResultsArgsSchema.safeParse(args2);
+  if (!parsed.success) {
+    return collectFailureResult({
+      failure_class: "invalid_args",
+      batch_id: "",
+      message: "Invalid collect_lane_results arguments",
+      errors: parsed.error.issues.map((issue3) => `${issue3.path.join(".")}: ${issue3.message}`)
+    });
+  }
+  const session = _internals81.getSessionOps();
+  if (!session || typeof session.messages !== "function") {
+    return collectFailureResult({
+      failure_class: "no_client",
+      batch_id: parsed.data.batch_id,
+      message: "OpenCode session messages client is not available"
+    });
+  }
+  const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_COLLECT_TIMEOUT_MS;
+  const deadline = _internals81.now() + timeoutMs;
+  const batchFilter = context.sessionID !== undefined ? { parentSessionId: context.sessionID } : undefined;
+  await sweepStaleDelegations(directory, DEFAULT_ASYNC_STALE_TIMEOUT_MS);
+  let records = findByBatchId(directory, parsed.data.batch_id, batchFilter);
+  if (records.length === 0) {
+    return collectFailureResult({
+      failure_class: "not_found",
+      batch_id: parsed.data.batch_id,
+      message: `No async lane batch found for ${parsed.data.batch_id}`
+    });
+  }
+  let keepPolling = true;
+  let pollIntervalMs = COLLECT_POLL_INTERVAL_MS;
+  while (keepPolling) {
+    await collectOnce(session, directory, records, parsed.data.cancel_pending === true);
+    await sweepStaleDelegations(directory, DEFAULT_ASYNC_STALE_TIMEOUT_MS);
+    records = findByBatchId(directory, parsed.data.batch_id, batchFilter);
+    if (allSettled(records) || parsed.data.wait !== true) {
+      keepPolling = false;
+      continue;
+    }
+    if (_internals81.now() >= deadline) {
+      keepPolling = false;
+      continue;
+    }
+    await _internals81.sleep(Math.min(pollIntervalMs, Math.max(0, deadline - _internals81.now())));
+    pollIntervalMs = nextCollectPollInterval(pollIntervalMs);
+  }
+  return buildCollectResult(parsed.data.batch_id, records, parsed.data.include_pending === true);
+}
+async function launchAsyncLane(args2) {
+  const validation2 = validateLaneAgent(args2.lane.agent, args2.context);
+  const role = validation2.role;
+  const startedAt = isoNow();
+  if (!validation2.ok) {
+    return {
+      id: args2.lane.id,
+      agent: args2.lane.agent,
+      role,
+      status: "rejected",
+      started_at: startedAt,
+      completed_at: isoNow(),
+      error: validation2.error
+    };
+  }
+  const decision = args2.dispatcher.dispatch(args2.lane.id);
+  if (decision.action !== "dispatch") {
+    return {
+      id: args2.lane.id,
+      agent: args2.lane.agent,
+      role,
+      status: "failed",
+      started_at: startedAt,
+      completed_at: isoNow(),
+      error: `dispatcher ${decision.action}: ${decision.reason}`
+    };
+  }
+  try {
+    const createTimeoutMessage = `Lane "${args2.lane.id}" session.create timed out after ${args2.timeoutMs}ms`;
+    const createPromise = args2.session.create({
+      query: { directory: args2.directory }
+    });
+    let createTimedOut = false;
+    createPromise.then((createResult2) => {
+      if (createTimedOut && createResult2.data?.id) {
+        scheduleSessionCleanup(args2.session, createResult2.data.id);
+      }
+    }).catch(() => {
+      return;
+    });
+    const createResult = await withTimeout2(createPromise, args2.timeoutMs, createTimeoutMessage).catch((error93) => {
+      if (formatError3(error93) === createTimeoutMessage) {
+        createTimedOut = true;
+      }
+      throw error93;
+    });
+    const sessionId = createResult.data?.id;
+    if (!sessionId) {
+      return failedLane(args2.lane, role, startedAt, `session.create failed: ${formatError3(createResult.error)}`, decision.slot.slotId, decision.slot.runId);
+    }
+    const pendingRecord = await recordPendingDelegation(args2.directory, {
+      correlationId: sessionId,
+      jobId: null,
+      subagentSessionId: sessionId,
+      parentSessionId: args2.context.sessionID ?? `dispatch_lanes_async:${args2.batchId}`,
+      callID: args2.batchId,
+      normalizedAgent: role,
+      swarmPrefixedAgent: args2.lane.agent,
+      planTaskId: null,
+      evidenceTaskId: null,
+      batchId: args2.batchId,
+      laneId: args2.lane.id,
+      mode: args2.mode ?? "advisory",
+      promptHash: promptHash(args2.lane, args2.directory, args2.batchId),
+      workspace: {
+        directory: args2.directory,
+        gitHead: null,
+        dirtyHash: null,
+        prHeadSha: args2.prHeadSha ?? null,
+        scope: args2.scope ?? null
+      },
+      generation: 1
+    }, { staleTimeoutMs: DEFAULT_ASYNC_STALE_TIMEOUT_MS });
+    if (!pendingRecord) {
+      cleanupAsyncLaunchSession(args2.session, sessionId);
+      return failedLane(args2.lane, role, startedAt, "Failed to record async lane in background delegation ledger", decision.slot.slotId, decision.slot.runId);
+    }
+    const promptController = new AbortController;
+    let promptResult;
+    try {
+      promptResult = await withTimeout2(args2.session.promptAsync({
+        path: { id: sessionId },
+        query: { directory: args2.directory },
+        body: {
+          agent: args2.lane.agent,
+          tools: buildReadOnlyTools(),
+          parts: [{ type: "text", text: args2.lane.prompt }]
+        },
+        signal: promptController.signal
+      }), args2.timeoutMs, `Lane "${args2.lane.id}" session.promptAsync timed out after ${args2.timeoutMs}ms`, promptController);
+    } catch (error93) {
+      const message = formatError3(error93);
+      await appendDelegationTransition(args2.directory, sessionId, {
+        status: "error",
+        result: {
+          error: message,
+          chars: message.length,
+          truncated: false,
+          digest: digestText(message)
+        }
+      });
+      cleanupAsyncLaunchSession(args2.session, sessionId);
+      return failedLane(args2.lane, role, startedAt, message, decision.slot.slotId, decision.slot.runId);
+    }
+    if (promptResult.error) {
+      const error93 = `session.promptAsync failed: ${formatError3(promptResult.error)}`;
+      await appendDelegationTransition(args2.directory, sessionId, {
+        status: "error",
+        result: {
+          error: error93,
+          chars: error93.length,
+          truncated: false,
+          digest: digestText(error93)
+        }
+      });
+      cleanupAsyncLaunchSession(args2.session, sessionId);
+      return failedLane(args2.lane, role, startedAt, error93, decision.slot.slotId, decision.slot.runId);
+    }
+    await appendDelegationTransition(args2.directory, sessionId, {
+      status: "running"
+    });
+    return {
+      id: args2.lane.id,
+      agent: args2.lane.agent,
+      role,
+      status: "pending",
+      session_id: sessionId,
+      slot_id: decision.slot.slotId,
+      run_id: decision.slot.runId,
+      started_at: startedAt,
+      completed_at: isoNow()
+    };
+  } catch (error93) {
+    return failedLane(args2.lane, role, startedAt, formatError3(error93), decision.slot.slotId, decision.slot.runId);
+  } finally {
+    args2.dispatcher.releaseSlot(decision.slot.slotId);
+  }
+}
+async function collectOnce(session, directory, records, cancelPending) {
+  for (const record3 of records) {
+    if (record3.status !== "pending" && record3.status !== "running")
+      continue;
+    if (cancelPending) {
+      if (typeof session.abort === "function") {
+        await session.abort({ path: { id: record3.subagentSessionId } }).catch(() => {
+          return;
+        });
+      }
+      await appendDelegationTransition(directory, record3.correlationId, {
+        status: "cancelled"
+      });
+      continue;
+    }
+    let messages;
+    try {
+      messages = await session.messages({
+        path: { id: record3.subagentSessionId },
+        query: { directory, limit: 50 }
+      });
+    } catch {
+      continue;
+    }
+    if (!messages.data)
+      continue;
+    const text = extractLastAssistantText(messages.data);
+    if (!text)
+      continue;
+    const bounded = boundLaneOutput(text);
+    await appendDelegationTransition(directory, record3.correlationId, {
+      status: "completed",
+      result: {
+        text: bounded.output,
+        chars: bounded.output_chars,
+        truncated: bounded.output_truncated,
+        digest: digestText(text)
+      }
+    });
+  }
+}
+function extractLastAssistantText(messages) {
+  for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+    const message = messages[i2];
+    if (message.info?.role !== "assistant")
+      continue;
+    const text = extractText3(message.parts);
+    if (text.trim().length > 0)
+      return text;
+  }
+  return "";
+}
+function nextCollectPollInterval(currentMs) {
+  if (currentMs <= 0)
+    return COLLECT_POLL_INTERVAL_MS;
+  return Math.min(currentMs * 2, MAX_COLLECT_POLL_INTERVAL_MS);
+}
 async function runLane(session, dispatcher, lane, directory, timeoutMs, context) {
   const validation2 = validateLaneAgent(lane.agent, context);
   const role = validation2.role;
@@ -125993,6 +126663,49 @@ function buildResult(laneResults, maxConcurrent, timeoutMs) {
     lane_results: laneResults
   };
 }
+function buildCollectResult(batchId, records, includePending) {
+  const laneResults = records.filter((record3) => includePending || record3.status !== "pending" && record3.status !== "running").map(recordToLaneResult);
+  const completed = records.filter((record3) => record3.status === "completed");
+  const failed = records.filter((record3) => record3.status === "error");
+  const cancelled = records.filter((record3) => record3.status === "cancelled");
+  const stale = records.filter((record3) => record3.status === "stale");
+  const pending = records.filter((record3) => record3.status === "pending" || record3.status === "running");
+  const consumed = records.filter((record3) => record3.status === "consumed");
+  return {
+    success: pending.length === 0 && failed.length === 0 && cancelled.length === 0 && stale.length === 0,
+    batch_id: batchId,
+    total: records.length,
+    completed: completed.length,
+    failed: failed.length,
+    cancelled: cancelled.length,
+    stale: stale.length,
+    pending: pending.length,
+    consumed: consumed.length,
+    all_settled: pending.length === 0,
+    lane_results: laneResults
+  };
+}
+function recordToLaneResult(record3) {
+  const status = record3.status === "error" ? "failed" : record3.status === "running" ? "pending" : record3.status;
+  return {
+    id: record3.laneId ?? record3.correlationId,
+    agent: record3.swarmPrefixedAgent,
+    role: record3.normalizedAgent,
+    status,
+    session_id: record3.subagentSessionId,
+    started_at: new Date(record3.createdAt).toISOString(),
+    completed_at: new Date(record3.completedAt ?? record3.updatedAt).toISOString(),
+    ...record3.result?.text !== undefined ? {
+      output: record3.result.text,
+      output_chars: record3.result.chars,
+      output_truncated: record3.result.truncated
+    } : {},
+    ...record3.result?.error !== undefined ? { error: record3.result.error } : {}
+  };
+}
+function allSettled(records) {
+  return records.every((record3) => record3.status !== "pending" && record3.status !== "running");
+}
 function failedLane(lane, role, startedAt, error93, slotId, runId, sessionId) {
   return {
     id: lane.id,
@@ -126095,6 +126808,40 @@ function failureResult(args2) {
     errors: args2.errors
   };
 }
+function asyncFailureResult(args2) {
+  return {
+    success: false,
+    failure_class: args2.failure_class,
+    message: args2.message,
+    batch_id: null,
+    dispatched: 0,
+    pending: 0,
+    failed: 0,
+    rejected: 0,
+    max_concurrent: 0,
+    timeout_ms: 0,
+    lane_results: [],
+    errors: args2.errors
+  };
+}
+function collectFailureResult(args2) {
+  return {
+    success: false,
+    failure_class: args2.failure_class,
+    message: args2.message,
+    batch_id: args2.batch_id,
+    total: 0,
+    completed: 0,
+    failed: 0,
+    cancelled: 0,
+    stale: 0,
+    pending: 0,
+    consumed: 0,
+    all_settled: false,
+    lane_results: [],
+    errors: args2.errors
+  };
+}
 function findDuplicateLaneIds(lanes) {
   const seen = new Set;
   const duplicates = new Set;
@@ -126110,6 +126857,14 @@ function scheduleSessionCleanup(session, sessionId) {
     return;
   });
 }
+function cleanupAsyncLaunchSession(session, sessionId) {
+  if (typeof session.abort === "function") {
+    session.abort({ path: { id: sessionId } }).catch(() => {
+      return;
+    });
+  }
+  scheduleSessionCleanup(session, sessionId);
+}
 async function withTimeout2(promise3, timeoutMs, message, controller) {
   let timeout;
   try {
@@ -126120,9 +126875,6 @@ async function withTimeout2(promise3, timeoutMs, message, controller) {
           controller?.abort();
           reject(new Error(message));
         }, timeoutMs);
-        if (typeof timeout.unref === "function") {
-          timeout.unref();
-        }
       })
     ]);
   } finally {
@@ -126150,6 +126902,29 @@ function boundErrorString(text) {
 function isoNow() {
   return new Date(_internals81.now()).toISOString();
 }
+function makeBatchId() {
+  return `lanes-${_internals81.now().toString(36)}`;
+}
+function promptHash(lane, directory, batchId) {
+  return digestText(JSON.stringify({
+    batchId,
+    laneId: lane.id,
+    agent: lane.agent,
+    directory,
+    prompt: lane.prompt.replace(/\r\n/g, `
+`)
+  }));
+}
+function digestText(text) {
+  return createHash16("sha256").update(text).digest("hex");
+}
+function sleep2(ms) {
+  if (ms <= 0)
+    return Promise.resolve();
+  return new Promise((resolve57) => {
+    setTimeout(resolve57, ms);
+  });
+}
 var dispatch_lanes = createSwarmTool({
   description: "Dispatch multiple read-only exploration/review lanes concurrently through OpenCode sessions and return a structured join result.",
   args: {
@@ -126164,12 +126939,53 @@ var dispatch_lanes = createSwarmTool({
     return JSON.stringify(result, null, 2);
   }
 });
+var dispatch_lanes_async = createSwarmTool({
+  description: "Launch multiple read-only advisory lanes with OpenCode promptAsync and return immediately with a batch id for collect_lane_results.",
+  args: {
+    lanes: DispatchLanesAsyncArgsSchema.shape.lanes,
+    max_concurrent: DispatchLanesAsyncArgsSchema.shape.max_concurrent,
+    timeout_ms: DispatchLanesAsyncArgsSchema.shape.timeout_ms,
+    batch_id: DispatchLanesAsyncArgsSchema.shape.batch_id,
+    mode: DispatchLanesAsyncArgsSchema.shape.mode,
+    pr_head_sha: DispatchLanesAsyncArgsSchema.shape.pr_head_sha,
+    scope: DispatchLanesAsyncArgsSchema.shape.scope
+  },
+  execute: async (args2, directory, ctx) => {
+    const result = await executeDispatchLanesAsync(args2, directory, {
+      callerAgent: getContextAgent(ctx),
+      sessionID: getContextSessionID(ctx)
+    });
+    return JSON.stringify(result, null, 2);
+  }
+});
+var collect_lane_results = createSwarmTool({
+  description: "Collect or poll results for a dispatch_lanes_async batch; this is the required join barrier for advisory lane workflows and does not advance workflow gates.",
+  args: {
+    batch_id: CollectLaneResultsArgsSchema.shape.batch_id,
+    wait: CollectLaneResultsArgsSchema.shape.wait,
+    timeout_ms: CollectLaneResultsArgsSchema.shape.timeout_ms,
+    include_pending: CollectLaneResultsArgsSchema.shape.include_pending,
+    cancel_pending: CollectLaneResultsArgsSchema.shape.cancel_pending
+  },
+  execute: async (args2, directory, ctx) => {
+    const result = await executeCollectLaneResults(args2, directory, {
+      sessionID: getContextSessionID(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;
 }
+function getContextSessionID(ctx) {
+  if (!ctx || typeof ctx !== "object")
+    return;
+  const value = ctx.sessionID;
+  return typeof value === "string" ? value : undefined;
+}
 
 // src/tools/manifest.ts
 init_doc_scan();
@@ -126850,11 +127666,11 @@ var external_skill_delete = createSwarmTool({
 // src/tools/external-skill-discover.ts
 init_zod();
 init_loader();
-import { createHash as createHash16, randomUUID as randomUUID12 } from "node:crypto";
+import { createHash as createHash18, randomUUID as randomUUID12 } from "node:crypto";
 
 // src/services/external-skill-validator.ts
 init_knowledge_validator();
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 var PROMPT_INJECTION_PATTERNS = [
   {
     pattern: /system\s*:/i,
@@ -127389,7 +128205,7 @@ function evaluateCandidate(candidate, options) {
 }
 var _internals84 = {
   getTimestamp: () => new Date().toISOString(),
-  computeSha256: (content) => createHash15("sha256").update(content).digest("hex"),
+  computeSha256: (content) => createHash17("sha256").update(content).digest("hex"),
   stripMarkdownCodeForUnsafeScan
 };
 
@@ -127411,7 +128227,7 @@ var _internals85 = {
     return { content, finalUrl: response.url };
   },
   getTimestamp: () => new Date().toISOString(),
-  computeSha256: (content) => createHash16("sha256").update(content).digest("hex"),
+  computeSha256: (content) => createHash18("sha256").update(content).digest("hex"),
   uuid: () => randomUUID12()
 };
 var SOURCE_TRUST_LEVELS = {
@@ -127797,7 +128613,7 @@ var external_skill_list = createSwarmTool({
 // src/tools/external-skill-promote.ts
 init_zod();
 init_loader();
-import { createHash as createHash17 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 import * as fs95 from "node:fs/promises";
 import * as path149 from "node:path";
 init_create_tool();
@@ -127962,7 +128778,7 @@ var external_skill_promote = createSwarmTool({
         }
         throw writeErr;
       }
-      const promotedContentHash = createHash17("sha256").update(skillMarkdown).digest("hex");
+      const promotedContentHash = createHash19("sha256").update(skillMarkdown).digest("hex");
       const prePromotionHistory = candidate.evaluation_history;
       const lastPrePromotionEntry = prePromotionHistory.length > 0 ? prePromotionHistory[prePromotionHistory.length - 1] : undefined;
       const originalEvaluation = lastPrePromotionEntry ? {
@@ -145435,7 +146251,7 @@ import * as zlib from "node:zlib";
 // src/evidence/documents.ts
 init_utils2();
 init_redaction();
-import { createHash as createHash19 } from "node:crypto";
+import { createHash as createHash21 } from "node:crypto";
 import { appendFile as appendFile17, mkdir as mkdir34 } from "node:fs/promises";
 import * as path189 from "node:path";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
@@ -145479,7 +146295,7 @@ function createEvidenceDocumentRecord(input, defaultCapturedAt) {
   };
 }
 function createEvidenceDocumentId(input) {
-  const hash4 = createHash19("sha256").update([
+  const hash4 = createHash21("sha256").update([
     input.sourceType,
     input.query ?? "",
     input.title ?? "",
@@ -147276,6 +148092,8 @@ var TOOL_MANIFEST = defineHandlers({
   swarm_memory_propose: () => swarm_memory_propose,
   swarm_command: () => swarm_command,
   dispatch_lanes: () => dispatch_lanes,
+  dispatch_lanes_async: () => dispatch_lanes_async,
+  collect_lane_results: () => collect_lane_results,
   summarize_work: () => summarize_work,
   write_architecture_supervisor_evidence: () => write_architecture_supervisor_evidence,
   lean_turbo_plan_lanes: () => lean_turbo_plan_lanes,