opencode-swarm 7.14.0 → 7.16.0

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

@@ -0,0 +1,27 @@
+/**
+ * Lean Turbo Module — barrel export.
+ *
+ * Re-exports all public symbols from sub-modules so consumers can import
+ * everything from a single path:
+ *
+ * ```ts
+ * import { LeanTurboRunner, planLeanTurboLanes, LeanTurboLane, ... } from './turbo/lean';
+ * ```
+ */
+export type { LaneDispatchResult, LaneResult, LaneStatus, LeanTurboPhaseResult, } from './runner';
+export { LeanTurboRunner } from './runner';
+export type { LeanTurboLanePlan, PlanPhase, PlanTask, } from './planner';
+export { GLOBAL_FILES_LIST, isGlobalFile, isPathSafe, isProtectedPath, normalizePath, PROTECTED_PATTERNS_LIST, pathsConflict, planLeanTurboLanes, readTaskScopes, } from './planner';
+export type { LeanTurboCounters, LeanTurboDegradedTask, LeanTurboLane, LeanTurboPersistedState, LeanTurboRunState, LeanTurboStatus, } from './state';
+export { emptyCounters, emptyPersisted, emptyRunState, isLeanTurboRunActive, isStateUnreadable, loadLeanTurboRunState, pauseLeanTurboRun, repairStateUnreadable, resetLeanTurboRun, saveLeanTurboRunState, } from './state';
+export type { LeanTurboConfig } from '../../config/schema';
+export type { LaneEvidence, PhaseEvidence } from './evidence';
+export { listLaneEvidence, readLaneEvidence, readPhaseEvidence, writeLaneEvidence, writePhaseEvidence, } from './evidence';
+export type { LeanTurboPhaseReadyConfig, LeanTurboPhaseReadyResult, } from './phase-ready';
+export { verifyLeanTurboPhaseReady } from './phase-ready';
+export type { TaskRiskAssessment, TaskRiskCategory } from './risk';
+export { assessTaskRisk } from './risk';
+export type { LeanTurboPhaseCriticConfig, PhaseCriticResult, } from './integration';
+export { dispatchPhaseCritic } from './integration';
+export type { LeanTurboPhaseReviewerConfig, PhaseReviewerResult, } from './reviewer';
+export { dispatchPhaseReviewer } from './reviewer';

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

@@ -0,0 +1,137 @@
+import { type LaneEvidence, listLaneEvidence, readPhaseEvidence } from './evidence';
+/**
+ * Configuration options for phase critic dispatch.
+ */
+export interface LeanTurboPhaseCriticConfig {
+    /**
+     * Override the critic agent name.
+     * Default: derived from `generatedAgentNames` via `{swarmId}_critic` pattern
+     * when a swarm has multiple critics, or `critic` for the default swarm.
+     */
+    criticAgent?: string;
+    /**
+     * Timeout in milliseconds for the critic dispatch.
+     * Default: no timeout (critic is awaited indefinitely).
+     */
+    timeoutMs?: number;
+}
+/**
+ * Result of a phase critic dispatch.
+ */
+export interface PhaseCriticResult {
+    /** Critic verdict */
+    verdict: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED' | 'ESCALATE_TO_HUMAN';
+    /** Human-readable reason for the verdict */
+    reason?: string;
+    /** Path to the persisted critic evidence file */
+    evidencePath: string;
+}
+/**
+ * Reviewer evidence record (lean-turbo-reviewer.json).
+ */
+interface ReviewerEvidence {
+    phase: number;
+    verdict: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED';
+    reason?: string | null;
+    timestamp: string;
+}
+/**
+ * Resolves the default critic agent name from the generated agent names.
+ *
+ * Uses the `{swarmId}_critic` pattern for named swarms and bare `critic`
+ * for the default swarm. Follows the same suffix-based resolution used by
+ * `getCanonicalAgentRole` so that arbitrary swarm prefixes are handled correctly.
+ */
+declare function resolveDefaultCriticAgent(generatedAgentNames: string[]): string;
+/**
+ * Reads the reviewer evidence from .swarm/evidence/{phase}/lean-turbo-reviewer.json.
+ *
+ * @returns Parsed reviewer evidence, or null if file does not exist or is invalid
+ */
+declare function readReviewerEvidence(directory: string, phase: number): Promise<ReviewerEvidence | null>;
+/**
+ * Compiles a structured boundary review package from reviewer and phase evidence.
+ */
+interface CriticPackage {
+    phase: number;
+    sessionID: string;
+    /** Reviewer verdict if available */
+    reviewerVerdict?: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED';
+    /** Whether reviewer evidence was missing or invalid */
+    reviewerMissing: boolean;
+    /** Safety concerns noted during compilation */
+    safetyConcerns: string[];
+    laneSummaries: Array<{
+        laneId: string;
+        taskIds: string[];
+        files: string[];
+        status: LaneEvidence['status'];
+        agent?: string;
+    }>;
+    filesChanged: string[];
+    testResults: {
+        totalLanes: number;
+        completedLanes: number;
+        failedLanes: number;
+    };
+    degradationSummary: {
+        totalDegraded: number;
+        resolvedDegraded: number;
+        pendingDegraded: number;
+    };
+}
+declare function compileCriticPackage(directory: string, phase: number, sessionID: string): Promise<CriticPackage>;
+/**
+ * Parses a critic verdict from the agent's text response.
+ *
+ * Looks for a verdict marker line: `VERDICT: APPROVED`, `VERDICT: NEEDS_REVISION`,
+ * `VERDICT: REJECTED`, or `VERDICT: ESCALATE_TO_HUMAN` (case-insensitive).
+ * Returns null if no marker is found.
+ *
+ * The optional reason is extracted from a `REASON:` marker line that follows
+ * the verdict marker on a subsequent line.
+ */
+declare function parseCriticVerdict(responseText: string): {
+    verdict: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED' | 'ESCALATE_TO_HUMAN';
+    reason?: string;
+} | null;
+/**
+ * Writes the critic verdict to the evidence file.
+ * Uses atomic write (temp file + rename) to prevent partial-file artifacts.
+ */
+declare function writeCriticEvidence(directory: string, phase: number, verdict: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED' | 'ESCALATE_TO_HUMAN', reason?: string): Promise<string>;
+/**
+ * Test-only dependency-injection seam.
+ * Allows tests to intercept critic dispatch without mock.module leakage.
+ */
+export declare const _internals: {
+    compileCriticPackage: typeof compileCriticPackage;
+    parseCriticVerdict: typeof parseCriticVerdict;
+    writeCriticEvidence: typeof writeCriticEvidence;
+    dispatchCriticAgent: (directory: string, pkg: CriticPackage, agentName: string, timeoutMs: number) => Promise<string>;
+    resolveDefaultCriticAgent: typeof resolveDefaultCriticAgent;
+    readReviewerEvidence: typeof readReviewerEvidence;
+    listLaneEvidence: typeof listLaneEvidence;
+    readPhaseEvidence: typeof readPhaseEvidence;
+};
+/**
+ * Dispatch a read-only critic agent to evaluate boundary conditions for a completed Lean Turbo phase.
+ *
+ * Steps:
+ *  1. Read reviewer evidence from `.swarm/evidence/{phase}/lean-turbo-reviewer.json`
+ *  2. Read lane and phase evidence from `.swarm/evidence/{phase}/lean-turbo/`
+ *  3. Compile a boundary review package with safety concerns noted
+ *  4. Dispatch a read-only critic agent (tools: write=false, edit=false, patch=false)
+ *  5. Parse the verdict from the agent's response
+ *  6. Write the verdict to `.swarm/evidence/{phase}/lean-turbo-critic.json`
+ *  7. Return the result
+ *
+ * @param directory - Project root directory
+ * @param phase - Phase number being reviewed
+ * @param sessionID - Lean Turbo session ID
+ * @param config - Optional configuration overrides
+ * @returns PhaseCriticResult with verdict, optional reason, and evidence path
+ * @throws Error if dispatch fails or response cannot be parsed (fail-closed)
+ */
+export declare function dispatchPhaseCritic(directory: string, phase: number, sessionID: string, config?: LeanTurboPhaseCriticConfig): Promise<PhaseCriticResult>;
+export {};

package/dist/turbo/lean/phase-ready.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Lean Turbo Phase Boundary Gate Verification.
+ *
+ * Provides a synchronous helper to check whether a Lean Turbo phase is ready
+ * to advance to the next phase — i.e., whether all gates (lane completion,
+ * lock clearance, degraded task resolution, reviewer/critic approval) have
+ * been satisfied.
+ */
+import { listActiveLocks } from '../../parallel/file-locks';
+import { listLaneEvidence } from './evidence';
+import { readPersisted } from './state';
+/**
+ * Configuration options for phase gate checks.
+ * Passed optionally so callers can control whether reviewer/critic checks run.
+ */
+export interface LeanTurboPhaseReadyConfig {
+    phase_reviewer?: boolean;
+    phase_critic?: boolean;
+    integrated_diff_required?: boolean;
+}
+/**
+ * Result of the Lean Turbo phase readiness check.
+ */
+export interface LeanTurboPhaseReadyResult {
+    ok: boolean;
+    reason: string;
+    evidence?: {
+        lanes: string[];
+        degradedTasks: string[];
+        reviewerVerdict?: string;
+        criticVerdict?: string;
+    };
+}
+/**
+ * Shape of the plan.json file read by _internals.readPlanJson.
+ */
+interface PlanJson {
+    phases: Array<{
+        id?: number;
+        tasks: Array<{
+            id: string;
+            status: string;
+        }>;
+    }>;
+}
+/**
+ * Shape of the reviewer evidence file (lean-turbo-reviewer.json).
+ */
+interface ReviewerEvidence {
+    phase: number;
+    verdict: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED';
+    reason?: string | null;
+    timestamp: string;
+}
+/**
+ * Shape of the critic evidence file (lean-turbo-critic.json).
+ */
+interface CriticEvidence {
+    phase: number;
+    verdict: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED' | 'ESCALATE_TO_HUMAN';
+    reason?: string | null;
+    timestamp: string;
+}
+/**
+ * Test-only seam. Replaces the lock-list and state-load functions so tests
+ * can inject mock results without touching the real `file-locks` module or
+ * the module-level `stateUnreadable` flag used by `loadLeanTurboRunState`.
+ */
+export declare const _internals: {
+    listActiveLocks: typeof listActiveLocks;
+    readPersisted: typeof readPersisted;
+    readPlanJson: (dir: string) => PlanJson | null;
+    readReviewerEvidence: (dir: string, phase: number) => ReviewerEvidence | null;
+    readCriticEvidence: (dir: string, phase: number) => CriticEvidence | null;
+    listLaneEvidence: typeof listLaneEvidence;
+    listLaneEvidenceSync: (dir: string, phase: number) => string[];
+    verifyLeanTurboPhaseReady: typeof verifyLeanTurboPhaseReady;
+};
+/**
+ * Synchronously verify whether a Lean Turbo phase is ready to advance.
+ *
+ * Checks are performed in fail-fast order:
+ *  1. Read `.swarm/turbo-state.json` via readPersisted → null/unreadable → ok: false
+ *  2. Find a session with status === 'running' and phase === args.phase and strategy === 'lean'
+ *     If sessionID is provided, also require sessionId === sessionID → none → ok: false
+ *  3. Validate session.lanes is a non-empty array → empty → ok: false
+ *  4. Check all eligible lanes have status 'completed' or 'failed' → not → ok: false
+ *  5. Check no active lane locks exist for lanes in this phase → locks → ok: false
+ *  6. Check all degraded tasks in lane plan are resolved → pending/in_progress → ok: false
+ *  7. Check integrated diff evidence exists (when required) → missing → ok: false
+ *  8. Check reviewer approval if phase_reviewer enabled → missing/rejected → ok: false
+ *  9. Check critic approval if phase_critic enabled → missing/rejected → ok: false
+ *  10. All checks pass → ok: true
+ *
+ * Supports two calling conventions for backward compatibility:
+ * - New: verifyLeanTurboPhaseReady(dir, phase, sessionID?, config?)
+ * - Legacy: verifyLeanTurboPhaseReady(dir, phase, config?) — config was previously the 3rd param
+ *
+ * @param directory - Project root directory
+ * @param phase     - Phase number to verify readiness for
+ * @param sessionIDOrConfig - Optional session ID (string) OR config object (legacy 3rd-param style)
+ * @param config    - Optional config; defaults to { phase_reviewer: true, phase_critic: true, integrated_diff_required: true }
+ */
+export declare function verifyLeanTurboPhaseReady(directory: string, phase: number, sessionIDOrConfig?: string | LeanTurboPhaseReadyConfig, config?: LeanTurboPhaseReadyConfig): LeanTurboPhaseReadyResult;
+export {};

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

@@ -0,0 +1,115 @@
+/**
+ * Lane Planning Engine for Lean Turbo.
+ *
+ * Lean Turbo is a parallel execution strategy that dispatches up to N non-conflicting
+ * coder lanes concurrently. This module implements the lane planner that partitions
+ * phase tasks into parallel lanes based on file-scope conflicts.
+ *
+ * ## Lane Planning Algorithm
+ *
+ * The planner operates in several phases:
+ *
+ * 1. **Task Extraction**: Extract tasks for the specified phase, filtering out
+ *    already-completed tasks.
+ *
+ * 2. **Scope Resolution**: For each task, resolve its file scope:
+ *    - Use provided scopes map if available
+ *    - Otherwise, read from `.swarm/scopes/scope-{taskId}.json`
+ *    - Fall back to `files_touched` from plan.json if `require_declared_scope` is false
+ *    - If no scope available and `require_declared_scope` is true, serialize the task
+ *
+ * 3. **Conflict Detection**: Classify each task's files into:
+ *    - **Global files**: High-risk files that affect all coders (package.json, etc.)
+ *      → marked as degraded with reason "global file conflict"
+ *    - **Protected paths**: Paths containing security-sensitive patterns
+ *      → marked as degraded with reason "protected path" (if `degrade_on_risk` is true)
+ *      → serialized otherwise
+ *    - **Normal files**: Regular scoped files that need conflict checking
+ *
+ * 4. **Lane Assignment**:
+ *    - Sort tasks by dependency order (tasks with no deps first)
+ *    - For each non-conflicting task group, create a lane (up to `max_parallel_coders`)
+ *    - Tasks with conflicts are serialized or degraded based on `conflict_policy`
+ *
+ * 5. **Counter Population**: Track planned lanes, serialized tasks, and degraded tasks.
+ *
+ * ## 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.
+ */
+import type { LeanTurboConfig } from '../../config/schema';
+import type { LeanTurboCounters, LeanTurboDegradedTask, LeanTurboLane } from './state';
+export { GLOBAL_FILES_LIST, isGlobalFile, isPathSafe, isProtectedPath, normalizePath, PROTECTED_PATTERNS_LIST, pathsConflict, readTaskScopes, } from './conflicts';
+/**
+ * A single task within a plan phase.
+ * Matches the structure stored in .swarm/plan.json.
+ */
+export interface PlanTask {
+    id: string;
+    description: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'blocked';
+    depends?: string[];
+    files_touched?: string[];
+}
+/**
+ * A phase within a plan, containing multiple tasks.
+ */
+export interface PlanPhase {
+    id: number;
+    name: string;
+    tasks: PlanTask[];
+}
+/**
+ * The complete lane plan produced by `planLeanTurboLanes`.
+ * Describes how phase tasks are partitioned into parallel lanes.
+ */
+export interface LeanTurboLanePlan {
+    /** The phase number this plan covers */
+    phase: number;
+    /** Unique identifier for this lane plan (planId from run state) */
+    planId: string;
+    /** The computed parallel lanes */
+    lanes: LeanTurboLane[];
+    /** Tasks that were degraded (risk conditions detected) */
+    degradedTasks: LeanTurboDegradedTask[];
+    /** Tasks that were serialized (conflicts resolved by ordering) */
+    serializedTasks: string[];
+    /** Human-readable summary when all tasks are degraded */
+    degradationSummary?: string;
+    /** Execution counters for this planning run */
+    counters: LeanTurboCounters;
+    /** Map of taskId -> array of dependency taskIds that are in other lanes.
+     *  The runner must serialize execution of these tasks until the referenced
+     *  dependencies complete. */
+    crossLaneDependencies: Record<string, string[]>;
+}
+/**
+ * Partition phase tasks into parallel lanes based on file-scope conflicts.
+ *
+ * This is the main entry point for Lean Turbo lane planning. It:
+ * 1. Extracts tasks for the specified phase
+ * 2. Resolves file scopes for each task
+ * 3. Detects conflicts between tasks
+ * 4. Assigns non-conflicting tasks to parallel lanes
+ * 5. Serializes or degrades conflicting tasks based on config
+ *
+ * @param directory - Project root directory
+ * @param phaseNumber - Phase number to plan
+ * @param plan - The full plan object (from .swarm/plan.json)
+ * @param config - Lean Turbo configuration
+ * @param scopes - Optional pre-loaded scopes map (taskId -> file paths)
+ * @returns Complete lane plan with lanes, degraded tasks, and counters
+ */
+export declare function planLeanTurboLanes(directory: string, phaseNumber: number, plan: {
+    phases: PlanPhase[];
+}, config: LeanTurboConfig, scopes?: Record<string, string[]>): LeanTurboLanePlan;

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

@@ -0,0 +1,124 @@
+import { type LaneEvidence, listLaneEvidence, readPhaseEvidence } from './evidence';
+import { readPersisted } from './state';
+/**
+ * Configuration options for phase reviewer dispatch.
+ */
+export interface LeanTurboPhaseReviewerConfig {
+    /**
+     * Override the reviewer agent name.
+     * Default: derived from `generatedAgentNames` via `{swarmId}_reviewer` pattern
+     * when a swarm has multiple reviewers, or `reviewer` for the default swarm.
+     */
+    reviewerAgent?: string;
+    /**
+     * Timeout in milliseconds for the reviewer dispatch.
+     * Default: no timeout (reviewer is awaited indefinitely).
+     */
+    timeoutMs?: number;
+    /**
+     * Require a diff summary in the compiled review package.
+     * When true, the package must include an `integratedDiffSummary` field.
+     * Default: false.
+     */
+    requireDiffSummary?: boolean;
+}
+/**
+ * Result of a phase reviewer dispatch.
+ */
+export interface PhaseReviewerResult {
+    /** Reviewer verdict */
+    verdict: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED';
+    /** Human-readable reason for the verdict */
+    reason?: string;
+    /** Path to the persisted reviewer evidence file */
+    evidencePath: string;
+}
+/**
+ * Resolves the default reviewer agent name from the generated agent names.
+ *
+ * Uses the `{swarmId}_reviewer` pattern for named swarms and bare `reviewer`
+ * for the default swarm. Follows the same suffix-based resolution used by
+ * `getCanonicalAgentRole` so that arbitrary swarm prefixes are handled correctly.
+ */
+declare function resolveDefaultReviewerAgent(generatedAgentNames: string[]): string;
+/**
+ * Compiles a structured review package from lane and phase evidence.
+ */
+interface ReviewPackage {
+    phase: number;
+    sessionID: string;
+    laneSummaries: Array<{
+        laneId: string;
+        taskIds: string[];
+        files: string[];
+        status: LaneEvidence['status'];
+        agent?: string;
+    }>;
+    filesChanged: string[];
+    testResults: {
+        totalLanes: number;
+        completedLanes: number;
+        failedLanes: number;
+    };
+    buildStatus: 'unknown' | 'passed' | 'failed';
+    degradationSummary: {
+        totalDegraded: number;
+        resolvedDegraded: number;
+        pendingDegraded: number;
+    };
+    integratedDiffSummary?: string;
+}
+declare function compileReviewPackage(directory: string, phase: number, sessionID: string, requireDiffSummary: boolean): Promise<ReviewPackage>;
+/**
+ * Parses a reviewer verdict from the agent's text response.
+ *
+ * Looks for a verdict marker line: `VERDICT: APPROVED`, `VERDICT: NEEDS_REVISION`,
+ * or `VERDICT: REJECTED` (case-insensitive). Returns null if no marker is found.
+ *
+ * The optional reason is extracted from a `REASON:` marker line that follows
+ * the verdict marker on a subsequent line.
+ */
+declare function parseReviewerVerdict(responseText: string): {
+    verdict: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED';
+    reason?: string;
+} | null;
+/**
+ * Writes the reviewer verdict to the evidence file.
+ * Uses atomic write (temp file + rename) to prevent partial-file artifacts.
+ */
+declare function writeReviewerEvidence(directory: string, phase: number, verdict: 'APPROVED' | 'NEEDS_REVISION' | 'REJECTED', reason?: string): Promise<string>;
+/**
+ * Test-only dependency-injection seam.
+ * Allows tests to intercept reviewer dispatch without mock.module leakage.
+ */
+export declare const _internals: {
+    compileReviewPackage: typeof compileReviewPackage;
+    parseReviewerVerdict: typeof parseReviewerVerdict;
+    writeReviewerEvidence: typeof writeReviewerEvidence;
+    dispatchReviewerAgent: (directory: string, pkg: ReviewPackage, agentName: string, timeoutMs: number) => Promise<string>;
+    resolveDefaultReviewerAgent: typeof resolveDefaultReviewerAgent;
+    listLaneEvidence: typeof listLaneEvidence;
+    readPhaseEvidence: typeof readPhaseEvidence;
+    readPersisted: typeof readPersisted | null;
+};
+/**
+ * Dispatch a read-only reviewer agent to evaluate a completed Lean Turbo phase.
+ *
+ * Steps:
+ *  1. Read all lane evidence from `.swarm/evidence/{phase}/lean-turbo/`
+ *  2. Read phase evidence from `.swarm/evidence/{phase}/lean-turbo/lean-turbo-phase.json`
+ *  3. Compile a combined review package
+ *  4. Dispatch a read-only reviewer agent (tools: write=false, edit=false, patch=false)
+ *  5. Parse the verdict from the agent's response
+ *  6. Write the verdict to `.swarm/evidence/{phase}/lean-turbo-reviewer.json`
+ *  7. Return the result
+ *
+ * @param directory - Project root directory
+ * @param phase - Phase number being reviewed
+ * @param sessionID - Lean Turbo session ID
+ * @param config - Optional configuration overrides
+ * @returns PhaseReviewerResult with verdict, optional reason, and evidence path
+ * @throws Error if dispatch fails or response cannot be parsed (fail-closed)
+ */
+export declare function dispatchPhaseReviewer(directory: string, phase: number, sessionID: string, config?: LeanTurboPhaseReviewerConfig): Promise<PhaseReviewerResult>;
+export {};

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

@@ -0,0 +1,47 @@
+/**
+ * Risk Classification for Lean Turbo Tasks.
+ *
+ * This module provides risk assessment for tasks based on their file scopes,
+ * determining whether tasks can execute in parallel or must be serialized/degraded.
+ *
+ * ## Risk Categories
+ *
+ * - **normal**: Regular scoped files that can be parallelized
+ * - **global**: Tasks touching global files (affects all coders) → always degraded
+ * - **protected**: Tasks touching protected paths → degraded or serialized based on config
+ * - **no-scope**: Tasks without declared scope when `require_declared_scope` is true → serialized
+ * - **invalid-scope**: Tasks with invalid scope entries → serialized
+ */
+import type { LeanTurboConfig } from '../../config/schema';
+/**
+ * Risk category classification for a task.
+ */
+export type TaskRiskCategory = 'normal' | 'global' | 'protected' | 'no-scope' | 'invalid-scope';
+/**
+ * Result of risk assessment for a task.
+ */
+export interface TaskRiskAssessment {
+    /** The risk category */
+    category: TaskRiskCategory;
+    /** Human-readable reason for the classification (undefined for 'normal') */
+    reason?: string;
+    /** Files that contributed to the risk assessment */
+    files: string[];
+}
+/**
+ * Assess the risk category of a task based on its file scope.
+ *
+ * Classification priority (first match wins):
+ * 1. Global files → 'global' (always degraded)
+ * 2. Protected paths → 'protected' (degraded if degrade_on_risk, else serialized)
+ * 3. Invalid scope entries → 'invalid-scope' (serialized)
+ * 4. No declared scope (when required) → 'no-scope' (serialized)
+ * 5. Otherwise → 'normal'
+ *
+ * @param files - The task's file scope (already validated and normalized)
+ * @param hasDeclaredScope - Whether the task has an explicit declared scope
+ * @param hasInvalidScope - Whether the scope contains invalid/unsafe entries
+ * @param config - Lean Turbo configuration
+ * @returns Risk assessment with category, reason, and contributing files
+ */
+export declare function assessTaskRisk(files: string[], hasDeclaredScope: boolean, hasInvalidScope: boolean, config: LeanTurboConfig): TaskRiskAssessment;