@agentproto/worktree 0.12.0 → 0.14.0

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,12 +345,191 @@ 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. */
 declare function globToRegExp(pattern: string): RegExp;
 /** Expand a glob against `root`, returning root-relative posix paths of matching files. */
 declare function expandGlob(root: string, pattern: string): Promise<string[]>;
+/** A `cloneGlobs`/`copyGlobs` pattern that could resolve outside its root — a
+ *  leading `/`, or a literal `..` path segment. */
+declare class GlobTraversalError extends Error {
+    constructor(pattern: string);
+}
+/**
+ * Expand a glob against `root` for CLONING a whole entry. Unlike
+ * {@link expandGlob} — which enumerates individual FILES and deliberately
+ * skips descending into `node_modules` — this matches whole entries (files
+ * OR directories) and never descends past a match: a matching directory is
+ * returned as a single unit for the caller to clone as a whole tree, so a
+ * pattern like `node_modules` costs one `readdir`, not a walk of everything
+ * inside it. `**` is not supported (a clone target must be a single named
+ * entry per level, not an arbitrary-depth wildcard) and throws.
+ *
+ * Throws {@link GlobTraversalError} on a pattern that could resolve outside
+ * `root` (a leading `/`, or any `..` segment) — checked before any
+ * filesystem access.
+ */
+declare function expandCloneGlob(root: string, pattern: string): Promise<string[]>;
+
+/**
+ * Clone every entry matched by `patterns` (see {@link expandCloneGlob}) from
+ * `repoRoot` into `cwd`, meant to run BEFORE `depsCmd` so a gitignored,
+ * expensive-to-recreate tree (e.g. `node_modules`) is already present when
+ * 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`. `signal` cancels mid-copy (the `cp` process
+ * group is killed) with {@link ProvisionCancelledError}.
+ */
+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.
@@ -390,6 +591,71 @@ declare function getScript(config: AgentprotoConfig, name: string): NamedScript
  */
 declare function loadConfigFromBase(repoRoot: string, base?: string): Promise<AgentprotoConfig | null>;
 
+/**
+ * `<workspace>/.agentproto/worktree.json` — a LOCAL, host-owned worktree
+ * lifecycle default, read straight off disk (never `git show`, never a
+ * worktree's own tree). Same idea as `<workspace>/.agentproto/allowed-
+ * commands.json` (`command-allowlist.ts`): a per-machine setting that lets
+ * one host declare what a fresh worktree needs (a `node_modules` clone, a
+ * per-worktree pnpm store) without committing that machine's paths into the
+ * repo. `.agentproto/` is gitignored repo-wide (see this repo's own
+ * `.gitignore`), so this file can never ride in on a branch — there is
+ * nothing here for `config.ts`'s "only what a reviewer merged" guarantee to
+ * defend against; the trust model is simply "whoever owns this machine's
+ * filesystem".
+ *
+ * `workspace` is the SOURCE checkout — the same directory passed as
+ * `provisionWorktreeTool`'s `repoRoot` — never the freshly created worktree
+ * (which starts with no `.agentproto/worktree.json` of its own, since the
+ * dir is gitignored and nothing copies it in).
+ */
+declare const LOCAL_WORKTREE_CONFIG_REL = ".agentproto/worktree.json";
+declare const localWriteFileEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+        create: "create";
+        append: "append";
+    }>>;
+}, z.core.$strip>;
+declare const localWorktreeConfigSchema: z.ZodObject<{
+    copyGlobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cloneGlobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    writeFiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        mode: z.ZodOptional<z.ZodEnum<{
+            create: "create";
+            append: "append";
+        }>>;
+    }, z.core.$strip>>>;
+    depsCmd: z.ZodOptional<z.ZodString>;
+    linkPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type LocalWriteFileEntry = z.infer<typeof localWriteFileEntrySchema>;
+type LocalWorktreeConfig = z.infer<typeof localWorktreeConfigSchema>;
+/**
+ * Parse + validate raw `worktree.json` text. Throws {@link ConfigError} on
+ * malformed JSON or a schema violation — same failure shape as
+ * `config.ts`'s `parseConfig`, so callers can handle both uniformly.
+ */
+declare function parseLocalWorktreeConfig(raw: string): LocalWorktreeConfig;
+/**
+ * Load `<workspace>/.agentproto/worktree.json` straight off disk. Returns
+ * `null` when the file is absent (the common case — most workspaces don't
+ * opt in). Throws {@link ConfigError} on a present-but-invalid file.
+ */
+declare function loadLocalWorktreeConfig(workspace: string): Promise<LocalWorktreeConfig | null>;
+/** Substitute the literal `{slug}` token for `slug` in `text`. */
+declare function applySlugPlaceholder(text: string, slug: string): string;
+/**
+ * Resolve a local config's `writeFiles` for one concrete worktree: expands
+ * `{slug}` in `path`/`content` so a declarative entry (e.g. a pnpm
+ * `virtualStoreDir` pointed outside the worktree) can be written once and
+ * still land at a distinct, collision-free path per worktree.
+ */
+declare function resolveLocalWriteFiles(files: readonly LocalWriteFileEntry[] | undefined, slug: string): LocalWriteFileEntry[];
+
 /**
  * Typed env surface for worktree lifecycle hooks, scripts, and services.
  *
@@ -548,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
@@ -2157,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, HookError, type HookRun, type HostnameParts, type InBaseReclaimReason, InMemoryBranchVerdictStore, InMemoryVerdictMemoStore, type IntegrationState, type LadderContext, type ListWorktreeStatusesInput, type LivenessState, 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, branchReviewQueue, branchVerdictSchema, classify, classifyForGc, classifyTip, classifyTipAgainstBase, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, connectDaemonAgentSessionHost, createForgeClient, createLadderContext, createProxyServer, detectAnchor, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isMechanicalDepBumpRange, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, makeDaemonAgentSessionHost, normalizeHook, parseConfig, parseGithubOwnerRepo, peerEnv, peerEnvKey, planBranchGc, planGc, readBranchGcRestoreLog, readSessionsRegistry, readWorktreeMarker, reclaimOneWorktree, reconcileIntegration, recordBranchVerdict, removeWorktreeFast, repoLabel, resolveGcClass, 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,9 +1,9 @@
-export { connectDaemonAgentSessionHost, makeDaemonAgentSessionHost, worktreeAgentInputSchema, worktreeAgentWorkflow } from './chunk-5SDH2V6M.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-EVHLUKC7.mjs';
-export { CONFIG_FILENAME, ConfigError, DEFAULT_PROXY_PORT, ENV_VARS, FileVerdictMemoStore, HookError, InMemoryVerdictMemoStore, ProxyTable, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, ServiceSupervisor, VERDICT_MEMO_PATH, WORKTREES_TURBO_CACHE_DIR_ENV, WORKTREE_TRASH_DIRNAME, WorktreeNotRemovableError, allocatePort, classify, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, normalizeHook, parseConfig, peerEnv, peerEnvKey, readSessionsRegistry, readWorktreeMarker, reconcileIntegration, removeWorktreeFast, repoLabel, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, stripPort, sweepWorktreeTrash, worktreeProvider, writeWorktreeMarker } from './chunk-EVHLUKC7.mjs';
-import { cleanupWorktreeTool } from './chunk-EK5BH2YL.mjs';
-export { cleanupWorktreeTool, listServicesTool, provisionWorktreeTool, runGateTool, runScriptTool, serviceStatusSchema, startServiceTool, stopServiceTool } from './chunk-EK5BH2YL.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';
 import { homedir } from 'os';
 import { resolve, join, dirname, basename, sep, relative, isAbsolute } from 'path';

package/dist/provider/index.mjs

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

package/dist/tools/index.d.ts

@@ -14,6 +14,7 @@ declare const provisionWorktreeTool: _agentproto_tool.ToolHandle<{
     dir?: string | undefined;
     depsCmd?: string | undefined;
     copyGlobs?: string[] | undefined;
+    cloneGlobs?: string[] | undefined;
     linkPaths?: string[] | undefined;
     writeFiles?: {
         path: string;

package/dist/tools/index.mjs

@@ -1,4 +1,4 @@
 import '../chunk-E3EM24BS.mjs';
-export { cleanupWorktreeTool, listServicesTool, provisionWorktreeTool, runGateTool, runScriptTool, serviceStatusSchema, startServiceTool, stopServiceTool } from '../chunk-EK5BH2YL.mjs';
+export { cleanupWorktreeTool, listServicesTool, provisionWorktreeTool, runGateTool, runScriptTool, serviceStatusSchema, startServiceTool, stopServiceTool } from '../chunk-3FZWPMLF.mjs';
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentproto/worktree",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "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.2.5",
+    "@agentproto/harness": "0.4.7",
+    "@agentproto/tool": "0.3.2",
+    "@agentproto/workflow-runtime": "0.15.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": {

package/dist/chunk-EK5BH2YL.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/tools/provision-worktree.tool.ts","../src/tools/cleanup-worktree.tool.ts","../src/tools/run-gate.tool.ts","../src/tools/run-script.tool.ts","../src/tools/service.schema.ts","../src/tools/start-service.tool.ts","../src/tools/stop-service.tool.ts","../src/tools/list-services.tool.ts"],"names":["defineTool","z"],"mappings":"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","file":"chunk-EK5BH2YL.mjs","sourcesContent":["import { z } from \"zod\"\nimport { defineTool } from \"@agentproto/tool\"\n\n/**\n * AIP-14 contract: create a git worktree off a base ref, on its own branch,\n * optionally installing deps and copying gitignored files (secrets) into it.\n * Agnostic — no hardcoded package manager or env layout; both are inputs.\n */\nexport const provisionWorktreeTool = defineTool({\n  id: \"worktree.provision\",\n  description:\n    \"Create a git worktree for `repoRoot` at a sibling '_worktrees/<slug>' \" +\n    \"directory (or `dir`, when given), on a new branch 'wt/<slug>' (or \" +\n    \"`branch`, when given) cut from `base`. If `depsCmd` is given, it runs \" +\n    \"inside the new worktree afterwards (e.g. install deps). If `copyGlobs` \" +\n    \"is given, matching files under `repoRoot` (including gitignored ones, \" +\n    \"e.g. local secrets) are copied into the worktree at the same relative \" +\n    \"path. If `linkPaths` is given, each is symlinked from `repoRoot` into \" +\n    \"the worktree before `depsCmd` runs — for gitignored, expensive-to-\" +\n    \"recreate trees a fresh worktree lacks (node_modules, sibling workspace \" +\n    \"repos) so the workspace graph resolves without a full reinstall. When \" +\n    \"`depsCmd`/`linkPaths` are omitted, they fall back to `worktree.depsCmd`/\" +\n    \"`worktree.linkPaths` declared in the base tree's agentproto.json (same \" +\n    \"`runSetup` gate as the setup hooks below) — an explicit input always \" +\n    \"wins over the declarative default. If \" +\n    \"`writeFiles` is given, each entry's `content` is written into the \" +\n    \"worktree at `path` before `depsCmd` runs — for generated, worktree-\" +\n    \"specific config a tool invoked by `depsCmd` needs to see (e.g. a \" +\n    \"package-manager config pointing a cache/store dir outside the \" +\n    \"worktree, so it isn't shared with — or clobbered by — a sibling \" +\n    \"worktree). `mode: \\\"create\\\"` (default) skips an entry whose path \" +\n    \"already exists, matching `linkPaths`' never-clobber rule; \" +\n    \"`mode: \\\"append\\\"` always appends (creating the file if missing) and, \" +\n    \"if git already tracks that path, marks it `skip-worktree` afterwards \" +\n    \"so the tweak never shows up as a local modification the caller could \" +\n    \"accidentally commit — callers are responsible for making the content \" +\n    \"itself idempotent (e.g. checking `repoRoot`'s copy of the file for the \" +\n    \"line before including the entry, since a fresh worktree's tracked \" +\n    \"files start as a byte-identical checkout). Also writes a creation-\" +\n    \"provenance marker into the worktree's private gitdir.\",\n  version: \"0.2.0\",\n  inputSchema: z.object({\n    repoRoot: z.string().describe(\"Absolute path to the git repository root.\"),\n    base: z\n      .string()\n      .optional()\n      .describe(\"Ref the new branch is cut from. Default 'origin/main'.\"),\n    slug: z\n      .string()\n      .regex(/^[a-z0-9][a-z0-9-]*$/, \"slug must be lowercase kebab-case\")\n      .describe(\"Short identifier — names both the worktree directory and its branch.\"),\n    branch: z\n      .string()\n      .optional()\n      .describe(\"Branch name for the new worktree. Default 'wt/<slug>'.\"),\n    dir: z\n      .string()\n      .optional()\n      .describe(\"Absolute path for the new worktree. Default '<repoRoot>/../_worktrees/<slug>'.\"),\n    depsCmd: z\n      .string()\n      .optional()\n      .describe(\"Shell command run inside the worktree after creation, e.g. 'pnpm install --prefer-offline'.\"),\n    copyGlobs: z\n      .array(z.string())\n      .optional()\n      .describe(\"Glob patterns (relative to repoRoot) of gitignored files to copy into the worktree, e.g. 'envs/**/.env.local'.\"),\n    linkPaths: z\n      .array(z.string())\n      .optional()\n      .describe(\"Relative paths (dirs or files) symlinked from repoRoot into the worktree before depsCmd, e.g. 'node_modules' or a gitignored sibling workspace repo. Lets the workspace graph resolve without a full reinstall.\"),\n    writeFiles: z\n      .array(\n        z.object({\n          path: z.string().describe(\"Path relative to the worktree root.\"),\n          content: z.string().describe(\"File content, written or appended verbatim.\"),\n          mode: z\n            .enum([\"create\", \"append\"])\n            .optional()\n            .describe(\"'create' (default): write only if path doesn't already exist. 'append': always append (creating if missing); if git tracks the path, it's marked skip-worktree afterwards so the change never shows as a local modification.\"),\n        }),\n      )\n      .optional()\n      .describe(\"Files written into the worktree before depsCmd runs, e.g. a package-manager config generated for this specific worktree.\"),\n    runSetup: z\n      .boolean()\n      .optional()\n      .describe(\"Read the base tree's agentproto.json and apply its declarative worktree lifecycle: `worktree.depsCmd`/`worktree.linkPaths` as fallbacks for the inputs above, then the `worktree.setup` hooks after creation. Default true; a failing setup hook fails provisioning.\"),\n    setupLogPath: z\n      .string()\n      .optional()\n      .describe(\"Absolute path to append the FULL, unfiltered stdout+stderr of every `worktree.setup` hook command to (success or failure). Caller-provided — typically a path under the spawning session's own directory, so the full output outlives a subsequently-reclaimed worktree. Best-effort: a write failure never fails provisioning. When omitted, only a short, noise-filtered tail survives in a failing hook's own error message.\"),\n    retrySetupOnFailure: z\n      .boolean()\n      .optional()\n      .describe(\"Re-run a failing `worktree.setup` command exactly once before giving up — a complement to (never a substitute for) a real root-cause fix, meant for unattended callers with no way to retry themselves short of provisioning an entirely new worktree. Default false: an interactive caller (e.g. `agentproto worktree new`) sees a genuine failure on the first try rather than waiting through an identical rerun.\"),\n  }),\n  outputSchema: z.object({\n    cwd: z.string().describe(\"Absolute path to the created worktree.\"),\n    branch: z.string().describe(\"The branch the worktree was created on.\"),\n  }),\n  mutates: [\"fs:write\"],\n  approval: \"auto\",\n  riskLevel: 1,\n})\n","import { z } from \"zod\"\nimport { defineTool } from \"@agentproto/tool\"\n\n/**\n * AIP-14 contract: remove a git worktree, optionally deleting its branch.\n *\n * Guarded by default (PLAN.md §5.2 layer 3): with neither discard flag set,\n * this runs a plain `git worktree remove` — git itself is the final arbiter\n * and refuses on modified or unignored-untracked files, tolerating gitignored\n * trees like `node_modules/`. `discardUntracked` / `discardModified` each\n * authorize exactly one class of destruction git otherwise refuses; only\n * when the flags cover everything actually dirty does `--force` get passed\n * through. This replaces an unconditional `--force` that used to destroy\n * real edits indiscriminately (the incident this contract change exists to\n * prevent) — hence `riskLevel: 2`, up from the old unconditional-force `1`.\n */\nexport const cleanupWorktreeTool = defineTool({\n  id: \"worktree.cleanup\",\n  description:\n    \"Remove a git worktree created by 'worktree.provision'. Refuses if the \" +\n    \"worktree has modified tracked files or unignored untracked files, \" +\n    \"unless the matching `discardModified` / `discardUntracked` flag is \" +\n    \"set — a clean or gitignore-only tree (e.g. installed deps) always \" +\n    \"removes with no flags. If `deleteBranch` is true and `branch` is \" +\n    \"given, also force-delete that branch (only ever called for merged \" +\n    \"branches by this package's own callers).\",\n  version: \"0.2.0\",\n  inputSchema: z.object({\n    repoRoot: z.string().describe(\"Absolute path to the git repository root.\"),\n    cwd: z.string().describe(\"Absolute path to the worktree to remove.\"),\n    branch: z.string().optional().describe(\"The worktree's branch, for deleteBranch.\"),\n    deleteBranch: z.boolean().optional().describe(\"Also force-delete `branch` after removing the worktree.\"),\n    base: z.string().optional().describe(\"Ref whose committed agentproto.json supplies teardown hooks. Default 'origin/main'.\"),\n    runTeardown: z.boolean().optional().describe(\"Run the `worktree.teardown` hooks before removal. Default true; teardown failures are logged, never blocking.\"),\n    discardUntracked: z.boolean().optional().describe(\"Authorize discarding unignored untracked files. Default false: refuse if any are present.\"),\n    discardModified: z.boolean().optional().describe(\"Authorize discarding modified tracked files (staged or unstaged). Default false: refuse if any are present.\"),\n  }),\n  outputSchema: z.object({\n    removed: z.literal(true),\n  }),\n  mutates: [\"fs:write\"],\n  approval: \"auto\",\n  riskLevel: 2,\n})\n","import { z } from \"zod\"\nimport { defineTool } from \"@agentproto/tool\"\n\n/**\n * AIP-14 contract: run a caller-provided gate/check command inside a\n * directory (typically a provisioned worktree) and report pass/fail.\n * `cmd` is a trusted, developer-authored config value (same trust model as\n * a CI job's `script:` line), run through a shell so it may include flags.\n */\nexport const runGateTool = defineTool({\n  id: \"worktree.run-gate\",\n  description:\n    \"Run a gate command (e.g. 'pnpm test') inside `cwd` and report pass/fail \" +\n    \"from its exit code, along with captured stdout/stderr.\",\n  version: \"0.1.0\",\n  inputSchema: z.object({\n    cwd: z.string().describe(\"Directory to run the command in.\"),\n    cmd: z.string().describe(\"Shell command to run, e.g. 'pnpm test'.\"),\n  }),\n  outputSchema: z.object({\n    passed: z.boolean(),\n    exitCode: z.number().int(),\n    stdout: z.string(),\n    stderr: z.string(),\n  }),\n  mutates: [],\n  approval: \"auto\",\n  riskLevel: 1,\n})\n","import { z } from \"zod\"\nimport { defineTool } from \"@agentproto/tool\"\n\n/**\n * AIP-14 contract: run a one-shot named `scripts.<name>` command from the\n * repo's committed `agentproto.json` inside a worktree, with the\n * `AGENTPROTO_*` context env injected. For long-running services use\n * `worktree.start-service` instead.\n */\nexport const runScriptTool = defineTool({\n  id: \"worktree.run-script\",\n  description:\n    \"Run a declared `scripts.<name>` command (from the base tree's \" +\n    \"agentproto.json) inside `worktreePath`, injecting AGENTPROTO_* env, and \" +\n    \"report pass/fail with captured stdout/stderr. For a `type: \\\"service\\\"` \" +\n    \"script prefer `worktree.start-service`.\",\n  version: \"0.1.0\",\n  inputSchema: z.object({\n    repoRoot: z.string().describe(\"Absolute path to the source git repository root.\"),\n    worktreePath: z.string().describe(\"Absolute path to the worktree to run in.\"),\n    branch: z.string().describe(\"The worktree's branch name (for AGENTPROTO_BRANCH_NAME).\"),\n    script: z.string().describe(\"Name of the script under `scripts` to run.\"),\n    base: z.string().optional().describe(\"Ref whose committed agentproto.json is read. Default 'origin/main'.\"),\n  }),\n  outputSchema: z.object({\n    passed: z.boolean(),\n    exitCode: z.number().int(),\n    stdout: z.string(),\n    stderr: z.string(),\n  }),\n  mutates: [\"fs:write\"],\n  approval: \"auto\",\n  riskLevel: 1,\n})\n","import { z } from \"zod\"\n\n/** Shared shape of a supervised service's status across the service tools. */\nexport const serviceStatusSchema = z.object({\n  name: z.string().describe(\"The declared script name.\"),\n  hostname: z.string().describe(\"The *.localhost host the reverse proxy routes to this service.\"),\n  port: z.number().int().describe(\"The port the service listens on.\"),\n  url: z.string().describe(\"The service's reverse-proxy URL.\"),\n  pid: z.number().int().nullable().describe(\"Child process id while running, else null.\"),\n  status: z.enum([\"running\", \"exited\"]).describe(\"Whether the service process is up.\"),\n  exitCode: z.number().int().nullable().describe(\"Exit code once it has exited, else null.\"),\n  startedAt: z.string().nullable().describe(\"ISO timestamp of the last start, else null.\"),\n})\n\nexport type ServiceStatusOutput = z.infer<typeof serviceStatusSchema>\n","import { z } from \"zod\"\nimport { defineTool } from \"@agentproto/tool\"\nimport { serviceStatusSchema } from \"./service.schema.js\"\n\n/**\n * AIP-14 contract: start a declared `type: \"service\"` script for a worktree.\n * Allocates the service's port (declared port if free, else ephemeral),\n * injects AGENTPROTO_PORT/URL + peer env, and registers its hostname with the\n * reverse proxy. Idempotent per worktree+name.\n */\nexport const startServiceTool = defineTool({\n  id: \"worktree.start-service\",\n  description:\n    \"Start a declared `scripts.<name>` service for a worktree as a supervised \" +\n    \"long-running child process. Allocates a port, injects AGENTPROTO_PORT / \" +\n    \"AGENTPROTO_URL and AGENTPROTO_SERVICE_<PEER>_PORT|URL for siblings, and \" +\n    \"registers a `<script>--<branch>--<repo>.localhost` proxy route.\",\n  version: \"0.1.0\",\n  inputSchema: z.object({\n    repoRoot: z.string().describe(\"Absolute path to the source git repository root.\"),\n    worktreePath: z.string().describe(\"Absolute path to the worktree.\"),\n    branch: z.string().describe(\"The worktree's branch name.\"),\n    script: z.string().describe(\"Name of the `type: \\\"service\\\"` script to start.\"),\n    base: z.string().optional().describe(\"Ref whose committed agentproto.json is read. Default 'origin/main'.\"),\n    proxyPort: z.number().int().min(1).max(65535).optional().describe(\"Reverse-proxy port used to build the service URL.\"),\n  }),\n  outputSchema: serviceStatusSchema,\n  mutates: [\"process:spawn\"],\n  approval: \"auto\",\n  riskLevel: 1,\n})\n","import { z } from \"zod\"\nimport { defineTool } from \"@agentproto/tool\"\n\n/** AIP-14 contract: stop a running supervised service for a worktree. */\nexport const stopServiceTool = defineTool({\n  id: \"worktree.stop-service\",\n  description:\n    \"Stop a supervised service (SIGTERM) for a worktree and drop its reverse-\" +\n    \"proxy route. A no-op (stopped: false) if the service isn't running.\",\n  version: \"0.1.0\",\n  inputSchema: z.object({\n    worktreePath: z.string().describe(\"Absolute path to the worktree.\"),\n    script: z.string().describe(\"Name of the service to stop.\"),\n  }),\n  outputSchema: z.object({\n    stopped: z.boolean().describe(\"Whether a running service was actually stopped.\"),\n  }),\n  mutates: [\"process:spawn\"],\n  approval: \"auto\",\n  riskLevel: 1,\n})\n","import { z } from \"zod\"\nimport { defineTool } from \"@agentproto/tool\"\nimport { serviceStatusSchema } from \"./service.schema.js\"\n\n/**\n * AIP-14 contract: list every declared service for a worktree with its\n * resolved port / proxy URL and current run status. Resolves (allocating\n * ports for) the worktree's services on first call so declared-but-unstarted\n * services still appear.\n */\nexport const listServicesTool = defineTool({\n  id: \"worktree.list-services\",\n  description:\n    \"List the declared services for a worktree — each with its allocated \" +\n    \"port, `*.localhost` proxy URL, and running/exited status.\",\n  version: \"0.1.0\",\n  inputSchema: z.object({\n    repoRoot: z.string().describe(\"Absolute path to the source git repository root.\"),\n    worktreePath: z.string().describe(\"Absolute path to the worktree.\"),\n    branch: z.string().describe(\"The worktree's branch name.\"),\n    base: z.string().optional().describe(\"Ref whose committed agentproto.json is read. Default 'origin/main'.\"),\n    proxyPort: z.number().int().min(1).max(65535).optional().describe(\"Reverse-proxy port used to build service URLs.\"),\n  }),\n  outputSchema: z.object({\n    services: z.array(serviceStatusSchema),\n  }),\n  mutates: [],\n  approval: \"auto\",\n  riskLevel: 0,\n})\n"]}