opencode-swarm 6.75.0 → 6.77.0

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/test-runner.d.ts

@@ -50,5 +50,37 @@ export interface TestErrorResult {
 }
 export type TestResult = TestSuccessResult | TestErrorResult;
 export declare function detectTestFramework(cwd: string): Promise<TestFramework>;
+/**
+ * Returns true when `basename` matches a language-specific test file naming
+ * convention that is NOT captured by the compound-extension or dot-separated
+ * `.test.`/`.spec.` checks above.
+ *
+ * Covered patterns (all lower-cased for comparison):
+ *   Go   : <name>_test.go          (per `go test` convention)
+ *   Python: test_<name>.py          (pytest discovery default)
+ *           <name>_test.py          (pytest alternative)
+ *   Ruby : <name>_spec.rb           (RSpec convention)
+ *   Java : Test<Name>.java          (JUnit 4/5 prefix)
+ *          <Name>Test.java          (JUnit 4/5 suffix)
+ *          <Name>Tests.java         (JUnit 4/5 plural suffix)
+ *          <Name>IT.java            (Maven Failsafe integration-test suffix)
+ *   C#   : <Name>Test.cs            (xUnit/NUnit/MSTest suffix)
+ *          <Name>Tests.cs           (xUnit/NUnit/MSTest plural suffix)
+ *   Rust : test files are recognized by test-directory placement
+ *           (for example, tests/<anything>.rs via /tests/ path detection)
+ *   Kotlin: <Name>Test.kt / <Name>Tests.kt / Test<Name>.kt
+ *
+ * Exported for unit tests; production code uses it only through
+ * getTestFilesFromConvention.
+ */
+export declare function isLanguageSpecificTestFile(basename: string): boolean;
+/**
+ * Map source files (or already-test files) to the test files that should be
+ * run for them. Handles any language whose test files follow a naming convention
+ * — TS/JS, Go, Python, Ruby, Java, C#, Kotlin, PowerShell.
+ *
+ * Exported for unit tests.
+ */
+export declare function getTestFilesFromConvention(sourceFiles: string[], workingDir?: string): string[];
 export declare function runTests(framework: TestFramework, scope: 'all' | 'convention' | 'graph' | 'impact', files: string[], coverage: boolean, timeout_ms: number, cwd: string): Promise<TestResult>;
 export declare const test_runner: ReturnType<typeof tool>;

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.75.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",