@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/tasks/index.js

@@ -0,0 +1,90 @@
+import {
+  TaskOverlaps2,
+  overlapWarnings2,
+  editLines2,
+  ZED2,
+  EDITORS2,
+  ConflictChecks2,
+  REMOVE_REASONS2,
+  MERGE_STEPS2,
+  Finished2,
+  taskOf2,
+  WorktreeService2,
+  add2,
+  WIP_MESSAGE2,
+  checkpoint2,
+  save2,
+  claim2,
+  startDispatched2,
+  SERVER_WAIT_MS2,
+  follow2,
+  serveProject2,
+  landingsOverlapping2,
+  landingNotice2,
+  list2,
+  path2,
+  recommend2,
+  recommendation2,
+  remove2,
+  retry2,
+  recordRetry2,
+  TaskRoutes2,
+  show2,
+  TaskDetails2,
+  snapshot2,
+  tasksOf2,
+  fingerprint2,
+  DEFAULT_TIMEOUT3,
+  untilAfter2,
+  wait2,
+  asking2,
+  taskWait2
+} from "../index-caep3sde.js";
+import"../index-01z7ycdk.js";
+import"../index-e9z7s5hh.js";
+import"../index-kmzdvvt0.js";
+import"../index-t9w5a8ed.js";
+import"../index-0jttnv86.js";
+import"../index-g18nxyn7.js";
+export {
+  ConflictChecks2 as ConflictChecks,
+  DEFAULT_TIMEOUT3 as DEFAULT_TIMEOUT,
+  EDITORS2 as EDITORS,
+  Finished2 as Finished,
+  MERGE_STEPS2 as MERGE_STEPS,
+  REMOVE_REASONS2 as REMOVE_REASONS,
+  SERVER_WAIT_MS2 as SERVER_WAIT_MS,
+  TaskDetails2 as TaskDetails,
+  TaskOverlaps2 as TaskOverlaps,
+  TaskRoutes2 as TaskRoutes,
+  WIP_MESSAGE2 as WIP_MESSAGE,
+  WorktreeService2 as WorktreeService,
+  ZED2 as ZED,
+  add2 as add,
+  asking2 as asking,
+  checkpoint2 as checkpoint,
+  claim2 as claim,
+  editLines2 as editLines,
+  fingerprint2 as fingerprint,
+  follow2 as follow,
+  landingNotice2 as landingNotice,
+  landingsOverlapping2 as landingsOverlapping,
+  list2 as list,
+  overlapWarnings2 as overlapWarnings,
+  path2 as path,
+  recommend2 as recommend,
+  recommendation2 as recommendation,
+  recordRetry2 as recordRetry,
+  remove2 as remove,
+  retry2 as retry,
+  save2 as save,
+  serveProject2 as serveProject,
+  show2 as show,
+  snapshot2 as snapshot,
+  startDispatched2 as startDispatched,
+  taskOf2 as taskOf,
+  taskWait2 as taskWait,
+  tasksOf2 as tasksOf,
+  untilAfter2 as untilAfter,
+  wait2 as wait
+};

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

@@ -0,0 +1,17 @@
+import type { Worktree } from "./worktree";
+/** A task that landed on an open task's base, changing files that task also changed. */
+export interface Landing {
+    task: string;
+    commit: string;
+    files: string[];
+}
+/**
+ * Landings since `worktree` branched that changed files it also changed,
+ * newest first. A landing the branch has rebased past is not listed. Reads
+ * only, never rebasing the worktree.
+ */
+export declare function landingsOverlapping(worktree: Worktree): Promise<Landing[]>;
+/** The notice a working agent hears: one line, with nothing rebased for it. */
+export declare function landingNotice(landing: Landing, base: string): string;
+/** Each landing's notice for `worktree`, for `list` and `show` to name. */
+export declare function landingNotices(worktree: Worktree): Promise<string[]>;

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

@@ -0,0 +1,18 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Fs } from "../../../core/system/index.js";
+import type { WorktreeService } from "./worktree-service";
+export interface ListOptions {
+    /** Print the rows as JSON instead of a table. */
+    json?: boolean;
+    /**
+     * Add each task's Goal and changed 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, fs }: {
+    service: WorktreeService;
+    log: Logger;
+    fs: Fs;
+}, { json, files }?: ListOptions): Promise<void>;

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

@@ -0,0 +1,13 @@
+import type { Fs } from "../../../core/system/index.js";
+import { type Timer } from "../../../core/time/index.js";
+import type { WorktreeService } from "./worktree-service";
+/**
+ * What step `index` of `task`'s merge under way printed, then more as it
+ * prints, ending once the step is over and all of it is read; null when the
+ * merge has no such step, or it runs no command.
+ */
+export declare function mergeOutput({ service, fs, timer }: {
+    service: WorktreeService;
+    fs: Fs;
+    timer: Timer;
+}, task: string, index: number): Promise<ReadableStream<Uint8Array> | null>;

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

@@ -0,0 +1,15 @@
+/** A file to open, and the tree its editor window should hold. */
+export interface InTree {
+    tree: string;
+    file: string;
+}
+/**
+ * Where `path` opens: inside the task worktree under `worktrees` it is in,
+ * or, once that worktree is gone, at the same place in the main tree `root`,
+ * or inside `root` itself. Null for a path in neither, which the page may not
+ * open.
+ */
+export declare function inTree(path: string, { root, worktrees }: {
+    root: string;
+    worktrees: string;
+}, exists: (path: string) => Promise<boolean>): Promise<InTree | null>;

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

@@ -0,0 +1,16 @@
+import type { WorktreeService } from "./worktree-service";
+/** Compares new work with files already being changed by open tasks. */
+export declare class TaskOverlaps {
+    private readonly service;
+    constructor(service: WorktreeService);
+    files(): Promise<{
+        task: string;
+        files: string[];
+    }[]>;
+    warnings(task: string, goal: string, changed?: string[]): Promise<string[]>;
+}
+/** Names open work that touches a file named in the goal or already changed here. */
+export declare function overlapWarnings(peers: {
+    task: string;
+    files: string[];
+}[], task: string, goal: string, changed?: string[]): string[];

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

@@ -0,0 +1,13 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { WorktreeService } from "./worktree-service";
+/**
+ * Where a task lives, or (with no task) the main tree. Nothing but the path
+ * on stdout, so it composes: `cd "$(splates path)"`, `zed -a "$(splates path x)"`.
+ * Moving between trees is `cd` and nothing else, and the main tree 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.
+ */
+export declare function path({ service, log }: {
+    service: WorktreeService;
+    log: Logger;
+}, task?: string): Promise<void>;

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

@@ -0,0 +1,30 @@
+import type { Task, Tasks } from "../board";
+import { type LaneRecord, type LaneState } from "../board";
+/** What a finished task should be followed by, and what should just go. */
+export interface Recommendation {
+    /** The queued task to pick up next, or null when there is nothing fresh left. */
+    next: Task | null;
+    /** Queued tasks left waiting so long they probably no longer apply. */
+    stale: Task[];
+    /**
+     * The lane the finished task's queued tasks ran in, when it has more to do:
+     * `next` is its next step then, even one another lane still blocks.
+     */
+    lane?: LaneState;
+    /** Every lane there is now, to name those `lane` is blocked by. */
+    records?: LaneRecord[];
+    /** A lane the finished task's queued tasks emptied: its agent is done. */
+    finished?: LaneRecord;
+}
+/**
+ * Which queued task to take up after `task`. A task whose queued tasks ran in a lane goes
+ * on down that lane, since that is what its agent was handed. Otherwise one
+ * that came up in it first, since whoever just finished it knows that context
+ * best, then the open one highest on the list, which is how
+ * whoever keeps the list says what matters most; never one still blocked by
+ * another yet to merge. Queued tasks past `staleness` are never recommended, only
+ * offered for removal.
+ */
+export declare function recommend(tasks: Tasks, task: string | null, staleness: number, ran?: LaneRecord[]): Promise<Recommendation>;
+/** The lines `merge` ends with, or none when there is nothing to say. */
+export declare function recommendation({ next, stale, lane, records, finished, }: Recommendation): string[];

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

@@ -0,0 +1,47 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { DeferralAsk, Tasks } from "../board";
+import { type TaskBranches } from "../merge";
+import { type Slots } from "../ports";
+import type { RemoveReason } from "./worktree";
+import type { WorktreeService } from "./worktree-service";
+export interface RemoveOptions {
+    /** Discard the tree even when another agent holds its lease. */
+    force?: boolean;
+    /** The `splates server` conversation working on it, when removed from the page. */
+    conversation?: string;
+    /** Why, kept in its outcome for the Stats page. */
+    reason?: RemoveReason;
+    /**
+     * Why blocked work stopped and what it waits on, which `reason: "blocked"`
+     * requires, kept on the board task it goes back to.
+     */
+    deferral?: Partial<DeferralAsk> & {
+        /** The task's detail rewritten for whoever takes it next. */
+        detail?: string;
+    };
+}
+/**
+ * Discards a whole task: `git worktree remove` plus the branch and the
+ * record.
+ *
+ * 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.
+ *
+ * What it took leaves the board too, unless blocked work is being deferred.
+ * Deferred work goes back to ready or the backlog, outside the queue and
+ * any queued lane until the person queues it again, holding why it stopped
+ * and what it waits on; work that took no board task gets one of its own,
+ * ready, so the deferral is kept somewhere.
+ */
+export declare function remove({ service, log, tasks: queue, slots, branches, }: {
+    service: WorktreeService;
+    log: Logger;
+    tasks: Tasks;
+    slots: Slots;
+    branches: TaskBranches;
+}, task: string, { force, conversation, reason, deferral }?: RemoveOptions): Promise<{
+    released: {
+        id: number;
+        subject: string;
+    }[];
+}>;

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

@@ -0,0 +1,35 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Config } from "../config";
+import type { Journal } from "../records";
+import type { Worktree } from "./worktree";
+import type { WorktreeService } from "./worktree-service";
+/**
+ * The way back from `budget_exhausted`. A task that has spent its merge
+ * attempts or its conflicted rebases gets both budgets back whole, instead of
+ * `remove` and redo.
+ *
+ * Only once they are spent, and only for a person: the budget's whole job is
+ * to make an agent stop and ask. An agent that granted itself more would be
+ * back to grinding against a moving trunk forever, so the skill leaves it to
+ * the person, who has looked at the tree first.
+ */
+export declare function retry({ service, config, log, }: {
+    service: WorktreeService;
+    config: Config;
+    log: Logger;
+}, task: string): Promise<Granted>;
+/** `retry`, recorded in the journal with the attempts the task had spent. */
+export declare function recordRetry(ctx: {
+    journal: Journal;
+    service: WorktreeService;
+    config: Config;
+    log: Logger;
+}, task: string): Promise<Granted>;
+/** A retry that was granted: the task back to working, and the attempts it had spent. */
+export interface Granted {
+    worktree: Worktree;
+    /** The merge attempts it had spent before the grant. */
+    attempts: number;
+}
+/** What `retry` does, without the printing, for `splates server`'s page too. */
+export declare function grantRetry(service: WorktreeService, task: string): Promise<Granted>;

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

@@ -0,0 +1,23 @@
+import type { Conversations } from "../conversations";
+import type { Project, ProjectWatch } from "../server/shared";
+/**
+ * What a project's page reads of its tasks, and what it does to them. Each
+ * handler is a property, so `serveProject` spreads them into the project's
+ * routes; what they work on stays private, out of the spread.
+ */
+export declare class TaskRoutes {
+    #private;
+    constructor(project: Project, conversations: Conversations | null, watch: ProjectWatch);
+    readonly file: (request: Request) => Promise<Response>;
+    readonly open: (request: Request) => Promise<Response>;
+    readonly paths: (request: Request) => Promise<Response>;
+    readonly finishedTasks: () => Promise<Response>;
+    readonly mergeEstimates: () => Promise<Response>;
+    readonly mergeOutput: (request: Request) => Promise<Response>;
+    readonly finishedTask: (request: Request) => Promise<Response>;
+    readonly diff: (request: Request) => Promise<Response>;
+    readonly retryTask: (request: Request) => Promise<Response>;
+    readonly removeTask: (request: Request) => Promise<Response>;
+    /** Removes `task` as the page's remove does, stopping each conversation in it. */
+    readonly removeNamed: (task: string) => Promise<void>;
+}

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

@@ -0,0 +1,137 @@
+import { type Logger } from "../../../core/log/index.js";
+import { type Fs } from "../../../core/system/index.js";
+import type { AutoPicked } from "../auto-pick";
+import type { Gate, MergeProgress, Worktree } from "./worktree";
+import type { WorktreeService } from "./worktree-service";
+/**
+ * One task in full: what `list` shows for it, plus the `SPLATES.md` its agent
+ * left at the worktree root. Reading a tree this way takes no lease, so it
+ * cannot knock the agent driving it off its own work.
+ */
+export declare function show({ service, fs, log }: {
+    service: WorktreeService;
+    fs: Fs;
+    log: Logger;
+}, task: string, opts?: ShowOptions): Promise<void>;
+export interface Details {
+    task: string;
+    /** Files predicted to conflict at the last checked committed tips. */
+    comingConflict?: string[];
+    landed?: string[];
+    status: string;
+    branch: string;
+    base: string;
+    /** The `splates server` conversation whose agent added it, or null. */
+    caller: string | null;
+    /**
+     * The `splates server` conversation whose agent last took it, or its caller's
+     * for a subagent; null for an agent outside the page.
+     */
+    takenBy: string | null;
+    worktree: string;
+    lease: "held" | "stale" | "none";
+    /** Where its merge stands before landing: waiting its turn, or testing; null with none under way. */
+    gate: Gate | null;
+    /** When its merge under way was asked for; null with none under way. */
+    mergeSince: string | null;
+    /** Its merge's place in line for the premerge lock while it waits, 1 next; null otherwise. */
+    mergePlace: number | null;
+    /** How far its merge under way has got; null with none under way. */
+    mergeSteps: MergeProgress | null;
+    ahead: number | null;
+    /**
+     * Whether removing it would lose work: commits its base does not have, or
+     * changes not yet committed besides its SPLATES.md. A branch reset behind
+     * its base has none.
+     */
+    unmerged: boolean;
+    added: number | null;
+    removed: number | null;
+    age: string | null;
+    /** When it was added, which `age` counts from. */
+    createdAt: string | null;
+    /**
+     * The last sign of an agent at work on it: a splates command writing its
+     * record, a commit on its branch, or an edit to its SPLATES.md or to a file
+     * not yet committed. Null when nothing says.
+     */
+    activeAt: string | null;
+    /** The merges it has tried; at `mergeAttemptLimit`, only `splates retry` lets it try again. */
+    mergeAttempts: number;
+    mergeAttemptLimit: number;
+    /** Its conflicted rebases, counted apart from `mergeAttempts`. */
+    conflictAttempts: number;
+    conflictAttemptLimit: number;
+    /** Whether either budget is spent, so only `splates retry` lets it merge again. */
+    budgetSpent: boolean;
+    /**
+     * Whether the plan leaves nothing unchecked under `## Blocked` or
+     * `## Next`, which `splates merge` requires.
+     */
+    ready: boolean;
+    plan: string | null;
+    /** How the `SPLATES.md` departs from the shape the skill prescribes. */
+    planProblems: string[];
+    /**
+     * Whether `splates add --agent` handed it to an agent that `splates server` has
+     * yet to start a conversation with.
+     */
+    dispatched: boolean;
+    /**
+     * The conversation `splates server` started for the agent another conversation
+     * handed it to, which answers to that one, its caller, rather than to the
+     * user; null for any other task.
+     */
+    handedTo: string | null;
+    /** The last Auto pick that started it, as its record keeps it; null before any. */
+    autoPick: AutoPicked | null;
+}
+export interface ShowOptions {
+    /** Print the details as JSON instead of prose. */
+    json?: boolean;
+}
+/** Configures how {@link TaskDetails} gathers a task's info. */
+export interface TaskDetailsOptions {
+    /** What the worktree is read through; the real filesystem by default. */
+    fs?: Fs;
+}
+/**
+ * Everything there is to say about one task, as `show` prints it and the
+ * `splates server` page shows it. Keep one to read tasks many times, and call
+ * {@link moved} whenever a branch or a worktree's files may have moved.
+ */
+export declare class TaskDetails {
+    private readonly fs;
+    /** Each task's git facts, by {@link gitKey}, read since git last moved. */
+    private readonly kept;
+    /** Bumped by {@link moved}, so a read begun before it is not kept. */
+    private generation;
+    /** As `generation`, for the worktrees {@link moved} named, by path. */
+    private readonly generations;
+    constructor(opts?: TaskDetailsOptions);
+    /**
+     * Forgets what git said of every task: a branch, its base, or a
+     * worktree's files may have moved.
+     */
+    moved(worktree?: string): void;
+    get(worktree: Worktree): Promise<Details>;
+    /** What git says of `worktree`: kept since git last moved, or read now. */
+    private git;
+    private forget;
+    private readGit;
+    /**
+     * The latest of its record's last write, its own latest commit, and the
+     * edits to its SPLATES.md and uncommitted files, as `Details.activeAt`.
+     */
+    private activeAt;
+}
+/**
+ * The two ends of a task one conversation handed to an agent, from before
+ * agents stopped handing tasks out: the caller that handed it out, and the
+ * conversation `splates server` started for the agent. Null for any other
+ * task, which answers to the user alone.
+ */
+export declare function handOff(worktree: Worktree): {
+    caller: string;
+    conversation: string;
+} | null;

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

@@ -0,0 +1,86 @@
+import type { Fs } from "../../../core/system/index.js";
+import type * as Board from "../board";
+import type { CredRequest, Creds } from "../creds";
+import type { Slot } from "../ports";
+import type { Behind, Release } from "../server/shared";
+import type { Ship } from "../ship";
+import { type Details, TaskDetails } from "./show";
+import type { WorktreeService } from "./worktree-service";
+/**
+ * Everything one page shows: `task list`, and `list` and `show` for each
+ * task.
+ */
+export interface Snapshot {
+    /** What `?project=` names the project by, which the registry gives it. */
+    project: string;
+    /** The repository's directory name, so a page among many says whose it is. */
+    repo: string;
+    /** Where the repository sits, with the home directory as `~`. */
+    path: string;
+    /** The main tree, absolute, which agents' file paths start from. */
+    root: string;
+    /** The directory that holds each task's worktree, absolute. */
+    worktreeRoot: string;
+    /** Past this age a queued task is offered for removal rather than recommended. */
+    taskStalenessMs: number;
+    todos: Board.TaskRecord[];
+    /** Its tasks' blockers in other projects, and theirs it blocks; absent unread. */
+    elsewhere?: Board.ElsewhereOnBoard;
+    /** Every lane, in board order, empty ones too. */
+    lanes: Board.LaneRecord[];
+    /**
+     * The name of every lane there has been, those on the board first, to
+     * name a lane's orchestrator after it once the lane is done.
+     */
+    laneNames: Board.LaneRecord[];
+    tasks: Details[];
+    /** The merge batches running now, each leader first; absent from older servers. */
+    mergeBatches?: string[][];
+    /** Every cred agents requested, open or not, the latest first; never a value. */
+    creds: CredRequest[];
+    /** The branch tasks land on, which the main tree has checked out. */
+    trunk: string;
+    /** A newer splates than the one serving, once `splates server` has seen one on npm. */
+    release: Release | null;
+    /** Commits to splates's own source since `splates server` started from it. */
+    behind: Behind | null;
+    /**
+     * Whether building the page failed as `splates server` started, so the page
+     * serving is the one built before, and may be out of date.
+     */
+    unbuilt: boolean;
+    /** The slot `splates server --slot` serves under, shown beside the project's name. */
+    slot: Slot | null;
+    /** The project's latest ship, going or ended. Absent from older servers. */
+    ship?: Ship | null;
+}
+/**
+ * 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 declare function snapshot({ project, service, tasks: queue, creds, fs, details, home, release, behind, unbuilt, slot, }: {
+    project: string;
+    service: WorktreeService;
+    tasks: Board.Tasks;
+    creds: Creds;
+    fs: Fs;
+    /**
+     * What reads each task, kept across reads to keep what git said of each
+     * until git moves; a fresh one, keeping nothing, by default.
+     */
+    details?: TaskDetails;
+    /** The home directory to show as `~`, when there is one. */
+    home?: string;
+    release?: Release | null;
+    behind?: Behind | null;
+    unbuilt?: boolean;
+    slot?: Slot | null;
+}): Promise<Snapshot>;
+/** `list` and `show` for each task, as {@link snapshot} reads them. */
+export declare function tasksOf({ service, fs, details, }: {
+    service: WorktreeService;
+    fs: Fs;
+    details?: TaskDetails;
+}): Promise<Details[]>;
+/** What a page shows of `snapshot`, as a string to compare with the last pushed. */
+export declare function fingerprint({ todos, lanes, laneNames, tasks, mergeBatches, creds, release, behind, ship, }: Snapshot): string;

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

@@ -0,0 +1,71 @@
+import { Attachments } from "../artifacts";
+import { type TaskStore } from "../board";
+import type { TaskState } from "./worktree";
+/**
+ * Started tasks as their worktrees read them, from the numbered store the
+ * list of tasks shares: each one's branch, tree, lease and the rest, found by
+ * its name, written without touching what the list holds of it.
+ */
+export declare class StartedRecords {
+    private readonly store;
+    constructor(store: TaskStore);
+    /** The started task called `task`, or null for none. */
+    find(task: string): Promise<TaskState | null>;
+    /**
+     * What the record of started task `task` says of it as it ends: its
+     * number, what it was queued as, and the queued tasks it took up; null
+     * for one with no record.
+     */
+    ending(task: string): Promise<{
+        id: number;
+        subject: string;
+        took: {
+            id: number;
+            subject: string;
+        }[];
+    } | null>;
+    /** Every started task. */
+    all(): Promise<TaskState[]>;
+    /**
+     * Writes `state` into its task's record. A task's first save starts it
+     * under the lowest number it holds that is still queued, or a number of
+     * its own, off the list.
+     */
+    save(state: TaskState): Promise<void>;
+    /**
+     * Changes started task `task`'s record from what it holds now, under
+     * the lock, so a change made from a stale read cannot undo another's.
+     * `change` answers the record to keep, or null to leave it; a task
+     * with no record is left.
+     */
+    amend(task: string, change: (state: TaskState) => TaskState | null): Promise<void>;
+    /** Writes `state` into its task's record. Call it under the store's lock. */
+    private write;
+    /**
+     * Ends `task`'s start: drops what it added to the record, and its files.
+     * One off the list goes, and one on it goes back to the stage it started
+     * from, for the list to settle; `unqueue`, never back in the queue.
+     */
+    end(task: string, { unqueue }?: {
+        unqueue?: boolean | undefined;
+    }): Promise<void>;
+    /**
+     * Where started task `task`'s files live, beside its record: the
+     * screenshots and videos its questions show, in `tasks/<N>/started/`,
+     * apart from those it was queued with. They go when the task ends. Null
+     * for a task with no record.
+     */
+    files(task: string): Promise<Attachments | null>;
+    /**
+     * Drops the files of every started task whose start has ended: what a
+     * process that died between ending a task and clearing its folder left
+     * behind.
+     */
+    sweep(): Promise<void>;
+    private filesAt;
+    /**
+     * The record `task` starts under: the lowest-numbered queued task it
+     * holds, or a new one off the list. Call it under the store's lock.
+     */
+    private numbered;
+}

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

@@ -0,0 +1,47 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Fs } from "../../../core/system/index.js";
+import { Duration } from "../../../core/time/index.js";
+import type { Tasks } from "../board";
+import type { Worktree } from "./worktree";
+import type { WorktreeService } from "./worktree-service";
+/** How long `wait` gives a task before handing the wait back to its caller. */
+export declare const DEFAULT_TIMEOUT: Duration;
+/** When a wait begun now gives up after `timeout`, as an ISO time. */
+export declare function untilAfter(timeout: Duration): string;
+export interface WaitOptions {
+    /** How long to wait before giving up. */
+    timeout?: Duration;
+    /** How long between reads of the record; the default suits a human's patience. */
+    poll?: Duration;
+    /** The time a quiet agent is measured to, in milliseconds. */
+    now?: () => number;
+}
+/**
+ * Blocks until a task stops moving: merged or removed (both leave the name
+ * `removed`), waiting on a person to answer its questions, or broken. Waiting is for the agent whose
+ * 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.
+ */
+export declare function wait({ service, log, fs }: {
+    service: WorktreeService;
+    log: Logger;
+    fs?: Fs;
+}, task: string, { timeout, poll, now }?: WaitOptions): Promise<void>;
+/**
+ * The first open question `worktree`'s agent went quiet on, so it waits on a
+ * person to answer it; null while it works, or asks nothing.
+ */
+export declare function asking(worktree: Worktree, fs: Fs | undefined, now: number): Promise<string | null>;
+/**
+ * Blocks until queued task `id` leaves the list, which it does when the task that
+ * took it merges (or it is removed): what an agent whose next task comes
+ * after it waits for, not knowing which task will take it. Ends early when
+ * the task that has it waits on a person to answer its questions.
+ */
+export declare function taskWait({ service, tasks: queue, log, fs, }: {
+    service: WorktreeService;
+    tasks: Tasks;
+    log: Logger;
+    fs?: Fs;
+}, id: number, { timeout, poll, now }?: WaitOptions): Promise<void>;