@stringsync/splates 0.0.60 → 1.13.3

package/replica.d.ts

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

package/server.d.ts

@@ -1,6 +1,6 @@
-import { type SplatesDeps } from "@stringsync/splates-server/server";
+import { type SplatesDeps } from "./vendor/@stringsync/splates-server/server/index.js";
 /**
  * `splates server`, which the root cli mounts after `splates log`: bare, it
  * runs the server here.
  */
-export declare const splatesServer: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;
+export declare const splatesServer: import("./vendor/core/cmd/index.js").Cli<SplatesDeps, SplatesDeps>;

package/setup.d.ts

@@ -1,5 +1,5 @@
-import type { SplatesDeps } from "@stringsync/splates-server/server";
-import { Setup } from "@stringsync/splates-server/setup";
+import type { SplatesDeps } from "./vendor/@stringsync/splates-server/server/index.js";
+import { Setup } from "./vendor/@stringsync/splates-server/setup/index.js";
 /** What `splates setup` was asked for. */
 export interface SetupOptions {
     /** A step's id, or empty for every area's progress. */

package/ship.d.ts

@@ -1,3 +1,3 @@
-import type { SplatesDeps } from "@stringsync/splates-server/server";
+import type { SplatesDeps } from "./vendor/@stringsync/splates-server/server/index.js";
 /** `splates ship [project]` prints the Ships page link for the person to open. */
-export declare const splatesShip: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;
+export declare const splatesShip: import("./vendor/core/cmd/index.js").Cli<SplatesDeps, SplatesDeps>;

package/slots.d.ts

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

package/splates.d.ts

@@ -1,4 +1,4 @@
-import type { SplatesDeps } from "@stringsync/splates-server/server";
+import type { SplatesDeps } from "./vendor/@stringsync/splates-server/server/index.js";
 /**
  * Splits a leading `--project <slug>`, or `--project=<slug>`, off the
  * arguments, for `run` to be handed as `project`.
@@ -7,4 +7,4 @@ export declare function projectArgs(argv: string[]): {
     project?: string;
     argv: string[];
 };
-export declare const splates: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;
+export declare const splates: import("./vendor/core/cmd/index.js").Cli<SplatesDeps, SplatesDeps>;

package/task.d.ts

@@ -1,3 +1,3 @@
-import type { SplatesDeps } from "@stringsync/splates-server/server";
+import type { SplatesDeps } from "./vendor/@stringsync/splates-server/server/index.js";
 /** `splates task`, the queue, which the root cli mounts after the commands for the task you work on. */
-export declare const splatesTask: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;
+export declare const splatesTask: import("./vendor/core/cmd/index.js").Cli<SplatesDeps, SplatesDeps>;

package/tunnel.d.ts

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

package/vendor/@stringsync/splates-server/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 stringsync LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

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

package/vendor/@stringsync/splates-server/agents/acp-extensions.d.ts

@@ -0,0 +1,92 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import type { ConversationState } from "../conversations";
+/**
+ * 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";
+    /** What the agent says of how it ended, as Claude's `... (exit code 0)`. */
+    summary?: string;
+    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, and
+ * into the tool call that started it, at `at`.
+ */
+export declare function foldBackground(state: ConversationState, update: AsyncTaskUpdate, at: string | null): void;
+/**
+ * Ends every command the agent left running, as its process ending does,
+ * though it said nothing of them: stopped at `at`, and off the list.
+ */
+export declare function endBackground(state: ConversationState, at: string | null): void;

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

@@ -0,0 +1,19 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Setting } from "../conversations";
+import { type Roster } from "../models";
+export interface AgentsOptions {
+    /** Print the roster as JSON instead of tables. */
+    json?: boolean;
+}
+/**
+ * The roster: each agent, how it starts, its models with what each is good
+ * at and costs, and the thinking levels it offered when last started, for an
+ * orchestrator choosing whom to delegate to. Writes the defaults first when
+ * there is none, and says where, so they can be edited.
+ */
+export declare function agents({ roster, offered, log, }: {
+    roster: Roster;
+    /** What each agent's sessions last offered, by its id. */
+    offered: Record<string, Setting[]>;
+    log: Logger;
+}, { json }?: AgentsOptions): Promise<void>;

package/vendor/@stringsync/splates-server/agents/compaction.d.ts

@@ -0,0 +1,17 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import type { Compaction, ConversationState } from "../conversations";
+/** Whether `update` reports a compaction rather than a tool call of the agent's. */
+export declare function isCompaction(update: acp.ToolCall | acp.ToolCallUpdate): boolean;
+/** Takes what an update says of the compaction into it. */
+export declare function fillCompaction(part: Compaction, update: acp.ToolCall | acp.ToolCallUpdate, at: string | null): void;
+/** The compaction `id`, wherever in the conversation it was; null for none. */
+export declare function compactionIn(state: ConversationState, id: string): Compaction | null;
+/** A compaction `id` just begun at `at`, with nothing said of it yet. */
+export declare function newCompaction(id: string, at: string | null): Compaction;
+/**
+ * Takes ACP's `compaction_update` into `part`: its status, and its summary,
+ * which replaces the one kept, or clears it when null or empty.
+ */
+export declare function updateCompaction(part: Compaction, update: acp.CompactionUpdate, at: string | null): void;
+/** Appends a `compaction_summary_chunk`'s text to the summary `part` keeps. */
+export declare function appendSummary(part: Compaction, chunk: acp.CompactionSummaryChunk): void;

package/vendor/@stringsync/splates-server/agents/connection.d.ts

@@ -0,0 +1,191 @@
+import * as acp from "@agentclientprotocol/sdk";
+import type { Answer, ConversationDeps, ConversationHost, Setting } from "../conversations";
+import { type Live } from "../conversations";
+import type { Agent, AgentProcess, Launch, ProcessHandle } from "./process";
+/**
+ * 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.
+ */
+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;
+    /** Whether the next prompt is the session's first, whose missing log starts at zero. */
+    private kimiNewSession;
+    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;
+    });
+    /**
+     * Asks for `model` and `picks` once the session opens, in place of what
+     * it was started with.
+     */
+    openOn(model: string | null, picks: Record<string, string>): void;
+    /** 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. `launch` starts it on the
+     * worker it was placed on; the launcher's own by default.
+     */
+    open(agent: Agent, cwd: string, launch?: Launch): Promise<void>;
+    /**
+     * Speaks ACP again to `process`, which a worker kept running while the
+     * server 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;
+    /**
+     * Lets go of the running agent for the next server to take back:
+     * await it, then flush the conversation log, 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 `request` answers, or a failure once the agent has had `ANSWER_WAIT`
+     * and not: the start then closes the conversation with it, and the process
+     * with it, so the person sees an error to retry, not a message queued for
+     * an agent that never answers. A session loaded is left unbounded, since
+     * it answers only once the agent has replayed it.
+     */
+    private answered;
+    /** 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 session is open, it has died, or it 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>;
+    /** Kimi's cumulative model-call tokens, which its ACP response leaves out. */
+    private kimiTotal;
+    /** 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;
+    /**
+     * Lets go of the session, kept on a worker that is gone, so the next
+     * open starts a new one wherever it is placed.
+     */
+    forgetSession(): void;
+    /** Stops the agent, dismissing any question it was asking the person. */
+    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 server 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/vendor/@stringsync/splates-server/agents/errors.d.ts

@@ -0,0 +1,8 @@
+/** Redacts common credential-bearing diagnostics before persistence or display. */
+export declare function agentError(message: string): string;
+/**
+ * What an agent's failed request says, redacted: its message, and the detail
+ * an ACP error carries in `data`, without which most say only "Internal error".
+ * An agent `agent` names that refuses for want of a sign-in says how to sign in.
+ */
+export declare function requestError(error: unknown, agent?: string): string;

package/vendor/@stringsync/splates-server/agents/fold.d.ts

@@ -0,0 +1,45 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import type { ConversationState, Field, Limit, Message, Setting } from "../conversations";
+/**
+ * Folds one ACP update, sent `at`, into the messages: text runs on in the
+ * message it started, and a tool call is one part that fills in as it runs.
+ */
+export declare function fold(state: ConversationState, update: acp.SessionUpdate, at?: string | null): void;
+/**
+ * The windows Claude's rate limit info in `update` tells of: every one in
+ * `unifiedWindows` when it sends them, else the one it names. Its
+ * `utilization` runs from 0 to 1, and `resetsAt` is in seconds.
+ */
+export declare function limitsIn(update: acp.UsageUpdate, at: string | null): Limit[];
+/** `limits`, each window in `news` replaced by what it says now. */
+/** The prefix of a limit window recording that OpenCode refused a model for its Go cap. */
+export declare const CAP_PREFIX = "cap:";
+export declare function heard(limits: Limit[], news: Limit[]): Limit[];
+/** Adds the tokens a turn used to those of the turns before it. */
+export declare function tally(state: ConversationState, usage: acp.Usage): void;
+/**
+ * The agent's message at the end, started if the person spoke last, marked
+ * as having moved `at`. Queued messages stay below it: the agent has yet to
+ * hear them, so nothing it says meanwhile answers them.
+ */
+export declare function agentTurn(state: ConversationState, at: string | null): Message;
+/** Marks the agent's message at the end, if it is the last, as having moved `at`. */
+export declare function moved(state: ConversationState, at: string | null): void;
+/** Whether `update` is the agent at work, as it is only in a turn. */
+export declare function starts(update: acp.SessionUpdate): boolean;
+/**
+ * Whether `update` ends a turn: Claude says where each turn came from in the
+ * usage it sends at the turn's end, and only then.
+ */
+export declare function result(update: acp.SessionUpdate): boolean;
+/** The session's settings the agent lets the person pick from, in its order. */
+export declare function settingsIn(options: acp.SessionConfigOption[] | null | undefined): Setting[];
+/** `value` for `setting` as ACP sets it: a toggle's as a boolean. */
+export declare function configValue(setting: Setting, value: string): {
+    type: "boolean";
+    value: boolean;
+} | {
+    value: string;
+};
+/** A form an agent asks with, as the fields the page shows. */
+export declare function fieldsIn(schema: unknown): Field[];

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

@@ -0,0 +1,16 @@
+export type { AsyncTaskUpdate } from "./acp-extensions";
+export { endBackground, foldBackground } from "./acp-extensions";
+export { agents } from "./agents";
+export { AgentConnection } from "./connection";
+export { agentError, requestError } from "./errors";
+export { agentTurn, CAP_PREFIX, fold, heard, result, tally } from "./fold";
+export type { Agent, AgentFrame, AgentProcess, Launch, Launcher, ProcessHandle, Session, } from "./process";
+export { framed, launch, launcherOf, listSessions } from "./process";
+export { prepareScratch, SCRATCH, scratchLaunch } from "./scratch";
+export type { SessionServers } from "./shared-browser";
+export { PLAYWRIGHT_MCP, SharedBrowser } from "./shared-browser";
+export { StartLock } from "./start-lock";
+export { AgentStream } from "./stream";
+export { toolIn } from "./tool-calls";
+export type { Flag } from "./watch";
+export { Watch } from "./watch";

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

@@ -0,0 +1,60 @@
+import {
+  toolIn2,
+  foldBackground2,
+  endBackground2,
+  agents2,
+  agentError2,
+  requestError2,
+  fold2,
+  CAP_PREFIX2,
+  heard2,
+  tally2,
+  agentTurn2,
+  result2,
+  SCRATCH2,
+  prepareScratch2,
+  scratchLaunch2,
+  AgentStream2,
+  AgentConnection2,
+  framed2,
+  launcherOf2,
+  launch2,
+  listSessions2,
+  PLAYWRIGHT_MCP2,
+  SharedBrowser2,
+  StartLock2,
+  Watch2
+} 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 {
+  AgentConnection2 as AgentConnection,
+  AgentStream2 as AgentStream,
+  CAP_PREFIX2 as CAP_PREFIX,
+  PLAYWRIGHT_MCP2 as PLAYWRIGHT_MCP,
+  SCRATCH2 as SCRATCH,
+  SharedBrowser2 as SharedBrowser,
+  StartLock2 as StartLock,
+  Watch2 as Watch,
+  agentError2 as agentError,
+  agentTurn2 as agentTurn,
+  agents2 as agents,
+  endBackground2 as endBackground,
+  fold2 as fold,
+  foldBackground2 as foldBackground,
+  framed2 as framed,
+  heard2 as heard,
+  launch2 as launch,
+  launcherOf2 as launcherOf,
+  listSessions2 as listSessions,
+  prepareScratch2 as prepareScratch,
+  requestError2 as requestError,
+  result2 as result,
+  scratchLaunch2 as scratchLaunch,
+  tally2 as tally,
+  toolIn2 as toolIn
+};

package/vendor/@stringsync/splates-server/agents/process.d.ts

@@ -0,0 +1,67 @@
+import type { Lock } from "../../../core/system/index.js";
+import { type Timer } from "../../../core/time/index.js";
+/** 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 server 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.
+ * `starting` is the lock a conversation's agent takes as it starts.
+ */
+export declare function listSessions(agent: Agent, cwd: string, run: Launch, timer: Timer, starting: Lock): Promise<Session[]>;

package/vendor/@stringsync/splates-server/agents/scratch.d.ts

@@ -0,0 +1,7 @@
+import type { Fs } from "../../../core/system/index.js";
+/** Set on an agent process that must write only in its scratch and agent state. */
+export declare const SCRATCH = "SPLATES_SCRATCH";
+/** Makes the directories a scratch agent may write, on the machine it will run on. */
+export declare function prepareScratch(fs: Fs, agent: string, cwd: string, home?: string): Promise<void>;
+/** `argv` sandboxed when `env` marks a scratch agent, unchanged otherwise. */
+export declare function scratchLaunch(argv: string[], cwd: string, env: Record<string, string>, platform: string, home?: string): string[];