@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/models/roster.d.ts

@@ -0,0 +1,130 @@
+import type { Ps } from "../../../core/system/index.js";
+import type { Agent, Setting } from "../conversations";
+import { type Document, type Storage } from "../storage";
+/**
+ * The agents splates can start and the models each runs, from
+ * `~/.splates/agents.json`, which an orchestrator in any project, of any
+ * model family, reads to delegate to any other.
+ */
+export declare class Roster {
+    /** `~/.splates/agents.json`, or a test's own. */
+    private readonly doc;
+    /** Where the file is, as a message names it. */
+    readonly path: string;
+    constructor(
+    /** `~/.splates/agents.json`, or a test's own. */
+    doc: Document<unknown>, 
+    /** Where the file is, as a message names it. */
+    path?: string);
+    /** The roster kept in `agents.json` of `storage`, the machine's. */
+    static in(storage: Storage): Roster;
+    /** The file's JSON, null when there is none; a file not JSON is refused. */
+    private load;
+    /** The validated document, retaining fields that splates does not interpret. */
+    read(): Promise<RosterFile | null>;
+    /** Edits the latest validated roster under its document's lock. */
+    update(edit: (file: RosterFile | null) => RosterFile | Promise<RosterFile>): Promise<void>;
+    /**
+     * Writes the defaults when there is no roster yet, saying whether it did,
+     * so the user has a file to edit rather than a list they cannot see.
+     */
+    seed(): Promise<boolean>;
+    /**
+     * Adds default agent `agent` to a roster written before it joined the
+     * defaults, once: an agent the roster has seen, as one it was seeded with,
+     * stays off it once the person takes it off. Returns whether it changed.
+     */
+    gain(agent: string): Promise<boolean>;
+    /**
+     * Puts `agent` on the roster running `models`, in the default roster's
+     * order, creating the file when there is none. Only that agent's entry
+     * changes: another agent, this one's launch arguments and any model of its
+     * own that the defaults do not list stay as they are.
+     */
+    choose(agent: string, models: readonly string[]): Promise<void>;
+    /**
+     * Adds to each roster agent the default models it offers (`offered`, by
+     * agent id) that the roster lacks and has not yet seen, so a roster
+     * written before a default joined still carries it. A model the person
+     * dropped by choosing stays dropped. Returns whether the roster changed.
+     */
+    adopt(offered: Record<string, Setting[]>): Promise<boolean>;
+    /**
+     * Takes `agent` off the roster, leaving every other entry as it is. A
+     * roster that does not list it, or no roster at all, is left alone; one
+     * left with no agents stays, empty, rather than going back to the defaults.
+     */
+    remove(agent: string): Promise<void>;
+    /** Every agent on the roster, in its order; the defaults when there is none. */
+    agents(): Promise<RosterAgent[]>;
+    private validate;
+    private write;
+}
+/** A validated roster with its unrecognized fields kept for editing. */
+export interface RosterFile {
+    format?: number;
+    agents: RosterAgent[];
+    [key: string]: unknown;
+}
+/** A model an agent can run, and what picking it buys. */
+export interface RosterModel {
+    /** What the agent's Model setting takes: `opus`, `gpt-6-luna`. */
+    id: string;
+    name: string;
+    /** What it is good at, so an orchestrator can choose it for a job. */
+    strengths: string;
+    /** What it costs, relative to the others or as a price. */
+    cost: string;
+    /** How capable it is, 1 (weakest) to 4 (strongest). */
+    tier?: number;
+    /** How quickly it answers. */
+    speed?: Speed;
+    /** What it costs against the others, 1 (cheapest) to 4 (dearest). */
+    costRank?: number;
+}
+/** How quickly a model answers. */
+export type Speed = "fast" | "medium" | "slow";
+/** An agent on the roster: how to start it, and the models it runs. */
+export interface RosterAgent extends Agent {
+    models: RosterModel[];
+}
+/**
+ * The agents a machine's roster starts with, and what it lists while there is
+ * no `agents.json`: each with the models it offers, by the ids its Model
+ * setting takes.
+ */
+export declare const DEFAULT_AGENTS: RosterAgent[];
+/** An agent off the roster, on one of its models, or on its own without one. */
+export interface AgentPick {
+    agent: string;
+    /** The roster's id for the model, which the agent's Model setting takes. */
+    model?: string;
+    /** The thinking level, by the value the agent's thought_level setting takes; absent, the agent's own. */
+    effort?: string;
+}
+/** The models `agent` runs, as the roster lists them; none for an agent off it. */
+export declare function modelsOf(agent: Agent): RosterModel[];
+/** What the router compares models by; every field is always known. */
+export interface ModelTraits {
+    tier: number;
+    speed: Speed;
+    costRank: number;
+}
+/**
+ * Speed, tier and cost rank of `pick`'s model: the roster's own, else the
+ * default roster's for that agent and model, so an `agents.json` written before
+ * these fields still ranks. Undefined for a pick on no model, or one neither
+ * knows or whose fields are still missing.
+ */
+export declare function traitsOf(agents: RosterAgent[], pick: AgentPick): ModelTraits | undefined;
+/** `pick` in a word: `claude`, or `claude (opus)` on a model. */
+export declare function pickLabel(pick: AgentPick): string;
+/**
+ * `agent` on `model`, named by its id or name in any case, as the roster's
+ * ids; OpenCode and provider-qualified models require an exact ID. Refuses an agent or a model the roster does not list, saying so with
+ * `data`. An agent whose models the roster leaves out takes the model as
+ * given.
+ */
+export declare function pickAgent(agents: RosterAgent[], agent: string, model: string | undefined, data?: Record<string, unknown>): AgentPick;
+/** Where the user's splates files live: `~/.splates`, or `SPLATES_HOME`, as the tests set. */
+export declare function splatesHome(ps: Ps): string;

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

@@ -0,0 +1,99 @@
+import { type Demo } from "./demo";
+import { type PermissionProposal } from "./permission";
+import { type Question } from "./plan";
+/**
+ * `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, a task it proposes, a permission it asks the person
+ * to give, or a demo for the person to try.
+ */
+export type Stretch = {
+    type: "text";
+    text: string;
+} | {
+    type: "questions";
+    questions: Question[];
+} | {
+    type: "review";
+    review: Review;
+} | {
+    type: "proposal";
+    proposal: Proposal;
+} | {
+    type: "report";
+    report: TaskReport;
+} | {
+    type: "todo";
+    todo: TodoProposal;
+} | {
+    type: "permission";
+    permission: PermissionProposal;
+} | {
+    type: "demo";
+    demo: Demo;
+};
+/** 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, as the skill's reports title them. */
+export type Ending = "merged" | "done" | "removed" | "deferred" | "escalated" | "working";
+/**
+ * A report the skill titles `## ✅ Merged <task> onto <base>`, `## ✅ Done:
+ * <what came of it>` (work over with no task, such as an automation's run), `## 🛑 Removed
+ * <task>: <why>`, `## ⏸ Deferred <task>: <what it waits on>`, `## ⚠️ Escalated <task>: <what it needs>`, or `## ⏳
+ * Working <task>: on <agent>`.
+ */
+export interface TaskReport {
+    ending: Ending;
+    task: string;
+    /** Where it merged; null for the others. */
+    base: 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;
+}
+/** A queued task 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 task is and why it matters now, as markdown. */
+    body: string;
+}

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

@@ -0,0 +1,13 @@
+export type { Ending, Review, Stretch, TaskReport } from "./asked";
+export { stretches } from "./asked";
+export { keptDecisions, madeByYou } from "./decided";
+export type { Need, Needing } from "./needs";
+export { answeredThrough, answersTo, externals, need, needOfExternal, needs, openedBy, orphaned, TASK, } from "./needs";
+export { queueIsSettled } from "./permission";
+export { goalLine, questions, sectionApart } from "./plan";
+export type { DemoPoint } from "./prompts";
+export { APPROVE, CHECKPOINT, DEFER, DIRECTIVES, demoReference, directive, GRANT_DENIED, GRANTED, handOffReference, isUpdate, leadingDirectives, MERGE, RECONNECT, RESUME, RETRIED, RUN_ALLOWED, RUN_DENIED, setupReference, taskNumberReference, taskReference, UNTRIAGED, unmergeReference, } from "./prompts";
+export type { Answer } from "./reply";
+export { answerIn, besides, changes, isEmpty, quotedIn, replyOf, takenOf, } from "./reply";
+export { isWholeSuite, retryOf, shipOf } from "./run-command";
+export { unanswered, waitsOnYou } from "./unanswered";

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

@@ -0,0 +1,12 @@
+import type { Outcome } from "../stats";
+import type { Decision } from "./plan";
+/** How many calls in `outcome` the person made: the questions put to them. */
+export declare function madeByYou(outcome: Outcome): number;
+/**
+ * The questions `outcome` asked, each with how many it stands for: its own
+ * decisions one each, or for a line from before they were kept, its counts
+ * read back as unsized questions.
+ */
+export declare function decided(outcome: Outcome): [Pick<Decision, "size" | "ended">, number][];
+/** Whether `outcome` kept its calls at all: lines from before any were kept say nothing of them. */
+export declare function keptDecisions(outcome: Outcome): boolean;

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

@@ -0,0 +1,29 @@
+/**
+ * Something to try, as the skill writes it under `### 🎬 Demo: <title>`:
+ * where, then numbered steps.
+ */
+export interface Demo {
+    /** What it shows, from its heading; null when the heading says none. */
+    title: string | null;
+    /** Where to try it and anything said before the steps, as markdown. */
+    intro: string;
+    steps: Step[];
+}
+/** A step of a demo: what to do, on its line, and what to see, under it. */
+export interface Step {
+    number: string;
+    action: string;
+    /** What should happen, screenshots included, as markdown. */
+    expect: string;
+}
+/**
+ * The demo titled at `start`: what it says up to its steps, or to `until`,
+ * where something else begins, then its steps, and the line after them; null
+ * for any other line.
+ */
+export declare function demoAt(lines: string[], start: number, until: number): {
+    demo: Demo;
+    end: number;
+} | null;
+/** Whether `line` titles a demo. */
+export declare function isDemoTitle(line: string): boolean;

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

@@ -0,0 +1,16 @@
+export type { Ending, Proposal, Review, Stretch, TaskReport, TodoProposal, } from "./asked";
+export { stretches } from "./asked";
+export { decided, keptDecisions, madeByYou } from "./decided";
+export type { Demo } from "./demo";
+export type { Need, Needing } from "./needs";
+export { ASKED_QUIET, answeredThrough, answersTo, externals, need, needOfExternal, needs, openedBy, orphaned, TASK, } from "./needs";
+export type { EvalAsk, PermissionProposal, ReachAsk } from "./permission";
+export { queueIsSettled } from "./permission";
+export type { Decision, Question } from "./plan";
+export { checkPlan, decisions, goalLine, goalOf, openQuestions, outcomeOf, PLAN_FILE, Plans, picks, questions, ready, sectionApart, unfinished, whatIsLeft, } from "./plan";
+export type { DemoPoint } from "./prompts";
+export { APPROVE, CHECKPOINT, continuedReference, DEFER, DICTATED, DIRECTIVES, directive, evalsDoneReference, eventReference, GRANT_DENIED, GRANTED, groomReference, handOffReference, isUpdate, leadingDirectives, MERGE, RECONNECT, RESUME, RETRIED, RUN_ALLOWED, RUN_DENIED, scheduleReference, setupReference, sortReference, taskNumberReference, taskReference, UNTRIAGED, } from "./prompts";
+export type { Answer } from "./reply";
+export { answerIn, besides, changes, isEmpty, quotedIn, replyOf, takenOf, } from "./reply";
+export { PlanStore } from "./store";
+export { unanswered, waitsOnYou } from "./unanswered";

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

@@ -0,0 +1,137 @@
+import {
+  queueIsSettled2,
+  PLAN_FILE2,
+  Plans2,
+  goalLine2,
+  sectionApart2,
+  outcomeOf2,
+  goalOf2,
+  questions2,
+  openQuestions2,
+  picks2,
+  decisions2,
+  unfinished2,
+  ready2,
+  whatIsLeft2,
+  checkPlan2,
+  stretches2,
+  madeByYou2,
+  decided2,
+  keptDecisions2,
+  needs2,
+  externals2,
+  needOfExternal2,
+  orphaned2,
+  ASKED_QUIET2,
+  need2,
+  answeredThrough2,
+  answersTo2,
+  TASK2,
+  openedBy2,
+  taskNumberReference2,
+  UNTRIAGED2,
+  eventReference2,
+  scheduleReference2,
+  groomReference2,
+  sortReference2,
+  taskReference2,
+  handOffReference2,
+  continuedReference2,
+  setupReference2,
+  isUpdate2,
+  evalsDoneReference2,
+  CHECKPOINT2,
+  RESUME2,
+  RECONNECT2,
+  MERGE2,
+  RUN_ALLOWED2,
+  RUN_DENIED2,
+  RETRIED2,
+  GRANTED2,
+  GRANT_DENIED2,
+  APPROVE2,
+  DEFER2,
+  DICTATED2,
+  DIRECTIVES2,
+  leadingDirectives2,
+  directive2,
+  replyOf2,
+  isEmpty2,
+  takenOf2,
+  changes2,
+  quotedIn2,
+  answerIn2,
+  besides2,
+  PlanStore2,
+  unanswered2,
+  waitsOnYou2
+} from "../index-0jttnv86.js";
+import"../index-g18nxyn7.js";
+export {
+  APPROVE2 as APPROVE,
+  ASKED_QUIET2 as ASKED_QUIET,
+  CHECKPOINT2 as CHECKPOINT,
+  DEFER2 as DEFER,
+  DICTATED2 as DICTATED,
+  DIRECTIVES2 as DIRECTIVES,
+  GRANTED2 as GRANTED,
+  GRANT_DENIED2 as GRANT_DENIED,
+  MERGE2 as MERGE,
+  PLAN_FILE2 as PLAN_FILE,
+  PlanStore2 as PlanStore,
+  Plans2 as Plans,
+  RECONNECT2 as RECONNECT,
+  RESUME2 as RESUME,
+  RETRIED2 as RETRIED,
+  RUN_ALLOWED2 as RUN_ALLOWED,
+  RUN_DENIED2 as RUN_DENIED,
+  TASK2 as TASK,
+  UNTRIAGED2 as UNTRIAGED,
+  answerIn2 as answerIn,
+  answeredThrough2 as answeredThrough,
+  answersTo2 as answersTo,
+  besides2 as besides,
+  changes2 as changes,
+  checkPlan2 as checkPlan,
+  continuedReference2 as continuedReference,
+  decided2 as decided,
+  decisions2 as decisions,
+  directive2 as directive,
+  evalsDoneReference2 as evalsDoneReference,
+  eventReference2 as eventReference,
+  externals2 as externals,
+  goalLine2 as goalLine,
+  goalOf2 as goalOf,
+  groomReference2 as groomReference,
+  handOffReference2 as handOffReference,
+  isEmpty2 as isEmpty,
+  isUpdate2 as isUpdate,
+  keptDecisions2 as keptDecisions,
+  leadingDirectives2 as leadingDirectives,
+  madeByYou2 as madeByYou,
+  need2 as need,
+  needOfExternal2 as needOfExternal,
+  needs2 as needs,
+  openQuestions2 as openQuestions,
+  openedBy2 as openedBy,
+  orphaned2 as orphaned,
+  outcomeOf2 as outcomeOf,
+  picks2 as picks,
+  questions2 as questions,
+  queueIsSettled2 as queueIsSettled,
+  quotedIn2 as quotedIn,
+  ready2 as ready,
+  replyOf2 as replyOf,
+  scheduleReference2 as scheduleReference,
+  sectionApart2 as sectionApart,
+  setupReference2 as setupReference,
+  sortReference2 as sortReference,
+  stretches2 as stretches,
+  takenOf2 as takenOf,
+  taskNumberReference2 as taskNumberReference,
+  taskReference2 as taskReference,
+  unanswered2 as unanswered,
+  unfinished2 as unfinished,
+  waitsOnYou2 as waitsOnYou,
+  whatIsLeft2 as whatIsLeft
+};

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

@@ -0,0 +1,131 @@
+import { Duration } from "../../../core/time/index.js";
+import type { TaskRecord } from "../board";
+import type { ConversationState } from "../conversations";
+import type { Details } from "../tasks";
+import { type Question } from "./plan";
+/** One agent the page shows: a conversation, its task, or both. */
+export interface Needing {
+    conversation: ConversationState | null;
+    task: Details | null;
+    need: Need;
+}
+/**
+ * Every listed conversation, and every live task no listed conversation runs
+ * in (an external agent, run outside the page) and none is about to, with
+ * what each needs: those waiting first,
+ * oldest stop first, then those assuming, most open questions first, then the
+ * rest in the order given.
+ */
+export declare function needs({ tasks, conversations, todos, now, }: {
+    tasks: Details[];
+    conversations: ConversationState[];
+    /** The board's tasks, to tell a queue card already acted on from one still asking. */
+    todos?: readonly TaskRecord[];
+    /** What an external agent's quiet is measured to: see `ASKED_QUIET`. */
+    now?: number;
+}): Needing[];
+/**
+ * What an agent needs from the person, by how much it costs to leave it:
+ * `waiting` has stopped on them, `assuming` goes ahead on a guess an answer
+ * may overturn, `working` needs nothing yet, and `idle` is not doing anything.
+ */
+export type Need = {
+    kind: "waiting";
+    why: Why;
+    /**
+     * What to act on: the ask, the review's summary, the first open
+     * question, or the failure.
+     */
+    subject: string;
+    /** When it stopped, where that is known. */
+    since: string | null;
+    /**
+     * The task's open questions, else those the agent's last reply
+     * asks; none for other waits of a task-less conversation.
+     */
+    questions: Question[];
+    /** The agent handed out by this one it waits for, lifted onto it. */
+    via?: string;
+} | {
+    kind: "assuming";
+    /** The first open question. */
+    subject: string;
+    questions: Question[];
+    /** The agent handed out by this one whose questions it relays. */
+    via?: string;
+} | {
+    kind: "working";
+    /** The next step under `## Next`, else the Goal's first line. */
+    subject: string | null;
+    /** Its task's merge: waiting its turn for the premerge lock, or testing and landing. */
+    merge?: "queued" | "running";
+    /** When that merge was asked for, its wait for the lock included. */
+    mergeSince?: string;
+    /** A queued merge's place in line for the lock, 1 being next. */
+    mergePlace?: number;
+    /** Its turn is over and a run its eval card started goes on. */
+    evals?: true;
+} | {
+    kind: "idle";
+};
+/**
+ * Why an agent waits: a live ACP ask (a permission or a form), a review its
+ * last reply asked for, open questions it ended its turn on, in its task's
+ * `## Blocked` or its last reply (or for an external agent, went quiet on), a failure, or for a task, no agent left on
+ * it (see `orphaned`).
+ */
+export type Why = "ask" | "review" | "questions" | "failed" | "orphaned";
+/**
+ * Every live task no listed conversation runs in, an external agent's, with
+ * what it needs, before `answeredThrough`. One handed to an agent shows once
+ * its conversation starts.
+ */
+export declare function externals(tasks: Details[], conversations: ConversationState[], now?: number): Needing[];
+/** What a task no listed conversation runs in needs: see `externals`. */
+export declare function needOfExternal(task: Details, conversations: ConversationState[], now?: number): Need;
+/**
+ * Whether no agent the page runs is left on a live task: none is on it,
+ * the one whose agent last took it is archived or gone, or every one on it
+ * failed. What it says of it, and since when; null while an agent may yet
+ * be on it: one on it that has not failed, an agent outside the page holding
+ * its lease now, or one a listed conversation started, which answers to it
+ * (see `answersTo`). A conversation listed on another task may have a
+ * subagent on this one, so it is not orphaned either.
+ */
+export declare function orphaned(task: Details, conversations: readonly ConversationState[]): {
+    subject: string;
+    since: string | null;
+} | null;
+/**
+ * How long an external agent goes without a sign of work on its task, with
+ * questions open, before it is taken to wait on their answers: it has ended
+ * its turn on them, as a page conversation shows outright.
+ */
+export declare const ASKED_QUIET: Duration;
+/**
+ * What one agent needs, from its conversation (null for an agent the page
+ * does not run) and the task it is in (null for the main tree), at `now`.
+ */
+export declare function need(task: Details | null, conversation: ConversationState | null, now?: number, todos?: readonly TaskRecord[]): Need;
+/**
+ * `found` with each agent that answers to another conversation waiting on
+ * that one rather than on the person: only the person answers its asks, so
+ * one waits on that one's row, where they show, whatever it is doing; its
+ * questions reach the person through that one's reports, so one waits on
+ * that one's row once it is idle, having relayed it, naming the agent, and
+ * while it works on regardless, that one goes ahead with them owed, as an
+ * assuming agent does. A failure stays the agent's own, since nothing tells
+ * that one of it.
+ */
+export declare function answeredThrough(found: Needing[], conversations: ConversationState[]): Needing[];
+/**
+ * The conversation an external agent, such as a subagent its harness
+ * started, answers to rather than the person, while the page holds it: the
+ * listed one whose agent added its task. A conversation of its own answers
+ * to the person.
+ */
+export declare function answersTo({ conversation, task }: Pick<Needing, "conversation" | "task">, conversations: readonly ConversationState[]): ConversationState | null;
+/** What `#conversations/task/<name>` opens: a task whose agent runs outside the page. */
+export declare const TASK = "task/";
+/** What opens `row`: its conversation's id, or its external agent's task. */
+export declare function openedBy(row: Needing): string;

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

@@ -0,0 +1,64 @@
+import type { TaskRecord } from "../board";
+import type { Reach } from "../projects";
+/** Whether the board has queued or started every task a queue card names. */
+export declare function queueIsSettled(proposal: PermissionProposal, todos: readonly TaskRecord[]): boolean;
+/** Whether `line` titles a permission card. */
+export declare function asksPermission(line: string): boolean;
+/** What the permission card titled `line`, with `body` under it, asks; null for any other line. */
+export declare function permissionOf(line: string, body: string): PermissionProposal | null;
+/**
+ * A permission card an agent's reply ends with, asking the person to allow
+ * what an agent never does itself: queue a lane or tasks, remove a lane, run
+ * evals or a heavy command, or grant one project reach into another. The
+ * card's buttons act on it.
+ */
+export interface PermissionProposal {
+    /**
+     * What it asks: queue work, remove a lane with its tasks, run evals, run
+     * a heavy command, the whole test suite among them, or let one project
+     * reach further into another.
+     */
+    action: "queue" | "remove-lane" | "run-evals" | "run-command" | "grant";
+    /**
+     * For `queue`: the other project, by its slug, whose tasks it queues;
+     * absent for the conversation's own.
+     */
+    project?: string;
+    /** For `grant`: what it lets project `from` do in project `in`. */
+    grant?: ReachAsk;
+    /** The lane it acts on whole; null for tasks named one by one. */
+    lane: number | null;
+    /** The tasks named one by one; none for a lane. */
+    tasks: number[];
+    /** What the title says after its colon, if anything. */
+    title: string | null;
+    /** What it comes to, as markdown. */
+    body: string;
+    /** For `run-evals`: what to run, from the card's scenario list. */
+    evals?: EvalAsk;
+    /** For `run-command`: the command to run, from the first backticked line. */
+    command?: string;
+}
+/**
+ * The reach a `## 🔐 Permission: grant <in> <reach> to <from>` card asks
+ * project `in` to give project `from`, each by its slug.
+ */
+export interface ReachAsk {
+    in: string;
+    from: string;
+    reach: Reach;
+}
+/**
+ * The evals a `## 🔐 Permission: run evals <skill>: <what it checks>` card
+ * asks to run: the scenarios it picked, one `` - `scenario-id` `` item each, and
+ * optionally the revision the skill's change is judged against, as a
+ * `` Baseline: `rev` `` line and how many times to run each cell, as a
+ * `Repetitions: <n>` line.
+ */
+export interface EvalAsk {
+    skill: string;
+    scenarios: string[];
+    baseline: string | null;
+    /** Runs of each cell; the runner's own default when absent. */
+    reps?: number;
+}