@stringsync/splates 0.0.45 → 0.0.46

package/agent-stream.d.ts

@@ -1,91 +0,0 @@
-import type * as acp from "@agentclientprotocol/sdk";
-import { type Eventful } from "webappwiz/events";
-import type { AgentProcess } from "./agent-process.js";
-/** What an `AgentStream` says beyond the messages it carries. */
-export interface AgentStreamEvents extends Record<string, unknown> {
-    /** A message of the frame with this seq is being handed over. */
-    handling: number;
-    /** Every message of the frame with this seq has been dispatched. */
-    dispatched: number;
-    /** A response to a request sent before this stream, by an id under its base. */
-    stale: acp.AnyResponse;
-    /** A request this side sent, by the id it went out with. */
-    request: {
-        id: number;
-        method: string;
-    };
-}
-export interface AgentStreamOptions {
-    /**
-     * Where this side's request ids start: after a restart, give one past the
-     * highest id the log holds, so a late answer to an old request comes
-     * back as `stale` rather than as an answer to a new one.
-     */
-    base?: number;
-}
-/**
- * ACP over an agent's frames, for the SDK's connection to read and write. It
- * hands over one message at a time and waits for the connection to have
- * handled it before the next, so `seq` names the frame of the message being
- * handled while its handler runs. Lines are held until a frame ends on a
- * newline, so a replay from past `dispatched` starts at a line and repeats
- * none.
- */
-export declare class AgentStream implements acp.Stream, Eventful<AgentStreamEvents> {
-    private readonly process;
-    readonly readable: ReadableStream<acp.AnyMessage>;
-    readonly writable: WritableStream<acp.AnyMessage>;
-    private readonly dispatcher;
-    readonly events: import("webappwiz/events").Events<AgentStreamEvents>;
-    /** Added to every request id sent. */
-    readonly base: number;
-    private readonly frames;
-    private more;
-    private ended;
-    /** Text since the last frame that ended on a newline. */
-    private partial;
-    private _seq;
-    private _dispatched;
-    private _lastId;
-    private _asking;
-    /** Whether a frame has been handed over in part, which `detach` lets finish. */
-    private midFrame;
-    private detaching;
-    private writer;
-    private writing;
-    constructor(process: AgentProcess, { base }?: AgentStreamOptions);
-    /** The seq of the frame the message being handled came in, 0 before the first. */
-    get seq(): number;
-    /** The highest seq every message of whose frame has been handled. */
-    get dispatched(): number;
-    /** The id the last request this side sent went out with; null before the first. */
-    get lastId(): number | null;
-    /**
-     * The id of the agent's request being handled, for a handler to log
-     * what it is answering; null while the message being handled is not one.
-     */
-    get asking(): acp.JsonRpcId | null;
-    /**
-     * Stops handing messages over at the end of the frame being handled, so
-     * a log flushed after this holds whole frames only, and settles once it
-     * has: the frames after it stay with the process for the next stream.
-     */
-    detach(): Promise<void>;
-    /**
-     * Answers request `id` of the agent's as it was on the wire, for one a
-     * log holds from before this stream, which the connection never heard.
-     */
-    respond(id: acp.JsonRpcId, answer: {
-        result: unknown;
-    } | {
-        error: acp.ErrorResponse;
-    }): Promise<void>;
-    private read;
-    private pull;
-    private finish;
-    /** A response to this side's request, with the id it asked by; or null for one handed back as stale. */
-    private incoming;
-    private outgoing;
-    private send;
-    private input;
-}

package/agents.d.ts

@@ -1,15 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Roster } from "./roster.js";
-export interface AgentsOptions {
-    /** Print the roster as JSON instead of tables. */
-    json?: boolean;
-}
-/**
- * The roster: each agent, how it starts, and its models with what each is
- * good at and costs, 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, log }: {
-    roster: Roster;
-    log: Logger;
-}, { json }?: AgentsOptions): Promise<void>;

package/artifact-room.d.ts

@@ -1,47 +0,0 @@
-import type { Fs } from "webappwiz/system";
-import { type Artifacts, type ArtifactVersion } from "./artifacts.js";
-/**
- * Room for artifacts across a project, which every conversation's store
- * makes its adds through, one at a time. An add past the project's capacity
- * first evicts the bytes of other versions, in `evictionOrder`, keeping
- * their records as placeholders; when even all of them would not make room,
- * it is refused and nothing goes. Files attached to conversations count
- * toward the capacity but are never evicted: they serve the questions that
- * show them.
- */
-export declare class ArtifactRoom {
-    private readonly deps;
-    private queue;
-    constructor(deps: {
-        fs: Fs;
-        /** Where every conversation of the project keeps its files. */
-        dir: string;
-        /** How many bytes every conversation may keep together. */
-        capacity: number;
-        /** Every conversation's store, and whether it is archived. */
-        shelves: () => ArtifactShelf[];
-    });
-    /** Runs `work` once every add before it has finished. */
-    hold<T>(work: () => Promise<T>): Promise<T>;
-    /**
-     * Evicts what it must for `bytes` more of the artifact `name` to fit, or
-     * refuses `too_large`, evicting nothing, when it cannot.
-     */
-    make(bytes: number, name: string): Promise<void>;
-}
-/** One conversation's store, as the room sees it. */
-export interface ArtifactShelf {
-    store: Artifacts;
-    archived: boolean;
-}
-/**
- * Every version whose bytes are kept, in the order eviction takes them:
- * removed and superseded ones of any conversation first, then the shown ones
- * of archived conversations, then those of live ones; oldest first within
- * each.
- */
-export declare function evictionOrder(shelves: ArtifactShelf[]): {
-    store: Artifacts;
-    name: string;
-    version: ArtifactVersion;
-}[];

package/artifact-viewers.d.ts

@@ -1,6 +0,0 @@
-/**
- * How the page shows an artifact of `mimeType`: an image or a recording in
- * the lightbox, a page in a sandboxed frame, or null for one it only offers
- * as a download, which the server sends as an attachment to match.
- */
-export declare function viewerOf(mimeType: string): "image" | "video" | "page" | null;

package/artifacts.d.ts

@@ -1,161 +0,0 @@
-import { type IdProvider } from "webappwiz/id";
-import type { Fs } from "webappwiz/system";
-import type { ArtifactRoom } from "./artifact-room.js";
-import type { Config } from "./config.js";
-/**
- * A conversation's artifacts: their bytes, in `artifacts/` beside its log's
- * other files, and their record, `held`, which each change goes to through
- * `record` (the log, then the state) once its bytes are in place. One change
- * at a time, so two adds of one name never take the same version.
- */
-export declare class Artifacts {
-    private readonly deps;
-    /** Where the bytes are kept. */
-    readonly dir: string;
-    /** Where every conversation of the project keeps its files. */
-    private readonly conversations;
-    private readonly ids;
-    private queue;
-    constructor(
-    /** The conversation's log, whose files directory holds the artifacts. */
-    log: string, deps: {
-        fs: Fs;
-        now: () => string;
-        limits: ArtifactLimits;
-        ids?: IdProvider;
-        /** The record as it stands. */
-        held: () => Artifact[];
-        /** Keeps `change`, folding it into `held`. */
-        record: (change: ArtifactChange) => Promise<void>;
-        /**
-         * The project's room, which evicts what other versions it must
-         * for an add past the project's capacity; without it, as for a
-         * CLI that reaches no `splates server`, such an add is refused.
-         */
-        room?: ArtifactRoom;
-    });
-    /** The record as it stands. */
-    get held(): Artifact[];
-    /**
-     * Keeps `file` as the next version of the artifact named for it, listing
-     * it again if it was removed. Past the project's capacity, its room evicts
-     * what it can first; refuses one past any limit still `too_large`,
-     * changing nothing.
-     */
-    add(file: ArtifactFile): Promise<ArtifactVersion>;
-    /** Marks the artifact `name` removed, keeping every version's bytes for cleanup. */
-    remove(name: string): Promise<void>;
-    /**
-     * Deletes the bytes of `version` of the artifact `name`, saying `why`,
-     * and keeps its record, so it shows as a placeholder.
-     */
-    delete(name: string, version: number, why: ArtifactGone): Promise<void>;
-    /**
-     * Deletes the bytes of every version no longer shown, those of removed
-     * artifacts and those a later one superseded, as its conversation is
-     * archived: what stays is what its panel still lists.
-     */
-    archive(): Promise<void>;
-    /**
-     * The bytes and media type of `version` of the artifact `name`, its
-     * current one by default; null when there is no such version or its
-     * bytes are gone.
-     */
-    read(name: string, version?: number): Promise<{
-        bytes: Uint8Array;
-        mimeType: string;
-    } | null>;
-    /**
-     * Refuses `file` when it has no name, or when it or this conversation
-     * would pass its limit; its size when it fits.
-     */
-    private admit;
-    /** Writes `file`'s bytes and records them as its name's next version. */
-    private keep;
-    /** Deletes `version`'s bytes and records that they went, and why. */
-    private drop;
-    /** The artifact `name`, refusing `not_found` when there is none. */
-    private find;
-    private serially;
-}
-/**
- * A file an agent made as an output of its conversation, such as a
- * screenshot, a recording or an HTML page, kept by name for the life of the
- * conversation, whatever task it was made in. Adding the name again makes its
- * next version. Its record stays for good, so one whose bytes went still
- * shows as a placeholder.
- */
-export interface Artifact {
-    name: string;
-    /** The `version` of the one shown; the newest, as added. */
-    current: number;
-    /** Every version, oldest first, numbered from 1. */
-    versions: ArtifactVersion[];
-    /** When it was removed, its versions kept until cleanup takes them; null while listed. */
-    removedAt: string | null;
-}
-/** One version of an artifact: what was added under its name at once. */
-export interface ArtifactVersion {
-    version: number;
-    /** Its file in the conversation's artifacts directory, named so none collide. */
-    file: string;
-    mimeType: string;
-    /** Its size. */
-    bytes: number;
-    addedAt: string;
-    /** When and why its bytes were deleted, its record kept; null while they are kept. */
-    gone: {
-        at: string;
-        why: ArtifactGone;
-    } | null;
-}
-/**
- * Why a version's bytes went: its conversation was archived, the project ran
- * past its cap, or the person deleted it.
- */
-export type ArtifactGone = "archived" | "evicted" | "deleted";
-/** A change to a conversation's artifacts, as its log keeps it. */
-export type ArtifactChange = ({
-    type: "add";
-    name: string;
-} & Omit<ArtifactVersion, "version" | "gone">) | {
-    type: "remove";
-    name: string;
-    at: string;
-} | {
-    type: "gone";
-    name: string;
-    version: number;
-    at: string;
-    why: ArtifactGone;
-};
-/** A file to keep as an artifact, as the agent hands it over. */
-export interface ArtifactFile {
-    name: string;
-    mimeType: string;
-    bytes: Uint8Array;
-}
-/** How many bytes artifacts may take, each past which an add is refused. */
-export interface ArtifactLimits {
-    /** One file. */
-    file: number;
-    /** Every version one conversation keeps the bytes of. */
-    conversation: number;
-    /** Every version every conversation in the project keeps the bytes of. */
-    project: number;
-}
-/** What `splates.config.ts` leaves the limits at unless it says otherwise. */
-export declare const ARTIFACT_LIMITS: ArtifactLimits;
-/** The limits `config` sets. */
-export declare function artifactLimits(config: Pick<Config, "artifactFileCapacity" | "artifactConversationCapacity" | "artifactProjectCapacity">): ArtifactLimits;
-/** Folds `change` into `artifacts`, as live and as a log is read back. */
-export declare function applyArtifact(artifacts: Artifact[], change: ArtifactChange): void;
-/** Whether `version` is the one its artifact's panel shows: its current, while listed. */
-export declare function shown(artifact: Artifact, version: ArtifactVersion): boolean;
-/**
- * How many bytes every conversation under `dir` keeps, read from disk: its
- * artifacts' and the files attached to it.
- */
-export declare function projectBytes(fs: Fs, dir: string): Promise<number>;
-/** Refuses an add that would have `what` hold `bytes`, past its `capacity`. */
-export declare function tooLarge(what: string, name: string, bytes: number, capacity: number): never;

package/asked.d.ts

@@ -1,146 +0,0 @@
-import { type Assumed } from "./assumed.js";
-import { type Demo } from "./demo.js";
-import { type Question } from "./plan.js";
-/**
- * `text` cut where it asks questions: a list numbered from 1 at the margin,
- * outside code blocks, every item a question, the lines indented under each
- * its body and its `- (a)` or `- [a]` choices, read as `## Blocked` reads
- * them. An item is a question when its line ends in `?`, or in `?` and an
- * aside in parentheses: `(all that apply)`; when it goes on past a `?`, which
- * leaves the rest to its body; or when it offers choices. Any other list is
- * only text.
- */
-export declare function stretches(text: string): Stretch[];
-/**
- * A stretch of an agent's message: markdown as it was written, the questions
- * it asks the person in the splates skill's format, its report asking them to
- * review a task before it merges, a design it proposes, its report of how a task ended or what it
- * waits on or that the lanes it orchestrated are done, its word that it
- * started lanes, a todo it proposes, a demo for the person to try, the calls
- * it made without asking, or its word that it requested a cred.
- */
-export type Stretch = {
-    type: "text";
-    text: string;
-} | {
-    type: "questions";
-    questions: Question[];
-} | {
-    type: "review";
-    review: Review;
-} | {
-    type: "proposal";
-    proposal: Proposal;
-} | {
-    type: "report";
-    report: Report;
-} | {
-    type: "start";
-    start: LanesStart;
-} | {
-    type: "todo";
-    todo: TodoProposal;
-} | {
-    type: "demo";
-    demo: Demo;
-} | {
-    type: "assumed";
-    assumed: Assumed[];
-};
-/** A review the skill's `## 🔍 Ready to merge` report asks for. */
-export interface Review {
-    task: string;
-    base: string;
-    /** Its first paragraph: what changed, in a sentence, as markdown. */
-    summary: string;
-    /** The demo it holds, to try before merging. */
-    demo: Demo | null;
-    /** The commands its `Checks:` line says passed, in order. */
-    checks: string[];
-    /** The commands its `Failed:` line says failed, in order. */
-    failed: string[];
-    /** Whatever else it says, past the summary, as markdown. */
-    details: string;
-}
-/**
- * What the agent proposes to do, as the skill's `## 💡 Proposed` report puts
- * it, for the person to approve before it starts. The questions after it are
- * the calls it rests on, those with a `(chosen)` choice already answered.
- */
-export interface Proposal {
-    /** What it proposes, as its title says. */
-    subject: string;
-    /** What it recommends, and the `####` sections saying why, as markdown. */
-    body: string;
-}
-/**
- * How a task ended, or what it waits on, or that a lane orchestrator is done
- * with its lanes or waits on the person, as the skill's reports title them.
- */
-export type Ending = "merged" | "removed" | "escalated" | "handed" | "finished" | "waiting" | "working";
-/** A report on a task, or a lane orchestrator's last word on its lanes. */
-export type Report = TaskReport | LanesReport;
-/**
- * A report the skill titles `## ✅ Merged <task> onto <base>`, `## 🛑 Removed
- * <task>: <why>`, `## ⚠️ Escalated <task>: <what it needs>`, `## 🤝 Handed
- * off <task> to <agent>: <why>`, or `## ⏳ Working <task>: on <agent>`, for a
- * task its agent handed on and relays for, as a lane's orchestrator does.
- */
-export interface TaskReport {
-    ending: Exclude<Ending, "finished" | "waiting">;
-    task: string;
-    /** Where it merged; null for the others. */
-    base: string | null;
-    /** The agent it was handed off to; null for the others. */
-    to: string | null;
-    /** What the title says after its colon, if anything. */
-    reason: string | null;
-    /** What changed, and anything else said before what follows, as markdown. */
-    body: string;
-    /** The markdown the agent wrote for it, from its title to its end. */
-    source: string;
-}
-/**
- * The report a lane orchestrator ends on: once every lane it works is done,
- * titled `## 🏁 Finished lanes <name>, <name>`, as there is nothing left for
- * it to hand out; or once each lane not done waits on a task that escalated,
- * titled `## ⏸️ Waiting lanes <name>, <name>: <on what>`, as the person must
- * answer that task before it can go on.
- */
-export interface LanesReport {
-    ending: "finished" | "waiting" | "working";
-    /** The lanes' names, as the title lists them. */
-    lanes: string[];
-    /** What the title says after its colon, if anything. */
-    reason: string | null;
-    /** How each lane stands, and anything else said, as markdown. */
-    body: string;
-    /** The markdown the agent wrote for it, from its title to its end. */
-    source: string;
-}
-/** What an agent says it is starting on: a task, or a lane orchestrator's lanes. */
-export type Start = TaskStart | LanesStart;
-/** A task the agent added for itself or claimed, its Goal from that event. */
-export interface TaskStart {
-    task: string;
-    /** What done means, as the task's Goal says, as markdown. */
-    goal: string;
-}
-/**
- * The lanes an orchestrator says it is starting to work, as `## 🌱 Started
- * lanes <name>, <name>`, what they add up to under it.
- */
-export interface LanesStart {
-    /** The lanes' names, as the title lists them. */
-    lanes: string[];
-    /** What the lanes add up to, as markdown. */
-    goal: string;
-}
-/** A todo the skill proposes as `### 📝 <subject> [#<id>]`. */
-export interface TodoProposal {
-    id: number;
-    /** The subject as the agent wrote it, which may since have changed. */
-    subject: string;
-    /** What the todo is and why it matters now, as markdown. */
-    body: string;
-}

package/asked.js

@@ -1,7 +0,0 @@
-import {
-  stretches2
-} from "./index-gcfq7awr.js";
-import"./index-k73tsw5g.js";
-export {
-  stretches2 as stretches
-};

package/assumed.d.ts

@@ -1,34 +0,0 @@
-import { type Exhibit } from "./exhibit.js";
-import { type Question } from "./plan.js";
-/**
- * A call the agent made without asking, as the skill's `- Assumed <number>:
- * <what>` line says it in a reply: numbered as in its task's `## Assumptions`.
- */
-export interface Assumed {
-    number: string;
-    /** What it chose, as the line says it. */
-    text: string;
-    /** What the reply shows it in, when the line captions an exhibit. */
-    exhibit?: Exhibit;
-}
-/**
- * Each of `assumed` as its task's `plan` writes it, matched by number: under
- * `## Assumptions`, or under `## Blocked` once challenged, so a reply that
- * challenged it still reads as it did. One the plan has no item for, as
- * outside a task or once it is gone, is its line alone, with no choices.
- * Either way, one the reply captions an exhibit with shows it, unless the
- * plan already shows it something.
- */
-export declare function assumedIn(plan: string, assumed: Assumed[]): Question[];
-/** Whether `line` is a reply's `- Assumed <number>:` line. */
-export declare function isAssumed(line: string): boolean;
-/**
- * The run of `- Assumed <number>:` lines from `start`, blank lines between
- * them, and the line after it; null for any other line. An exhibit in the
- * run, `### 🖼️ <title>` and what it shows, is what the lines right after it
- * caption, up to a blank line; one that captions none ends the run.
- */
-export declare function assumedAt(lines: string[], start: number): {
-    assumed: Assumed[];
-    end: number;
-} | null;

package/attach.d.ts

@@ -1,30 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Fs, Ps } from "webappwiz/system";
-import type { Git } from "./git.js";
-import type { WorktreeService } from "./worktree-service.js";
-export interface AttachOptions {
-    /** Task whose files these are. Defaults to the one `cwd` is a worktree for. */
-    task?: string;
-    /** Files it holds to drop first, by path or by the name they were stored under. */
-    remove?: string[];
-    /**
-     * Conversation to keep the files with. Defaults to the one whose agent runs
-     * the command; with neither, they stay with the task and go when it does.
-     */
-    conversation?: string;
-}
-/**
- * Stores files for a task's questions to show, in a folder splates owns, so
- * the screenshots and recordings an agent takes never land in a commit.
- * An agent in a conversation has them kept with it, so a merged task's
- * report card still shows them; any other agent's go when the task merges or
- * is removed. Prints where each was stored, which is the path a question
- * names.
- */
-export declare function attach(deps: {
-    service: WorktreeService;
-    git: Git;
-    log: Logger;
-    fs: Fs;
-    ps: Ps;
-}, paths: string[], cwd: string, { task, remove, conversation: given }?: AttachOptions): Promise<string[]>;

package/attachments.d.ts

@@ -1,43 +0,0 @@
-import { type IdProvider } from "webappwiz/id";
-import type { Fs, Ps } from "webappwiz/system";
-/** A file handed over, as bytes so a pasted image needs no temp file. */
-export interface Attachment {
-    /** What it was called, kept in the stored name so the files stay apart. */
-    name: string;
-    bytes: Uint8Array;
-}
-/**
- * The folder of files that belong to a todo or a task: todo 7's beside its
- * record, in `todos/7/`, and task `login`'s in `tasks/login/`.
- * Under `.git/splates`, so nothing here is ever committed and every tree can
- * open what it holds.
- */
-export declare class Attachments {
-    readonly dir: string;
-    private readonly fs;
-    private readonly ids;
-    constructor(dir: string, fs: Fs, ids?: IdProvider);
-    /** Copies each file in, returning the absolute path each was stored at. */
-    store(files: Attachment[]): Promise<string[]>;
-    /** Each file stored here, by absolute path, with its size in bytes. */
-    held(): Promise<{
-        path: string;
-        bytes: number;
-    }[]>;
-    /** Whether `path` is one of this folder's files, and not a way out of it. */
-    owns(path: string): boolean;
-    /** Deletes the files given that are this folder's; others are left alone. */
-    remove(paths: string[]): Promise<void>;
-    /** Deletes the folder and everything in it. */
-    clear(): Promise<void>;
-}
-/**
- * Reads files named on the command line, relative to the current directory or
- * absolute, refusing the whole command over one that cannot be read.
- */
-export declare function readFiles({ fs, ps }: {
-    fs: Fs;
-    ps: Ps;
-}, paths: string[]): Promise<Attachment[]>;
-/** The bytes of every file under `dir`, folders included, 0 when it is not there. */
-export declare function folderBytes(fs: Fs, dir: string): Promise<number>;

package/baselines.d.ts

@@ -1,55 +0,0 @@
-import type { Finding } from "./findings.js";
-import type { Outcome } from "./outcomes.js";
-/** Each project's baseline, over the merged tasks that ended in the window before `now`. */
-export declare function baselines(outcomes: Outcome[], now: Date): Baseline[];
-/**
- * What a project's recent merged tasks were like, so one task can be held
- * against them: each measure's median and 90th percentile, and how often each
- * kind of finding came up.
- */
-export interface Baseline {
-    /** The main tree of the repository. */
-    project: string;
-    /** Its merged tasks in the window. */
-    tasks: number;
-    /** Each measure over the tasks that kept it; null with too few to compare against. */
-    measures: Record<Measure, Spread | null>;
-    /** How many of its tasks had each finding, by `findingKeys`. */
-    findings: Record<string, number>;
-}
-/** Where a measure's values fall among a project's tasks. */
-export interface Spread {
-    /** The tasks that kept it. */
-    tasks: number;
-    median: number;
-    p90: number;
-}
-/** What a task is held against its project's on. */
-export type Measure = 
-/** From add to merge, in milliseconds. */
-"spentMs"
-/** What its own turns cost; Codex says none. */
- | "cost"
-/** Lines added and removed. */
- | "lines"
-/** Calls the person made, asked or challenged. */
- | "decidedByYou" | "failedMerges";
-export declare const MEASURES: readonly Measure[];
-/** Each tuned here, so a comparison that cries wolf is one number to change. */
-export declare const BASELINE: {
-    /** How far back the tasks compared against ended. */
-    readonly windowMs: number;
-    /** Fewer tasks than this keeping a measure, and it gives no comparison. */
-    readonly minTasks: 10;
-    /** A value is an outlier past the 90th percentile, or this many medians. */
-    readonly timesMedian: 2;
-};
-/** What `outcome` shows of each measure; null for one it did not keep. */
-export declare function measured(outcome: Outcome): Record<Measure, number | null>;
-/** Whether `value` stands out from `spread`: never against no spread. */
-export declare function outlier(value: number, spread: Spread | null): boolean;
-/**
- * What a finding counts toward: its kind, and, for one that names what
- * failed, that too, so the same failing test is counted apart from others.
- */
-export declare function findingKeys(finding: Finding): string[];

package/claim.d.ts

@@ -1,17 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Fs } from "webappwiz/system";
-import type { WorktreeService } from "./worktree-service.js";
-/**
- * The resume entry point: a fresh agent thread picking up existing work. An
- * escalated task goes back to `working`, since someone is on it again; its
- * merge budget stays as it was, which only `retry` refills.
- */
-export declare function claim({ service, log, fs }: {
-    service: WorktreeService;
-    log: Logger;
-    fs: Fs;
-}, task: string): Promise<{
-    escalated: boolean;
-    tookOver: boolean;
-    goal: string;
-}>;