opencode-swarm 7.131.0 → 7.132.0

package/dist/parallel/index.d.ts

@@ -1,5 +1,3 @@
 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';
 export { type ComplexityMetrics, computeComplexity, type ReviewDepth, type ReviewRouting, routeReview, routeReviewForChanges, shouldParallelizeReview, } from './review-router.js';

package/dist/plan/parallel-verdict.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Plan-time parallel-execution verdict helper (#1656 / #1674 v8 flagship).
+ *
+ * Pure, synchronous, side-effect-free pairwise conflict analysis for N proposed
+ * parallel task groups. Used by BOTH:
+ *   - the `plan_conflict_check` tool (architect-facing advisory — see
+ *     `src/tools/plan-conflict-check.ts`), and
+ *   - the delegation gate (`src/hooks/delegation-gate.ts`) which recomputes the
+ *     verdict INLINE at coder-dispatch time to enforce the v8 "serial fallback
+ *     when scopes overlap or are unknown" contract (acceptance criterion 4).
+ *
+ * Single source of truth: one helper, two call sites, so the architect's
+ * advisory and the gate's enforcement can never disagree on what "disjoint"
+ * means.
+ *
+ * Design notes:
+ *  - Sync by design: it reads only `.swarm/scopes/scope-<taskId>.json` via
+ *    the hardened persisted-scope reader (sync + fail-closed). The gate runs in
+ *    `toolBefore` on every tool call and must stay bounded; an async/gitten
+ *    helper would violate the bounded-gate spirit.
+ *  - The helper itself NEVER calls `getCoChangePairs` (async + `git log`).
+ *    Co-change signal is opt-in and supplied by the caller (the tool) via
+ *    `options.cochangePairs`. The gate never supplies it, keeping the
+ *    enforcement path git-free and fast.
+ *  - Fail-closed: a missing/malformed scope → `unknown_scope`, which conflicts
+ *    with everything, so `verdict` can never be `all_disjoint` while any task
+ *    lacks a declared scope. This is the v8 safety guarantee.
+ *  - Writes nothing. Honors issue #1656's "read-only (writes nothing)" tool
+ *    acceptance criterion.
+ */
+import type { CoChangeEntry } from '../tools/co-change-analyzer.js';
+import { type CoChangeThreshold } from '../turbo/epic/cochange-conflict.js';
+import { normalizePath, pathsConflict, readTaskScopes } from '../turbo/lean/conflicts.js';
+/**
+ * Per-pair conflict classification. Mirrors `EpicPairVerdict`'s signal
+ * decomposition but flattens `none` into `disjoint` for the plan-level view.
+ */
+export interface ParallelVerdictPair {
+    /** First task id (input order). */
+    a: string;
+    /** Second task id (input order). */
+    b: string;
+    /** `conflict` = path or co-change overlap; `disjoint` = provably no overlap; `unknown` = ≥1 task has no usable scope. */
+    verdict: 'conflict' | 'disjoint' | 'unknown';
+    /** Human-readable evidence lines (path pairs, co-change pairs). Empty for `disjoint`/`unknown`. */
+    evidence: string[];
+}
+/**
+ * Whole-plan verdict. The gate keys off `verdict === 'all_disjoint'` to allow
+ * parallel execution; anything else forces serial.
+ */
+export interface ParallelVerdict {
+    /** `all_disjoint` iff every pair is `disjoint` (no conflicts, no unknowns). */
+    verdict: 'all_disjoint' | 'conflicts_present' | 'unknown_scopes';
+    /** Pairwise results, one per input task pair (i < j). */
+    pairs: ParallelVerdictPair[];
+    /** Suggested serialization order (topological sort over the conflict graph). Input order preserved when no conflicts. */
+    suggestedSerialOrder: string[];
+    /** Task ids whose scope could not be resolved (missing/malformed). */
+    unknownScopeTasks: string[];
+}
+/** Default co-change threshold when the caller opts into co-change but omits one. */
+export declare const DEFAULT_PARALLEL_COCHANGE_THRESHOLD: CoChangeThreshold;
+/** Hard cap for the synchronous O(N²) verdict path (F-005). */
+export declare const MAX_PARALLEL_VERDICT_TASKS = 64;
+export interface ComputeParallelVerdictOptions {
+    /** When true AND `cochangePairs` is supplied, fold co-change signal into each pair. Off by default. */
+    useCochange?: boolean;
+    /** Caller-supplied co-change data (e.g. from `getCoChangePairs`). The helper never fetches it. */
+    cochangePairs?: CoChangeEntry[];
+    /** Override the co-change threshold. Defaults to `DEFAULT_PARALLEL_COCHANGE_THRESHOLD`. */
+    cochangeThreshold?: CoChangeThreshold;
+}
+/**
+ * Compute a pairwise conflict verdict for the given task ids.
+ *
+ * Pure + synchronous. Reads only `.swarm/scopes/`. Writes nothing. Fail-closed
+ * on any read/parse error (treats the task as `unknown`).
+ *
+ * @param directory  Project root (for `.swarm/scopes/` reads).
+ * @param taskIds    Task ids to analyze. Caller is responsible for min-length
+ *                   validation (the tool requires ≥2; the gate only calls this
+ *                   with ≥2 pending tasks).
+ * @param options    Optional co-change signal + threshold.
+ */
+export declare function computeParallelVerdict(directory: string, taskIds: string[], options?: ComputeParallelVerdictOptions): ParallelVerdict;
+/**
+ * Quick pairwise check used by the gate: are these task ids provably disjoint?
+ *
+ * Equivalent to `computeParallelVerdict(...).verdict === 'all_disjoint'` but
+ * exposed as a named predicate so the gate reads as intent.
+ */
+export declare function isProvablyDisjoint(directory: string, taskIds: string[]): boolean;
+export { normalizePath, pathsConflict, readTaskScopes };

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

@@ -40,6 +40,20 @@ export interface StatusData {
     leanDegradedTasks?: number;
     /** Human-readable degradation summary */
     leanDegradationSummary?: string;
+    /**
+     * #1657: merge-back conflict recovery worktrees preserved for manual
+     * recovery (durable records under `.swarm/recovery/`). Surfaced so the
+     * architect/operator can see pending recovery work in `/swarm status`
+     * rather than having to re-read a prior tool result. `undefined`/empty when
+     * no lanes are preserved.
+     */
+    leanPreservedRecoveryWorktrees?: Array<{
+        laneId: string;
+        status: string;
+        worktreePath: string;
+        reason: string;
+        replayHint: string;
+    }>;
     /** Whether Full-Auto mode is currently active */
     fullAutoActive?: boolean;
     /**

package/dist/tools/index.d.ts

@@ -49,6 +49,7 @@ export { parse_lane_candidates } from './parse-lane-candidates';
 export { phase_complete } from './phase-complete';
 export { pkg_audit } from './pkg-audit';
 export { type PlaceholderFinding, type PlaceholderScanInput, type PlaceholderScanResult, placeholder_scan, placeholderScan, } from './placeholder-scan';
+export { plan_conflict_check } from './plan-conflict-check';
 export { pr_workflow_status } from './pr-workflow-status';
 export { type PreCheckBatchInput, type PreCheckBatchResult, pre_check_batch, runPreCheckBatch, type ToolResult, } from './pre-check-batch';
 export { executePreparePrFeedbackScope, prepare_pr_feedback_scope, } from './prepare-pr-feedback-scope';

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

@@ -6,6 +6,7 @@ import type { ToolDefinition } from '@opencode-ai/plugin/tool';
 import { loadPluginConfigWithMeta as loadPluginConfigWithMeta_import } from '../config';
 import type { LaneResult, MergeBackFailureInfo } from '../turbo/lean/runner';
 import { LeanTurboRunner as LeanTurboRunner_import } from '../turbo/lean/runner';
+import type { LeanTurboDegradedTask } from '../turbo/lean/state';
 /**
  * Arguments for the lean_turbo_run_phase tool
  */
@@ -21,6 +22,12 @@ export interface LeanTurboRunPhaseResult {
     success: boolean;
     lanes?: LaneResult[];
     degradedTasks?: string[];
+    /**
+     * #1657: full degraded-task details (reason/files/requiredMode), additive
+     * alongside `degradedTasks`. Lets the architect see per-task degradation
+     * reasons in the tool result without reading /swarm status separately.
+     */
+    degradedDetails?: LeanTurboDegradedTask[];
     serializedTasks?: string[];
     mergeBackFailures?: MergeBackFailureInfo[];
     reason?: string;

package/dist/tools/manifest.d.ts

@@ -53,6 +53,7 @@ export declare const TOOL_MANIFEST: {
     checkpoint: () => ToolDefinition;
     pkg_audit: () => ToolDefinition;
     parse_lane_candidates: () => ToolDefinition;
+    plan_conflict_check: () => ToolDefinition;
     prepare_pr_feedback_scope: () => ToolDefinition;
     write_pr_review_artifact: () => ToolDefinition;
     write_pr_review_trigger_eval: () => ToolDefinition;

package/dist/tools/plan-conflict-check.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `plan_conflict_check` tool (#1656 — v8 parallel-first execution prerequisite).
+ *
+ * Read-only advisory: compute a pairwise file-conflict matrix for N proposed
+ * parallel task groups using declared scopes (and optional git co-change),
+ * returning a verdict and suggested serialization order.
+ *
+ * READ-ONLY CONTRACT (issue #1656 acceptance): this tool writes NOTHING — not
+ * to `.swarm/`, not to the source tree. It calls no other tools. The only I/O
+ * is reading `.swarm/plan.json` (via `loadPlanJsonOnly`) and
+ * `.swarm/scopes/scope-<taskId>.json` (via `readTaskScopes` inside
+ * `computeParallelVerdict`), plus an optional `git log` (only when the caller
+ * opts in via `use_cochange: true`).
+ *
+ * Why this tool exists alongside the gate: the gate (`delegation-gate.ts`)
+ * independently recomputes the verdict INLINE at coder-dispatch time via the
+ * same shared `computeParallelVerdict` helper. The tool gives the architect a
+ * way to inspect the conflict matrix BEFORE attempting parallel dispatch, so it
+ * can choose disjoint task groups and understand why the gate will (or won't)
+ * permit parallelism. Single source of truth (the helper), two call sites.
+ */
+import type { tool } from '@opencode-ai/plugin';
+import { z } from 'zod';
+export declare const plan_conflict_check_args: {
+    task_ids: z.ZodArray<z.ZodString>;
+    use_cochange: z.ZodOptional<z.ZodBoolean>;
+    phase_id: z.ZodOptional<z.ZodString>;
+};
+export interface PlanConflictCheckResult {
+    /** Summary verdict. `all_disjoint` ⇒ safe to parallelize. */
+    verdict: 'all_disjoint' | 'conflicts_present' | 'unknown_scopes';
+    /** Pairwise results. */
+    pairs: Array<{
+        a: string;
+        b: string;
+        verdict: 'conflict' | 'disjoint' | 'unknown';
+        evidence: string[];
+    }>;
+    /** Suggested serialization order (topological sort over the conflict graph). */
+    suggested_serial_order: string[];
+    /** Tasks whose declared scope could not be resolved. */
+    unknown_scope_tasks: string[];
+    /** Whether co-change signal was used. */
+    used_cochange: boolean;
+    /** Diagnostic: did plan.json load successfully? */
+    plan_loaded: boolean;
+    /** Task ids requested by the caller but absent from the loaded plan. */
+    unknown_to_plan?: string[];
+}
+/**
+ * Pure executor (no createSwarmTool wrapper) so it is directly unit-testable.
+ *
+ * Reads `.swarm/plan.json` (to confirm the task ids exist) and
+ * `.swarm/scopes/scope-*.json` (via `computeParallelVerdict`). Writes nothing.
+ */
+export declare function executePlanConflictCheck(args: {
+    task_ids: string[];
+    use_cochange?: boolean;
+    phase_id?: string;
+}, directory: string): Promise<PlanConflictCheckResult>;
+export declare const plan_conflict_check: ReturnType<typeof tool>;

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

@@ -196,6 +196,10 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: "architect"[];
     };
+    plan_conflict_check: {
+        description: string;
+        agents: "architect"[];
+    };
     write_pr_review_trigger_eval: {
         description: string;
         agents: "architect"[];

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

@@ -0,0 +1,90 @@
+/**
+ * Durable merge-back conflict recovery records (#1657).
+ *
+ * When a lean-turbo lane's merge-back fails (conflict / partial / error), the
+ * runner preserves the lane's worktree + branch for manual recovery but —
+ * before this module — that information lived only in:
+ *   - the in-memory `LeanTurboLane` state (lost when the session ends), and
+ *   - a scrolled-away log line.
+ *
+ * Problem #1: `cleanupOrphanedBranches` (`src/worktree/merge.ts`) force-deletes
+ * any lane branch whose session isn't active, including a branch just preserved
+ * for recovery. The only copy of unmerged lane work could be deleted by routine
+ * init-time cleanup before a human ever sees the recovery message.
+ *
+ * Problem #2: `/swarm status` had no concept of preserved worktrees, so the
+ * architect was blind to pending recovery work unless it re-read the tool
+ * result inline.
+ *
+ * This module writes a durable record under `.swarm/recovery/` on every
+ * merge-back failure, lets `cleanupOrphanedBranches` EXEMPT recovery branches
+ * (fail-safe on read error), and lets `/swarm status` surface them. Records are
+ * auto-cleared when the lane later merges back successfully (no accumulation).
+ *
+ * Records live ONLY under `.swarm/recovery/` (AGENTS.md invariant 4 — `.swarm/`
+ * containment). They are intentionally NOT part of the plan ledger or
+ * turbo-state: recovery is a side-channel safety net, not authoritative plan
+ * or run state.
+ */
+/**
+ * A durable merge-back recovery record. Mirrors `MergeBackFailureInfo` plus
+ * the session/bookkeeping fields needed for orphan-cleanup exemption and
+ * status surfacing.
+ */
+export interface RecoveryRecord {
+    /** Lane identifier (e.g. "lane-1"). */
+    laneId: string;
+    /** Session that created the record (for scoping/status). */
+    sessionId: string;
+    /** Lane branch preserved for recovery (e.g. "swarm-lane/<sid>/<laneId>"). */
+    branchName?: string;
+    /** Lane worktree filesystem path preserved for recovery. */
+    worktreePath: string;
+    /** Merge-back failure class. */
+    status: 'failed' | 'partial' | 'conflict';
+    /** Human-readable reason for the merge-back failure. */
+    reason: string;
+    /** Conflict files (when status === 'conflict'). */
+    conflictFiles?: string[];
+    /** Epoch ms when the record was written. */
+    recordedAt: number;
+    /** Portable human guidance for inspecting the preserved worktree. */
+    replayHint: string;
+}
+/**
+ * Write a recovery record atomically (temp file + rename, mirroring the
+ * `turbo-state.json` pattern in `src/turbo/lean/state.ts`). Best-effort:
+ * swallows errors so a recovery-write failure can never break the merge-back
+ * path that called it.
+ */
+export declare function writeRecoveryRecord(directory: string, record: Omit<RecoveryRecord, 'recordedAt'> & {
+    recordedAt?: number;
+}): void;
+/**
+ * List all recovery records under `.swarm/recovery/`. Tolerates malformed
+ * files (skips + continues). Returns `[]` if the directory is absent or
+ * unreadable.
+ */
+export declare function listRecoveryRecords(directory: string): RecoveryRecord[];
+/**
+ * Fast check: does any recovery record reference the given branch name?
+ * Used by `cleanupOrphanedBranches` to exempt recovery branches. Returns
+ * `false` on any read error (the caller decides fail-open vs fail-safe —
+ * see `cleanupOrphanedBranches`).
+ */
+export declare function hasRecoveryRecordForBranch(directory: string, branchName: string): boolean;
+/**
+ * Remove the recovery record for a specific lane + session. Called on
+ * SUCCESSFUL merge-back so records don't accumulate (a record exists only
+ * while a lane is in a failed/preserved state). Best-effort.
+ */
+export declare function clearRecoveryRecord(directory: string, laneId: string, sessionId: string): void;
+/**
+ * Did the recovery-directory read itself throw (vs simply being empty)?
+ * `cleanupOrphanedBranches` uses this to decide fail-safe behavior: on a
+ * genuine read error it skips ALL lane-branch deletions for that pass
+ * (recovery safety trumps orphan cleanliness). Returns `true` if the
+ * directory exists but could not be read, OR if any record file exists but
+ * is unreadable.
+ */
+export declare function recoveryReadErrored(directory: string): boolean;

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

@@ -25,7 +25,7 @@ import { type ModelOverride } from '../../utils/model-dispatch-fallback';
 import { writeLaneEvidence, writePhaseEvidence } from './evidence';
 import { attemptMergeBackFromDirty, getMergeStrategy, mergeLaneBranch, postMergeCleanup, startupOrphanRecovery } from './merge-back';
 import { planLeanTurboLanes } from './planner';
-import type { LeanTurboLane } from './state';
+import type { LeanTurboDegradedTask, LeanTurboLane } from './state';
 import { loadLeanTurboRunState, saveLeanTurboRunState } from './state';
 import { assertCleanWorkingTree, provisionWorktree, removeLaneProfileFromDiskReal, removeWorktree } from './worktree';
 /**
@@ -152,6 +152,12 @@ export interface LeanTurboPhaseResult {
     lanes: LaneResult[];
     /** Task IDs that were degraded (risk conditions) */
     degradedTasks: string[];
+    /**
+     * #1657: full degraded-task details (reason/files/requiredMode) so the
+     * architect sees per-task degradation reasons in the tool result, not
+     * just task IDs. Additive alongside `degradedTasks` (kept for back-compat).
+     */
+    degradedDetails?: LeanTurboDegradedTask[];
     /**
      * Task IDs excluded from parallel lanes due to lock conflicts.
      * Caller must complete these via standard serial flow before phase can advance.
@@ -323,6 +329,15 @@ export declare class LeanTurboRunner {
      * the serialized tasks set for standard serial fallback.
      */
     private _processLane;
+    /**
+     * Persist a durable recovery record for a merge-back / dispatch failure (#1657).
+     *
+     * Wraps `writeRecoveryRecord` (best-effort, non-fatal) with this session's
+     * id and portable human recovery guidance. Called from every failure branch of
+     * `_sequentialWorktreeCleanup`. Records are auto-cleared on successful
+     * merge-back so they exist only while a lane is preserved.
+     */
+    private _persistRecovery;
     /**
      * Sequential worktree cleanup for completed and failed worktree lanes.
      *

package/dist/worktree/merge.d.ts

@@ -86,6 +86,11 @@ export interface OrphanCleanupResult {
         branch: string;
         error: string;
     }>;
+    /** #1657: lane branches skipped because a recovery record references them. */
+    skippedRecoveryBranches: string[];
+    /** #1657: set when the recovery-directory read errored and ALL lane-branch
+     * deletions were skipped this pass (fail-safe). */
+    recoveryReadError?: boolean;
 }
 export interface StartupRecoveryResult {
     prunedWorktrees: boolean;

package/package.json

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

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

@@ -1,34 +0,0 @@
-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/meta-indexer.d.ts

@@ -1,32 +0,0 @@
-export interface MetaSummaryEntry {
-    timestamp: string;
-    phase?: number;
-    taskId?: string;
-    agent?: string;
-    summary: string;
-    source?: string;
-}
-/**
- * Extract meta.summary from event JSONL files
- */
-export declare function extractMetaSummaries(eventsPath: string): MetaSummaryEntry[];
-/**
- * Index meta summaries to external knowledge store
- */
-export declare function indexMetaSummaries(directory: string, externalKnowledgeDir?: string): Promise<{
-    indexed: number;
-    path: string;
-}>;
-/**
- * Query indexed summaries
- */
-export declare function querySummaries(directory: string, options?: {
-    phase?: number;
-    taskId?: string;
-    agent?: string;
-    since?: string;
-}): MetaSummaryEntry[];
-/**
- * Get latest summary for a task
- */
-export declare function getLatestTaskSummary(directory: string, taskId: string): MetaSummaryEntry | undefined;