@webappwiz/arbor 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jared Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,297 @@
+# @webappwiz/arbor
+
+Runs several AI coding agents on one repository at once, each in its own git
+worktree, landing on `main` without pull requests.
+
+```bash
+bunx @webappwiz/arbor <command>
+```
+
+Each agent drives its own landing. It works in a worktree, then calls
+`arbor merge` to get that work onto trunk. If merging fails, the failure comes
+back to that same agent, in the same conversation, which fixes it and calls
+`merge` again. There is no daemon, no queue, no orchestrator.
+
+Two rules make that safe:
+
+1. **arbor never spawns an agent.** Agents exist because a human opened a
+   thread. arbor is a set of deterministic verbs over git and disk: no LLM
+   calls, no knowledge of who is running.
+2. **Agents never run raw git for these operations.** Every state transition
+   goes through an arbor command. Exit codes and stderr are the interface the
+   agent reasons about.
+
+Conflicts between agents are expected, not a process failure. Discarding a task
+and redoing it against current trunk is cheap and often better than a hard
+rebase, and that is what `rm` is for.
+
+## Commands
+
+### `arbor add <task>`
+
+Creates the task: branch `task/<task>`, a worktree at
+`../<repo>-arbor/<task>`, and a state record.
+
+A fresh worktree shares no untracked files with the repo (no `node_modules`,
+no `.env`) which is what `postCheckout` is for.
+
+If the hook fails the worktree stays; fix it and re-run the hook by hand.
+
+Refuses a repo with submodules (`usage`). A worktree gets its own empty
+submodule directories, so every task would have to bootstrap them before
+anything builds, and arbor would rather say so than hand back a tree that does
+not work.
+
+### `arbor claim <task>`
+
+Takes ownership of an existing worktree. **This is the resume entry point**: a
+fresh agent thread picking up dead work starts here.
+
+Prints the worktree path, status, uncommitted changes, and, loudly, any
+half-finished rebase or merge the tree is standing in. Refuses if another agent
+holds the lease. A worktree with no record is rebuilt rather than rejected.
+
+### `arbor merge`
+
+Lands the current worktree's branch on trunk. The core command.
+
+**Never a merge commit.** It rebases onto trunk, runs the `preMerge` gate
+there, and fast-forwards trunk with `git merge --ff-only`. History stays
+linear.
+
+1. Refuses if the worktree is dirty, out of retry budget, or leased elsewhere.
+2. Takes the merge lock, **blocking**, polling every 2s. Blocking is
+   deliberate: telling an agent "busy, try later" invites it to go edit more
+   code in a branch that is supposed to be frozen.
+3. `git rebase <trunk>`, then the `preMerge` gate, **in that order**. A branch that
+   passed before rebasing says nothing about whether it works against current
+   trunk; this is the only defense against semantic conflicts, where both sides
+   merge cleanly and the combination is broken.
+4. Re-checks the lease, then `git checkout <trunk> && git merge --ff-only`.
+5. Discards the task (worktree, branch and record) exactly as `rm`
+   would. The work is on trunk, so the tree has nothing left to hold, and
+   `arbor ls` stays a list of live work rather than a graveyard of landed
+   tasks. The agent's own directory goes with it, so the success message
+   prints the main tree to `cd` back to.
+
+On conflict the rebase is **left in progress**: the agent needs the markers.
+Resolve, `git add`, `git rebase --continue`, `arbor merge` again. When the gate
+fails the branch is reset to where it was and trunk is never touched.
+
+There is deliberately no flag to skip the gate: a repo that wants none
+configures none.
+
+### `arbor rm <task>`
+
+Discards a task: `git worktree remove` plus the branch and the record.
+
+For abandoning work that will never land. A successful `merge` already
+discards its own tree. Use it freely. Warns about commits that never landed,
+but never blocks: throwing work away is the cheap escape hatch, not a last
+resort.
+
+Removal leaves a tombstone in `.git/arbor/removed/` so a second `rm` can say
+`already_removed` rather than `not_found`. The ledger keeps the 50 most recent
+and drops the oldest as new ones arrive, so a long-forgotten task reports
+`not_found` again.
+
+### `arbor ls [--json]`
+
+Every task: name, status, lease (`held`/`stale`/`none`), commits ahead of
+trunk, age. A corrupt record shows as `unknown` instead of taking
+down the listing; a record whose worktree vanished shows as `orphaned`.
+
+### `arbor show <task> [--json]`
+
+One task in full: the row `ls` would print for it, plus the `ARBOR.md`
+its agent keeps at the worktree root and the reason behind an `escalated`
+status.
+
+```
+alpha working
+  branch:    task/alpha
+  worktree:  /src/repo-arbor/alpha
+  lease:     held
+  ahead:     3  +82 -14
+  age:       2h
+
+ARBOR.md
+# alpha
+...
+```
+
+`ls` says a task exists; this says what it is doing. Like `path`, it takes no
+lease, so reading another agent's tree cannot knock it off its own work the way
+`claim` would. A task with no `ARBOR.md` is called out rather than passed over
+in silence: it is the one thing that makes the work resumable.
+
+A `ARBOR.md` that is there gets checked against the shape the agent skill
+prescribes (`# <task>`, `## Goal`, `## Next` with something unchecked in it, a
+`## Blocked` question once escalated), and anything off is printed under it.
+Warnings only, never a refusal: the agent that wrote the file is the one that
+runs `show` on it, and a rough plan still beats none.
+
+### `arbor log [--count 20] [--json]`
+
+The last N things done here (`add`, `claim`, `merge`, `rm`, `escalate`,
+`retry`),
+oldest first, each with the task and how it ended (`ok`, or the refusal reason).
+
+```
+WHEN  ACTION    TASK   RESULT
+2h    add       alpha  ok
+1h    merge     alpha  tests_failed
+1h    merge     alpha  ok
+```
+
+`ls` is what still exists; this is what happened. Entries outlive their tasks:
+a successful `merge` and a `rm` both take the record with them, so this is
+the only thing that remembers a task landed at all. The last 200 are kept
+(`logCapacity`) in `.git/arbor/log.jsonl`.
+
+### `arbor dev [--port 4269]`
+
+`ls`, `show` and `log` in a browser, on `http://localhost:4269`, reloading
+themselves as tasks change. Read-only, and takes no lease.
+
+### `arbor path [task]`
+
+Prints one path and nothing else, so it composes:
+
+```bash
+cd "$(arbor path)"             # back to the main tree, from any worktree
+zed -a "$(arbor path alpha)"   # read a task's work beside your own
+git -C "$(arbor path alpha)" diff main...task/alpha
+```
+
+**This is how a human looks at an agent's work.** Moving between trees is `cd`
+and nothing else. Worktrees are directories, not checkouts, so your main tree
+stays on trunk while agents work and there is no branch to switch, nothing to
+stash, nothing to switch back. Reading a task this way takes no lease, so it
+cannot knock the agent driving it off its own tree the way `claim` would.
+
+With no task it prints the main tree, which is the one path a process standing
+in a worktree cannot otherwise name: git's `--show-toplevel` hands back the
+worktree it is already in.
+
+Refuses a task that does not exist, or one whose directory is gone, rather than
+printing a path you cannot `cd` into.
+
+### `arbor escalate <reason> [--task <name>]`
+
+The explicit "this needs a human" exit. Records the reason, drops the lease, and
+leaves the worktree **exactly** as it is so the human sees what the agent saw.
+
+This exists so an agent has a way out that is not "resolve the conflict badly to
+finish the task". Agents are reliable at mechanical conflicts (both sides added
+imports, a signature changed on one side and its callers on the other) and
+unreliable when both sides restructured the same logic, because then there is no
+correct merge, only a decision.
+
+### `arbor retry <task>`
+
+Grants an escalated task another `mergeRetryCount` merge attempts and puts it
+back to `working`. The way out of `budget_exhausted` that is not `rm` and redo,
+for the case where the task was one fix away rather than genuinely lost.
+
+Only from `escalated`, and that is the whole design. The budget exists to make
+an agent stop and hand the task over; an agent that could grant itself more
+attempts would be back to grinding against a moving trunk forever. So the price
+of a fresh budget is that a human has looked at the tree first.
+
+It takes no lease: whoever picks the task up runs `arbor claim` as usual.
+
+## Exit codes
+
+The agent's control flow runs on these.
+
+| Code | Reason              | Meaning and what to do                                            |
+| ---- | ------------------- | ----------------------------------------------------------------- |
+| 0    | none                | Success.                                                           |
+| 1    | `usage`             | Bad task name, bad flags, a repo arbor does not support, or an unexpected git failure. |
+| 2    | `conflict`          | Rebase conflicted. **Rebase is still in progress.** Resolve, `git add`, `git rebase --continue`, merge again. |
+| 3    | `tests_failed`      | The gate (`postRewrite`, `preMerge`) failed after the rebase. Branch rolled back, trunk untouched. Fix and merge again. |
+| 4    | `lease_lost`        | Another agent took the tree mid-merge. **Stop. Do not retry.**     |
+| 5    | `budget_exhausted`  | Out of merge attempts. `arbor escalate`, and a human can grant another budget with `arbor retry`; or `arbor rm` and redo against current trunk. |
+| 6    | `lease_held`        | Another agent is driving this tree.                                |
+| 7    | `dirty`             | Uncommitted changes. Commit before merging.                       |
+| 8    | `not_found`         | No such task, or not run from a task worktree.                     |
+| 9    | `hook_failed`       | `postCheckout` failed. The worktree still exists; fix and re-run the hook. |
+| 10   | `exists`            | Task already exists. `arbor claim` it, or `arbor rm` first.    |
+| 11   | `orphaned`          | Record with no worktree. `arbor rm` it.                         |
+| 12   | `merge_failed`      | Trunk could not be fast-forwarded (usually a dirty main worktree). |
+| 13   | `already_removed`    | This task was removed earlier; nothing left to remove.              |
+
+Every failure prints a one-line JSON object on **stdout** (`{"reason": ...}`,
+plus fields like `paths` for conflicts) and the human explanation on **stderr**.
+
+## Configuration
+
+`arbor.config.ts` at the repo root, all keys optional. `defineConfig` is an
+identity function that exists for the types:
+
+```ts
+import { defineConfig } from "@webappwiz/arbor/config";
+
+export default defineConfig({
+	trunk: "main",
+	worktreeRoot: "../myrepo-arbor",
+	postCheckout: "bun install && cp ../../myrepo/.env .env",
+	postRewrite: "bun install",     // after each rebase, before preMerge
+	preMerge: "bun test",           // the last gate before the branch lands
+	leaseStalenessMs: 90_000,
+	mergeRetryCount: 2,
+	removedCapacity: 50,            // removed names kept, so rm can say "already removed"
+	logCapacity: 200,               // entries `arbor log` keeps before the oldest fall off
+});
+```
+
+The hooks are named for the git events they sit around: `postCheckout` runs
+once, when `add` checks the worktree out; `postRewrite` runs after every rebase
+`merge` does; `preMerge` runs after that, and is the last thing between the
+branch and the base. They all run through `sh -c` in the worktree with
+`ARBOR_TASK` and `ARBOR_WORKTREE` in the environment.
+
+Every hook is unset by default: arbor has no opinion about what a repo runs, or
+whether it has tests at all. Configure `preMerge` and a nonzero exit rolls the
+branch back and spends an attempt, leaving the base untouched; `postRewrite`
+fails the same gate the same way. Configure neither and a task lands on a clean
+rebase alone.
+
+arbor does not allocate ports. Several worktrees running at once will collide on
+whatever they bind, and the thing that binds (docker-compose, a dev server, a
+test harness) is the only thing able to retry and release. `ARBOR_TASK` is in
+the environment to derive a stable port from if a task needs one.
+
+### Leases and locks
+
+State lives in `.git/arbor/`, shared by every worktree, never tracked by git.
+Records are written to a temp file and `rename()`d into place, so a concurrent
+reader never sees half a file. The merge lock is `mkdir` on
+`.git/arbor/merge.lock`: atomic everywhere, no dependencies, and it either
+succeeds or fails with no check-then-write window. A holder that dies is
+detected (dead pid, or a timestamp past `leaseStalenessMs`) and its lock is
+stolen, loudly.
+
+A lease is **held** when its heartbeat is fresh *and*, for a holder on this
+host, its pid still exists. The pid check matters because every arbor command is
+its own short-lived process: without it, a tree would stay locked for the whole
+staleness window after a command that merely finished, and `add` would block
+the `merge` that follows it.
+
+### `git rerere`
+
+Adding `git config rerere.enabled true` to `postCheckout` is worth it. The cache
+lives in `.git/rr-cache`, which every worktree shares, verified against two
+real worktrees: a conflict resolved in one is replayed automatically in the
+other. Git still leaves the file staged as `UU`, so the agent must confirm with
+`git add` and `git rebase --continue`. Not enabled by default; opt in per repo.
+
+## Retry budget
+
+`mergeAttempts` counts conflicts, failed test runs, and failed fast-forwards. It
+exists because of a real livelock: an agent rebases onto trunk, another agent
+lands during its test run, and it is stale again before it finishes. Under load
+an unlucky agent can chase a moving trunk indefinitely. When the budget is gone,
+escalate or `arbor rm`: redoing the task against current trunk usually beats
+retrofitting a rebase.

package/add.d.ts

@@ -0,0 +1,16 @@
+import { type Logger } from "webappwiz/log";
+import type { Fs } from "webappwiz/system";
+import type { Config } from "./config.js";
+import type { Shell } from "./shell.js";
+import type { WorktreeService } from "./worktree-service.js";
+export interface AddOptions {
+    /** Branch the task starts from and merges onto. Defaults to the trunk. */
+    base?: string;
+}
+export declare function add({ service, shell, config, log, fs, }: {
+    service: WorktreeService;
+    shell: Shell;
+    config: Config;
+    log: Logger;
+    fs: Fs;
+}, task: string, { base }?: AddOptions): Promise<void>;

package/age.d.ts

@@ -0,0 +1,2 @@
+/** How long ago an ISO timestamp was, at the coarsest unit that still reads. */
+export declare function age(since: string): string;

package/arbor.d.ts

@@ -0,0 +1,14 @@
+import { type Deps } from "webappwiz/cmd";
+import type { HttpServer } from "webappwiz/http";
+import type { Fs } from "webappwiz/system";
+import type { Assets } from "./dev/assets.js";
+import { type Repository } from "./repository.js";
+/** Everything `arbor` is run with, before the repository middleware adds to it. */
+export interface ArborDeps extends Deps {
+    fs: Fs;
+    /** Only `dev` listens, but the runtime is picked once, where arbor starts. */
+    http: HttpServer;
+    /** Likewise: only `dev` serves the page, and it is built before it ships. */
+    assets: Assets;
+}
+export declare const arbor: import("webappwiz/cmd").Cli<ArborDeps, ArborDeps & Repository>;

package/claim.d.ts

@@ -0,0 +1,7 @@
+import { type Logger } from "webappwiz/log";
+import type { WorktreeService } from "./worktree-service.js";
+/** The resume entry point: a fresh agent thread picking up existing work. */
+export declare function claim({ service, log }: {
+    service: WorktreeService;
+    log: Logger;
+}, task: string): Promise<void>;

package/config.d.ts

@@ -0,0 +1,43 @@
+export interface Config {
+    /**
+     * The integration branch name. `merge` rebases a task onto this branch and
+     * then fast-forwards it to the result; new worktrees start from it.
+     */
+    trunk: string;
+    /** Directory holding one worktree per task, a sibling of the repo. */
+    worktreeRoot: string;
+    /** Command run by `add` in the new worktree, via `sh -c`. */
+    postCheckout: string | null;
+    /**
+     * Command run by `merge` after the rebase, before `preMerge`, via `sh -c`.
+     * A rebase can bring in a dependency the worktree has never installed, and
+     * whatever `preMerge` runs needs it.
+     */
+    postRewrite: string | null;
+    /**
+     * Command run by `merge` after the rebase, via `sh -c`. The last gate before
+     * the branch lands: a nonzero exit rolls the branch back and leaves the base
+     * untouched. Tests are the obvious thing to put here, but arbor has no
+     * opinion; a repo with nothing to run leaves it null and merges on a green
+     * rebase alone.
+     */
+    preMerge: string | null;
+    /** How long since its last heartbeat before a task's lease is up for grabs. */
+    leaseStalenessMs: number;
+    /** Failed `merge` attempts a task gets before it must escalate or be removed. */
+    mergeRetryCount: number;
+    /**
+     * How many removed task names to keep, so `rm` can say "already removed"
+     * rather than "never existed". A flat cap with no age policy: losing the
+     * oldest costs a nicer message and nothing else.
+     */
+    removedCapacity: number;
+    /** How many entries `arbor log` keeps before the oldest fall off. */
+    logCapacity: number;
+}
+/**
+ * Identity, for the types. `export default defineConfig({ ... })` in
+ * `arbor.config.ts` gets the key names and their types checked, and completion
+ * while writing it; a bare object literal gets neither.
+ */
+export declare function defineConfig(config: Partial<Config>): Partial<Config>;

package/config.js

@@ -0,0 +1,7 @@
+// config.ts
+function defineConfig(config) {
+  return config;
+}
+export {
+  defineConfig
+};

package/dev/assets.d.ts

@@ -0,0 +1,17 @@
+/** The three files the browser asks for, as the server hands them over. */
+export interface Assets {
+    /** The page, which asks for the other two. */
+    shell: string;
+    /** The React app, bundled for the browser. */
+    script: string;
+    /** The stylesheet, with Tailwind already compiled. */
+    styles: string;
+}
+/**
+ * The page this package ships, built by `build.ts` and imported here as text so
+ * it travels inside the bundle a release publishes. Serving it costs a string
+ * lookup, and nothing is read off disk: a published package has no `dev/`
+ * directory to read from, and the CLI's own dependencies stay clear of React
+ * and Tailwind because neither is needed once the page is built.
+ */
+export declare const assets: Assets;

package/dev.d.ts

@@ -0,0 +1,31 @@
+import type { HttpServer } from "webappwiz/http";
+import type { Logger } from "webappwiz/log";
+import type { Fs } from "webappwiz/system";
+import type { Assets } from "./dev/assets.js";
+import type { Journal } from "./journal.js";
+import type { WorktreeService } from "./worktree-service.js";
+export declare const DEFAULT_PORT = 4269;
+/** A running server, and the one thing a caller ever wants to do with it. */
+export interface DevServer {
+    port: number;
+    stop(): Promise<void>;
+}
+/**
+ * Serves what `ls`, `show` and `log` print, as one page that refetches when the
+ * repo changes. Read-only on purpose: driving arbor is what the CLI is for, and
+ * a button that took a lease would fight the agent holding it.
+ *
+ * The page itself is a React app under `dev/`, built before publishing and
+ * carried in the bundle, so nothing here builds markup and nothing reads it
+ * off disk.
+ */
+export declare function dev({ service, fs, journal, log, http, assets, }: {
+    service: WorktreeService;
+    fs: Fs;
+    journal: Journal;
+    log: Logger;
+    http: HttpServer;
+    assets: Assets;
+}, { port }?: {
+    port?: number | undefined;
+}): Promise<DevServer>;

package/escalate.d.ts

@@ -0,0 +1,15 @@
+import { type Logger } from "webappwiz/log";
+import type { Lock } from "webappwiz/system";
+import type { Git } from "./git.js";
+import type { WorktreeService } from "./worktree-service.js";
+/**
+ * The way out that is not "resolve the conflict badly to finish the task".
+ * When both sides restructured the same logic there is no correct merge, only
+ * a decision, and that belongs to a human.
+ */
+export declare function escalate({ service, git, lock, log, }: {
+    service: WorktreeService;
+    git: Git;
+    lock: Lock;
+    log: Logger;
+}, reason: string, cwd: string, task?: string): Promise<void>;

package/exit.d.ts

@@ -0,0 +1,40 @@
+import type { Deps, Middleware } from "webappwiz/cmd";
+/** Exit codes are the API: an agent branches on these, not on prose. */
+export declare const EXIT: {
+    readonly usage: 1;
+    readonly conflict: 2;
+    readonly tests_failed: 3;
+    readonly lease_lost: 4;
+    readonly budget_exhausted: 5;
+    readonly lease_held: 6;
+    readonly dirty: 7;
+    readonly not_found: 8;
+    readonly hook_failed: 9;
+    readonly exists: 10;
+    readonly orphaned: 11;
+    readonly merge_failed: 12;
+    readonly already_removed: 13;
+};
+export type Reason = keyof typeof EXIT;
+/**
+ * A refusal, carrying the reason to branch on, a message to show, and any
+ * data worth reporting with it. `exits` turns one into output and a status
+ * code.
+ */
+export declare class Exit extends Error {
+    readonly reason: Reason;
+    readonly data: Record<string, unknown>;
+    constructor(reason: Reason, message: string, data?: Record<string, unknown>);
+}
+/**
+ * How a command refuses. Every call site means "and go no further", which is
+ * what the `never` return buys: the code below a `fail` is unreachable, and
+ * TypeScript narrows accordingly.
+ */
+export declare function fail(reason: Reason, message: string, data?: Record<string, unknown>): never;
+/**
+ * Decides what a refusal looks like (a machine-readable reason on stdout, a
+ * human explanation on stderr) and is the only place that ends the process.
+ * An agent branches on the first and reads the second.
+ */
+export declare function exits<C extends Deps>(): Middleware<C>;

package/git.d.ts

@@ -0,0 +1,54 @@
+import { type Fs, type Ps } from "webappwiz/system";
+export interface GitResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+/**
+ * Every git call arbor makes, scoped to one repository. Agents are not allowed
+ * to run these themselves, since going through arbor is what makes concurrent
+ * work safe, so this is the only place git is spoken.
+ */
+/** What a `Git` works through; the real ones by default. */
+export interface GitOptions {
+    ps?: Ps;
+    fs?: Fs;
+}
+export declare class Git {
+    /** The main worktree, where trunk lives. */
+    readonly root: string;
+    private readonly ps;
+    private readonly fs;
+    constructor(
+    /** The main worktree, where trunk lives. */
+    root: string, opts?: GitOptions);
+    run(cwd: string, ...args: string[]): Promise<GitResult>;
+    out(cwd: string, ...args: string[]): Promise<string>;
+    branchExists(branch: string): Promise<boolean>;
+    currentBranch(cwd: string): Promise<string>;
+    head(cwd: string): Promise<string>;
+    shortHead(cwd: string): Promise<string>;
+    porcelain(cwd: string): Promise<string[]>;
+    conflictedPaths(cwd: string): Promise<string[]>;
+    commitsAhead(trunk: string, branch: string): Promise<number | null>;
+    /** Lines added and removed on `branch` since it left `trunk`. */
+    diffStat(trunk: string, branch: string): Promise<{
+        added: number;
+        removed: number;
+    } | null>;
+    rebase(cwd: string, onto: string): Promise<GitResult>;
+    resetHard(cwd: string, commit: string): Promise<GitResult>;
+    checkout(branch: string): Promise<GitResult>;
+    mergeFfOnly(branch: string): Promise<GitResult>;
+    addWorktree(branch: string, path: string, from: string): Promise<GitResult>;
+    removeWorktree(path: string): Promise<GitResult>;
+    /** Drops metadata for worktrees whose directories are gone. */
+    pruneWorktrees(): Promise<GitResult>;
+    deleteBranch(branch: string): Promise<GitResult>;
+    /** The one `.git` every worktree of this repo shares. */
+    commonDir(): Promise<string>;
+    /** The git directory belonging to a worktree, or null if it has none. */
+    worktreeGitDir(worktree: string): Promise<string | null>;
+    /** Half-finished merges and rebases a resuming agent is standing in. */
+    interruptedOps(worktree: string): Promise<string[]>;
+}

package/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};