@stringsync/splates 0.0.45 → 0.0.47

package/todo.d.ts

@@ -1,146 +1,3 @@
-import type { Attachment, Attachments } from "./attachments.js";
-import type { Journal } from "./journal.js";
-import type { AgentPick } from "./roster.js";
-import type { Todos } from "./todos.js";
-/** What a todo is on disk: one file apiece, so two agents never rewrite one. */
-export interface TodoState {
-    id: number;
-    /** What is left to do, in a line. */
-    subject: string;
-    /** Whatever more there is to say about it, or empty when the line is enough. */
-    text: string;
-    /** Where it stands in the list, 1 at the top: the one to pick up first. */
-    position: number;
-    /** 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[];
-    /**
-     * The todos that have to merge before this one starts, sorted. One leaves
-     * the list when it merges or is removed, and with it every link to it.
-     */
-    blockedBy: number[];
-    /** The lane it runs in, or null for none. */
-    lane: number | null;
-    /** The agent, and model, that should work it, over its lane's; absent for none. */
-    assignee?: AgentPick;
-    /** The other project it was added from; absent for one added here. */
-    origin?: TodoOrigin;
-}
-/**
- * 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 subject(): string;
-    get text(): string;
-    get position(): number;
-    get from(): string | null;
-    get takenBy(): string | null;
-    get createdAt(): Date;
-    /** How long it has waited, in milliseconds. */
-    get waited(): number;
-    /**
-     * The todos blocking it that have yet to merge, leaving out those `task`
-     * has or takes in the same breath, among `together`: what it should not be
-     * started before.
-     */
-    blockers(task: string, together?: number[]): Promise<Todo[]>;
-    /** 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[];
-    /** The todos that have to merge before it starts. */
-    get blockedBy(): number[];
-    get lane(): number | null;
-    get attachments(): Attachments;
-    /**
-     * Says what is left to do in other words, with other files, or higher or
-     * lower in the list, keeping its id and history.
-     */
-    update({ subject, text, position, files, keep, blockedBy, lane, assignee, }: TodoChange): Promise<Todo>;
-    remove(): Promise<void>;
-    /** Removes it, as the person did, keeping it for `Todos.restore` to put back. */
-    discard(): Promise<void>;
-}
-/** A todo's words, place or files changed: new ones added, some of the old kept. */
-export interface TodoChange {
-    /** A new line; the old one stays when this is absent. */
-    subject?: string;
-    /** New detail, empty for none; the old stays when this is absent. */
-    text?: string;
-    /** Where to move it in the list; it stays put when this is absent. */
-    position?: number;
-    /** Files to add. */
-    files?: Attachment[];
-    /** The paths of the files it has now to keep; absent keeps them all. */
-    keep?: string[];
-    /** Every todo blocking it from now on; the old stay when this is absent. */
-    blockedBy?: number[];
-    /** The lane it runs in, `"new"` for one of its own, null for none; it stays when absent. */
-    lane?: number | "new" | null;
-    /** The agent that should work it, null for none; it stays when absent. */
-    assignee?: AgentPick | null;
-}
-/**
- * Where a todo came up, as a list shows it: its task here, or for one added
- * from another project, `<project>/<task>`, the project by its directory's
- * name; null for one a person added from the main tree.
- */
-export declare function cameFrom({ from, origin }: TodoState): string | null;
-/** The other project a todo was added from, and the task there it came up in. */
-export interface TodoOrigin {
-    /** That project's main tree. */
-    project: string;
-    /** Its task the todo came up in, or null for its main tree. */
-    task: string | null;
-}
-/** What a new todo has besides its subject, all of it optional. */
-export interface TodoNew {
-    /** Whatever more there is to say about it. */
-    text?: string;
-    files?: Attachment[];
-    /** Where it goes in the list, pushing those from there down; the bottom by default. */
-    position?: number;
-    /** The todos blocking it: each has to merge before it starts. */
-    blockedBy?: number[];
-    /** The lane it goes in, `"new"` for one of its own; none by default. */
-    lane?: number | "new" | null;
-    /** The agent that should work it; none by default. */
-    assignee?: AgentPick | null;
-    /** The other project it is added from; none by default. */
-    origin?: TodoOrigin;
-}
-/** `state` worked by `assignee`, or by nobody in particular for null. */
-export declare function assigned<State extends {
-    assignee?: AgentPick;
-}>(state: State, assignee: AgentPick | null | undefined): State;
-/**
- * A subject and its detail, trimmed. A subject running past one line keeps
- * only the first, the rest leading the detail, so the list stays one line a
- * todo however it was written.
- */
-export declare function wording(subject: string, text: string): {
-    subject: string;
-    text: string;
-};
-/**
- * Runs `update`, which changes todo `id`, and journals it with what moved
- * between the todo before and after, so a refused one is journaled bare.
- */
-export declare function recordUpdate(journal: Journal, todos: Todos, id: number, update: () => Promise<Todo>): Promise<Todo>;
-/** `todos` as an event names them: each by its id and subject. */
-export declare function todosNamed(todos: readonly Todo[]): {
-    id: number;
-    subject: string;
-}[];
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+/** `splates todo`, which the root cli mounts after the task commands. */
+export declare const splatesTodo: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;

package/{splates-tunnel.d.ts → tunnel.d.ts}

@@ -1,3 +1,3 @@
-import type { SplatesDeps } from "./splates.js";
+import type { SplatesDeps } from "@stringsync/splates-server/server";
 /** `splates tunnel`, which the root cli mounts after `splates lane`. */
 export declare const splatesTunnel: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;

package/{splates-worker.d.ts → worker.d.ts}

@@ -1,3 +1,3 @@
-import type { SplatesDeps } from "./splates.js";
+import type { SplatesDeps } from "@stringsync/splates-server/server";
 /** `splates worker`, which the root cli mounts after `splates slots`. */
 export declare const splatesWorker: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;

package/acp-extensions.d.ts

@@ -1,82 +0,0 @@
-import type * as acp from "@agentclientprotocol/sdk";
-import type { ConversationState } from "./conversation-state.js";
-/**
- * What every session is opened with. Claude's AskUserQuestion is off, so its
- * questions go under `## Blocked` and into its reply, as the splates skill asks,
- * rather than into a form `SPLATES.md` never sees. Other agents ignore it.
- */
-export declare const SESSION_META: {
-    claudeCode: {
-        options: {
-            disallowedTools: string[];
-        };
-    };
-};
-/** The ACP extension that says a prompt into the turn the agent is running. */
-export declare const STEER = "_session/steering";
-/**
- * The updates and request, an ACP draft Claude's adapter speaks ahead of the
- * SDK, that say when a background command starts and ends, and stop one.
- */
-export declare const ASYNC_TASK_SPAWNED = "async_task_spawned";
-export declare const ASYNC_TASK_STATE = "async_task_state_update";
-export declare const ASYNC_TASK_PROGRESS = "async_task_progress";
-export declare const ASYNC_TASK_STOP = "_session/async_task/stop";
-/** The notification the client hears each of those updates as (see `asyncTasks`). */
-export declare const ASYNC_TASK_UPDATE = "_splates/async_task";
-/**
- * The messages from an agent, each update on a background command moved to
- * `ASYNC_TASK_UPDATE`, ahead of the SDK's checks, which would refuse it as a
- * session update they do not know.
- */
-export declare function asyncTasks(messages: ReadableStream<acp.AnyMessage>): ReadableStream<acp.AnyMessage>;
-export interface AsyncTaskSpawned {
-    sessionUpdate: typeof ASYNC_TASK_SPAWNED;
-    asyncTaskId: string;
-    name: string;
-    /** `shell` for a command, else a workflow or the like. */
-    taskType: string;
-    description: string;
-    toolCallId?: string;
-    outputFilePath?: string;
-}
-export interface AsyncTaskState {
-    sessionUpdate: typeof ASYNC_TASK_STATE;
-    asyncTaskId: string;
-    state: "running" | "paused" | "completed" | "failed" | "stopped";
-    outputFilePath?: string;
-}
-/** What the agent says as a command goes on: here, only where its output is. */
-export interface AsyncTaskProgress {
-    sessionUpdate: typeof ASYNC_TASK_PROGRESS;
-    asyncTaskId: string;
-    outputFilePath?: string;
-}
-export type AsyncTaskUpdate = AsyncTaskSpawned | AsyncTaskState | AsyncTaskProgress;
-/** Whether an agent says, as it starts, that it takes `STEER`. */
-export declare function steers(initialized: acp.InitializeResponse): boolean;
-/**
- * The AIR session list: subscribed for a working directory, the agent says
- * as each of its sessions there starts or ends a turn. Codex says so of a
- * turn it starts on its own nowhere else.
- */
-export declare const SESSION_LIST_SUBSCRIBE = "_session/list/subscribe";
-export declare const SESSION_LIST_CHANGES = "_session/list/changes";
-/** Whether an agent says, as it starts, that it takes `SESSION_LIST_SUBSCRIBE`. */
-export declare function listsSessions(initialized: acp.InitializeResponse): boolean;
-/** What a `SESSION_LIST_CHANGES` row says of a session's turn. */
-export interface ListedTurn {
-    running: boolean;
-    /** When its last turn ended, in ms; null before one has. */
-    endedAt: number | null;
-}
-/**
- * What `params` of `SESSION_LIST_CHANGES` say of `session`'s turn; null when
- * they hold no row for it, or one that says nothing of its turns, as for a
- * session no process has open.
- */
-export declare function listedTurn(params: Record<string, unknown>, session: string): ListedTurn | null;
-/** Whether `update` is the agent's final answer, after which its turn ends. */
-export declare function finalAnswer(update: acp.SessionUpdate): boolean;
-/** Folds an update on a background command into those the agent left. */
-export declare function foldBackground(state: ConversationState, update: AsyncTaskUpdate): void;

package/add.d.ts

@@ -1,53 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Fs, HeavyCap } from "webappwiz/system";
-import type { Config } from "./config.js";
-import { type RosterAgent } from "./roster.js";
-import type { Shell } from "./shell.js";
-import type { Todos } from "./todos.js";
-import type { Dispatched } from "./worktree.js";
-import type { WorktreeService } from "./worktree-service.js";
-export interface AddOptions {
-    /** Branch the task starts from and merges onto. Defaults to the trunk. */
-    base?: string;
-    /**
-     * The todos this task takes up: their words seed the plan's Goal, and
-     * nobody else can take them while the task lives.
-     */
-    todos?: number[];
-    /**
-     * One or two lines on what done means, written under `## Goal` ahead of
-     * whatever the todos 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 to hand the task to, which `splates server` starts in its tree once
-     * the tree is ready; its id must be one of `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: the task goes
-     * to an agent of its own, so `dispatch` is a must.
-     */
-    away?: boolean;
-    /**
-     * Hands the task out though the agent adding it has as many out to
-     * agents as `config.agentsPerAgent` allows, as only the person may ask.
-     */
-    overCapacity?: boolean;
-}
-export declare function add({ service, shell, config, log, fs, todos, heavy, }: {
-    service: WorktreeService;
-    shell: Shell;
-    config: Config;
-    log: Logger;
-    fs: Fs;
-    todos: Todos;
-    heavy: HeavyCap;
-}, task: string, { base, todos: ids, goal: asked, onTree, dispatch, agents, away, overCapacity, }?: AddOptions): Promise<void>;

package/adherence.d.ts

@@ -1,49 +0,0 @@
-import type { Fs } from "webappwiz/system";
-import type { ConversationState } from "./conversation-state.js";
-import type { Outcomes } from "./outcomes.js";
-import { type Transcript } from "./skill-checks.js";
-/**
- * How closely `splates server`'s conversations follow the splates skill, across
- * projects, in `~/.splates/adherence.jsonl`: a line each time a turn ends and
- * changes how a conversation's checks went, the last one standing for it. It
- * outlives the conversations' logs, which go as archived ones are pruned.
- */
-export declare class Adherence {
-    /** `~/.splates/adherence.jsonl`, or a test's own. */
-    readonly path: string;
-    private readonly fs;
-    /** Where the commits a conversation merged are kept; null to judge without them. */
-    private readonly outcomes;
-    /** The scores last written for each conversation, so a turn that changes none writes nothing. */
-    private readonly written;
-    constructor(
-    /** `~/.splates/adherence.jsonl`, or a test's own. */
-    path: string, fs: Fs, 
-    /** Where the commits a conversation merged are kept; null to judge without them. */
-    outcomes: Outcomes | null);
-    /** Judges `state` as it stands, and keeps the result when it changed. */
-    judge(state: ConversationState, project: string, at: string): Promise<void>;
-    /** Each conversation's checks as last judged. */
-    list(): Promise<Judged[]>;
-    /** What `state` merged, read from the outcomes only once it has merged anything. */
-    private endOf;
-}
-/** How each check went over one conversation: the places it applied, passed and failed. */
-export type Scores = Record<string, {
-    passed: number;
-    failed: number;
-}>;
-/** A conversation's checks as last judged, a line of `~/.splates/adherence.jsonl`. */
-export interface Judged {
-    conversation: string;
-    /** The main tree of the repository it ran in. */
-    project: string;
-    agent: string;
-    /** The splates skill version it started on; null when unknown. */
-    skill: string | null;
-    /** When it was judged, as an ISO timestamp. */
-    at: string;
-    scores: Scores;
-}
-/** A conversation as `skill-checks` reads it: what it said and ran, in order. */
-export declare function condense(state: ConversationState): Transcript;

package/age.d.ts

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

package/agent-connection.d.ts

@@ -1,171 +0,0 @@
-import * as acp from "@agentclientprotocol/sdk";
-import type { Agent, AgentProcess, ProcessHandle } from "./agent-process.js";
-import type { ConversationDeps, ConversationHost } from "./conversation-host.js";
-import type { Live } from "./conversation-log.js";
-import type { Answer, Setting } from "./conversation-state.js";
-/**
- * A conversation's side of ACP: the agent's process and the connection to
- * it, what the agent asks of this side, routed to the person, and the calls
- * the conversation makes on it. Opened anew each time the agent starts or
- * comes back, with the same session, or reattached to a process a worker
- * kept running while the coordinator restarted.
- */
-export declare class AgentConnection {
-    private readonly host;
-    private readonly deps;
-    private connection;
-    private process;
-    private stream;
-    /** What listens on the stream and the log while they are up. */
-    private listening;
-    /** How many times `open` has run, so a start that fails late knows it is still the latest. */
-    private opens;
-    /** The agent's session, once it has opened one. */
-    private session;
-    /** Settles the agent's pending ask with the person's answer. */
-    private settle;
-    /** Whether the agent takes a prompt into its running turn. */
-    private steering;
-    /**
-     * Whether the running turn is on its final answer: a prompt steered in
-     * now may find it ended, and the agent start a turn of its own for it.
-     */
-    private finishing;
-    /** Whether the agent takes images in a prompt. */
-    private seeing;
-    /** Whether the turn running is one the agent started, with no prompt to end it. */
-    private unprompted;
-    /** Whether the agent has said a turn ended, as Claude does, so one it starts can end. */
-    private tells;
-    /** Whether the agent says on its session list when a turn ends, as Codex does. */
-    private follows;
-    /**
-     * The turn the agent started for a steer, as Codex does when its turn
-     * ended on the way: when splates heard of it, in ms, and whether the
-     * session list has said since that it runs.
-     */
-    private following;
-    /** Settles once the agent has answered the last steer, which may have started a turn of its own. */
-    private steered;
-    /** The commands running, by tool call, each watched since it started. */
-    private readonly watching;
-    /** Whether the next open loads the session, replaying it, rather than resuming it. */
-    private loading;
-    /** The person's words the replay has said so far, not yet logged as a prompt. */
-    private heard;
-    /** Recovery loads replay history already in the log. */
-    private suppressReplay;
-    /** Settings picked before the session opened, set once it has. */
-    private picks;
-    /** The model asked for before the session opened, picked once it has. */
-    private model;
-    private sessionCwd;
-    constructor(host: ConversationHost, deps: ConversationDeps, { session, loading, picks, model, sessionCwd, }?: {
-        session?: string | null;
-        /** Whether the first open loads `session`, replaying it, rather than resuming it. */
-        loading?: boolean;
-        picks?: Record<string, string>;
-        model?: string | null;
-        sessionCwd?: string | null;
-    });
-    /** The agent's pid while it runs, for the commands it left running. */
-    get pid(): number | null;
-    /** What takes the agent's process back after a restart; null while none could. */
-    get handle(): ProcessHandle | null;
-    get sessionId(): string | null;
-    /** Whether the agent's process is up and speaking ACP. */
-    get connected(): boolean;
-    /** Whether the agent takes a prompt into its running turn, as it stands. */
-    get canSteer(): boolean;
-    /** Whether the agent takes images in a prompt. */
-    get sees(): boolean;
-    /** Whether the agent is waiting on the person for an answer. */
-    get asking(): boolean;
-    /**
-     * Runs the agent and opens a session with it: the one this conversation
-     * had, when there was one, else a new one.
-     */
-    open(agent: Agent, cwd: string): Promise<void>;
-    /**
-     * Speaks ACP again to `process`, which a worker kept running while the
-     * coordinator restarted, where the log left off: `live` says what was in
-     * flight. A late answer to the prompt it was on ends the turn, and the
-     * question it was asking is answered on the request it came in.
-     */
-    reattach(agent: Agent, process: AgentProcess, live: Live): void;
-    /**
-     * Releases the running agent for the next coordinator to reconnect.
-     * Flush the conversation log after awaiting this before shutting down.
-     */
-    detach(): Promise<void>;
-    /**
-     * Opens ACP over `process`, which from here is the one this conversation
-     * runs: its frames stamp the log, its exit closes the conversation, and
-     * the worker is acked for each frame once the log holds it.
-     */
-    private attach;
-    /** What `process` said on stderr if it exits within `DEATH_WAIT`, else null. */
-    private diedSaying;
-    /**
-     * Waits for no other agent to be starting, answering with what lets the
-     * next one start: once this one's process is up, has died, or has had
-     * `START_WAIT` to answer, so one that hangs holds up no other for long.
-     */
-    private startAlone;
-    /** Says `prompt` to the agent as a turn, settling with what it answered once the turn ends. */
-    prompt(prompt: acp.ContentBlock[]): Promise<acp.PromptResponse | undefined>;
-    /** Whether the agent runs a turn it started for a steer, which no prompt's answer ends. */
-    get detached(): boolean;
-    /** A stale or substituted choice must never reach a prompt or steering call. */
-    private validateModel;
-    /**
-     * Says `prompt` into the turn the agent is running, answering with what
-     * came of it: `injected`, `startedNewTurn`, or `promptRequired` when the
-     * turn ended on the way.
-     */
-    steer(prompt: acp.ContentBlock[]): Promise<string | undefined>;
-    private steerInto;
-    /** Shows the turn the agent started for a steer as running, until it ends. */
-    private follow;
-    /**
-     * Ends the turn being followed once the session list says it no longer
-     * runs. A row read before it started can come after `startedNewTurn`,
-     * saying the turn before it ended: it counts only once a row has said the
-     * turn runs, or when it ended past the second splates heard it start in,
-     * since the agent says when in whole seconds.
-     */
-    private listed;
-    /** Stops the agent's turn, if it is connected. */
-    cancel(): Promise<void>;
-    /** Stops background command `id`; the agent says it ended as it does. */
-    stopTask(id: string): Promise<void>;
-    /**
-     * Sets `setting` to `value`, answering with the session's settings as the
-     * agent then offers them: at once while it is connected, or, while it is
-     * not, as picked for when it next opens.
-     */
-    choose(setting: Setting, value: string): Promise<Setting[]>;
-    /** Settles the agent's pending ask, if `id` is still the one it is on. */
-    answer(id: string, answer: Answer): void;
-    /** Ends the process, dismissing whatever the agent was asking. */
-    close(): void;
-    /** What the agent may ask of this side, all of it routed to the person. */
-    private client;
-    /**
-     * Watches each command the agent runs from when it starts, and keeps what
-     * it did to git that it should not have once it ends.
-     */
-    private watchCommand;
-    /** Logs the person's words the replay has said, as one prompt. */
-    private logHeard;
-    /** Keeps how the person answered the permission asked for tool call `id`. */
-    private decided;
-    /**
-     * Holds `asked` until the person answers it, or the turn is cancelled,
-     * logged with the request it came in, so a coordinator started again can
-     * answer it there.
-     */
-    private ask;
-    /** Settles the pending ask, if any, with `answer`, and logs that it is answered. */
-    private settled;
-}

package/agent-errors.d.ts

@@ -1,2 +0,0 @@
-/** Redacts common credential-bearing diagnostics before persistence or display. */
-export declare function agentError(message: string): string;

package/agent-process.d.ts

@@ -1,65 +0,0 @@
-import { type Timer } from "webappwiz/time";
-/** An agent splates can hold a conversation with over ACP, and how to start it. */
-export interface Agent {
-    id: string;
-    name: string;
-    argv: string[];
-}
-/** What a process wrote to stdout, numbered from 1 so a restart can say what it holds. */
-export interface AgentFrame {
-    bytes: Uint8Array;
-    seq: number;
-}
-/** What finds a process again after a restart: the worker it runs on and its channel there. */
-export interface ProcessHandle {
-    worker: string;
-    channel: number;
-}
-/** A running agent: bytes in, frames out, and a way to stop it. */
-export interface AgentProcess {
-    /** Its pid, for what runs under it; null for one that never started. */
-    pid: number | null;
-    input: WritableStream<Uint8Array>;
-    output: ReadableStream<AgentFrame>;
-    /**
-     * Says everything up to frame `seq` is written down, so a restart replays
-     * from past it; nothing to do for a process that ends with this one.
-     */
-    ack(seq: number): void;
-    /** What takes it back after a restart; null for one that ends with this process. */
-    handle: ProcessHandle | null;
-    /** What it last wrote to stderr, for when it dies before saying why. */
-    stderr(): string;
-    exited: Promise<number>;
-    kill(): void;
-}
-/** `bytes` as frames, numbered from 1 as they come. */
-export declare function framed(bytes: ReadableStream<Uint8Array>): ReadableStream<AgentFrame>;
-/** Starts `argv` in `cwd`, with `env` added to its own, its stdio piped. */
-export type Launch = (argv: string[], cwd: string, env: Record<string, string>) => AgentProcess;
-/** What starts a conversation's agent, and takes one back after a restart. */
-export interface Launcher {
-    launch: Launch;
-    /**
-     * The process `handle` names, kept running while this coordinator was
-     * away, its output carrying on from past frame `held`, the last one the
-     * log holds. Throws when nothing here can take it back.
-     */
-    resume(handle: ProcessHandle, held: number): AgentProcess;
-}
-/** `launch` alone, for a process that ends with this one: nothing takes one back. */
-export declare function launcherOf(launch: Launch): Launcher;
-export declare const launch: Launch;
-/** A session an agent holds that splates could bring in. */
-export interface Session {
-    agent: string;
-    session: string;
-    title: string | null;
-    /** When it was last active, as the agent says; null when it does not. */
-    updatedAt: string | null;
-}
-/**
- * The sessions `agent` holds in `cwd`, asked of a process of its own that
- * stops once it answers; none when it cannot both list and load them.
- */
-export declare function listSessions(agent: Agent, cwd: string, run: Launch, timer: Timer): Promise<Session[]>;