@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/storage/sqlite-document.d.ts

@@ -0,0 +1,20 @@
+import type { Lock } from "../../../core/system/index.js";
+import type { Document } from "./document";
+import type { Schema } from "./schema";
+import type { SqliteDb } from "./sqlite-db";
+/** A document kept as one row, replaced whole on each write. */
+export declare class SqliteDocument<T> implements Document<T> {
+    readonly key: string;
+    /** The key in the whole database, which a view's `key` is relative to. */
+    readonly at: string;
+    private readonly db;
+    private readonly lock;
+    private readonly schema?;
+    constructor(key: string, 
+    /** The key in the whole database, which a view's `key` is relative to. */
+    at: string, db: SqliteDb, lock: Lock, schema?: Schema<T> | undefined);
+    read(): Promise<T | null>;
+    write(value: T): Promise<void>;
+    update(edit: (current: T | null) => T | Promise<T>): Promise<T>;
+    remove(): Promise<void>;
+}

package/vendor/@stringsync/splates-server/storage/sqlite-import.d.ts

@@ -0,0 +1,11 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { SqliteDb } from "./sqlite-db";
+/**
+ * Copies every file under `dir` into the database under `root`, each as the
+ * kind of thing its name says: a `.jsonl` file as a log, one line an entry,
+ * a `.jsonl` file in `log/` or a `<log>.segments/` directory as a segment of
+ * that log, any other as a record or blob. Leaves out locks, stamps and
+ * temporary files, which name the disk. Run again over what it copied, it
+ * replaces it.
+ */
+export declare function importTree(db: SqliteDb, fs: Fs, dir: string, root: string): Promise<void>;

package/vendor/@stringsync/splates-server/storage/sqlite-keys.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The bounds on a `key` column of everything under `prefix`, a key with no
+ * trailing `/`, for a `BETWEEN`-shaped range an index can serve: `lo` is
+ * `prefix/`, and `hi` the first key past it, or null under the root, where
+ * nothing is past.
+ */
+export declare function under(prefix: string): {
+    lo: string;
+    hi: string | null;
+};
+/** SQL for `col` in the range `under` gives, bound as `lo, hi, hi`. */
+export declare function inRange(col: string): string;
+/** The parameters `inRange` binds. */
+export declare function rangeParams(prefix: string): [string, string | null, string | null];
+/** The text of `data`, which a document or a record keeps as UTF-8. */
+export declare function decode(data: Uint8Array): string;
+export declare function encode(text: string): Uint8Array;

package/vendor/@stringsync/splates-server/storage/sqlite-lock.d.ts

@@ -0,0 +1,25 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Lock, Ps } from "../../../core/system/index.js";
+import type { SqliteDb } from "./sqlite-db";
+/**
+ * A mutex between the processes on this machine that share a database:
+ * `acquire` waits until no live process holds it, taking it from one that
+ * died, and `release` gives it up.
+ */
+export declare class SqliteLock implements Lock {
+    readonly key: string;
+    private readonly deps;
+    constructor(key: string, deps: {
+        db: SqliteDb;
+        ps: Ps;
+        log?: Logger;
+        pollMs?: number;
+    });
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    releaseIfOurs(): Promise<void>;
+    private holder;
+    /** Removes `holder`'s row, and not one another took since it was read. */
+    private drop;
+    private isStale;
+}

package/vendor/@stringsync/splates-server/storage/sqlite-log.d.ts

@@ -0,0 +1,31 @@
+import type { Log, Segment } from "./log";
+import type { Schema } from "./schema";
+import type { SqliteDb } from "./sqlite-db";
+/** A log kept in a `SqliteStorage`, as `SqliteStorage.log` opens one. */
+export declare class SqliteLog<T> implements Log<T> {
+    readonly key: string;
+    /** The log's key in the whole database. */
+    readonly at: string;
+    /** The key its segments are kept under. */
+    readonly segmentsAt: string;
+    private readonly db;
+    private readonly schema?;
+    constructor(key: string, 
+    /** The log's key in the whole database. */
+    at: string, 
+    /** The key its segments are kept under. */
+    segmentsAt: string, db: SqliteDb, schema?: Schema<T> | undefined);
+    exists(): Promise<boolean>;
+    append(...entries: T[]): Promise<void>;
+    replay(): Promise<T[]>;
+    first(): Promise<T | null>;
+    compact(merge: (entries: T[]) => T[]): Promise<void>;
+    rotate(): Promise<Segment | null>;
+    segments(): Promise<Segment[]>;
+    replaySegment(segment: Segment): Promise<T[]>;
+    dropSegment(segment: Segment): Promise<void>;
+    remove(): Promise<void>;
+    private segmentKey;
+    /** The entries `where` picks, oldest first, as the lines of a file. */
+    private lines;
+}

package/vendor/@stringsync/splates-server/storage/sqlite.d.ts

@@ -0,0 +1,53 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Lock, Ps } from "../../../core/system/index.js";
+import type { Timer } from "../../../core/time/index.js";
+import type { Collection } from "./collection";
+import type { Document, DocumentOptions } from "./document";
+import type { Log, LogOptions } from "./log";
+import type { Kept, Storage, Watch, WatchOptions } from "./storage";
+export interface SqliteStorageOptions {
+    fs: Fs;
+    ps: Ps;
+    log?: Logger;
+    timer?: Timer;
+    /** How often a watch looks for another process's writes, and a waiter for a lock's release. */
+    pollMs?: number;
+    /**
+     * Where `materialize` writes a copy for an agent to read as a file:
+     * `<path>.files` by default.
+     */
+    cache?: string;
+}
+/**
+ * Storage kept in one SQLite database at `path`, which every process on the
+ * machine opens; what an agent must read as a file is copied out beside it.
+ * Dispose the storage opened to close the database; a view `within` shares it.
+ */
+export declare class SqliteStorage implements Storage, Resource {
+    readonly root: string;
+    private readonly shared;
+    static open(path: string, opts: SqliteStorageOptions): SqliteStorage;
+    private constructor();
+    document<T>(key: string, opts?: DocumentOptions<T>): Document<T>;
+    log<T>(key: string, opts?: LogOptions<T>): Log<T>;
+    collection(key: string): Collection;
+    lock(key: string): Lock;
+    watch(key: string, opts?: WatchOptions): Watch;
+    locate(key: string): string;
+    materialize(key: string): Promise<string>;
+    children(key: string): Promise<string[]>;
+    size(key: string): Promise<number>;
+    keys(key: string): Promise<string[]>;
+    copy(key: string, from?: number): Promise<Kept | null>;
+    remove(key: string): Promise<void>;
+    /**
+     * Copies the files under `dir` on `fs` in, each at its path as a key, as
+     * a log, a record or a blob by its name: what moves records kept as files
+     * into the database. Leaves locks and stamps behind.
+     */
+    importFiles(fs: Fs, dir: string): Promise<void>;
+    within(key: string): Storage;
+    dispose(): void;
+    private full;
+}

package/vendor/@stringsync/splates-server/storage/storage.d.ts

@@ -0,0 +1,87 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Eventful } from "../../../core/events/index.js";
+import type { Lock } from "../../../core/system/index.js";
+import type { Collection } from "./collection";
+import type { Document, DocumentOptions } from "./document";
+import type { Log, LogOptions } from "./log";
+/**
+ * Where splates keeps its state, as a few kinds of thing rather than files,
+ * so a database or a cloud store can stand in for the disk. Every key is a
+ * `/`-separated path relative to the storage, extension included, so the
+ * file-system one keeps each thing in the file a store kept it in before.
+ */
+export interface Storage {
+    /** One whole value, read and written at once. */
+    document<T>(key: string, opts?: DocumentOptions<T>): Document<T>;
+    /** Entries only ever added to, read back in the order they came. */
+    log<T>(key: string, opts?: LogOptions<T>): Log<T>;
+    /** Records and blobs kept by name, as a store of one per task keeps them. */
+    collection(key: string): Collection;
+    /**
+     * The mutex every holder of `key` shares, across processes and, on a
+     * worker, across machines.
+     */
+    lock(key: string): Lock;
+    /**
+     * Tells of each change at `key` or directly under it, as a write or a
+     * removal, until disposed. Throws when the storage cannot watch `key`, as
+     * the disk cannot a directory not yet made, so callers can say what they
+     * will miss.
+     */
+    watch(key: string, opts?: WatchOptions): Watch;
+    /**
+     * The path `key` can be opened at as a file, which is what an agent is
+     * handed to read an attachment; a storage with no files gives a path no
+     * file is at.
+     */
+    locate(key: string): string;
+    /**
+     * A path on this machine where what is kept at `key`, a record, a blob or
+     * a log, opens as a file, for an agent to read: where the disk keeps it,
+     * or a copy a storage with no files writes to a local cache first.
+     */
+    materialize(key: string): Promise<string>;
+    /** The names directly under `key` that hold more keys of their own, sorted. */
+    children(key: string): Promise<string[]>;
+    /** The bytes everything under `key`, nested keys included, takes. */
+    size(key: string): Promise<number>;
+    /**
+     * Every key under `key`, nested ones included, that holds something
+     * itself: a document, a record or blob, or a log or one of its segments.
+     * Sorted, relative to the storage, and never a lock.
+     */
+    keys(key: string): Promise<string[]>;
+    /**
+     * What `key` holds itself, as a copy kept elsewhere needs it: a value's
+     * bytes, or a log's whole lines after the first `from`, with how many it
+     * has. Null when it holds nothing.
+     */
+    copy(key: string, from?: number): Promise<Kept | null>;
+    /** Removes everything under `key`, nested keys included; nothing there is no error. */
+    remove(key: string): Promise<void>;
+    /** The storage under `key`, which its own keys are relative to. */
+    within(key: string): Storage;
+}
+/** What `Storage.copy` reads at a key. */
+export type Kept = {
+    kind: "value";
+    bytes: Uint8Array;
+} | {
+    kind: "log";
+    /** The lines after the ones skipped, each without its newline. */
+    lines: string[];
+    /** How many lines the log has, those skipped included. */
+    count: number;
+};
+export interface WatchOptions {
+    /** Everything under `key` too, rather than what is directly under it. */
+    recursive?: boolean;
+}
+/** What `Storage.watch` tells of. */
+export interface StorageChanges extends Record<string, unknown> {
+    /** The key that changed, relative to the storage watched. */
+    changed: string;
+}
+/** A watch on a storage's keys, which stops once disposed. */
+export interface Watch extends Eventful<StorageChanges>, Resource {
+}

package/vendor/@stringsync/splates-server/table.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Columns padded to their widest cell. Padding goes by visible width, not
+ * string length: cells carry color codes.
+ */
+export declare function table(header: string[], rows: string[][]): string;

package/vendor/@stringsync/splates-server/tasks/add.d.ts

@@ -0,0 +1,45 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Fs } from "../../../core/system/index.js";
+import type { Tasks } from "../board";
+import type { Config } from "../config";
+import { type RosterAgent } from "../models";
+import type { Shell } from "../terminal";
+import type { Dispatched } from "./worktree";
+import { type WorktreeService } from "./worktree-service";
+export interface AddOptions {
+    /** Branch the task starts from and merges onto. Defaults to the trunk. */
+    base?: string;
+    /**
+     * The queued task this task starts, as a list of one: its words seed the
+     * plan's Goal, and nobody else can take it while the task lives.
+     */
+    tasks?: number[];
+    /**
+     * One or two lines on what done means, written under `## Goal` ahead of
+     * whatever the queued tasks seed it with.
+     */
+    goal?: string;
+    /**
+     * Runs once the worktree exists and before its record makes the task live,
+     * so whatever it tells of the task is in place before anyone can see it.
+     */
+    onTree?: () => Promise<void>;
+    /**
+     * The agent `splates server`'s queue hands the task to, which it starts in
+     * the task's tree once the tree is ready; its id must be one of `agents`.
+     * Never from an agent, which starts no agents.
+     */
+    dispatch?: Dispatched;
+    /** The roster's agents, which `dispatch` must name one of, and its model. */
+    agents?: RosterAgent[];
+    /** Added from another project, as `splates --project` does, which is refused. */
+    away?: boolean;
+}
+export declare function add({ service, shell, config, log, fs, tasks: queue, }: {
+    service: WorktreeService;
+    shell: Shell;
+    config: Config;
+    log: Logger;
+    fs: Fs;
+    tasks: Tasks;
+}, task: string, { base, tasks: ids, goal: asked, onTree, dispatch, agents, away, }?: AddOptions): Promise<void>;

package/vendor/@stringsync/splates-server/tasks/browser.d.ts

@@ -0,0 +1,5 @@
+export { editLines } from "./diff";
+export type { Editor } from "./editors";
+export { EDITORS, ZED } from "./editors";
+export type { MergeFailure, MergeStep, RemoveReason } from "./worktree";
+export { MERGE_STEPS, REMOVE_REASONS } from "./worktree";

package/vendor/@stringsync/splates-server/tasks/checkpoint.d.ts

@@ -0,0 +1,39 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Git } from "../git";
+import { type Pushed, type TaskBranches } from "../merge";
+import type { Worktree } from "./worktree";
+import type { WorktreeService } from "./worktree-service";
+/** The message of the commit a checkpoint saves uncommitted work in. */
+export declare const WIP_MESSAGE = "WIP: checkpoint";
+/** What a checkpoint did. */
+export interface Checkpointed {
+    task: string;
+    /** Whether it committed work that was uncommitted. */
+    committed: boolean;
+    /** Whether the remote has the branch as it now stands. */
+    pushed: boolean;
+}
+/**
+ * Saves the task `cwd` is a worktree of to the central remote, as before a
+ * restart: commits what is uncommitted as a WIP commit, which the agent
+ * squashes before merging, then pushes the branch, so a worker that dies
+ * now loses nothing. Mid-rebase it commits nothing, and pushes the branch
+ * as it stood before the rebase. With no remote configured, this tree is
+ * the only copy, so it leaves it as it is.
+ */
+export declare function checkpoint({ service, git, log, branches, }: {
+    service: WorktreeService;
+    git: Git;
+    log: Logger;
+    branches: TaskBranches;
+}, cwd: string): Promise<Checkpointed>;
+/**
+ * Commits what `tree` holds uncommitted as a WIP commit, unless a rebase or
+ * the like is under way, then pushes its branch as `splates/<task>`: through
+ * the tree's own git, so a clone on a worker is saved there. Throws when
+ * the commit fails.
+ */
+export declare function save(tree: Pick<Worktree, "task" | "branch" | "path" | "git">, branches: TaskBranches): Promise<{
+    committed: boolean;
+    pushed: Pushed;
+}>;

package/vendor/@stringsync/splates-server/tasks/claim.d.ts

@@ -0,0 +1,14 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Fs } from "../../../core/system/index.js";
+import type { WorktreeService } from "./worktree-service";
+/**
+ * The resume entry point: a fresh agent thread picking up existing work. Its
+ * merge budget stays as it was, which only `retry` refills.
+ */
+export declare function claim({ service, log, fs, }: {
+    service: WorktreeService;
+    log: Logger;
+    fs: Fs;
+}, task: string): Promise<{
+    goal: string;
+}>;

package/vendor/@stringsync/splates-server/tasks/conflicts.d.ts

@@ -0,0 +1,19 @@
+import type { Storage } from "../storage";
+import type { Worktree } from "./worktree";
+/** A prediction for committed tips, never an operation on an agent's tree. */
+export interface ComingConflict {
+    base: string;
+    tip: string;
+    files: string[];
+}
+/** Keeps predictions separately so background checks cannot overwrite a lease. */
+export declare class ConflictChecks {
+    private readonly storage;
+    constructor(storage: Storage);
+    read(task: string): Promise<ComingConflict | null>;
+    /** Checks each pair of tips once, including across server restarts. */
+    check(worktree: Worktree): Promise<{
+        conflict: ComingConflict;
+        fresh: boolean;
+    } | null>;
+}

package/vendor/@stringsync/splates-server/tasks/diff.d.ts

@@ -0,0 +1,29 @@
+/** A line of a diff, as assistant-ui's `CodeDiff` draws one. */
+export interface DiffLine {
+    kind: "context" | "added" | "removed";
+    text: string;
+}
+/** A run of changed lines and the context around them. */
+export interface Hunk {
+    /** Where it is, as git heads it: `@@ -10,6 +10,8 @@`. */
+    range: string;
+    lines: DiffLine[];
+}
+/** One file's changes. */
+export interface FileDiff {
+    path: string;
+    /** Where it was, for a file that moved; null otherwise. */
+    from: string | null;
+    status: "added" | "deleted" | "renamed" | "modified";
+    added: number;
+    removed: number;
+    /** Git says only that it differs, with no lines to show. */
+    binary: boolean;
+    /** Some of it is not committed yet. */
+    uncommitted: boolean;
+    hunks: Hunk[];
+}
+/** `git diff` output as files, hunks and lines. */
+export declare function parseDiff(text: string): FileDiff[];
+/** An edit as lines: what it took out, then what it put in. */
+export declare function editLines(old: string | null, now: string): DiffLine[];

package/vendor/@stringsync/splates-server/tasks/dispatched.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from "../../../core/log/index.js";
+import { type Conversations } from "../conversations";
+import type { WorktreeService } from "./worktree-service";
+/**
+ * Starts the agent of each task `splates server`'s queue handed to one and
+ * that has none yet, in the task's tree, on the model and thinking level
+ * asked for, told to claim it: in the conversation the queue held for it,
+ * when there is one. Safe to call again: a task is started once, as long
+ * as no two runs overlap. Answers once each is started, not told.
+ */
+export declare function startDispatched({ service, conversations, log, }: {
+    service: WorktreeService;
+    conversations: Conversations;
+    log: Logger;
+}): Promise<void>;

package/vendor/@stringsync/splates-server/tasks/editors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The editors a file the page names opens in: the link the browser hands it,
+ * and the command `dev` runs on this machine to open the file inside the
+ * tree it belongs to, which a link cannot say.
+ */
+export interface Editor {
+    id: string;
+    /** What the Settings dialog calls it. */
+    label: string;
+    /** The scheme of its `<scheme>://file/<path>:<line>` links. */
+    scheme: string;
+    /**
+     * The command that opens `tree` as its window and `file` in it, at `line`
+     * when there is one; the window alone when `file` is the tree.
+     */
+    argv(tree: string, file: string, line: number | null): string[];
+}
+export declare const ZED: Editor;
+/** Every editor, in the order the Settings dialog offers them. */
+export declare const EDITORS: readonly [Editor, Editor, Editor];
+/** The editor `id` names, or null for one this splates does not know. */
+export declare function editorOf(id: string): Editor | null;

package/vendor/@stringsync/splates-server/tasks/finished.d.ts

@@ -0,0 +1,81 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { Storage } from "../storage";
+import type { RemoveReason } from "./worktree";
+/** A task that merged or was removed, as `Finished` keeps it to look back on. */
+export interface FinishedTask {
+    /** What names it among the finished, apart from a later finish of the same number. */
+    key: string;
+    /** Its number, which a queued task it was started from goes on holding. */
+    id: number;
+    task: string;
+    /** The first line of its Goal, or of what it was queued as when it had none. */
+    subject: string;
+    ended: "merged" | "removed";
+    /** Why it was removed, when it was and one was given. */
+    reason: RemoveReason | null;
+    base: string;
+    /** The commit it landed as, for one that merged. */
+    commit: string | null;
+    startedAt: string;
+    endedAt: string;
+    /** The `splates server` conversation that worked it, or null for none. */
+    conversation: string | null;
+    /** The queued tasks it took up, which left the queue with it or went back. */
+    took: {
+        id: number;
+        subject: string;
+    }[];
+    /** Whether the plan it ended on has a `## Demo` saying how to show it. */
+    hasDemo: boolean;
+}
+/** A finished task with the `SPLATES.md` it ended on, "" when it had none. */
+export interface FinishedPlan extends FinishedTask {
+    plan: string;
+}
+/**
+ * Every task that has finished in a repo, newest kept, in
+ * `.git/splates/finished/<key>.md`: its facts as front matter and the
+ * `SPLATES.md` it ended on as the body, so the page can show what it did
+ * once its tree and record are gone. The attached files that plan shows are
+ * copied into `.git/splates/finished/<key>/` and the plan pointed at them,
+ * so its screenshots outlive the conversation or task that held them.
+ */
+export declare class Finished {
+    /** The project's, holding `finished/`. */
+    private readonly storage;
+    /** Reads the attached files a plan names, which are named by absolute path. */
+    private readonly fs;
+    /** How many it keeps, the oldest going first. */
+    private readonly capacity;
+    private readonly records;
+    /** Where the kept records can be opened. */
+    readonly dir: string;
+    constructor(
+    /** The project's, holding `finished/`. */
+    storage: Storage, 
+    /** Reads the attached files a plan names, which are named by absolute path. */
+    fs: Fs, 
+    /** How many it keeps, the oldest going first. */
+    capacity: number);
+    /**
+     * Keeps `finished`, with a copy of each file its plan names that
+     * `attached` says is one a task held, the plan rewritten to name the copy.
+     */
+    record(finished: Omit<FinishedPlan, "key" | "hasDemo">, attached?: (path: string) => boolean): Promise<void>;
+    /**
+     * Whether `path` is a file kept with a finished task, one level inside
+     * its `<key>/`, and not a way out of here.
+     */
+    owns(path: string): boolean;
+    /**
+     * `plan` naming copies, kept under `key`, of the attached files it named,
+     * which go on to show once their conversation or task is gone. A file
+     * that can no longer be read is left named as it was.
+     */
+    private keep;
+    private filesKey;
+    /** Every one kept, the latest to finish first, without its plan. */
+    list(): Promise<FinishedTask[]>;
+    /** The one kept as `key`, with its plan, or null for none. */
+    read(key: string): Promise<FinishedPlan | null>;
+}

package/vendor/@stringsync/splates-server/tasks/follow.d.ts

@@ -0,0 +1,48 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { Git } from "../git";
+import type { Projects } from "../projects";
+/**
+ * How long a server is waited on before it counts as unreachable: one that
+ * stalled would otherwise hold the task command for fetch's own five minutes.
+ */
+export declare const SERVER_WAIT_MS = 30000;
+/** What `fetch` is used for here, so a test can stand in for it. */
+type Send = (url: string, init: RequestInit) => Promise<Response>;
+/**
+ * Tells `splates server` that the agent in a conversation took or left a task, so
+ * the conversation follows it into that worktree, or back to the main tree.
+ * An agent started from the page runs with its conversation and the server
+ * in its env; any other `splates` has neither, and says nothing. A server that
+ * cannot be reached is worth a line, never a failure: the task command has
+ * done its work.
+ */
+export declare function follow({ ps, fs, log, send }: {
+    ps: Ps;
+    fs?: Fs;
+    log: Logger;
+    send?: Send;
+}, task: string | null, { from, base, }?: {
+    /** The task being left; given, the conversation moves only out of it. */
+    from?: string;
+    /**
+     * The branch `task` lands on, for an add to send before the task's
+     * record names it, so the server can tell a part from a task to follow.
+     */
+    base?: string;
+}): Promise<void>;
+/**
+ * Asks `splates server` to serve the project `git` is in, so the agent a task
+ * there was just handed to from another project starts: the server opens a
+ * project only once something asks for it. Outside `splates server` it says
+ * nothing; a server that cannot be reached is worth a line.
+ */
+export declare function serveProject({ ps, fs, log, git, projects, send, }: {
+    ps: Ps;
+    fs?: Fs;
+    log: Logger;
+    git: Git;
+    projects: Projects;
+    send?: Send;
+}): Promise<void>;
+export {};

package/vendor/@stringsync/splates-server/tasks/index.d.ts

@@ -0,0 +1,30 @@
+export { add } from "./add";
+export { checkpoint, save, WIP_MESSAGE } from "./checkpoint";
+export { claim } from "./claim";
+export type { ComingConflict } from "./conflicts";
+export { ConflictChecks } from "./conflicts";
+export type { FileDiff } from "./diff";
+export { editLines } from "./diff";
+export { startDispatched } from "./dispatched";
+export type { Editor } from "./editors";
+export { EDITORS, ZED } from "./editors";
+export type { FinishedPlan, FinishedTask } from "./finished";
+export { Finished } from "./finished";
+export { follow, SERVER_WAIT_MS, serveProject } from "./follow";
+export type { Landing } from "./landings";
+export { landingNotice, landingsOverlapping } from "./landings";
+export { list } from "./list";
+export { overlapWarnings, TaskOverlaps } from "./overlaps";
+export { path } from "./path";
+export { recommend, recommendation } from "./recommend";
+export { remove } from "./remove";
+export { recordRetry, retry } from "./retry";
+export { TaskRoutes } from "./routes";
+export type { Details } from "./show";
+export { show, TaskDetails } from "./show";
+export type { Snapshot } from "./snapshot";
+export { fingerprint, snapshot, tasksOf } from "./snapshot";
+export { asking, DEFAULT_TIMEOUT, taskWait, untilAfter, wait } from "./wait";
+export type { DiffSize, FailedTest, GateFailure, LivePhase, MergeFailure, MergeProgress, MergeStep, MergeTimes, RemoveReason, TaskState, Worktree, } from "./worktree";
+export { MERGE_STEPS, REMOVE_REASONS } from "./worktree";
+export { taskOf, WorktreeService } from "./worktree-service";