@stringsync/splates 0.0.0-stage → 0.0.45

package/init.d.ts

@@ -0,0 +1,28 @@
+import { type Logger } from "webappwiz/log";
+import type { Fs, Ps } from "webappwiz/system";
+import type { Git } from "./git.js";
+import type { Projects } from "./projects.js";
+/**
+ * Makes this repository a splates project: `repository` has set up its records
+ * by now, when it had none, so what is left is installing the skill that
+ * teaches its agents to work through splates, through `bunx skills add` from
+ * this release's tag, and joining the registry, which
+ * lets one `splates server` serve it beside every other. Run again, or in a
+ * project already under way, it changes nothing that is already so.
+ */
+export declare function init({ git, projects, fs, ps, log, }: {
+    git: Git;
+    projects: Projects;
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+}): Promise<void>;
+/**
+ * Takes this repository off the registry, so `splates server` no longer offers it:
+ * its records stay, and `splates init` brings it back.
+ */
+export declare function forget({ git, projects, log, }: {
+    git: Git;
+    projects: Projects;
+    log: Logger;
+}): Promise<void>;

package/journal.d.ts

@@ -0,0 +1,57 @@
+import { type Fs, type Ps } from "webappwiz/system";
+import { type Action, type Event, type Facts, type FactsOf } from "./events.js";
+/** How long a log file is kept once it fills, so a live conversation can still show the events in it. */
+export declare const LOG_KEPT_MS: number;
+/** What a `Journal` is stored through; the real filesystem and process by default. */
+export interface JournalOptions {
+    fs?: Fs;
+    ps?: Ps;
+}
+/**
+ * What has been done in this repo, oldest first. Events outlive their tasks:
+ * `merge` and `remove` take the record with them, so this is the only thing
+ * that remembers a task existed at all.
+ *
+ * Each event is appended, never rewritten, so two agents writing at once both
+ * keep theirs. Once the file holds `capacity` events it is moved into the
+ * `log` directory beside it, under a name that sorts by when, and a fresh one
+ * starts; moved files go once they are `LOG_KEPT_MS` old.
+ */
+export declare class Journal {
+    private readonly path;
+    private readonly capacity;
+    private readonly fs;
+    private readonly ps;
+    private readonly archive;
+    constructor(path: string, capacity: number, opts?: JournalOptions);
+    record<A extends Action, T>(action: A, task: string | null, run: () => Promise<T>, ...[facts]: FactsOf<A, T>): Promise<T>;
+    /**
+     * Logs a wait as it begins, then `record`s how it ended with `began`
+     * naming that first event, so the page can count it down while it runs.
+     */
+    waiting<A extends "wait" | "todo wait" | "creds wait", T>(action: A, task: string | null, facts: Omit<Facts[A], "began">, run: () => Promise<T>): Promise<T>;
+    tail(count: number): Promise<Event[]>;
+    /**
+     * The events in the log and in the file moved aside last: every event
+     * written since a reader last looked, so long as it looks before the log
+     * fills twice over.
+     */
+    recent(): Promise<Event[]>;
+    private append;
+    /**
+     * Moves the full file aside. Two writers rotating at once is harmless: the
+     * second either finds nothing to move or moves the few events written since,
+     * under a name of its own.
+     */
+    private rotate;
+    /** The moved files, oldest first. */
+    private archived;
+    /**
+     * The events in `path` that carry every fact their action records now:
+     * one that went through before its action recorded them is left out,
+     * since a reader trusts an event's facts as its type gives them.
+     */
+    private read;
+    /** Every event in `path`, whatever facts it carries. */
+    private parsed;
+}

package/landed.d.ts

@@ -0,0 +1,14 @@
+import { type Baseline } from "./baselines.js";
+import type { Outcome } from "./outcomes.js";
+/** How a merged task went, beside how its project's tasks went the week before. */
+export interface Landed {
+    outcome: Outcome;
+    /** Its project's tasks over the week to its merge, itself among them; null for none. */
+    baseline: Baseline | null;
+}
+/**
+ * The last merge of `task` in `project`, held against the week up to it, so
+ * the comparison reads the same however long after it is asked. Null when it
+ * never merged there.
+ */
+export declare function landed(outcomes: Outcome[], project: string, task: string): Landed | null;

package/lane-todos.d.ts

@@ -0,0 +1,44 @@
+import type { Fs } from "webappwiz/system";
+import type { LaneRecord } from "./lanes.js";
+import type { TodoState } from "./todo.js";
+/** A todo in a lane, as a lane's orchestrator hears of it. */
+export interface LaneTodo {
+    id: number;
+    /** Its lane, by number and name, the name kept for once the lane ends. */
+    lane: {
+        id: number;
+        name: string;
+    };
+    /** Whether a task has taken it. */
+    taken: boolean;
+}
+/** What became of a todo in a lane since it was last seen. */
+export interface LaneTodoChange {
+    todo: number;
+    lane: {
+        id: number;
+        name: string;
+    };
+    /** `done` once it left the list, merged or removed; `open` once its task let it go. */
+    change: "done" | "open";
+}
+/** The todos in a lane, out of every todo and the lanes on the board. */
+export declare function laneTodos(todos: TodoState[], lanes: LaneRecord[]): LaneTodo[];
+/**
+ * What became of each todo in `before` by `now`: done for one gone from the
+ * list, open for one taken then and not now. One that moved lanes, or came
+ * into one, is neither.
+ */
+export declare function laneChanges(before: LaneTodo[], now: LaneTodo[], all: TodoState[]): LaneTodoChange[];
+/**
+ * The lane todos as last seen, kept on disk, so what changed while `splates
+ * dev` was down is told once it is back.
+ */
+export declare class SeenLaneTodos {
+    private readonly fs;
+    private readonly path;
+    constructor(fs: Fs, path: string);
+    /** What was last seen, or null before anything was. */
+    read(): Promise<LaneTodo[] | null>;
+    write(seen: LaneTodo[]): Promise<void>;
+}

package/lane.d.ts

@@ -0,0 +1,55 @@
+import { type Logger } from "webappwiz/log";
+import type { Facts } from "./events.js";
+import type { Journal } from "./journal.js";
+import { type LaneRecord } from "./lanes.js";
+import type { Todos } from "./todos.js";
+export interface LaneListOptions {
+    /** Print the lanes as JSON instead of a table. */
+    json?: boolean;
+}
+/** Every lane, with its todos in order, who is on it, and what blocks it. */
+export declare function laneList({ todos, log }: {
+    todos: Todos;
+    log: Logger;
+}, { json }?: LaneListOptions): Promise<void>;
+export interface LaneShowOptions {
+    /** Print the lane as JSON instead of prose. */
+    json?: boolean;
+}
+/**
+ * One lane in full, step by step: what an agent handed `[SPLATES LANE N]`
+ * reads to know which todo is next, and whether it is blocked first. For
+ * null, the untriaged todos, and how to place them in lanes.
+ */
+export declare function laneShow({ todos, log }: {
+    todos: Todos;
+    log: Logger;
+}, id: number | null, { json }?: LaneShowOptions): Promise<void>;
+/** Starts an empty lane called `name`, after the others. */
+export declare function laneAdd({ todos, log }: {
+    todos: Todos;
+    log: Logger;
+}, name: string): Promise<LaneRecord>;
+export interface LaneUpdateOptions {
+    /** What it is called from now on. */
+    name?: string;
+    /** Where it goes among the lanes, 1 the first; the others close up around it. */
+    position?: number;
+}
+/** Calls a lane by another name, or moves it among the others. */
+export declare function laneUpdate({ todos, log }: {
+    todos: Todos;
+    log: Logger;
+}, id: number, { name, position }?: LaneUpdateOptions): Promise<LaneRecord>;
+/** What a lane update changed, for the event: only the parts it was asked to. */
+export declare function laneUpdated(id: number, record: LaneRecord, { name, position }: LaneUpdateOptions): Facts["lane update"];
+/**
+ * Runs `drop`, which removes lane `id`, and journals it with the lane's name
+ * and the todos it sent back to none, read before it went.
+ */
+export declare function recordLaneRemove(journal: Journal, todos: Todos, id: number, drop: () => Promise<void>): Promise<void>;
+/** Removes a lane, putting its todos back with the untriaged ones. */
+export declare function laneRemove({ todos, log }: {
+    todos: Todos;
+    log: Logger;
+}, id: number): Promise<void>;

package/lanes-from-tags.d.ts

@@ -0,0 +1,17 @@
+import { type Logger } from "webappwiz/log";
+import { type Fs, type Ps } from "webappwiz/system";
+/** Where the repository at `dir` keeps its todos, and what to do it with. */
+export interface LanesFromTagsOptions {
+    /** The root of a repository, or of one of its worktrees. */
+    dir: string;
+    log?: Logger;
+    fs?: Fs;
+    ps?: Ps;
+}
+/**
+ * Moves the todos of the repository at `dir` that still have tags, from
+ * before splates kept lanes instead, into a lane a tag, and says where each
+ * went; splates refuses to read them until then. Says nothing when `dir` is
+ * no repository, keeps no todos, or none has tags.
+ */
+export declare function lanesFromTags(opts: LanesFromTagsOptions): Promise<void>;

package/lanes.d.ts

@@ -0,0 +1,96 @@
+import type { TodoState } from "./todo.js";
+/**
+ * What blocks which todos, and the lanes they run in, worked out from the
+ * todos alone. Nothing here reads or writes the disk, so the CLI and the
+ * `splates server` page draw the same lanes from the same list.
+ */
+/** A todo that has to merge first, and where it stands now. */
+export interface Blocker {
+    id: number;
+    subject: string;
+    /** The lane it is in, or null when it is in none. */
+    lane: number | null;
+    /** The task working on it, or null while nobody has it. */
+    takenBy: string | null;
+}
+/**
+ * A lane as stored: its number, never handed out again once it is gone, and
+ * what it is called. Lanes are kept in the order the board shows them.
+ */
+export interface LaneRecord {
+    id: number;
+    name: string;
+}
+/** A queue of todos that build on each other, worked top first. */
+export interface LaneState {
+    id: number;
+    name: string;
+    todos: TodoState[];
+    /** The tasks at work on its todos now, top first: who is on the lane. */
+    agents: string[];
+    /** The first todo no task has taken: what the lane's orchestrator hands out next. */
+    next: TodoState | null;
+    /**
+     * Todos in other lanes, or in none, blocking `next` that have
+     * yet to merge: what the lane is waiting on before it can go on.
+     */
+    blockers: Blocker[];
+    /** `next` can be taken now: nothing blocking it is left but in this lane's hands. */
+    ready: boolean;
+}
+/**
+ * Every lane, in the order `records` keeps them, each with its todos in list
+ * order. A lane some todo is in but `records` lacks, as one written before
+ * lanes had names, comes last, called by its number.
+ */
+export declare function lanes(todos: TodoState[], records: LaneRecord[]): LaneState[];
+/** `records`, and after them a record for each lane a todo is in that they lack. */
+export declare function named(todos: TodoState[], records: LaneRecord[]): LaneRecord[];
+/** The lane `record` stands for, empty when no todo is in it. */
+export declare function lane(todos: TodoState[], { id, name }: LaneRecord): LaneState;
+/** What blocks `todo` and has yet to merge, in list order. */
+export declare function blockersOf(todos: TodoState[], todo: TodoState): Blocker[];
+/** The todos `id` blocks, in list order. */
+export declare function followers(todos: TodoState[], id: number): TodoState[];
+/** Nothing blocking it is still open, and nobody has it: free to start. */
+export declare function isReady(todo: TodoState): boolean;
+/**
+ * The todos that would form a loop if `blocker` blocked `id`, as the chain
+ * from `id` round to itself in merge order, or null when there is none. A
+ * loop is `id` already blocking `blocker`, however far down.
+ */
+export declare function cycle(todos: TodoState[], id: number, blocker: number): number[] | null;
+/**
+ * `todos` in list order, but with each one below every todo in its own lane
+ * that blocks it: a todo that would come too soon is moved down to just
+ * below the last of them, and everything else keeps its place.
+ */
+export declare function settle(todos: TodoState[]): TodoState[];
+/**
+ * The first pair in `todos`, in list order, where a todo sits above one in
+ * its own lane that blocks it; null when the lanes all keep to their
+ * links.
+ */
+export declare function misordered(todos: TodoState[]): {
+    todo: TodoState;
+    blockedBy: TodoState;
+} | null;
+/** A blocking todo, and the lane it is in by name: `#177 in Licensing`. */
+export declare function blockerLabel({ id, lane }: {
+    id: number;
+    lane: number | null;
+}, records: LaneRecord[]): string;
+/**
+ * A name for a lane holding `todos`, none of `taken`: its first todo's
+ * subject, numbered past any lane already called that. The user renames it
+ * to what the run adds up to.
+ */
+export declare function aptName(todos: TodoState[], taken: string[]): string;
+/**
+ * The todos a markdown text mentions as `#N`, once each, in the order
+ * mentioned. Code spans and blocks are left out, where `#3` means something
+ * else, as is `#N` inside a word or a link like `page#2`.
+ */
+export declare function mentioned(text: string): number[];
+/** `#` and a number, standing on its own. */
+export declare const MENTION: RegExp;

package/legacy-names.d.ts

@@ -0,0 +1,70 @@
+import type { Logger } from "webappwiz/log";
+import type { Fs, Ps } from "webappwiz/system";
+/** splates's old name, as its command, its skill and its directories went by. */
+export declare const LEGACY = "arbor";
+/** The old name of a `SPLATES_*` variable or cred, or null for any other. */
+export declare function legacyName(name: string): string | null;
+/** The `SPLATES_*` name of an `ARBOR_*` variable or cred, or null for any other. */
+export declare function renamed(old: string): string | null;
+/** A task's notes file in a worktree made before the rename. */
+export declare const LEGACY_PLAN_FILE = "ARBOR.md";
+/** The state directory under `.git`, and the home directory's, before the rename. */
+export declare const LEGACY_DIR = "arbor";
+/** Says once per process, on stderr, that an old name was used. */
+declare class Warnings {
+    #private;
+    once(name: string, instead: string): void;
+}
+export declare const legacyWarnings: Warnings;
+/**
+ * `next`, or `old` while only the old directory is there: until `splates server`
+ * has moved it, every command reads records where arbor left them.
+ */
+export declare function unmigrated(next: string, old: string): string;
+/** What `moveLegacyDir` works with. */
+export interface MoveOptions {
+    fs: Fs;
+    log: Logger;
+    /** Makes `path` a symbolic link to `target`; the real one by default. */
+    link?: (target: string, path: string) => Promise<void>;
+}
+/**
+ * Moves arbor's directory `old` to `next` and leaves a link at `old`, so the
+ * absolute paths records hold, attachments named in plans, todos and
+ * conversations above all, still resolve. Does nothing once moved, or when
+ * `next` is already there. Answers whether it moved.
+ */
+export declare function moveLegacyDir(old: string, next: string, { fs, log, link }: MoveOptions): Promise<boolean>;
+/** Renames a worktree's `ARBOR.md` to `planFile`, unless it has one already. */
+export declare function movePlan(tree: string, planFile: string, fs: Fs): Promise<void>;
+/**
+ * `path` under `.git/splates` when it names a file under `.git/arbor`, as
+ * plans, todos and conversations written before the move do.
+ */
+export declare function movedPath(path: string): string;
+/** The old name of the file a repo keeps `file`'s settings in, or null. */
+export declare function legacyFile(file: string): string | null;
+/** What `renameLegacyFiles` and `removeLegacySkill` work with. */
+export interface LegacyRepoOptions {
+    /** The repository's main tree. */
+    root: string;
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+}
+/**
+ * Renames `arbor.config.ts` and `arbor.systems.ts` to splates's names, through
+ * git when it tracks them so the rename is staged as one, and points their
+ * imports of `@webappwiz/arbor` at `@stringsync/splates`. Leaves a file alone when one
+ * under the new name is already there.
+ */
+export declare function renameLegacyFiles({ root, fs, ps, log, }: LegacyRepoOptions): Promise<void>;
+/**
+ * Takes arbor's skill at `path` out of its project, which splates's replaces.
+ * Leaves one that links to a copy kept by hand.
+ */
+export declare function removeLegacySkill(path: string, { fs, log }: {
+    fs: Fs;
+    log: Logger;
+}): Promise<void>;
+export {};

package/legacy-ps.d.ts

@@ -0,0 +1,31 @@
+import type { Resource } from "webappwiz/disposable";
+import { type Child, type Ps, type SpawnCaptureResult, type SpawnOptions, type SpawnResult, type StartOptions, type TerminalChild, type TerminalOptions } from "webappwiz/system";
+/**
+ * A `Ps` that reads each `SPLATES_*` variable under its `ARBOR_*` name too,
+ * warning once, and sets both names on every child, so a `wiz` or skill still
+ * reading the old ones sees what splates means.
+ */
+export declare class LegacyNamesPs implements Ps {
+    private readonly inner;
+    constructor(inner: Ps);
+    get platform(): NodeJS.Platform;
+    get pid(): number;
+    get hostname(): string;
+    get args(): string[];
+    get self(): string[];
+    env(name: string): string | undefined;
+    alive(pid: number): boolean;
+    spawn(argv: string[], opts?: SpawnOptions): Promise<SpawnResult>;
+    spawnCapture(argv: string[], opts?: SpawnOptions): Promise<SpawnCaptureResult>;
+    start(argv: string[], opts?: StartOptions): Child;
+    startOnTerminal(argv: string[], opts: TerminalOptions): TerminalChild;
+    processes(): ReturnType<Ps["processes"]>;
+    listening(): ReturnType<Ps["listening"]>;
+    cwd(): string;
+    cd(path: string): void;
+    exit(code: number): void;
+    on(signal: string, handler: (...args: unknown[]) => void): Resource;
+    once(event: "exit", handler: () => void): Resource;
+}
+/** The machine's processes, under both names. */
+export declare function systemPs(): Ps;

package/limits.d.ts

@@ -0,0 +1,32 @@
+import type { Fs } from "webappwiz/system";
+import { type Limit } from "./conversations.js";
+/**
+ * Each agent's plan limits as it last said, from any project, kept under the
+ * user's home: a new conversation shows how much of the plan is left before
+ * any conversation in its project has said.
+ */
+export declare class Limits {
+    /** `~/.splates/limits.json`, or a test's own. */
+    readonly path: string;
+    private readonly deps;
+    /** Read once, then kept: this process is the one writing it. */
+    private known;
+    /** Set when a newer splates wrote the file, which this one leaves alone. */
+    private newer;
+    /** Writes one after another, so none is lost to another. */
+    private writing;
+    constructor(
+    /** `~/.splates/limits.json`, or a test's own. */
+    path: string, deps: {
+        fs: Fs;
+    });
+    /** Every agent's limits, by its id; none for one that never said. */
+    all(): Promise<Record<string, Limit[]>>;
+    /**
+     * Keeps each of `limits` that is newer than what `agent` said of its
+     * window before: a log read back can be older than another project's.
+     */
+    remember(agent: string, limits: Limit[]): Promise<void>;
+    private read;
+    private write;
+}

package/list.d.ts

@@ -0,0 +1,18 @@
+import { type Logger } from "webappwiz/log";
+import type { Fs } from "webappwiz/system";
+import type { WorktreeService } from "./worktree-service.js";
+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/load-config.d.ts

@@ -0,0 +1,44 @@
+import { type Fs } from "webappwiz/system";
+import type { Config } from "./config.js";
+import { Git } from "./git.js";
+/** The file a repo's settings are in, at its root. */
+export declare const CONFIG_FILE = "splates.config.ts";
+export interface LoadConfigOptions {
+    /** What `splates.config.ts` is looked for through; the real one by default. */
+    fs?: Fs;
+    /** What the trunk is detected through; the repo's own git by default. */
+    git?: Git;
+}
+/**
+ * The settings splates runs a repo with: what `splates.config.ts` names, then the
+ * branch `origin/HEAD` points at for the trunk, then splates's own defaults.
+ * Throws when the config file is there but cannot be imported.
+ */
+export declare function loadConfig(root: string, opts?: LoadConfigOptions): Promise<Config>;
+/** Reads the TypeScript files a repo keeps its settings in, through `fs`. */
+export declare class ConfigFiles {
+    private readonly fs;
+    constructor(fs?: Fs);
+    /**
+     * What `root`'s `splates.config.ts` names, or nothing when there is no such
+     * file. Systems live in `splates.systems.ts` now: a config that still names
+     * them is read without them, so `splates update` can run to move them.
+     */
+    read(root: string): Promise<Partial<Config>>;
+    /**
+     * Everything `root`'s `splates.config.ts` exports as its default, unchecked, or
+     * nothing when there is no such file.
+     */
+    importConfig(root: string): Promise<Record<string, unknown>>;
+    /**
+     * Where `file` is at `root`, under arbor's old name for it until `splates
+     * update` renames it, or null when it is under neither.
+     */
+    private found;
+    /**
+     * What the TypeScript file `file` at `root` exports as its default, unchecked,
+     * or nothing when there is no such file. Read afresh whenever the file has
+     * changed, so a long-running `splates server` sees an edit without a restart.
+     */
+    importDefault(root: string, file: string): Promise<Record<string, unknown>>;
+}

package/log.d.ts

@@ -0,0 +1,14 @@
+import { type Logger } from "webappwiz/log";
+import type { Journal } from "./journal.js";
+/** Enough to cover a session's worth of work without scrolling. */
+export declare const DEFAULT_COUNT = 20;
+export interface LogOptions {
+    /** How many of the most recent entries to show. */
+    count?: number;
+    /** Print the entries as JSON instead of a table. */
+    json?: boolean;
+}
+export declare function log({ journal, log }: {
+    journal: Journal;
+    log: Logger;
+}, { count, json }?: LogOptions): Promise<void>;

package/machine.d.ts

@@ -0,0 +1,42 @@
+import type { Fs } from "webappwiz/system";
+/** How hard the machine `splates server` runs on is working right now. */
+export interface MachineReading {
+    /** What the page calls the machine: "Mac" on macOS, else "machine". */
+    kind: "Mac" | "machine";
+    /** The share of CPU time busy since the reading before, 0 to 1. */
+    cpu: number;
+    /** The share of memory in use, 0 to 1. */
+    memory: number;
+    /** The load average over the last minute. */
+    load: number;
+    cores: number;
+    /** The hottest CPU sensor in °C, or null where none can be read. */
+    temperature: number | null;
+}
+/** Where a reading comes from: the OS by default, a fake in tests. */
+export interface MachineSensors {
+    platform: NodeJS.Platform;
+    cpus(): {
+        times: Record<"user" | "nice" | "sys" | "idle" | "irq", number>;
+    }[];
+    loadavg(): number[];
+    freemem(): number;
+    totalmem(): number;
+    temperature(): Promise<number | null>;
+}
+/**
+ * Reads the machine on each ask, its CPU share taken over the time since the
+ * ask before, or since it was made for the first.
+ */
+export declare class Machine {
+    #private;
+    constructor(sensors: MachineSensors);
+    read(): Promise<MachineReading>;
+}
+/**
+ * The machine this process runs on. Temperature is read from Linux's thermal
+ * zones, and from the CPU die sensors on Apple Silicon; null elsewhere.
+ */
+export declare function osSensors(fs: Fs): MachineSensors;
+/** The hottest of Linux's thermal zones under `root`, in °C, or null for none. */
+export declare function thermalZones(fs: Fs, root: string): Promise<number | null>;

package/merge.d.ts

@@ -0,0 +1,35 @@
+import { type Logger } from "webappwiz/log";
+import type { Fs, HeavyCap, Lock } from "webappwiz/system";
+import type { Config } from "./config.js";
+import type { Facts } from "./events.js";
+import type { Git } from "./git.js";
+import type { Shell } from "./shell.js";
+import { type Slots } from "./slots.js";
+import type { Todos } from "./todos.js";
+import type { FailedTest } from "./worktree.js";
+import type { WorktreeService } from "./worktree-service.js";
+/**
+ * Lands the current worktree's branch on its base branch, trunk unless the
+ * task was created with `--base`. Never a merge commit: it rebases onto the
+ * base, runs the gate there, and fast-forwards the base with
+ * `git merge --ff-only`, in whichever worktree has the base checked out.
+ * History stays linear.
+ */
+export declare function merge({ service, git, lock, shell, config, log, todos, fs, slots, heavy, }: {
+    service: WorktreeService;
+    git: Git;
+    lock: Lock;
+    shell: Shell;
+    config: Config;
+    log: Logger;
+    todos: Todos;
+    fs: Fs;
+    slots: Slots;
+    heavy: HeavyCap;
+}, cwd: string, facts?: Partial<Facts["merge"]>): Promise<void>;
+/**
+ * The tests a runner reported as failing, each with what it said, which the
+ * tail cuts off. Another runner prints none, so the tail alone is what the
+ * agent gets.
+ */
+export declare function failedTests(output: string): FailedTest[];

package/migrate-config.d.ts

@@ -0,0 +1,31 @@
+import { type Logger } from "webappwiz/log";
+import type { Fs } from "webappwiz/system";
+import { type SystemsFile } from "./systems.js";
+/**
+ * Moves the systems an older `splates.config.ts` names into `splates.systems.ts`,
+ * taking the `systems` key out of the config. Does nothing when the config
+ * names none. Rewrites the config only once re-importing it shows the rest of
+ * it unchanged, and puts it back otherwise. Answers with the exit code to end
+ * on.
+ */
+export declare function moveSystems({ root, fs, log, }: {
+    /** The repository's main tree. */
+    root: string;
+    fs: Fs;
+    log: Logger;
+}): Promise<number>;
+/**
+ * Types an older `splates.config.ts` by a type-only import and `satisfies`
+ * rather than `defineConfig`, so a reader can import it without splates
+ * installed. Leaves a config it cannot rewrite as it is, since
+ * `defineConfig` still works. Rewrites it only once re-importing it shows it
+ * unchanged, and puts it back otherwise.
+ */
+export declare function typeConfig({ root, fs, log, }: {
+    /** The repository's main tree. */
+    root: string;
+    fs: Fs;
+    log: Logger;
+}): Promise<void>;
+/** A `splates.systems.ts` that names `systems`, keys unquoted where they can be. */
+export declare function systemsSource(systems: SystemsFile): string;

package/models.d.ts

@@ -0,0 +1,24 @@
+import type { Fs } from "webappwiz/system";
+import type { Setting } from "./conversations.js";
+/**
+ * Where `model` is among `settings`: the model setting's id, and the value
+ * there whose value or name it is; null when none offers it. Provider-qualified
+ * values always require an exact ID; `exact` also disables all display aliases.
+ */
+export declare function modelOption(settings: Setting[], model: string, exact?: boolean): {
+    setting: string;
+    value: string;
+} | null;
+/**
+ * The model `settings` has picked, by its name, `Opus 5.5`; for a default,
+ * the model its description says it stands for. Null when none is offered.
+ */
+export declare function pickedModel(settings: Setting[]): string | null;
+/**
+ * The agent the conversation logged at `log` runs, and the model it last had
+ * picked; null when there is no such log.
+ */
+export declare function ranWith(log: string, fs: Fs): Promise<{
+    agent: string;
+    model: string | null;
+} | null>;