toolroll 0.9.103 → 0.9.105

package/dist/flow-replies.d.ts

@@ -1,48 +0,0 @@
-/**
- * Replies to a card's email (v91).
- *
- * A Send email step keeps the Message-ID of what it sent and whom it went
- * to. An email that names one of those (In-Reply-To or References) and comes
- * from someone the card wrote to is a reply to that card: it joins the card's
- * discussion, and a card waiting for it in a Wait zone moves on, the reply
- * kept as that zone's output ({{stage.<wait zone>}}). Anyone can copy a
- * Message-ID into a header, so a message from anyone else is never taken as a
- * reply; neither is a machine's (out of office, bounces).
- *
- * The mailbox is read for replies only while some card is in an email
- * conversation, about once a minute, read-only like Inbox triggers. An Inbox
- * trigger reading the same mailbox hands replies here instead of making a new
- * card, and a reply both see is taken once.
- */
-import type { FlowCardRow, Store } from "./store.js";
-import { type InboundMail, type MailReader } from "./mailbox.js";
-/** Where the next email to this card's conversation goes in the thread: its latest message, and the chain before it. */
-export declare function threadOf(store: Store, card: FlowCardRow): {
-    inReplyTo: string;
-    references: string[];
-    people: Set<string>;
-} | null;
-/** What a Send email step sent, kept so a reply can find the card (and the email the card came from, which a reply may name). */
-export declare function recordSent(store: Store, card: FlowCardRow, sent: {
-    id: string;
-    to: string[];
-}, now: Date): void;
-export type Replied = {
-    card: FlowCardRow;
-    moved: boolean;
-    again: boolean;
-};
-/** Take one email as a reply to the card whose conversation it answers; null when it answers none that is active. */
-export declare function takeReply(store: Store, mail: InboundMail, own: string, now: Date): Replied | null;
-export type ReplyWatchIo = {
-    dir: string | null;
-    fetch: typeof fetch;
-    mail?: MailReader;
-};
-export type ReplyWatch = {
-    read: number;
-    taken: number;
-    problem: string | null;
-};
-/** Read the mailbox for replies to cards in an email conversation, when it is due. */
-export declare function watchFlowReplies(store: Store, now: Date, io: ReplyWatchIo): Promise<ReplyWatch>;

package/dist/flow-result-card.d.ts

@@ -1,22 +0,0 @@
-/**
- * A flow's result as a card (docs/plans/toolroll-cards.md): its steps from what the flow recorded (flow_event), with no
- * model, and a research report's items shown as the agent's report, never as Toolroll's records.
- */
-import { type ChatCard } from "./contracts/chat-card.js";
-import type { FlowDefinition } from "./flows.js";
-import type { FlowCardRow, FlowRow, Store } from "./store.js";
-/** The result card of one flow card, as its records stand now; null when there is nothing recorded to show. */
-export declare function flowResultCard(store: Store, flow: FlowRow, definition: FlowDefinition, card: FlowCardRow, now: Date, extra?: {
-    links?: readonly {
-        label: string;
-        path: string;
-    }[];
-    items?: readonly {
-        title: string;
-        source: string;
-    }[];
-}): ChatCard | null;
-/** The result card a "Done" notice carries; null for every other notice. */
-export declare function flowDoneCard(store: Store, notification: {
-    dedupeKey: string;
-}, now: Date): ChatCard | null;

package/dist/flow-schedule.d.ts

@@ -1,154 +0,0 @@
-/**
- * Schedules (v115: flow-owned; routines became scheduled flows).
- *
- * A schedule trigger fires on one of four readable cadences. Its two failure modes are subtle enough to deserve
- * names: advancing one interval after downtime leaves the next firing in the past — a catch-up burst; advancing to
- * `now + interval` drifts the cadence forever. The rule is ALIGNED advancement: the next occurrence strictly after
- * now, anchored to the occurrence that just fired (for `every`) or to the clock itself (for calendar schedules).
- * Missed slots while nothing was running fire ONCE — the overdue occurrence — and are never backfilled.
- */
-import type { StandingOrder } from "./contracts/flow.js";
-import { type PhaseRoute } from "./phase-routing.js";
-import { type AcceptanceCriterion, type ExecutionProfile } from "./scope.js";
-import { type Store } from "./store.js";
-export type { StandingOrder };
-export type Schedule = {
-    kind: "every";
-    minutes: number;
-} | {
-    kind: "daily";
-    hhmm: string;
-    timezone?: string;
-}
-/** v96: Monday to Friday. */
- | {
-    kind: "weekdays";
-    hhmm: string;
-    timezone?: string;
-} | {
-    kind: "weekly";
-    day: number;
-    hhmm: string;
-    timezone?: string;
-};
-export declare const WEEKDAYS: readonly ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
-export declare function validTimezone(value: string): boolean;
-/** Bounds a person would pick on purpose: 5 minutes to 7 days. */
-export declare const MIN_EVERY_MINUTES = 5;
-export declare const MAX_EVERY_MINUTES: number;
-/**
- * Existing daily schedules remain UTC. Calendar schedules may name an IANA
- * timezone, whose wall-clock time stays fixed across daylight saving changes.
- * No cron expressions in v1 — a schedule the operator cannot read at a
- * glance is a schedule they cannot honestly approve.
- */
-export declare function parseSchedule(text: string): Schedule | null;
-export declare function scheduleText(schedule: Schedule): string;
-/** The schedule, in words an operator agrees to. */
-export declare function describeSchedule(schedule: Schedule): string;
-/**
- * The first occurrence after approval: the schedule starts counting from the
- * yes, because "approved at 14:07, every 60 minutes" firing instantly would
- * spend before the approver's hand left the keyboard.
- */
-export declare function firstFireAt(schedule: Schedule, now: Date): string;
-/**
- * Aligned advancement: the smallest cadence occurrence STRICTLY after now.
- * `anchor` is the occurrence that just fired (or was just skipped) — the
- * cadence grid grows from it, so a pass that ran late does not tilt every
- * later firing by its lateness.
- */
-export declare function nextFireAt(schedule: Schedule, anchorIso: string, now: Date): string;
-/** The rolling window a standing order's cost ceiling counts over: seven days, and every surface says so. */
-export declare const BUDGET_WINDOW_MS: number;
-/** A firing's task id: the order's stem stamped with its slot (`nightly-deps-20261008-0700`). */
-export declare function instanceId(stem: string, slotIso: string): string;
-/**
- * The exact standing order an approver agreed to, as 128 bits — byte for byte what a routine's digest was, so a
- * routine's approval moved onto a scheduled flow (v115) still verifies: the project, the terms, the schedule, the
- * ceiling, and the agents the approval froze. Editing any of them (or moving the flow) strands the approval.
- */
-export declare function standingDigestOf(repo: string, schedule: string, order: StandingOrder, acceptance: readonly AcceptanceCriterion[], profile: ExecutionProfile, route: PhaseRoute): string;
-export type StandingApproval = {
-    live: true;
-    by: string | null;
-    profile: ExecutionProfile;
-    route: PhaseRoute;
-    acceptance: AcceptanceCriterion[];
-} | {
-    live: false;
-    problem: string | null;
-    acceptance: AcceptanceCriterion[] | null;
-};
-/**
- * Whether a standing order's carried approval still stands, read whole before anything is written: the frozen agents
- * read back, re-hash with the order's terms, this schedule and project to the digest the approver signed, state no
- * problem, and build and repair on the approved profile's own agents. `problem` is null when there is no approval.
- */
-export declare function standingApproval(order: StandingOrder, repo: string, schedule: string): StandingApproval;
-export type StandingFiring = {
-    made: "filed";
-    taskId: string;
-    approved: boolean;
-    note: string | null;
-} | {
-    made: "skipped";
-    note: string;
-};
-/** A firing that must not stand: thrown inside the transaction so nothing it wrote survives. */
-export declare class StandingOrderRefused extends Error {
-}
-/**
- * File one firing of a standing order (v115, what firing a routine did), inside the caller's transaction. It skips,
- * saying why, while the last task is unfinished or the rolling 7-day ceiling is reached (an unmeasured paid run fails
- * closed). Otherwise it files the order's terms unchanged: approved by the carried approval when that still verifies
- * — on exactly the agents it froze, sealed like any automatic approval under the project's rules — or else as an
- * ordinary proposal that waits for the project's approval rules like any other.
- */
-export declare function fileStandingOrder(store: Store, input: {
-    flowId: number;
-    repo: string;
-    trigger: number;
-    schedule: string;
-    order: StandingOrder;
-    title: string;
-    slot: string;
-}, now: Date): StandingFiring;
-/** A standing order in the words a person reads before turning its schedule on. */
-export declare function describeStandingOrder(order: StandingOrder, repo: string, schedule: string): string[];
-/** The terms a person sets a standing order up with (a template's, a recipe's): what each firing files. */
-export type StandingTerms = {
-    goal: string;
-    outOfScope: string | null;
-    touches: string[];
-    requirements: string[];
-    acceptance: readonly AcceptanceCriterion[];
-    budgetPerRunMicrousd: number | null;
-    costCeilingUsd: number | null;
-};
-/** Every problem with a standing order's terms and schedule at once, as `field: problem` lines (none when it can be set up). */
-export declare function standingTermsProblems(terms: StandingTerms, schedule: string): string[];
-export type ScheduledFlowMade = {
-    ok: true;
-    flow: number;
-    trigger: number;
-} | {
-    ok: false;
-    message: string;
-};
-/**
- * A scheduled flow a person set up (a template or a recipe; v115, what filing a routine was): a Build step that follows
- * the task each firing files, then Done, and a schedule trigger carrying the terms as its standing order — with no
- * approval, so each firing waits for approval under the project's rules. The schedule starts PAUSED with no time:
- * nothing repeats until a person turns it on, and it starts counting then. Its tasks are filed as `filedBy`'s (default
- * `by`; null files them as automation's). Inside the caller's transaction, if any.
- */
-export declare function createScheduledFlow(store: Store, input: {
-    repo: string;
-    name: string;
-    stem: string;
-    schedule: string;
-    terms: StandingTerms;
-    by: string;
-    filedBy?: string | null;
-}, now: Date): ScheduledFlowMade;

package/dist/flow-scripts.d.ts

@@ -1,31 +0,0 @@
-import { type ScriptLanguage } from "./flows.js";
-import type { Store } from "./store.js";
-export type ScriptDraft = {
-    name: string;
-    about: string;
-    body: string;
-    timeoutMinutes: number;
-    language: ScriptLanguage;
-    file: string | null;
-};
-/** A script as it would be saved, checked in plain words. Throws. */
-export declare function validateScript(input: {
-    name?: unknown;
-    about?: unknown;
-    body?: unknown;
-    timeoutMinutes?: unknown;
-    language?: unknown;
-    file?: unknown;
-}): ScriptDraft;
-/** What a run is held to. A shell script written here keeps its v84 digest. */
-export declare const scriptDigest: (draft: Pick<ScriptDraft, "body" | "timeoutMinutes"> & Partial<Pick<ScriptDraft, "language" | "file">>) => string;
-export type ScriptSaved = {
-    ok: true;
-    said: string;
-    version: number;
-} | {
-    ok: false;
-    message: string;
-};
-/** Save a script (a new version when it exists). */
-export declare function saveScript(store: Store, repo: string, input: Parameters<typeof validateScript>[0], actor: string, now: Date): ScriptSaved;

package/dist/flow-secrets.d.ts

@@ -1,13 +0,0 @@
-export declare const SECRET_NAME: RegExp;
-/** Any saved secret's value that shows up in output, replaced (a web response, a tool's answer, a script's output). */
-export declare const scrubSecrets: (text: string, secrets: Record<string, string>) => string;
-export declare function readFlowSecrets(dir: string | null, repo: string): Record<string, string>;
-export declare function flowSecretNames(dir: string | null, repo: string): string[];
-/** Set (or, with an empty value, remove) one of a project's secrets. Names are CAPITALS_AND_UNDERSCORES. */
-export declare function setFlowSecret(dir: string, repo: string, name: string, value: string): {
-    ok: true;
-    said: string;
-} | {
-    ok: false;
-    message: string;
-};

package/dist/flow-send.d.ts

@@ -1,54 +0,0 @@
-import { type FlowDecision } from "./flow-engine.js";
-import { type FlowChoiceAnswer, type FlowSendContent, type FlowSendLink } from "./contracts/flow-send.js";
-import { type FlowDefinition, type FlowStage } from "./flows.js";
-import { type FlowCardRow, type FlowRow, type Store } from "./store.js";
-/** The notice a "Send to me" visit sends: `flow-send:<card>:<entry>`. */
-export declare const FLOW_SEND_KEY: RegExp;
-/** The notice a "Person chooses" visit sends: `flow-choose:<card>:<entry>`, a "flow-decision" like an approval's. */
-export declare const FLOW_CHOOSE_KEY: RegExp;
-/** What the person is asked under the buttons. */
-export declare const REPLY_ASK = "Or reply with what you'd change.";
-/** A visit's content and its links (src/contracts/flow-send.ts). */
-export type { FlowSendContent, FlowSendLink };
-/** Who a card's "Send to me" and "Person chooses" zones are for: its owner, else the flow's. */
-export declare function flowPersonOf(card: Pick<FlowCardRow, "owner">, flow: Pick<FlowRow, "owner">): string;
-/** What a visit sends its person, worked out from the card as it is now. */
-export declare function flowSendContent(store: Store, flow: FlowRow, definition: FlowDefinition, stage: FlowStage, card: FlowCardRow, now: Date, evidenceRoot?: string): FlowSendContent;
-/** A kept content, read back (src/contracts/flow-send.ts: one kept before it carried a version reads as it did); null
- * when it can't be, and the visit's content is worked out again. */
-export declare function readFlowSend(json: string): FlowSendContent | null;
-/** The words of a sent visit: its title, summary and pull request (the one link that isn't a page of Toolroll's). */
-export declare function flowSendText(content: FlowSendContent): string;
-/** The links a sent visit's message carries as buttons: Toolroll's own pages, the first one first. */
-export declare function flowSendPaths(content: FlowSendContent): {
-    label: string;
-    path: string;
-}[];
-/** A "Send to me" visit: what the step before produced, to the person once; the card moves on after. */
-export declare function sendStep(store: Store, flow: FlowRow, definition: FlowDefinition, stage: FlowStage, card: FlowCardRow, now: Date, evidenceRoot?: string): void;
-/** A "Person chooses" visit: the same content with the zone's options, to the person once; the card waits for their choice. */
-export declare function chooseStep(store: Store, flow: FlowRow, definition: FlowDefinition, stage: FlowStage, card: FlowCardRow, now: Date, evidenceRoot?: string): void;
-/** The words above a choice's buttons: what was done, then what to do. */
-export declare function flowChooseBody(content: FlowSendContent): string;
-/** What a sent visit's message ends with, after its summary (and items): its pull request, and for a choice what to do. */
-export declare function flowSendTail(content: FlowSendContent): string[];
-export type FlowChoiceVisit = {
-    card: FlowCardRow;
-    flow: FlowRow;
-    stage: FlowStage;
-    definition: FlowDefinition;
-    person: string;
-};
-/** The card, if it is still at that visit, waiting for its person's choice. */
-export declare function flowChoiceAt(store: Store, cardId: number, entry: number): FlowChoiceVisit | null;
-/**
- * A person's choice on a card waiting at a "Person chooses" zone: an option (by its place, and the words and zone they saw), or a
- * reply (`choice` null) that becomes the note for where replies go. `where` names the place it was made, for the card's
- * history and the ledger: "Telegram", "Slack", "the console".
- */
-export declare function chooseFlowCard(store: Store, input: FlowChoiceAnswer & {
-    actor: string;
-    where: string;
-    repos: readonly string[];
-    evidenceRoot?: string;
-}, now: Date): FlowDecision;

package/dist/flow-share.d.ts

@@ -1,78 +0,0 @@
-import { type FlowDefinition } from "./flows.js";
-import { FLOW_FILE_FORMAT, FLOW_FILE_VERSION, type FlowFile, type FlowFileParameter, type FlowFileScript } from "./contracts/flow.js";
-import type { FlowRow, Store } from "./store.js";
-export { FLOW_FILE_FORMAT, FLOW_FILE_VERSION };
-export type { FlowFile, FlowFileParameter, FlowFileScript };
-/** The largest flow file Toolroll reads or fetches. */
-export declare const FLOW_FILE_MAX_BYTES: number;
-export declare const FLOW_FILE_SUFFIX = ".toolroll-flow.json";
-export type FlowExported = {
-    file: FlowFile;
-    json: string;
-    fileName: string;
-    left: string[];
-};
-/** A flow as a file: its zones and paths, its triggers' settings and the scripts it runs, nothing of this installation's. */
-export declare function exportFlow(store: Store, flow: FlowRow, dir: string | null): FlowExported;
-/** A flow file refused: why, in plain words, each problem naming its path in the file (`zones[0].routes[0]: ...`). */
-export declare class FlowFileError extends Error {
-}
-/**
- * Read a flow file: its size, its JSON and format, then its one schema (flowFileSchema: every zone, trigger, script
- * and parameter, strict about unknown keys — `zones[0].routes[0]: unknown key 'to' (did you mean goesTo?)`), and a
- * newer version refused plainly. Then what the schema can't say: no keys in a trigger, ids and names used once, each
- * {{param.x}} declared, every script valid and the zones a flow. Throws FlowFileError in plain words.
- */
-export declare function parseFlowFile(text: string): FlowFile;
-/** --param k=v lines (or a form's fields) as values; refuses parameters the file doesn't ask for. */
-export declare function parameterValues(file: FlowFile, given: Record<string, string>): Record<string, string>;
-export declare function needWords(need: string): string;
-export type FlowImportPlan = {
-    name: string;
-    repo: string;
-    definition: FlowDefinition;
-    triggers: Record<string, unknown>[];
-    /** Scripts to add (held until approved), and those the project already has exactly. */
-    scripts: {
-        add: FlowFileScript[];
-        kept: string[];
-    };
-    values: Record<string, string>;
-    title: string;
-    /** The whole preview, line by line (the CLI's); `parts` is the same, grouped for the console's page. */
-    terms: string[];
-    parts: {
-        about: string | null;
-        steps: string[];
-        notes: string[];
-        triggers: string[];
-        scripts: string[];
-        kept: string[];
-        filled: string | null;
-        needs: string | null;
-    };
-};
-/** The import in plain words, checked against the project it lands in. Throws FlowFileError. */
-export declare function planFlowImport(store: Store, repo: string, file: FlowFile, given: Record<string, string>, actor: string): FlowImportPlan;
-/** Make the planned flow: scripts held, the flow, and its triggers switched off. One transaction. */
-export declare function importFlow(store: Store, plan: FlowImportPlan, actor: string, now: Date, dir: string | null): {
-    id: number;
-    said: string;
-};
-/** A gist or GitHub file page as the address of its raw text; null when it isn't one Toolroll fetches. */
-export declare function rawFlowUrl(address: string): string | null;
-export type FetchLike = (url: string, init: {
-    redirect: "follow";
-    signal: AbortSignal;
-    headers: Record<string, string>;
-}) => Promise<{
-    ok: boolean;
-    status: number;
-    url?: string;
-    headers: {
-        get(name: string): string | null;
-    };
-    body: ReadableStream<Uint8Array> | null;
-}>;
-/** A flow file from a gist or GitHub, over HTTPS only, refused past the size cap. Throws FlowFileError in plain words. */
-export declare function fetchFlowFile(address: string, fetcher?: FetchLike): Promise<string>;

package/dist/flow-sort.d.ts

@@ -1,63 +0,0 @@
-import { type SortDecision } from "./contracts/sort-answer.js";
-import type { FlowSort, FlowStage } from "./flows.js";
-export declare const JEV_URL = "https://openrouter.ai/api/alpha/decisions";
-export declare const JEV_MODEL = "~typesafe/jev-latest";
-export type { SortDecision, SortNoteAnswer } from "./contracts/sort-answer.js";
-export type SortCard = {
-    title: string;
-    description: string | null;
-    note: string | null;
-    outputs: Record<string, string>;
-    source: {
-        label: string;
-    } | null;
-};
-type Question = {
-    type: "choice";
-    instructions: string;
-    criteria: Record<string, string>;
-} | {
-    type: "score";
-    instructions: string;
-    criteria: string[];
-} | {
-    type: "noul";
-    instructions: string;
-};
-export type JevRequest = {
-    model: string;
-    state: Record<string, string>;
-    questions: Record<string, Question>;
-};
-/** What Jev reads: the card, where it came from, the latest note and what earlier zones reported — bounded, keys blanked. */
-export declare function sortState(card: SortCard, earlier: readonly {
-    id: string;
-    title: string;
-}[]): Record<string, string>;
-/** The one request for a card: the zone's question over its answers, plus what it also notes. */
-export declare function sortRequest(sort: FlowSort, state: Record<string, string>): JevRequest;
-export type JevAsked = {
-    ok: true;
-    body: Record<string, unknown>;
-    ms: number;
-} | {
-    ok: false;
-    said: string;
-};
-/** Ask Jev through OpenRouter. Trouble reaching it (or a refused key, or no credit) is a reason to try again, in words. */
-export declare function askJev(fetcher: typeof fetch, key: string, request: JevRequest): Promise<JevAsked>;
-/**
- * Jev's answers, read through the reply's contract (src/contracts/sort-answer.ts) and then against the zone's own
- * options only; anything else is a problem, never a route. Confidences and chances are clamped into 0–1.
- */
-export declare function readJevAnswers(stage: FlowStage, body: Record<string, unknown>, ms: number): SortDecision | {
-    problem: string;
-};
-/** The decision in one line, as the card and later zones read it ({{stage.<id>}}). */
-export declare function sortWords(decision: SortDecision): string;
-/** The run's log: every answer's chance and each note, for the Insights run view. */
-export declare function sortLog(stage: FlowStage, decision: SortDecision): string;
-/** A kept decision, or null when there is none or it can't be read. */
-export declare function parseSortDecision(json: string | null): SortDecision | null;
-/** A card's chip on the canvas: the answer and how sure, and the first score's short level. */
-export declare function sortChip(decision: SortDecision): string;

package/dist/flow-starters-ui.d.ts

@@ -1,15 +0,0 @@
-/**
- * Starter flows (New flow → Starter flows): a project's starter flows, each switched on with one yes. A row says what
- * it's for, what it will do and what it never does (the whole of what the yes agrees to), then one button. A starter
- * that's on links to its flow; one that can't run here says why.
- */
-import type { StarterView } from "./flow-starters.js";
-import { type Html } from "./html.js";
-export declare const STARTERS_CSS: string;
-export declare function startersHtml(input: {
-    repo: string;
-    projectName: string;
-    starters: readonly StarterView[];
-    canSwitch: boolean;
-    suggested: string | null;
-}): Html;

package/dist/flow-starters.d.ts

@@ -1,63 +0,0 @@
-import { type FlowStepInput } from "./flows.js";
-import type { TriggerInput } from "./contracts/flow.js";
-import type { FlowRow, Store } from "./store.js";
-export declare const STARTER_IDS: readonly ["ci-fix", "issue-task", "overnight", "plane-review"];
-export type StarterId = (typeof STARTER_IDS)[number];
-export type StarterFlow = {
-    id: StarterId;
-    /** The flow's name, and how the starter is called everywhere. */
-    name: string;
-    /** One line: what it's for. */
-    summary: string;
-    /** What switching it on does, in order. */
-    does: (where: {
-        github: string | null;
-        branch: string;
-        own: boolean;
-    }) => string[];
-    /** What it never does. */
-    never: string;
-    github: boolean;
-    steps: FlowStepInput[];
-    /** The steps in Toolroll's own repository, when they differ: there, every fix lands in Toolroll. */
-    ownSteps?: FlowStepInput[];
-    trigger: (where: {
-        branch: string;
-    }) => TriggerInput;
-};
-export declare const STARTER_FLOWS: readonly StarterFlow[];
-/** The morning plane review's steps: find the cause, fix it, open a pull request; any failure waits for a person. */
-export declare function planeReviewSteps(own: boolean): FlowStepInput[];
-/** Whether a project is Toolroll's own source. */
-export declare function isToolrollRepo(repo: string): boolean;
-export declare const starterOf: (id: string) => StarterFlow | null;
-/** The flow a starter made in a project, while it is on. */
-export declare function starterFlowOf(store: Store, starter: StarterFlow, repo: string): FlowRow | null;
-export type StarterView = {
-    id: StarterId;
-    name: string;
-    summary: string;
-    does: string[];
-    never: string;
-    on: {
-        flow: number;
-    } | null;
-    blocked: string | null;
-};
-/** Each starter for a project: what it does there, whether it's on, and why it can't be switched on when it can't. */
-export declare function startersFor(store: Store, repo: string): StarterView[];
-export type SwitchedOn = {
-    ok: true;
-    flow: number;
-    said: string;
-    already: boolean;
-} | {
-    ok: false;
-    said: string;
-};
-/** Switch a starter on in a project: its flow (zones) and its trigger, together or not at all. Once is enough. */
-export declare function switchOnStarter(store: Store, starter: StarterFlow, repo: string, by: string, now: Date, dir: string | null): SwitchedOn;
-/** The starter that would do a task's kind of work every time: fixing CI, an issue, or a queued job. */
-export declare function starterForWork(text: string): StarterFlow;
-/** What switching a starter on means, for a chat card's terms. */
-export declare function starterTerms(store: Store, starter: StarterFlow, repo: string): string[];

package/dist/flow-steps.d.ts

@@ -1,52 +0,0 @@
-import type { Runner } from "./backend.js";
-import { type DraftRunner } from "./flow-draft.js";
-import { type MailSender, type ToolCaller } from "./flow-actions.js";
-import type { FlowCardRow, FlowStepKind, Store } from "./store.js";
-import type { TurnRunner } from "./subagents.js";
-import type { ToolLister } from "./subagent-tools.js";
-export type StepIo = {
-    /** `gh` for GitHub; git and the check's shell, both without a model. */
-    gh: Runner;
-    git: Runner;
-    shell: Runner;
-    fetch: typeof fetch;
-    /** Beside the database: the Linear key. */
-    dir: string | null;
-    /** Where temporary copies of a card's work are made. */
-    scratch: string;
-    /** Whether this machine can confine a script (tests only; default: the macOS sandbox or bubblewrap is here). */
-    fenceAvailable?: () => boolean;
-    /** The home folder a launch is fenced around (tests only; default: this user's). */
-    home?: string;
-    evidenceRoot?: string;
-    /** The branch a card with no result yet is checked against. */
-    base: string;
-    /** The operator's OpenRouter key, for sort steps (default: the one stored in Settings → AI providers). */
-    openRouterKey?: () => string | null;
-    /** Writes a draft (default: Claude through this computer's sign-in, no tools). */
-    draft?: DraftRunner;
-    /** Sends an email (default: the mail server in Settings → Email). */
-    mail?: MailSender;
-    /** Calls a project tool (default: starts its MCP server, like its Test button). */
-    callTool?: ToolCaller;
-    /** Where the project tools' secrets live (default: this computer's home). */
-    toolHome?: string;
-    /** Takes a subagent's turn (default: Claude through this computer's sign-in, answering in its fixed shape). */
-    subagent?: TurnRunner;
-    /** Lists what a project tool offers a subagent (default: starts its MCP server and asks). */
-    listTools?: ToolLister;
-};
-export type StepPass = {
-    ran: number;
-    problems: string[];
-};
-/** Run every due check and update in one project, then move each card on. */
-export declare function runFlowSteps(store: Store, repo: string, now: Date, io: StepIo): Promise<StepPass>;
-/** Claim this card's visit to its step zone, only while the card is still there on that visit: a pass that read the card
- * before another pass (or a person) moved it never runs the step for a visit that's over. */
-export declare function claimStep(store: Store, card: FlowCardRow, step: {
-    stage: string;
-    kind: FlowStepKind;
-    script: string | null;
-    scriptVersion: number | null;
-}, now: Date): boolean;