@stringsync/splates 0.0.60 → 1.13.3

package/vendor/@stringsync/splates-server/ship/stages.d.ts

@@ -0,0 +1,69 @@
+import { Duration } from "../../../core/time/index.js";
+import type { ReleaseStep } from "./release-steps";
+/** A step not begun, expected to take `expected` ms, from ships before when `known`. */
+export declare function pendingStage(key: StageKey, { expected, known }?: {
+    expected: number;
+    known: boolean;
+}): Stage;
+/**
+ * Where one step of a project's part in a ship stands, for the page to show:
+ * not begun, under way, waiting on a check, waiting on the person, hung
+ * (under way past its deadline, and still going), done, failed, or skipped.
+ */
+export type StageState = "pending" | "running" | "checking" | "asking" | "hung" | "done" | "failed" | "skipped";
+/**
+ * The steps a project's part in a ship takes: its bump task, that task's
+ * merge gate and its merge, then signing in to npm, the publishes' second
+ * factor, the ship command, the approval of what it staged, and the versions it published checked against
+ * the plan.
+ */
+export type StageKey = "upstream" | "adopt" | "publish" | "live" | "bump" | "gate" | "merged" | "push" | "remote" | "login" | "otp" | "command" | "approve" | "versions";
+/** What splates last asked of a step, and what it heard. */
+export interface StageCheck {
+    at: string;
+    result: string;
+    /** When the next check runs, while the step polls; absent once it stops. */
+    next?: string;
+}
+/** Where a step's output is in its project's ship log: bytes `from` to `to`, null while it prints. */
+export interface StageLog {
+    from: number;
+    to: number | null;
+}
+/** One step of a project's part in a ship, in one shape for every step. */
+export interface Stage {
+    key: StageKey;
+    /** What the page calls it. */
+    name: string;
+    state: StageState;
+    started: string | null;
+    ended: string | null;
+    /** How long it is expected to take, in milliseconds. */
+    expected: number;
+    /** Whether {@link expected} comes from ships before, rather than a default. */
+    known: boolean;
+    /** When it shows hung, once started. */
+    deadline: string | null;
+    check: StageCheck | null;
+    log: StageLog | null;
+    /** On the ship command: the steps the project's own Release reports, as they stand; absent when it reports none. */
+    releaseSteps?: ReleaseStep[];
+}
+/** When a step that started at `started` shows hung. */
+export declare function deadlineOf(stage: Stage, started: string): string;
+/** `stage` begun at `at` in `state`, unless it began already. */
+export declare function begun(stage: Stage, at: string, state?: StageState): Stage;
+/** `stage` ended at `at` in `state`, begun then too when it never began. */
+export declare function ended(stage: Stage, at: string, state: StageState): Stage;
+/** `stage` as the page shows it at `now`: hung when under way past its deadline. */
+export declare function shownStage(stage: Stage, now: number): Stage;
+/** How long a step took, in milliseconds, once done. */
+export declare function took(stage: Stage): number | null;
+/** What each step is called. */
+export declare const STAGE_NAMES: Record<StageKey, string>;
+/** How long each step is expected to take before any ship of it says. */
+export declare const STAGE_DEFAULTS: Record<StageKey, Duration>;
+/** How long a step goes before it shows hung the first time, with no ship before to say. */
+export declare const FIRST_DEADLINE: Duration;
+/** The states a step ends in. */
+export declare const STAGE_ENDED: StageState[];

package/vendor/@stringsync/splates-server/ship/steps.d.ts

@@ -0,0 +1,69 @@
+import type { AsyncResource } from "../../../core/disposable/index.js";
+import type { Fs } from "../../../core/system/index.js";
+import { type WallClock } from "../../../core/time/index.js";
+import type { Storage } from "../storage";
+import { type Cascade, type CascadeStep, Cascades } from "./cascade";
+import type { Pin, ShipGraph } from "./graph";
+import { type ShipLive } from "./live";
+import type { ShipRegistry } from "./registry";
+import type { Ship, Shipping } from "./run";
+import { type ShipSelection } from "./selection";
+/** A project’s publisher and adoption operations, including cleanup after Abandon. */
+export interface StepProject {
+    shipping: Pick<Shipping, "start" | "resume" | "settled" | "current" | "stop">;
+    adopt(ship: Cascade, step: CascadeStep, pins: Pin[], log: (text: string) => Promise<void>, signal: AbortSignal, assigned?: () => Promise<void>): Promise<boolean | undefined>;
+    discard?(ship: Cascade, step: CascadeStep): Promise<void>;
+    /** Whether the release's tag reached the remote, which a release that died after publishing lacks. */
+    released?(version: string): Promise<boolean>;
+}
+export interface ShipStepsOptions {
+    graph(): Promise<ShipGraph>;
+    project(slug: string): Promise<StepProject>;
+    live: Pick<ShipLive, "check">;
+    registry: Pick<ShipRegistry, "published">;
+    clock?: WallClock;
+    pause?: () => Promise<void>;
+    /** Reports a background storage or runner failure. */
+    error(error: unknown): void;
+}
+/** Ship selected projects in release order, with Retry and Abandon for a stopped release. */
+export declare class ShipSteps extends Cascades implements AsyncResource {
+    private readonly storage;
+    private readonly fs;
+    private readonly opts;
+    private readonly record;
+    private readonly clock;
+    private going;
+    private closing;
+    private controller;
+    private publisher;
+    constructor(storage: Storage, fs: Fs, opts: ShipStepsOptions);
+    current(): Promise<Cascade | null>;
+    shown(): Promise<{
+        cascade: Cascade | null;
+        ship: Ship | null;
+    }>;
+    /** Start only after validating every choice; a stopped ship still owns the machine. */
+    start(input: ShipSelection): Promise<Cascade>;
+    /** A failed stage is retried in place; completed stages stay complete. */
+    retry(): Promise<Cascade>;
+    /** Give a failed mechanical adoption to an agent, retaining its prepared tree. */
+    handToAgent(): Promise<Cascade>;
+    /** Ends the plan, retaining every completed publication. No later stage may start. */
+    abandon(): Promise<Cascade>;
+    /** Continue an interrupted ship, rechecking its unfinished stage before doing more work. */
+    resume(): Promise<void>;
+    settled(): Promise<void>;
+    /** Leave the durable stage running for the next server to recheck. */
+    disposeAsync(): Promise<void>;
+    private run;
+    private execute;
+    private perform;
+    private waitLive;
+    private discard;
+    private active;
+    private save;
+    private stamp;
+    private bytes;
+    private log;
+}

package/vendor/@stringsync/splates-server/ship/token-request.d.ts

@@ -0,0 +1,11 @@
+/** The creds name a ship publishes under when the store keeps one. */
+export declare const NPM_TOKEN = "NPM_TOKEN";
+/** Asks for the `NPM_TOKEN` in `creds`' device store, and nothing when it is kept. */
+export declare function requestNpmToken(creds: {
+    request: (name: string, options: {
+        scope: "device";
+        purpose: string;
+        instructions: string;
+        task: null;
+    }) => Promise<unknown>;
+}): Promise<void>;

package/vendor/@stringsync/splates-server/ship/token.d.ts

@@ -0,0 +1,21 @@
+import type { Fs, Ps } from "../../../core/system/index.js";
+/** Why a ship stopped on a token npm turned away. */
+export declare const TOKEN_REFUSED = "npm refused the NPM_TOKEN in the creds store: it may have expired, been revoked, or be limited to IP ranges this machine is outside of; make a new granular token and replace it on the Creds page";
+/**
+ * What `npm whoami` says under the environment a ship's npm runs in, with
+ * `token` signed in when there is one, and that environment.
+ */
+export declare function checkNpm({ fs, ps, dir, root }: {
+    fs: Fs;
+    ps: Ps;
+    dir: string;
+    root: string;
+}, token: string | undefined): Promise<{
+    env: Record<string, string>;
+    whoami: import("../../../core/system/index.js").SpawnCaptureResult;
+}>;
+/** What a ship records of its `npm whoami` check. */
+export declare function whoamiResult(whoami: {
+    exitCode: number;
+    stdout: string;
+}, token: string | undefined): string;

package/vendor/@stringsync/splates-server/spend/adapters.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from "./providers";
+/** OpenAI spend by day and line item. */
+export declare const openai: Provider;
+/** The account's billing history: each charge as Cloudflare invoiced it. */
+export declare const cloudflare: Provider;

package/vendor/@stringsync/splates-server/spend/billing.d.ts

@@ -0,0 +1,38 @@
+import type { Expected } from "./plans";
+import { type Provider } from "./providers";
+import type { Spend } from "./spend";
+/** How a provider's row on the Billing page reads after a pull. */
+export interface ProviderStatus {
+    provider: string;
+    /**
+     * `ok` pulled, `missing` has no cred, `unreachable` failed, `untracked`
+     * not counted yet, `counted` counted by splates as it is used,
+     * `estimated` estimated by splates from list prices, with no bill to pull.
+     */
+    state: "ok" | "missing" | "unreachable" | "untracked" | "counted" | "estimated";
+    /** What to tell the user; for `ok`, only a note that the bill trails use. */
+    message: string;
+    /** How many new charges the pull added. */
+    added: number;
+    /** What the provider says it will charge next, not billed yet. */
+    expected?: Expected[];
+}
+export interface BillingOptions {
+    cred(name: string): Promise<string | undefined>;
+    /** The display currency; USD unsaid. */
+    currency?: string;
+    fetcher?: typeof fetch;
+    /** The date now, `2026-10-21`. */
+    today: string;
+    /** How far back to pull; 90 days unsaid. */
+    days?: number;
+    providers?: readonly Provider[];
+}
+/**
+ * Pulls what each provider billed into the ledger, converted to the display
+ * currency, once per charge however often it runs. A provider that cannot be
+ * reached is reported, never recorded as zero.
+ */
+export declare function pullBilling(spend: Spend, opts: BillingOptions): Promise<ProviderStatus[]>;
+/** How the row of a provider splates never pulls reads; null for one it does. */
+export declare function unpulledStatus(provider: Provider): ProviderStatus | null;

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

@@ -0,0 +1,15 @@
+export type { BillingOptions, ProviderStatus } from "./billing";
+export { pullBilling } from "./billing";
+export type { Expected, Plan, PlansOptions } from "./plans";
+export { readPlans, renewals } from "./plans";
+export { PROVIDERS } from "./providers";
+export { Rates } from "./rates";
+export type { SpendReport } from "./report";
+export { spendReport } from "./report";
+export type { BillingRoutesOptions, BillingView } from "./routes";
+export { BillingRoutes, CURRENCIES } from "./routes";
+export { Spend } from "./spend";
+export type { Period, ProjectTotal, SpendEntry, SpendKind, SpendQuery, SpendTotal, } from "./totals";
+export { periodStart, projectTotals, totals } from "./totals";
+export type { TurnSpend, TurnTokens, Used } from "./turn";
+export { KINDS, turnSpend } from "./turn";

package/vendor/@stringsync/splates-server/spend/plans.d.ts

@@ -0,0 +1,45 @@
+import type { Fs } from "../../../core/system/index.js";
+/**
+ * A charge on the bill that no provider has billed yet as splates sees it:
+ * an agent plan's renewal, priced at its list price since no plan has a
+ * billing API, or a subscription a provider says it will invoice.
+ */
+export interface Expected {
+    provider: string;
+    service: string;
+    /** The day it is charged, `2026-10-30`. */
+    day: string;
+    amount: number;
+    currency: string;
+}
+/** A plan and how much it charges each renewal. */
+export interface Plan {
+    provider: string;
+    /** The plan's name, as the Billing page shows it: `Max 20x plan`. */
+    service: string;
+    amount: number;
+    currency: string;
+    /** How many months pass between renewals. */
+    everyMonths: number;
+    /** When it began, or the earliest renewal its source confirms, as an ISO timestamp. */
+    since: string;
+}
+/**
+ * The agent plans this machine is signed in to, read from their own logins;
+ * one that cannot be read or fully priced is left out.
+ */
+export declare function readPlans(fs: Fs, home: string, opts?: PlansOptions): Promise<Plan[]>;
+export interface PlansOptions {
+    /** Where Kimi Code keeps its login and how to ask for its subscription. */
+    kimi?: {
+        home: string;
+        baseUrl?: string;
+        fetcher?: typeof fetch;
+        now?: () => number;
+    };
+}
+/**
+ * Each renewal of `plans` from `since` to `until` (`2026-10-01`, exclusive),
+ * at each plan's own interval, on its anchor day or that month's last day.
+ */
+export declare function renewals(plans: readonly Plan[], since: string, until: string): Expected[];

package/vendor/@stringsync/splates-server/spend/providers.d.ts

@@ -0,0 +1,45 @@
+import type { Expected } from "./plans";
+/** One amount a provider billed, in its own currency. */
+export interface Charge {
+    /** The day it was billed, `2026-10-20`. */
+    day: string;
+    service: string;
+    amount: number;
+    currency: string;
+    /** Unique within the provider, so the same charge pulled twice is kept once. */
+    ref: string;
+}
+/** What an adapter needs: a way to read a cred, and the network. */
+export interface Sources {
+    cred(name: string): Promise<string | undefined>;
+    fetcher: typeof fetch;
+    /** The date now (`2026-10-21`). */
+    today: string;
+    /** The earliest day to pull. */
+    since: string;
+}
+export interface Provider {
+    id: string;
+    /** The cred it reads, for the Creds page to ask for. */
+    cred: string | null;
+    /**
+     * Set for a provider splates does not count yet: what to say on its row.
+     */
+    untracked?: string;
+    /**
+     * Set for a provider splates counts itself as it uses it, with nothing to
+     * pull: what to say on its row.
+     */
+    counted?: string;
+    /** Set for a provider with no bill to pull, estimated from list prices: what to say on its row. */
+    estimated?: string;
+    /** Set when the bill trails use: what to say on the pulled row. */
+    lags?: string;
+    /** Where the provider's own billing page is, for a row to link to. */
+    dashboard?: string;
+    pull?(sources: Sources, token: string): Promise<Charge[]>;
+    /** What the provider says it will charge next and has not billed yet. */
+    upcoming?(sources: Sources, token: string): Promise<Expected[]>;
+}
+/** Every provider billed outside splates, those not counted yet said so. */
+export declare const PROVIDERS: readonly Provider[];

package/vendor/@stringsync/splates-server/spend/rates.d.ts

@@ -0,0 +1,23 @@
+/** An amount in the display currency, with what it was converted from. */
+export interface Converted {
+    dollars: number;
+    original: {
+        amount: number;
+        currency: string;
+        rate: number;
+        rateDate: string;
+    };
+}
+/**
+ * Converts amounts to one display currency at the rate of the day each was
+ * billed, fetched once per currency and day. Throws when a rate cannot be had,
+ * so the caller can say so rather than show a wrong figure.
+ */
+export declare class Rates {
+    readonly currency: string;
+    private readonly fetcher;
+    private readonly known;
+    constructor(currency?: string, fetcher?: typeof fetch);
+    convert(amount: number, from: string, day: string): Promise<Converted>;
+    private fetchRate;
+}

package/vendor/@stringsync/splates-server/spend/report.d.ts

@@ -0,0 +1,39 @@
+import type { Expected } from "./plans";
+import type { Rates } from "./rates";
+import type { Spend } from "./spend";
+import { type ProjectTotal, type SpendTotal } from "./totals";
+/** What the Billing page shows of a range: totals by service and by day. */
+export interface SpendReport {
+    /** When it was read, as an ISO timestamp. */
+    updated: string;
+    /** The currency the amounts are in. */
+    currency: string;
+    /** The latest day whose rate was used, or null when nothing was converted. */
+    rateDate: string | null;
+    /** Why the amounts are in dollars rather than `currency`, when no rate could be had. */
+    rateError: string | null;
+    /** Each provider's services in the range. */
+    services: SpendTotal[];
+    /** Each provider's day, oldest first. */
+    days: SpendTotal[];
+    /** Each project's share of the range, with what no project's work is recorded against as `null`. */
+    projects: ProjectTotal[];
+    /**
+     * What is expected after the range and before the end of the month it
+     * ends in, by service: a plan's renewal or a subscription not invoiced.
+     */
+    upcoming: SpendTotal[];
+}
+/**
+ * The ledger's totals from `since` to `until` (ISO timestamps, either may be
+ * left off), with each `expected` charge on its day, in the currency of
+ * `rates`, each entry at the rate of the day it was spent. When a rate cannot
+ * be had the dollars are shown as dollars.
+ */
+export declare function spendReport(ledger: Spend, range: {
+    since?: string;
+    until?: string;
+    now: string;
+    rates?: Rates;
+    expected?: readonly Expected[];
+}): Promise<SpendReport>;

package/vendor/@stringsync/splates-server/spend/routes.d.ts

@@ -0,0 +1,46 @@
+import type { Storage } from "../storage";
+import { type ProviderStatus } from "./billing";
+import { type Plan } from "./plans";
+import type { Spend } from "./spend";
+/** The currencies the Billing page offers, the European Central Bank's most traded. */
+export declare const CURRENCIES: string[];
+/** What the Billing page shows of its sources. */
+export interface BillingView {
+    currency: string;
+    currencies: string[];
+    /** When providers were last pulled, or null before the first pull. */
+    pulledAt: string | null;
+    /** Each provider, with the cred it reads and how its last pull went. */
+    providers: (ProviderStatus & {
+        cred: string | null;
+        /** Where the provider's own billing page is; null for none. */
+        dashboard: string | null;
+    })[];
+}
+/** What a `BillingRoutes` reads beyond the ledger. */
+export interface BillingRoutesOptions {
+    fetcher?: typeof fetch;
+    /** The agent plans this machine is signed in to, whose renewals the bill expects; none unsaid. */
+    plans?: () => Promise<Plan[]>;
+}
+/**
+ * The Billing page's sources: the display currency, kept on the machine, and
+ * a pull of what each provider billed, whose results the page reads back.
+ */
+export declare class BillingRoutes {
+    #private;
+    private readonly ledger;
+    private readonly cred;
+    private readonly fetcher;
+    private readonly plans;
+    constructor(storage: Storage, ledger: Spend, cred: (name: string) => Promise<string | undefined>, opts?: BillingRoutesOptions);
+    currency(): Promise<string>;
+    private view;
+    /** The sources as last pulled. */
+    readonly read: () => Promise<Response>;
+    /** Pulls every provider's billing, once at a time, and answers as `read` does. */
+    readonly pull: () => Promise<Response>;
+    readonly setCurrency: (request: Request) => Promise<Response>;
+    /** The spend in the display currency. */
+    readonly spend: (request: Request) => Promise<Response>;
+}

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

@@ -0,0 +1,15 @@
+import type { Storage } from "../storage";
+import { type SpendEntry, type SpendQuery } from "./totals";
+/**
+ * Every amount spent, in dollars, kept in `spend.jsonl` on the machine so it
+ * survives restarts and any project's agents add to the one ledger. Nothing
+ * else does the pricing: the Billing page reads totals from here.
+ */
+export declare class Spend {
+    private readonly log;
+    constructor(storage: Storage);
+    record(...entries: SpendEntry[]): Promise<void>;
+    /** Amounts spent, oldest first; historical runner rows stay in storage. */
+    entries(): Promise<SpendEntry[]>;
+    totals(query?: SpendQuery): Promise<import("./totals").SpendTotal[]>;
+}

package/vendor/@stringsync/splates-server/spend/totals.d.ts

@@ -0,0 +1,63 @@
+/** Money billed; plan use at API list prices; or a charge expected with no bill yet, which only the report adds. */
+export type SpendKind = "billed" | "equivalent" | "expected";
+/** One amount spent, in dollars, as the ledger keeps it. */
+export interface SpendEntry {
+    /** When it was spent, as an ISO timestamp. */
+    at: string;
+    /** Who was paid or whose plan was used: `claude`, `codex`, `kimi`, `opencode`, `openai`, `cloudflare`. */
+    provider: string;
+    /** What of the provider's was used: a model, or a product such as `transcription`. */
+    service: string;
+    kind: SpendKind;
+    dollars: number;
+    /** The project's slug, task and conversation it was spent for, when one was. */
+    project: string | null;
+    task: string | null;
+    conversation: string | null;
+    /** For an amount a provider billed: a stable key, so pulling it again adds nothing. */
+    ref?: string;
+    /** For an amount billed in another currency: what was billed and the rate it was converted at. */
+    original?: {
+        amount: number;
+        currency: string;
+        rate: number;
+        rateDate: string;
+    };
+}
+/** Totals `entries` as `query` asks, oldest period first, then by provider and service. */
+export declare function totals(entries: readonly SpendEntry[], query?: SpendQuery): SpendTotal[];
+/** One project's spend, the kinds apart. */
+export interface ProjectTotal {
+    /** The project's slug, or null for what no project's work is recorded against: provider bills and plan fees. */
+    project: string | null;
+    billed: number;
+    equivalent: number;
+    expected: number;
+}
+/** Totals `entries` by project, in slug order, what has no project last. */
+export declare function projectTotals(entries: readonly SpendEntry[]): ProjectTotal[];
+export type Period = "day" | "week" | "month";
+export interface SpendQuery {
+    /** What to total by; unsaid, everything is one row. */
+    by?: "provider" | "service";
+    /** Split by this span too; unsaid, all time at once. */
+    per?: Period;
+    /** Entries from this ISO timestamp (inclusive) to `until` (exclusive). */
+    since?: string;
+    until?: string;
+    provider?: string;
+    project?: string;
+    task?: string;
+}
+/** One row of totals, the kinds apart. */
+export interface SpendTotal {
+    provider: string | null;
+    service: string | null;
+    /** The span's first day (`2026-10-21`, a Monday for a week, the 1st for a month); null for all time. */
+    period: string | null;
+    billed: number;
+    equivalent: number;
+    expected: number;
+}
+/** The start of the span `at` falls in, as a UTC date. */
+export declare function periodStart(at: string, per: Period): string;

package/vendor/@stringsync/splates-server/spend/turn.d.ts

@@ -0,0 +1,39 @@
+import { type Catalog } from "../prices";
+import type { SpendKind } from "./totals";
+/** What a conversation had used by some moment, as its state tallies it. */
+export interface Used {
+    /** Tokens read over every turn, those from cache among them. */
+    input: number;
+    cached: number;
+    output: number;
+    /** What the agent says the session cost, in dollars; null for one that never says. */
+    cost: number | null;
+    /** Tokens in the context window; null until said. */
+    context: number | null;
+}
+/** An agent turn's tokens in the shape OpenCode observes them, one per turn. */
+export interface TurnTokens {
+    model: string | null;
+    input: number;
+    cachedRead: number;
+    cachedWrite: number;
+    output: number;
+}
+/**
+ * How each agent's use is paid for: Claude, Codex and Kimi are used through a
+ * subscription, so their dollars are what the API would have charged;
+ * OpenCode bills by use.
+ */
+export declare const KINDS: Record<string, SpendKind>;
+/** What one turn cost in dollars, and the kind of money it is; null when unpriceable. */
+export interface TurnSpend {
+    dollars: number;
+    kind: SpendKind;
+}
+/**
+ * Prices the turn that took a conversation from `before` to `after`: at the
+ * cost the agent said it ran up in between, else its tokens at the model's
+ * API list price in `catalog`. Null when the turn cost nothing, or nothing
+ * is known to price it by.
+ */
+export declare function turnSpend(agent: string, model: string | null, before: Used, after: Used, catalog: Catalog | null, observed?: readonly TurnTokens[], kinds?: Record<string, SpendKind>): TurnSpend | null;

package/vendor/@stringsync/splates-server/stats/adherence.d.ts

@@ -0,0 +1,40 @@
+import type { ConversationState } from "../conversations";
+import type { Log, Storage } from "../storage";
+import { type Transcript } from "./skill-checks";
+/**
+ * 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 {
+    /** The scores last written for each conversation, so a turn that changes none writes nothing. */
+    private readonly written;
+    readonly log: Log<Judged>;
+    constructor(
+    /** The machine's storage, or a test's own. */
+    storage: Storage);
+    /** 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[]>;
+}
+/** 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/vendor/@stringsync/splates-server/stats/baselines.d.ts

@@ -0,0 +1,55 @@
+import type { Finding } from "./findings";
+import type { Outcome } from "./outcomes";
+/** 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"
+/** Questions put to the person. */
+ | "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[];