opencode-swarm 7.95.0 → 7.97.0

package/.opencode/skills/codebase-review-swarm/references/review-protocol-v8.2.md

@@ -128,7 +128,7 @@ Before writing under `.swarm/`, verify `.swarm/` is ignored or locally excluded.
 1. Run 0A alone.
 2. After 0A, run 0B and 0C through `dispatch_lanes_async` only if the repository is large enough to benefit. While those lanes run, the Architect continues deterministic inventory work that does not depend on their results.
 3. After 0B, run 0D and 0E through `dispatch_lanes_async` only if 0E can leave `linked_claims` blank for Architect linking in 0J. Otherwise run 0D before 0E.
-4. Preferred async batch order: batch 1 = 0F and 0G; batch 2 = 0H and 0I. Never exceed two Phase 0 agents.
+4. Preferred async batch order: batch 1 = 0F and 0G; batch 2 = 0H and 0I. Never exceed two Phase 0 agents — Phase 0 inventory units (0A→0J) form a largely sequential dependency chain, so concurrency is intentionally capped at 2 to respect that ordering rather than scaled toward the 8-lane dispatch limit.
 5. Run 0F after 0E when possible.
 6. Run 0G after 0B and 0C.
 7. Run 0H and 0I after 0B and 0C.

package/.opencode/skills/council/SKILL.md

@@ -114,8 +114,10 @@ Do NOT share other agents' responses at this stage.
    (synthesis outline, citation normalization, disagreement categories). Only
    use `wait: true` if lanes are still pending and no more independent work
    remains. All three lanes must be settled before proceeding to synthesis.
-   If `dispatch_lanes_async` is unavailable, use blocking parallel dispatch
-   and record that async advisory lanes were unavailable. The
+   If `dispatch_lanes_async` is unavailable, use blocking `dispatch_lanes`
+   and record that async advisory lanes were unavailable; do not substitute
+   per-agent Task calls for this fallback unless lane tools are unavailable and
+   you explicitly verify equivalent agent type, prompt, scope, and isolation. The
    `round1Responses` array will contain entries with `memberId` of
    `council_generalist`, `council_skeptic`, and `council_domain_expert` and
    `role` of `generalist`, `skeptic`, and `domain_expert` respectively. If

package/.opencode/skills/deep-dive/SKILL.md

@@ -18,7 +18,7 @@ Read-only deep audit of a specified codebase scope using parallel explorer waves
 Parse the MODE: DEEP_DIVE header to extract:
 - `scope`: the codebase area to audit (e.g., "auth", "payment flow", "src/hooks/")
 - `profile`: one of standard | security | ux | architecture | full (default: standard)
-- `max_explorers`: integer 1..8 (default: 6, or 8 for full profile)
+- `max_explorers`: integer 1..8 — upper bound on explorer waves (default: 6, or 8 for full profile). This is a CAP, not a fixed count: scale the actual wave size to the resolved scope surface — a trivial scope needs 1–2 explorers, a typical scope 3–5, a large multi-module scope up to the cap — never fix the count in advance.
 - `output`: markdown | json (default: markdown)
 - `update_main`: boolean (default: true) — whether to fetch/ff-only main before starting
 - `allow_dirty`: boolean (default: false) — whether to proceed with uncommitted changes
@@ -52,6 +52,8 @@ Dispatch explorer waves with `dispatch_lanes_async` when available. Each wave co
 - ~3500 total lines across all files in a mission
 - Group files by import proximity (files that import each other go in the same mission)
 
+**Partition is the contract:** missions own non-overlapping file sets — no file appears in two missions — and the union of all missions must cover every file in the Step 2 scope map. Any scope-map file not assigned to a mission is an explicit coverage gap, not an optional skip.
+
 **Profile-based lane selection — each profile activates specific lanes:**
 
 | Lane | Template | standard | security | ux | architecture | full |

package/.opencode/skills/deep-research/SKILL.md

@@ -118,13 +118,19 @@ include:
 - `OUTPUT`: claims with evidence refs, contradictions noted, confidence (0–1)
 - `SKILLS: none`
 
-The sme synthesizes only from the provided evidence — it does not fetch. Before
-Step 5, call `collect_lane_results` with `wait: true` for every open synthesis
-batch. Collect all completed worker responses into a candidate findings set, each
-finding tagged with its subtopic, evidence refs, and the worker's confidence.
-Treat missing, stale, cancelled, or failed lanes as explicit coverage gaps. If
-`dispatch_lanes_async` is unavailable, use blocking parallel dispatch and record
-that async advisory lanes were unavailable.
+The sme synthesizes only from the provided evidence — it does not fetch. While
+synthesis lanes run, poll with `collect_lane_results` without `wait` (or
+`wait: false`) to process completed worker responses as they settle while
+continuing independent architect work between polls. Before Step 5, call
+`collect_lane_results` with `wait: true` for every open synthesis batch only if
+lanes are still pending and no independent work remains. Do not advance to Step 5
+until every synthesis lane is settled. Collect all completed worker responses into
+a candidate findings set, each finding tagged with its subtopic, evidence refs,
+and the worker's confidence. Treat missing, stale, cancelled, or failed lanes as
+explicit coverage gaps. If `dispatch_lanes_async` is unavailable, use blocking
+`dispatch_lanes` and record that async advisory lanes were unavailable; do not
+substitute per-agent Task calls for this fallback unless lane tools are unavailable
+and you explicitly verify equivalent agent type, prompt, scope, and isolation.
 
 ## Step 5 — Dual-Reviewer Claim Verification
 

package/.opencode/skills/execute/SKILL.md

@@ -204,9 +204,9 @@ This step supplements (not replaces) the existing regression-sweep and test-drif
 
 ## Dispatch-lanes empty-output fallback
 
-When an agent dispatched via `dispatch_lanes` returns empty output (0 chars, `output_digest` matching SHA-256 of empty string `e3b0c442...b855`), this indicates a suspected incompatibility between the `dispatch_lanes` code path and that specific agent.
+This fallback applies only to a settled, blocking `dispatch_lanes` result with empty output (0 chars, `output_digest` matching SHA-256 of empty string `e3b0c442...b855`). It does **not** apply to `dispatch_lanes_async` rows that are still pending/running, an early `collect_lane_results` poll, or an async result whose full text is available through `retrieve_lane_output`.
 
-**Do NOT re-dispatch via `dispatch_lanes`** — it will fail again (confirmed pattern). Immediately retry the **same agent** via the **Task tool** (`Task(subagent_type=..., prompt=...)`), which uses a different session-creation code path. Record which dispatch mechanism succeeded for debugging.
+For read-only advisory lanes, do **not** jump straight to Task. First re-collect async lanes with `collect_lane_results` (`wait: true` when no independent work remains) and inspect any `output_ref` with `retrieve_lane_output`. If a settled blocking `dispatch_lanes` lane is genuinely empty, prefer retrying the same agent through `dispatch_lanes_async` when promptAsync is available. Use the **Task tool** (`Task(subagent_type=..., prompt=...)`) only as a last-resort equivalent dispatch mechanism after the lane tools are unavailable or have produced a confirmed empty settled result; record the same agent, same prompt, same scope, and which dispatch mechanism succeeded.
 
 If the Task tool also returns empty, **then** escalate to substitute review (4-member council without the broken agent) or surface to the user. Never fabricate or substitute a verdict for the missing agent.
 

package/.opencode/skills/pre-phase-briefing/SKILL.md

@@ -42,15 +42,31 @@ This briefing is a HARD REQUIREMENT for ALL phases. Skipping it is a process vio
 
 ### CODEBASE REALITY CHECK (Required Before Speccing or Planning)
 
-Before any spec generation, plan creation, or plan ingestion begins, the Architect must dispatch the Explorer agent in targeted, scoped chunks — one per logical area of the codebase referenced by the work (e.g., per module, per hook, per config surface). Each chunk must be explored with full depth rather than a broad surface pass.
+Before any spec generation, plan creation, or plan ingestion begins, the Architect must verify the codebase reality of every item the work references. This runs as **asynchronous, fanned-out Explorer lanes by default**, joined behind a hard settlement gate — never as a single blocking explorer call, and never as fire-and-forget.
 
-For each scoped chunk, Explorer must determine:
+**1. Enumerate and partition the references (before dispatch).**
+List every referenced item — file, module, function, API, config surface, and behavioral assumption — named or implied by the spec, the user request, or the plan. Partition them into **non-overlapping** lane assignments. The partition is the contract: no two lanes may share a reference (this prevents duplicated work), and the **union of all lanes must cover every referenced item** (this prevents gaps). Under-specified lane boundaries are the dominant fan-out failure mode — be explicit about what each lane owns.
+
+**2. Scale the number of lanes to the size of the referenced surface.**
+- Trivial surface (a single file/function, one logical area) → **1 lane**.
+- Typical phase spanning a few areas → **2–4 lanes**.
+- Large surface (many modules/hooks/config surfaces) → **more lanes, up to the dispatch cap of 8 lanes per batch**.
+
+Do not fix the lane count in advance and do not over-spawn: extra lanes on a small surface waste tokens without improving coverage, while too few on a large surface leave gaps. Split by codebase area by default; when the surface is a single dense area, split by check-type instead — one lane for *existence & current state*, one for *assumption correctness & prior-work*.
+
+**3. Dispatch asynchronously, then keep working.**
+Dispatch the lanes with `dispatch_lanes_async`, record the returned `batch_id`, and continue **non-dependent** Architect work while they run — digest the retrospective and `user_directives`, review the spec/plan text for internal consistency, check governance/QA-gate config and the obligation ledger, and prepare the plan skeleton / task decomposition. This is dispatch-and-keep-busy, not fire-and-forget. Poll with `collect_lane_results` (wait omitted or false) to process settled lanes incrementally, or join with `wait: true` once independent work is exhausted.
+
+Each lane must be given: its objective, its named (disjoint) reference subset, the fixed REALITY-CHECK output format below, and clear boundaries. Lanes are read-only — they cannot `declare_scope` or mutate the worktree.
+
+**4. For each referenced item, the lane must determine:**
 - Does this file/module/function already exist?
 - If it exists, what is its current state? Does it already implement any part of what the plan or spec describes?
 - Is the plan's or user's assumption about the current state accurate? Flag any discrepancy between what is expected and what actually exists.
 - Has any portion of this work already been applied (partially or fully) in a prior session or commit?
 
-Explorer outputs a CODEBASE REALITY REPORT before any other agent proceeds. The report must list every referenced item with one of:
+**5. Hard settlement gate (join before any downstream work).**
+The Architect synthesizes the lane outputs into a single CODEBASE REALITY REPORT. The report must list every referenced item with one of:
   NOT STARTED | PARTIALLY DONE | ALREADY COMPLETE | ASSUMPTION INCORRECT
 
 Format:
@@ -59,11 +75,11 @@ Format:
     ✗ src/services/status-service.ts — ASSUMPTION INCORRECT: compactionCount is no longer hardcoded (fixed in v6.29.1)
     ✓ src/config/evidence-schema.ts — confirmed phase_number min(1)
 
-No implementation agent (coder, reviewer, test-engineer) may begin until this report is finalized.
+No spec finalization, plan generation, plan ingestion, `declare_scope`, or implementation-agent dispatch (coder, reviewer, test-engineer) may begin until ALL lanes in the batch are settled (`collect_lane_results` reports `all_settled`) AND this report is finalized. A lane that is missing, failed, or timed out is an explicit coverage gap, not a pass: mark the affected references BLOCKED or SKIPPED_WITH_REASON and resolve them before proceeding — never silently continue. Async dispatch changes *when* the Architect waits, never *whether* the gate holds.
 
 This check fires automatically in:
 - MODE: SPECIFY — before explorer dispatch for context (step 2)
 - MODE: PLAN — before plan generation or validation
 - EXTERNAL PLAN IMPORT PATH — before parsing the provided plan
 
-GREENFIELD EXEMPTION: If the work is purely greenfield (new project, no existing codebase references), skip this check.
+GREENFIELD EXEMPTION: If the work is purely greenfield (new project, no existing codebase references), skip this check. A trivial single-area surface stays a single lane rather than being force-fanned.

package/.opencode/skills/swarm-pr-feedback/SKILL.md

@@ -198,15 +198,27 @@ If a source is unavailable, retry with alternative access paths. If unavailable
 After the complete feedback ledger exists and before editing, use
 `dispatch_lanes_async` when available for independent read-only verification lanes:
 comment classification, CI/log root-cause inspection, test impact mapping,
-release/docs claim checks, and stale-branch/conflict analysis. Record each
-returned `batch_id`, then continue only ledger-safe architect work: normalize
-feedback IDs, gather deterministic PR metadata, prepare reproduction commands,
-and plan likely fix groups. Do not edit, close items, or mark feedback resolved
-from running lanes.
+release/docs claim checks, and stale-branch/conflict analysis. Partition the
+ledger so each `FB-###` item is owned by exactly one verification lane and the
+union of lanes covers the entire ledger — no feedback item may be left
+unassigned to a lane; state each lane's owned `FB-###` range in its prompt. Scale
+the lane count to the ledger size: a 1–3 item round may use a single combined
+lane, while a large multi-round intake may warrant one lane per category above.
+Cap each `dispatch_lanes_async` batch at 8 lanes (`MAX_LANES`); if the ledger
+needs more than 8 verification lanes, dispatch in sequential batches and settle
+each batch's COVERAGE GATE before the next — do not over-spawn lanes for a
+trivial round. Record each returned `batch_id`, then continue only ledger-safe
+architect work: normalize feedback IDs, gather deterministic PR metadata, prepare
+reproduction commands, and plan likely fix groups. Do not edit, close items, or
+mark feedback resolved from running lanes.
 
 Before the Verification step can mark any item `RESOLVED`, `DISPROVED`,
-`PRE_EXISTING`, `NEEDS_MORE_EVIDENCE`, or `NEEDS_USER_DECISION`, call
-`collect_lane_results` with `wait: true` for every open verification batch.
+`PRE_EXISTING`, `NEEDS_MORE_EVIDENCE`, or `NEEDS_USER_DECISION`, every open
+verification batch must be fully settled. Poll with `collect_lane_results` (wait
+omitted or `false`) to process settled lanes incrementally — clustering confirmed
+items and pre-reading files for settled findings while ledger-safe work remains —
+then issue a final `collect_lane_results` with `wait: true` per batch once
+independent work is exhausted, to confirm every lane is settled.
 Missing, stale, cancelled, or failed lanes are coverage gaps that must be closed
 before marking any item RESOLVED/DISPROVED/PRE_EXISTING. Apply the COVERAGE GATE:
 retry failed lanes (max 2), deploy a verified equivalent alternative (same agent

package/.opencode/skills/swarm-pr-review/SKILL.md

@@ -517,7 +517,7 @@ Before Phase 4 or synthesis, all base lanes must be settled. `dispatch_lanes_asy
 
 For ANY lane that failed (either mode):
 1. **Retry** (max 2 attempts) with materially different parameters — different session, different prompt decomposition, or blocking `dispatch_lanes`.
-2. If retries fail, **deploy an equivalent alternative** and **verify equivalence**: same agent type, same prompt, same scope, same isolation. State the equivalence verification explicitly. Different dispatch mechanism (e.g., Task tool instead of `dispatch_lanes_async`) IS acceptable when these criteria are met. Use `retrieve_lane_output` to inspect the full artifact before declaring equivalence or failure.
+2. If retries fail, **deploy an equivalent alternative** and **verify equivalence**: same agent type, same prompt, same scope, same isolation. State the equivalence verification explicitly. Task is not an early-poll or empty-partial-output fallback; use it only as a last-resort equivalent dispatch mechanism after `dispatch_lanes_async` is unavailable or a settled lane result is confirmed failed/empty, and after blocking `dispatch_lanes` is unavailable or inappropriate. Use `retrieve_lane_output` to inspect the full artifact before declaring equivalence or failure.
 3. If no equivalent alternative can be verified, **report to the user as INCOMPLETE**. Present partial findings from successful lanes alongside the INCOMPLETE verdict. The user decides whether to accept reduced coverage. The architect NEVER makes that call.
 
 ### Candidate extraction via parser
@@ -558,6 +558,8 @@ in the same batch unless intentionally replacing that exact lane before dispatch
 
 Explorers optimize for recall. Over-reporting is expected. Explorers produce candidates only.
 
+The six lanes are a fixed **check-type** partition (correctness / security / deps / docs / tests / performance), not an area partition: the count is intentionally constant — every PR needs all six review dimensions — and the lanes deliberately overlap by file, each receiving the same diff via `common_prompt` and viewing it through a different lens. This is the deliberate exception to surface-scaled fan-out: the base wave is a fixed six by design, never collapsed or expanded with the size of the change. Coverage is guaranteed by the six dimensions each reading the whole diff, not by partitioning files across lanes — so the disjoint-partition rule that governs area-split fan-outs does not apply to these check-type lanes.
+
 | Lane | Focus | Required checks |
 |---|---|---|
 | Lane 1: Correctness and edge cases | Logic errors, null/undefined handling, incorrect operators, async ordering, races, off-by-one, error paths | input domain, nullability, async/await, loop termination, exception behavior, backward compatibility |

package/dist/cli/{config-doctor-n5w1jexx.js → config-doctor-h1xrvq83.js}

@@ -12,8 +12,8 @@ import {
   shouldRunOnStartup,
   writeBackupArtifact,
   writeDoctorArtifact
-} from "./index-tht37da9.js";
-import"./index-w015kchv.js";
+} from "./index-xx3sv77e.js";
+import"./index-tqbb2jx6.js";
 import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
 import"./index-zgwm4ryv.js";

package/dist/cli/{evidence-summary-service-mr9sns2d.js → evidence-summary-service-g4x5e3e3.js}

@@ -6,7 +6,7 @@ import {
   loadPlanJsonOnly,
   mergeDurableGateEntriesFromEvidence,
   readDurableGateEvidence
-} from "./index-y1z6yaq4.js";
+} from "./index-4c5jpmn9.js";
 import"./index-mh1ej70w.js";
 import"./index-kv4dd5c5.js";
 import"./index-gn8n22th.js";

package/dist/cli/{guardrail-explain-1ad236sh.js → guardrail-explain-t6svvtmn.js}

@@ -1,15 +1,15 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-0xkf7xn2.js";
-import"./index-wz5ex5q7.js";
-import"./index-c7xgx041.js";
+} from "./index-a9ghr5cx.js";
+import"./index-sgdr2e4n.js";
+import"./index-b223mczb.js";
 import"./index-2a6ppa65.js";
 import"./index-fjxjb66n.js";
 import"./index-hb10a2g8.js";
-import"./index-tht37da9.js";
-import"./index-w015kchv.js";
-import"./index-y1z6yaq4.js";
+import"./index-xx3sv77e.js";
+import"./index-tqbb2jx6.js";
+import"./index-4c5jpmn9.js";
 import"./index-adz3nk9b.js";
 import"./index-v4fcn4tr.js";
 import"./index-mh1ej70w.js";

package/dist/cli/{guardrail-log-0v924awy.js → guardrail-log-9yyeccv5.js}

@@ -1,9 +1,9 @@
 // @bun
 import {
   handleGuardrailLog
-} from "./index-5zwr6xz4.js";
-import"./index-c7xgx041.js";
-import"./index-w015kchv.js";
+} from "./index-rdc6nvmw.js";
+import"./index-b223mczb.js";
+import"./index-tqbb2jx6.js";
 import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
 import"./index-zgwm4ryv.js";

package/dist/cli/{index-y1z6yaq4.js → index-4c5jpmn9.js}

@@ -2236,7 +2236,7 @@ async function loadPlan(directory) {
                       await rebuildPlan(directory, rebuilt, {
                         reason: "ledger_hash_mismatch_recovery"
                       });
-                      warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at .swarm/SWARM_PLAN.md if it exists.");
+                      warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at .swarm/plan-export/SWARM_PLAN.md if it exists.");
                       return rebuilt;
                     }
                   } catch (replayError) {
@@ -2259,7 +2259,7 @@ async function loadPlan(directory) {
                         return approved.plan;
                       }
                     } catch {}
-                    warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check .swarm/SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
+                    warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check .swarm/plan-export/SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
                   }
                 }
               }
@@ -2306,7 +2306,7 @@ async function loadPlan(directory) {
           return validated;
         }
       } catch (error2) {
-        warn(`[loadPlan] plan.json validation failed: ${error2 instanceof Error ? error2.message : String(error2)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/SWARM_PLAN.md for a checkpoint.`);
+        warn(`[loadPlan] plan.json validation failed: ${error2 instanceof Error ? error2.message : String(error2)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/plan-export/SWARM_PLAN.md for a checkpoint.`);
         let rawPlanId = null;
         try {
           const rawParsed = JSON.parse(planJsonContent);

package/dist/cli/{index-0xkf7xn2.js → index-a9ghr5cx.js}

@@ -12,14 +12,14 @@ import {
   detectPosixWrites,
   detectWindowsWrites,
   resolveWriteTargets
-} from "./index-wz5ex5q7.js";
+} from "./index-sgdr2e4n.js";
 import {
   checkFileAuthority,
   classifyFile,
   isInDeclaredScope,
   redactPath,
   redactShellCommand
-} from "./index-c7xgx041.js";
+} from "./index-b223mczb.js";
 
 // src/services/guardrail-explain-service.ts
 import path from "path";

package/dist/cli/{index-c7xgx041.js → index-b223mczb.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   stripKnownSwarmPrefix
-} from "./index-w015kchv.js";
+} from "./index-tqbb2jx6.js";
 import {
   init_logger,
   warn

package/dist/cli/{index-7d38zerp.js → index-byb9tgay.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-0xkf7xn2.js";
+} from "./index-a9ghr5cx.js";
 import {
   handleGuardrailLog
-} from "./index-5zwr6xz4.js";
+} from "./index-rdc6nvmw.js";
 import {
   COMMAND_REGISTRY,
   SWARM_COMMAND_TOOL_ALLOWLIST,
@@ -78,18 +78,18 @@ import {
   handleWriteRetroCommand,
   normalizeSwarmCommandInput,
   resolveCommand
-} from "./index-wz5ex5q7.js";
-import"./index-c7xgx041.js";
+} from "./index-sgdr2e4n.js";
+import"./index-b223mczb.js";
 import"./index-2a6ppa65.js";
 import"./index-fjxjb66n.js";
 import"./index-hb10a2g8.js";
-import"./index-tht37da9.js";
+import"./index-xx3sv77e.js";
 import {
   AGENT_TOOL_MAP,
   ORCHESTRATOR_NAME,
   stripKnownSwarmPrefix
-} from "./index-w015kchv.js";
-import"./index-y1z6yaq4.js";
+} from "./index-tqbb2jx6.js";
+import"./index-4c5jpmn9.js";
 import"./index-adz3nk9b.js";
 import"./index-v4fcn4tr.js";
 import"./index-mh1ej70w.js";

package/dist/cli/{index-5zwr6xz4.js → index-rdc6nvmw.js}

@@ -2,7 +2,7 @@
 import {
   redactPath,
   redactShellCommand
-} from "./index-c7xgx041.js";
+} from "./index-b223mczb.js";
 
 // src/services/guardrail-log-service.ts
 import * as fs from "fs/promises";

package/dist/cli/{index-wz5ex5q7.js → index-sgdr2e4n.js}

@@ -57,7 +57,7 @@ import {
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-tht37da9.js";
+} from "./index-xx3sv77e.js";
 import {
   AGENT_TOOL_MAP,
   ALL_SUBAGENT_NAMES,
@@ -70,7 +70,7 @@ import {
   TOOL_NAME_SET,
   resolveExternalSkillsConfig,
   stripKnownSwarmPrefix
-} from "./index-w015kchv.js";
+} from "./index-tqbb2jx6.js";
 import {
   MAX_TRANSIENT_RETRIES,
   PlanSchema,
@@ -114,7 +114,7 @@ import {
   transientBackoff,
   validateProjectRoot,
   writeProjectedSpecSync
-} from "./index-y1z6yaq4.js";
+} from "./index-4c5jpmn9.js";
 import {
   _internals as _internals2,
   _internals1 as _internals3,
@@ -909,7 +909,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.95.0",
+  version: "7.97.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",
@@ -13070,7 +13070,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-qz5mgmz3.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-a8fneygm.js");
     const { config: pmLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -13351,6 +13351,8 @@ async function runCleanStage(ctx) {
   }
   let swarmPlanFilesRemoved = 0;
   const candidates = [
+    path25.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.json"),
+    path25.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.md"),
     path25.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
     path25.join(ctx.directory, ".swarm", "SWARM_PLAN.md"),
     path25.join(ctx.directory, "SWARM_PLAN.json"),
@@ -13630,7 +13632,7 @@ This project was already finalized in a previous /swarm close run. The plan has
         `- Removed ${cleanResult.configBackupsRemoved} stale config backup file(s)`
       ] : [],
       ...cleanResult.swarmPlanFilesRemoved > 0 ? [
-        `- Removed ${cleanResult.swarmPlanFilesRemoved} SWARM_PLAN checkpoint artifact(s)`
+        `- Removed ${cleanResult.swarmPlanFilesRemoved} SWARM_PLAN checkpoint artifact(s) from .swarm/plan-export/ and legacy locations`
       ] : [],
       ...ctx.planExists && !ctx.planAlreadyDone ? ["- Set non-completed phases/tasks to closed status"] : [],
       ...ctx.curationSucceeded && ctx.allLessons.length > 0 ? [`- Committed ${ctx.allLessons.length} lesson(s) to knowledge store`] : [],
@@ -16791,7 +16793,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-n5w1jexx.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-h1xrvq83.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true);
     output = formatDoctorMarkdown(fixResult.result);
   } else {
@@ -17604,7 +17606,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-mr9sns2d.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-g4x5e3e3.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -29819,7 +29821,7 @@ async function handleResetCommand(directory, args) {
     return [
       "## Swarm Reset",
       "",
-      "\u26A0\uFE0F This will delete all swarm state from .swarm/ (plan, context, checkpoints, SWARM_PLAN artifacts)",
+      "\u26A0\uFE0F This will delete all swarm state from .swarm/ (plan, context, checkpoints, SWARM_PLAN artifacts including .swarm/plan-export/)",
       "",
       "**Tip**: Run `/swarm export` first to backup your state.",
       "",
@@ -29833,6 +29835,8 @@ async function handleResetCommand(directory, args) {
     "context.md",
     "SWARM_PLAN.md",
     "SWARM_PLAN.json",
+    "plan-export/SWARM_PLAN.md",
+    "plan-export/SWARM_PLAN.json",
     "checkpoints.json",
     "events.jsonl"
   ];
@@ -31853,7 +31857,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-7d38zerp.js");
+    const { buildHelpText } = await import("./index-byb9tgay.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -31862,7 +31866,7 @@ async function handleHelpCommand(ctx) {
     return _internals45.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals45.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-7d38zerp.js");
+  const { buildHelpText: fullHelp } = await import("./index-byb9tgay.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -31995,7 +31999,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-1ad236sh.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-t6svvtmn.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -32005,7 +32009,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-0v924awy.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-9yyeccv5.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",

package/dist/cli/{index-w015kchv.js → index-tqbb2jx6.js}

@@ -552,11 +552,11 @@ var TOOL_METADATA = {
     agents: ["architect"]
   },
   dispatch_lanes_async: {
-    description: "launch read-only advisory lanes non-blockingly and return a batch id immediately so you can keep working; poll incrementally with collect_lane_results (wait omitted or false) while doing independent investigation, or join with wait: true when you need all results",
+    description: "launch read-only advisory lanes non-blockingly and return a batch id plus lane session handles immediately so you can keep working; launch_timeout_ms is only a promptAsync acceptance budget, not a lane runtime timeout; poll incrementally with collect_lane_results (wait omitted or false) while doing independent investigation, or join with wait: true when you need all results",
     agents: ["architect"]
   },
   collect_lane_results: {
-    description: "collect or poll results for a dispatch_lanes_async batch; supports both non-blocking polling (wait omitted or false) and blocking join (wait: true). Use non-blocking polls to check progress and process settled lanes incrementally while continuing independent work; use blocking join only when you need all lanes settled before proceeding. Does not advance workflow gates.",
+    description: "collect or poll results for a dispatch_lanes_async batch; supports both non-blocking polling (wait omitted or false) and blocking join (wait: true). Non-blocking polls include pending lane identities by default and process settled lanes incrementally while continuing independent work; busy/retry lanes are not timed out just because they run for a long time. Does not advance workflow gates.",
     agents: ["architect"]
   },
   summarize_work: {

package/dist/cli/{index-tht37da9.js → index-xx3sv77e.js}

@@ -3,7 +3,7 @@ import {
   ALL_AGENT_NAMES,
   PluginConfigSchema,
   stripKnownSwarmPrefix
-} from "./index-w015kchv.js";
+} from "./index-tqbb2jx6.js";
 import {
   log
 } from "./index-zgwm4ryv.js";

package/dist/cli/index.js

@@ -7,16 +7,16 @@ import {
   getPluginLockFilePaths,
   package_default,
   resolveCommand
-} from "./index-wz5ex5q7.js";
-import"./index-c7xgx041.js";
+} from "./index-sgdr2e4n.js";
+import"./index-b223mczb.js";
 import"./index-2a6ppa65.js";
 import"./index-fjxjb66n.js";
 import"./index-hb10a2g8.js";
-import"./index-tht37da9.js";
+import"./index-xx3sv77e.js";
 import {
   DEFAULT_AGENT_CONFIGS
-} from "./index-w015kchv.js";
-import"./index-y1z6yaq4.js";
+} from "./index-tqbb2jx6.js";
+import"./index-4c5jpmn9.js";
 import"./index-adz3nk9b.js";
 import"./index-v4fcn4tr.js";
 import"./index-mh1ej70w.js";

package/dist/cli/{schema-qz5mgmz3.js → schema-a8fneygm.js}

@@ -81,7 +81,7 @@ import {
   resolveGeneratedAgentRole,
   resolveGuardrailsConfig,
   stripKnownSwarmPrefix
-} from "./index-w015kchv.js";
+} from "./index-tqbb2jx6.js";
 import"./index-p0arc26j.js";
 import"./index-293f68mj.js";
 import"./index-a76rekgs.js";

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.95.0",
+    version: "7.97.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",
@@ -729,11 +729,11 @@ var init_tool_metadata = __esm(() => {
       agents: ["architect"]
     },
     dispatch_lanes_async: {
-      description: "launch read-only advisory lanes non-blockingly and return a batch id immediately so you can keep working; poll incrementally with collect_lane_results (wait omitted or false) while doing independent investigation, or join with wait: true when you need all results",
+      description: "launch read-only advisory lanes non-blockingly and return a batch id plus lane session handles immediately so you can keep working; launch_timeout_ms is only a promptAsync acceptance budget, not a lane runtime timeout; poll incrementally with collect_lane_results (wait omitted or false) while doing independent investigation, or join with wait: true when you need all results",
       agents: ["architect"]
     },
     collect_lane_results: {
-      description: "collect or poll results for a dispatch_lanes_async batch; supports both non-blocking polling (wait omitted or false) and blocking join (wait: true). Use non-blocking polls to check progress and process settled lanes incrementally while continuing independent work; use blocking join only when you need all lanes settled before proceeding. Does not advance workflow gates.",
+      description: "collect or poll results for a dispatch_lanes_async batch; supports both non-blocking polling (wait omitted or false) and blocking join (wait: true). Non-blocking polls include pending lane identities by default and process settled lanes incrementally while continuing independent work; busy/retry lanes are not timed out just because they run for a long time. Does not advance workflow gates.",
       agents: ["architect"]
     },
     summarize_work: {
@@ -20500,7 +20500,7 @@ async function loadPlan(directory) {
                       await rebuildPlan(directory, rebuilt, {
                         reason: "ledger_hash_mismatch_recovery"
                       });
-                      warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at .swarm/SWARM_PLAN.md if it exists.");
+                      warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at .swarm/plan-export/SWARM_PLAN.md if it exists.");
                       return rebuilt;
                     }
                   } catch (replayError) {
@@ -20523,7 +20523,7 @@ async function loadPlan(directory) {
                         return approved.plan;
                       }
                     } catch {}
-                    warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check .swarm/SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
+                    warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check .swarm/plan-export/SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
                   }
                 }
               }
@@ -20570,7 +20570,7 @@ async function loadPlan(directory) {
           return validated;
         }
       } catch (error49) {
-        warn(`[loadPlan] plan.json validation failed: ${error49 instanceof Error ? error49.message : String(error49)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/SWARM_PLAN.md for a checkpoint.`);
+        warn(`[loadPlan] plan.json validation failed: ${error49 instanceof Error ? error49.message : String(error49)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/plan-export/SWARM_PLAN.md for a checkpoint.`);
         let rawPlanId = null;
         try {
           const rawParsed = JSON.parse(planJsonContent);
@@ -73548,6 +73548,8 @@ async function runCleanStage(ctx) {
   }
   let swarmPlanFilesRemoved = 0;
   const candidates = [
+    path60.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.json"),
+    path60.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.md"),
     path60.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
     path60.join(ctx.directory, ".swarm", "SWARM_PLAN.md"),
     path60.join(ctx.directory, "SWARM_PLAN.json"),
@@ -73827,7 +73829,7 @@ This project was already finalized in a previous /swarm close run. The plan has
         `- Removed ${cleanResult.configBackupsRemoved} stale config backup file(s)`
       ] : [],
       ...cleanResult.swarmPlanFilesRemoved > 0 ? [
-        `- Removed ${cleanResult.swarmPlanFilesRemoved} SWARM_PLAN checkpoint artifact(s)`
+        `- Removed ${cleanResult.swarmPlanFilesRemoved} SWARM_PLAN checkpoint artifact(s) from .swarm/plan-export/ and legacy locations`
       ] : [],
       ...ctx.planExists && !ctx.planAlreadyDone ? ["- Set non-completed phases/tasks to closed status"] : [],
       ...ctx.curationSucceeded && ctx.allLessons.length > 0 ? [`- Committed ${ctx.allLessons.length} lesson(s) to knowledge store`] : [],
@@ -96336,7 +96338,7 @@ async function handleResetCommand(directory, args2) {
     return [
       "## Swarm Reset",
       "",
-      "⚠️ This will delete all swarm state from .swarm/ (plan, context, checkpoints, SWARM_PLAN artifacts)",
+      "⚠️ This will delete all swarm state from .swarm/ (plan, context, checkpoints, SWARM_PLAN artifacts including .swarm/plan-export/)",
       "",
       "**Tip**: Run `/swarm export` first to backup your state.",
       "",
@@ -96350,6 +96352,8 @@ async function handleResetCommand(directory, args2) {
     "context.md",
     "SWARM_PLAN.md",
     "SWARM_PLAN.json",
+    "plan-export/SWARM_PLAN.md",
+    "plan-export/SWARM_PLAN.json",
     "checkpoints.json",
     "events.jsonl"
   ];
@@ -101929,7 +101933,7 @@ If a tool modifies a file, it is a CODER tool. Delegate.
 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.
    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.
-   Read-only advisory-lane exception (NON-BLOCKING; distinct from both exceptions above): the "Send, STOP, wait" rule governs MUTATION delegations (coder, and the test_engineer/reviewer Stage B completion gates). It does NOT govern read-only advisory exploration/review lanes. When you dispatch read-only advisory lanes — \`{{AGENT_PREFIX}}explorer\`, \`{{AGENT_PREFIX}}sme\`, \`{{AGENT_PREFIX}}researcher\`, the council members (\`council_generalist\`/\`council_skeptic\`/\`council_domain_expert\`), or an advisory \`{{AGENT_PREFIX}}critic\` lane — use the NON-BLOCKING path so you keep working while they run. Dispatch PROMPTLY: emit the \`dispatch_lanes_async\` call EARLY with compact lane prompts — do not accumulate long planning prose or build oversized inline prompts first, or the tool call can be truncated out of your message and the lanes never launch (a real failure mode on smaller models). The lane mechanism is a SINGLE \`dispatch_lanes_async\` call carrying all lane specs — NOT a per-agent Task/run-in-background pattern. Call \`dispatch_lanes_async\` with all lane specs in one call, record the returned \`batch_id\`, then IMMEDIATELY continue non-dependent architect work (refine the plan/obligation ledger, inspect metadata, prepare the synthesis/reviewer structure, run deterministic read-only tools). Do NOT sit idle waiting on running lanes, and do NOT synthesize findings from still-running lanes. Join later by calling \`collect_lane_results\` with \`wait: true\` as the explicit barrier immediately before you synthesize. Use blocking \`dispatch_lanes\` only when \`dispatch_lanes_async\`/promptAsync is unavailable. Keep each lane prompt compact: send large shared context (PR diff, ledger, scope) ONCE via the \`common_prompt\` field, or have lanes read it from a file by absolute path, instead of inlining the same blob into every lane prompt — inlining large context into many lanes is what produces malformed or truncated tool-call JSON and forces clumsy file workarounds. This non-blocking exception applies ONLY to read-only advisory lanes; it NEVER applies to coder delegations, to the test_engineer/reviewer Stage B completion gates, or to the critic PLAN-review gate, which all still follow "Send, STOP, wait" (or the Stage B parallel-dispatch exception above).
+   Read-only advisory-lane exception (NON-BLOCKING; distinct from both exceptions above): the "Send, STOP, wait" rule governs MUTATION delegations (coder, and the test_engineer/reviewer Stage B completion gates). It does NOT govern read-only advisory exploration/review lanes. When you dispatch read-only advisory lanes — \`{{AGENT_PREFIX}}explorer\`, \`{{AGENT_PREFIX}}sme\`, \`{{AGENT_PREFIX}}researcher\`, the council members (\`council_generalist\`/\`council_skeptic\`/\`council_domain_expert\`), or an advisory \`{{AGENT_PREFIX}}critic\` lane — use the NON-BLOCKING path so you keep working while they run. Dispatch PROMPTLY: emit the \`dispatch_lanes_async\` call EARLY with compact lane prompts — do not accumulate long planning prose or build oversized inline prompts first, or the tool call can be truncated out of your message and the lanes never launch (a real failure mode on smaller models). The lane mechanism is a SINGLE \`dispatch_lanes_async\` call carrying all lane specs — NOT a per-agent Task/run-in-background pattern. Call \`dispatch_lanes_async\` with all lane specs in one call, record the returned \`batch_id\`, then IMMEDIATELY continue non-dependent architect work (refine the plan/obligation ledger, inspect metadata, prepare the synthesis/reviewer structure, run deterministic read-only tools). Poll incrementally with \`collect_lane_results\` without \`wait\` (or with \`wait: false\`) to harvest lanes as they settle; process completed lane output immediately while other lanes remain pending/running, then continue independent work between polls. Do NOT sit idle waiting on running lanes, and do NOT synthesize findings from still-running lanes. Join later by calling \`collect_lane_results\` with \`wait: true\` as the explicit barrier immediately before you synthesize. Use blocking \`dispatch_lanes\` only when \`dispatch_lanes_async\`/promptAsync is unavailable. Keep each lane prompt compact: send large shared context (PR diff, ledger, scope) ONCE via the \`common_prompt\` field, or have lanes read it from a file by absolute path, instead of inlining the same blob into every lane prompt — inlining large context into many lanes is what produces malformed or truncated tool-call JSON and forces clumsy file workarounds. This non-blocking exception applies ONLY to read-only advisory lanes; it NEVER applies to coder delegations, to the test_engineer/reviewer Stage B completion gates, or to the critic PLAN-review gate, which all still follow "Send, STOP, wait" (or the Stage B parallel-dispatch exception above).
 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.
@@ -102289,7 +102293,7 @@ Available Tools: {{AVAILABLE_TOOLS}}
 
 ## DELEGATION FORMAT
 
-Delegations are performed ONLY by calling the **Task** tool. Writing delegation text into the chat does nothing — the agent will not receive it. Every delegation below is the content you pass to the Task tool, not text you output to the conversation.
+Mutation delegations are performed by calling the **Task** tool. Read-only advisory lanes are the explicit exception: dispatch them with \`dispatch_lanes_async\` plus incremental \`collect_lane_results\` polls (no \`wait\` / \`wait: false\`) before a final \`wait: true\` join, or blocking \`dispatch_lanes\` only when async is unavailable. Never turn advisory lanes into a per-agent Task/run-in-background pattern. Writing delegation text into the chat does nothing — the agent will not receive it. Every mutation delegation below is the content you pass to the Task tool, not text you output to the conversation.
 
 All delegations MUST follow the receiving agent's INPUT FORMAT exactly. Do NOT invent fields, omit required fields, or force one agent's schema onto another. Every delegation MUST begin with the agent name, include \`TASK:\`, and include \`SKILLS:\` when that agent prompt supports skills.
 Do NOT add conversational preamble before the agent prefix. Begin directly with the agent name.
@@ -102533,7 +102537,7 @@ Purpose: Read the previous retrospective and produce a codebase reality report b
 ACTION: Load skill file:.opencode/skills/pre-phase-briefing/SKILL.md immediately. Follow the protocol defined there.
 
 HARD CONSTRAINTS:
-- Complete the codebase reality report before starting or resuming phase implementation.
+- Complete the codebase reality report before spec finalization, plan generation, plan ingestion, declare_scope, or starting/resuming phase implementation. Dispatching the reality-check lanes asynchronously is allowed and preferred; settling all lanes before any of that downstream work is not optional.
 
 ### MODE: COUNCIL
 Activates when the user invokes /swarm council or requests a council-style decision review.
@@ -107428,6 +107432,7 @@ async function scanDocIndex(directory) {
   const resolvedDirectory = await realpath4(directory).catch(() => directory);
   const discoveredFiles = [];
   let rootReadable = false;
+  let truncated = false;
   const walkDir2 = async (dir) => {
     let entries;
     try {
@@ -107438,8 +107443,10 @@ async function scanDocIndex(directory) {
       return;
     }
     for (const entry of entries) {
-      if (discoveredFiles.length >= MAX_INDEXED_FILES)
+      if (discoveredFiles.length >= MAX_INDEXED_FILES) {
+        truncated = true;
         return;
+      }
       const isDir = entry.isDirectory();
       let isFile = entry.isFile();
       if (entry.isSymbolicLink()) {
@@ -107511,7 +107518,6 @@ async function scanDocIndex(directory) {
     };
   }
   discoveredFiles.sort((a, b) => a.path.toLowerCase().localeCompare(b.path.toLowerCase()));
-  let truncated = false;
   if (discoveredFiles.length > MAX_INDEXED_FILES) {
     discoveredFiles.splice(MAX_INDEXED_FILES);
     truncated = true;
@@ -131427,6 +131433,7 @@ var COMMON_PROMPT_SEPARATOR = `
 
 `;
 var DEFAULT_TIMEOUT_MS3 = 300000;
+var DEFAULT_ASYNC_LAUNCH_TIMEOUT_MS = 30000;
 var MAX_TIMEOUT_MS2 = 1800000;
 var MAX_LANE_OUTPUT_CHARS = 20000;
 var ASYNC_MESSAGE_FETCH_LIMIT = 50;
@@ -131502,9 +131509,10 @@ var DispatchLanesArgsSchema = exports_external.object({
   lanes: exports_external.array(LaneSchema).min(1).max(MAX_LANES).describe("Read-only lane specs to dispatch concurrently"),
   common_prompt: exports_external.string().min(1).regex(/\S/, "common_prompt must contain non-whitespace content").max(MAX_PROMPT_CHARS - COMMON_PROMPT_SEPARATOR.length - 1).optional().describe("Optional shared context prepended to every lane prompt. Send large shared context (PR diff, obligation ledger, scope) ONCE here instead of inlining the same blob into each lane prompt; this keeps the tool-call payload small and avoids malformed/truncated tool-call JSON. Combined common_prompt + per-lane prompt must not exceed the per-lane character limit."),
   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")
+  timeout_ms: exports_external.number().int().min(10).max(MAX_TIMEOUT_MS2).optional().describe("Per-lane timeout in milliseconds. For blocking dispatch this covers session create and prompt execution; for async dispatch this covers launch only, never lane runtime.")
 });
 var DispatchLanesAsyncArgsSchema = DispatchLanesArgsSchema.extend({
+  launch_timeout_ms: exports_external.number().int().min(10).max(MAX_TIMEOUT_MS2).optional().describe("Async launch acceptance timeout in milliseconds. This only bounds session creation and promptAsync acceptance; it is never a lane runtime timeout. Deprecated alias: timeout_ms."),
   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(),
@@ -131514,7 +131522,7 @@ 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().describe("Include pending/running lanes in results with partial output; useful for progress checks during non-blocking polls"),
+  include_pending: exports_external.boolean().optional().describe("Include pending/running lanes in lane_results. Defaults to true for non-blocking polls and false for wait=true joins."),
   cancel_pending: exports_external.boolean().optional().describe("Abort and mark pending/running lanes cancelled")
 });
 var _internals94 = {
@@ -131614,7 +131622,7 @@ async function executeDispatchLanesAsync(args2, directory, context = {}) {
     });
   }
   const maxConcurrent = Math.min(parsed.data.max_concurrent ?? lanes.length, lanes.length, MAX_LANES);
-  const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_TIMEOUT_MS3;
+  const launchTimeoutMs = parsed.data.launch_timeout_ms ?? parsed.data.timeout_ms ?? DEFAULT_ASYNC_LAUNCH_TIMEOUT_MS;
   const dispatcher = _internals94.createParallelDispatcher({
     enabled: true,
     maxConcurrentTasks: maxConcurrent,
@@ -131627,7 +131635,7 @@ async function executeDispatchLanesAsync(args2, directory, context = {}) {
       dispatcher,
       lane,
       directory,
-      timeoutMs,
+      timeoutMs: launchTimeoutMs,
       context,
       batchId,
       mode: parsed.data.mode,
@@ -131645,7 +131653,8 @@ async function executeDispatchLanesAsync(args2, directory, context = {}) {
       failed: failed.length,
       rejected: rejected.length,
       max_concurrent: maxConcurrent,
-      timeout_ms: timeoutMs,
+      launch_timeout_ms: launchTimeoutMs,
+      timeout_ms: launchTimeoutMs,
       lane_results: laneResults
     };
   } finally {
@@ -131673,7 +131682,6 @@ async function executeCollectLaneResults(args2, directory, context = {}) {
   const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_COLLECT_TIMEOUT_MS;
   const deadline = _internals94.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({
@@ -131686,7 +131694,7 @@ async function executeCollectLaneResults(args2, directory, context = {}) {
   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);
+    await sweepStaleAsyncLaneRecords(session, directory, records, DEFAULT_ASYNC_STALE_TIMEOUT_MS);
     records = findByBatchId(directory, parsed.data.batch_id, batchFilter);
     if (allSettled(records) || parsed.data.wait !== true) {
       keepPolling = false;
@@ -131699,7 +131707,7 @@ async function executeCollectLaneResults(args2, directory, context = {}) {
     await _internals94.sleep(Math.min(pollIntervalMs, Math.max(0, deadline - _internals94.now())));
     pollIntervalMs = nextCollectPollInterval(pollIntervalMs);
   }
-  return buildCollectResult(parsed.data.batch_id, records, parsed.data.include_pending === true);
+  return buildCollectResult(parsed.data.batch_id, records, parsed.data.include_pending ?? parsed.data.wait !== true);
 }
 async function launchAsyncLane(args2) {
   const validation2 = validateLaneAgent(args2.lane.agent, args2.context);
@@ -131773,54 +131781,17 @@ async function launchAsyncLane(args2) {
         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: digestText2(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: digestText2(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"
+    scheduleAsyncLanePrompt({
+      session: args2.session,
+      directory: args2.directory,
+      sessionId,
+      lane: args2.lane,
+      timeoutMs: args2.timeoutMs
     });
     return {
       id: args2.lane.id,
@@ -131854,6 +131825,9 @@ async function collectOnce(session, directory, records, cancelPending) {
       });
       continue;
     }
+    const readyForCollection = await isLaneReadyForCollection(session, directory, record3.subagentSessionId);
+    if (!readyForCollection)
+      continue;
     let messages;
     try {
       messages = await session.messages({
@@ -131899,6 +131873,82 @@ async function collectOnce(session, directory, records, cancelPending) {
     });
   }
 }
+function scheduleAsyncLanePrompt(args2) {
+  queueMicrotask(() => {
+    startAsyncLanePrompt(args2).catch(async (error93) => {
+      const message = formatError3(error93);
+      await appendAsyncLaneLaunchError(args2.directory, args2.session, args2.sessionId, message);
+    });
+  });
+}
+async function startAsyncLanePrompt(args2) {
+  const promptController = new AbortController;
+  let promptResult;
+  try {
+    promptResult = await withTimeout2(args2.session.promptAsync({
+      path: { id: args2.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 launch timed out after ${args2.timeoutMs}ms`, promptController);
+  } catch (error93) {
+    await appendAsyncLaneLaunchError(args2.directory, args2.session, args2.sessionId, formatError3(error93));
+    return;
+  }
+  if (promptResult.error) {
+    await appendAsyncLaneLaunchError(args2.directory, args2.session, args2.sessionId, `session.promptAsync launch failed: ${formatError3(promptResult.error)}`);
+    return;
+  }
+  await appendDelegationTransition(args2.directory, args2.sessionId, {
+    status: "running"
+  });
+}
+async function appendAsyncLaneLaunchError(directory, session, sessionId, message) {
+  await appendDelegationTransition(directory, sessionId, {
+    status: "error",
+    result: {
+      error: message,
+      chars: message.length,
+      truncated: false,
+      digest: digestText2(message)
+    }
+  });
+  cleanupAsyncLaunchSession(session, sessionId);
+}
+async function isLaneReadyForCollection(session, directory, sessionId) {
+  if (typeof session.status !== "function")
+    return true;
+  try {
+    const status = await session.status({ query: { directory } });
+    if (status.error || !status.data)
+      return false;
+    const current = status.data[sessionId];
+    return current === undefined || current.type === "idle";
+  } catch {
+    return false;
+  }
+}
+async function sweepStaleAsyncLaneRecords(session, directory, records, staleTimeoutMs) {
+  if (staleTimeoutMs <= 0)
+    return;
+  const now = _internals94.now();
+  for (const record3 of records) {
+    if (record3.status !== "pending" && record3.status !== "running" && record3.status !== "ingestion_error")
+      continue;
+    if (now - record3.updatedAt <= staleTimeoutMs)
+      continue;
+    const readyForCollection = await isLaneReadyForCollection(session, directory, record3.subagentSessionId);
+    if (!readyForCollection)
+      continue;
+    await appendDelegationTransition(directory, record3.correlationId, {
+      status: "stale"
+    });
+  }
+}
 function extractAssistantTranscript(messages) {
   const assistantTexts = [];
   for (const message of messages) {
@@ -132207,6 +132257,7 @@ function asyncFailureResult(args2) {
     failed: 0,
     rejected: 0,
     max_concurrent: 0,
+    launch_timeout_ms: 0,
     timeout_ms: 0,
     lane_results: [],
     errors: args2.errors
@@ -132360,11 +132411,12 @@ var dispatch_lanes = createSwarmTool({
   }
 });
 var dispatch_lanes_async = createSwarmTool({
-  description: "Launch multiple read-only advisory lanes with OpenCode promptAsync and return IMMEDIATELY with a batch id (non-blocking). After launching, keep working on non-dependent investigation while lanes run — poll incrementally with collect_lane_results (wait omitted or false) to process settled lanes as they complete, or use wait: true only at workflow boundaries where all results are needed. Keep each lane prompt compact: send large shared context once via common_prompt (or have lanes read it from a file by absolute path) instead of inlining it into every lane prompt, which can produce oversized or malformed tool-call JSON.",
+  description: "Launch multiple read-only advisory lanes with OpenCode promptAsync and return IMMEDIATELY with a batch id and lane session handles (non-blocking). launch_timeout_ms only bounds session creation and promptAsync acceptance; it is NOT a lane runtime timeout. After launching, keep working on non-dependent investigation while lanes run — poll incrementally with collect_lane_results (wait omitted or false) to process settled lanes as they complete, or use wait: true only at workflow boundaries where all results are needed. Keep each lane prompt compact: send large shared context once via common_prompt (or have lanes read it from a file by absolute path) instead of inlining it into every lane prompt, which can produce oversized or malformed tool-call JSON.",
   args: {
     lanes: DispatchLanesAsyncArgsSchema.shape.lanes,
     common_prompt: DispatchLanesAsyncArgsSchema.shape.common_prompt,
     max_concurrent: DispatchLanesAsyncArgsSchema.shape.max_concurrent,
+    launch_timeout_ms: DispatchLanesAsyncArgsSchema.shape.launch_timeout_ms,
     timeout_ms: DispatchLanesAsyncArgsSchema.shape.timeout_ms,
     batch_id: DispatchLanesAsyncArgsSchema.shape.batch_id,
     mode: DispatchLanesAsyncArgsSchema.shape.mode,
@@ -132380,7 +132432,7 @@ var dispatch_lanes_async = createSwarmTool({
   }
 });
 var collect_lane_results = createSwarmTool({
-  description: "Collect or poll results for a dispatch_lanes_async batch. Supports two modes: (1) non-blocking poll (wait omitted or false) — performs one collection pass and returns current lane status and any settled results so you can process completed lanes while continuing independent work; (2) blocking join (wait: true) — polls until all lanes settle or timeout. Use non-blocking polls to check progress incrementally; use blocking join only at workflow boundaries where all results are required. Does not advance workflow gates.",
+  description: "Collect or poll results for a dispatch_lanes_async batch. Supports two modes: (1) non-blocking poll (wait omitted or false) — performs one collection pass and returns current lane status, including pending lane identities by default, and any settled results so you can process completed lanes while continuing independent work; (2) blocking join (wait: true) — polls until all lanes settle or the collection wait budget expires. Busy/retry lanes do not become stale solely because they run for a long time. Does not advance workflow gates.",
   args: {
     batch_id: CollectLaneResultsArgsSchema.shape.batch_id,
     wait: CollectLaneResultsArgsSchema.shape.wait,
@@ -141306,18 +141358,32 @@ init_ledger();
 init_manager();
 import * as fs115 from "node:fs";
 import * as path187 from "node:path";
+var _fsInternals = {
+  mkdirSync: (...args2) => fs115.mkdirSync(...args2),
+  writeFileSync: (path188, data, encoding) => fs115.writeFileSync(path188, data, encoding ?? "utf8"),
+  readFileSync: (path188, encoding) => fs115.readFileSync(path188, encoding ?? "utf8"),
+  existsSync: (path188) => fs115.existsSync(path188)
+};
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const swarmDir = path187.join(directory, ".swarm");
-    fs115.mkdirSync(swarmDir, { recursive: true });
-    const jsonPath = path187.join(swarmDir, "SWARM_PLAN.json");
-    const mdPath = path187.join(swarmDir, "SWARM_PLAN.md");
-    fs115.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
+    const exportDir = path187.join(directory, ".swarm", "plan-export");
+    _fsInternals.mkdirSync(exportDir, { recursive: true });
+    const jsonPath = path187.join(exportDir, "SWARM_PLAN.json");
+    const mdPath = path187.join(exportDir, "SWARM_PLAN.md");
+    _fsInternals.writeFileSync(jsonPath, JSON.stringify(plan, null, 2));
     const md = derivePlanMarkdown(plan);
-    fs115.writeFileSync(mdPath, md, "utf8");
+    const header = `<!--
+AUTO-GENERATED EXPORT/CHECKPOINT SNAPSHOT — DO NOT EDIT
+This file is NOT the live plan. It is a derived export artifact.
+- .swarm/plan-ledger.jsonl is the authoritative source of plan state.
+- .swarm/plan.json and .swarm/plan.md are derived projections.
+Regenerated on: save_plan and phase_complete.
+-->
+`;
+    _fsInternals.writeFileSync(mdPath, header + md);
   } catch (error93) {
     console.warn(`[checkpoint] Failed to write SWARM_PLAN checkpoint: ${error93 instanceof Error ? error93.message : String(error93)}`);
   }

package/dist/plan/checkpoint.d.ts

@@ -1,6 +1,20 @@
+/**
+ * Checkpoint artifact writer.
+ * Writes SWARM_PLAN.md and SWARM_PLAN.json inside .swarm/plan-export/.
+ * Export-only — not a live runtime source of truth.
+ * Called on: save_plan, phase completion, /swarm close.
+ * NOT called on every task update.
+ */
+import * as fs from 'node:fs';
+export declare const _fsInternals: {
+    mkdirSync: (path: fs.PathLike, options?: fs.MakeDirectoryOptions | fs.Mode | null | undefined) => string | undefined;
+    writeFileSync: (path: string, data: string, encoding?: BufferEncoding) => void;
+    readFileSync: (path: string, encoding?: BufferEncoding) => string;
+    existsSync: (path: string) => boolean;
+};
 import { type Plan } from '../config/plan-schema';
 /**
- * Write SWARM_PLAN.json and SWARM_PLAN.md inside the .swarm/ directory under the project root.
+ * Write SWARM_PLAN.json and SWARM_PLAN.md inside the .swarm/plan-export/ directory under the project root.
  * Non-blocking: logs a warning on failure but never throws.
  * @param directory - The working directory (project root)
  */
@@ -14,7 +28,7 @@ export interface ImportCheckpointResult {
     error?: string;
 }
 /**
- * Import a checkpoint from .swarm/SWARM_PLAN.json (with backward-compat fallback to project root).
+ * Import a checkpoint from .swarm/plan-export/SWARM_PLAN.json (with backward-compat fallback to .swarm/ and project root).
  * Validates the checkpoint against PlanSchema, persists it as the live plan
  * via savePlan, and appends a 'plan_rebuilt' ledger event.
  *

package/dist/tools/dispatch-lanes.d.ts

@@ -26,6 +26,7 @@ declare const DispatchLanesAsyncArgsSchema: z.ZodObject<{
     common_prompt: z.ZodOptional<z.ZodString>;
     max_concurrent: z.ZodOptional<z.ZodNumber>;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
+    launch_timeout_ms: z.ZodOptional<z.ZodNumber>;
     batch_id: z.ZodOptional<z.ZodString>;
     mode: z.ZodOptional<z.ZodString>;
     pr_head_sha: z.ZodOptional<z.ZodString>;
@@ -88,6 +89,8 @@ export interface DispatchLanesAsyncResult {
     failed: number;
     rejected: number;
     max_concurrent: number;
+    launch_timeout_ms: number;
+    /** Deprecated alias for launch_timeout_ms; retained for existing callers. */
     timeout_ms: number;
     lane_results: DispatchLaneResult[];
     errors?: string[];
@@ -181,6 +184,16 @@ export interface SessionOps {
         }> | null;
         error?: unknown;
     }>;
+    status?: (args: {
+        query?: {
+            directory?: string;
+        };
+    }) => Promise<{
+        data?: Record<string, {
+            type?: string;
+        }> | null;
+        error?: unknown;
+    }>;
     abort?: (args: {
         path: {
             id: string;
@@ -225,11 +238,16 @@ export declare const _test_exports: {
         common_prompt: z.ZodOptional<z.ZodString>;
         max_concurrent: z.ZodOptional<z.ZodNumber>;
         timeout_ms: z.ZodOptional<z.ZodNumber>;
+        launch_timeout_ms: z.ZodOptional<z.ZodNumber>;
         batch_id: z.ZodOptional<z.ZodString>;
         mode: z.ZodOptional<z.ZodString>;
         pr_head_sha: z.ZodOptional<z.ZodString>;
         scope: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+    DEFAULT_TIMEOUT_MS: number;
+    DEFAULT_ASYNC_LAUNCH_TIMEOUT_MS: number;
+    DEFAULT_ASYNC_STALE_TIMEOUT_MS: number;
+    DEFAULT_COLLECT_TIMEOUT_MS: number;
 };
 type ReadOnlyToolPermissions = Record<string, false> & {
     write: false;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.95.0",
+	"version": "7.97.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",