opencode-swarm 7.58.1 → 7.59.1

package/dist/memory/schema.d.ts

@@ -129,10 +129,10 @@ export declare const MemoryProposalSchema: z.ZodObject<{
     id: z.ZodString;
     operation: z.ZodEnum<{
         ignore: "ignore";
+        merge: "merge";
         add: "add";
         delete: "delete";
         update: "update";
-        merge: "merge";
         supersede: "supersede";
     }>;
     proposedRecord: z.ZodOptional<z.ZodObject<{

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

@@ -4,7 +4,7 @@
  */
 import type { ToolDefinition } from '@opencode-ai/plugin/tool';
 import { loadPluginConfigWithMeta as loadPluginConfigWithMeta_import } from '../config';
-import type { LaneResult } from '../turbo/lean/runner';
+import type { LaneResult, MergeBackFailureInfo } from '../turbo/lean/runner';
 import { LeanTurboRunner as LeanTurboRunner_import } from '../turbo/lean/runner';
 /**
  * Arguments for the lean_turbo_run_phase tool
@@ -22,6 +22,7 @@ export interface LeanTurboRunPhaseResult {
     lanes?: LaneResult[];
     degradedTasks?: string[];
     serializedTasks?: string[];
+    mergeBackFailures?: MergeBackFailureInfo[];
     reason?: string;
     errors?: string[];
 }

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

@@ -8,7 +8,7 @@
  * import { LeanTurboRunner, planLeanTurboLanes, LeanTurboLane, ... } from './turbo/lean';
  * ```
  */
-export type { LaneDispatchResult, LaneResult, LaneStatus, LeanTurboPhaseResult, } from './runner';
+export type { LaneDispatchResult, LaneResult, LaneStatus, LeanTurboPhaseResult, MergeBackFailureInfo, } 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';
@@ -25,3 +25,6 @@ export type { LeanTurboPhaseCriticConfig, PhaseCriticResult, } from './integrati
 export { dispatchPhaseCritic } from './integration';
 export type { LeanTurboPhaseReviewerConfig, PhaseReviewerResult, } from './reviewer';
 export { dispatchPhaseReviewer } from './reviewer';
+export { _internals as worktreeInternals, assertCleanWorkingTree, autoCommitDirty, cleanUntrackedFiles, isCleanWorktree, provisionWorktree, removeWorktree, } from './worktree';
+export type { CleanupFailure, CleanupSuccess, ConflictHandlingError, ConflictInfo, DirtyMergeFailure, DirtyMergePartial, DirtyMergeSuccess, MergeConflict, MergeFailure, MergeSuccess, OrphanCleanupResult, StartupRecoveryResult, } from './merge-back';
+export { _internals as mergeBackInternals, attemptMergeBackFromDirty, cleanupOrphanedBranches, getMergeStrategy, handleMergeConflict, mergeLaneBranch, postMergeCleanup, startupOrphanRecovery, } from './merge-back';

package/dist/turbo/lean/merge-back.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Merge-back operations for lean turbo parallel lanes.
+ *
+ * Provides four public functions for merging lane branches back into
+ * the primary worktree, cleaning up lane branches, and handling merge
+ * conflicts. All subprocess calls go through the `_internals` DI seam
+ * so tests can replace the real `bunSpawn` without leaking across Bun's
+ * shared test-runner process.
+ *
+ * @module merge-back
+ */
+import type { LeanTurboConfig } from '../../config/schema';
+import { bunSpawn } from '../../utils/bun-compat';
+/**
+ * Test-only dependency-injection seam. Production code calls
+ * `_internals.bunSpawn(...)` so tests can replace the function on this object
+ * without touching the real `../../utils/bun-compat` module — `mock.module`
+ * from `bun:test` leaks across files in Bun's shared test-runner process,
+ * which would corrupt unrelated suites that import `bun-compat`. Mutating this
+ * local object is file-scoped and trivially restorable via `afterEach`.
+ */
+export declare const _internals: {
+    bunSpawn: typeof bunSpawn;
+    /** Test seam for process.platform — allows non-Windows CIs to exercise Windows paths. */
+    platform: string;
+    /** Test seam for sleep — allows tests to skip real delays. */
+    sleep: (ms: number) => Promise<void>;
+};
+export interface MergeSuccess {
+    merged: true;
+    strategy: string;
+}
+export interface MergeConflict {
+    conflict: true;
+    files: string[];
+    message: string;
+}
+export interface MergeFailure {
+    error: string;
+}
+export interface CleanupSuccess {
+    cleaned: true;
+}
+export interface CleanupFailure {
+    error: string;
+    partial?: boolean;
+}
+export interface ConflictInfo {
+    files: string[];
+    message: string;
+    aborted: true;
+}
+export interface ConflictHandlingError {
+    error: string;
+    aborted: boolean;
+}
+export interface DirtyMergeSuccess {
+    merged: true;
+    strategy: string;
+    autoCommitted: boolean;
+    cleaned: boolean;
+}
+export interface DirtyMergePartial {
+    partial: true;
+    stage: string;
+    autoCommitted: boolean;
+    cleaned: boolean;
+    message: string;
+}
+export interface DirtyMergeFailure {
+    failed: true;
+    stage: string;
+    message: string;
+}
+export interface OrphanCleanupResult {
+    removed: string[];
+    skipped: string[];
+    errors: Array<{
+        branch: string;
+        error: string;
+    }>;
+}
+export interface StartupRecoveryResult {
+    prunedWorktrees: boolean;
+    remainingBranches: string[];
+    warnings: string[];
+}
+/**
+ * Reads the merge strategy from the lean turbo configuration.
+ *
+ * Returns `config.merge_strategy` if set, otherwise defaults to `'merge'`.
+ * This is a pure function — no subprocess calls.
+ *
+ * @param config - Lean turbo configuration.
+ * @returns The merge strategy to use: `'merge'`, `'rebase'`, or `'cherry-pick'`.
+ */
+export declare function getMergeStrategy(config: LeanTurboConfig): 'merge' | 'rebase' | 'cherry-pick';
+/**
+ * Merges a lane branch back into the primary worktree using the specified
+ * strategy.
+ *
+ * On conflict, automatically aborts the in-progress merge/rebase/cherry-pick
+ * to restore the working tree to a clean state, then returns conflict details.
+ *
+ * @param primaryDir - The main project root (cwd for all git commands).
+ * @param branchName - The lane branch name (e.g. `swarm-lane/<sessionId>/<laneId>`).
+ * @param strategy   - Merge strategy to use.
+ * @returns Discriminated union: success, conflict, or failure.
+ */
+export declare function mergeLaneBranch(primaryDir: string, branchName: string, strategy: 'merge' | 'rebase' | 'cherry-pick'): Promise<MergeSuccess | MergeConflict | MergeFailure>;
+/**
+ * Cleans up a lane branch after a successful merge.
+ *
+ * Deletes the lane branch and prunes stale worktree metadata (DD-9).
+ * Reports partial success if branch deletion fails but worktree prune succeeds.
+ *
+ * @param directory  - The project root (cwd for git commands).
+ * @param branchName - The lane branch name to delete.
+ * @returns Discriminated union: success, partial failure, or full failure.
+ */
+export declare function postMergeCleanup(directory: string, branchName: string): Promise<CleanupSuccess | CleanupFailure>;
+/**
+ * Handles a merge conflict by listing conflicted files and aborting the
+ * in-progress operation to restore the working tree to a clean state.
+ *
+ * Uses a strategy-specific abort command so the correct git sub-command
+ * is invoked (`merge --abort`, `rebase --abort`, or `cherry-pick --abort`).
+ * Using the wrong abort command would leave the repository in a dirty state.
+ *
+ * @param primaryDir - The main project root (cwd for all git commands).
+ * @param branchName - The lane branch name that caused the conflict.
+ *   Retained for logging and future conflict-reporting use.
+ * @param strategy - The merge strategy that is currently in progress.
+ * @returns Discriminated union: conflict info or handling error.
+ */
+export declare function handleMergeConflict(primaryDir: string, _branchName: string, strategy: 'merge' | 'rebase' | 'cherry-pick'): Promise<ConflictInfo | ConflictHandlingError>;
+/**
+ * Attempts to merge a lane branch back from a potentially dirty worktree
+ * using progressive cleanup (DD-7).
+ *
+ * Pipeline:
+ * 1. Auto-commit dirty state in the worktree
+ * 2. Clean untracked files
+ * 3. Attempt the merge-back
+ *
+ * Each step is fault-tolerant: failures log a warning and continue.
+ * Only when both auto-commit AND clean fail (not just skip) does the
+ * pipeline abandon early with `{ failed: true, stage: 'cleanup' }`.
+ *
+ * @param worktreePath - Absolute path to the lane worktree directory.
+ * @param branchName   - The lane branch name (e.g. `swarm-lane/<sessionId>/<laneId>`).
+ * @param primaryDir   - The main project root (cwd for merge commands).
+ * @param strategy     - Merge strategy to use.
+ * @returns Discriminated union: success, partial, or failure.
+ */
+export declare function attemptMergeBackFromDirty(worktreePath: string, branchName: string, primaryDir: string, strategy: 'merge' | 'rebase' | 'cherry-pick'): Promise<DirtyMergeSuccess | DirtyMergePartial | DirtyMergeFailure>;
+/**
+ * Cleans up orphaned swarm-lane branches that do not belong to any active session.
+ *
+ * Lists all branches matching `swarm-lane/*`, identifies orphans (branches whose
+ * session ID is not in `activeSessionIds`), force-deletes them, and prunes stale
+ * worktree metadata.
+ *
+ * @param directory        - The project root (cwd for all git commands).
+ * @param activeSessionIds - Session IDs that are still active; their branches are skipped.
+ * @returns Result with arrays of removed, skipped, and errored branch names.
+ */
+export declare function cleanupOrphanedBranches(directory: string, activeSessionIds?: string[]): Promise<OrphanCleanupResult>;
+/**
+ * Performs startup orphan recovery: prunes stale worktrees, then identifies
+ * any remaining orphaned swarm-lane branches for warning.
+ *
+ * This is designed to run at session startup (DD-3). It does NOT delete branches —
+ * it reports them as warnings so the caller can decide on further action.
+ *
+ * @param directory        - The project root (cwd for all git commands).
+ * @param activeSessionIds - Session IDs that are still active; their branches are expected.
+ * @returns Result indicating whether pruning happened, orphaned branches, and warnings.
+ */
+export declare function startupOrphanRecovery(directory: string, activeSessionIds?: string[]): Promise<StartupRecoveryResult>;

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

@@ -22,9 +22,11 @@ import { acquireLaneLocks, releaseLaneLocks } from '../../parallel/file-locks';
 import { loadPlanJsonOnly } from '../../plan/manager';
 import { hasActiveFullAuto } from '../../state';
 import { writeLaneEvidence } from './evidence';
+import { attemptMergeBackFromDirty, getMergeStrategy, mergeLaneBranch, postMergeCleanup, startupOrphanRecovery } from './merge-back';
 import { planLeanTurboLanes } from './planner';
 import type { LeanTurboLane } from './state';
 import { loadLeanTurboRunState, saveLeanTurboRunState } from './state';
+import { assertCleanWorkingTree, provisionWorktree, removeWorktree } from './worktree';
 /**
  * Shape of the OpencodeClient session API used by the runner.
  * Extracted into an interface so tests can inject a mock without
@@ -83,6 +85,17 @@ export interface LaneDispatchResult {
     /** Error message if ok === false */
     error?: string;
 }
+/**
+ * Describes a merge-back failure for a completed lane.
+ */
+export interface MergeBackFailureInfo {
+    /** Lane identifier */
+    laneId: string;
+    /** Human-readable reason for the merge-back failure */
+    reason: string;
+    /** Conflict files if the failure was a merge conflict */
+    conflictFiles?: string[];
+}
 /**
  * Result of a single lane's processing.
  */
@@ -99,6 +112,8 @@ export interface LaneResult {
     sessionId?: string;
     /** Error message if status is 'failed' or 'blocked' */
     error?: string;
+    /** Merge-back failure info if the coder completed but integration back to primary failed */
+    mergeBackFailure?: MergeBackFailureInfo;
 }
 /**
  * Result of a full phase run.
@@ -114,6 +129,8 @@ export interface LeanTurboPhaseResult {
     degradedTasks: string[];
     /** Task IDs excluded from parallel lanes, must complete via standard serial flow */
     serializedTasks: string[];
+    /** Lanes whose coder completed but merge-back to primary branch failed */
+    mergeBackFailures?: MergeBackFailureInfo[];
 }
 /**
  * Orchestrates Lean Turbo lane execution.
@@ -151,6 +168,14 @@ export declare class LeanTurboRunner {
         writeLaneEvidence: typeof writeLaneEvidence;
         /** Timeout for lane dispatch (session.create + session.prompt) in ms. Undefined = no timeout. */
         laneDispatchTimeoutMs: number | undefined;
+        provisionWorktree: typeof provisionWorktree;
+        removeWorktree: typeof removeWorktree;
+        mergeLaneBranch: typeof mergeLaneBranch;
+        postMergeCleanup: typeof postMergeCleanup;
+        attemptMergeBackFromDirty: typeof attemptMergeBackFromDirty;
+        startupOrphanRecovery: typeof startupOrphanRecovery;
+        getMergeStrategy: typeof getMergeStrategy;
+        assertCleanWorkingTree: typeof assertCleanWorkingTree;
     };
     /**
      * Test-only dependency-injection seam for session operations.
@@ -218,7 +243,7 @@ export declare class LeanTurboRunner {
      * @param lane - Lane to dispatch
      * @param agentName - Agent name to dispatch to
      */
-    dispatchLane(lane: LeanTurboLane, agentName: string): Promise<LaneDispatchResult>;
+    dispatchLane(lane: LeanTurboLane, agentName: string, worktreeDirectory?: string): Promise<LaneDispatchResult>;
     /**
      * Internal dispatch implementation (separated for timeout wrapping).
      */
@@ -277,6 +302,20 @@ export declare class LeanTurboRunner {
      * the serialized tasks set for standard serial fallback.
      */
     private _processLane;
+    /**
+     * Sequential worktree cleanup for completed and failed worktree lanes.
+     *
+     * Runs AFTER all lanes have been dispatched and completed via Promise.all.
+     * Each worktree lane is processed one at a time, preventing concurrent
+     * git merge/rebase/cherry-pick from corrupting the shared .git index.
+     *
+     * - **Success lanes**: mergeLaneBranch → removeWorktree → postMergeCleanup
+     * - **Success lanes with merge failure**: log warning, keep worktree, update lane result
+     * - **Failed lanes**: attemptMergeBackFromDirty → removeWorktree
+     *
+     * @returns Array of MergeBackFailureInfo for lanes where merge-back failed
+     */
+    private _sequentialWorktreeCleanup;
     /**
      * Select the next available agent using round-robin.
      */
@@ -302,6 +341,13 @@ export declare class LeanTurboRunner {
      * Update durable state with the full lane plan (called once per phase).
      */
     private _updateDurableState;
+    /**
+     * Persist a lane's worktreePath and branchName to durable state.
+     *
+     * Called after provisioning so that after a crash/restart these fields
+     * are recoverable from turbo-state.json.
+     */
+    private _persistLaneWorktreeFields;
     /**
      * Update a single lane's status in durable state.
      * Serialized through _withStateLock to prevent race conditions with concurrent lanes.

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

@@ -9,6 +9,16 @@ export interface LeanTurboLane {
     error?: string;
     agent?: string;
     sessionId?: string;
+    /** Worktree path for isolated lane execution (undefined when worktree_isolation is disabled) */
+    worktreePath?: string;
+    /** Branch name for the lane's worktree (swarm-lane/<sessionId>/<laneId>) */
+    branchName?: string;
+    /**
+     * In-memory-only flag: set when dispatch fails with a provisioned worktree.
+     * Signals that _sequentialWorktreeCleanup should run attemptMergeBackFromDirty
+     * + removeWorktree for this lane. Never persisted to disk.
+     */
+    _failureCleanupPending?: boolean;
 }
 export interface LeanTurboDegradedTask {
     taskId: string;

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

@@ -0,0 +1,194 @@
+/**
+ * Git worktree lifecycle operations for lean turbo parallel lanes.
+ *
+ * Provides five public functions for creating, removing, inspecting, and
+ * cleaning git worktrees used by parallel coder lanes. All subprocess
+ * calls go through the `_internals` DI seam so tests can replace the
+ * real `bunSpawn` without leaking across Bun's shared test-runner process.
+ *
+ * @module worktree
+ */
+import type { LeanTurboConfig } from '../../config/schema';
+import { bunSpawn } from '../../utils/bun-compat';
+/**
+ * Test-only dependency-injection seam. Production code calls
+ * `_internals.bunSpawn(...)` so tests can replace the function on this object
+ * without touching the real `../../utils/bun-compat` module — `mock.module`
+ * from `bun:test` leaks across files in Bun's shared test-runner process,
+ * which would corrupt unrelated suites that import `bun-compat`. Mutating this
+ * local object is file-scoped and trivially restorable via `afterEach`.
+ */
+export declare const _internals: {
+    bunSpawn: typeof bunSpawn;
+    /** Test seam for process.platform — allows non-Windows CIs to exercise Windows paths. */
+    platform: string;
+    /** Test seam for sleep — allows tests to skip real delays. */
+    sleep: (ms: number) => Promise<void>;
+    /** Test seam for os.tmpdir() — allows tests to control temp path. */
+    osTmpdir: () => string;
+    /**
+     * Test seam for querying `git config core.longpaths`.
+     * Returns `'true'` | `'false'` | `undefined` (not set or query failed).
+     * Production implementation runs `git config core.longpaths` via runGit.
+     */
+    getCoreLongPaths: (directory: string) => Promise<string | undefined>;
+};
+interface PathBudgetOk {
+    ok: true;
+}
+interface PathBudgetExceeded {
+    ok: false;
+    error: string;
+    suggestion: string;
+}
+/**
+ * Checks whether the total path length for files inside a worktree would
+ * exceed the Windows MAX_PATH budget (260 chars).
+ *
+ * On non-Windows platforms this is a no-op and always returns `{ ok: true }`.
+ *
+ * If `core.longpaths` is enabled in the git config (`true`), the MAX_PATH
+ * limit does not apply (Git 2.35+) and the budget check is skipped entirely.
+ * If the config query fails or returns anything other than `true`, the
+ * existing budget check proceeds (fail-safe).
+ *
+ * The check runs `git ls-files` via `_internals.bunSpawn` to discover the
+ * longest relative file path in the project, then computes
+ * `worktreeRoot.length + 1 + longestRelativePath.length`. If this total is
+ * >= 250 (a safety margin under 260), the budget is exceeded.
+ *
+ * @param worktreeRoot - Absolute path to the worktree root directory.
+ * @param directory    - Project root (used as `cwd` for `git ls-files`).
+ */
+export declare function checkPathBudget(worktreeRoot: string, directory: string): Promise<PathBudgetOk | PathBudgetExceeded>;
+/**
+ * Returns a shortened worktree path under the system temp directory.
+ *
+ * On non-Windows platforms this is not typically needed but still returns
+ * a deterministic path. The returned path is
+ * `<os.tmpdir()>/swwt/<sessionId>/<laneId>`.
+ *
+ * @param directory  - Project root (unused but kept for API symmetry).
+ * @param sessionId  - Lean turbo session identifier.
+ * @param laneId     - Lane identifier.
+ */
+export declare function shortenWorktreePath(_directory: string, sessionId: string, laneId: string): string;
+interface ProvisionSuccess {
+    worktreePath: string;
+    branchName: string;
+}
+interface ProvisionFailure {
+    error: string;
+}
+interface RemoveSuccess {
+    success: true;
+}
+interface RemoveFailure {
+    error: string;
+}
+interface AutoCommitSuccess {
+    committed: true;
+    message: string;
+}
+interface AutoCommitSkip {
+    committed: false;
+    reason: string;
+}
+interface CleanSuccess {
+    cleaned: true;
+}
+interface CleanFailure {
+    cleaned: false;
+    error: string;
+}
+interface CleanCheckSuccess {
+    clean: true;
+}
+interface CleanCheckFailure {
+    clean: false;
+    error: string;
+}
+/**
+ * Creates a new git worktree for a lean turbo lane.
+ *
+ * Branch naming follows DD-3: `swarm-lane/<sessionId>/<laneId>`.
+ * Worktree path follows DD-6: uses `config.worktree_dir` when set,
+ * otherwise defaults to `<project-parent>/.swarm-worktrees/<sessionId>/<laneId>`.
+ *
+ * Before creating the worktree, checks whether the branch already exists
+ * (via `git branch --list`) and returns an error if so.
+ *
+ * @param directory  - Project root (an absolute path to the git working tree).
+ * @param laneId    - Lane identifier (e.g. "lane-1").
+ * @param sessionId - Lean turbo session identifier.
+ * @param config    - Lean turbo configuration (may contain `worktree_dir`).
+ * @returns An object with `worktreePath` and `branchName` on success, or
+ *          `{ error: string }` on failure.
+ */
+export declare function provisionWorktree(directory: string, laneId: string, sessionId: string, config: LeanTurboConfig): Promise<ProvisionSuccess | ProvisionFailure>;
+/**
+ * Removes a git worktree **without** `--force`.
+ *
+ * On Windows (`process.platform === 'win32'`), retries up to 3 times with a
+ * 2-second delay when the error contains `EBUSY` or `EPERM` (DD-10). After
+ * exhausting retries the worktree is abandoned — the function returns an
+ * error but does NOT throw.
+ *
+ * @param worktreePath - Absolute path to the worktree directory to remove.
+ * @param projectRoot  - Absolute path to the project root (a git repository)
+ *                       used as `cwd` for the `git worktree remove` command.
+ *                       Required because the worktree's parent directory may
+ *                       not itself be a git repository.
+ * @returns `{ success: true }` on success or `{ error: string }` on failure.
+ */
+export declare function removeWorktree(worktreePath: string, projectRoot: string): Promise<RemoveSuccess | RemoveFailure>;
+/**
+ * Checks whether a worktree is clean — no uncommitted changes AND no
+ * untracked files.
+ *
+ * Runs two git commands with `cwd` set to the worktree:
+ * 1. `git status --porcelain` — detects staged/unstaged modifications
+ * 2. `git ls-files --others --exclude-standard` — detects untracked files
+ *
+ * @param worktreePath - Absolute path to the worktree directory.
+ * @returns `true` when the worktree is completely clean, `false` otherwise.
+ */
+export declare function isCleanWorktree(worktreePath: string): Promise<boolean>;
+/**
+ * Auto-commits dirty state in a worktree before cleanup.
+ *
+ * Stages all files (`git add -A`) and commits with the message
+ * `swarm-lane: auto-commit before cleanup`. If there is nothing to commit,
+ * returns `{ committed: false, reason: 'Nothing to commit' }`.
+ *
+ * @param worktreePath - Absolute path to the worktree directory.
+ * @returns `{ committed: true, message }` on success or `{ committed: false, reason }`
+ *          if nothing to commit or on failure.
+ */
+export declare function autoCommitDirty(worktreePath: string): Promise<AutoCommitSuccess | AutoCommitSkip>;
+/**
+ * Removes untracked files and directories from a worktree (DD-7 amendment).
+ *
+ * Before running `git clean -fd`, performs a dry-run (`git clean -fdn`) to
+ * list what would be deleted.  If the list contains anything that is not
+ * a known generated/temporary artifact, the clean is **skipped** to prevent
+ * accidental deletion of uncommitted source files created by lane coders.
+ *
+ * @param worktreePath - Absolute path to the worktree directory.
+ * @returns `{ cleaned: true }` on success or `{ cleaned: false, error }`
+ *          on failure or when untracked source files are detected.
+ */
+export declare function cleanUntrackedFiles(worktreePath: string): Promise<CleanSuccess | CleanFailure>;
+/**
+ * Verifies that the working tree at `directory` has no uncommitted or
+ * untracked changes before worktree provisioning (DD-2).
+ *
+ * If the working tree is dirty, returns a descriptive error message
+ * instructing the user to commit or stash.
+ *
+ * @param directory - Project root (an absolute path to the git working tree).
+ * @returns `{ clean: true }` when the working tree is clean, or
+ *          `{ clean: false, error: string }` when dirty or unverifiable.
+ */
+export declare function assertCleanWorkingTree(directory: string): Promise<CleanCheckSuccess | CleanCheckFailure>;
+export {};

package/package.json

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