opencode-swarm 7.0.0-beta.1 → 7.0.0

package/dist/knowledge/identity.d.ts

@@ -0,0 +1,25 @@
+/** Project Identity Management for opencode-swarm.
+ * Handles creation and retrieval of project identity files.
+ */
+export interface ProjectIdentity {
+    projectHash: string;
+    projectName: string;
+    repoUrl?: string;
+    absolutePath: string;
+    createdAt: string;
+    swarmVersion: string;
+}
+/**
+ * Get identity file path for a project hash.
+ * Path: {platform-config-dir}/projects/{projectHash}/identity.json
+ */
+export declare function resolveIdentityPath(projectHash: string): string;
+/**
+ * Read existing identity.json or return null if it doesn't exist.
+ */
+export declare function readProjectIdentity(projectHash: string): Promise<ProjectIdentity | null>;
+/**
+ * Create or update identity.json for a project.
+ * Uses atomic write pattern (write to temp file, then rename).
+ */
+export declare function writeProjectIdentity(directory: string, projectHash: string, projectName: string): Promise<ProjectIdentity>;

package/dist/knowledge/index.d.ts

@@ -0,0 +1,2 @@
+/** Knowledge system exports for opencode-swarm. */
+export * from './identity.js';

package/dist/lang/detector.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Language Detection Utilities
+ *
+ * Provides detectProjectLanguages() for scanning a project directory
+ * and getProfileForFile() for resolving a language profile from a file path.
+ * No tool logic — pure detection only.
+ */
+import { type LanguageProfile } from './profiles.js';
+/**
+ * Resolve a language profile from a file path based on its extension.
+ * Returns undefined for files with no extension or unknown extensions.
+ */
+export declare function getProfileForFile(filePath: string): LanguageProfile | undefined;
+/**
+ * Scan a project directory (and immediate subdirectories) to detect active languages.
+ * Detection is based on presence of build indicator files or source files with known extensions.
+ * Returns unique profiles in priority order (Tier 1 first, then Tier 2, then Tier 3).
+ * Skips unreadable directories silently.
+ */
+export declare function detectProjectLanguages(projectDir: string): Promise<LanguageProfile[]>;

package/dist/lang/framework-detector.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Framework Detection Utilities
+ *
+ * Provides deterministic multi-signal framework detection.
+ * Laravel detection uses at least 2 of 3 signals to avoid false positives.
+ */
+/**
+ * Detection signals for Laravel framework identification.
+ * Each signal independently indicates a Laravel project.
+ */
+export interface LaravelDetectionSignals {
+    /** artisan file present in project root (no extension) */
+    hasArtisanFile: boolean;
+    /** laravel/framework present in composer.json require dependencies */
+    hasLaravelFrameworkDep: boolean;
+    /** config/app.php present (Laravel config directory structure) */
+    hasConfigApp: boolean;
+}
+/**
+ * Resolved command overlay for a detected Laravel project.
+ * All fields are set to best-available commands for CI-quality use.
+ */
+export interface LaravelCommandOverlay {
+    /** Primary test command. Always php artisan test for Laravel. */
+    testCommand: string;
+    /** Lint/format command. Pint if detected, PHP-CS-Fixer otherwise, null if neither. */
+    lintCommand: string | null;
+    /** Static analysis command. PHPStan if phpstan config is present, null otherwise. */
+    staticAnalysisCommand: string | null;
+    /**
+     * Identified static analysis tool. 'larastan' if phpstan.neon contains a
+     * Larastan extension reference, 'phpstan' if a phpstan config is present
+     * without Larastan markers, null if no phpstan config is present.
+     */
+    staticAnalysisTool: 'larastan' | 'phpstan' | null;
+    /** Dependency audit command (always composer audit --locked --format=json for Laravel). */
+    auditCommand: string;
+    /** Whether --parallel flag is supported (Pest parallel testing via artisan). */
+    supportsParallel: boolean;
+}
+/**
+ * Detect whether a directory is a Laravel project.
+ * Uses multi-signal detection: at least 2 of 3 signals must be present
+ * to minimize false positives against generic Composer PHP projects.
+ *
+ * Signals checked:
+ * 1. artisan file in project root (strong signal — only Laravel projects have this)
+ * 2. laravel/framework in composer.json require section
+ * 3. config/app.php file (Laravel directory structure)
+ *
+ * @param directory - Absolute path to the project root
+ * @returns true if project is a Laravel project, false otherwise
+ */
+export declare function detectLaravelProject(directory: string): boolean;
+/**
+ * Get individual Laravel detection signals for a directory.
+ * Exposed for testing and diagnostic purposes.
+ *
+ * @param directory - Absolute path to the project root
+ * @returns LaravelDetectionSignals with each signal's boolean state
+ */
+export declare function getLaravelSignals(directory: string): LaravelDetectionSignals;
+/**
+ * Determine whether a project is configured to use Larastan (the Laravel
+ * extension for PHPStan) rather than vanilla PHPStan.
+ *
+ * Detection is content-based: the first 4096 bytes of `phpstan.neon` are
+ * read and scanned for a reference to either of the two known Larastan
+ * package names (`nunomaduro/larastan` or `larastan/larastan`).
+ *
+ * Only `phpstan.neon` is checked — `phpstan.neon.dist` is a distribution
+ * baseline that projects override locally, so it is not scanned for the
+ * Larastan marker.
+ *
+ * @param directory - Absolute path to the project root
+ * @returns true if phpstan.neon contains a Larastan extension reference
+ */
+export declare function isLarastanConfigured(directory: string): boolean;
+/**
+ * Get the Laravel command overlay for a project directory.
+ * Returns null if the directory is not a Laravel project.
+ *
+ * Command selection logic:
+ * - testCommand: always 'php artisan test' (wraps both PHPUnit and Pest)
+ * - lintCommand: 'vendor/bin/pint --test' if pint.json present,
+ *   'vendor/bin/php-cs-fixer fix --dry-run --diff' if .php-cs-fixer.php present,
+ *   null otherwise
+ * - staticAnalysisCommand: 'vendor/bin/phpstan analyse' if phpstan.neon or phpstan.neon.dist present,
+ *   null otherwise
+ * - staticAnalysisTool: 'larastan' if phpstan.neon contains a Larastan extension reference,
+ *   'phpstan' if a phpstan config is present without Larastan markers, null otherwise
+ * - auditCommand: always 'composer audit --locked --format=json'
+ * - supportsParallel: true (php artisan test --parallel is supported)
+ *
+ * @param directory - Absolute path to the project root
+ * @returns LaravelCommandOverlay if Laravel detected, null if not a Laravel project
+ */
+export declare function getLaravelCommandOverlay(directory: string): LaravelCommandOverlay | null;

package/dist/lang/index.d.ts

@@ -0,0 +1,4 @@
+export * from './detector';
+export * from './profiles';
+export * from './registry';
+export * from './runtime';

package/dist/lang/profiles.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Language Profile Registry - Pure Data Types
+ *
+ * This file defines the LanguageProfile interface and LanguageRegistry class.
+ * No tool logic, no subprocess calls - pure data definitions only.
+ */
+export interface BuildCommand {
+    name: string;
+    cmd: string;
+    detectFile?: string;
+    priority: number;
+}
+export interface TestFramework {
+    name: string;
+    detect: string;
+    cmd: string;
+    priority: number;
+}
+export interface LintTool {
+    name: string;
+    detect: string;
+    cmd: string;
+    priority: number;
+}
+export interface LanguageProfile {
+    id: string;
+    displayName: string;
+    tier: 1 | 2 | 3;
+    extensions: string[];
+    treeSitter: {
+        grammarId: string;
+        wasmFile: string;
+    };
+    build: {
+        detectFiles: string[];
+        commands: BuildCommand[];
+    };
+    test: {
+        detectFiles: string[];
+        frameworks: TestFramework[];
+    };
+    lint: {
+        detectFiles: string[];
+        linters: LintTool[];
+    };
+    audit: {
+        detectFiles: string[];
+        command: string | null;
+        outputFormat: 'json' | 'text';
+    };
+    sast: {
+        nativeRuleSet: string | null;
+        semgrepSupport: 'ga' | 'beta' | 'experimental' | 'none';
+    };
+    prompts: {
+        coderConstraints: string[];
+        reviewerChecklist: string[];
+        testConstraints?: string[];
+    };
+}
+export declare class LanguageRegistry {
+    private profiles;
+    private extensionIndex;
+    constructor();
+    register(profile: LanguageProfile): void;
+    get(id: string): LanguageProfile | undefined;
+    getById(id: string): LanguageProfile | undefined;
+    getByExtension(ext: string): LanguageProfile | undefined;
+    getAll(): LanguageProfile[];
+    getTier(tier: 1 | 2 | 3): LanguageProfile[];
+}
+export declare const LANGUAGE_REGISTRY: LanguageRegistry;

package/dist/lang/registry.d.ts

@@ -0,0 +1,24 @@
+import { type Parser } from './runtime';
+export interface LanguageDefinition {
+    id: string;
+    extensions: string[];
+    commentNodes: string[];
+}
+export declare const languageDefinitions: LanguageDefinition[];
+export declare function getLanguageForExtension(extension: string): LanguageDefinition | undefined;
+export declare function listSupportedLanguages(): readonly LanguageDefinition[];
+/**
+ * Get a parser for a specific file path
+ * Determines language from file extension, loads grammar, returns configured parser
+ *
+ * @param filePath - Absolute or relative path to the file
+ * @returns Parser instance or null if language not supported
+ */
+export declare function getParserForFile(filePath: string): Promise<Parser | null>;
+/**
+ * Check if a file path has a supported language extension
+ *
+ * @param filePath - Path to check
+ * @returns true if extension is supported
+ */
+export declare function isSupportedFile(filePath: string): boolean;

package/dist/lang/runtime.d.ts

@@ -0,0 +1,35 @@
+import type { Parser as ParserType } from 'web-tree-sitter';
+export type Parser = ParserType;
+/**
+ * Parser cache to avoid reloading grammars multiple times per session
+ */
+export declare const parserCache: Map<string, ParserType>;
+/**
+ * Initialize a parser for the given language
+ * Loads WASM from dist/lang/grammars/ (copied during build)
+ *
+ * @param languageId - Language identifier (e.g., 'javascript', 'python')
+ * @returns Configured Parser instance
+ * @throws Error if WASM file not found or failed to load
+ */
+export declare function loadGrammar(languageId: string): Promise<ParserType>;
+/**
+ * Check if a language grammar is available (WASM file exists)
+ * Does not load the grammar, just checks existence
+ *
+ * @param languageId - Language identifier
+ * @returns true if grammar is available
+ */
+export declare function isGrammarAvailable(languageId: string): Promise<boolean>;
+/**
+ * Clear the parser cache (useful for testing)
+ */
+export declare function clearParserCache(): void;
+/**
+ * Get list of initialized languages
+ */
+export declare function getInitializedLanguages(): string[];
+/**
+ * Get list of supported language IDs
+ */
+export declare function getSupportedLanguages(): string[];

package/dist/model-fallback.adversarial.test.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Adversarial tests for model fallback schema and state (v6.33)
+ *
+ * Tests attack vectors against:
+ * 1. AgentOverrideConfigSchema fallback_models field
+ * 2. AgentSessionState model_fallback_index and modelFallbackExhausted
+ *
+ * ADVERSARIAL TEST CASES:
+ * 1. fallback_models with 1000 entries — should Zod-reject (max 3)
+ * 2. fallback_models with non-string values (numbers, objects, null)
+ * 3. fallback_models with empty strings ""
+ * 4. fallback_models with extremely long model name strings (10K chars)
+ * 5. model_fallback_index set to NaN — should it be NaN or coerced?
+ * 6. model_fallback_index set to -1 — negative index
+ * 7. model_fallback_index set to MAX_SAFE_INTEGER — overflow risk?
+ * 8. modelFallbackExhausted set to undefined in deserialization — should default to false
+ * 9. Circular reference in fallback_models array elements
+ * 10. Prototype pollution via __proto__ in fallback_models
+ * 11. AgentOverrideConfigSchema.parse with all fields including fallback_models, verify no field collision
+ * 12. Serialization with model_fallback_index as a float (3.14) — should survive round-trip
+ */
+export {};

package/dist/model-fallback.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tests for model fallback schema and state (v6.33)
+ *
+ * Covers:
+ * 1. AgentOverrideConfigSchema fallback_models field parsing
+ * 2. State initialization of model_fallback_index and modelFallbackExhausted
+ * 3. Serialization round-trip for both fields
+ * 4. Deserialization defaults when fields are missing
+ * 5. Migration safety via ensureAgentSession
+ * 6. Edge cases for schema and state
+ */
+export {};

package/dist/mutation/__tests__/engine.adversarial.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mutation/__tests__/engine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mutation/__tests__/equivalence.adversarial.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mutation/__tests__/equivalence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mutation/__tests__/gate.adversarial.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mutation/__tests__/gate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mutation/__tests__/generator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mutation/engine.d.ts

@@ -0,0 +1,47 @@
+export type MutationOutcome = 'killed' | 'survived' | 'timeout' | 'error' | 'equivalent' | 'skipped';
+export interface MutationPatch {
+    id: string;
+    filePath: string;
+    functionName: string;
+    mutationType: string;
+    patch: string;
+    lineNumber?: number;
+}
+export interface MutationResult {
+    patchId: string;
+    filePath: string;
+    functionName: string;
+    mutationType: string;
+    outcome: MutationOutcome;
+    testOutput?: string;
+    durationMs: number;
+    error?: string;
+}
+export interface MutationReport {
+    totalMutants: number;
+    killed: number;
+    survived: number;
+    timeout: number;
+    equivalent: number;
+    skipped: number;
+    errors: number;
+    killRate: number;
+    adjustedKillRate: number;
+    perFunction: Map<string, {
+        killed: number;
+        survived: number;
+        total: number;
+        equivalent: number;
+        skipped: number;
+        killRate: number;
+    }>;
+    results: MutationResult[];
+    durationMs: number;
+    budgetMs: number;
+    budgetExceeded: boolean;
+    timestamp: string;
+}
+export declare const MAX_MUTATIONS_PER_FUNCTION = 10;
+export declare function executeMutation(patch: MutationPatch, testCommand: string[], _testFiles: string[], workingDir: string): Promise<MutationResult>;
+export declare function computeReport(results: MutationResult[], durationMs: number, budgetMs?: number): MutationReport;
+export declare function executeMutationSuite(patches: MutationPatch[], testCommand: string[], testFiles: string[], workingDir: string, budgetMs?: number, onProgress?: (completed: number, total: number, result: MutationResult) => void, sourceFiles?: Map<string, string>): Promise<MutationReport>;

package/dist/mutation/equivalence.d.ts

@@ -0,0 +1,35 @@
+import type { MutationPatch } from './engine.js';
+/** Result of equivalence check for a single mutant */
+export interface EquivalenceResult {
+    patchId: string;
+    isEquivalent: boolean;
+    method: 'static' | 'llm_judge' | 'skipped';
+    confidence: number;
+    reason: string;
+}
+/** Callback signature for LLM judge — injected by caller */
+export type LLMJudgeCallback = (original: string, mutated: string, context: string) => Promise<{
+    isEquivalent: boolean;
+    confidence: number;
+    reason: string;
+}>;
+/**
+ * Stage 1: Static equivalence filter.
+ * Strips comments (single-line // and multi-line /* *\/), console.log/debugger statements,
+ * trailing whitespace, and blank lines. Returns true if the stripped versions are identical.
+ */
+export declare function isStaticallyEquivalent(originalCode: string, mutatedCode: string): boolean;
+/**
+ * Check a single mutant for equivalence using two-stage approach.
+ * Stage 1: static analysis. Stage 2: LLM judge (if provided and Stage 1 didn't determine equivalence).
+ */
+export declare function checkEquivalence(patch: MutationPatch, originalCode: string, mutatedCode: string, llmJudge?: LLMJudgeCallback): Promise<EquivalenceResult>;
+/**
+ * Batch check multiple mutants for equivalence.
+ * Returns results for all patches.
+ */
+export declare function batchCheckEquivalence(patches: Array<{
+    patch: MutationPatch;
+    originalCode: string;
+    mutatedCode: string;
+}>, llmJudge?: LLMJudgeCallback): Promise<EquivalenceResult[]>;

package/dist/mutation/gate.d.ts

@@ -0,0 +1,28 @@
+import type { MutationReport, MutationResult } from './engine.js';
+export type MutationGateVerdict = 'pass' | 'warn' | 'fail';
+export interface MutationGateResult {
+    verdict: MutationGateVerdict;
+    killRate: number;
+    adjustedKillRate: number;
+    totalMutants: number;
+    killed: number;
+    survived: number;
+    threshold: number;
+    warnThreshold: number;
+    message: string;
+    /** Survived mutants that need test improvements */
+    survivedMutants: MutationResult[];
+    /** Prompt for targeted test improvement (non-empty when verdict is 'warn' or 'fail') */
+    testImprovementPrompt: string;
+}
+/** Default thresholds */
+export declare const PASS_THRESHOLD = 0.8;
+export declare const WARN_THRESHOLD = 0.6;
+/**
+ * Evaluate a mutation report against quality gate thresholds.
+ * @param report - The mutation report to evaluate
+ * @param passThreshold - Kill rate at or above this passes (default: 0.80)
+ * @param warnThreshold - Kill rate at or above this warns (default: 0.60)
+ * @returns MutationGateResult with verdict and details
+ */
+export declare function evaluateMutationGate(report: MutationReport, passThreshold?: number, warnThreshold?: number): MutationGateResult;

package/dist/mutation/generator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LLM-based mutation patch generator.
+ *
+ * Uses the opencode SDK to call an LLM session and generate mutation testing patches
+ * for specified source files. Produces MutationPatch[] for use by executeMutationSuite.
+ */
+import type { ToolContext } from '@opencode-ai/plugin';
+import type { MutationPatch } from './engine.js';
+/**
+ * Generate mutation testing patches for the given source files using an LLM.
+ *
+ * @param files - Array of file paths to generate mutations for
+ * @param ctx - Optional ToolContext providing sessionID and directory
+ * @returns Promise<MutationPatch[]> array of mutation patches, never throws
+ */
+export declare function generateMutants(files: string[], ctx?: ToolContext): Promise<MutationPatch[]>;

package/dist/output/agent-writer.d.ts

@@ -0,0 +1,27 @@
+export type AgentType = 'architect' | 'coder' | 'reviewer' | 'test_engineer' | 'explorer' | 'sme' | 'critic' | 'docs' | 'designer';
+export type OutputType = 'review' | 'test' | 'research' | 'analysis' | 'summary';
+export interface AgentOutputMetadata {
+    agent: AgentType;
+    type: OutputType;
+    taskId: string;
+    phase: number;
+    timestamp: string;
+    durationMs?: number;
+    success?: boolean;
+}
+/**
+ * Write agent output to persistent storage
+ * Output: .swarm/outputs/phase-N/task-N.M/{agent}-{type}-{timestamp}.md
+ */
+export declare function writeAgentOutput(directory: string, metadata: AgentOutputMetadata, content: string): Promise<string>;
+/**
+ * Read agent output from persistent storage
+ */
+export declare function readAgentOutput(directory: string, phase: number, taskId: string): Promise<{
+    metadata: AgentOutputMetadata;
+    content: string;
+}[]>;
+/**
+ * List all agent outputs for a phase
+ */
+export declare function listAgentOutputs(directory: string, phase?: number): Promise<AgentOutputMetadata[]>;

package/dist/output/index.d.ts

@@ -0,0 +1 @@
+export { type AgentOutputMetadata, type AgentType, listAgentOutputs, type OutputType, readAgentOutput, writeAgentOutput, } from './agent-writer';

package/dist/parallel/dependency-graph.d.ts

@@ -0,0 +1,34 @@
+export interface TaskNode {
+    id: string;
+    phase: number;
+    description: string;
+    depends: string[];
+    dependents: string[];
+    status: 'pending' | 'in_progress' | 'complete' | 'blocked';
+}
+export interface DependencyGraph {
+    tasks: Map<string, TaskNode>;
+    phases: Map<number, string[]>;
+    roots: string[];
+    leaves: string[];
+}
+/**
+ * Parse plan.json and build dependency graph
+ */
+export declare function parseDependencyGraph(planPath: string): DependencyGraph;
+/**
+ * Get tasks that can run in parallel (no unresolved dependencies)
+ */
+export declare function getRunnableTasks(graph: DependencyGraph): string[];
+/**
+ * Check if a task is blocked (has incomplete dependencies)
+ */
+export declare function isTaskBlocked(graph: DependencyGraph, taskId: string): boolean;
+/**
+ * Get execution order (topological sort)
+ */
+export declare function getExecutionOrder(graph: DependencyGraph): string[];
+/**
+ * Find all paths from root to a task
+ */
+export declare function getDependencyChain(graph: DependencyGraph, taskId: string): string[];

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

@@ -0,0 +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/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/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/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;
+}