opencode-swarm 7.83.0 → 7.85.0

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

@@ -138,6 +138,8 @@ Before writing under `.swarm/`, verify `.swarm/` is ignored or locally excluded.
 
 Collect every async batch with `collect_lane_results` before consuming its ledger output or advancing to a dependent step. If `dispatch_lanes_async` or `collect_lane_results` is unavailable, fall back to blocking `dispatch_lanes`; if deterministic dispatch is unavailable, run isolated local passes and record that fallback. Do not run dependent inventory passes merely to keep agents busy. Missing dependency context is `unknown`, not guessed.
 
+For every collected or blocking lane result, treat `output` as a preview when `output_ref` is present. Call `retrieve_lane_output` and use the full artifact before consuming inventory ledgers, linking claims, deciding that a unit produced no candidates, or advancing a dependent step. If a lane is degraded, incomplete, truncated without a usable ref, missing, stale, cancelled, or failed, record the affected coverage unit as a limitation and re-dispatch a narrower lane or mark it UNVERIFIED; do not infer absence from preview text.
+
 ## Phase 0 inventory
 
 ### 0A — Bootstrap and prior context
@@ -207,6 +209,8 @@ Rules:
 
 Every dispatch includes selected track(s), exact file list or surface IDs, source-of-truth packet, repository-context packet, relevant ledgers, the applicable `TRACK_DEPTH_PLAN`, candidate format, `out_of_scope_note` rule, and anti-cursory/non-dilution reminder. Prefer `dispatch_lanes_async` for independent candidate-generation coverage units so the Architect can continue building the review ledger, coverage map, and validation routing while lanes inspect subsystems. Call `collect_lane_results` before Phase 2 reviewer validation; no candidate may be routed, counted, or synthesized until its async batch has settled or been explicitly marked blocked/skipped.
 
+If candidate-generation lane results include `output_ref`, retrieve and parse the full artifact before candidate counting, deduplication, routing, or synthesis. Preview-only, degraded, or incomplete lane output is a coverage limitation, not negative evidence.
+
 File-size rule: no more than 15 files per deep pass; no more than 8 dense files per deep pass. Dense = >300 logical lines, multiple unrelated responsibilities, or interleaved UI/state/network/security logic. No sampling inside assigned scope. Large selections require more deep passes, not larger batches or lower depth.
 
 Candidate micro-loop:

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

@@ -113,7 +113,12 @@ Do NOT share other agents' responses at this stage.
    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. These come from the agents' JSON output; no
+   `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

@@ -75,6 +75,8 @@ Explorer missions are dispatched in parallel waves. Launch the wave promptly —
 
 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.
 
+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.
+
 Explorers generate CANDIDATE FINDINGS only — they do NOT make verdicts. All findings are unverified until Step 5.
 
 ## Step 4 — Normalize Candidates

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

@@ -128,6 +128,12 @@ that async advisory lanes were unavailable.
 
 ## Step 5 — Dual-Reviewer Claim Verification
 
+When a lane result includes `output_ref`, treat `output` as a preview and call
+`retrieve_lane_output` before extracting claims, summarizing a subtopic, or marking
+the subtopic clean. If the result is `output_degraded`, `transcript_incomplete`, or
+truncated without a usable ref, mark the affected subtopic UNVERIFIED or
+re-dispatch a narrower lane; do not treat preview absence as evidence absence.
+
 Split the candidate findings into 2 shards. Dispatch 2 parallel
 `the active swarm's reviewer agent` calls. Each reviewer receives its shard plus
 the relevant RESEARCH CONTEXT and the instruction:

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

@@ -172,6 +172,12 @@ Missing, stale, cancelled, or failed lanes remain explicit ledger limitations.
 If `dispatch_lanes_async` is unavailable, use blocking verification and record
 that async advisory lanes were unavailable.
 
+When a verification lane result includes `output_ref`, treat `output` as a
+preview and call `retrieve_lane_output` before using it to classify, resolve,
+disprove, or group feedback items. If the result is `output_degraded`,
+`transcript_incomplete`, or truncated without a usable ref, keep the affected
+ledger items as `NEEDS_MORE_EVIDENCE` or re-dispatch a narrower read-only lane.
+
 ### CI matrix cascade check (do this before fixing)
 
 When the PR's `unit` job is a matrix across multiple OSes and downstream jobs

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

@@ -495,6 +495,8 @@ Launch all base lanes with `dispatch_lanes_async` when available. Pass the six l
 
 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.
 
+When any collected or blocking `lane_results[]` item has `output_ref`, treat `output` as a preview only. Call `retrieve_lane_output` and consume the full artifact before extracting candidates, deciding that a lane produced no candidates, or routing work to reviewers. If a lane has `output_truncated: true`, `output_degraded: true`, `transcript_incomplete: true`, or no usable `output_ref`, record an explicit coverage gap and re-dispatch a narrower lane or mark affected candidates/coverage UNVERIFIED; never infer candidate absence from a preview.
+
 **lane id uniqueness for parallel dispatches:** When re-dispatching failed or re-running explorer lanes, every `dispatch_lanes_async` or `dispatch_lanes` lane `id` MUST be unique within that dispatch batch and should include lane and attempt suffixes (e.g. `pr_review_explore_lane1_attempt2`). Never reuse an id in the same batch unless intentionally replacing that exact lane before dispatch.
 
 Explorers optimize for recall. Over-reporting is expected. Explorers produce candidates only.
@@ -535,6 +537,8 @@ Explorers must not use `CONFIRMED`, `DISPROVED`, or `PRE_EXISTING`.
 
 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.
 
+Apply the same `output_ref` rule to micro-lanes: retrieve full output before candidate routing, and treat degraded or incomplete lane artifacts as UNVERIFIED coverage rather than as clean negative evidence.
+
 Each micro-lane receives:
 
 - exact files and hunks in scope,

package/README.md

@@ -1080,7 +1080,9 @@ Control how tool outputs are summarized for LLM context.
 | `/swarm agents` | Registered agents with models and permissions |
 | `/swarm history` | Completed phases with status |
 | `/swarm config` | Current resolved configuration |
-| `/swarm diagnose` | Health check for `.swarm/` files and config |
+| `/swarm diagnose` | Health check for `.swarm/` files, config, and sandbox executor status |
+| `/swarm guardrail explain [--agent <role>] [--scope <path>] [--write <path>...] [--] <command>` | Dry-run guardrail decisions — report what would be allowed/blocked without executing anything |
+| `/swarm guardrail-log [--blocks-only]` | Read and print the guardrail decision log most-recent-first; `--blocks-only` shows only block decisions |
 | `/swarm export` | Export plan and context as portable JSON |
 | `/swarm evidence [task]` | Evidence bundles for a task or all tasks |
 | `/swarm archive [--dry-run]` | Archive old evidence with retention policy |

package/dist/background/lane-output-store.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+export declare const LANE_OUTPUT_REF_PREFIX = "L1";
+export declare const MAX_LANE_OUTPUT_STORED_BYTES: number;
+declare const LaneOutputArtifactSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    ref: z.ZodString;
+    batchId: z.ZodString;
+    laneId: z.ZodString;
+    agent: z.ZodString;
+    role: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    parentSessionId: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodString>;
+    source: z.ZodEnum<{
+        dispatch_lanes: "dispatch_lanes";
+        collect_lane_results: "collect_lane_results";
+    }>;
+    text: z.ZodString;
+    chars: z.ZodNumber;
+    bytes: z.ZodNumber;
+    digest: z.ZodString;
+    messageCount: z.ZodOptional<z.ZodNumber>;
+    transcriptIncomplete: z.ZodOptional<z.ZodBoolean>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export type LaneOutputSource = z.infer<typeof LaneOutputArtifactSchema>['source'];
+export type LaneOutputArtifact = z.infer<typeof LaneOutputArtifactSchema>;
+export interface StoreLaneOutputInput {
+    batchId: string;
+    laneId: string;
+    agent: string;
+    role: string;
+    sessionId?: string;
+    parentSessionId?: string;
+    mode?: string;
+    source: LaneOutputSource;
+    text: string;
+    messageCount?: number;
+    transcriptIncomplete?: boolean;
+}
+export interface StoreLaneOutputResult {
+    ref?: string;
+    digest: string;
+    chars: number;
+    bytes: number;
+    degraded: boolean;
+    error?: string;
+}
+export interface ReadLaneOutputResult {
+    artifact: LaneOutputArtifact;
+}
+export declare function storeLaneOutput(directory: string, input: StoreLaneOutputInput, now?: () => number): StoreLaneOutputResult;
+export declare function readLaneOutput(directory: string, ref: string): ReadLaneOutputResult | null;
+export declare function buildLaneOutputPreview(args: {
+    text: string;
+    ref?: string;
+    degraded?: boolean;
+    maxChars: number;
+}): {
+    output: string;
+    output_chars: number;
+    output_truncated: boolean;
+};
+export declare function paginateLaneOutput(text: string, offset: number, limit: number): {
+    totalLines: number;
+    startLine: number;
+    endLine: number;
+    content: string;
+    exhausted: boolean;
+};
+export {};

package/dist/background/pending-delegations.d.ts

@@ -80,6 +80,12 @@ export interface BackgroundDelegationResult {
     chars: number;
     truncated: boolean;
     digest: string;
+    outputRef?: string;
+    outputPreviewChars?: number;
+    outputDegraded?: boolean;
+    outputArtifactError?: string;
+    transcriptIncomplete?: boolean;
+    messageCount?: number;
 }
 /**
  * Read and fold the store to the latest snapshot per correlationId. Lock-free and

package/dist/cli/capability-probe-jevmgwmf.js

@@ -0,0 +1,18 @@
+// @bun
+import {
+  SandboxCapabilityProbe,
+  init_capability_probe,
+  isBubblewrapAvailable,
+  isSandboxExecAvailable,
+  isWindowsSandboxAvailable
+} from "./index-hz59hg4h.js";
+import"./index-yx44zd0p.js";
+import"./index-a76rekgs.js";
+init_capability_probe();
+
+export {
+  isWindowsSandboxAvailable,
+  isSandboxExecAvailable,
+  isBubblewrapAvailable,
+  SandboxCapabilityProbe
+};

package/dist/cli/config-doctor-zejarrr6.js

@@ -0,0 +1,35 @@
+// @bun
+import {
+  applySafeAutoFixes,
+  createConfigBackup,
+  detectStraySwarmDirs,
+  getConfigPaths,
+  readDoctorArtifact,
+  removeStraySwarmDir,
+  restoreFromBackup,
+  runConfigDoctor,
+  runConfigDoctorWithFixes,
+  shouldRunOnStartup,
+  writeBackupArtifact,
+  writeDoctorArtifact
+} from "./index-0sxvwjt0.js";
+import"./index-hw9b2xng.js";
+import"./index-zfsbaaqh.js";
+import"./index-p0arc26j.js";
+import"./index-yx44zd0p.js";
+import"./index-293f68mj.js";
+import"./index-a76rekgs.js";
+export {
+  writeDoctorArtifact,
+  writeBackupArtifact,
+  shouldRunOnStartup,
+  runConfigDoctorWithFixes,
+  runConfigDoctor,
+  restoreFromBackup,
+  removeStraySwarmDir,
+  readDoctorArtifact,
+  getConfigPaths,
+  detectStraySwarmDirs,
+  createConfigBackup,
+  applySafeAutoFixes
+};