opencode-swarm 7.81.3 → 7.82.0

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

@@ -92,7 +92,11 @@ RESEARCH CONTEXT
    continue only non-dependent architect work: prepare the synthesis outline,
    normalize the RESEARCH CONTEXT citations, and draft disagreement categories.
    Do not call `convene_general_council` or present conclusions from running
-   lanes. Each dispatch message must
+   lanes. Dispatch promptly — do not accumulate extensive planning prose before the
+   call, or output truncation may swallow the tool call itself. 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. Each dispatch message must
    include:
    - The question
    - Round number: 1

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

@@ -71,7 +71,7 @@ Each explorer mission receives:
 - 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."
 
-Explorer missions are dispatched in parallel waves. 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.
+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.
 

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

@@ -102,7 +102,12 @@ Dispatch up to `max_researchers` `the active swarm's sme agent` calls with
 `batch_id`, then continue architect-owned retrieval quality work that does not
 depend on worker output: tighten the evidence ledger, check source authority,
 prepare reviewer shard structure, and identify unresolved gaps. Do not write final
-claims from running lanes. Each sme dispatch must
+claims from running lanes. Dispatch promptly — do not accumulate extensive planning
+prose before the call, or output truncation may swallow the tool call itself. 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. Each sme dispatch must
 include:
 - `DOMAIN`: the subtopic
 - `TASK`: "Synthesize an evidence-grounded answer for this subtopic. Cite each

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

@@ -491,7 +491,7 @@ Tool candidate rules:
 
 ## Phase 3: Parallel Base Explorer Lanes
 
-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.
+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.
 

package/dist/background/completion-observer.d.ts

@@ -1,27 +1,14 @@
 /**
  * Background subagent completion observer/ingester.
  *
- * Registers as a swarm `event` hook to watch for the upstream background-completion signal:
- * a message part with `synthetic === true` whose text is a task envelope with
- * `state="completed"` or `state="error"`. When such a part correlates to a durable pending
- * background-delegation record, it is logged (debug-gated) as the empirical confirmation
- * instrument operators use to verify the runtime signal in a real environment.
- *
- * PR1 async advisory lanes ingest trusted terminal completions into the durable
- * background-delegation ledger only. This still NEVER advances workflow gates or records
- * gate evidence; gate-bearing execution is intentionally outside this advisory path.
- *
- * The `synthetic` flag is the trust gate (set by OpenCode, not the model/user). Non-synthetic
- * text that merely looks like an envelope is ignored. The observer is fail-open: any error is
- * swallowed so it can never block event delivery or plugin load (Invariant 1/10).
+ * Trusted synthetic background completions always settle the durable
+ * background-delegation ledger. Correctness-critical Stage B completions then
+ * pass through workspace freshness validation before gate evidence, receipts, or
+ * task workflow state can advance.
  */
 interface ObserverConfig {
     enabled: boolean;
 }
-/**
- * Build the background completion observer. Returns an `event` handler suitable for the
- * OpenCode plugin `event` hook. No-op (cheap early return) when the feature is disabled.
- */
 export declare function createBackgroundCompletionObserver(opts: {
     config: ObserverConfig;
     directory: string;

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

@@ -12,8 +12,8 @@
  *
  * Scope: dispatch records `pending`/`running` snapshots, collection or trusted synthetic
  * completions record terminal snapshots, and the stale sweep records `stale` snapshots.
- * This store still has NO gate advancement and NO gate evidence side effect; it is an
- * advisory result ledger only.
+ * This store itself has no gate-advancement side effect. Stage B gate ingestion is a
+ * separate consumer of trusted terminal snapshots.
  *
  * Concurrency: all writes (append, sweep) run under a single project-scoped lock via
  * `withEvidenceLock`, so concurrent dispatches/sweeps cannot interleave appends. Reads are
@@ -23,7 +23,7 @@
  * `.swarm/` (Invariant 4).
  */
 export declare const BACKGROUND_DELEGATIONS_FILE = "background-delegations.jsonl";
-export type BackgroundDelegationStatus = 'pending' | 'running' | 'completed' | 'error' | 'cancelled' | 'stale' | 'consumed';
+export type BackgroundDelegationStatus = 'pending' | 'running' | 'ingestion_error' | 'completed' | 'error' | 'cancelled' | 'stale' | 'consumed';
 export interface BackgroundDelegationRecord {
     schemaVersion: 1 | 2;
     /** Subagent session id from the dispatch envelope — the correlation key. */
@@ -56,6 +56,7 @@ export interface BackgroundDelegationRecord {
     promptHash?: string;
     /** Project/root provenance captured at dispatch time. */
     workspace?: BackgroundWorkspaceSnapshot;
+    prompt?: BackgroundPromptSnapshot;
     generation?: number;
     result?: BackgroundDelegationResult;
     completedAt?: number;
@@ -67,6 +68,12 @@ export interface BackgroundWorkspaceSnapshot {
     prHeadSha: string | null;
     scope: string | null;
 }
+export interface BackgroundPromptSnapshot {
+    text: string;
+    chars: number;
+    truncated: boolean;
+    digest: string;
+}
 export interface BackgroundDelegationResult {
     text?: string;
     error?: string;
@@ -101,6 +108,7 @@ export interface RecordPendingInput {
     mode?: string;
     promptHash?: string;
     workspace?: BackgroundWorkspaceSnapshot;
+    prompt?: BackgroundPromptSnapshot;
     generation?: number;
 }
 /**
@@ -113,6 +121,7 @@ export interface RecordPendingInput {
 export declare function recordPendingDelegation(directory: string, input: RecordPendingInput, options?: {
     staleTimeoutMs?: number;
 }): Promise<BackgroundDelegationRecord | null>;
+export declare function buildPromptSnapshot(text: string, maxChars: number): BackgroundPromptSnapshot;
 export declare function appendDelegationTransition(directory: string, correlationId: string, transition: {
     status: BackgroundDelegationStatus;
     result?: BackgroundDelegationResult;

package/dist/background/stage-b-gates.d.ts

@@ -0,0 +1,18 @@
+import type { BackgroundDelegationRecord, BackgroundDelegationResult } from './pending-delegations.js';
+export interface StageBIngestionResult {
+    ok: boolean;
+    consumed: boolean;
+    stale?: boolean;
+    reason?: string;
+}
+export declare function isBackgroundGateBearingRecord(record: BackgroundDelegationRecord): boolean;
+export declare function validateStageBWorkspace(directory: string, record: BackgroundDelegationRecord): {
+    ok: boolean;
+    stale: boolean;
+    reason?: string;
+};
+export declare function ingestBackgroundStageBCompletion(args: {
+    directory: string;
+    record: BackgroundDelegationRecord;
+    result: BackgroundDelegationResult;
+}): Promise<StageBIngestionResult>;

package/dist/background/workspace-snapshot.d.ts

@@ -0,0 +1,31 @@
+import * as child_process from 'node:child_process';
+import type { BackgroundWorkspaceSnapshot } from './pending-delegations.js';
+type SpawnSync = typeof child_process.spawnSync;
+interface CaptureWorkspaceSnapshotOptions {
+    scope?: string | null;
+    prHeadSha?: string | null;
+    /**
+     * Re-resolve the current upstream ref for freshness validation. When the
+     * dispatch captured an explicit PR head SHA, ingestion must compare against a
+     * live local ref, not replay the stored metadata back into the snapshot.
+     */
+    resolveCurrentPrHeadSha?: boolean;
+}
+export declare function captureWorkspaceSnapshot(directory: string, optionsOrScope?: string | null | CaptureWorkspaceSnapshotOptions, prHeadShaArg?: string | null): BackgroundWorkspaceSnapshot;
+export declare function workspaceSnapshotMatches(expected: BackgroundWorkspaceSnapshot | undefined, current: BackgroundWorkspaceSnapshot): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export type WorkspaceFreshness = ReturnType<typeof workspaceSnapshotMatches>;
+export declare const compareWorkspaceSnapshot: typeof workspaceSnapshotMatches;
+export declare function compareWorkspaceSnapshots(expected: BackgroundWorkspaceSnapshot | undefined, current: BackgroundWorkspaceSnapshot): {
+    stale: boolean;
+    reason?: string;
+};
+export declare function digest(text: string): string;
+export declare const _internals: {
+    spawnSync: SpawnSync;
+};
+export {};

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.81.3",
+    version: "7.82.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",
@@ -17763,15 +17763,15 @@ var init_tool_metadata = __esm(() => {
       ]
     },
     dispatch_lanes: {
-      description: "dispatch multiple read-only exploration/review lanes concurrently and return a structured join result",
+      description: "dispatch read-only exploration/review lanes concurrently and BLOCK until all finish; prefer dispatch_lanes_async for non-blocking dispatch, use this only when promptAsync is unavailable",
       agents: ["architect"]
     },
     dispatch_lanes_async: {
-      description: "launch multiple read-only advisory lanes asynchronously and return a batch id for later collection",
+      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",
       agents: ["architect"]
     },
     collect_lane_results: {
-      description: "collect or poll results for a dispatch_lanes_async advisory batch without advancing workflow gates",
+      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",
       agents: ["architect"]
     },
     summarize_work: {
@@ -41475,6 +41475,14 @@ async function activateProposal(directory, slug, force = false, options = {}) {
       reason: `proposal not found or already activated: ${readErr instanceof Error ? readErr.message : String(readErr)}`
     };
   }
+  if (await isRejectedSkillContent(directory, cleanSlug, proposalContent)) {
+    return {
+      activated: false,
+      from,
+      to,
+      reason: "previously rejected equivalent content"
+    };
+  }
   const flipped = proposalContent.replace(/^status:\s*draft\s*$/m, "status: active");
   let evaluation;
   if (options.evaluate) {
@@ -41497,7 +41505,7 @@ async function activateProposal(directory, slug, force = false, options = {}) {
       await appendRejectedSkillEdit({
         directory,
         slug: cleanSlug,
-        candidateContent: flipped,
+        candidateContent: proposalContent,
         incumbentContent,
         operation: options.operation ?? "skill_apply"
       }, evaluation);

package/dist/hooks/review-receipt-collector.d.ts

@@ -48,6 +48,14 @@ export interface ReviewerReceiptInput {
 export interface ReviewerReceiptOutput {
     output?: unknown;
 }
+export interface ReviewerReceiptTranscriptInput {
+    targetAgent?: string;
+    prompt: string;
+    transcript: string;
+    sessionID?: string;
+    sessionId?: string;
+}
+export declare function collectReviewerReceiptFromTranscript(directory: string, input: ReviewerReceiptTranscriptInput): Promise<string | null>;
 /**
  * `tool.execute.after` collector. When a reviewer Task returns, parse its
  * verdict block and persist a durable review receipt. No-op for non-reviewer