@stringsync/splates 0.0.61 → 1.13.3

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

@@ -0,0 +1,155 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Lock, Ps } from "../../../core/system/index.js";
+import { type Document, type Storage } from "../storage";
+/** A repository splates has run in, as the registry keeps it. */
+export interface ProjectRecord {
+    /** The main tree's root, never a task's worktree. */
+    root: string;
+    /** When splates first ran there, as an ISO timestamp. */
+    added: string;
+    /**
+     * What each other project may do here, by its root, those left out
+     * `DEFAULT_REACH`.
+     */
+    grants?: Record<string, Reach>;
+}
+/** A registered repository, as the registry reads it back. */
+export interface Project extends ProjectRecord {
+    /**
+     * What a URL names it by: the root's last part, `webappwiz`, with `-2`
+     * and on for a second of the same name, in the order they joined.
+     */
+    slug: string;
+    /** The repository is no longer there: moved or deleted since. */
+    gone: boolean;
+}
+/** The registry's file as stored, whatever splates wrote it. */
+interface StoredRegistry {
+    format?: number;
+    projects?: ProjectRecord[];
+    focused?: string[] | string | null;
+    ids?: Record<string, string>;
+}
+/** What `Projects` works with. */
+export interface ProjectsOptions {
+    /** Tells whether a project's repository is still there. */
+    fs: Fs;
+    /** Held while the file is rewritten, so two commands never drop each other's. */
+    lock: Lock;
+    /** The current time; a test passes its own. */
+    now?: () => Date;
+}
+/**
+ * The roster of splates projects on this machine. `splates init` adds a
+ * project to it, and one `splates server` lists, focuses and forgets the
+ * projects through it instead of scanning the disk.
+ */
+export declare class Projects {
+    /** `projects.json` of the machine's storage, or a test's own. */
+    private readonly document;
+    private readonly fs;
+    private readonly lock;
+    private readonly now;
+    /**
+     * This machine's registry, in `SPLATES_HOME`, `~/.splates` for none, with a
+     * lock that counts as stale after `stalenessMs`.
+     */
+    static ofMachine({ fs, ps, log }: {
+        fs: Fs;
+        ps: Ps;
+        log: Logger;
+    }, stalenessMs?: number): Projects;
+    /** The registry kept in `storage`, which is a machine's or a slot's home. */
+    static in(storage: Storage, fs: Fs, now?: () => Date): Projects;
+    constructor(
+    /** `projects.json` of the machine's storage, or a test's own. */
+    document: Document<StoredRegistry>, { fs, lock, now }: ProjectsOptions);
+    /**
+     * Adds the repository at `root`, once, saying whether it did: registering
+     * it again changes nothing.
+     */
+    register(root: string): Promise<boolean>;
+    /**
+     * The id the records of the checkout at `root` are kept under, or null
+     * while it has none. Forgetting a project keeps it, so its records are
+     * found again once it is registered.
+     */
+    idOf(root: string): Promise<string | null>;
+    /** `idOf`, giving the checkout at `root` an id first when it has none. */
+    idFor(root: string): Promise<string>;
+    /**
+     * Makes the registered repository at `root` the one an address naming
+     * none shows, as picking it on the page does, saying whether it is
+     * registered.
+     */
+    focus(root: string): Promise<boolean>;
+    /**
+     * The project an address naming none shows: the one focused last, else
+     * the one focused before it, and so on, else the first registered,
+     * skipping those gone; null while there is none.
+     */
+    focused(): Promise<Project | null>;
+    /**
+     * Every registered project, in the order splates first ran in each, those
+     * whose repository is gone flagged rather than dropped: one on a drive
+     * that is not mounted comes back.
+     */
+    list(): Promise<Project[]>;
+    /**
+     * What the project at `from` may do in the one at `to`: what `to` granted
+     * it, else `DEFAULT_REACH`.
+     */
+    reach(from: string, to: string): Promise<Reach>;
+    /**
+     * Lets the project at `from` do as much as `reach` in the registered one
+     * at `to`, saying whether `to` is registered.
+     */
+    grant(to: string, from: string, reach: Reach): Promise<boolean>;
+    /**
+     * The registered project a command names as `slug`, refusing one that is
+     * not there.
+     */
+    named(slug: string): Promise<Project>;
+    /**
+     * Drops the repository at `root`, saying whether it was there: one gone
+     * for good, or one `splates server` should no longer offer.
+     */
+    forget(root: string): Promise<boolean>;
+    /**
+     * Rewrites the file as `edit` says, under the lock, saying whether it
+     * did: `edit` returns null to leave it as it is.
+     */
+    private change;
+    private read;
+    private write;
+}
+/**
+ * What an agent working in one project may do in another through splates,
+ * each including those before it: read its tasks and lanes; queue tasks
+ * in its untriaged lane; or run its queue, lanes and hooks.
+ * Grants stop splates commands, not file edits.
+ */
+export declare const REACHES: readonly ["read", "queue", "tasks"];
+export type Reach = (typeof REACHES)[number];
+/** What a project lets another do that it has granted nothing. */
+export declare const DEFAULT_REACH: Reach;
+/** Whether `granted` covers what `needed` asks for. */
+export declare function reaches(granted: Reach, needed: Reach): boolean;
+/**
+ * One line telling an agent where a project a prompt names as `#slug` sits,
+ * and how to change it:
+ *
+ * ```
+ * #shop is the splates project at /Users/me/shop: read its code there, and land any change to it from a task added there.
+ * ```
+ */
+export declare function projectLine({ slug, root, reach, }: {
+    slug: string;
+    root: string;
+    /**
+     * What the project the prompt is in may do there; null when it is that
+     * project, or in none.
+     */
+    reach: Reach | null;
+}): string;
+export {};

package/vendor/@stringsync/splates-server/projects/reaches.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Ps } from "../../../core/system/index.js";
+import type { Git } from "../git";
+import type { Projects, Reach } from "./projects";
+/**
+ * `splates projects list`: each other project, with what it may do in the one
+ * `git` is in, and what that one may do there.
+ */
+export declare function listReaches({ projects, git, log }: {
+    projects: Projects;
+    git: Git;
+    log: Logger;
+}, { json }?: {
+    json?: boolean;
+}): Promise<void>;
+/**
+ * `splates projects grant`: lets agents of the project `slug` names do as much
+ * as `reach` in the one `git` is in. The person's call alone, so an agent is
+ * refused: it asks with a grant card, whose Allow grants it.
+ */
+export declare function grantReach({ projects, git, log, ps, }: {
+    projects: Projects;
+    git: Git;
+    log: Logger;
+    ps: Ps;
+}, slug: string, reach: Reach): Promise<void>;

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

@@ -0,0 +1,2 @@
+export type { Pushed } from "./push";
+export { forgetDevices, Pushes } from "./push";

package/vendor/@stringsync/splates-server/push/notices.d.ts

@@ -0,0 +1,44 @@
+import type { Needing } from "../plans";
+/** Something a row did worth telling the person about, away from the page. */
+export interface Notice {
+    row: Needing;
+    title: string;
+    body: string;
+}
+/** Which notices the person asked for, as the page's Notifications settings say. */
+export interface Wants {
+    waiting: boolean;
+    finished: boolean;
+    quiet: boolean;
+    /** Minutes a running agent goes without a word before it counts as quiet. */
+    quietAfter: number;
+}
+/**
+ * Tells what changed in the rows since the last look worth notifying of,
+ * the same on the page and on the server, which pushes it to a phone the
+ * page cannot run on once it leaves the front.
+ */
+export declare class Notices {
+    /** By row, what the last look saw; null before the first. */
+    private seen;
+    /**
+     * Compares `rows`, named by `name`, with the last look at `now`, and
+     * returns what changed worth telling, of the kinds `wants` asks for: a
+     * row that came to wait, a conversation that finished its turn, and one
+     * running with no word for the quiet time. The first look tells nothing,
+     * since it has nothing to compare.
+     */
+    look(rows: Needing[], name: (row: Needing) => string, now: number, wants: Wants): Notice[];
+}
+/**
+ * The key of a ship's push, which the page's ship badge opens on, from a
+ * click or as the `?ship=open` its address carries.
+ */
+export declare const SHIP_KEY = "ship";
+/** What tells `row` apart from the others, in a notification and its click. */
+export declare function keyOf(row: Needing): string;
+/**
+ * The first line of `markdown` with its marks taken out, cut to `length`:
+ * a notification shows plain text, and a phone only a line or so of it.
+ */
+export declare function plain(markdown: string, length: number): string;

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

@@ -0,0 +1,91 @@
+import type { Logger } from "../../../core/log/index.js";
+import { type Pusher, type VapidKeys } from "../../../core/push/index.js";
+import { Duration } from "../../../core/time/index.js";
+import type { Projects } from "../projects";
+import type { Handler, Served } from "../server/shared";
+import type { Storage } from "../storage";
+/** How often the server looks for something worth pushing, while a device listens. */
+export declare const PUSH_EVERY: Duration;
+/** What `Pushes` reads each served project through. */
+export interface PushesDeps {
+    /** The machine's storage, which keeps `push.json`. */
+    storage: Storage;
+    log: Logger;
+    projects: Projects;
+    /** By root, every project the server has opened. */
+    served: Map<string, Promise<Served>>;
+    /** What sends a push, signed with the keys kept; the Web Push services by default. */
+    pusher?: (keys: VapidKeys) => Pusher;
+    /** How often to look; `PUSH_EVERY` by default. */
+    every?: Duration;
+}
+/**
+ * Tells each device that subscribed, through its browser's push service,
+ * what the page's own notifications would: an agent that came to wait,
+ * finished its turn or went quiet, in any project the server has open. The
+ * page cannot tell it itself once a phone freezes it, soon after the app
+ * leaves the front. The keys it signs with and the devices it pushes to are
+ * kept in one file for every project on the machine, so a restart keeps them.
+ */
+export declare class Pushes {
+    private readonly deps;
+    private readonly file;
+    private readonly keys;
+    private devices;
+    private readonly pusher;
+    /** By device and project, what the last look saw. */
+    private readonly notices;
+    /**
+     * By project root, what the last look saw its ship wait on npm for, by
+     * its kind and since, or null for nothing; none before the first look.
+     */
+    private readonly waits;
+    private readonly tick;
+    private looking;
+    static start(deps: PushesDeps): Promise<Pushes>;
+    private constructor();
+    /** The public key a page subscribes with. */
+    readonly key: Handler;
+    /** Keeps a device's subscription and what it wants, replacing what it said before. */
+    readonly subscribe: Handler;
+    /** Forgets the device whose subscription `endpoint` names. */
+    readonly unsubscribe: Handler;
+    /** Pushes each device the new notices it wants; call it on a timer. */
+    look(): Promise<void>;
+    dispose(): void;
+    private lookOnce;
+    /**
+     * What `project`'s ship came to wait on npm for since the last look, or
+     * null: npm's links expire within minutes, so the person hears of each
+     * at once. The first look tells nothing, since it has nothing to compare.
+     */
+    private shipWait;
+    /**
+     * Pushes `notice` to every device at once, whatever it wants and
+     * however quiet the hour, for what must not be missed: a worker budget
+     * limit nearing or reached.
+     */
+    announce(notice: Omit<Pushed, "inFront">): Promise<void>;
+    private push;
+    private forget;
+    /**
+     * The devices as the file keeps them now, since undoing setup's
+     * notifications forgets them there; the last ones read when it will not
+     * read.
+     */
+    private kept;
+    private keep;
+}
+/** Makes every browser subscribe again from the page, after the keys changed; the running server stops pushing to the old devices. */
+export declare function forgetDevices(storage: Storage): Promise<void>;
+/** What the server pushes for a notice, as `Pushes` sends it. */
+export interface Pushed {
+    title: string;
+    body: string;
+    /** The row's key, which tags its notification and opens it. */
+    key: string;
+    /** The row's address, from the page's own: its `?project=` and hash. */
+    url: string;
+    /** Whether to show it even while a window of the page is in front. */
+    inFront: boolean;
+}

package/vendor/@stringsync/splates-server/queue/commands.d.ts

@@ -0,0 +1,44 @@
+import { type Logger } from "../../../core/log/index.js";
+import { type Task, type Tasks } from "../board";
+import type { WorktreeService } from "../tasks";
+/** What the queue commands work with. */
+export interface QueueDeps {
+    tasks: Tasks;
+    log: Logger;
+}
+/**
+ * The queue in the order workers take it, each task with what it waits on:
+ * the open tasks it is blocked by, or those removed without merging.
+ */
+export declare function queueList({ tasks, log }: QueueDeps, { json }?: {
+    json?: boolean;
+}): Promise<void>;
+/**
+ * Puts tasks `ids` in the queue, from the backlog or groomed, for a worker
+ * to start once nothing they are blocked by is open. Refuses one an agent
+ * has taken, which is already under way.
+ */
+export declare function queueAdd({ tasks, log }: QueueDeps, ids: number[]): Promise<Task[]>;
+/**
+ * Names the tasks just queued, `ids`, wait on that are not queued, however
+ * far down, with the command that queues them, blockers first: until then
+ * those stay queued and blocked. Says nothing when there are none.
+ */
+export declare function sayUnqueuedBlockers({ tasks, log }: QueueDeps, ids: readonly number[]): Promise<void>;
+/**
+ * Takes tasks `ids` out of the queue, back to `ready` when they were
+ * groomed, else `backlog`. Refuses one not in it.
+ */
+export declare function queueRemove({ tasks, log }: QueueDeps, ids: number[]): Promise<Task[]>;
+/**
+ * Moves queued task `id` to `position` in the queue, from 1 for the next to
+ * start, past the end meaning the end. What it is blocked by still goes
+ * first, so it lands as near there as its links allow; prints the queue.
+ */
+export declare function queueMove(deps: QueueDeps, id: number, position: number): Promise<void>;
+/**
+ * Call it first in a command that changes the queue: it refuses an agent,
+ * since only the person queues, unqueues or orders work, telling the agent
+ * to end its reply with a queue card instead.
+ */
+export declare function refuseAgentQueue(service: Pick<WorktreeService, "ps">, command: string): void;

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

@@ -0,0 +1,7 @@
+export type { QueueDeps } from "./commands";
+export { queueAdd, queueList, queueMove, queueRemove, refuseAgentQueue, sayUnqueuedBlockers, } from "./commands";
+export { QueueMoves } from "./moves";
+export { taskName } from "./name";
+export { blockage, canStart, holdsBack, isBlocked, queueOrder, unqueuedBlockers, } from "./order";
+export type { HeldConversation, HeldConversations, QueuePicked, QueuePicker, QueueRunnerDeps, QueueStart, QueueStarter, } from "./runner";
+export { QUEUE_SWEEP, QueueRunner, queuePrompt } from "./runner";

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

@@ -0,0 +1,44 @@
+import {
+  queueOrder2,
+  holdsBack2,
+  canStart2,
+  blockage2,
+  isBlocked2,
+  unqueuedBlockers2,
+  QueueMoves2,
+  queueList2,
+  queueAdd2,
+  sayUnqueuedBlockers2,
+  queueRemove2,
+  queueMove2,
+  refuseAgentQueue2,
+  taskName2,
+  QUEUE_SWEEP2,
+  QueueRunner2,
+  queuePrompt2
+} 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 {
+  QUEUE_SWEEP2 as QUEUE_SWEEP,
+  QueueMoves2 as QueueMoves,
+  QueueRunner2 as QueueRunner,
+  blockage2 as blockage,
+  canStart2 as canStart,
+  holdsBack2 as holdsBack,
+  isBlocked2 as isBlocked,
+  queueAdd2 as queueAdd,
+  queueList2 as queueList,
+  queueMove2 as queueMove,
+  queueOrder2 as queueOrder,
+  queuePrompt2 as queuePrompt,
+  queueRemove2 as queueRemove,
+  refuseAgentQueue2 as refuseAgentQueue,
+  sayUnqueuedBlockers2 as sayUnqueuedBlockers,
+  taskName2 as taskName,
+  unqueuedBlockers2 as unqueuedBlockers
+};

package/vendor/@stringsync/splates-server/queue/moves.d.ts

@@ -0,0 +1,15 @@
+import type { Tasks } from "../board";
+/**
+ * Moves tasks within the queue, saying nothing: what the page's drag does
+ * with the board's `tasks`.
+ */
+export declare class QueueMoves {
+    private readonly tasks;
+    constructor(tasks: Tasks);
+    /**
+     * Moves queued task `id` to `position` in the queue, from 1 for the next
+     * to start, past the end meaning the end. What it is blocked by still
+     * goes first, so it lands as near there as its links allow.
+     */
+    move(id: number, position: number): Promise<void>;
+}

package/vendor/@stringsync/splates-server/queue/name.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A task name for `queued`: the slug its writer gave it, else its subject's
+ * words, lowercased and dashed, cut at a word to `NAME_LENGTH`; numbered past
+ * any in `taken`.
+ */
+export declare function taskName(queued: {
+    subject: string;
+    slug?: string;
+}, taken: ReadonlySet<string>): string;

package/vendor/@stringsync/splates-server/queue/order.d.ts

@@ -0,0 +1,50 @@
+import { type ElsewhereBlocker, type TaskRecord } from "../board/browser";
+/**
+ * The queued tasks of `all` no agent has taken, in the order the queue
+ * starts them: each after what blocks it, otherwise in list order.
+ */
+export declare function queueOrder(all: readonly TaskRecord[]): TaskRecord[];
+/**
+ * Why queued task `task` cannot start yet, among `all`: the open tasks it
+ * is blocked by, and those removed without merging, which the person has
+ * to let go of, and `elsewhere`, those of other projects yet to merge or
+ * removed there; none when it can start.
+ */
+export declare function holdsBack(task: TaskRecord, all: readonly TaskRecord[]): {
+    open: TaskRecord[];
+    lost: number[];
+    elsewhere: ElsewhereBlocker[];
+};
+/** Whether queued task `task` can start now, among `all`. */
+export declare function canStart(task: TaskRecord, all: readonly TaskRecord[]): boolean;
+/**
+ * What holds queued task `task` back that only the person can clear, among
+ * `all`: `chain`, the open tasks it waits on however far down that nothing
+ * will start, blockers first, as `unqueuedBlockers` finds; `lost`, its own
+ * blockers removed without merging; and `deep`, whether a task it waits on
+ * lost one of its own. Empty for a task not queued, or one taken.
+ */
+export declare function blockage(task: TaskRecord, all: readonly TaskRecord[]): {
+    chain: TaskRecord[];
+    lost: number[];
+    deep: boolean;
+};
+/**
+ * Whether queued task `task` is blocked, among `all`: it cannot start until
+ * the person queues a task it waits on or drops a link to one removed.
+ */
+export declare function isBlocked(task: TaskRecord, all: readonly TaskRecord[]): boolean;
+/** The open tasks of `all` that `task` waits on, however far down, past any under way. */
+export declare function waitedOn(task: TaskRecord, all: readonly TaskRecord[]): TaskRecord[];
+/**
+ * The open tasks of `all` that tasks `ids` wait on, however far down, and
+ * that nothing will start: neither queued, under way, nor among `ids`;
+ * each after what it waits on, so queueing them in order queues blockers
+ * first. Empty when every blocker is queued or running already.
+ */
+export declare function unqueuedBlockers(ids: readonly number[], all: readonly TaskRecord[]): TaskRecord[];
+/**
+ * Whether deferred task `task` goes back to the conversation that deferred
+ * it by itself: untaken, waiting only on tasks, and each of them merged.
+ */
+export declare function resumesItself(task: TaskRecord, all: readonly TaskRecord[]): boolean;

package/vendor/@stringsync/splates-server/queue/runner.d.ts

@@ -0,0 +1,129 @@
+import { type Resource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import { Duration, type Timer } from "../../../core/time/index.js";
+import type { TaskRecord } from "../board";
+import type { QueueSpot } from "../conversations";
+import type { AgentPick } from "../models";
+/** How often the queue checks itself again when it has seen no change. */
+export declare const QUEUE_SWEEP: Duration;
+/** The most sweeps the queue waits before trying a refused start again. */
+export declare const RETRY_SWEEPS_MAX = 30;
+/** One queued task the queue starts, as `QueueRunner` hands it to its `start`. */
+export interface QueueStart {
+    queued: TaskRecord;
+    /** The name for its task, one no task out has. */
+    task: string;
+    /** The agent and model to work it: the one it names, else what Auto pick decided. */
+    pick: AgentPick;
+    /** What its agent is told beyond claiming the task. */
+    prompt: string;
+    /** The conversation held for it, which takes the task; absent for none. */
+    held?: string;
+}
+/**
+ * Adds the task for `start`, handed to its agent, which `splates server`
+ * starts as for any `splates add --agent`. Throws when the add is refused.
+ */
+export type QueueStarter = (start: QueueStart) => Promise<void>;
+/** Starts a project's queued tasks: `watch` to begin, `sweep` to check now, `retry` a refused start, `dispose` to stop. */
+export declare class QueueRunner implements Resource {
+    #private;
+    private readonly deps;
+    private constructor();
+    /** Works the queue, checking it at once. */
+    static watch({ timer, ...deps }: QueueRunnerDeps & {
+        timer?: Timer;
+    }): QueueRunner;
+    /** Starts every queued task nothing blocks now. */
+    sweep(): Promise<void>;
+    /** Tries queued task `id` again, its start refused, as though it changed. */
+    retry(id: number): Promise<void>;
+    dispose(): void;
+}
+/** What a `QueueRunner` works with. */
+export interface QueueRunnerDeps {
+    /** Every task on the list, queued or not. */
+    queued: () => Promise<TaskRecord[]>;
+    /**
+     * Settles what the list cannot see itself, such as blockers in other
+     * projects that merged there, before each check reads it; absent, nothing.
+     */
+    settle?: () => Promise<unknown>;
+    /** The name of every task out, so a new one takes another. */
+    tasks: () => Promise<string[]>;
+    /** Who works a queued task that names no agent: Auto pick. */
+    picker: QueuePicker;
+    start: QueueStarter;
+    /**
+     * Tells the conversation that deferred `task` to take it up again, as
+     * Resume on its card does; whether it was told, false when that
+     * conversation is gone. Absent, deferred tasks never resume by themselves.
+     */
+    resume?: (task: TaskRecord) => Promise<boolean>;
+    /** The conversations held for queued tasks; absent, none is held. */
+    held?: HeldConversations;
+    /**
+     * Whether everything splates starts on its own waits, so no queued task
+     * starts; absent, never paused.
+     */
+    paused?: () => boolean;
+    log: Logger;
+}
+/** Picks the agent for a queued task that names none. */
+export interface QueuePicker {
+    /** Starts judging each of `queued` in the background, so later guesses are better; resolves once each has begun. */
+    ahead(queued: readonly TaskRecord[]): Promise<void>;
+    /**
+     * Whether queued task `id` is being judged ahead now, so its held
+     * conversation waits for the pick, to be made once its record says it.
+     */
+    judging(id: number): boolean;
+    /**
+     * Whom each of `queued` would go to now, by id, asking no judge: what was
+     * judged of its words before, else the rule for any task.
+     */
+    guess(queued: readonly TaskRecord[]): Promise<Map<number, AgentPick>>;
+    /**
+     * Decides whom `queued` starts on, on fresh plan limits, and keeps the
+     * decision on its record. Never rejects: with no judge, or one that
+     * fails, it takes the rule for any task.
+     */
+    decide(queued: TaskRecord): Promise<QueuePicked>;
+}
+/** What `QueuePicker.decide` decided for a queued task. */
+export interface QueuePicked {
+    pick: AgentPick;
+    /** Logs the decision in conversation `id`, the one that works the task. */
+    tell(id: string): Promise<void>;
+}
+/** A conversation held for a queued task, as `HeldConversations` lists it. */
+export interface HeldConversation {
+    id: string;
+    /** The queued task it is held for. */
+    queued: number;
+    agent: string;
+    createdAt: string;
+    /** Whether a task the queue started names it, to take it. */
+    handed: boolean;
+}
+/**
+ * The conversations held for queued tasks, one for each from the moment it
+ * is queued, so the person sees it waiting: out of the line for a slot,
+ * which only the queue's starts join, until the queue starts its task.
+ */
+export interface HeldConversations {
+    /** Every one held, or made held and not yet given its task. */
+    list: () => Promise<HeldConversation[]>;
+    /** Makes one held for `queued`, on `pick`. */
+    hold: (queued: TaskRecord, pick: AgentPick) => Promise<void>;
+    /** Says where `id` stands in the queue, holding it again once stopped. */
+    place: (id: string, spot: QueueSpot) => void;
+    /** Archives `id`, its task gone from the queue, or taken another way. */
+    drop: (id: string) => Promise<void>;
+}
+/**
+ * What a queued task's agent is told beyond claiming its task: that the
+ * queue started it, the commit each task it was blocked by landed as,
+ * which it builds on, and to groom it first when it is not yet groomed.
+ */
+export declare function queuePrompt(queued: TaskRecord): string;

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

@@ -0,0 +1,27 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import { type ElsewhereBoards, type ElsewhereFollower, type ElsewhereOpen, type ElsewhereTask } from "../board";
+import type { Projects } from "../projects";
+/**
+ * Reads the boards of the other splates projects on this machine, for a
+ * task that waits on one of theirs; dispose of it once done, which closes
+ * each project it opened.
+ */
+export declare class OpenBoards implements ElsewhereBoards, Disposable {
+    private readonly deps;
+    private readonly projects;
+    private readonly opened;
+    constructor(deps: {
+        fs: Fs;
+        ps: Ps;
+        log: Logger;
+    }, projects: Projects);
+    root(slug: string): Promise<string | null>;
+    slug(root: string): Promise<string>;
+    find(root: string, id: number): Promise<ElsewhereTask | null>;
+    following(root: string): Promise<ElsewhereFollower[]>;
+    openTasks(root: string): Promise<ElsewhereOpen[]>;
+    [Symbol.dispose](): void;
+    /** The records of the project at `root`, or null for one that has none. */
+    private open;
+}