@agentproto/worktree 0.13.0 → 0.14.1

package/dist/index.d.ts

@@ -233,6 +233,18 @@ interface ExecResult {
 /** Extra `AGENTPROTO_*` (or any) vars, merged onto `process.env` for the child. */
 interface ExecOptions {
     env?: Record<string, string>;
+    /**
+     * Cancels the child. When given, the child is spawned as the leader of its
+     * own process group (POSIX), and an abort signals the WHOLE group, so a
+     * `sh -c "pnpm install"` takes its `pnpm` and every worker underneath it
+     * down too instead of orphaning them. SIGTERM first, SIGKILL after
+     * {@link killGraceMs}. Already-aborted signals reject before spawning.
+     * The promise still resolves (with the child's real exit code) once the
+     * tree is gone; callers decide what an aborted run means.
+     */
+    signal?: AbortSignal;
+    /** Grace between SIGTERM and SIGKILL on abort. Default 5000ms. */
+    killGraceMs?: number;
 }
 /** Run an argv (no shell — args pass through verbatim, no injection risk). */
 declare function execArgv(command: string, args: readonly string[], cwd: string, opts?: ExecOptions): Promise<ExecResult>;
@@ -262,18 +274,21 @@ declare function execGit(repoRoot: string, args: readonly string[]): Promise<Exe
  *      are authorized to die; only the cost is being moved.
  *   2. `git worktree prune` — git forgets the (now missing) registration.
  *      The worktree disappears from `git worktree list` immediately.
- *   3. `rm -rf` on the trash dir runs in a DETACHED child
- *      (`spawn("rm", ["-rf", trashDir], { detached: true, stdio: "ignore" })`
- *      + `.unref()`) — the parent never waits for the hundreds of thousands
- *      of unlinks, and survives its own exit. The next `gc` apply also
+ *   3. `rm -rf` on the trash dirs runs in ONE DETACHED, serialized deleter
+ *      per pool (`ensureTrashDeleter`; a `.trash/.deleting` pid file stops a
+ *      second one spawning while it lives) — the parent never waits for the
+ *      hundreds of thousands of unlinks, survives its own exit, and a burst
+ *      of reclaims doesn't storm the disk with parallel `rm`s. The next `gc` apply also
  *      sweeps stale `.trash` dirs (`sweepWorktreeTrash`) so nothing leaks
  *      even if a child is killed mid-delete.
  *
  * SAFETY — the plain/forced `git worktree remove` semantics this must not
- * weaken, verified empirically against git (see the brief):
- *   - A non-force removal must refuse a dirty tree: the caller passes
- *     `force: false` only for a tree already checked clean, and
- *     `removeWorktreeFast` re-checks `git status --porcelain` itself and
+ * weaken, verified empirically against git:
+ *   - Plain `git worktree remove` ACCEPTS gitignored files (`node_modules`,
+ *     `dist`) and refuses only modified/staged tracked files, unignored
+ *     untracked files, dirty submodules and locked worktrees. A non-force
+ *     `removeWorktreeFast` gates on `git status --porcelain
+ *     --ignore-submodules=none` (no `--ignored`) plus a locked check, and
  *     throws (leaving the worktree in place) rather than renaming dirt away.
  *   - A forced removal is only ever passed after a salvage snapshot or an
  *     explicit user-granted discard flag upstream — this module doesn't
@@ -288,7 +303,7 @@ declare const WORKTREE_TRASH_DIRNAME = ".trash";
 interface RemoveWorktreeFastOptions {
     /**
      * `false` (default): re-verify the tree is clean via `git status
-     * --porcelain` and refuse (throw) on any dirt — the same refusal a plain
+     * --porcelain --untracked-files=normal --ignore-submodules=none` and refuse (throw) on any dirt — the same refusal a plain
      * `git worktree remove` performs. `true`: skip the cleanliness gate,
      * exactly like `git worktree remove --force` — only pass this when dirt
      * has been authorized (salvage snapshot durable / discard flags granted)
@@ -301,11 +316,18 @@ interface RemoveWorktreeFastOptions {
      */
     now?: () => number;
     /**
-     * Test seam — overrides the detached `rm -rf` child (e.g. an in-process
-     * spy). Receives the trash dir path. Default: a detached
-     * `spawn("rm", ["-rf", …])` the parent never waits on.
+     * Test seam — overrides background deletion per trash dir (e.g. an
+     * in-process spy). Receives the trash dir path. Default: one detached,
+     * serialized deleter per pool (`ensureTrashDeleter`) the parent never
+     * waits on.
      */
     spawnRemoval?: (trashDir: string) => void;
+    /**
+     * Test seam — replaces spawning the pool's single serialized background
+     * deleter (see `ensureTrashDeleter`). Receives the `.trash` parent and
+     * returns the spawned pid. Ignored when `spawnRemoval` is set.
+     */
+    spawnDeleter?: (trashParent: string) => number | undefined;
 }
 /**
  * Remove a linked git worktree instantly: validate → rename to trash →
@@ -323,6 +345,7 @@ declare function removeWorktreeFast(repoRoot: string, path: string, options?: Re
  */
 declare function sweepWorktreeTrash(root: string, options?: {
     spawnRemoval?: (dir: string) => void;
+    spawnDeleter?: (trashParent: string) => number | undefined;
 }): void;
 
 /** Compile a `/`-separated glob (supporting `*`, `?`, `**`) into an anchored regex. */
@@ -357,9 +380,156 @@ declare function expandCloneGlob(root: string, pattern: string): Promise<string[
  * the package manager runs — turning `depsCmd` into a quick verify/repair
  * instead of a full reinstall. Skips an entry whose destination already
  * exists — same never-clobber rule `linkPaths`/`writeFiles` follow in
- * `provision-worktree.body.ts`.
+ * `provision-worktree.body.ts`. `signal` cancels mid-copy (the `cp` process
+ * group is killed) with {@link ProvisionCancelledError}.
  */
-declare function cloneEntries(repoRoot: string, cwd: string, patterns: readonly string[]): Promise<void>;
+declare function cloneEntries(repoRoot: string, cwd: string, patterns: readonly string[], signal?: AbortSignal): Promise<void>;
+
+/**
+ * Daemon-wide scheduler for the HEAVY phases of worktree provisioning
+ * (`cloneGlobs`, `depsCmd`, `copyGlobs`, the `worktree.setup` hooks).
+ *
+ * Incident 2026-09-28: five `agent_start({worktree})` spawns provisioned at
+ * once, each ran a full `pnpm install` against one pnpm store on one SSD, the
+ * load average hit 170, and every install took ~14 min instead of ~4 while the
+ * sessions sat in `starting` looking stalled. The cure is admission control:
+ * at most N heavy segments run at once, the rest wait in a queue that can be
+ * observed and cancelled.
+ *
+ * One provisioning takes ONE slot for its whole heavy segment (clone → deps →
+ * copy → setup) rather than one per phase, so a half-built worktree never
+ * re-queues behind newer arrivals. `git worktree add` and the cheap steps
+ * around it stay outside the slot.
+ *
+ * Dispatch order is FIFO with a fair-share tiebreak: among the waiters whose
+ * repo is under its cap, the next one is the waiter whose CALLER currently
+ * holds the fewest running slots, oldest first on ties. One caller that
+ * spawns ten worktrees therefore cannot starve another caller's single spawn,
+ * and with a single caller this is plain FIFO.
+ */
+/** Default cap on concurrently running heavy segments. */
+declare const DEFAULT_PROVISION_CONCURRENCY = 2;
+/** Env override for the global cap; wins over `worktrees.provisionConcurrency`. */
+declare const PROVISION_CONCURRENCY_ENV = "AGENTPROTO_WORKTREES_PROVISION_CONCURRENCY";
+/** The phases a provisioning moves through, in order. `worktree` is the
+ *  unthrottled `git worktree add` + cheap prep; the rest are the heavy ones. */
+type ProvisionPhase = "worktree" | "clone" | "deps" | "copy" | "setup";
+/** Resolved, validated scheduler limits. `Infinity` means "no cap". */
+interface ProvisionLimits {
+    /** Max heavy segments running at once, across every repo. */
+    concurrency: number;
+    /** Extra per-repo caps (also bounded by `concurrency`). Keys are absolute
+     *  repo-root paths or bare repo directory names. */
+    perRepo: Readonly<Record<string, number>>;
+    /** Load guard: hold back a new heavy segment while the 1-minute load
+     *  average exceeds `cores x loadFactor`. `0` = off (the default). */
+    loadFactor: number;
+}
+declare const DEFAULT_PROVISION_LIMITS: ProvisionLimits;
+/**
+ * Parse the `worktrees` section of `~/.agentproto/config.json` (plus env)
+ * into {@link ProvisionLimits}. Never throws: an invalid value falls back to
+ * the default for that field so a typo can't take provisioning down.
+ *
+ *   - `provisionConcurrency`: integer >= 0 (`0` = unlimited). Env
+ *     `AGENTPROTO_WORKTREES_PROVISION_CONCURRENCY` wins over the config field.
+ *   - `provisionConcurrencyByRepo`: `{ "<repo path or dir name>": cap }`.
+ *   - `provisionLoadFactor`: number > 0 enables the load guard.
+ */
+declare function parseProvisionLimits(raw: unknown, env?: Readonly<Record<string, string | undefined>>): ProvisionLimits;
+/** Thrown when a provisioning is cancelled: while queued (its slot request is
+ *  dropped) or while running (its child process tree is killed). */
+declare class ProvisionCancelledError extends Error {
+    constructor(message?: string);
+}
+/** Progress a provisioning reports to whoever spawned it. `queued` repeats
+ *  whenever the projected position moves. */
+type ProvisionProgress = {
+    kind: "queued";
+    position: number;
+    phase: ProvisionPhase;
+} | {
+    kind: "started";
+    phase: ProvisionPhase;
+} | {
+    kind: "phase";
+    phase: ProvisionPhase;
+} | {
+    kind: "done";
+    outcome: "ok" | "failed" | "cancelled";
+};
+/** Ambient, per-provisioning context. Carried through `AsyncLocalStorage`
+ *  because the `worktree.provision` tool contract has no room for callbacks,
+ *  and the runner's own abort signal is bound to the tool's 30s default
+ *  timeout, which must never cancel a multi-minute install. */
+interface ProvisionRunContext {
+    /** Whose spawn this is, for fair-share. Typically the parent session id. */
+    callerKey?: string;
+    /** Cancels this provisioning (queued or running). */
+    signal?: AbortSignal;
+    onProgress?: (progress: ProvisionProgress) => void;
+}
+declare function runWithProvisionContext<T>(ctx: ProvisionRunContext, fn: () => T): T;
+declare function currentProvisionContext(): ProvisionRunContext | undefined;
+interface AcquireRequest {
+    /** Absolute repo root; matched against `perRepo` caps. */
+    repoKey: string;
+    callerKey?: string;
+    signal?: AbortSignal;
+    /** Called with the projected 1-based queue position when this request
+     *  starts waiting and whenever its position changes. Never called when the
+     *  slot is granted immediately. */
+    onQueued?: (position: number) => void;
+}
+/** A held slot. `release` is idempotent. */
+interface ProvisionLease {
+    release(): void;
+}
+interface SchedulerOptions {
+    limits?: ProvisionLimits;
+    /** Test seams. */
+    loadavg1?: () => number;
+    cpuCount?: () => number;
+    /** How often a load-guarded queue re-checks the load. Default 5000ms. */
+    loadPollMs?: number;
+}
+interface SchedulerSnapshot {
+    running: number;
+    queued: number;
+    limit: number;
+}
+declare class ProvisionScheduler {
+    private limits;
+    private readonly queue;
+    private readonly running;
+    private seq;
+    private loadTimer;
+    private readonly loadavg1;
+    private readonly cpuCount;
+    private readonly loadPollMs;
+    constructor(opts?: SchedulerOptions);
+    /** Replace the limits (config is re-read per provision). Raising a cap
+     *  admits waiters immediately; lowering one never interrupts a running
+     *  segment, it just delays the next admission. */
+    configure(limits: ProvisionLimits): void;
+    snapshot(): SchedulerSnapshot;
+    /**
+     * Request a heavy-phase slot. Resolves with a lease once admitted; rejects
+     * with {@link ProvisionCancelledError} when `signal` aborts first (the
+     * queue entry is dropped, so a cancelled spawn never occupies a slot).
+     */
+    acquire(req: AcquireRequest): Promise<ProvisionLease>;
+    private repoCap;
+    private runningFor;
+    /** Waiters in the order they would be admitted absent per-repo caps. */
+    private projectedOrder;
+    private loadGuardBlocks;
+    private pump;
+    private notifyPositions;
+    private armLoadTimer;
+}
+/** The process-wide (daemon-wide) scheduler every worktree provisioning shares. */
+declare const provisionScheduler: ProvisionScheduler;
 
 /**
  * `agentproto.json` — the declarative per-repo worktree lifecycle.
@@ -644,10 +814,15 @@ declare class HookError extends Error {
  * Both attempts are logged (when `logPath` is given); the thrown
  * `HookError` carries the RETRY's own result, since that's the one the
  * caller is actually giving up on.
+ *
+ * `opts.signal` cancels the run: the running hook's whole process tree is
+ * killed (see `ExecOptions.signal`) and {@link ProvisionCancelledError} is
+ * thrown instead of a `HookError`, with no retry.
  */
 declare function runSetup(config: AgentprotoConfig, ctx: WorktreeEnvContext, opts?: {
     logPath?: string;
     retryOnFailure?: boolean;
+    signal?: AbortSignal;
 }): Promise<HookRun[]>;
 /**
  * Run the `worktree.teardown` hooks sequentially. Unlike setup, a failing
@@ -2253,4 +2428,4 @@ declare function recordBranchVerdict(input: {
     now?: () => string;
 }): Promise<BranchVerdictRecord>;
 
-export { type AgentprotoConfig, type ApplyBranchGcOptions, type ApplyGcOptions, BRANCH_GC_SCOPES, BRANCH_GC_STATE_DIR, BRANCH_TRIAGE_VERDICTS, BRANCH_VERDICTS_PATH, type BaseDivergence, type BranchCoverage, type BranchGcApplyOutcome, type BranchGcApplyResult, type BranchGcClass, type BranchGcHoldReason, type BranchGcPlan, type BranchGcPlanEntry, type BranchGcReclaimReason, type BranchGcRestoreEntry, type BranchGcRestoreLog, type BranchGcSummary, type BranchHistory, type BranchPushState, type BranchRef, type BranchRefKind, type BranchReviewCandidate, type BranchReviewQueue, type BranchStatus, type BranchTriageVerdict, type BranchVerdict, BranchVerdictError, type BranchVerdictRecord, type BranchVerdictStore, type BranchVerdictSummary, CONFIG_FILENAME, type Classification, type ClassifyForGcOptions, type ComputeProvenanceOptions, type ComputeTreeStateOptions, type ComputeWorktreeStatusInput, ConfigError, DEFAULT_BRANCH_GC_MIN_AGE_DAYS, DEFAULT_GC_NOISE_PATHS, DEFAULT_PROXY_PORT, type DaemonAgentSessionHost, type DaemonClient, ENV_VARS, type ExecOptions, type ExecResult, FileBranchVerdictStore, FileVerdictMemoStore, type ForgeClient, type ForgePullRequestRef, ForgeUnavailableError, type GateState, type GcApplyOutcome, type GcClass, type GcHoldReason, type GcPlanEntry, type GcReclaimReason, GhCliForgeClient, type GitWorktreeRef, GlobTraversalError, HookError, type HookRun, type HostnameParts, type InBaseReclaimReason, InMemoryBranchVerdictStore, InMemoryVerdictMemoStore, type IntegrationState, LOCAL_WORKTREE_CONFIG_REL, type LadderContext, type ListWorktreeStatusesInput, type LivenessState, type LocalWorktreeConfig, type LocalWriteFileEntry, type NamedScript, type PeerService, type PlanBranchGcInput, type PlanGcInput, type ProvenanceConfidence, type ProvenanceInfo, ProxyTable, type ReconcileIntegrationInput, type RemoveWorktreeFastOptions, type ResolveGcClassOptions, type ResolveSupervisorInput, type ResolvedGcClass, type ResolvedWorktreeRuntime, RestForgeClient, type RunningProxy, SALVAGE_ROOT, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, type SalvageManifest, type SalvageResult, type SalvageWorktreeInput, type ScriptConfig, type ServiceRuntime, type ServiceStatus, ServiceSupervisor, type SessionRef, type SupervisorOptions, type TipClassification, type TreeIndex, type TreeState, UnreachableForgeClient, VERDICT_MEMO_PATH, type VerdictMemoRecord, type VerdictMemoStore, WORKTREES_TURBO_CACHE_DIR_ENV, WORKTREE_TRASH_DIRNAME, type WorktreeAgentInput, type WorktreeClass, type WorktreeEnvContext, type WorktreeMarker, WorktreeNotRemovableError, type WorktreeStatusEntry, allocatePort, applyBranchGc, applyGc, applySlugPlaceholder, branchReviewQueue, branchVerdictSchema, classify, classifyForGc, classifyTip, classifyTipAgainstBase, cloneEntries, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, connectDaemonAgentSessionHost, createForgeClient, createLadderContext, createProxyServer, detectAnchor, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandCloneGlob, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isMechanicalDepBumpRange, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, loadLocalWorktreeConfig, makeDaemonAgentSessionHost, normalizeHook, parseConfig, parseGithubOwnerRepo, parseLocalWorktreeConfig, peerEnv, peerEnvKey, planBranchGc, planGc, readBranchGcRestoreLog, readSessionsRegistry, readWorktreeMarker, reclaimOneWorktree, reconcileIntegration, recordBranchVerdict, removeWorktreeFast, repoLabel, resolveGcClass, resolveLocalWriteFiles, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, salvageWorktree, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, startProxy, stripPort, summarizeBranchGcPlan, sweepWorktreeTrash, worktreeAgentInputSchema, worktreeAgentWorkflow, writeWorktreeMarker };
+export { type AcquireRequest, type AgentprotoConfig, type ApplyBranchGcOptions, type ApplyGcOptions, BRANCH_GC_SCOPES, BRANCH_GC_STATE_DIR, BRANCH_TRIAGE_VERDICTS, BRANCH_VERDICTS_PATH, type BaseDivergence, type BranchCoverage, type BranchGcApplyOutcome, type BranchGcApplyResult, type BranchGcClass, type BranchGcHoldReason, type BranchGcPlan, type BranchGcPlanEntry, type BranchGcReclaimReason, type BranchGcRestoreEntry, type BranchGcRestoreLog, type BranchGcSummary, type BranchHistory, type BranchPushState, type BranchRef, type BranchRefKind, type BranchReviewCandidate, type BranchReviewQueue, type BranchStatus, type BranchTriageVerdict, type BranchVerdict, BranchVerdictError, type BranchVerdictRecord, type BranchVerdictStore, type BranchVerdictSummary, CONFIG_FILENAME, type Classification, type ClassifyForGcOptions, type ComputeProvenanceOptions, type ComputeTreeStateOptions, type ComputeWorktreeStatusInput, ConfigError, DEFAULT_BRANCH_GC_MIN_AGE_DAYS, DEFAULT_GC_NOISE_PATHS, DEFAULT_PROVISION_CONCURRENCY, DEFAULT_PROVISION_LIMITS, DEFAULT_PROXY_PORT, type DaemonAgentSessionHost, type DaemonClient, ENV_VARS, type ExecOptions, type ExecResult, FileBranchVerdictStore, FileVerdictMemoStore, type ForgeClient, type ForgePullRequestRef, ForgeUnavailableError, type GateState, type GcApplyOutcome, type GcClass, type GcHoldReason, type GcPlanEntry, type GcReclaimReason, GhCliForgeClient, type GitWorktreeRef, GlobTraversalError, HookError, type HookRun, type HostnameParts, type InBaseReclaimReason, InMemoryBranchVerdictStore, InMemoryVerdictMemoStore, type IntegrationState, LOCAL_WORKTREE_CONFIG_REL, type LadderContext, type ListWorktreeStatusesInput, type LivenessState, type LocalWorktreeConfig, type LocalWriteFileEntry, type NamedScript, PROVISION_CONCURRENCY_ENV, type PeerService, type PlanBranchGcInput, type PlanGcInput, type ProvenanceConfidence, type ProvenanceInfo, ProvisionCancelledError, type ProvisionLease, type ProvisionLimits, type ProvisionPhase, type ProvisionProgress, type ProvisionRunContext, ProvisionScheduler, ProxyTable, type ReconcileIntegrationInput, type RemoveWorktreeFastOptions, type ResolveGcClassOptions, type ResolveSupervisorInput, type ResolvedGcClass, type ResolvedWorktreeRuntime, RestForgeClient, type RunningProxy, SALVAGE_ROOT, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, type SalvageManifest, type SalvageResult, type SalvageWorktreeInput, type SchedulerOptions, type SchedulerSnapshot, type ScriptConfig, type ServiceRuntime, type ServiceStatus, ServiceSupervisor, type SessionRef, type SupervisorOptions, type TipClassification, type TreeIndex, type TreeState, UnreachableForgeClient, VERDICT_MEMO_PATH, type VerdictMemoRecord, type VerdictMemoStore, WORKTREES_TURBO_CACHE_DIR_ENV, WORKTREE_TRASH_DIRNAME, type WorktreeAgentInput, type WorktreeClass, type WorktreeEnvContext, type WorktreeMarker, WorktreeNotRemovableError, type WorktreeStatusEntry, allocatePort, applyBranchGc, applyGc, applySlugPlaceholder, branchReviewQueue, branchVerdictSchema, classify, classifyForGc, classifyTip, classifyTipAgainstBase, cloneEntries, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, connectDaemonAgentSessionHost, createForgeClient, createLadderContext, createProxyServer, currentProvisionContext, detectAnchor, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandCloneGlob, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isMechanicalDepBumpRange, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, loadLocalWorktreeConfig, makeDaemonAgentSessionHost, normalizeHook, parseConfig, parseGithubOwnerRepo, parseLocalWorktreeConfig, parseProvisionLimits, peerEnv, peerEnvKey, planBranchGc, planGc, provisionScheduler, readBranchGcRestoreLog, readSessionsRegistry, readWorktreeMarker, reclaimOneWorktree, reconcileIntegration, recordBranchVerdict, removeWorktreeFast, repoLabel, resolveGcClass, resolveLocalWriteFiles, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, runWithProvisionContext, salvageWorktree, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, startProxy, stripPort, summarizeBranchGcPlan, sweepWorktreeTrash, worktreeAgentInputSchema, worktreeAgentWorkflow, writeWorktreeMarker };

package/dist/index.mjs

@@ -1,7 +1,7 @@
-export { connectDaemonAgentSessionHost, makeDaemonAgentSessionHost, worktreeAgentInputSchema, worktreeAgentWorkflow } from './chunk-YMDOSMMD.mjs';
+export { connectDaemonAgentSessionHost, makeDaemonAgentSessionHost, worktreeAgentInputSchema, worktreeAgentWorkflow } from './chunk-FC3I5NTS.mjs';
 import './chunk-E3EM24BS.mjs';
-import { computeProvenance, execArgv, classify, computeWorktreeStatus, sweepWorktreeTrash, listGitWorktrees, execGit, worktreeProvider } from './chunk-MYH5XOX6.mjs';
-export { CONFIG_FILENAME, ConfigError, DEFAULT_PROXY_PORT, ENV_VARS, FileVerdictMemoStore, GlobTraversalError, HookError, InMemoryVerdictMemoStore, LOCAL_WORKTREE_CONFIG_REL, ProxyTable, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, ServiceSupervisor, VERDICT_MEMO_PATH, WORKTREES_TURBO_CACHE_DIR_ENV, WORKTREE_TRASH_DIRNAME, WorktreeNotRemovableError, allocatePort, applySlugPlaceholder, classify, cloneEntries, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandCloneGlob, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, loadLocalWorktreeConfig, normalizeHook, parseConfig, parseLocalWorktreeConfig, peerEnv, peerEnvKey, readSessionsRegistry, readWorktreeMarker, reconcileIntegration, removeWorktreeFast, repoLabel, resolveLocalWriteFiles, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, stripPort, sweepWorktreeTrash, worktreeProvider, writeWorktreeMarker } from './chunk-MYH5XOX6.mjs';
+import { computeProvenance, execArgv, classify, computeWorktreeStatus, sweepWorktreeTrash, listGitWorktrees, execGit, worktreeProvider } from './chunk-IEW2O3PF.mjs';
+export { CONFIG_FILENAME, ConfigError, DEFAULT_PROVISION_CONCURRENCY, DEFAULT_PROVISION_LIMITS, DEFAULT_PROXY_PORT, ENV_VARS, FileVerdictMemoStore, GlobTraversalError, HookError, InMemoryVerdictMemoStore, LOCAL_WORKTREE_CONFIG_REL, PROVISION_CONCURRENCY_ENV, ProvisionCancelledError, ProvisionScheduler, ProxyTable, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, ServiceSupervisor, VERDICT_MEMO_PATH, WORKTREES_TURBO_CACHE_DIR_ENV, WORKTREE_TRASH_DIRNAME, WorktreeNotRemovableError, allocatePort, applySlugPlaceholder, classify, cloneEntries, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, currentProvisionContext, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandCloneGlob, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, loadLocalWorktreeConfig, normalizeHook, parseConfig, parseLocalWorktreeConfig, parseProvisionLimits, peerEnv, peerEnvKey, provisionScheduler, readSessionsRegistry, readWorktreeMarker, reconcileIntegration, removeWorktreeFast, repoLabel, resolveLocalWriteFiles, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, runWithProvisionContext, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, stripPort, sweepWorktreeTrash, worktreeProvider, writeWorktreeMarker } from './chunk-IEW2O3PF.mjs';
 import { cleanupWorktreeTool } from './chunk-3FZWPMLF.mjs';
 export { cleanupWorktreeTool, listServicesTool, provisionWorktreeTool, runGateTool, runScriptTool, serviceStatusSchema, startServiceTool, stopServiceTool } from './chunk-3FZWPMLF.mjs';
 import { mkdir, copyFile, readFile, writeFile, open, rename, readdir, realpath, rm, stat } from 'fs/promises';

package/dist/provider/index.mjs

@@ -1,4 +1,4 @@
-export { worktreeProvider } from '../chunk-MYH5XOX6.mjs';
+export { worktreeProvider } from '../chunk-IEW2O3PF.mjs';
 import '../chunk-3FZWPMLF.mjs';
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentproto/worktree",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "description": "AIP-14 TOOL contracts + builtin AIP-30 PROVIDER for provisioning, gating, and cleaning up a git worktree — the primitive an AgentStep binds its `cwd` to for a launch-agent-in-a-worktree workflow.",
   "keywords": [
     "agentproto",
@@ -57,19 +57,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@modelcontextprotocol/sdk": "^1.30.1",
     "zod": "^4.6.5",
-    "@agentproto/driver": "0.2.4",
-    "@agentproto/harness": "0.4.6",
-    "@agentproto/tool": "0.3.1",
-    "@agentproto/workflow-runtime": "0.14.0"
+    "@agentproto/driver": "0.3.0",
+    "@agentproto/harness": "0.4.7",
+    "@agentproto/workflow-runtime": "0.16.0",
+    "@agentproto/tool": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.5",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^3.2.7",
-    "@agentproto/routine": "0.3.0",
+    "@agentproto/routine": "0.3.1",
     "@agentproto/tooling": "0.1.0"
   },
   "scripts": {