opencode-swarm 7.59.1 → 7.60.0

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

@@ -1,180 +1,5 @@
-/**
- * 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>;
+import { _internals, attemptMergeBackFromDirty, cleanupOrphanedBranches, handleMergeConflict, mergeLaneBranch, postMergeCleanup, startupOrphanRecovery } from '../../worktree/merge';
+export { _internals, attemptMergeBackFromDirty, cleanupOrphanedBranches, handleMergeConflict, mergeLaneBranch, postMergeCleanup, startupOrphanRecovery, };
+export type { CleanupFailure, CleanupSuccess, ConflictHandlingError, ConflictInfo, DirtyMergeFailure, DirtyMergePartial, DirtyMergeSuccess, MergeConflict, MergeFailure, MergeSuccess, OrphanCleanupResult, StartupRecoveryResult, } from '../../worktree/merge';
+export declare function getMergeStrategy(config: LeanTurboConfig): import("../../worktree").MergeStrategy;

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

@@ -1,194 +1,8 @@
-/**
- * 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 {
+import { _internals, assertCleanWorkingTree, autoCommitDirty, checkPathBudget, cleanUntrackedFiles, isCleanWorktree, removeWorktree, shortenWorktreePath } from '../../worktree/core';
+export { _internals, assertCleanWorkingTree, autoCommitDirty, checkPathBudget, cleanUntrackedFiles, isCleanWorktree, removeWorktree, shortenWorktreePath, };
+export type { AutoCommitSkip, AutoCommitSuccess, CleanCheckFailure, CleanCheckSuccess, CleanFailure, CleanSuccess, ProvisionFailure, ProvisionSuccess, RemoveFailure, RemoveSuccess, } from '../../worktree/core';
+export declare function provisionWorktree(directory: string, laneId: string, sessionId: string, config: LeanTurboConfig): Promise<import("../../worktree").WorktreeFailure | {
     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/dist/worktree/core.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 { bunSpawn } from '../utils/bun-compat';
+import type { WorktreeHandle, WorktreeOptions, WorktreeProvisionResult } from './types';
+/**
+ * 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;
+export interface ProvisionSuccess extends WorktreeHandle {
+}
+export interface ProvisionFailure {
+    error: string;
+}
+export interface RemoveSuccess {
+    success: true;
+}
+export interface RemoveFailure {
+    error: string;
+}
+export interface AutoCommitSuccess {
+    committed: true;
+    message: string;
+}
+export interface AutoCommitSkip {
+    committed: false;
+    reason: string;
+}
+export interface CleanSuccess {
+    cleaned: true;
+}
+export interface CleanFailure {
+    cleaned: false;
+    error: string;
+}
+export interface CleanCheckSuccess {
+    clean: true;
+}
+export interface CleanCheckFailure {
+    clean: false;
+    error: string;
+}
+export declare function makeWorktreeBranchName(sessionId: string, id: string, options: Pick<WorktreeOptions, 'purpose' | 'branchStyle'>): string;
+/**
+ * Creates a new git worktree for an isolated swarm execution unit.
+ *
+ * Branch naming defaults to `swarm/<purpose>/<sessionId>/<id>`. Lean Turbo
+ * callers pass `branchStyle: 'legacy-lane'` to preserve
+ * `swarm-lane/<sessionId>/<laneId>`.
+ * Worktree path uses `options.worktreeDir` when set, otherwise defaults to
+ * `<project-parent>/.swarm-worktrees/<sessionId>/<id>`.
+ *
+ * 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 id        - Execution unit identifier (for example, task or lane ID).
+ * @param sessionId - Parent session identifier.
+ * @param options   - Worktree purpose, branch naming, and path options.
+ * @returns A worktree handle on success, or `{ error: string }` on failure.
+ */
+export declare function provisionWorktree(directory: string, id: string, sessionId: string, options: WorktreeOptions): Promise<WorktreeProvisionResult>;
+/**
+ * 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/dist/worktree/index.d.ts

@@ -0,0 +1,5 @@
+export type { AutoCommitSkip, AutoCommitSuccess, CleanCheckFailure, CleanCheckSuccess, CleanFailure, CleanSuccess, ProvisionFailure, ProvisionSuccess, RemoveFailure, RemoveSuccess, } from './core';
+export { _internals as coreInternals, assertCleanWorkingTree, autoCommitDirty, checkPathBudget, cleanUntrackedFiles, isCleanWorktree, makeWorktreeBranchName, provisionWorktree, removeWorktree, shortenWorktreePath, } from './core';
+export type { CleanupFailure, CleanupSuccess, ConflictHandlingError, ConflictInfo, DirtyMergeFailure, DirtyMergePartial, DirtyMergeSuccess, MergeConflict, MergeFailure, MergeSuccess, OrphanCleanupResult, StartupRecoveryResult, } from './merge';
+export { _internals as mergeInternals, attemptMergeBackFromDirty, cleanupOrphanedBranches, getMergeStrategy, handleMergeConflict, mergeLaneBranch, postMergeCleanup, startupOrphanRecovery, } from './merge';
+export * from './types';