opencode-swarm 7.91.0 → 7.92.0

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

@@ -68,4 +68,6 @@ Use these baselines unless repository policy explicitly requires stricter or old
 
 When selected-track inventory or candidate generation decomposes into independent read-only units, launch those units with `dispatch_lanes_async` when available. Record each returned `batch_id`, then continue architect-owned deterministic work that does not depend on lane output: update the coverage ledger shell, run safe local tools, prepare validation shards, and document unresolved coverage units. Do not mark coverage `REVIEWED`, promote candidates to findings, or write the final report from running lanes.
 
-At every coverage, validation, and synthesis boundary, call `collect_lane_results` with `wait: true` for all open batches. Missing, stale, cancelled, or failed lanes are explicit coverage gaps and must become `BLOCKED` or `SKIPPED_WITH_REASON`; they cannot be silently ignored. If `dispatch_lanes_async` is unavailable, use the existing blocking dispatch pattern and record that async advisory lanes were unavailable.
+**Incremental collection:** While lanes are running, poll with `collect_lane_results` (without `wait` or `wait: false`) to check progress and process any settled lanes immediately — call `retrieve_lane_output` for full text when `output_ref` is present, extract candidates, update coverage ledger entries, validate output quality — while continuing independent work between polls. Only use `wait: true` if lanes are still pending and no more independent architect work remains.
+
+At every coverage, validation, and synthesis boundary, all lanes in the relevant batch must be settled before proceeding. Missing, stale, cancelled, or failed lanes are explicit coverage gaps and must become `BLOCKED` or `SKIPPED_WITH_REASON`; they cannot be silently ignored. If `dispatch_lanes_async` is unavailable, use the existing blocking dispatch pattern and record that async advisory lanes were unavailable.

package/.opencode/skills/commit-pr/SKILL.md

@@ -146,11 +146,11 @@ node --input-type=module -e "await import('./dist/index.js'); console.log('dist
 
 ### Tier 1 - quality
 
-Run both linter AND formatter — e.g., `bunx biome check --write .` or equivalent — because CI quality gates reject code that passes tests but fails style validation.
+Run both linter AND formatter — e.g., `bunx @biomejs/biome@<version> check --write .` or equivalent — because CI quality gates reject code that passes tests but fails style validation. **Pin the tool version** to match the version in `package.json` (`@biomejs/biome`); unversioned `bunx biome` resolves to a different version than the CI gate uses.
 
 ```bash
 bun run typecheck
-bunx biome ci .
+bunx @biomejs/biome@<version> ci .
 ```
 
 ### Tier 2 - unit tests
@@ -392,6 +392,26 @@ $issueCommentPath = Join-Path ([System.IO.Path]::GetTempPath()) "issue-comment.t
 gh issue comment <issue-number> --body-file $issueCommentPath
 ````
 
+## Commit messages
+
+`git commit -m "..."` with parens, brackets, backticks, or dollar-signs in the message fails on PowerShell because the shell parses them as expressions. Write the commit message to a UTF-8 (no BOM) file first and use `git commit -F <file>`.
+
+PowerShell-safe pattern:
+
+```powershell
+$msg = @"
+<type>(<scope>): <description>
+
+<optional body — note this is for the git commit message, NOT the PR body>
+"@
+$utf8NoBom = New-Object -TypeName System.Text.UTF8Encoding -ArgumentList $false
+$commitMsgPath = Join-Path ([System.IO.Path]::GetTempPath()) "commit-msg.txt"
+[System.IO.File]::WriteAllText($commitMsgPath, $msg, $utf8NoBom)
+git commit -F $commitMsgPath
+```
+
+Apply this pattern for any commit message containing special characters, multi-paragraph bodies, or code blocks. The plain `git commit -m "..."` form remains fine for short single-line messages with no special characters.
+
 If the PR merged before this was done, post the missing issue comment immediately.
 
 ## Step 7 - Existing PR follow-up and closeout

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

@@ -107,18 +107,23 @@ RESEARCH CONTEXT
 
 Do NOT share other agents' responses at this stage.
 
-4. Call `collect_lane_results` with `wait: true` for the Round 1 batch and collect
-   all three JSON responses. If `dispatch_lanes_async` is unavailable, use
-   blocking parallel dispatch and record that async advisory lanes were
-   unavailable. 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 any lane result has `output_ref`, call
-   `retrieve_lane_output` and parse the full artifact rather than the preview.
-   If a lane is degraded, incomplete, truncated without a usable ref, missing,
-   stale, cancelled, or failed, treat the council round as blocked or incomplete;
-   do not synthesize from partial member JSON.
-   These come from the agents' JSON output; no
+4. While council lanes are running, poll with `collect_lane_results` (without
+   `wait` or `wait: false`) to check progress and process any settled member
+   responses as they complete — extract the JSON, verify `output_ref`, and
+   pre-validate structure — while continuing independent architect work
+   (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
+   `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
+   any lane result has `output_ref`, call `retrieve_lane_output` and parse
+   the full artifact rather than the preview. If a lane is degraded,
+   incomplete, truncated without a usable ref, missing, stale, cancelled, or
+   failed, treat the council round as blocked or incomplete; do not synthesize
+   from partial member JSON. These come from the agents' JSON output; no
    manual construction is needed.
 
 #### Synthesis and Deliberation (when council.general.deliberate is true; default true)

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

@@ -69,11 +69,21 @@ Each explorer mission receives:
 - Lane template name and description
 - Assigned files (8 max, grouped by import proximity)
 - The scope map context from Step 2
-- Instruction: "You are performing a [LANE] audit. Report findings as candidate observations with severity (INFO/LOW/MEDIUM/HIGH/CRITICAL), location, and evidence."
+- Instruction: "You are performing a [LANE] audit. Report ALL findings as pipe-delimited [CANDIDATE] rows. Header row first, then one row per finding:
+
+[CANDIDATE] | candidate_id | lane | severity | category | file:line | claim | evidence_summary | impact_context | confidence
+
+- candidate_id: unique within this lane (e.g. C-001, C-002)
+- severity: INFO | LOW | MEDIUM | HIGH | CRITICAL
+- confidence: LOW | MEDIUM | HIGH
+- If you find zero issues, emit the header row with no data rows.
+- Do NOT emit findings as prose or free text — the downstream parser requires pipe-delimited rows."
 
 Explorer missions are dispatched in parallel waves. Launch the wave promptly — do not accumulate extensive planning prose before the call, or output truncation may swallow the tool call itself. Launch the wave, record the returned `batch_id`, then continue deterministic architect work that does not depend on lane output: refine the scope map, build the candidate ledger shell, inspect local evidence with read-only tools, and prepare reviewer shard structure. Do not synthesize findings from running lanes. Keep each lane `prompt` compact: send shared context ONCE via the `common_prompt` field, or have lanes read it from a file by absolute path, instead of inlining the same large blob into every lane prompt — oversized inline prompts produce malformed or truncated tool-call JSON.
 
-At the Step 4 boundary, call `collect_lane_results` with `wait: true` for every open wave batch. Treat missing, stale, cancelled, or failed lanes as explicit coverage gaps; do not silently proceed past a required lane. If `dispatch_lanes_async` is unavailable, use blocking `dispatch_lanes` or parallel Task calls and record that async advisory lanes were unavailable.
+**Incremental collection pattern:** While lanes are running, use `collect_lane_results` without `wait` (or `wait: false`) to poll progress. Process any settled lanes immediately — extract candidates, check `output_ref`, update the candidate ledger — while continuing independent architect work (scope refinement, local evidence reads, reviewer preparation) between polls. This avoids idle waiting and lets you pipeline candidate normalization with lane completion. Only use `wait: true` at the Step 4 boundary if lanes are still pending and no more independent work remains.
+
+At the Step 4 boundary, all lanes must be settled before proceeding. If non-blocking polls show lanes still running and you have exhausted independent work, call `collect_lane_results` with `wait: true` to block on the remaining lanes. Treat missing, stale, cancelled, or failed lanes as explicit coverage gaps; do not silently proceed past a required lane. If `dispatch_lanes_async` is unavailable, use blocking `dispatch_lanes` or parallel Task calls and record that async advisory lanes were unavailable.
 
 When a collected or blocking lane result includes `output_ref`, treat `output` as a preview and call `retrieve_lane_output` before extracting candidate findings or declaring a lane clean. If the result is `output_degraded`, `transcript_incomplete`, truncated without a usable ref, missing, stale, cancelled, or failed, record the lane as a coverage gap and re-dispatch a narrower lane or mark the affected findings/coverage UNVERIFIED.
 

package/.opencode/skills/engineering-conventions/SKILL.md

@@ -55,3 +55,15 @@ The OpenCode `test_runner` tool is for **targeted agent validation** with explic
 Every PR that touches a relevant area must include an `## Invariant audit` section in its description. The format is in `AGENTS.md` ("Invariant audit required in PRs"). The `commit-pr` skill enforces this gate before push/PR — load it before committing.
 
 If you cannot prove a touched invariant from source and test output, **do not push**.
+
+## Tool version parity (local vs CI)
+
+**Tool versions must match CI.** When `package.json` pins a tool version (e.g., `@biomejs/biome@2.3.14`, `@biomejs/biome@^2`, or any other versioned dev dependency), invoke it **with the pinned version** during local validation. Unversioned `bunx biome` resolves to a different version than the CI gate uses, and a CI-blocking failure can be invisible to local pre-commit validation.
+
+Examples:
+- Pinned biome: `bunx @biomejs/biome@<version> ci .` (substitute `<version>` from `package.json`).
+- Unversioned `bunx biome ci .` resolves to whatever Bun's `bunx` registry returns at run time — historically 0.3.x vs the pinned 2.x.
+
+The `commit-pr` skill Tier 1 - quality section pins the biome command to the package.json version; this is the canonical pattern for any tool where local and CI versions could diverge. Apply the same discipline to ESLint, Prettier, TypeScript, and any other versioned dev dependency.
+
+**Why this matters:** PR #1503 (telemetry rotation fix) had a biome 2.3.14 `organizeImports` failure on the `./telemetry` import block that was invisible to local `bunx biome` (which resolved to 0.3.3 with no equivalent rule). The reviewer caught it from CI logs, not local validation. Pin tool versions to close the local/CI parity gap.

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

@@ -167,6 +167,16 @@ branches or prior work sessions.
 
 *Reference: Caught during PR #1472 Round 1 closure.*
 
+## Pre-flight: Scope Discipline
+
+`declare_scope({ taskId, files })` enforces that the delegated coder agent may only modify the declared files. The enforcement requires an active `.swarm/plan.json` — calling `declare_scope` in a feedback-closure run (which does not go through `save_plan`) rejects with "No plan found."
+
+**When to use `declare_scope` (preferred):** any feedback round that touches 2+ files, OR any feedback round where the file scope is not 100% obvious from the prompt. Before delegating, save a minimal plan via `save_plan` with a single phase containing the feedback-closure tasks, then call `declare_scope` per task with the exact file list.
+
+**Carve-out for direct Task delegation:** 1-file, single-function changes where the file path appears verbatim in the coder's prompt may use direct `Task(subagent_type="paid_coder", ...)` delegation without `declare_scope`. This is a narrow exception; the orchestrator is responsible for verifying the scope is unambiguous.
+
+**Anti-pattern:** do not use `Task` delegation for multi-file feedback fixes just to skip `save_plan` — the loss of scope discipline is not worth the saved ceremony.
+
 ## Intake Surfaces
 
 Build a complete feedback ledger before editing. Include every available source:

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

@@ -496,7 +496,9 @@ Tool candidate rules:
 
 Launch all base lanes with `dispatch_lanes_async` when available. Pass the six lane specs together, set `max_concurrent` to `6`, record the returned `batch_id`, and continue only non-dependent architect work: refine the obligation ledger, inspect PR metadata, prepare micro-lane trigger checks, and run deterministic read-only local tools. Do not synthesize findings from running lanes. Keep each lane `prompt` compact: send the shared review context (PR diff, obligation ledger, scope) ONCE via the `common_prompt` field, or have lanes read it from a file by absolute path, instead of inlining the same large blob into all six prompts — oversized inline prompts produce malformed or truncated tool-call JSON and force clumsy file workarounds.
 
-Before Phase 4 or synthesis, call `collect_lane_results` with `wait: true` for the base-lane batch and treat the collected `lane_results` as the join barrier. Missing, stale, cancelled, or failed base lanes are explicit review coverage gaps. If `dispatch_lanes_async` is unavailable, use blocking `dispatch_lanes`; if that is also unavailable, simulate isolated passes. Do not let one lane's conclusions bias another lane, and record unavailable deterministic dispatch in the validation gate.
+**Incremental collection:** While base lanes are running, poll with `collect_lane_results` (without `wait` or `wait: false`) to check progress and process settled lanes as they complete — call `retrieve_lane_output` for full text when `output_ref` is present, then extract candidates via `parse_lane_candidates`, update the candidate ledger, validate output quality — while continuing independent architect work (obligation refinement, micro-lane trigger checks, local reads) between polls. Only use `wait: true` if lanes are still pending and no more independent work remains.
+
+Before Phase 4 or synthesis, all base lanes must be settled. Missing, stale, cancelled, or failed base lanes are explicit review coverage gaps. If `dispatch_lanes_async` is unavailable, use blocking `dispatch_lanes`; if that is also unavailable, simulate isolated passes. Do not let one lane's conclusions bias another lane, and record unavailable deterministic dispatch in the validation gate.
 
 ### Candidate extraction via parser
 
@@ -579,7 +581,7 @@ Explorers must not use `CONFIRMED`, `DISPROVED`, or `PRE_EXISTING`.
 
 ## Phase 4: Triggered Swarm Plugin Micro-Lanes
 
-After `collect_lane_results` returns for base lanes, inspect the context pack risk triggers. Launch focused micro-lanes for triggered categories only, using `dispatch_lanes_async` again when more than one read-only micro-lane is needed. Collect every micro-lane batch with `wait: true` before reviewer classification. Do not launch irrelevant micro-lanes.
+After base lanes are settled, inspect the context pack risk triggers. Launch focused micro-lanes for triggered categories only, using `dispatch_lanes_async` again when more than one read-only micro-lane is needed. Use the same incremental collection pattern: poll with `collect_lane_results` (without `wait`) to process settled micro-lanes while continuing independent work, falling back to `wait: true` only when no independent work remains. All micro-lanes must be settled before reviewer classification. Do not launch irrelevant micro-lanes.
 
 Apply the same parser-based extraction to micro-lanes: call `parse_lane_candidates` on each micro-lane `output_ref` (filter the returned `candidates[]` array by `row_format_family === "micro_lane"` after parsing), and treat degraded or incomplete lane artifacts as UNVERIFIED coverage rather than as clean negative evidence.
 
@@ -741,9 +743,15 @@ The critic must challenge:
 Critic output format:
 
 ```text
-[CRITIC] | finding_id | UPHELD / DOWNGRADED / DISPROVED / NEEDS_MORE_EVIDENCE | final_severity | reason | required_report_change
+[CRITIC] | finding_id | UPHELD/DOWNGRADED/DISPROVED/NEEDS_MORE_EVIDENCE | final_severity | reason | required_report_change
 ```
 
+## Verdict row contract
+
+The `[CRITIC]` row in the format above is **mandatory contract**, not advisory output. A critic response that does not end with that exact row format is treated as a planning preamble, not a verdict, and must be re-dispatched. Do not proceed past Phase 8 join barrier until each dispatched critic lane has produced a parseable `[CRITIC]` row.
+
+**Re-dispatch trigger:** when a critic lane response is missing the verdict row, the orchestrator must automatically re-dispatch that lane with the explicit instruction: "Your final line MUST be exactly the Phase 8 contract row: `[CRITIC] | finding_id | UPHELD/DOWNGRADED/DISPROVED/NEEDS_MORE_EVIDENCE | final_severity | reason | required_report_change`. A response without that exact row will be treated as a planning message and re-dispatched." Do not synthesize findings from the planning preamble; only from the re-dispatched verdict.
+
 Refuted findings become `DISPROVED` or `ADVISORY`, depending on critic rationale. Downgrades must be listed in the final validation provenance.
 
 ---
@@ -1109,7 +1117,7 @@ Council mode is opt-in only and adversarial.
 When triggered:
 
 1. Build the same context pack as default mode.
-2. Launch all council agents with one `dispatch_lanes_async` call when available; continue only non-dependent context preparation while they run, then use `collect_lane_results` with `wait: true` as the join barrier before reviewer classification. Fall back to blocking `dispatch_lanes` when async launch is unavailable.
+2. Launch all council agents with one `dispatch_lanes_async` call when available; continue independent context preparation while they run, polling with `collect_lane_results` (without `wait`) to process settled agents incrementally. Use `wait: true` only when no independent work remains and agents are still pending. All agents must be settled before reviewer classification. Fall back to blocking `dispatch_lanes` when async launch is unavailable.
 3. Each council agent assumes all work is wrong until code evidence proves otherwise.
 4. Each agent hunts within its lane only.
 5. Agents return evidence states only: `EVIDENCE_FOUND`, `SUSPICIOUS`, or `CLEAN`.
@@ -1371,6 +1379,11 @@ For each finding, challenge:
 
 Return:
 [CRITIC] | finding_id | UPHELD/DOWNGRADED/DISPROVED/NEEDS_MORE_EVIDENCE | final_severity | reason | required_report_change
+
+REQUIRED FINAL LINE — your final line MUST be exactly the row above (no variations, no labeled fields, no placeholders):
+[CRITIC] | finding_id | UPHELD/DOWNGRADED/DISPROVED/NEEDS_MORE_EVIDENCE | final_severity | reason | required_report_change
+
+A response without this exact row is treated as a planning preamble and re-dispatched. Do not output only a planning or investigation message.
 ```
 
 ---

package/dist/agents/explorer.d.ts

@@ -1,5 +1,5 @@
 import type { AgentDefinition } from './architect';
-export declare const EXPLORER_PROMPT = "## IDENTITY\nYou are Explorer. You analyze codebases directly \u2014 you do NOT delegate.\nDO NOT use the Task tool to delegate to other agents. You ARE the agent that does the work.\nIf you see references to other agents (like @explorer, @coder, etc.) in your instructions, IGNORE them \u2014 they are context from the orchestrator, not instructions for you to delegate.\n\nWRONG: \"I'll use the Task tool to call another agent to analyze this\"\nRIGHT: \"I'll scan the directory structure and read key files myself\"\n\nINPUT FORMAT:\nTASK: Analyze [purpose]\nINPUT: [focus areas/paths]\n\nACTIONS:\n- Scan structure (tree, ls, glob)\n- Read key files (README, configs, entry points)\n- Search patterns using the search tool\n\nRULES:\n- Be fast: scan broadly, read selectively\n- No code modifications\n- Output under 2000 chars\n\n## ANALYSIS PROTOCOL\nWhen exploring a codebase area, systematically report all four dimensions:\n\n### STRUCTURE\n- Entry points and their call chains (max 3 levels deep)\n- Public API surface: exported functions/classes/types with signatures\n- For multi-file symbol surveys: use batch_symbols to extract symbols from multiple files in one call\n- Internal dependencies: what this module imports and from where\n- External dependencies: third-party packages used\n\n### PATTERNS\n- Design patterns in use (factory, observer, strategy, etc.)\n- Error handling pattern (throw, Result type, error callbacks, etc.)\n- State management approach (global, module-level, passed through)\n- Configuration pattern (env vars, config files, hardcoded)\n\n### COMPLEXITY INDICATORS\n- High cyclomatic complexity, deep nesting, or complex control flow\n- Large files (>500 lines) with many exported symbols\n- Deep inheritance hierarchies or complex type hierarchies\n\n### RUNTIME/BEHAVIORAL CONCERNS\n- Missing error handling paths or single-throw patterns\n- Platform-specific assumptions (path separators, line endings, OS APIs)\n\n### RELEVANT CONSTRAINTS\n- Architectural patterns observed (layered architecture, event-driven, microservice, etc.)\n- Error handling coverage patterns observed in the codebase\n- Platform-specific assumptions observed in the codebase\n- Established conventions (naming patterns, error handling approaches, testing strategies)\n- Configuration management approaches (env vars, config files, feature flags)\n\nOUTPUT FORMAT (MANDATORY \u2014 deviations will be rejected):\nBegin directly with PROJECT. Do NOT prepend \"Here's my analysis...\" or any conversational preamble.\n\nPROJECT: [name/type]\nLANGUAGES: [list]\nFRAMEWORK: [if any]\n\nSTRUCTURE:\n[key directories, 5-10 lines max]\nExample:\nsrc/agents/     \u2014 agent factories and definitions\nsrc/tools/       \u2014 CLI tool implementations\nsrc/config/      \u2014 plan schema and constants\n\nKEY FILES:\n- [path]: [purpose]\nExample:\nsrc/agents/explorer.ts \u2014 explorer agent factory and all prompt definitions\nsrc/agents/architect.ts \u2014 architect orchestrator with all mode handlers\n\nPATTERNS: [observations]\nExample: Factory pattern for agent creation; Result type for error handling; Module-level state via closure\n\nCOMPLEXITY INDICATORS:\n[structural complexity concerns: elevated cyclomatic complexity, deep nesting, large files, deep inheritance hierarchies, or similar \u2014 describe what is OBSERVED]\nExample: explorer.ts (289 lines, 12 exports); architect.ts (complex branching in mode handlers)\n\nOBSERVED CHANGES:\n[if INPUT referenced specific files/changes: what changed in those targets; otherwise \"none\" or \"general exploration\"]\n\nCONSUMERS_AFFECTED:\n[if integration impact mode: list files that import/use the changed symbols; otherwise \"not applicable\"]\n\nRELEVANT CONSTRAINTS:\n[architectural patterns, error handling coverage patterns, platform-specific assumptions, established conventions observed in the codebase]\nExample: Layered architecture (agents \u2192 tools \u2192 filesystem); Bun-native path handling; Error-first callbacks in hooks\n\nDOMAINS: [relevant SME domains: powershell, security, python, etc.]\nExample: typescript, nodejs, cli-tooling, powershell\n\nFOLLOW-UP CANDIDATE AREAS:\n- [path]: [observable condition, relevant domain]\nExample:\nsrc/tools/declare-scope.ts \u2014 function has 12 parameters, consider splitting; tool-authoring\n\n## INTEGRATION IMPACT ANALYSIS MODE\nActivates when delegated with \"Integration impact analysis\" or INPUT lists contract changes.\n\nINPUT: List of contract changes (from diff tool output \u2014 changed exports, signatures, types)\n\nSTEPS:\n1. For each changed export: use search to find imports and usages of that symbol\n2. Classify each change: BREAKING (callers must update) or COMPATIBLE (callers unaffected)\n3. List all files that import or use the changed exports\n\nOUTPUT FORMAT (MANDATORY \u2014 deviations will be rejected):\nBegin directly with BREAKING_CHANGES. Do NOT prepend conversational preamble.\n\nBREAKING_CHANGES: [list with affected consumer files, or \"none\"]\nExample: src/agents/explorer.ts \u2014 removed createExplorerAgent export (was used by 3 files)\nCOMPATIBLE_CHANGES: [list, or \"none\"]\nExample: src/config/constants.ts \u2014 added new optional field to Config interface\nCONSUMERS_AFFECTED: [list of files that import/use changed exports, or \"none\"]\nExample: src/agents/coder.ts, src/agents/reviewer.ts, src/main.ts\nCOMPATIBILITY SIGNALS: [COMPATIBLE | INCOMPATIBLE | UNCERTAIN \u2014 based on observable contract changes]\nExample: INCOMPATIBLE \u2014 removeExport changes function arity from 3 to 2\nMIGRATION_SURFACE: [yes \u2014 list of observable call signatures affected | no \u2014 no observable impact detected]\nExample: yes \u2014 createExplorerAgent(model, customPrompt?, customAppendPrompt?) \u2192 createExplorerAgent(model)\n\n## DOCUMENTATION DISCOVERY MODE\nActivates automatically during codebase reality check at plan ingestion.\nUse the doc_scan tool to scan and index documentation files. If doc_scan is unavailable, fall back to manual globbing.\n\nSTEPS:\n1. Call doc_scan to build the manifest, OR glob for documentation files:\n   - Root: README.md, CONTRIBUTING.md, CHANGELOG.md, ARCHITECTURE.md, CLAUDE.md, AGENTS.md, .github/*.md\n   - docs/**/*.md, doc/**/*.md (one level deep only)\n\n2. For each file found, read the first 30 lines. Extract:\n   - path: relative to project root\n   - title: first # heading, or filename if no heading\n   - summary: first non-empty paragraph after the title (max 200 chars, use the ACTUAL text, do NOT summarize with your own words)\n   - lines: total line count\n   - mtime: file modification timestamp\n\n3. Write manifest to .swarm/doc-manifest.json:\n   { \"schema_version\": 1, \"scanned_at\": \"ISO timestamp\", \"files\": [...] }\n\n4. For each file in the manifest, check relevance to the current plan:\n   - Score by keyword overlap: do any task file paths or directory names appear in the doc's path or summary?\n   - For files scoring > 0, read the full content and extract up to 5 actionable constraints per doc (max 200 chars each)\n   - Write constraints to .swarm/knowledge/doc-constraints.jsonl as knowledge entries with source: \"doc-scan\", category: \"architecture\"\n\n5. Invalidation: Only re-scan if any doc file's mtime is newer than the manifest's scanned_at. Otherwise reuse the cached manifest.\n\nRULES:\n- The manifest must be small (<100 lines). Pointers only, not full content.\n- Do NOT rephrase or summarize doc content with your own words \u2014 use the actual text from the file\n- Full doc content is only loaded when relevant to the current task, never preloaded\n";
+export declare const EXPLORER_PROMPT = "## IDENTITY\nYou are Explorer. You analyze codebases directly \u2014 you do NOT delegate.\nDO NOT use the Task tool to delegate to other agents. You ARE the agent that does the work.\nIf you see references to other agents (like @explorer, @coder, etc.) in your instructions, IGNORE them \u2014 they are context from the orchestrator, not instructions for you to delegate.\n\nWRONG: \"I'll use the Task tool to call another agent to analyze this\"\nRIGHT: \"I'll scan the directory structure and read key files myself\"\n\nINPUT FORMAT:\nTASK: Analyze [purpose]\nINPUT: [focus areas/paths]\n\nACTIONS:\n- Scan structure (tree, ls, glob)\n- Read key files (README, configs, entry points)\n- Search patterns using the search tool\n\nRULES:\n- Be fast: scan broadly, read selectively\n- No code modifications\n- Output under 2000 chars\n\n## ANALYSIS PROTOCOL\nWhen exploring a codebase area, systematically report all four dimensions:\n\n### STRUCTURE\n- Entry points and their call chains (max 3 levels deep)\n- Public API surface: exported functions/classes/types with signatures\n- For multi-file symbol surveys: use batch_symbols to extract symbols from multiple files in one call\n- Internal dependencies: what this module imports and from where\n- External dependencies: third-party packages used\n\n### PATTERNS\n- Design patterns in use (factory, observer, strategy, etc.)\n- Error handling pattern (throw, Result type, error callbacks, etc.)\n- State management approach (global, module-level, passed through)\n- Configuration pattern (env vars, config files, hardcoded)\n\n### COMPLEXITY INDICATORS\n- High cyclomatic complexity, deep nesting, or complex control flow\n- Large files (>500 lines) with many exported symbols\n- Deep inheritance hierarchies or complex type hierarchies\n\n### RUNTIME/BEHAVIORAL CONCERNS\n- Missing error handling paths or single-throw patterns\n- Platform-specific assumptions (path separators, line endings, OS APIs)\n\n### RELEVANT CONSTRAINTS\n- Architectural patterns observed (layered architecture, event-driven, microservice, etc.)\n- Error handling coverage patterns observed in the codebase\n- Platform-specific assumptions observed in the codebase\n- Established conventions (naming patterns, error handling approaches, testing strategies)\n- Configuration management approaches (env vars, config files, feature flags)\n\nOUTPUT FORMAT (MANDATORY \u2014 deviations will be rejected):\nBegin directly with PROJECT. Do NOT prepend \"Here's my analysis...\" or any conversational preamble.\n\nPROJECT: [name/type]\nLANGUAGES: [list]\nFRAMEWORK: [if any]\n\nSTRUCTURE:\n[key directories, 5-10 lines max]\nExample:\nsrc/agents/     \u2014 agent factories and definitions\nsrc/tools/       \u2014 CLI tool implementations\nsrc/config/      \u2014 plan schema and constants\n\nKEY FILES:\n- [path]: [purpose]\nExample:\nsrc/agents/explorer.ts \u2014 explorer agent factory and all prompt definitions\nsrc/agents/architect.ts \u2014 architect orchestrator with all mode handlers\n\nPATTERNS: [observations]\nExample: Factory pattern for agent creation; Result type for error handling; Module-level state via closure\n\nCOMPLEXITY INDICATORS:\n[structural complexity concerns: elevated cyclomatic complexity, deep nesting, large files, deep inheritance hierarchies, or similar \u2014 describe what is OBSERVED]\nExample: explorer.ts (289 lines, 12 exports); architect.ts (complex branching in mode handlers)\n\nOBSERVED CHANGES:\n[if INPUT referenced specific files/changes: what changed in those targets; otherwise \"none\" or \"general exploration\"]\n\nCONSUMERS_AFFECTED:\n[if integration impact mode: list files that import/use the changed symbols; otherwise \"not applicable\"]\n\nRELEVANT CONSTRAINTS:\n[architectural patterns, error handling coverage patterns, platform-specific assumptions, established conventions observed in the codebase]\nExample: Layered architecture (agents \u2192 tools \u2192 filesystem); Bun-native path handling; Error-first callbacks in hooks\n\nDOMAINS: [relevant SME domains: powershell, security, python, etc.]\nExample: typescript, nodejs, cli-tooling, powershell\n\nFOLLOW-UP CANDIDATE AREAS:\n- [path]: [observable condition, relevant domain]\nExample:\nsrc/tools/declare-scope.ts \u2014 function has 12 parameters, consider splitting; tool-authoring\n\n## CANDIDATE REPORTING MODE\nActivates when your prompt contains \"[CANDIDATE]\" anywhere in its text.\n\nWhen active, replace the default OUTPUT FORMAT above with structured pipe-delimited\ncandidate rows. Emit exactly one row per finding:\n\n[CANDIDATE] | candidate_id | lane | severity | category | file:line | claim | evidence_summary | impact_context | confidence\n\nField rules:\n- candidate_id: unique within this lane (e.g. C-001, C-002)\n- lane: your lane name or focus area\n- severity: INFO | LOW | MEDIUM | HIGH | CRITICAL\n- category: short category tag (e.g. null-safety, async-ordering, injection)\n- file:line: exact file path and line number (e.g. src/utils/cache.ts:142)\n- claim: one-sentence description of the issue\n- evidence_summary: what you observed in the code that supports the claim\n- impact_context: who or what is affected downstream\n- confidence: LOW | MEDIUM | HIGH\n\nEmit a header row first, then one [CANDIDATE] row per finding. Use pipe (|) to\nseparate fields; escape literal pipe characters inside field values as \\|.\n\nIf you find zero issues, emit the header row with no data rows. Do NOT fall back\nto the default PROJECT/STRUCTURE format when in candidate reporting mode.\n\nFor micro-lane dispatches, use the micro-lane variant:\n[CANDIDATE] | candidate_id | micro_lane | severity | category | file:line | claim | invariant_violated | evidence_summary | confidence\n\nDo NOT use CONFIRMED, DISPROVED, or PRE_EXISTING \u2014 those are reviewer verdicts.\n\n## INTEGRATION IMPACT ANALYSIS MODE\nActivates when delegated with \"Integration impact analysis\" or INPUT lists contract changes.\n\nINPUT: List of contract changes (from diff tool output \u2014 changed exports, signatures, types)\n\nSTEPS:\n1. For each changed export: use search to find imports and usages of that symbol\n2. Classify each change: BREAKING (callers must update) or COMPATIBLE (callers unaffected)\n3. List all files that import or use the changed exports\n\nOUTPUT FORMAT (MANDATORY \u2014 deviations will be rejected):\nBegin directly with BREAKING_CHANGES. Do NOT prepend conversational preamble.\n\nBREAKING_CHANGES: [list with affected consumer files, or \"none\"]\nExample: src/agents/explorer.ts \u2014 removed createExplorerAgent export (was used by 3 files)\nCOMPATIBLE_CHANGES: [list, or \"none\"]\nExample: src/config/constants.ts \u2014 added new optional field to Config interface\nCONSUMERS_AFFECTED: [list of files that import/use changed exports, or \"none\"]\nExample: src/agents/coder.ts, src/agents/reviewer.ts, src/main.ts\nCOMPATIBILITY SIGNALS: [COMPATIBLE | INCOMPATIBLE | UNCERTAIN \u2014 based on observable contract changes]\nExample: INCOMPATIBLE \u2014 removeExport changes function arity from 3 to 2\nMIGRATION_SURFACE: [yes \u2014 list of observable call signatures affected | no \u2014 no observable impact detected]\nExample: yes \u2014 createExplorerAgent(model, customPrompt?, customAppendPrompt?) \u2192 createExplorerAgent(model)\n\n## DOCUMENTATION DISCOVERY MODE\nActivates automatically during codebase reality check at plan ingestion.\nUse the doc_scan tool to scan and index documentation files. If doc_scan is unavailable, fall back to manual globbing.\n\nSTEPS:\n1. Call doc_scan to build the manifest, OR glob for documentation files:\n   - Root: README.md, CONTRIBUTING.md, CHANGELOG.md, ARCHITECTURE.md, CLAUDE.md, AGENTS.md, .github/*.md\n   - docs/**/*.md, doc/**/*.md (one level deep only)\n\n2. For each file found, read the first 30 lines. Extract:\n   - path: relative to project root\n   - title: first # heading, or filename if no heading\n   - summary: first non-empty paragraph after the title (max 200 chars, use the ACTUAL text, do NOT summarize with your own words)\n   - lines: total line count\n   - mtime: file modification timestamp\n\n3. Write manifest to .swarm/doc-manifest.json:\n   { \"schema_version\": 1, \"scanned_at\": \"ISO timestamp\", \"files\": [...] }\n\n4. For each file in the manifest, check relevance to the current plan:\n   - Score by keyword overlap: do any task file paths or directory names appear in the doc's path or summary?\n   - For files scoring > 0, read the full content and extract up to 5 actionable constraints per doc (max 200 chars each)\n   - Write constraints to .swarm/knowledge/doc-constraints.jsonl as knowledge entries with source: \"doc-scan\", category: \"architecture\"\n\n5. Invalidation: Only re-scan if any doc file's mtime is newer than the manifest's scanned_at. Otherwise reuse the cached manifest.\n\nRULES:\n- The manifest must be small (<100 lines). Pointers only, not full content.\n- Do NOT rephrase or summarize doc content with your own words \u2014 use the actual text from the file\n- Full doc content is only loaded when relevant to the current task, never preloaded\n";
 export declare const CURATOR_INIT_PROMPT = "## IDENTITY\nYou are Explorer in CURATOR_INIT mode. You consolidate prior session knowledge into an architect briefing.\nDO NOT use the Task tool to delegate. You ARE the agent that does the work.\n\nINPUT FORMAT:\nTASK: CURATOR_INIT\nPRIOR_SUMMARY: [JSON or \"none\"]\nKNOWLEDGE_ENTRIES: [JSON array of existing entries with UUIDs]\nPROJECT_CONTEXT: [context.md excerpt]\n\nACTIONS:\n- Read the prior summary to understand session history\n- Cross-reference knowledge entries against project context\n- Note contradictions (knowledge says X, project state shows Y)\n- Observe where lessons could be tighter or stale\n- Produce a concise briefing for the architect\n\nRULES:\n- Output under 2000 chars\n- No code modifications\n- Flag contradictions explicitly with CONTRADICTION: prefix\n- Memory proposals are for concise durable facts only. Do not propose raw API docs, web search snippets, crawl output, or transcripts as memory; cite their evidence-cache refs and propose only the stable fact they support.\n- If no prior summary exists, state \"First session \u2014 no prior context\"\n\nOUTPUT FORMAT:\nBRIEFING:\n[concise summary of prior session state, key decisions, active blockers]\n\nCONTRADICTIONS:\n- [entry_id]: [description] (or \"None detected\")\n\nOBSERVATIONS:\n- entry <uuid> appears high-confidence: [observable evidence]  (suggests boost confidence, mark hive_eligible)\n- entry <uuid> appears stale: [observable evidence]  (suggests archive \u2014 no longer injected)\n- entry <uuid> could be tighter: [what's verbose or duplicate]  (suggests rewrite with tighter version, max 280 chars)\n- entry <uuid> contradicts project state: [observable conflict]  (suggests tag as contradicted)\n- new candidate: [concise lesson text from observed patterns]  (suggests new entry)\nUse the UUID from KNOWLEDGE_ENTRIES when observing about existing entries. Use \"new candidate\" only when observing a potential new entry.\n\nKNOWLEDGE_STATS:\n- Entries reviewed: [N]\n- Prior phases covered: [N]\n";
 export declare const CURATOR_PHASE_PROMPT = "## IDENTITY\nYou are Explorer in CURATOR_PHASE mode. You consolidate a completed phase into a digest.\nDO NOT use the Task tool to delegate. You ARE the agent that does the work.\n\nINPUT FORMAT:\nTASK: CURATOR_PHASE [phase_number]\nPRIOR_DIGEST: [running summary or \"none\"]\nPHASE_EVENTS: [JSON array from events.jsonl for this phase]\nPHASE_EVIDENCE: [summary of evidence bundles]\nPHASE_DECISIONS: [decisions from context.md]\nAGENTS_DISPATCHED: [list]\nAGENTS_EXPECTED: [list from config]\nKNOWLEDGE_ENTRIES: [JSON array of existing entries with UUIDs]\n\nACTIONS:\n- Extend the prior digest with this phase's outcomes (do NOT regenerate from scratch)\n- Observe workflow deviations: missing reviewer, missing retro, skipped test_engineer\n- Report knowledge update candidates with observable evidence: entries that appear promoted, archived, rewritten, or contradicted\n- Summarize key decisions and blockers resolved\n\nRULES:\n- Output under 2000 chars\n- No code modifications\n- Compliance observations are READ-ONLY \u2014 report, do not enforce\n- OBSERVATIONS should not contain directives \u2014 report what is observed, do not instruct the architect what to do\n- Extend the digest, never replace it\n- Memory proposals are for concise durable facts only. Do not promote raw API docs, web search snippets, crawl output, or transcripts into memory; cite evidence-cache refs and propose only the stable fact they support.\n\nOUTPUT FORMAT:\nPHASE_DIGEST:\nphase: [N]\nsummary: [what was accomplished]\nagents_used: [list]\ntasks_completed: [N]/[total]\nkey_decisions: [list]\nblockers_resolved: [list]\n\nCOMPLIANCE:\n- [type] observed: [description] (or \"No deviations observed\")\n\nOBSERVATIONS:\n- entry <uuid> appears high-confidence: [observable evidence]  (suggests boost confidence, mark hive_eligible)\n- entry <uuid> appears stale: [observable evidence]  (suggests archive \u2014 no longer injected)\n- entry <uuid> could be tighter: [what's verbose or duplicate]  (suggests rewrite with tighter version, max 280 chars)\n- entry <uuid> contradicts project state: [observable conflict]  (suggests tag as contradicted)\n- new candidate: [concise lesson text from observed patterns]  (suggests new entry)\nUse the UUID from KNOWLEDGE_ENTRIES when observing about existing entries. Use \"new candidate\" only when observing a potential new entry.\n\nEXTENDED_DIGEST:\n[the full running digest with this phase appended]\n\n## V3 ACTIONABILITY ENRICHMENT (overrides the format above when triggered)\nWhen the input asks you to \"Convert this prose lesson into an actionable knowledge directive\", ignore the PHASE_DIGEST output format entirely and output ONLY a single JSON object \u2014 no fences, no commentary, no digest.\nMANDATORY fields (the directive is rejected without them):\n- at least one non-empty scope field: \"applies_to_agents\" (roles: architect, coder, reviewer, test_engineer, sme, docs, designer, critic, curator) or \"applies_to_tools\" (edit, write, patch, bash, read, grep, glob)\n- at least one non-empty predicate field: \"forbidden_actions\", \"required_actions\", or \"verification_checks\"\nOptional: \"triggers\" (short surfacing phrases), \"directive_priority\" (low|medium|high|critical).\nExample output:\n{\"applies_to_agents\":[\"coder\"],\"forbidden_actions\":[\"use async iterators in hot paths\"],\"required_actions\":[\"use a plain for loop in hot paths\"],\"triggers\":[\"hot path\",\"async iterator\"],\"directive_priority\":\"high\"}\n";
 export declare const CURATOR_POSTMORTEM_PROMPT = "## IDENTITY\nYou are Explorer in CURATOR_POSTMORTEM mode. You synthesize a project-end post-mortem from structured .swarm/ evidence.\nDO NOT use the Task tool to delegate. You ARE the agent that does the work.\nDO NOT scan raw source code \u2014 work only from the recorded evidence provided below.\n\nINPUT FORMAT:\nTASK: CURATOR_POSTMORTEM [plan_id]\nPLAN_SUMMARY: [plan phases, task counts, completion status]\nCURATOR_DIGESTS: [running digest from curator_phase across all phases]\nKNOWLEDGE_ENTRIES: [JSON array of existing entries with UUIDs]\nKNOWLEDGE_EVENTS_SUMMARY: [aggregated violation/applied/ignored counts per entry]\nPENDING_PROPOSALS: [skill/motif proposals awaiting triage]\nUNACTIONABLE_QUARANTINE: [entries flagged unactionable with retry status]\nDRIFT_REPORTS: [per-phase alignment/drift scores if available]\nRETROSPECTIVES: [any session retrospectives found]\n\nACTIONS:\n1. IMPROVEMENT AGENDA: Rank process + code improvement opportunities, each citing recorded evidence (task IDs, event records, evidence bundles). Focus on what would most reduce mistakes or increase reuse in the next project.\n2. FINAL CURATION PASS: Consolidate knowledge across phases \u2014 identify near-duplicate lessons that accumulated under different IDs, recommend hive promotion for project-proven entries (high confidence, multiple phases confirmed), flag never-applied entries past 3+ phases for review.\n3. QUEUE TRIAGE: For each pending proposal, recommend apply/reject with one-line reasoning. Surface unactionable-quarantine counts and retry candidates.\n4. LEARNING METRICS SUMMARY: Embed violation-rate trend, application rates, escalation frequency if metrics data is provided.\n\nRULES:\n- Output under 4000 chars\n- No code modifications \u2014 read-only synthesis\n- Every improvement item must cite a specific evidence artifact or event record\n- Do not invent evidence \u2014 if an artifact is missing, note the gap\n- Proposals route through existing gated paths (knowledge_add, skill proposals, hive promotion) \u2014 recommend the path, do not bypass it\n- HIGH-severity items that should become critical directives must be flagged for critic gate validation\n\nOUTPUT FORMAT:\nPOST_MORTEM_REPORT:\nplan_id: [plan identifier]\ngenerated_at: [ISO timestamp]\n\nIMPROVEMENT_AGENDA:\n1. [priority] [description] \u2014 evidence: [artifact/event ref]\n2. ...\n\nCURATION_RECOMMENDATIONS:\n- merge: [entry_a UUID] + [entry_b UUID] \u2014 [reason]\n- promote_to_hive: [entry UUID] \u2014 [evidence of cross-phase confirmation]\n- flag_stale: [entry UUID] \u2014 [never applied in N phases]\n- rewrite: [entry UUID] \u2014 [what's verbose/outdated]\n\nQUEUE_TRIAGE:\n- [proposal_id]: APPLY|REJECT \u2014 [one-line reasoning]\n\nLEARNING_METRICS:\n[3-line summary of trends if data available, or \"metrics data not provided\"]\n\nSUMMARY:\n[3-line executive summary for architect briefing]\n";

package/dist/background/candidate-parser.d.ts

@@ -119,6 +119,7 @@ export interface DiagnosticsSummary {
     degraded_source_count: number;
     incomplete_source_count: number;
     format_families_detected: string[];
+    format_mismatch_hint?: string;
 }
 /**
  * Top-level return value from parseCandidates.

package/dist/cli/{config-doctor-g04wdz19.js → config-doctor-fkwyrtpq.js}

@@ -12,8 +12,8 @@ import {
   shouldRunOnStartup,
   writeBackupArtifact,
   writeDoctorArtifact
-} from "./index-bywt2171.js";
-import"./index-123s7kjc.js";
+} from "./index-2jpbaedv.js";
+import"./index-xsbtbffr.js";
 import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
 import"./index-zgwm4ryv.js";

package/dist/cli/{explorer-h2fnj343.js → explorer-4ttwy7jd.js}

@@ -6,7 +6,7 @@ import {
   CURATOR_POSTMORTEM_PROMPT,
   EXPLORER_PROMPT,
   createExplorerAgent
-} from "./index-bm4f0nme.js";
+} from "./index-1x2608ga.js";
 import"./index-a76rekgs.js";
 export {
   createExplorerAgent,

package/dist/cli/{guardrail-explain-0ephhnjq.js → guardrail-explain-ygfy1qg9.js}

@@ -1,14 +1,14 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-wtyysb1n.js";
-import"./index-e9tp9p2w.js";
-import"./index-6tnmt41c.js";
-import"./index-bm4f0nme.js";
+} from "./index-zzza86z4.js";
+import"./index-dy1qpyh3.js";
+import"./index-ne4g3mk1.js";
+import"./index-1x2608ga.js";
 import"./index-5hrexm02.js";
 import"./index-w7gkpmq8.js";
-import"./index-bywt2171.js";
-import"./index-123s7kjc.js";
+import"./index-2jpbaedv.js";
+import"./index-xsbtbffr.js";
 import"./index-y1z6yaq4.js";
 import"./index-adz3nk9b.js";
 import"./index-v4fcn4tr.js";

package/dist/cli/{guardrail-log-m3285thy.js → guardrail-log-x3w800x5.js}

@@ -1,9 +1,9 @@
 // @bun
 import {
   handleGuardrailLog
-} from "./index-gg589mfw.js";
-import"./index-6tnmt41c.js";
-import"./index-123s7kjc.js";
+} from "./index-yykcmn6m.js";
+import"./index-ne4g3mk1.js";
+import"./index-xsbtbffr.js";
 import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
 import"./index-zgwm4ryv.js";

package/dist/cli/{index-bm4f0nme.js → index-1x2608ga.js}

@@ -99,6 +99,36 @@ FOLLOW-UP CANDIDATE AREAS:
 Example:
 src/tools/declare-scope.ts \u2014 function has 12 parameters, consider splitting; tool-authoring
 
+## CANDIDATE REPORTING MODE
+Activates when your prompt contains "[CANDIDATE]" anywhere in its text.
+
+When active, replace the default OUTPUT FORMAT above with structured pipe-delimited
+candidate rows. Emit exactly one row per finding:
+
+[CANDIDATE] | candidate_id | lane | severity | category | file:line | claim | evidence_summary | impact_context | confidence
+
+Field rules:
+- candidate_id: unique within this lane (e.g. C-001, C-002)
+- lane: your lane name or focus area
+- severity: INFO | LOW | MEDIUM | HIGH | CRITICAL
+- category: short category tag (e.g. null-safety, async-ordering, injection)
+- file:line: exact file path and line number (e.g. src/utils/cache.ts:142)
+- claim: one-sentence description of the issue
+- evidence_summary: what you observed in the code that supports the claim
+- impact_context: who or what is affected downstream
+- confidence: LOW | MEDIUM | HIGH
+
+Emit a header row first, then one [CANDIDATE] row per finding. Use pipe (|) to
+separate fields; escape literal pipe characters inside field values as \\|.
+
+If you find zero issues, emit the header row with no data rows. Do NOT fall back
+to the default PROJECT/STRUCTURE format when in candidate reporting mode.
+
+For micro-lane dispatches, use the micro-lane variant:
+[CANDIDATE] | candidate_id | micro_lane | severity | category | file:line | claim | invariant_violated | evidence_summary | confidence
+
+Do NOT use CONFIRMED, DISPROVED, or PRE_EXISTING \u2014 those are reviewer verdicts.
+
 ## INTEGRATION IMPACT ANALYSIS MODE
 Activates when delegated with "Integration impact analysis" or INPUT lists contract changes.
 

package/dist/cli/{index-bywt2171.js → index-2jpbaedv.js}

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

package/dist/cli/{index-gpkbg9p4.js → index-ary5jkky.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-wtyysb1n.js";
+} from "./index-zzza86z4.js";
 import {
   handleGuardrailLog
-} from "./index-gg589mfw.js";
+} from "./index-yykcmn6m.js";
 import {
   COMMAND_REGISTRY,
   SWARM_COMMAND_TOOL_ALLOWLIST,
@@ -78,17 +78,17 @@ import {
   handleWriteRetroCommand,
   normalizeSwarmCommandInput,
   resolveCommand
-} from "./index-e9tp9p2w.js";
-import"./index-6tnmt41c.js";
-import"./index-bm4f0nme.js";
+} from "./index-dy1qpyh3.js";
+import"./index-ne4g3mk1.js";
+import"./index-1x2608ga.js";
 import"./index-5hrexm02.js";
 import"./index-w7gkpmq8.js";
-import"./index-bywt2171.js";
+import"./index-2jpbaedv.js";
 import {
   AGENT_TOOL_MAP,
   ORCHESTRATOR_NAME,
   stripKnownSwarmPrefix
-} from "./index-123s7kjc.js";
+} from "./index-xsbtbffr.js";
 import"./index-y1z6yaq4.js";
 import"./index-adz3nk9b.js";
 import"./index-v4fcn4tr.js";

package/dist/cli/{index-e9tp9p2w.js → index-dy1qpyh3.js}

@@ -54,7 +54,7 @@ import {
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-bywt2171.js";
+} from "./index-2jpbaedv.js";
 import {
   AGENT_TOOL_MAP,
   ALL_SUBAGENT_NAMES,
@@ -67,7 +67,7 @@ import {
   TOOL_NAME_SET,
   resolveExternalSkillsConfig,
   stripKnownSwarmPrefix
-} from "./index-123s7kjc.js";
+} from "./index-xsbtbffr.js";
 import {
   MAX_TRANSIENT_RETRIES,
   PlanSchema,
@@ -906,7 +906,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.91.0",
+  version: "7.92.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",
@@ -6273,7 +6273,7 @@ async function runCuratorPostMortem(directory, options = {}) {
     let reportContent;
     if (options.llmDelegate) {
       try {
-        const { CURATOR_POSTMORTEM_PROMPT: CURATOR_POSTMORTEM_PROMPT2 } = await import("./explorer-h2fnj343.js");
+        const { CURATOR_POSTMORTEM_PROMPT: CURATOR_POSTMORTEM_PROMPT2 } = await import("./explorer-4ttwy7jd.js");
         const userInput = assembleLLMInput(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
         const ac = new AbortController;
         const timer = setTimeout(() => ac.abort(), 300000);
@@ -9074,7 +9074,7 @@ function isWriteToSwarmPlan(input) {
   const toolName = record.toolName;
   if (typeof toolName !== "string")
     return false;
-  if (!["write", "edit", "apply_patch"].includes(toolName))
+  if (!["write", "edit", "apply_patch", "swarm_apply_patch"].includes(toolName))
     return false;
   const rawPath = record.path;
   const rawFile = record.file;
@@ -9095,7 +9095,7 @@ function isWriteToEvidenceFile(input) {
   const toolName = record.toolName;
   if (typeof toolName !== "string")
     return false;
-  if (!["write", "edit", "apply_patch"].includes(toolName))
+  if (!["write", "edit", "apply_patch", "swarm_apply_patch"].includes(toolName))
     return false;
   const rawPath = record.path;
   const rawFile = record.file;
@@ -11626,7 +11626,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-t9th7frq.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-1kndsf0c.js");
     const { config: pmLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -15325,7 +15325,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-g04wdz19.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-fkwyrtpq.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true);
     output = formatDoctorMarkdown(fixResult.result);
   } else {
@@ -30387,7 +30387,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-gpkbg9p4.js");
+    const { buildHelpText } = await import("./index-ary5jkky.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -30396,7 +30396,7 @@ async function handleHelpCommand(ctx) {
     return _internals45.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals45.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-gpkbg9p4.js");
+  const { buildHelpText: fullHelp } = await import("./index-ary5jkky.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -30529,7 +30529,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-0ephhnjq.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-ygfy1qg9.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -30539,7 +30539,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-m3285thy.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-x3w800x5.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",

package/dist/cli/{index-6tnmt41c.js → index-ne4g3mk1.js}

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

package/dist/cli/{index-123s7kjc.js → index-xsbtbffr.js}

@@ -521,11 +521,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; join later with collect_lane_results",
+    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",
     agents: ["architect"]
   },
   collect_lane_results: {
-    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",
+    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.",
     agents: ["architect"]
   },
   summarize_work: {
@@ -570,8 +570,8 @@ var TOOL_METADATA = {
     description: "returns Lean Turbo configuration and active status for the current session",
     agents: []
   },
-  apply_patch: {
-    description: "Apply a unified diff patch to workspace files with exact context matching, atomic writes, and path validation",
+  swarm_apply_patch: {
+    description: "Apply a unified diff patch to workspace files with exact context matching, atomic writes, and path validation. Use standard unified diff format only \u2014 does NOT support *** Begin Patch / *** Update File payloads (use native apply_patch for those).",
     agents: ["coder", "test_engineer"]
   },
   external_skill_discover: {

package/dist/cli/{index-gg589mfw.js → index-yykcmn6m.js}

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

package/dist/cli/{index-wtyysb1n.js → index-zzza86z4.js}

@@ -12,14 +12,14 @@ import {
   detectPosixWrites,
   detectWindowsWrites,
   resolveWriteTargets
-} from "./index-e9tp9p2w.js";
+} from "./index-dy1qpyh3.js";
 import {
   checkFileAuthority,
   classifyFile,
   isInDeclaredScope,
   redactPath,
   redactShellCommand
-} from "./index-6tnmt41c.js";
+} from "./index-ne4g3mk1.js";
 
 // src/services/guardrail-explain-service.ts
 import path from "path";

package/dist/cli/index.js

@@ -7,15 +7,15 @@ import {
   getPluginLockFilePaths,
   package_default,
   resolveCommand
-} from "./index-e9tp9p2w.js";
-import"./index-6tnmt41c.js";
-import"./index-bm4f0nme.js";
+} from "./index-dy1qpyh3.js";
+import"./index-ne4g3mk1.js";
+import"./index-1x2608ga.js";
 import"./index-5hrexm02.js";
 import"./index-w7gkpmq8.js";
-import"./index-bywt2171.js";
+import"./index-2jpbaedv.js";
 import {
   DEFAULT_AGENT_CONFIGS
-} from "./index-123s7kjc.js";
+} from "./index-xsbtbffr.js";
 import"./index-y1z6yaq4.js";
 import"./index-adz3nk9b.js";
 import"./index-v4fcn4tr.js";

package/dist/cli/{schema-t9th7frq.js → schema-1kndsf0c.js}

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

package/dist/config/constants.d.ts

@@ -25,7 +25,7 @@ export declare const TURBO_AGENT_TOOL_MAP: Partial<Record<AgentName, ToolName[]>
  * NOTE: bash/shell tools are intentionally excluded — bash commands are opaque
  * to static scope analysis. Post-hoc detection via guardrails diff-scope provides secondary coverage.
  */
-export declare const WRITE_TOOL_NAMES: readonly ["write", "edit", "patch", "apply_patch", "create_file", "insert", "replace", "append", "prepend"];
+export declare const WRITE_TOOL_NAMES: readonly ["write", "edit", "patch", "apply_patch", "swarm_apply_patch", "create_file", "insert", "replace", "append", "prepend"];
 export type WriteToolName = (typeof WRITE_TOOL_NAMES)[number];
 export declare const DEFAULT_MODELS: Record<string, string>;
 export declare const DEFAULT_AGENT_CONFIGS: Record<string, {

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.91.0",
+    version: "7.92.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",
@@ -698,11 +698,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; join later with collect_lane_results",
+      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",
       agents: ["architect"]
     },
     collect_lane_results: {
-      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",
+      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.",
       agents: ["architect"]
     },
     summarize_work: {
@@ -747,8 +747,8 @@ var init_tool_metadata = __esm(() => {
       description: "returns Lean Turbo configuration and active status for the current session",
       agents: []
     },
-    apply_patch: {
-      description: "Apply a unified diff patch to workspace files with exact context matching, atomic writes, and path validation",
+    swarm_apply_patch: {
+      description: "Apply a unified diff patch to workspace files with exact context matching, atomic writes, and path validation. Use standard unified diff format only — does NOT support *** Begin Patch / *** Update File payloads (use native apply_patch for those).",
       agents: ["coder", "test_engineer"]
     },
     external_skill_discover: {
@@ -1185,6 +1185,7 @@ var init_constants = __esm(() => {
     "edit",
     "patch",
     "apply_patch",
+    "swarm_apply_patch",
     "create_file",
     "insert",
     "replace",
@@ -43289,7 +43290,7 @@ function createToolBeforeHandler(ctx) {
           }
         }
       }
-      if (tool === "apply_patch" || tool === "patch") {
+      if (tool === "apply_patch" || tool === "swarm_apply_patch" || tool === "patch") {
         const agentName = swarmState.activeAgent.get(sessionID) ?? "unknown";
         const cwd = effectiveDirectory;
         for (const p of extractPatchTargetPaths(tool, args2)) {
@@ -43432,16 +43433,23 @@ function createToolBeforeHandler(ctx) {
     return payloads.some((p) => re.test(p));
   }
   function extractPatchTargetPaths(tool, args2) {
-    if (tool !== "apply_patch" && tool !== "patch")
+    if (tool !== "apply_patch" && tool !== "swarm_apply_patch" && tool !== "patch")
       return [];
     const toolArgs = args2;
+    const paths = new Set;
+    if (Array.isArray(toolArgs?.files)) {
+      for (const f of toolArgs.files) {
+        if (typeof f === "string" && f.length > 0 && f !== "/dev/null") {
+          paths.add(f);
+        }
+      }
+    }
     const patchText = toolArgs?.input ?? toolArgs?.patch ?? toolArgs?.diff ?? (Array.isArray(toolArgs?.cmd) ? toolArgs.cmd[1] : undefined);
     if (typeof patchText !== "string")
-      return [];
+      return Array.from(paths);
     if (patchText.length > 1e6) {
       throw new Error("WRITE BLOCKED: Patch payload exceeds 1 MB — authority cannot be verified for all modified paths. Split into smaller patches.");
     }
-    const paths = new Set;
     const patchPathPattern = /\*\*\*\s+(?:Update|Add|Delete)\s+File:\s*(.+)/gi;
     const diffPathPattern = /\+\+\+\s+b\/(.+)/gm;
     const gitDiffPathPattern = /^diff --git a\/(.+?) b\/(.+?)$/gm;
@@ -43483,9 +43491,9 @@ function createToolBeforeHandler(ctx) {
   function handlePlanAndScopeProtection(sessionID, tool, args2) {
     const toolArgs = args2;
     const targetPath = toolArgs?.filePath ?? toolArgs?.path ?? toolArgs?.file ?? toolArgs?.target;
-    if (tool === "apply_patch" || tool === "patch") {
+    if (tool === "apply_patch" || tool === "swarm_apply_patch" || tool === "patch") {
       if (patchPayloadHasHumanOnlyInvocation(args2)) {
-        throw new Error("BLOCKED: apply_patch would introduce a script invoking a human-only swarm CLI subcommand. " + "Present the situation to the user and ask them to run the command themselves.");
+        throw new Error("BLOCKED: apply_patch/swarm_apply_patch would introduce a script invoking a human-only swarm CLI subcommand. " + "Present the situation to the user and ask them to run the command themselves.");
       }
     }
     if (typeof targetPath === "string" && targetPath.length > 0) {
@@ -43504,7 +43512,7 @@ function createToolBeforeHandler(ctx) {
         throw new Error("BLOCKED: write/edit tool would create a script invoking a human-only swarm CLI subcommand. " + "Present the situation to the user and ask them to run the command themselves.");
       }
     }
-    if (!targetPath && (tool === "apply_patch" || tool === "patch")) {
+    if (!targetPath && (tool === "apply_patch" || tool === "swarm_apply_patch" || tool === "patch")) {
       for (const p of extractPatchTargetPaths(tool, args2)) {
         const resolvedP = path28.resolve(effectiveDirectory, p);
         const planMdPath = path28.resolve(effectiveDirectory, ".swarm", "plan.md").toLowerCase();
@@ -43520,7 +43528,7 @@ function createToolBeforeHandler(ctx) {
           const session = swarmState.agentSessions.get(sessionID);
           if (session) {
             session.architectWriteCount++;
-            warn("Architect direct code edit detected via apply_patch", {
+            warn("Architect direct code edit detected via patch tool", {
               tool,
               sessionID,
               targetPath: p,
@@ -43872,7 +43880,7 @@ function createToolBeforeHandler(ctx) {
         }
       }
     }
-    if (input.tool === "apply_patch" || input.tool === "patch") {
+    if (input.tool === "apply_patch" || input.tool === "swarm_apply_patch" || input.tool === "patch") {
       const patchAgentName = swarmState.activeAgent.get(input.sessionID) ?? "unknown";
       if (!swarmState.activeAgent.has(input.sessionID)) {
         throw new Error(`WRITE BLOCKED: No active agent registered for session "${input.sessionID}". Call startAgentSession before issuing write tool calls.`);
@@ -62812,6 +62820,36 @@ FOLLOW-UP CANDIDATE AREAS:
 Example:
 src/tools/declare-scope.ts — function has 12 parameters, consider splitting; tool-authoring
 
+## CANDIDATE REPORTING MODE
+Activates when your prompt contains "[CANDIDATE]" anywhere in its text.
+
+When active, replace the default OUTPUT FORMAT above with structured pipe-delimited
+candidate rows. Emit exactly one row per finding:
+
+[CANDIDATE] | candidate_id | lane | severity | category | file:line | claim | evidence_summary | impact_context | confidence
+
+Field rules:
+- candidate_id: unique within this lane (e.g. C-001, C-002)
+- lane: your lane name or focus area
+- severity: INFO | LOW | MEDIUM | HIGH | CRITICAL
+- category: short category tag (e.g. null-safety, async-ordering, injection)
+- file:line: exact file path and line number (e.g. src/utils/cache.ts:142)
+- claim: one-sentence description of the issue
+- evidence_summary: what you observed in the code that supports the claim
+- impact_context: who or what is affected downstream
+- confidence: LOW | MEDIUM | HIGH
+
+Emit a header row first, then one [CANDIDATE] row per finding. Use pipe (|) to
+separate fields; escape literal pipe characters inside field values as \\|.
+
+If you find zero issues, emit the header row with no data rows. Do NOT fall back
+to the default PROJECT/STRUCTURE format when in candidate reporting mode.
+
+For micro-lane dispatches, use the micro-lane variant:
+[CANDIDATE] | candidate_id | micro_lane | severity | category | file:line | claim | invariant_violated | evidence_summary | confidence
+
+Do NOT use CONFIRMED, DISPROVED, or PRE_EXISTING — those are reviewer verdicts.
+
 ## INTEGRATION IMPACT ANALYSIS MODE
 Activates when delegated with "Integration impact analysis" or INPUT lists contract changes.
 
@@ -70106,7 +70144,7 @@ function isWriteToSwarmPlan(input) {
   const toolName = record3.toolName;
   if (typeof toolName !== "string")
     return false;
-  if (!["write", "edit", "apply_patch"].includes(toolName))
+  if (!["write", "edit", "apply_patch", "swarm_apply_patch"].includes(toolName))
     return false;
   const rawPath = record3.path;
   const rawFile = record3.file;
@@ -70127,7 +70165,7 @@ function isWriteToEvidenceFile(input) {
   const toolName = record3.toolName;
   if (typeof toolName !== "string")
     return false;
-  if (!["write", "edit", "apply_patch"].includes(toolName))
+  if (!["write", "edit", "apply_patch", "swarm_apply_patch"].includes(toolName))
     return false;
   const rawPath = record3.path;
   const rawFile = record3.file;
@@ -95786,7 +95824,7 @@ function deriveAction(tool3) {
   const toolLower = tool3.toLowerCase();
   if (toolLower === "task")
     return "delegate";
-  if (["write", "edit", "apply_patch"].includes(toolLower))
+  if (["write", "edit", "apply_patch", "swarm_apply_patch"].includes(toolLower))
     return "edit";
   if (["read", "glob", "search"].includes(toolLower))
     return "read";
@@ -101265,7 +101303,7 @@ Output to .swarm/plan.md MUST use "## Phase N" headers. Do not write MODE labels
 1. DELEGATE all coding to {{AGENT_PREFIX}}coder. You do NOT write code.
 // IMPORTANT: This list is auto-generated from AGENT_TOOL_MAP['architect'] in src/config/constants.ts
 YOUR TOOLS: {{YOUR_TOOLS}}
-CODER'S TOOLS: write, edit, patch, apply_patch, create_file, insert, replace — any tool that modifies file contents.
+CODER'S TOOLS: write, edit, patch, apply_patch, swarm_apply_patch, create_file, insert, replace — any tool that modifies file contents.
 If a tool modifies a file, it is a CODER tool. Delegate.
 <!-- BEHAVIORAL_GUIDANCE_START -->
 1a. SCOPE DISCIPLINE — call declare_scope BEFORE every coder delegation AND before any test_engineer delegation that will write new test files.
@@ -101307,7 +101345,7 @@ Two small delegations with two QA gates > one large delegation with one QA gate.
       ✗ "I already know what to write" → knowing what to write is planning, not writing. Delegate to {{AGENT_PREFIX}}coder.
       ✗ "It's faster if I just do it" → speed without QA gates is how bugs ship
       ✗ "The coder succeeded on the last tasks, this one is trivial" → Rule 1 has no complexity exemption
-      ✗ "I'll just use apply_patch / edit / write directly" → these are coder tools, not architect tools
+      ✗ "I'll just use apply_patch / swarm_apply_patch / edit / write directly" → these are coder tools, not architect tools
       ✗ "I'll do the simple parts, coder does the hard parts" → ALL parts go to coder. You are not a coder.
       ✗ "This is time-critical / urgent / blocking" → WRONG. You are an AI with no deadlines. No urgency is real. Delegate to {{AGENT_PREFIX}}coder.
       ✗ "The fix is obvious — explaining it takes more effort than doing it" → WRONG. Writing the task spec IS your job. Delegate the implementation.
@@ -103669,6 +103707,7 @@ ${customAppendPrompt}`;
         edit: false,
         patch: false,
         apply_patch: false,
+        swarm_apply_patch: false,
         create_file: false,
         insert: false,
         replace: false,
@@ -111418,7 +111457,7 @@ function extractMessageText2(msg) {
 `);
 }
 function extractToolName(text) {
-  const match = text.match(/^(read_file|write|edit|apply_patch|task|bun|npm|git|bash|glob|grep|mkdir|cp|mv|rm)\b/i);
+  const match = text.match(/^(read_file|write|edit|apply_patch|swarm_apply_patch|task|bun|npm|git|bash|glob|grep|mkdir|cp|mv|rm)\b/i);
   return match?.[1];
 }
 function shouldMaskToolOutput(msg, index, totalMessages, recentWindowSize, threshold) {
@@ -120877,7 +120916,14 @@ function createCoChangeSuggesterHook(directory) {
   const hook = async (input, _output) => {
     const record3 = input;
     const toolName = typeof record3.tool === "string" ? record3.tool : "";
-    if (!["write", "edit", "apply_patch", "patch", "create_file"].includes(toolName)) {
+    if (![
+      "write",
+      "edit",
+      "apply_patch",
+      "swarm_apply_patch",
+      "patch",
+      "create_file"
+    ].includes(toolName)) {
       return;
     }
     const toolInput = record3.input;
@@ -124491,6 +124537,7 @@ var WRITE_EDIT_TOOLS = new Set([
   "write",
   "edit",
   "apply_patch",
+  "swarm_apply_patch",
   "create_file"
 ]);
 var NEW_EXPORT_RE = /^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm;
@@ -125776,8 +125823,12 @@ function buildErrorResult(message) {
     }
   };
 }
-var applyPatch = createSwarmTool({
-  description: "Apply a unified diff patch to workspace files. Validates paths, matches context exactly, and writes atomically. Coder-scoped write tool.",
+function isUnsupportedPatchFormat(patchText) {
+  const trimmed = patchText.trimStart();
+  return trimmed.startsWith("*** Begin Patch") || trimmed.startsWith("*** Update File") || trimmed.startsWith("*** Add File") || trimmed.startsWith("*** Delete File") || trimmed.startsWith("*** End Patch");
+}
+var swarmApplyPatch = createSwarmTool({
+  description: "Apply a unified diff patch to workspace files. Validates paths, matches context exactly, and writes atomically. Coder-scoped write tool. Use standard unified diff format (--- a/file / +++ b/file / @@ hunks). Does NOT support *** Begin Patch / *** Update File payloads — use the native apply_patch tool for those.",
   args: {
     patch: exports_external.string().min(1).describe("Unified diff text to parse and apply"),
     files: exports_external.array(exports_external.string()).min(1).describe("Array of target file paths the patch is expected to touch. Every parsed target must appear in this list."),
@@ -125787,7 +125838,7 @@ var applyPatch = createSwarmTool({
   },
   execute: async (args2, directory) => {
     if (!args2 || typeof args2 !== "object") {
-      return JSON.stringify(buildErrorResult("Could not parse apply_patch arguments"), null, 2);
+      return JSON.stringify(buildErrorResult("Could not parse swarm_apply_patch arguments"), null, 2);
     }
     const obj = args2;
     const patchText = obj.patch ?? "";
@@ -125804,6 +125855,9 @@ var applyPatch = createSwarmTool({
     if (!patchText || patchText.trim() === "") {
       return JSON.stringify(buildErrorResult("patch text cannot be empty"), null, 2);
     }
+    if (isUnsupportedPatchFormat(patchText)) {
+      return JSON.stringify(buildErrorResult("Unsupported patch format: *** Begin Patch / *** Update File style payloads are not supported by swarm_apply_patch. " + "Use the native apply_patch tool for this format, or provide a standard unified diff (--- a/file / +++ b/file / @@ hunks)."), null, 2);
+    }
     for (const filePath of files) {
       const validationError = validatePatchTargetPath(filePath, directory);
       if (validationError) {
@@ -130096,6 +130150,20 @@ 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 EXPLORER_CANDIDATE_FORMAT_SUFFIX = `
+
+IMPORTANT — OUTPUT FORMAT REQUIREMENT:
+You MUST emit your findings as pipe-delimited [CANDIDATE] rows.
+Header row first, then one row per finding.
+
+Standard explorer format (use unless the prompt specifies micro-lane work):
+[CANDIDATE] | candidate_id | lane | severity | category | file:line | claim | evidence_summary | impact_context | confidence
+
+Micro-lane format (use when the prompt references invariant checking or micro_lane):
+[CANDIDATE] | candidate_id | micro_lane | severity | category | file:line | claim | invariant_violated | evidence_summary | confidence
+
+If you find zero issues, emit only the header row with no data rows.
+Do NOT use the default PROJECT/STRUCTURE output format for this dispatch.`;
 var READ_ONLY_LANE_ROLES = new Set([
   "explorer",
   "reviewer",
@@ -130157,7 +130225,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(),
+  include_pending: exports_external.boolean().optional().describe("Include pending/running lanes in results with partial output; useful for progress checks during non-blocking polls"),
   cancel_pending: exports_external.boolean().optional().describe("Abort and mark pending/running lanes cancelled")
 });
 var _internals91 = {
@@ -130199,7 +130267,7 @@ async function executeDispatchLanes(args2, directory, context = {}) {
       errors: common.errors
     });
   }
-  const lanes = common.lanes;
+  const lanes = applyExplorerFormatSuffix(common.lanes);
   const maxConcurrent = Math.min(parsed.data.max_concurrent ?? lanes.length, lanes.length, MAX_LANES);
   const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_TIMEOUT_MS3;
   const dispatcher = _internals91.createParallelDispatcher({
@@ -130247,7 +130315,7 @@ async function executeDispatchLanesAsync(args2, directory, context = {}) {
       errors: common.errors
     });
   }
-  const lanes = common.lanes;
+  const lanes = applyExplorerFormatSuffix(common.lanes);
   const batchId = parsed.data.batch_id ?? makeBatchId();
   if (findByBatchId(directory, batchId).length > 0) {
     return asyncFailureResult({
@@ -130888,6 +130956,22 @@ function applyCommonPrompt(lanes, commonPrompt) {
     return { ok: false, errors: errors5 };
   return { ok: true, lanes: merged };
 }
+function applyExplorerFormatSuffix(lanes) {
+  const generatedAgentNames = _internals91.getGeneratedAgentNames();
+  return lanes.map((lane) => {
+    const role = resolveGeneratedAgentRole(lane.agent, generatedAgentNames);
+    if (role !== "explorer")
+      return lane;
+    if (lane.prompt.includes("[CANDIDATE]"))
+      return lane;
+    const prompt = `${lane.prompt}${EXPLORER_CANDIDATE_FORMAT_SUFFIX}`;
+    if (prompt.length > MAX_PROMPT_CHARS) {
+      console.warn(`[dispatch-lanes] applyExplorerFormatSuffix: lane "${lane.id}" prompt too long ` + `(${lane.prompt.length} chars + suffix = ${prompt.length}, max ${MAX_PROMPT_CHARS}); ` + `format enforcement skipped — explorer may not emit [CANDIDATE] rows`);
+      return lane;
+    }
+    return { ...lane, prompt };
+  });
+}
 function findDuplicateLaneIds(lanes) {
   const seen = new Set;
   const duplicates = new Set;
@@ -130987,7 +131071,7 @@ 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 tasks while the lanes run, then call collect_lane_results to join. 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 (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.",
   args: {
     lanes: DispatchLanesAsyncArgsSchema.shape.lanes,
     common_prompt: DispatchLanesAsyncArgsSchema.shape.common_prompt,
@@ -131007,7 +131091,7 @@ var dispatch_lanes_async = createSwarmTool({
   }
 });
 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.",
+  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.",
   args: {
     batch_id: CollectLaneResultsArgsSchema.shape.batch_id,
     wait: CollectLaneResultsArgsSchema.shape.wait,
@@ -138790,12 +138874,33 @@ function refusalResult(errorCode, errorMessage3, input, flags) {
     diagnostics: buildEmptyDiagnostics(input, flags)
   };
 }
+function detectFormatMismatchHint(text) {
+  if (text.trim() === "")
+    return;
+  const severityPattern = /\b(CRITICAL|HIGH|MEDIUM|LOW|INFO)\b/;
+  const fileLinePattern = /\b\S+\.[a-z]{1,4}:\d+\b/;
+  const hasSeverity = severityPattern.test(text);
+  const textForFileLine = text.replace(/\b\w+:\/\/\S*/g, "");
+  const hasFileLine = fileLinePattern.test(textForFileLine);
+  if (hasSeverity && hasFileLine) {
+    return "Lane output contains severity keywords and file:line references but no parseable [CANDIDATE] rows. The explorer may have emitted findings in prose format instead of pipe-delimited candidate rows.";
+  }
+  if (hasSeverity) {
+    return "Lane output contains severity keywords but no parseable [CANDIDATE] rows. The explorer may have emitted findings in an unstructured format.";
+  }
+  return;
+}
 function emptyTextResult(input, flags) {
   const envelope = buildInvocationEnvelope(input, flags, [], 0, 0, 0);
+  const diagnostics = buildEmptyDiagnostics(input, flags);
+  const hint = detectFormatMismatchHint(input.text);
+  if (hint) {
+    diagnostics.format_mismatch_hint = hint;
+  }
   return {
     candidates: [],
     invocation_envelope: envelope,
-    diagnostics: buildEmptyDiagnostics(input, flags)
+    diagnostics
   };
 }
 function parseCandidates(input, flags) {
@@ -138982,20 +139087,27 @@ ${trimmed}`;
   }
   const parseErrors = parseErrorDetails.length;
   const envelope = buildInvocationEnvelope(input, flags, Array.from(formatFamiliesDetected), candidates.length, parseErrors, malformedRows);
+  const diagnostics = {
+    candidate_count: candidates.length,
+    parse_errors: parseErrors,
+    parse_error_details: parseErrorDetails,
+    malformed_rows: malformedRows,
+    duplicate_id_count: duplicateIdCount,
+    duplicate_id_warnings: duplicateIdWarnings,
+    degraded_source_count: flags.degraded ? 1 : 0,
+    incomplete_source_count: input.transcriptIncomplete ? 1 : 0,
+    format_families_detected: Array.from(formatFamiliesDetected)
+  };
+  if (candidates.length === 0) {
+    const hint = detectFormatMismatchHint(input.text);
+    if (hint) {
+      diagnostics.format_mismatch_hint = hint;
+    }
+  }
   return {
     candidates,
     invocation_envelope: envelope,
-    diagnostics: {
-      candidate_count: candidates.length,
-      parse_errors: parseErrors,
-      parse_error_details: parseErrorDetails,
-      malformed_rows: malformedRows,
-      duplicate_id_count: duplicateIdCount,
-      duplicate_id_warnings: duplicateIdWarnings,
-      degraded_source_count: flags.degraded ? 1 : 0,
-      incomplete_source_count: input.transcriptIncomplete ? 1 : 0,
-      format_families_detected: Array.from(formatFamiliesDetected)
-    }
+    diagnostics
   };
 }
 function parseAndPersist(input, flags, options) {
@@ -154335,7 +154447,7 @@ var TOOL_MANIFEST = defineHandlers({
   lean_turbo_review: () => lean_turbo_review,
   lean_turbo_run_phase: () => lean_turbo_run_phase,
   lean_turbo_status: () => lean_turbo_status,
-  apply_patch: () => applyPatch,
+  swarm_apply_patch: () => swarmApplyPatch,
   external_skill_discover: () => external_skill_discover,
   external_skill_list: () => external_skill_list,
   external_skill_inspect: () => external_skill_inspect,

package/dist/tools/apply-patch.d.ts

@@ -45,4 +45,10 @@ export interface ApplyPatchArgs {
     allowCreates?: boolean;
     allowDeletes?: boolean;
 }
-export declare const applyPatch: ToolDefinition;
+/**
+ * Swarm unified-diff patch tool (formerly registered as apply_patch).
+ * Renamed to swarm_apply_patch so it no longer shadows the native opencode
+ * apply_patch tool. The native tool handles *** Begin Patch / *** Update File
+ * style payloads; this tool handles standard unified diffs only.
+ */
+export declare const swarmApplyPatch: ToolDefinition;

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

@@ -201,6 +201,7 @@ export declare const _internals: {
 };
 export declare const _test_exports: {
     applyCommonPrompt: typeof applyCommonPrompt;
+    applyExplorerFormatSuffix: typeof applyExplorerFormatSuffix;
     extractAssistantTranscript: typeof extractAssistantTranscript;
     formatError: typeof formatError;
     nextCollectPollInterval: typeof nextCollectPollInterval;
@@ -274,6 +275,7 @@ type ApplyCommonPromptResult = {
  * prompts when it is. Callers may treat the returned array as their own.
  */
 declare function applyCommonPrompt(lanes: DispatchLaneSpec[], commonPrompt: string | undefined): ApplyCommonPromptResult;
+declare function applyExplorerFormatSuffix(lanes: DispatchLaneSpec[]): DispatchLaneSpec[];
 declare function formatError(error: unknown): string;
 declare function promptHash(lane: DispatchLaneSpec, directory: string, batchId: string): string;
 export declare const dispatch_lanes: ReturnType<typeof createSwarmTool>;

package/dist/tools/index.d.ts

@@ -1,6 +1,6 @@
-import { applyPatch } from './apply-patch';
-export { applyPatch };
-export declare const apply_patch: typeof applyPatch;
+import { swarmApplyPatch } from './apply-patch';
+export { swarmApplyPatch };
+export declare const swarm_apply_patch: typeof swarmApplyPatch;
 export { batch_symbols } from './batch-symbols';
 export { build_check } from './build-check';
 export { check_gate_status } from './check-gate-status';

package/dist/tools/manifest.d.ts

@@ -112,7 +112,7 @@ export declare const TOOL_MANIFEST: {
     lean_turbo_review: () => ToolDefinition;
     lean_turbo_run_phase: () => ToolDefinition;
     lean_turbo_status: () => ToolDefinition;
-    apply_patch: () => ToolDefinition;
+    swarm_apply_patch: () => ToolDefinition;
     external_skill_discover: () => ToolDefinition;
     external_skill_list: () => ToolDefinition;
     external_skill_inspect: () => ToolDefinition;

package/dist/tools/tool-metadata.d.ts

@@ -379,7 +379,7 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: never[];
     };
-    apply_patch: {
+    swarm_apply_patch: {
         description: string;
         agents: ("test_engineer" | "coder")[];
     };

package/package.json

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