@stringsync/splates 0.0.60 → 1.13.3

package/vendor/@stringsync/splates-server/artifacts/viewers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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/vendor/@stringsync/splates-server/auto-pick/classes.d.ts

@@ -0,0 +1,29 @@
+import type { Noul } from "./system-one";
+/** One thing the judge says of a task, as the page names it. */
+export interface TaskClass<Id extends string> {
+    id: Id;
+    label: string;
+    noul: Noul;
+}
+export declare const KIND_IDS: readonly ["bugfix", "design", "open"];
+export type KindId = (typeof KIND_IDS)[number];
+export declare const DEPTH_IDS: readonly ["shallow", "moderate", "deep"];
+export type DepthId = (typeof DEPTH_IDS)[number];
+/** Kinds remain independent questions; the request's length is not a design decision. */
+export declare const KINDS: readonly TaskClass<KindId>[];
+/** The hardest reasoning step, independent of how much code or prose there is. */
+export declare const DEPTHS: readonly TaskClass<DepthId>[];
+export declare const BREADTHS: readonly [TaskClass<"spot">, TaskClass<"module">, TaskClass<"system">];
+export declare const CLARITY_IDS: readonly ["settled", "unresolved"];
+export type ClarityId = (typeof CLARITY_IDS)[number];
+/** How settled the requested behavior is, independent of tone and reasoning depth. */
+export declare const CLARITIES: readonly TaskClass<ClarityId>[];
+export declare const STAKES: readonly [TaskClass<"routine">, TaskClass<"sensitive">];
+export declare const VERIFICATIONS: readonly [TaskClass<"automated">, TaskClass<"visual">];
+/** Context judgments are recorded and explained; clarity also participates in rule matching. */
+export declare const CONTEXT_CLASSES: {
+    readonly breadth: readonly [TaskClass<"spot">, TaskClass<"module">, TaskClass<"system">];
+    readonly clarity: readonly TaskClass<"settled" | "unresolved">[];
+    readonly stakes: readonly [TaskClass<"routine">, TaskClass<"sensitive">];
+    readonly verification: readonly [TaskClass<"automated">, TaskClass<"visual">];
+};

package/vendor/@stringsync/splates-server/auto-pick/classify.d.ts

@@ -0,0 +1,60 @@
+import { Duration } from "../../../core/time/index.js";
+import { type DepthId, type KindId } from "./classes";
+import type { Judge } from "./system-one";
+/**
+ * What the judge said of a task: the probability, 0 to 1, that it is each
+ * kind of work and each depth. A question left unanswered is a coin toss.
+ */
+export interface Classification {
+    kinds: Record<KindId, number>;
+    depth: Record<DepthId, number>;
+    /** Additional evidence, absent on older records. */
+    breadth?: Record<"spot" | "module" | "system", number>;
+    /** How settled the intended behavior is; independently matched by rules. */
+    clarity?: Record<"settled" | "unresolved", number>;
+    stakes?: Record<"routine" | "sensitive", number>;
+    verification?: Record<"automated" | "visual", number>;
+}
+/** A classification, or why there is none, in a short line the page can show. */
+export type Classified = {
+    ok: true;
+    classification: Classification;
+} | {
+    ok: false;
+    reason: string;
+};
+/** What `classify` reads. */
+export interface ClassifyInput {
+    /** The task's subject line. */
+    subject: string;
+    /** The rest of the task: its body or a conversation's first prompt. */
+    detail: string;
+    /** The decision model; null when no cred for one is kept. */
+    judge: Judge | null;
+    /** Names and MIME types only; never attachment contents. */
+    attachments?: readonly AttachmentInfo[];
+    /** How long the judge may take; 5 seconds when not given. */
+    timeout?: Duration;
+    /** Gives up on the judgment, and rejects with its reason, when it aborts. */
+    signal?: AbortSignal;
+}
+/** Metadata available before a first message has been uploaded. */
+export interface AttachmentInfo {
+    name: string;
+    mimeType: string;
+}
+/**
+ * Asks the judge every question about the task in one judgment. With no
+ * judge, or one that fails or is slow, says why instead; rejects only when
+ * `input.signal` aborts.
+ */
+export declare function classify(input: ClassifyInput): Promise<Classified>;
+/** Paths mentioned anywhere in the goal survive the detail's size limit. */
+export declare function namedPaths(words: string): string[];
+/** Count, media kind and name of each attachment; no file is opened. */
+export declare function attachmentSummary(files: readonly AttachmentInfo[]): string;
+/**
+ * The detail the judge reads, at most this long: the head says how big the
+ * work is, and a provider cuts a long state short without saying.
+ */
+export declare const DETAIL_CHARS = 4000;

package/vendor/@stringsync/splates-server/auto-pick/clef.d.ts

@@ -0,0 +1,15 @@
+import { type EndpointOptions, type Judge, type JudgeOptions, type Judgment } from "./system-one";
+/** Cloudflare's decision model on Workers AI. */
+export declare class Clef implements Judge {
+    /** The Cloudflare account id Workers AI bills. */
+    private readonly account;
+    /** An API token with Workers AI read access. */
+    private readonly token;
+    private readonly opts;
+    constructor(
+    /** The Cloudflare account id Workers AI bills. */
+    account: string, 
+    /** An API token with Workers AI read access. */
+    token: string, opts?: EndpointOptions);
+    judge(judgment: Judgment, opts?: JudgeOptions): Promise<import("./system-one").Verdict>;
+}

package/vendor/@stringsync/splates-server/auto-pick/decide.d.ts

@@ -0,0 +1,78 @@
+import type { Limit, Setting } from "../conversations";
+import type { AgentPick, RosterAgent } from "../models";
+import { type Catalog } from "../prices";
+import { type ClarityId, type DepthId, type KindId } from "./classes";
+import type { Classification } from "./classify";
+import { type AutoPickRules } from "./rules";
+/**
+ * Turns a classification into a pick: kind, depth and certainty each
+ * when the judge is sure enough, find the first rule matching all three,
+ * and the first of its picks whose agent has plan left, used no faster than
+ * its windows go by, wins.
+ */
+export declare function decide(input: DecideInput): AutoPickDecision;
+/** Whom Auto pick starts on a task, and why. */
+export interface AutoPickDecision {
+    pick: AgentPick;
+    /** The index in the rules of the rule that matched. */
+    rule: number;
+    /** The kind the task was taken for; null when the judge was not sure of any. */
+    kind: KindId | null;
+    /** The depth the task was taken for; null when the judge was not sure of any. */
+    depth: DepthId | null;
+    /** How settled the behavior was; absent on older decisions, null when unclear. */
+    clarity?: ClarityId | null;
+    /** Why, in short lines the page can show, the pick first. */
+    reasons: string[];
+}
+/** What a decision reads besides the task's classification. */
+export interface DecideContext {
+    /** The person's mapping, `AutoPickStore.rules()`. */
+    rules: AutoPickRules;
+    /** The roster, `Roster.agents()`. */
+    agents: RosterAgent[];
+    /**
+     * The ids of the agents splates can start here, `Conversations.agents`: a
+     * pick of any other is passed over, so the decision names one that runs.
+     */
+    runnable: readonly string[];
+    /** Each agent's plan limits, `Limits.all()`. */
+    limits: Record<string, Limit[]>;
+    /** What each agent that ran on this machine offers, `Offered.all()`. */
+    offered: Record<string, Setting[]>;
+    now: Date;
+    /** Whether the task's first prompt has an image attached, so a pick that cannot see one is passed over. */
+    images?: boolean;
+    /** What models.dev says each model takes in; null when never heard. */
+    catalog?: Catalog | null;
+    /** Whether each agent last said it takes images, `Offered.sights()`. */
+    sights?: Record<string, boolean>;
+}
+/** What `decide` reads. */
+export interface DecideInput extends DecideContext {
+    /** What the judge said of the task. */
+    classification: Classification;
+}
+/** What `decideWithout` reads. */
+export interface DecideWithoutInput extends DecideContext {
+    /** Why there is no classification, as `classify` said. */
+    reason: string;
+}
+/**
+ * A pick for a task the judge could not classify: the first rule that takes
+ * any kind and any depth, saying why the judge was not asked.
+ */
+export declare function decideWithout(input: DecideWithoutInput): AutoPickDecision;
+/**
+ * A pick for the work of `set` taken one depth deeper, as when its first
+ * answer showed it was more than judged: the first rule matching its kind and
+ * that depth, saying `why`. A depth the judge was unsure of counts as
+ * shallow; null when it is deep already.
+ */
+export declare function decideDeeper(input: DecideContext, set: {
+    kind: string | null;
+    depth: string | null;
+    clarity?: string | null;
+}, why: string): AutoPickDecision | null;
+/** The pick in words: `Sonnet 5.5, low effort`. */
+export declare function headline(pick: AgentPick, agent: RosterAgent): string;

package/vendor/@stringsync/splates-server/auto-pick/defaults.d.ts

@@ -0,0 +1,3 @@
+import type { AutoPickRules } from "./rules";
+/** The Auto pick rules used until the person saves their own, and restored by Reset. */
+export declare const DEFAULT_RULES: AutoPickRules;

package/vendor/@stringsync/splates-server/auto-pick/follow-up.d.ts

@@ -0,0 +1,25 @@
+import { type Message } from "../conversations";
+/**
+ * What to hand the judge after the person sends a message: null for their
+ * first, which Auto pick judged as the conversation started, otherwise
+ * everything they have said, the latest kept should it run long.
+ */
+export declare function wordsToJudge(messages: readonly Message[]): {
+    subject: string;
+    detail: string;
+} | null;
+/**
+ * What the judge reads of a conversation the person switched Auto pick on
+ * for: everything they have said in `messages`, the latest kept should it
+ * run long; null before they have said anything.
+ */
+export declare function wordsSoFar(messages: readonly Message[]): {
+    subject: string;
+    detail: string;
+} | null;
+/**
+ * Whether the person's second message, among `said`, answers a first agent
+ * reply that ended on a bare prose question rather than a card, however the
+ * conversation began.
+ */
+export declare function askedBack(messages: readonly Message[], said: readonly Message[]): boolean;

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

@@ -0,0 +1,24 @@
+export type { ClarityId, DepthId, KindId, TaskClass } from "./classes";
+export { CLARITIES, CLARITY_IDS, DEPTH_IDS, DEPTHS, KIND_IDS, KINDS, } from "./classes";
+export type { AttachmentInfo, Classification, Classified, ClassifyInput, } from "./classify";
+export { classify, DETAIL_CHARS } from "./classify";
+export { Clef } from "./clef";
+export type { AutoPickDecision, DecideContext, DecideInput, DecideWithoutInput, } from "./decide";
+export { decide, decideWithout } from "./decide";
+export { DEFAULT_RULES } from "./defaults";
+export { type Attribution, Jev } from "./jev";
+export { JUDGE_CREDS, type JudgeFor, judgeFrom, projectJudge, } from "./judge";
+export { classificationKey } from "./key";
+export { lifting } from "./lift";
+export { QueueAutoPick } from "./queue";
+export type { AutoPicked } from "./record";
+export { AutoPickRoutes } from "./routes";
+export type { AutoPickRules, CheckedRules, Pace, Rule } from "./rules";
+export { ANY, AUTO_PICK_RULES, checkRules, DEFAULT_PACE, RULES_FORMAT, ruleLabel, } from "./rules";
+export type { AutoPickAgent, AutoPickRulesView } from "./rules-routes";
+export { AutoPickRulesRoutes, pickableAgents } from "./rules-routes";
+export type { AutoPickStart, AutoPickTarget, AutoPickWords } from "./start";
+export { startAutoPick } from "./start";
+export { AutoPickStore } from "./store";
+export type { Judge, JudgeOptions, Judgment, Noul, Verdict, } from "./system-one";
+export type { AutoPickTrial } from "./trial";

package/vendor/@stringsync/splates-server/auto-pick/jev.d.ts

@@ -0,0 +1,38 @@
+import type { Spend } from "../spend";
+import { type EndpointOptions, type Judge, type JudgeOptions, type Judgment } from "./system-one";
+/**
+ * Dollars per million input tokens Jev bills, output free
+ * (https://docs.typesafe.ai/models.md). models.dev does not list TypeSafe,
+ * so the price lives here rather than in `prices`.
+ */
+export declare const JEV_INPUT_PRICE = 0.042;
+/** Whose work a judgment was for, as the ledger names them. */
+export interface Attribution {
+    project: string | null;
+    task: string | null;
+    conversation: string | null;
+    /**
+     * What the judgment was for, beyond Auto pick, which the ledger's service
+     * names after the model, as `jev-latest notes`, so the Billing page shows
+     * it apart; none for Auto pick's own.
+     */
+    purpose?: string;
+}
+export interface JevOptions extends EndpointOptions {
+    /** Where each call's cost is recorded, priced from the tokens the reply says; nowhere when not given. */
+    spend?: Spend;
+    /** What each call's ledger entry says it was for; nothing when not given. */
+    attribution?: Attribution;
+    /** When a call was made, for its ledger entry. */
+    now?: () => Date;
+}
+/** TypeSafe's decision model. */
+export declare class Jev implements Judge {
+    /** A TypeSafe API key. */
+    private readonly token;
+    private readonly opts;
+    constructor(
+    /** A TypeSafe API key. */
+    token: string, opts?: JevOptions);
+    judge(judgment: Judgment, opts?: JudgeOptions): Promise<import("./system-one").Verdict>;
+}

package/vendor/@stringsync/splates-server/auto-pick/judge.d.ts

@@ -0,0 +1,21 @@
+import type { Credentials } from "../../../core/creds/index.js";
+import type { Project } from "../server/shared";
+import { type Attribution, type JevOptions } from "./jev";
+import type { Judge } from "./system-one";
+/** The creds each judge reads, named as `wiz creds` names them. */
+export declare const JUDGE_CREDS: {
+    readonly jev: readonly ["TYPESAFE_API_KEY"];
+    readonly clef: readonly ["CLOUDFLARE_ACCOUNT_ID", "CLOUDFLARE_API_TOKEN"];
+};
+/**
+ * The judge `classify` asks: Jev when its key is kept, else Clef when its
+ * account is; null when neither is.
+ */
+export declare function judgeFrom(credentials: Pick<Credentials, "get">, opts?: JevOptions): Promise<Judge | null>;
+/** The judge for work done for `who`, as a caller asks it. */
+export type JudgeFor = (who: Partial<Attribution>) => Promise<Judge | null>;
+/**
+ * The judge `project`'s creds give, Jev's calls recorded in the machine's
+ * ledger under the project's `slug`, when it has one, and `who`.
+ */
+export declare function projectJudge(project: Project, slug: () => Promise<string | null>, who?: Partial<Attribution>): Promise<Judge | null>;

package/vendor/@stringsync/splates-server/auto-pick/judged.d.ts

@@ -0,0 +1,33 @@
+import type { TaskRecord } from "../board";
+import { type AttachmentInfo, type Classification } from "./classify";
+import { type AutoPickDecision, type DecideContext } from "./decide";
+import type { Attribution } from "./jev";
+import type { JudgeFor } from "./judge";
+import type { AutoPicked } from "./record";
+/** What Auto pick decided for a task's words, and what the judge said of them. */
+export interface Judged {
+    decision: AutoPickDecision;
+    /** What the judge said of the words, now or before; null when it said nothing. */
+    classification: Classification | null;
+    /** Whether there was a judge to ask; without one, its key is asked for. */
+    judged: boolean;
+}
+/**
+ * Decides for a task's words: on `cached`, what the judge said of the same
+ * words before, with no judge asked; else on what `judge` says now; else, the
+ * judge missing, failing or slow, on the rule for any task, saying why.
+ */
+export declare function decideFor({ subject, detail, attachments, cached, judge, who, context, }: {
+    subject: string;
+    detail: string;
+    attachments?: readonly AttachmentInfo[];
+    cached: Classification | null;
+    judge: JudgeFor;
+    /** Whose work the judgment is, for the spend ledger. */
+    who?: Partial<Attribution>;
+    context: DecideContext;
+}): Promise<Judged>;
+/** What the judge said of `record`'s words before, kept on it under `key`; null for none. */
+export declare function cachedFor(record: TaskRecord, key: string): Classification | null;
+/** `judged` as a task's record keeps it, decided `at`, its words' classification under `key`. */
+export declare function autoPicked({ decision, classification }: Judged, key: string, at: Date): AutoPicked;

package/vendor/@stringsync/splates-server/auto-pick/key.d.ts

@@ -0,0 +1,6 @@
+import { type AttachmentInfo } from "./classify";
+/**
+ * A short hash of what `classify` reads of a task, the same for the same
+ * subject and judged detail, for a caller to keep classifications by.
+ */
+export declare function classificationKey(subject: string, detail: string, attachments?: readonly AttachmentInfo[]): string;

package/vendor/@stringsync/splates-server/auto-pick/lift.d.ts

@@ -0,0 +1,18 @@
+import type { Conversations, Lift } from "../conversations";
+import type { Project } from "../server/shared";
+import { type JudgeFor } from "./judge";
+/**
+ * Builds the hook that, on each message the person sends to a conversation
+ * Auto pick started, has the judge read what they have said and moves the
+ * conversation to a stronger model or higher thinking level on the same
+ * agent when the rules give one, logged with an Undo. Does nothing once the
+ * person has moved its model or effort. An answer to the agent's first reply
+ * that ended on a bare question moves it to the rules' pick one depth deeper.
+ */
+export declare function lifting(project: Project, conversations: Conversations, { slug, judge, now, }?: {
+    /** The judge to ask; the one the project's creds give by default. */
+    judge?: JudgeFor;
+    /** The project's slug, to name it in the spend ledger; none when not given. */
+    slug?: () => Promise<string | null>;
+    now?: () => Date;
+}): Lift;

package/vendor/@stringsync/splates-server/auto-pick/queue.d.ts

@@ -0,0 +1,30 @@
+import type { TaskRecord } from "../board";
+import type { Conversations } from "../conversations";
+import type { AgentPick } from "../models";
+import type { QueuePicked, QueuePicker } from "../queue";
+import type { Project } from "../server/shared";
+import { type JudgeFor } from "./judge";
+/**
+ * Auto pick for the queue: a queued task that names no agent is judged as
+ * it is queued, and again whenever its words change, so its held
+ * conversation waits on the agent it will start on; it starts on what Auto
+ * pick decides then, kept on its record and logged in its conversation as a
+ * start from its Start menu is. Only the queue's own starts come here; a
+ * conversation the person starts on a task keeps its agent.
+ */
+export declare class QueueAutoPick implements QueuePicker {
+    #private;
+    constructor(project: Project, conversations: Conversations, { slug, judge, now, }?: {
+        /** The judge to ask; the one the project's creds give by default. */
+        judge?: JudgeFor;
+        /** The project's slug, to name it in the spend ledger; none when not given. */
+        slug?: () => Promise<string | null>;
+        now?: () => Date;
+    });
+    ahead(queued: readonly TaskRecord[]): Promise<void>;
+    judging(id: number): boolean;
+    /** Waits out every judgment under way, as a test or a shutdown does. */
+    settled(): Promise<void>;
+    guess(queued: readonly TaskRecord[]): Promise<Map<number, AgentPick>>;
+    decide(queued: TaskRecord): Promise<QueuePicked>;
+}

package/vendor/@stringsync/splates-server/auto-pick/rank.d.ts

@@ -0,0 +1,10 @@
+import type { AutoPickSet } from "../conversations";
+import { type AgentPick, type RosterAgent } from "../models";
+/**
+ * Whether `to` is above `from` on the same agent: a model of a higher tier,
+ * or the same model at a higher thinking level, as the roster ranks them. A
+ * model it cannot rank moves nothing.
+ */
+export declare function higher(agents: RosterAgent[], from: AutoPickSet, to: AgentPick): boolean;
+/** What `set` picked, as the roster names a pick. */
+export declare function pickOf(set: AutoPickSet): AgentPick;

package/vendor/@stringsync/splates-server/auto-pick/record.d.ts

@@ -0,0 +1,19 @@
+import type { Classification } from "./classify";
+import type { AutoPickDecision } from "./decide";
+/**
+ * The last Auto pick for a task, kept on its record: whom it started and
+ * why, and what the judge said of the task's words and attachment metadata, so a pick of the same
+ * words again needs no judge.
+ */
+export interface AutoPicked extends AutoPickDecision {
+    /** When it was decided, as an ISO time. */
+    at: string;
+    /**
+     * What the judge said of the task, by the `classificationKey` of the words
+     * it read, including breadth, clarity, stakes and verification; absent when it said nothing, as with no judge or one that failed.
+     */
+    classified?: {
+        key: string;
+        classification: Classification;
+    };
+}

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

@@ -0,0 +1,25 @@
+import type { Conversations } from "../conversations";
+import type { Project, ProjectWatch } from "../server/shared";
+/**
+ * Starts a task on what Auto pick decides, or shows what it would decide.
+ * Spread an instance into a project's routes, as `ConversationRoutes` is.
+ */
+export declare class AutoPickRoutes {
+    #private;
+    constructor(project: Project, conversations: Conversations | null, watch: ProjectWatch, slug?: () => Promise<string | null>);
+    /**
+     * Starts a conversation on what Auto pick decides for `task`, a started
+     * task by name, in its tree, or `todo`, a queued one by number, in the
+     * main tree, or `words`, a new conversation's first message, in `task`'s
+     * tree if one is named. It answers before the judge does, as any start answers
+     * before its agent opens, and the prompt the page sends next waits on the
+     * pick.
+     */
+    readonly startAutoPick: (request: Request) => Promise<Response>;
+    /**
+     * What Auto pick would decide for `task` or `todo`, named as for
+     * `startAutoPick`, without starting it or writing its record: Setup's
+     * "Try it on a task".
+     */
+    readonly tryAutoPick: (request: Request) => Promise<Response>;
+}

package/vendor/@stringsync/splates-server/auto-pick/rule-names.d.ts

@@ -0,0 +1,9 @@
+import type { Pace, Rule } from "./rules";
+/** The rules' own format. */
+export declare const RULES_FORMAT = 2;
+/** The rule every mapping ends on, so every classification maps somewhere. */
+export declare const ANY: "*";
+/** The pace a mapping without one takes. */
+export declare const DEFAULT_PACE: Pace;
+/** What a rule matches in words: `Mechanical, any depth`. */
+export declare function ruleLabel(rule: Pick<Rule, "kind" | "depth" | "clarity">): string;

package/vendor/@stringsync/splates-server/auto-pick/rules-routes.d.ts

@@ -0,0 +1,49 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { AutoPickRules } from "./rules";
+/** The rules as Setup's editor reads them, with what each pick can name. */
+export interface AutoPickRulesView {
+    /** The rules saved, or the defaults when the file is missing or broken. */
+    rules: AutoPickRules;
+    /** Why the file could not be read, so saving would replace it; null when it read. */
+    problem: string | null;
+    /** The roster's agents, in its order, for a pick to name. */
+    agents: AutoPickAgent[];
+}
+/** An agent a pick can name, and what it can name with it. */
+export interface AutoPickAgent {
+    id: string;
+    name: string;
+    /** The roster's models for it; none when the roster leaves them to the agent. */
+    models: {
+        id: string;
+        name: string;
+    }[];
+    /**
+     * The thinking levels it offered when it last ran here, by value; null
+     * when it never ran here, so what it takes is not known yet.
+     */
+    efforts: string[] | null;
+}
+/**
+ * How Setup reads and writes this machine's Auto pick rules, the one
+ * mapping every project shares. Each handler is a property, so `dev` hands
+ * them straight to its routes, as it does `SetupRoutes`'.
+ */
+export declare class AutoPickRulesRoutes {
+    #private;
+    constructor({ fs, home }: {
+        fs: Fs;
+        home: string;
+    });
+    /** The rules and the agents a pick can name. */
+    readonly read: () => Promise<Response>;
+    /**
+     * Saves the rules the body's `rules` holds, answering the view of them,
+     * or a 400 whose message says what does not check out, the file untouched.
+     */
+    readonly save: (request: Request) => Promise<Response>;
+    /** Writes the defaults over the rules, answering the view of them. */
+    readonly reset: () => Promise<Response>;
+}
+/** The roster's agents in its order, each with the models and thinking levels a pick can name. */
+export declare function pickableAgents(fs: Fs, home: string): Promise<AutoPickAgent[]>;

package/vendor/@stringsync/splates-server/auto-pick/rules.d.ts

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import type { AgentPick } from "../models";
+import { type ClarityId, type DepthId, type KindId } from "./classes";
+import { ANY, DEFAULT_PACE, RULES_FORMAT, ruleLabel } from "./rule-names";
+export { ANY, DEFAULT_PACE, RULES_FORMAT, ruleLabel };
+/**
+ * The person's mapping from a task's classification to an agent, a model and
+ * a thinking level, one per machine, kept in `~/.splates/auto-pick.json`.
+ */
+export interface AutoPickRules {
+    /** The file's own format. */
+    format: 2;
+    /**
+     * How sure the judge has to be, 0 to 1, before its likeliest kind, depth or
+     * certainty counts; below it, the task is that dimension's `*` alone.
+     */
+    threshold: number;
+    /** Tried in order: the first that matches the task decides. The last is `* *`. */
+    rules: Rule[];
+    /** When a pick's plan counts as used too fast; left out, `DEFAULT_PACE`. */
+    pace?: Pace;
+}
+/** One line of the mapping: what it matches, and whom it picks. */
+export interface Rule {
+    /** The kind of work it matches, or `*` for any, a task of no sure kind too. */
+    kind: KindId | "*";
+    /** The depth it matches, or `*` for any, a task of no sure depth too. */
+    depth: DepthId | "*";
+    /** How settled the behavior is; omitted or * accepts any certainty, including unknown. */
+    clarity?: ClarityId | "*";
+    /**
+     * Whom it picks, the first first: a pick whose agent's plan is nearly
+     * used up is passed over for the next. A pick with no model takes the
+     * agent's default model, one with no effort its default thinking level.
+     */
+    picks: AgentPick[];
+}
+/** Rules that check out, or the first problem with them, in a line the page can show. */
+export type CheckedRules = {
+    ok: true;
+    rules: AutoPickRules;
+} | {
+    ok: false;
+    problem: string;
+};
+/** Checks `value` as a mapping, for the page's editor and the file alike. */
+export declare function checkRules(value: unknown): CheckedRules;
+/**
+ * When a pick is passed over for the next on its rule because of its agent's
+ * plan, each share 0 to 1 of a plan window.
+ */
+export interface Pace {
+    /**
+     * Whether a pick is passed over while its agent uses any window faster
+     * than the window goes by: more of it used than `slack` past the share
+     * of it gone.
+     */
+    on: boolean;
+    /** How far use may run ahead of the window's time before a pick is passed over. */
+    slack: number;
+    /** Past this much of any window, a pick is passed over, pace or not. */
+    spent: number;
+}
+/** What `auto-pick.json` holds, its last rule `* *`. */
+export declare const AUTO_PICK_RULES: z.ZodObject<{
+    format: z.ZodLiteral<2>;
+    threshold: z.ZodNumber;
+    rules: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "*": "*";
+            bugfix: "bugfix";
+            design: "design";
+            open: "open";
+        }>;
+        depth: z.ZodEnum<{
+            "*": "*";
+            deep: "deep";
+            moderate: "moderate";
+            shallow: "shallow";
+        }>;
+        clarity: z.ZodOptional<z.ZodEnum<{
+            "*": "*";
+            settled: "settled";
+            unresolved: "unresolved";
+        }>>;
+        picks: z.ZodArray<z.ZodObject<{
+            agent: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+            effort: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    pace: z.ZodOptional<z.ZodObject<{
+        on: z.ZodBoolean;
+        slack: z.ZodNumber;
+        spent: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;