opencode-swarm 6.76.0 → 6.77.0

package/dist/cli/index.js

@@ -19414,7 +19414,12 @@ var CouncilConfigSchema = exports_external.object({
 var ParallelizationConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(false),
   maxConcurrentTasks: exports_external.number().int().min(1).max(64).default(1),
-  evidenceLockTimeoutMs: exports_external.number().int().min(1000).max(300000).default(60000)
+  evidenceLockTimeoutMs: exports_external.number().int().min(1000).max(300000).default(60000),
+  stageB: exports_external.object({
+    parallel: exports_external.object({
+      enabled: exports_external.boolean().default(false)
+    }).default({ enabled: false })
+  }).default({ parallel: { enabled: false } })
 });
 var PluginConfigSchema = exports_external.object({
   agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),

package/dist/config/schema.d.ts

@@ -530,6 +530,11 @@ export declare const ParallelizationConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     maxConcurrentTasks: z.ZodDefault<z.ZodNumber>;
     evidenceLockTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    stageB: z.ZodDefault<z.ZodObject<{
+        parallel: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ParallelizationConfig = z.infer<typeof ParallelizationConfigSchema>;
 export declare const PluginConfigSchema: z.ZodObject<{
@@ -893,6 +898,11 @@ export declare const PluginConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         maxConcurrentTasks: z.ZodDefault<z.ZodNumber>;
         evidenceLockTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        stageB: z.ZodDefault<z.ZodObject<{
+            parallel: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     turbo_mode: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     full_auto: z.ZodDefault<z.ZodOptional<z.ZodObject<{

package/dist/index.js

@@ -15185,7 +15185,12 @@ var init_schema = __esm(() => {
   ParallelizationConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
     maxConcurrentTasks: exports_external.number().int().min(1).max(64).default(1),
-    evidenceLockTimeoutMs: exports_external.number().int().min(1000).max(300000).default(60000)
+    evidenceLockTimeoutMs: exports_external.number().int().min(1000).max(300000).default(60000),
+    stageB: exports_external.object({
+      parallel: exports_external.object({
+        enabled: exports_external.boolean().default(false)
+      }).default({ enabled: false })
+    }).default({ parallel: { enabled: false } })
   });
   PluginConfigSchema = exports_external.object({
     agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
@@ -24827,60 +24832,121 @@ function createDelegationGateHook(config2, directory) {
         if (targetAgent === "test_engineer")
           hasTestEngineer = true;
         if (!councilActive) {
-          if (targetAgent === "reviewer" && session.taskWorkflowStates) {
-            for (const [taskId, state] of session.taskWorkflowStates) {
-              if (state === "coder_delegated" || state === "pre_check_passed") {
-                try {
-                  advanceTaskState(session, taskId, "reviewer_run");
-                } catch (err2) {
-                  console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+          const stageBParallelEnabled = config2.parallelization?.stageB?.parallel?.enabled === true;
+          if (stageBParallelEnabled) {
+            if ((targetAgent === "reviewer" || targetAgent === "test_engineer") && session.taskWorkflowStates) {
+              const stageBEligibleStates = [
+                "coder_delegated",
+                "pre_check_passed",
+                "reviewer_run"
+              ];
+              for (const [taskId, state] of session.taskWorkflowStates) {
+                if (!stageBEligibleStates.includes(state))
+                  continue;
+                const eligibleState = state;
+                recordStageBCompletion(session, taskId, targetAgent);
+                if (hasBothStageBCompletions(session, taskId)) {
+                  try {
+                    if (eligibleState === "coder_delegated" || eligibleState === "pre_check_passed") {
+                      advanceTaskState(session, taskId, "reviewer_run");
+                    }
+                    advanceTaskState(session, taskId, "tests_run");
+                  } catch (err2) {
+                    console.warn(`[delegation-gate] toolAfter stage-b-parallel: could not advance ${taskId} (${eligibleState}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                  }
                 }
               }
-            }
-          }
-          if (targetAgent === "test_engineer" && session.taskWorkflowStates) {
-            for (const [taskId, state] of session.taskWorkflowStates) {
-              if (state === "reviewer_run") {
-                try {
-                  advanceTaskState(session, taskId, "tests_run");
-                } catch (err2) {
-                  console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+              const seedTaskId = getSeedTaskId(session);
+              if (seedTaskId) {
+                for (const [, otherSession] of swarmState.agentSessions) {
+                  if (otherSession === session)
+                    continue;
+                  if (!otherSession.taskWorkflowStates)
+                    continue;
+                  if (!otherSession.taskWorkflowStates.has(seedTaskId)) {
+                    otherSession.taskWorkflowStates.set(seedTaskId, "coder_delegated");
+                  }
+                  const seedState = otherSession.taskWorkflowStates.get(seedTaskId);
+                  if (!seedState || !stageBEligibleStates.includes(seedState)) {
+                    continue;
+                  }
+                  const seedEligibleState = seedState;
+                  recordStageBCompletion(otherSession, seedTaskId, targetAgent);
+                  if (hasBothStageBCompletions(otherSession, seedTaskId)) {
+                    try {
+                      if (seedEligibleState === "coder_delegated" || seedEligibleState === "pre_check_passed") {
+                        advanceTaskState(otherSession, seedTaskId, "reviewer_run");
+                      }
+                      advanceTaskState(otherSession, seedTaskId, "tests_run");
+                    } catch (err2) {
+                      console.warn(`[delegation-gate] toolAfter cross-session stage-b-parallel: could not advance ${seedTaskId} (${seedEligibleState}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    }
+                  }
                 }
               }
             }
-          }
-          if (targetAgent === "reviewer" || targetAgent === "test_engineer") {
-            for (const [, otherSession] of swarmState.agentSessions) {
-              if (otherSession === session)
-                continue;
-              if (!otherSession.taskWorkflowStates)
-                continue;
-              if (targetAgent === "reviewer") {
-                const seedTaskId = getSeedTaskId(session);
-                if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
-                  otherSession.taskWorkflowStates.set(seedTaskId, "coder_delegated");
+          } else {
+            if (targetAgent === "reviewer" && session.taskWorkflowStates) {
+              for (const [taskId, state] of session.taskWorkflowStates) {
+                if (state === "coder_delegated" || state === "pre_check_passed") {
+                  try {
+                    advanceTaskState(session, taskId, "reviewer_run");
+                  } catch (err2) {
+                    console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                  }
                 }
-                for (const [taskId, state] of otherSession.taskWorkflowStates) {
-                  if (state === "coder_delegated" || state === "pre_check_passed") {
-                    try {
-                      advanceTaskState(otherSession, taskId, "reviewer_run");
-                    } catch (err2) {
-                      console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
-                    }
+              }
+            }
+            if (targetAgent === "test_engineer" && session.taskWorkflowStates) {
+              for (const [taskId, state] of session.taskWorkflowStates) {
+                if (state === "reviewer_run") {
+                  try {
+                    advanceTaskState(session, taskId, "tests_run");
+                  } catch (err2) {
+                    console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 }
               }
-              if (targetAgent === "test_engineer") {
-                const seedTaskId = getSeedTaskId(session);
-                if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
-                  otherSession.taskWorkflowStates.set(seedTaskId, "reviewer_run");
+            }
+            if (targetAgent === "reviewer" || targetAgent === "test_engineer") {
+              for (const [, otherSession] of swarmState.agentSessions) {
+                if (otherSession === session)
+                  continue;
+                if (!otherSession.taskWorkflowStates)
+                  continue;
+                if (targetAgent === "reviewer") {
+                  const seedTaskId = getSeedTaskId(session);
+                  if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
+                    otherSession.taskWorkflowStates.set(seedTaskId, "coder_delegated");
+                  }
+                  for (const [
+                    taskId,
+                    state
+                  ] of otherSession.taskWorkflowStates) {
+                    if (state === "coder_delegated" || state === "pre_check_passed") {
+                      try {
+                        advanceTaskState(otherSession, taskId, "reviewer_run");
+                      } catch (err2) {
+                        console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                      }
+                    }
+                  }
                 }
-                for (const [taskId, state] of otherSession.taskWorkflowStates) {
-                  if (state === "reviewer_run") {
-                    try {
-                      advanceTaskState(otherSession, taskId, "tests_run");
-                    } catch (err2) {
-                      console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                if (targetAgent === "test_engineer") {
+                  const seedTaskId = getSeedTaskId(session);
+                  if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
+                    otherSession.taskWorkflowStates.set(seedTaskId, "reviewer_run");
+                  }
+                  for (const [
+                    taskId,
+                    state
+                  ] of otherSession.taskWorkflowStates) {
+                    if (state === "reviewer_run") {
+                      try {
+                        advanceTaskState(otherSession, taskId, "tests_run");
+                      } catch (err2) {
+                        console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                      }
                     }
                   }
                 }
@@ -25293,9 +25359,11 @@ __export(exports_state, {
   setSessionEnvironment: () => setSessionEnvironment,
   resetSwarmState: () => resetSwarmState,
   rehydrateSessionFromDisk: () => rehydrateSessionFromDisk,
+  recordStageBCompletion: () => recordStageBCompletion,
   recordPhaseAgentDispatch: () => recordPhaseAgentDispatch,
   pruneOldWindows: () => pruneOldWindows,
   isCouncilGateActive: () => isCouncilGateActive,
+  hasBothStageBCompletions: () => hasBothStageBCompletions,
   hasActiveTurboMode: () => hasActiveTurboMode,
   hasActiveFullAuto: () => hasActiveFullAuto,
   getTaskState: () => getTaskState,
@@ -25376,6 +25444,7 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, dire
     qaSkipCount: 0,
     qaSkipTaskIds: [],
     taskWorkflowStates: new Map,
+    stageBCompletion: new Map,
     taskCouncilApproved: new Map,
     lastGateOutcome: null,
     declaredCoderScope: null,
@@ -25491,6 +25560,9 @@ function ensureAgentSession(sessionId, agentName, directory) {
     if (!session.taskWorkflowStates) {
       session.taskWorkflowStates = new Map;
     }
+    if (!session.stageBCompletion) {
+      session.stageBCompletion = new Map;
+    }
     if (!session.taskCouncilApproved) {
       session.taskCouncilApproved = new Map;
     }
@@ -25667,6 +25739,27 @@ function getTaskState(session, taskId) {
   }
   return session.taskWorkflowStates.get(taskId) ?? "idle";
 }
+function recordStageBCompletion(session, taskId, agent) {
+  if (!isValidTaskId2(taskId))
+    return;
+  if (!session.stageBCompletion) {
+    session.stageBCompletion = new Map;
+  }
+  const existing = session.stageBCompletion.get(taskId);
+  if (existing) {
+    existing.add(agent);
+  } else {
+    session.stageBCompletion.set(taskId, new Set([agent]));
+  }
+}
+function hasBothStageBCompletions(session, taskId) {
+  if (!isValidTaskId2(taskId))
+    return false;
+  const completions = session.stageBCompletion?.get(taskId);
+  if (!completions)
+    return false;
+  return completions.has("reviewer") && completions.has("test_engineer");
+}
 function derivePlanIdFromPlan(plan) {
   return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
 }
@@ -83764,7 +83857,7 @@ function matchesTier3Pattern(files) {
   }
   return false;
 }
-function checkReviewerGate(taskId, workingDirectory) {
+function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = false) {
   try {
     if (hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
@@ -83823,6 +83916,9 @@ function checkReviewerGate(taskId, workingDirectory) {
       if (state === "tests_run" || state === "complete") {
         return { blocked: false, reason: "" };
       }
+      if (stageBParallelEnabled && hasBothStageBCompletions(session, taskId)) {
+        return { blocked: false, reason: "" };
+      }
     }
     if (validSessionCount === 0) {
       return { blocked: false, reason: "" };
@@ -83897,7 +83993,14 @@ function checkReviewerGate(taskId, workingDirectory) {
   }
 }
 async function checkReviewerGateWithScope(taskId, workingDirectory) {
-  const result = checkReviewerGate(taskId, workingDirectory);
+  let stageBParallelEnabled = false;
+  if (workingDirectory) {
+    try {
+      const cfg = await loadPluginConfig(workingDirectory);
+      stageBParallelEnabled = cfg.parallelization?.stageB?.parallel?.enabled === true;
+    } catch {}
+  }
+  const result = checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled);
   const scopeWarning = await validateDiffScope(taskId, workingDirectory).catch(() => null);
   if (!scopeWarning)
     return result;

package/dist/parallel/dispatcher/index.d.ts

@@ -1,2 +1,12 @@
 export { createNoopDispatcher, type NoopDispatcher, } from './noop-dispatcher.js';
+export { createParallelDispatcher, type ParallelDispatcher, } from './parallel-dispatcher.js';
 export type { DispatchDecision, DispatcherConfig, RunSlot, TaskExecutionHandle, } from './types.js';
+import { type NoopDispatcher } from './noop-dispatcher.js';
+import { type ParallelDispatcher } from './parallel-dispatcher.js';
+import type { DispatcherConfig } from './types.js';
+/**
+ * Factory: returns the appropriate dispatcher based on config.
+ * When disabled or maxConcurrentTasks <= 1, returns the no-op dispatcher.
+ * When enabled and maxConcurrentTasks > 1, returns the parallel dispatcher.
+ */
+export declare function createDispatcher(config: DispatcherConfig): NoopDispatcher | ParallelDispatcher;

package/dist/parallel/dispatcher/parallel-dispatcher.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Parallel dispatcher — enabled path for Stage B concurrent task execution.
+ *
+ * Uses p-limit for bounded concurrency. Returns 'dispatch' when a slot is
+ * available, 'defer' when at max capacity, 'reject' when disabled.
+ *
+ * PR 2: implements the enabled dispatcher alongside the existing NoopDispatcher.
+ * No production code imports this directly — it is wired in via createDispatcher().
+ */
+import type { DispatchDecision, DispatcherConfig, TaskExecutionHandle } from './types.js';
+export interface ParallelDispatcher {
+    readonly config: DispatcherConfig;
+    dispatch(taskId: string): DispatchDecision;
+    handles(): TaskExecutionHandle[];
+    releaseSlot(slotId: string): void;
+    shutdown(): void;
+}
+export declare function createParallelDispatcher(config: DispatcherConfig): ParallelDispatcher;

package/dist/state.d.ts

@@ -103,6 +103,13 @@ export interface AgentSessionState {
     qaSkipTaskIds: string[];
     /** Per-task workflow state — taskId → current state */
     taskWorkflowStates: Map<string, TaskWorkflowState>;
+    /**
+     * PR 2 Stage B barrier: per-task set of completed Stage B agents.
+     * Order-independent — either 'reviewer' or 'test_engineer' may complete first.
+     * When both are present, the task may advance to tests_run regardless of order.
+     * Only populated when parallelization.stageB.parallel.enabled = true.
+     */
+    stageBCompletion?: Map<string, Set<'reviewer' | 'test_engineer'>>;
     /** v6.71+ Council mode: per-task council verdict, recorded by delegation-gate when convene_council resolves. */
     taskCouncilApproved?: Map<string, {
         verdict: 'APPROVE' | 'REJECT' | 'CONCERNS';
@@ -350,6 +357,25 @@ export declare function advanceTaskState(session: AgentSessionState, taskId: str
  * @returns Current task workflow state
  */
 export declare function getTaskState(session: AgentSessionState, taskId: string): TaskWorkflowState;
+/**
+ * PR 2 Stage B barrier: record that a Stage B agent has completed for a task.
+ * Order-independent — either 'reviewer' or 'test_engineer' may complete first.
+ * Initializes the per-task set on first write.
+ *
+ * @param session - The agent session state
+ * @param taskId - The task identifier
+ * @param agent - Which Stage B agent completed ('reviewer' or 'test_engineer')
+ */
+export declare function recordStageBCompletion(session: AgentSessionState, taskId: string, agent: 'reviewer' | 'test_engineer'): void;
+/**
+ * PR 2 Stage B barrier: returns true iff both 'reviewer' and 'test_engineer' have
+ * been recorded for the given task in this session.
+ *
+ * @param session - The agent session state
+ * @param taskId - The task identifier
+ * @returns true when both Stage B agents have completed
+ */
+export declare function hasBothStageBCompletions(session: AgentSessionState, taskId: string): boolean;
 /**
  * Returns true iff council is authoritative for the current plan.
  *

package/dist/tools/update-task-status.d.ts

@@ -49,12 +49,14 @@ export interface ReviewerGateResult {
  * both reviewer delegation and test_engineer runs have been recorded.
  * @param taskId - The task ID to check gate state for
  * @param workingDirectory - Optional working directory for plan.json fallback
+ * @param stageBParallelEnabled - When true, also accept both-markers-present as passing (PR 2 barrier)
  * @returns ReviewerGateResult indicating whether the gate is blocked
  */
-export declare function checkReviewerGate(taskId: string, workingDirectory?: string): ReviewerGateResult;
+export declare function checkReviewerGate(taskId: string, workingDirectory?: string, stageBParallelEnabled?: boolean): ReviewerGateResult;
 /**
  * Wrapper around checkReviewerGate that appends a diff-scope advisory warning.
  * Keeps checkReviewerGate synchronous for backward compatibility.
+ * Also resolves the PR 2 stageB.parallel.enabled flag from config.
  * @param taskId - The task ID to check gate state for
  * @param workingDirectory - Optional working directory for plan.json fallback
  * @returns ReviewerGateResult with optional scope warning appended to reason

package/package.json

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