opencode-swarm 7.13.2 → 7.15.0

package/dist/parallel/file-locks.d.ts

@@ -1,3 +1,4 @@
+import * as fs from 'node:fs';
 /**
  * Test-only dependency-injection seam. Tests replace the function on this
  * object so they can inject mock behaviour without touching the real
@@ -12,13 +13,27 @@
  */
 export declare const _internals: {
     tryAcquireLock: typeof tryAcquireLock;
+    writeFile: typeof fs.promises.writeFile;
 };
+/**
+ * Sidecar metadata written alongside each lock sentinel file.
+ */
+export interface LockMetadata {
+    originalPath: string;
+    laneId: string;
+    taskId: string;
+    agent: string;
+    sessionID: string;
+    acquiredAt: string;
+    expiresAt: number;
+}
 export interface FileLock {
     filePath: string;
     agent: string;
     taskId: string;
     timestamp: string;
     expiresAt: number;
+    laneId?: string;
     _release?: () => Promise<void>;
 }
 /**
@@ -46,10 +61,43 @@ export declare function releaseLock(_directory: string, _filePath: string, _task
  */
 export declare function isLocked(directory: string, filePath: string): FileLock | null;
 /**
- * Clean up expired locks
+ * Clean up expired locks and their sidecar metadata files.
  */
 export declare function cleanupExpiredLocks(directory: string): number;
 /**
- * List all active locks
+ * List all active locks, reading metadata from sidecar files when available.
+ * Filters out expired locks.
  */
 export declare function listActiveLocks(directory: string): FileLock[];
+/**
+ * Acquire locks for all files in a lane (all-or-nothing).
+ *
+ * If ANY file is already locked, releases ALL previously acquired locks
+ * in this lane and returns `{ acquired: false, conflicts }`.
+ *
+ * @param directory - Project root directory
+ * @param laneId - Unique lane identifier
+ * @param files - Array of file paths to lock
+ * @param agent - Agent name
+ * @param taskId - Task ID
+ * @param sessionID - Session ID
+ * @returns Success with array of FileLock objects, or failure with conflict list
+ */
+export declare function acquireLaneLocks(directory: string, laneId: string, files: string[], agent: string, taskId: string, sessionID: string): Promise<{
+    acquired: true;
+    locks: FileLock[];
+} | {
+    acquired: false;
+    conflicts: string[];
+}>;
+/**
+ * Release all locks for a given lane.
+ *
+ * Reads all `.meta` files in `.swarm/locks/`, finds entries matching `laneId`,
+ * and releases + deletes corresponding lock files.
+ *
+ * @param directory - Project root directory
+ * @param laneId - Lane ID to release
+ * @returns Number of locks released
+ */
+export declare function releaseLaneLocks(directory: string, laneId: string): Promise<number>;

package/dist/services/status-service.d.ts

@@ -1,4 +1,15 @@
 import type { AgentDefinition } from '../agents';
+import { hasActiveFullAuto, hasActiveLeanTurbo } from '../state';
+import { loadLeanTurboRunState } from '../turbo/lean/state';
+/**
+ * Dependency-injection seam for status-service.
+ * Allows tests to intercept Lean Turbo state queries without mock.module leakage.
+ */
+export declare const _internals: {
+    loadLeanTurboRunState: typeof loadLeanTurboRunState;
+    hasActiveLeanTurbo: typeof hasActiveLeanTurbo;
+    hasActiveFullAuto: typeof hasActiveFullAuto;
+};
 /**
  * Structured status data returned by the status service.
  * This can be used by GUI, background flows, or command adapters.
@@ -11,6 +22,24 @@ export interface StatusData {
     agentCount: number;
     isLegacy: boolean;
     turboMode: boolean;
+    /** Lean Turbo strategy: 'lean', 'standard', or 'off' */
+    turboStrategy?: 'standard' | 'lean' | 'off';
+    /** Lean Turbo phase number, if Lean Turbo is active */
+    leanTurboPhase?: number;
+    /** Number of lanes currently in 'running' status */
+    leanActiveLaneCount?: number;
+    /** Max parallel coders configured for Lean Turbo */
+    leanMaxParallelCoders?: number;
+    /** Number of lanes completed */
+    leanCompletedLanes?: number;
+    /** Number of tasks marked as degraded */
+    leanDegradedTasks?: number;
+    /** Human-readable degradation summary */
+    leanDegradationSummary?: string;
+    /** Whether Full-Auto mode is currently active */
+    fullAutoActive?: boolean;
+    /** Reason for pause if Lean Turbo is paused */
+    leanPauseReason?: string;
     /** Last known context budget percentage (0-100), or null if not yet measured */
     contextBudgetPct: number | null;
     /** Number of context compaction events triggered this session */

package/dist/state.d.ts

@@ -157,6 +157,14 @@ export interface AgentSessionState {
     modelFallbackExhausted: boolean;
     /** Session-scoped Turbo Mode flag for controlling LLM inference speed */
     turboMode: boolean;
+    /** Session-scoped turbo strategy selection — standard or lean. When undefined,
+     *  falls back to standard (current behavior). */
+    turboStrategy?: 'standard' | 'lean';
+    /** Whether Lean Turbo is actively running in this session. Requires
+     *  turboStrategy === 'lean'. */
+    leanTurboActive?: boolean;
+    /** Current phase number when Lean Turbo is active (for durable state sync). */
+    leanTurboCurrentPhase?: number;
     /** Session-level QA gate overrides layered on top of the spec-level profile.
      *  Overrides can only enable gates (true); false values are ignored by
      *  getEffectiveGates. Cleared on session reset. Optional for backwards
@@ -533,6 +541,14 @@ export declare function hasActiveTurboMode(sessionID?: string): boolean;
  * @returns true if the specified session has fullAutoMode: true (model validation is advisory-only).
  */
 export declare function hasActiveFullAuto(sessionID?: string): boolean;
+/**
+ * Check if Lean Turbo Mode is active for a specific session or ANY session.
+ * @param sessionID - Optional session ID to check. If provided, checks only that session.
+ *                    If omitted, checks all sessions.
+ * @returns true if the specified session has turboStrategy: 'lean' AND leanTurboActive: true,
+ *          or if any session has that combination when no sessionID provided.
+ */
+export declare function hasActiveLeanTurbo(sessionID?: string): boolean;
 export declare function setSessionEnvironment(sessionId: string, profile: EnvironmentProfile): void;
 export declare function getSessionEnvironment(sessionId: string): EnvironmentProfile | undefined;
 export declare function ensureSessionEnvironment(sessionId: string): EnvironmentProfile;
@@ -574,6 +590,7 @@ export declare const _internals: {
     getTaskState: typeof getTaskState;
     hasActiveFullAuto: typeof hasActiveFullAuto;
     hasActiveTurboMode: typeof hasActiveTurboMode;
+    hasActiveLeanTurbo: typeof hasActiveLeanTurbo;
     buildRehydrationCache: typeof buildRehydrationCache;
     applyRehydrationCache: typeof applyRehydrationCache;
     rehydrateSessionFromDisk: typeof rehydrateSessionFromDisk;

package/dist/tools/index.d.ts

@@ -59,6 +59,12 @@ export { classifyAndCluster, classifyFailure, clusterFailures, } from '../test-i
 export type { FlakyTestEntry } from '../test-impact/flaky-detector.js';
 export { computeFlakyScore, detectFlakyTests, isTestQuarantined, } from '../test-impact/flaky-detector.js';
 export { generate_mutants } from './generate-mutants';
+export { lean_turbo_acquire_locks } from './lean-turbo-acquire-locks';
+export { lean_turbo_plan_lanes } from './lean-turbo-plan-lanes';
+export { lean_turbo_review } from './lean-turbo-review';
+export { lean_turbo_run_phase } from './lean-turbo-run-phase';
+export { lean_turbo_runner_status } from './lean-turbo-runner-status';
+export { lean_turbo_status } from './lean-turbo-status';
 export { lint_spec } from './lint-spec';
 export { mutation_test } from './mutation-test';
 export { symbols } from './symbols';

package/dist/tools/lean-turbo-acquire-locks.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Lean Turbo Acquire Locks Tool.
+ * Wraps acquireLaneLocks from src/parallel/file-locks.
+ * Acquires file locks for all files in a lane (all-or-nothing).
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import { type FileLock } from '../parallel/file-locks';
+/**
+ * Arguments for the lean_turbo_acquire_locks tool
+ */
+export interface LeanTurboAcquireLocksArgs {
+    directory: string;
+    laneId: string;
+    files: string[];
+    agent: string;
+    taskId: string;
+    sessionID: string;
+}
+/**
+ * Result from executing lean_turbo_acquire_locks
+ */
+export interface LeanTurboAcquireLocksResult {
+    success: boolean;
+    locks?: FileLock[];
+    conflicts?: string[];
+    errors?: string[];
+}
+/**
+ * Execute the lean_turbo_acquire_locks tool.
+ * Acquires locks for all files in a lane (all-or-nothing).
+ */
+export declare function executeLeanTurboAcquireLocks(args: LeanTurboAcquireLocksArgs): Promise<LeanTurboAcquireLocksResult>;
+/**
+ * Tool definition for lean_turbo_acquire_locks
+ */
+export declare const lean_turbo_acquire_locks: ToolDefinition;

package/dist/tools/lean-turbo-plan-lanes.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Lean Turbo Plan Lanes Tool.
+ * Wraps planLeanTurboLanes from src/turbo/lean/planner.
+ * Partitions phase tasks into parallel lanes based on file-scope conflicts.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import type { LeanTurboLanePlan } from '../turbo/lean/planner';
+/**
+ * Arguments for the lean_turbo_plan_lanes tool
+ */
+export interface LeanTurboPlanLanesArgs {
+    directory: string;
+    phase: number;
+    scopes?: Record<string, string[]>;
+}
+/**
+ * Result from executing lean_turbo_plan_lanes
+ */
+export interface LeanTurboPlanLanesResult {
+    success: boolean;
+    plan?: LeanTurboLanePlan;
+    lanes?: LeanTurboLanePlan['lanes'];
+    degradedTasks?: LeanTurboLanePlan['degradedTasks'];
+    serializedTasks?: LeanTurboLanePlan['serializedTasks'];
+    errors?: string[];
+}
+/**
+ * Execute the lean_turbo_plan_lanes tool.
+ * Partitions phase tasks into parallel lanes based on file-scope conflicts.
+ */
+export declare function executeLeanTurboPlanLanes(args: LeanTurboPlanLanesArgs): Promise<LeanTurboPlanLanesResult>;
+/**
+ * Tool definition for lean_turbo_plan_lanes
+ */
+export declare const lean_turbo_plan_lanes: ToolDefinition;

package/dist/tools/lean-turbo-review.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Lean Turbo Review Tool.
+ * Wraps dispatchPhaseReviewer from src/turbo/lean/reviewer.
+ * Dispatches a read-only reviewer agent to evaluate a completed Lean Turbo phase.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import { type PhaseReviewerResult } from '../turbo/lean/reviewer';
+/**
+ * Arguments for the lean_turbo_review tool
+ */
+export interface LeanTurboReviewArgs {
+    directory: string;
+    phase: number;
+    sessionID: string;
+}
+/**
+ * Result from executing lean_turbo_review
+ */
+export interface LeanTurboReviewResult {
+    success: boolean;
+    verdict?: PhaseReviewerResult['verdict'];
+    reason?: string;
+    evidencePath?: string;
+    errors?: string[];
+}
+/**
+ * Execute the lean_turbo_review tool.
+ * Dispatches a read-only reviewer agent to evaluate a completed Lean Turbo phase.
+ */
+export declare function executeLeanTurboReview(args: LeanTurboReviewArgs): Promise<LeanTurboReviewResult>;
+/**
+ * Tool definition for lean_turbo_review
+ */
+export declare const lean_turbo_review: ToolDefinition;

package/dist/tools/lean-turbo-run-phase.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Lean Turbo Run Phase Tool.
+ * Wraps LeanTurboRunner to execute a phase using Lean Turbo parallel lane execution.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import { loadPluginConfigWithMeta as loadPluginConfigWithMeta_import } from '../config';
+import type { LaneResult } from '../turbo/lean/runner';
+import { LeanTurboRunner as LeanTurboRunner_import } from '../turbo/lean/runner';
+/**
+ * Arguments for the lean_turbo_run_phase tool
+ */
+export interface LeanTurboRunPhaseArgs {
+    directory: string;
+    phase: number;
+    sessionID: string;
+}
+/**
+ * Result from executing lean_turbo_run_phase
+ */
+export interface LeanTurboRunPhaseResult {
+    success: boolean;
+    lanes?: LaneResult[];
+    degradedTasks?: string[];
+    serializedTasks?: string[];
+    reason?: string;
+    errors?: string[];
+}
+/**
+ * Test-only dependency-injection seam.
+ * Allows tests to inject mocks without mock.module leakage.
+ */
+export declare const _internals: {
+    LeanTurboRunner: typeof LeanTurboRunner_import;
+    loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta_import;
+};
+/**
+ * Execute the lean_turbo_run_phase tool.
+ * Creates a LeanTurboRunner and executes the specified phase.
+ */
+export declare function executeLeanTurboRunPhase(args: LeanTurboRunPhaseArgs): Promise<LeanTurboRunPhaseResult>;
+/**
+ * Tool definition for lean_turbo_run_phase
+ */
+export declare const lean_turbo_run_phase: ToolDefinition;

package/dist/tools/lean-turbo-runner-status.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Lean Turbo Runner Status Tool.
+ * Reads Lean Turbo run state from .swarm/turbo-state.json.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import { type LeanTurboRunState } from '../turbo/lean/state';
+/**
+ * Arguments for the lean_turbo_runner_status tool
+ */
+export interface LeanTurboRunnerStatusArgs {
+    directory: string;
+    sessionID: string;
+}
+/**
+ * Result from executing lean_turbo_runner_status
+ */
+export interface LeanTurboRunnerStatusResult {
+    success: boolean;
+    status?: LeanTurboRunState['status'];
+    phase?: number;
+    lanes?: LeanTurboRunState['lanes'];
+    degradedTasks?: LeanTurboRunState['degradedTasks'];
+    maxParallelCoders?: number;
+    sessionID?: string;
+    strategy?: 'lean';
+    errors?: string[];
+}
+/**
+ * Execute the lean_turbo_runner_status tool.
+ * Reads Lean Turbo run state from .swarm/turbo-state.json.
+ */
+export declare function executeLeanTurboRunnerStatus(args: LeanTurboRunnerStatusArgs): Promise<LeanTurboRunnerStatusResult>;
+/**
+ * Tool definition for lean_turbo_runner_status
+ */
+export declare const lean_turbo_runner_status: ToolDefinition;

package/dist/tools/lean-turbo-status.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Lean Turbo Status Tool.
+ * Returns Lean Turbo configuration and active status for the current session.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+/**
+ * Arguments for the lean_turbo_status tool
+ */
+export interface LeanTurboStatusArgs {
+    directory: string;
+    sessionID: string;
+}
+/**
+ * Lean Turbo configuration that would be active
+ */
+export interface LeanTurboStatusConfig {
+    max_parallel_coders: number;
+    require_declared_scope: boolean;
+    degrade_on_risk: boolean;
+    conflict_policy: 'degrade' | 'serialize';
+}
+/**
+ * Result from executing lean_turbo_status
+ */
+export interface LeanTurboStatusResult {
+    success: boolean;
+    strategy?: 'lean';
+    leanActive?: boolean;
+    config?: LeanTurboStatusConfig;
+    status?: string;
+    phase?: number;
+    lanes?: number;
+    degradedTasks?: number;
+    errors?: string[];
+}
+/**
+ * Execute the lean_turbo_status tool.
+ * Returns Lean Turbo configuration and active status.
+ */
+export declare function executeLeanTurboStatus(args: LeanTurboStatusArgs): Promise<LeanTurboStatusResult>;
+/**
+ * Tool definition for lean_turbo_status
+ */
+export declare const lean_turbo_status: ToolDefinition;

package/dist/tools/tool-names.d.ts

@@ -3,7 +3,7 @@
  * Used for constants and agent setup references.
  */
 /** Union type of all valid tool names */
-export type ToolName = 'diff' | 'diff_summary' | 'syntax_check' | 'placeholder_scan' | 'imports' | 'lint' | 'secretscan' | 'sast_scan' | 'build_check' | 'pre_check_batch' | 'quality_budget' | 'symbols' | 'complexity_hotspots' | 'schema_drift' | 'todo_extract' | 'evidence_check' | 'check_gate_status' | 'completion_verify' | 'submit_council_verdicts' | 'submit_phase_council_verdicts' | 'declare_council_criteria' | 'sbom_generate' | 'checkpoint' | 'pkg_audit' | 'test_runner' | 'test_impact' | 'mutation_test' | 'generate_mutants' | 'detect_domains' | 'gitingest' | 'retrieve_summary' | 'extract_code_blocks' | 'phase_complete' | 'save_plan' | 'update_task_status' | 'lint_spec' | 'write_retro' | 'write_drift_evidence' | 'write_hallucination_evidence' | 'write_mutation_evidence' | 'declare_scope' | 'knowledge_query' | 'doc_scan' | 'doc_extract' | 'curator_analyze' | 'knowledge_add' | 'knowledge_recall' | 'knowledge_remove' | 'co_change_analyzer' | 'search' | 'batch_symbols' | 'suggest_patch' | 'req_coverage' | 'get_approved_plan' | 'repo_map' | 'get_qa_gate_profile' | 'set_qa_gates' | 'web_search' | 'convene_general_council' | 'write_final_council_evidence' | 'skill_generate' | 'skill_list' | 'skill_apply' | 'skill_inspect' | 'skill_improve' | 'spec_write' | 'knowledge_ack';
+export type ToolName = 'diff' | 'diff_summary' | 'syntax_check' | 'placeholder_scan' | 'imports' | 'lint' | 'secretscan' | 'sast_scan' | 'build_check' | 'pre_check_batch' | 'quality_budget' | 'symbols' | 'complexity_hotspots' | 'schema_drift' | 'todo_extract' | 'evidence_check' | 'check_gate_status' | 'completion_verify' | 'submit_council_verdicts' | 'submit_phase_council_verdicts' | 'declare_council_criteria' | 'sbom_generate' | 'checkpoint' | 'pkg_audit' | 'test_runner' | 'test_impact' | 'mutation_test' | 'generate_mutants' | 'detect_domains' | 'gitingest' | 'retrieve_summary' | 'extract_code_blocks' | 'phase_complete' | 'save_plan' | 'update_task_status' | 'lint_spec' | 'write_retro' | 'write_drift_evidence' | 'write_hallucination_evidence' | 'write_mutation_evidence' | 'declare_scope' | 'knowledge_query' | 'doc_scan' | 'doc_extract' | 'curator_analyze' | 'knowledge_add' | 'knowledge_recall' | 'knowledge_remove' | 'co_change_analyzer' | 'search' | 'batch_symbols' | 'suggest_patch' | 'req_coverage' | 'get_approved_plan' | 'repo_map' | 'get_qa_gate_profile' | 'set_qa_gates' | 'web_search' | 'convene_general_council' | 'write_final_council_evidence' | 'skill_generate' | 'skill_list' | 'skill_apply' | 'skill_inspect' | 'skill_improve' | 'spec_write' | 'knowledge_ack' | 'lean_turbo_plan_lanes' | 'lean_turbo_acquire_locks' | 'lean_turbo_runner_status' | 'lean_turbo_review' | 'lean_turbo_run_phase' | 'lean_turbo_status';
 /** Readonly array of all tool names */
 export declare const TOOL_NAMES: readonly ToolName[];
 /** Set for O(1) tool name validation */

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

@@ -2,7 +2,7 @@
  * Update task status tool for changing the status of individual tasks in a plan.
  * Allows agents to mark tasks as pending, in_progress, completed, or blocked.
  */
-import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import type { ToolContext, ToolDefinition } from '@opencode-ai/plugin/tool';
 /**
  * Arguments for the update_task_status tool
  */
@@ -50,18 +50,20 @@ export interface ReviewerGateResult {
  * @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)
+ * @param sessionID - Optional session ID to scope Lean Turbo bypass to the current tool-execution context
  * @returns ReviewerGateResult indicating whether the gate is blocked
  */
-export declare function checkReviewerGate(taskId: string, workingDirectory?: string, stageBParallelEnabled?: boolean): ReviewerGateResult;
+export declare function checkReviewerGate(taskId: string, workingDirectory?: string, stageBParallelEnabled?: boolean, sessionID?: string): ReviewerGateResult;
 /**
  * Wrapper around checkReviewerGate that appends a diff-scope advisory warning.
  * Keeps checkReviewerGate synchronous for backward compatibility.
  * Stage B parallel is hardcoded (not config-driven).
  * @param taskId - The task ID to check gate state for
  * @param workingDirectory - Optional working directory for plan.json fallback
+ * @param sessionID - Optional session ID to scope Lean Turbo bypass to the current tool-execution context
  * @returns ReviewerGateResult with optional scope warning appended to reason
  */
-export declare function checkReviewerGateWithScope(taskId: string, workingDirectory?: string): Promise<ReviewerGateResult>;
+export declare function checkReviewerGateWithScope(taskId: string, workingDirectory?: string, sessionID?: string): Promise<ReviewerGateResult>;
 /**
  * Recovery mechanism: reconcile task state with delegation history.
  * When reviewer/test_engineer delegations occurred but the state machine
@@ -105,9 +107,10 @@ export declare function checkCouncilGate(workingDirectory: string, taskId: strin
  * Only one concurrent call wins the lock; others return success: false with recovery_guidance: "retry".
  * @param args - The update task status arguments
  * @param fallbackDir - Fallback working directory if args.working_directory is not provided
+ * @param ctx - Optional ToolContext providing sessionID for Lean Turbo cross-session bypass prevention
  * @returns UpdateTaskStatusResult with success status and details
  */
-export declare function executeUpdateTaskStatus(args: UpdateTaskStatusArgs, fallbackDir?: string): Promise<UpdateTaskStatusResult>;
+export declare function executeUpdateTaskStatus(args: UpdateTaskStatusArgs, fallbackDir?: string, ctx?: ToolContext): Promise<UpdateTaskStatusResult>;
 /**
  * Tool definition for update_task_status
  */

package/dist/turbo/lean/conflicts.d.ts

@@ -0,0 +1,100 @@
+/**
+ * File Scope Conflict Detection for Lean Turbo.
+ *
+ * This module provides conflict detection utilities for determining whether
+ * tasks can be executed in parallel based on their file scopes.
+ *
+ * ## Conflict Detection Rules
+ *
+ * Two tasks conflict if:
+ * - They touch the **same file**
+ * - One task touches a **parent directory** of a file the other task touches
+ *   (e.g., `src/auth/` vs `src/auth/login.ts`)
+ * - A task touches a **global file** (affects all coders)
+ * - A task touches a **protected path** (security-sensitive areas)
+ *
+ * ## Path Normalization
+ *
+ * All paths are normalized to POSIX-style (forward slashes, no trailing slash)
+ * before conflict detection. This ensures consistent behavior across platforms.
+ */
+/**
+ * A scope file persisted by the `declare_scope` tool.
+ * Stored at `.swarm/scopes/scope-{taskId}.json`.
+ */
+export interface ScopeFile {
+    taskId: string;
+    files: string[];
+    declaredAt: string;
+}
+/**
+ * Barrel file patterns that indicate generated/index files.
+ * These are treated as global because other tasks may import from them.
+ */
+export declare const BARREL_FILE_PATTERNS: readonly RegExp[];
+/**
+ * Normalize a file path to POSIX-style for consistent cross-platform comparison.
+ *
+ * - Converts backslashes to forward slashes
+ * - Removes trailing slashes
+ * - Collapses multiple consecutive slashes
+ * - Resolves `.` path segments (current directory references)
+ * - Does NOT resolve `..` segments or symlinks
+ *
+ * @param filePath - The path to normalize
+ * @returns POSIX-normalized path
+ */
+export declare function normalizePath(filePath: string): string;
+/**
+ * Check if a path contains directory traversal components.
+ * Rejects paths with `..` segments that could escape the project root.
+ *
+ * @param filePath - The path to validate
+ * @returns true if the path is safe (no traversal)
+ */
+export declare function isPathSafe(filePath: string): boolean;
+/**
+ * Check if two normalized paths conflict.
+ *
+ * Conflicts occur when:
+ * - The paths are identical (same file)
+ * - One path is a parent directory of the other
+ *
+ * IMPORTANT: Parent/child detection is path-segment aware.
+ * `src/auth/` contains `src/auth/login.ts` but NOT `src/authentication.ts`.
+ *
+ * @param path1 - First normalized path
+ * @param path2 - Second normalized path
+ * @returns true if the paths conflict
+ */
+export declare function pathsConflict(path1: string, path2: string): boolean;
+/**
+ * Check if a normalized path is a global file.
+ * Global files affect all coders and cannot be parallelized safely.
+ *
+ * @param normalizedPath - POSIX-normalized path
+ * @returns true if the file is global
+ */
+export declare function isGlobalFile(normalizedPath: string): boolean;
+/**
+ * Check if a normalized path matches a protected path pattern.
+ * Protected paths are security-sensitive areas that require special handling.
+ *
+ * @param normalizedPath - POSIX-normalized path to check
+ * @returns true if the path is protected
+ */
+export declare function isProtectedPath(normalizedPath: string): boolean;
+/**
+ * Read task scope from the scope file for a given task.
+ *
+ * Scope files are stored at `.swarm/scopes/scope-{taskId}.json`.
+ *
+ * @param directory - The project root directory
+ * @param taskId - The task ID (e.g., "4.1")
+ * @returns Array of file paths, or null if scope file doesn't exist
+ */
+export declare function readTaskScopes(directory: string, taskId: string): string[] | null;
+/** Exported for unit testing */
+export declare const GLOBAL_FILES_LIST: readonly string[];
+/** Exported for unit testing */
+export declare const PROTECTED_PATTERNS_LIST: readonly string[];

package/dist/turbo/lean/evidence.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Evidence record for a single lane.
+ */
+export interface LaneEvidence {
+    laneId: string;
+    taskIds: string[];
+    files: string[];
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'blocked';
+    startedAt?: string;
+    completedAt?: string;
+    error?: string;
+    agent?: string;
+    sessionId?: string;
+}
+import type { LeanTurboConfig } from '../../config/schema';
+/**
+ * Aggregated evidence for an entire Lean Turbo phase.
+ */
+export interface PhaseEvidence {
+    phase: number;
+    planId: string;
+    lanes: LaneEvidence[];
+    degradedTasks: {
+        taskId: string;
+        reason: string;
+    }[];
+    startedAt: string;
+    completedAt?: string;
+    status: 'running' | 'completed' | 'failed';
+    /** Paths to lane evidence files (e.g., `.swarm/evidence/{phase}/lean-turbo/{laneId}.json`) */
+    evidencePaths?: string[];
+    /** Summary of integrated diff across all lanes */
+    integratedDiffSummary?: string;
+    /** Integrated reviewer verdict */
+    reviewerVerdict?: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED';
+    /** Critic verdict */
+    criticVerdict?: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED' | 'ESCALATE_TO_HUMAN';
+    /** Snapshot of lean turbo config used for this phase */
+    configSnapshot?: LeanTurboConfig;
+    /** ISO timestamp when phase evidence was written (distinct from startedAt/completedAt) */
+    timestamp?: string;
+}
+/**
+ * Writes a single lane's evidence to disk.
+ *
+ * Uses atomic write (temp file + rename) so readers never see a partial file.
+ *
+ * @param directory - Project root directory
+ * @param phase - Phase number
+ * @param evidence - Lane evidence to persist
+ * @throws Error if laneId fails validation
+ */
+export declare function writeLaneEvidence(directory: string, phase: number, evidence: LaneEvidence): Promise<void>;
+/**
+ * Reads a single lane's evidence from disk.
+ *
+ * @param directory - Project root directory
+ * @param phase - Phase number
+ * @param laneId - Lane identifier
+ * @returns Parsed LaneEvidence, or null if file does not exist or is invalid
+ * @throws Error if laneId fails validation
+ */
+export declare function readLaneEvidence(directory: string, phase: number, laneId: string): Promise<LaneEvidence | null>;
+/**
+ * Writes phase-level aggregated evidence to disk.
+ *
+ * Uses atomic write (temp file + rename).
+ *
+ * @param directory - Project root directory
+ * @param evidence - Phase evidence to persist
+ */
+export declare function writePhaseEvidence(directory: string, evidence: PhaseEvidence): Promise<void>;
+/**
+ * Reads phase-level aggregated evidence from disk.
+ *
+ * @param directory - Project root directory
+ * @param phase - Phase number
+ * @returns Parsed PhaseEvidence, or null if file does not exist or is invalid
+ */
+export declare function readPhaseEvidence(directory: string, phase: number): Promise<PhaseEvidence | null>;
+/**
+ * Lists all lane evidence files for a given phase.
+ *
+ * Reads every `.json` file in the lean-turbo evidence directory and returns
+ * parsed LaneEvidence objects. Files that cannot be read or parsed are skipped.
+ *
+ * @param directory - Project root directory
+ * @param phase - Phase number
+ * @returns Array of LaneEvidence, skipping any invalid files
+ */
+export declare function listLaneEvidence(directory: string, phase: number): Promise<LaneEvidence[]>;