@webappwiz/arbor 0.0.20 → 0.0.22

package/list.d.ts

@@ -1,10 +1,18 @@
 import { type Logger } from "webappwiz/log";
+import type { Fs } from "webappwiz/system";
 import type { WorktreeService } from "./worktree-service.js";
 export interface ListOptions {
     /** Print the rows as JSON instead of a table. */
     json?: boolean;
+    /**
+     * Add each task's changed and planned files, which is what an agent checks
+     * its own plan against before starting. Off by default: it costs git calls
+     * and a file read per task.
+     */
+    files?: boolean;
 }
-export declare function list({ service, log }: {
+export declare function list({ service, log, fs }: {
     service: WorktreeService;
     log: Logger;
-}, { json }?: ListOptions): Promise<void>;
+    fs: Fs;
+}, { json, files }?: ListOptions): Promise<void>;

package/merge.d.ts

@@ -1,8 +1,10 @@
 import { type Logger } from "webappwiz/log";
-import type { Lock } from "webappwiz/system";
+import type { Fs, Lock } from "webappwiz/system";
 import type { Config } from "./config.js";
 import type { Git } from "./git.js";
+import type { Replies } from "./replies.js";
 import type { Shell } from "./shell.js";
+import { type Todos } from "./todo.js";
 import type { WorktreeService } from "./worktree-service.js";
 /**
  * Lands the current worktree's branch on its base branch, trunk unless the
@@ -11,11 +13,14 @@ import type { WorktreeService } from "./worktree-service.js";
  * `git merge --ff-only`, in whichever worktree has the base checked out.
  * History stays linear.
  */
-export declare function merge({ service, git, lock, shell, config, log, }: {
+export declare function merge({ service, git, lock, shell, config, log, todos, replies, fs, }: {
     service: WorktreeService;
     git: Git;
     lock: Lock;
     shell: Shell;
     config: Config;
     log: Logger;
+    todos: Todos;
+    replies: Replies;
+    fs: Fs;
 }, cwd: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webappwiz/arbor",
-	"version": "0.0.20",
+	"version": "0.0.22",
 	"description": "Runs several AI coding agents on one repository at once, each in its own git worktree",
 	"license": "MIT",
 	"author": "Jared Johnson",
@@ -10,6 +10,9 @@
 		"directory": "packages/arbor"
 	},
 	"type": "module",
+	"imports": {
+		"#dev/*": "./dev/*"
+	},
 	"engines": {
 		"bun": ">=1.3"
 	},
@@ -17,7 +20,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"webappwiz": "^0.0.20",
+		"webappwiz": "^0.0.22",
 		"zod": "^4.4.3"
 	},
 	"main": "./index.js",

package/plan.d.ts

@@ -1,3 +1,102 @@
+/** The plan each task keeps at its worktree root, excluded from git. */
+export declare const PLAN_FILE = "ARBOR.md";
+/**
+ * The paths an `ARBOR.md` says its task will touch: each top-level bullet
+ * under `## Files`, taken as written. Prose around the list is left out, and a
+ * plan with no such section plans nothing.
+ */
+export declare function plannedFiles(text: string): string[];
+/**
+ * One `- [ ] Q9.` item under `## Blocked`: something only a person can do.
+ * The item's line is its subject; lines indented under it are its body, and
+ * `- (a) ...` or `- [a] ...` lines among them are the answers it offers.
+ */
+export interface Question {
+    /** As the plan numbers it, `Q9`: the name a reply goes by. */
+    number: string;
+    /** Checked off, which the agent does once it has acted on the reply. */
+    done: boolean;
+    /** The item's own line, without its checkbox, number or reply. */
+    text: string;
+    /**
+     * The markdown indented under it, dedented, choices left out: detail,
+     * code blocks, `![shot](/abs/path.png)` images. Empty when there is none.
+     */
+    body: string;
+    /** Whatever follows ` → `, or null when nobody has answered yet. */
+    reply: string | null;
+    /**
+     * What a person added once the reply was read, oldest first: each an
+     * indented `→ ` line under the question.
+     */
+    followUps: string[];
+    /**
+     * The answers it offers, in order. Empty for a question answered in words
+     * alone. A reply can always add words to its picks, or answer in words
+     * instead.
+     */
+    choices: Choice[];
+    /**
+     * `one` for `- (a)` choices, at most one of which a reply picks; `any` for
+     * `- [a]` choices, where it picks all that apply. Null without choices.
+     */
+    pick: "one" | "any" | null;
+    /** The keys of the choices the reply picked, in the order offered. */
+    chosen: string[];
+    /** The absolute paths of the images its text and body show. */
+    images: string[];
+}
+/** One answer a question offers: `- (b) Migrate on next login`. */
+export interface Choice {
+    /** The letter it goes by: `b`. */
+    key: string;
+    text: string;
+}
+/**
+ * Every numbered item under `## Blocked`, open or checked off, each with the
+ * indented lines under it. The reply is read off the item's own line: an
+ * answer is one line, written by `arbor reply` or by hand after the arrow.
+ */
+export declare function questions(text: string): Question[];
+/**
+ * How a reply reads in the plan: each pick spelled out, so the agent needs
+ * nothing but the line, then any words after it. `a (Email), c (Push): and
+ * log it`.
+ */
+export declare function replyLine(asked: Question, { choices, text }: {
+    choices?: string[];
+    text: string;
+}): string;
+/**
+ * The plan with `reply` written onto that question's line, in place of any
+ * earlier one, or with no reply there at all when it is null. The checkbox is left alone: checking it off is the agent's
+ * word that it has acted on the answer. Null when the plan has no such
+ * question.
+ */
+export declare function withReply(text: string, number: string, 
+/** Null takes the reply off, leaving the question as it was asked. */
+reply: string | null): string | null;
+/**
+ * The plan with `reply` added under a question already answered, as an
+ * indented `→ ` line after everything else under it, and the question
+ * unchecked: whatever the agent did about the answer, it has more to read.
+ * Null when the plan has no such question.
+ */
+export declare function withFollowUp(text: string, number: string, reply: string): string | null;
+/**
+ * The plan with a new open question at the end of `## Blocked`, the section
+ * made if missing, numbered after the highest there. Returns the plan and
+ * the number it went by.
+ */
+export declare function withQuestion(text: string, subject: string, body?: string): {
+    plan: string;
+    number: string;
+};
+/**
+ * A question's number however a person typed it: `Q9`, `q9`, `9` and `Q9.`
+ * all mean `Q9`. Null for anything that is not a number at all.
+ */
+export declare function questionNumber(raw: string): string | null;
 export interface PlanOptions {
     /** The task name the title is expected to match. */
     task: string;

package/remove.d.ts

@@ -1,4 +1,5 @@
 import { type Logger } from "webappwiz/log";
+import type { Todos } from "./todo.js";
 import type { WorktreeService } from "./worktree-service.js";
 export interface RemoveOptions {
     /** Discard the tree even when another agent holds its lease. */
@@ -11,7 +12,8 @@ export interface RemoveOptions {
  * Throwing a task away and redoing it against current trunk is usually cheaper
  * than a hard rebase, so this is meant to be used freely.
  */
-export declare function remove({ service, log }: {
+export declare function remove({ service, log, todos, }: {
     service: WorktreeService;
     log: Logger;
+    todos: Todos;
 }, task: string, { force }?: RemoveOptions): Promise<void>;

package/replies.d.ts

@@ -0,0 +1,81 @@
+import { type IdProvider } from "webappwiz/id";
+import type { Fs, Lock } from "webappwiz/system";
+import { Attachments } from "./attachments.js";
+import { type Question } from "./plan.js";
+/** How long a person opening a reply holds it before it lapses unsaved. */
+export declare const EDIT_MS: number;
+/**
+ * A reply a person gave that its agent has not read yet. It waits here, out
+ * of the plan, so the agent sees nothing half-written: the agent claims it to
+ * read it, which writes it into the plan and ends any chance to edit it.
+ */
+export interface ReplyState {
+    task: string;
+    /** `Q2`. */
+    question: string;
+    /** The keys of the choices picked. */
+    choices: string[];
+    /** Words, alongside the picks or instead of them. */
+    text: string;
+    /** Absolute paths of the files attached, in `replies/<task>/Q2/`. */
+    files: string[];
+    repliedAt: string;
+    /**
+     * While a person has it open to edit, when that hold lapses; null when
+     * nobody does. An agent reads nothing held, so it never sees a reply
+     * mid-change.
+     */
+    editingUntil: string | null;
+}
+/** One reply waiting to be read, with what can be done to it. */
+export declare class PendingReply {
+    private readonly replies;
+    readonly state: ReplyState;
+    constructor(replies: Replies, state: ReplyState);
+    /** Held by a person right now. */
+    get editing(): boolean;
+    get attachments(): Attachments;
+    /** Holds it for a person to edit, for `EDIT_MS` from now. */
+    hold(): Promise<PendingReply>;
+    release(): Promise<PendingReply>;
+    /** Drops the record. Its files go too unless `keepFiles`, as a claim wants. */
+    remove({ keepFiles }?: {
+        keepFiles?: boolean | undefined;
+    }): Promise<void>;
+}
+/**
+ * Every reply waiting to be read, one JSON file each at
+ * `.git/arbor/replies/<task>/<question>.json`, its files beside it. Removing a
+ * task takes its folder with it.
+ */
+export declare class Replies {
+    readonly dir: string;
+    /** Held across a read and the write it decides, so a claim and an edit never cross. */
+    private readonly lock;
+    private readonly fs;
+    private readonly ids;
+    constructor(dir: string, 
+    /** Held across a read and the write it decides, so a claim and an edit never cross. */
+    lock: Lock, fs: Fs, { ids }?: {
+        ids?: IdProvider;
+    });
+    /** Runs `work` holding the lock every write to a reply goes through. */
+    locked<T>(work: () => Promise<T>): Promise<T>;
+    find(task: string, question: string): Promise<PendingReply | null>;
+    /** A task's waiting replies, by question number. */
+    forTask(task: string): Promise<PendingReply[]>;
+    attachments(task: string, question: string): Attachments;
+    /** Whether `path` is a file some reply holds, and not a way out of here. */
+    owns(path: string): boolean;
+    /** @internal Writes one reply. Rename makes the swap atomic for readers. */
+    save(state: ReplyState): Promise<PendingReply>;
+    /** @internal */
+    delete(task: string, question: string): Promise<void>;
+    private path;
+    private read;
+}
+/**
+ * A reply as its line in the plan reads once claimed: the picks spelled out,
+ * the words, then each file's path, so the line alone is the whole answer.
+ */
+export declare function replyText(asked: Question, reply: ReplyState): string;

package/reply.d.ts

@@ -0,0 +1,102 @@
+import { type Logger } from "webappwiz/log";
+import type { Fs } from "webappwiz/system";
+import type { Attachment } from "./attachments.js";
+import { type Question } from "./plan.js";
+import { type Replies, type ReplyState } from "./replies.js";
+import type { Todos } from "./todo.js";
+import type { WorktreeService } from "./worktree-service.js";
+export type { Attachment } from "./attachments.js";
+/** What answering, and reading an answer, work with. */
+export interface ReplyDeps {
+    service: WorktreeService;
+    fs: Fs;
+    replies: Replies;
+}
+export interface ReplyInput {
+    /** Words, alongside the picks or instead of them. */
+    text: string;
+    /**
+     * The keys of the choices picked (`b`), for a question that offers them:
+     * at most one for a `- (a)` question, any number for a `- [a]` one.
+     */
+    choices?: string[];
+    /** Files of any kind to add. */
+    files?: Attachment[];
+    /**
+     * Which files an earlier reply attached to keep, by path. Absent keeps
+     * none: a new reply replaces the old one whole.
+     */
+    keep?: string[];
+}
+export interface Replied {
+    task: string;
+    /** The question as the plan asks it. */
+    question: Question;
+    /** The reply, waiting for its agent to claim it. */
+    reply: ReplyState;
+}
+/**
+ * Answers one of a task's questions, or follows up one whose answer its agent
+ * has read. The reply waits under `.git/arbor/replies/<task>/` with its files,
+ * not in the plan, and replaces any earlier one there, until the task's agent
+ * claims it with `arbor replies` or `arbor wait --answered`. Until then it can
+ * be changed or withdrawn; after, it is the agent's, and anything more is
+ * another follow-up.
+ *
+ * Refuses a tree whose agent is in a live session. That agent is not reading
+ * its inbox, it is waiting in its chat, which is where the answer belongs.
+ */
+export declare function replyTo(deps: ReplyDeps, task: string, question: string, { text, choices, files, keep }: ReplyInput): Promise<Replied>;
+/**
+ * Takes back a reply its agent has not claimed yet, files and all: the
+ * question waits on a person again.
+ */
+export declare function withdrawReply(deps: ReplyDeps, task: string, question: string): Promise<Replied>;
+/**
+ * Holds a reply for a person editing it, so its agent cannot claim it
+ * half-changed. The hold lapses on its own (`EDIT_MS`) if the person walks
+ * away; saving or `releaseReply` ends it sooner. Refuses one its agent has
+ * already claimed: that is the moment it stops being editable.
+ */
+export declare function holdReply(deps: ReplyDeps, task: string, question: string): Promise<Replied>;
+/** Lets go of a reply a person was editing, leaving it as it was. */
+export declare function releaseReply({ replies }: {
+    replies: Replies;
+}, task: string, question: string): Promise<void>;
+export interface Claimed {
+    task: string;
+    /**
+     * The questions whose replies or follow-ups were claimed, as the plan now
+     * reads them.
+     */
+    claimed: Question[];
+    /** Questions with a reply a person is still editing: not yet readable. */
+    editing: string[];
+    /** Open questions with no reply at all. */
+    unanswered: string[];
+}
+/**
+ * What the task's agent does to read its replies: every one waiting and not
+ * being edited is written into the plan after ` → `, where the agent reads
+ * it, and from then on belongs to the agent. The files stay where they are,
+ * named by path in the line, until the task goes.
+ */
+export declare function claimReplies(deps: ReplyDeps, task: string): Promise<Claimed>;
+/** `arbor replies`: claims the task's replies and prints them. */
+export declare function readReplies(deps: ReplyDeps & {
+    log: Logger;
+}, task: string): Promise<Claimed>;
+/** What claiming found: the replies now in the plan, and what still waits. */
+export declare function claimedListing({ task, claimed, editing, unanswered, }: Claimed): string;
+/** What a person says to approve a review: the task may land. */
+export declare const APPROVED = "Approved: merge it.";
+/** What a person says to a question they would rather not answer here. */
+export declare const SKIP = "Skip this: go ahead without it.";
+/**
+ * Answers a question by setting it aside: it becomes a todo, its images
+ * carried along since the tree they sit in goes when the task does, and the
+ * reply tells the agent to leave it out of this task.
+ */
+export declare function defer(deps: ReplyDeps & {
+    todos: Todos;
+}, task: string, question: string): Promise<Replied>;

package/repository.d.ts

@@ -3,7 +3,9 @@ import { type Fs, type Lock } from "webappwiz/system";
 import type { Config } from "./config.js";
 import { Git } from "./git.js";
 import { Journal } from "./journal.js";
+import { Replies } from "./replies.js";
 import { Shell } from "./shell.js";
+import { Todos } from "./todo.js";
 import { WorktreeService } from "./worktree-service.js";
 /** What a command gets to work with, once there is a repository to work in. */
 export interface Repository {
@@ -13,6 +15,8 @@ export interface Repository {
     lock: Lock;
     shell: Shell;
     journal: Journal;
+    todos: Todos;
+    replies: Replies;
 }
 /**
  * Runs the action against the repository `cwd` sits in, and refuses to run it

package/show.d.ts

@@ -14,6 +14,11 @@ export interface Details {
     removed: number | null;
     age: string | null;
     escalation: string | null;
+    /**
+     * While escalated to be approved, the question that asks for it, `Q4`;
+     * null otherwise.
+     */
+    review: string | null;
     plan: string | null;
     /** How the `ARBOR.md` departs from the shape the skill prescribes. */
     planProblems: string[];

package/snapshot.d.ts

@@ -1,24 +1,35 @@
-import { type Fs } from "webappwiz/system";
-import type { Entry, Journal } from "./journal.js";
+import type { Fs } from "webappwiz/system";
+import { type Inbox } from "./inbox.js";
+import type { Replies } from "./replies.js";
 import { type Details } from "./show.js";
+import type { TodoState, Todos } from "./todo.js";
 import type { WorktreeService } from "./worktree-service.js";
-/** Everything one page shows: `list` and `show` for each task, plus `log`. */
+/**
+ * Everything one page shows: `list` and `show` for each task, every question
+ * each one asked however it stands, and `todo list`.
+ */
 export interface Snapshot {
+    /** The repository's directory name, so a page among many says whose it is. */
+    repo: string;
+    /** Past this age a todo is offered for removal rather than recommended. */
+    todoStalenessMs: number;
+    inbox: Inbox;
+    todos: TodoState[];
     tasks: Details[];
-    entries: Entry[];
 }
 /**
- * Reads the whole repo the way `list`, `show` and `log` do. Takes no lease, so
- * serving a page cannot knock an agent off the tree it is driving.
+ * Reads the whole repo the way the CLI's read commands do. Takes no lease, so
+ * the page can sit open on a live tree without disturbing the agent in it.
  */
-export interface SnapshotOptions {
-    /** What the worktrees are read through; the real filesystem by default. */
-    fs?: Fs;
-}
-export declare function snapshot(service: WorktreeService, journal: Journal, opts?: SnapshotOptions): Promise<Snapshot>;
+export declare function snapshot({ service, todos, replies, fs, }: {
+    service: WorktreeService;
+    todos: Todos;
+    replies: Replies;
+    fs: Fs;
+}): Promise<Snapshot>;
 /**
  * What the page is actually showing, minus the fields that move on their own.
  * `age` ticks every minute, and hashing it would push to every open page for
  * nothing.
  */
-export declare function fingerprint({ tasks, entries }: Snapshot): string;
+export declare function fingerprint({ inbox, todos, tasks }: Snapshot): string;

package/todo.d.ts

@@ -0,0 +1,138 @@
+import { type IdProvider } from "webappwiz/id";
+import { type Logger } from "webappwiz/log";
+import { type Fs, type Lock, type Ps } from "webappwiz/system";
+import { type Attachment, Attachments } from "./attachments.js";
+/** What a todo is on disk: one file apiece, so two agents never rewrite one. */
+export interface TodoState {
+    id: number;
+    text: string;
+    /** The task it came up in, or null when a person added it from the main tree. */
+    from: string | null;
+    createdAt: string;
+    /** The task working on it now, or null while it waits to be picked up. */
+    takenBy: string | null;
+    /** Absolute paths of the files attached, in `todos/<id>/`. */
+    files: string[];
+}
+/** A todo's words and files changed: new ones added, some of the old kept. */
+export interface TodoChange {
+    /** New words; the old ones stay when this is absent. */
+    text?: string;
+    /** Files to add. */
+    files?: Attachment[];
+    /** The paths of the files it has now to keep; absent keeps them all. */
+    keep?: string[];
+}
+/**
+ * Work deferred for later: what an agent notes when something outside its
+ * task comes up, so it can move on instead of growing the task. Kept under the
+ * shared `.git`, so every worktree sees a new one at once, with nothing to
+ * commit and nothing to merge.
+ */
+export declare class Todo {
+    private readonly todos;
+    readonly state: TodoState;
+    constructor(todos: Todos, state: TodoState);
+    get id(): number;
+    get text(): string;
+    get from(): string | null;
+    get takenBy(): string | null;
+    get createdAt(): Date;
+    /** How long it has waited, in milliseconds. */
+    get waited(): number;
+    /** Marks it as the work of `task`, refusing one another task already has. */
+    take(task: string): Promise<Todo>;
+    /** Puts it back on the list, as when the task that took it is removed. */
+    release(): Promise<Todo>;
+    get files(): string[];
+    get attachments(): Attachments;
+    /**
+     * Says what is left to do in other words, or with other files, keeping its
+     * id and history.
+     */
+    update({ text, files, keep }: TodoChange): Promise<Todo>;
+    remove(): Promise<void>;
+}
+/** What `Todos` is stored through; the real filesystem by default. */
+export interface TodosOptions {
+    fs?: Fs;
+    /** Names stored files apart; a test counts. */
+    ids?: IdProvider;
+}
+/** Every todo in the repo, one JSON file each under `.git/arbor/todos`. */
+export declare class Todos {
+    readonly dir: string;
+    /** Held while numbering a new todo, so two agents never share an id. */
+    private readonly lock;
+    private readonly fs;
+    private readonly ids;
+    constructor(dir: string, 
+    /** Held while numbering a new todo, so two agents never share an id. */
+    lock: Lock, opts?: TodosOptions);
+    /** Where a todo's files live, beside its record. */
+    attachments(id: number): Attachments;
+    /** Whether `path` is a file some todo holds, and not a way out of here. */
+    owns(path: string): boolean;
+    add(text: string, from: string | null, files?: Attachment[]): Promise<Todo>;
+    /** Oldest first. A file that will not parse is skipped rather than fatal. */
+    all(): Promise<Todo[]>;
+    find(id: number): Promise<Todo>;
+    /** The todos `task` has taken; what a merge or remove settles. */
+    takenBy(task: string): Promise<Todo[]>;
+    /** @internal Writes one todo. Rename makes the swap atomic for readers. */
+    save(state: TodoState): Promise<Todo>;
+    /** @internal */
+    delete(id: number): Promise<void>;
+    private path;
+    private lastId;
+    private read;
+}
+/** What a finished task should be followed by, and what should just go. */
+export interface Recommendation {
+    /** The todo to pick up next, or null when there is nothing fresh left. */
+    next: Todo | null;
+    /** Todos left waiting so long they probably no longer apply. */
+    stale: Todo[];
+}
+/**
+ * Which todo to take up after `task`: its own first, since whoever just
+ * finished it knows that context best, then the longest waiting. Todos past
+ * `staleness` are never recommended, only offered for removal.
+ */
+export declare function recommend(todos: Todos, task: string | null, staleness: number): Promise<Recommendation>;
+/** The lines `merge` ends with, or none when there is nothing to say. */
+export declare function recommendation({ next, stale }: Recommendation): string[];
+export interface TodoListOptions {
+    /** Print the todos as JSON instead of a table. */
+    json?: boolean;
+}
+export interface TodoFileOptions {
+    /** Files to attach, relative to the current directory or absolute. */
+    files?: string[];
+}
+export declare function todoAdd(deps: {
+    todos: Todos;
+    log: Logger;
+    fs: Fs;
+    ps: Ps;
+}, text: string, from: string | null, { files }?: TodoFileOptions): Promise<Todo>;
+export declare function todoList({ todos, log }: {
+    todos: Todos;
+    log: Logger;
+}, { json }?: TodoListOptions): Promise<void>;
+export interface TodoUpdateOptions extends TodoFileOptions {
+    /** New words; the old ones stay when this is absent or empty. */
+    text?: string;
+    /** Attached files to drop, by path or by the name they were stored under. */
+    removeFiles?: string[];
+}
+export declare function todoUpdate(deps: {
+    todos: Todos;
+    log: Logger;
+    fs: Fs;
+    ps: Ps;
+}, id: number, { text, files, removeFiles }?: TodoUpdateOptions): Promise<Todo>;
+export declare function todoRemove({ todos, log }: {
+    todos: Todos;
+    log: Logger;
+}, id: number): Promise<void>;

package/wait.d.ts

@@ -1,5 +1,7 @@
 import { type Logger } from "webappwiz/log";
+import type { Fs } from "webappwiz/system";
 import { Duration } from "webappwiz/time";
+import type { Replies } from "./replies.js";
 import type { WorktreeService } from "./worktree-service.js";
 /** How long `wait` gives a task before handing the wait back to its caller. */
 export declare const DEFAULT_TIMEOUT: Duration;
@@ -8,6 +10,11 @@ export interface WaitOptions {
     timeout?: Duration;
     /** How long between reads of the record; the default suits a human's patience. */
     poll?: Duration;
+    /**
+     * Wait for the task's open questions to be answered instead of for the task
+     * to stop moving: what an agent that escalated waits on.
+     */
+    answered?: boolean;
 }
 /**
  * Blocks until a task stops moving: merged or removed (both leave the name
@@ -15,8 +22,15 @@ export interface WaitOptions {
  * own work overlaps this one's and would rather rebase onto the result than
  * against it, which is why the timeout is short enough to come back and think
  * again rather than block a session for an afternoon.
+ *
+ * With `answered` it blocks instead until every open question under the
+ * task's `## Blocked` has a reply nobody is still editing, then claims them,
+ * which writes them into the plan, and prints them: the agent that escalated
+ * waits for its human this way, rather than polling its own plan.
  */
-export declare function wait({ service, log }: {
+export declare function wait({ service, log, fs, replies, }: {
     service: WorktreeService;
     log: Logger;
-}, task: string, { timeout, poll }?: WaitOptions): Promise<void>;
+    fs: Fs;
+    replies: Replies;
+}, task: string, { timeout, poll, answered, }?: WaitOptions): Promise<void>;

package/worktree-service.d.ts

@@ -21,6 +21,7 @@ export declare class WorktreeService {
     readonly config: Config;
     private readonly tasksDir;
     private readonly removedDir;
+    private readonly repliesDir;
     private readonly fs;
     readonly ps: Ps;
     constructor(git: Git, config: Config, arborDir: string, opts?: WorktreeServiceOptions);
@@ -31,6 +32,12 @@ export declare class WorktreeService {
     branchFor(task: string): string;
     taskFor(branch: string): string | null;
     recordPath(task: string): string;
+    /**
+     * Where a task's replies wait to be read, and the files attached to them.
+     * Under `.git/arbor` rather than in the worktree, so they are never
+     * committed and every tree can open them, and gone with the task.
+     */
+    repliesPath(task: string): string;
     /** Always answers; the returned worktree's status says what was found. */
     find(task: string): Promise<Worktree>;
     list(): Promise<Worktree[]>;