opencode-swarm 6.74.1 → 6.76.0

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

@@ -0,0 +1,2 @@
+export { createNoopDispatcher, type NoopDispatcher, } from './noop-dispatcher.js';
+export type { DispatchDecision, DispatcherConfig, RunSlot, TaskExecutionHandle, } from './types.js';

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

@@ -0,0 +1,18 @@
+/**
+ * No-op dispatcher — returned when parallelization is disabled (the default).
+ *
+ * All dispatch methods return a 'reject' decision with reason
+ * 'parallelization_disabled'.  No file I/O, no side effects, no imports of
+ * production runtime modules.
+ *
+ * PR 2 will implement the enabled dispatcher path behind the same factory
+ * interface.
+ */
+import type { DispatchDecision, DispatcherConfig, TaskExecutionHandle } from './types.js';
+export interface NoopDispatcher {
+    readonly config: DispatcherConfig;
+    dispatch(taskId: string): DispatchDecision;
+    handles(): TaskExecutionHandle[];
+    shutdown(): void;
+}
+export declare function createNoopDispatcher(config: DispatcherConfig): NoopDispatcher;

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

@@ -0,0 +1,10 @@
+/**
+ * Tests for the no-op dispatcher (Phase 5 dark foundation).
+ *
+ * Proves:
+ *   - disabled config → reject with 'parallelization_disabled'
+ *   - no file I/O, no side effects on dispatch
+ *   - handles() always empty
+ *   - shutdown() is a no-op
+ */
+export {};

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

@@ -0,0 +1,33 @@
+/**
+ * Type-only surfaces for the parallel task dispatcher (dark — PR 1 foundation).
+ *
+ * No runtime behavior here.  PR 2 will implement the enabled path.
+ */
+export interface DispatcherConfig {
+    enabled: boolean;
+    maxConcurrentTasks: number;
+    evidenceLockTimeoutMs: number;
+}
+export interface RunSlot {
+    slotId: string;
+    taskId: string;
+    runId: string;
+    startedAt: number;
+}
+export type DispatchDecision = {
+    action: 'dispatch';
+    reason: string;
+    slot: RunSlot;
+} | {
+    action: 'defer';
+    reason: string;
+} | {
+    action: 'reject';
+    reason: string;
+};
+export interface TaskExecutionHandle {
+    slotId: string;
+    taskId: string;
+    runId: string;
+    cancel(): void;
+}

package/dist/parallel/index.d.ts

@@ -1,3 +1,4 @@
+export { EvidenceLockTimeoutError, withEvidenceLock, } from '../evidence/lock.js';
 export { type DependencyGraph, getDependencyChain, getExecutionOrder, getRunnableTasks, isTaskBlocked, parseDependencyGraph, type TaskNode, } from './dependency-graph.js';
 export { cleanupExpiredLocks, type FileLock, isLocked, listActiveLocks, releaseLock, tryAcquireLock, } from './file-locks.js';
 export { extractMetaSummaries, getLatestTaskSummary, indexMetaSummaries, type MetaSummaryEntry, querySummaries, } from './meta-indexer.js';

package/dist/plan/manager.cas-backoff.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for retryCasWithBackoff — Phase 4 (CAS retry with exponential backoff).
+ *
+ * Verifies:
+ *   - Backoff schedule: 5ms start, doubles each attempt, cap 250ms, ±25% jitter
+ *   - plan_ledger_cas_retry telemetry is emitted on each retry (hash prefixes only)
+ *   - PlanConcurrentModificationError is thrown when retries are exhausted
+ *   - verifyValid returning false causes early exit without error
+ */
+export {};

package/dist/plan/manager.d.ts

@@ -7,8 +7,25 @@ export declare class PlanConcurrentModificationError extends Error {
     constructor(message: string);
 }
 import { type Plan, type RuntimePlan, type TaskStatus } from '../config/plan-schema';
+import { type LedgerEvent, type LedgerEventInput } from './ledger';
 /** Reset the startup ledger check flag. For testing only. */
 export declare function resetStartupLedgerCheck(): void;
+/**
+ * Append a ledger event with exponential-backoff retry on stale-writer conflicts.
+ *
+ * Replaces the raw `appendLedgerEventWithRetry` call in savePlan with a helper
+ * that uses the project-standard backoff schedule and emits observable telemetry
+ * on each retry. Hash values in telemetry are truncated to 8-char prefixes to
+ * avoid leaking full content hashes into event streams.
+ *
+ * Backoff schedule: start=5ms, doubles each attempt, cap=250ms, ±25% jitter.
+ */
+export declare function retryCasWithBackoff(directory: string, eventInput: LedgerEventInput, options: {
+    expectedHash: string;
+    planHashAfter?: string;
+    verifyValid?: () => Promise<boolean> | boolean;
+    maxRetries?: number;
+}): Promise<LedgerEvent | null>;
 /**
  * Load plan.json ONLY without auto-migration from plan.md.
  * Returns null if plan.json doesn't exist or is invalid.

package/dist/state/agent-run-context.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AgentRunContext — typed per-run state container.
+ *
+ * Holds the subset of swarmState needed for future per-run isolation:
+ *   activeToolCalls, activeAgent, delegationChains, agentSessions,
+ *   environmentProfiles, and a shared reference to process-global toolAggregates.
+ *
+ * PR 1 (dark foundation): the class exists and is instantiated for the default
+ * single-run path only.  No runtime behavior is changed.
+ * PR 2 will wire distinct contexts to parallel dispatcher slots.
+ *
+ * Generic type parameters let state.ts bind concrete internal types without
+ * creating a circular import.
+ */
+export declare class AgentRunContext<TToolCall = unknown, TToolAgg = unknown, TDelegation = unknown, TSession = unknown, TEnvProfile = unknown> {
+    readonly runId: string;
+    readonly activeToolCalls: Map<string, TToolCall>;
+    readonly activeAgent: Map<string, string>;
+    readonly delegationChains: Map<string, TDelegation[]>;
+    readonly agentSessions: Map<string, TSession>;
+    readonly environmentProfiles: Map<string, TEnvProfile>;
+    readonly toolAggregates: Map<string, TToolAgg>;
+    constructor(runId: string, toolAggregates: Map<string, TToolAgg>);
+}

package/dist/state.agent-run-context.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for AgentRunContext and getRunContext (Phase 3 — dark foundation).
+ *
+ * Verifies:
+ *   1. swarmState maps are the same objects as defaultRunContext maps (facade equivalence).
+ *   2. Distinct AgentRunContext instances do not share per-run maps.
+ *   3. toolAggregates is intentionally process-global (shared reference).
+ *   4. getRunContext with no arg / unknown runId returns defaultRunContext.
+ */
+export {};

package/dist/state.d.ts

@@ -9,6 +9,8 @@
 import type { OpencodeClient } from '@opencode-ai/sdk';
 import { type QaGates } from './db/qa-gate-profile.js';
 import { type EnvironmentProfile } from './environment/profile.js';
+import { AgentRunContext } from './state/agent-run-context.js';
+export { AgentRunContext } from './state/agent-run-context.js';
 /**
  * Represents a single tool call entry for tracking purposes
  */
@@ -203,12 +205,24 @@ export interface InvocationWindow {
     warningReason: string;
 }
 /**
- * Singleton state object for sharing data across hooks
+ * Default run context — the single active run for current single-threaded behavior.
+ * PR 2 will create additional contexts for parallel dispatcher slots.
+ */
+export declare const defaultRunContext: AgentRunContext<ToolCallEntry, ToolAggregate, DelegationEntry, AgentSessionState, EnvironmentProfile>;
+/**
+ * Return the AgentRunContext for the given runId.
+ * No argument or unknown runId returns defaultRunContext (single-run semantics preserved).
+ */
+export declare function getRunContext(runId?: string): typeof defaultRunContext;
+/**
+ * Singleton state object for sharing data across hooks.
+ * Per-run maps are backed by defaultRunContext so that swarmState references
+ * stay valid and single-run behavior is unchanged.
  */
 export declare const swarmState: {
     /** Active tool calls — keyed by callID for before→after correlation */
     activeToolCalls: Map<string, ToolCallEntry>;
-    /** Aggregated tool usage stats — keyed by tool name */
+    /** Aggregated tool usage stats — process-global accumulator */
     toolAggregates: Map<string, ToolAggregate>;
     /** Active agent per session — keyed by sessionID, updated by chat.message hook */
     activeAgent: Map<string, string>;

package/dist/telemetry.d.ts

@@ -1,4 +1,4 @@
-export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activated' | 'delegation_begin' | 'delegation_end' | 'task_state_changed' | 'gate_passed' | 'gate_failed' | 'phase_changed' | 'budget_updated' | 'model_fallback' | 'hard_limit_hit' | 'revision_limit_hit' | 'loop_detected' | 'scope_violation' | 'qa_skip_violation' | 'heartbeat' | 'turbo_mode_changed' | 'auto_oversight_escalation' | 'environment_detected';
+export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activated' | 'delegation_begin' | 'delegation_end' | 'task_state_changed' | 'gate_passed' | 'gate_failed' | 'phase_changed' | 'budget_updated' | 'model_fallback' | 'hard_limit_hit' | 'revision_limit_hit' | 'loop_detected' | 'scope_violation' | 'qa_skip_violation' | 'heartbeat' | 'turbo_mode_changed' | 'auto_oversight_escalation' | 'environment_detected' | 'evidence_lock_acquired' | 'evidence_lock_contended' | 'evidence_lock_stale_recovered' | 'plan_ledger_cas_retry';
 export type TelemetryListener = (event: TelemetryEvent, data: Record<string, unknown>) => void;
 /** @internal - For testing only */
 export declare function resetTelemetryForTesting(): void;

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/package.json

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