toolroll 0.9.103 → 0.9.105

package/dist/first-run.d.ts

@@ -1,197 +0,0 @@
-import type { Runner } from "./backend.js";
-export declare const SIGN_IN_COMMAND = "claude auth login";
-export declare const SANDBOX_COMMAND = "npx toolroll demo";
-/** How a person starts on a real project (the demo hands off to this). */
-export declare const START_COMMAND = "npx toolroll up";
-/** How it works, once, above the composer until the first request. */
-export declare const HOW_IT_WORKS = "Ask for a change. The lead writes a short plan; you approve it; an agent builds it on its own branch; it's Ready when your tests pass.";
-type SignInState = "connected" | "signed-out" | "not-installed" | "unverified" | "key-present" | "key-works" | "key-refused" | "missing-key";
-/**
- * The one command that gets an agent signed in on this computer: sign in to the CLI that's installed (Claude Code
- * first, then Codex), or install Claude Code and sign in, written for this operating system's shell. Unknown states
- * (not checked yet) get the install-and-sign-in command, which is right on a fresh machine and harmless otherwise.
- */
-export declare function signInCommandFor(states: {
-    claude: SignInState;
-    codex: SignInState;
-} | null, platform: NodeJS.Platform): string;
-export type FirstRunAction = {
-    kind: "link";
-    label: string;
-    href: string;
-} | {
-    kind: "command";
-    command: string;
-};
-/** `checking`: the answer is not in yet, so the step is shown neither done nor to do. */
-export type FirstRunStep = {
-    key: "agent" | "project" | "builder" | "task";
-    title: string;
-    done: boolean;
-    action: FirstRunAction | null;
-    checking?: true;
-};
-/** agentSignedIn is null until this machine's first sign-in check has answered. */
-export type FirstRunFacts = {
-    agentSignedIn: boolean | null;
-    projects: number;
-    hasTask: boolean;
-    firstResultAt: string | null;
-    signInCommand?: string;
-};
-/** The steps (the builder step is added by withBuilderStep), each done or with the one action that does it; null once the first result has arrived. */
-export declare function firstRunSteps(facts: FirstRunFacts): FirstRunStep[] | null;
-/** The builder step, before the first task: under `toolroll serve` nothing connects a builder, and a task filed then
- * waits forever, so the steps never all read done without one. It leads to Start a builder, which shows the command. */
-export declare function withBuilderStep(steps: FirstRunStep[] | null, connected: boolean): FirstRunStep[] | null;
-export type OpenIssue = {
-    number: number;
-    title: string;
-};
-export type TodoComment = {
-    file: string;
-    line: number;
-    text: string;
-};
-export type FirstTaskSuggestion = {
-    source: "issue" | "todo" | "generic";
-    label: string;
-    draft: string;
-};
-export declare const GENERIC_FIRST_TASKS: readonly FirstTaskSuggestion[];
-/** Issue titles and TODO text are written by anyone: keep only what a person can see, so the draft they send is the
- * draft the lead reads (no control, format, zero-width, bidi, tag or variation-selector characters). */
-export declare const visibleText: (text: string) => string;
-/** Three first tasks: open GitHub issues first, then TODO or FIXME comments, then safe generic ones. */
-export declare function firstTaskSuggestions(found: {
-    issues: readonly OpenIssue[];
-    todos: readonly TodoComment[];
-}): FirstTaskSuggestion[];
-/** `git grep -z -n` records ("file\0line\0text\n") to TODO or FIXME notes, one per file. NUL-separated so a
- * file name with a colon or a newline in it is still one file name. */
-export declare function parseTodoLines(stdout: string, limit?: number): TodoComment[];
-/** The TODO search: no colour and no column whatever the person's git config says, NUL after each file name. */
-export declare const TODO_GREP_ARGS: readonly string[];
-/** Read the project's own sources for suggestions: its open issues through the `gh` login, then its TODO comments. Failures fall through quietly. */
-export declare function findFirstTasks(repo: string, runner?: Runner): Promise<FirstTaskSuggestion[]>;
-/** "First result in 7 min": how long after the installation began its first Ready result arrived. */
-export declare function firstResultWords(since: string, at: string): string | null;
-/** A task's five steps, as a person reads them: the one label set the task page's rows, chat's first-task journey and
- * the progress line all read. */
-export declare const JOURNEY_STEPS: readonly [readonly ["plan", "Plan"], readonly ["approve", "Approval"], readonly ["build", "Build"], readonly ["checks", "Checks"], readonly ["ready", "Ready"]];
-export type JourneyKey = (typeof JOURNEY_STEPS)[number][0];
-/** `stuck`: the step it stopped at (Failed, Stopped, or waiting on something other than the approval). */
-/** `skipped`: a stage the task went past without it happening (its checks didn't run or couldn't be read). `needsYou`:
- * the current or stuck step waits on a person, so it is the one step drawn in the needs-you ink. */
-/** `say`: what the step's state means when its label alone doesn't say it ("Checks failed", "Checks not run"); the
- * label is always the step's own name from JOURNEY_STEPS. */
-export type JourneyStep = {
-    key: JourneyKey;
-    label: string;
-    state: "done" | "current" | "stuck" | "skipped" | "todo";
-    needsYou?: true;
-    say?: string;
-};
-/**
- * Where the first task stands on Plan → Approval → Build → Checks → Ready, from the one stage every surface reads
- * (task-status.ts). Waiting for a worker before approval is still the plan; after approval it is the build. `built`:
- * the build finished with a result.
- */
-export declare function firstTaskJourney(read: {
-    stage: "queued" | "planning" | "needs-you" | "waiting" | "building" | "checking" | "reviewing" | "finished" | "complete" | "failed" | "stopped";
-    need?: string | undefined;
-}, approved: boolean, built?: boolean): JourneyStep[];
-/** The approved check as the task's status reads it (task-status.ts `approvedCheckStateOf`), for its road: `null` when
- * nothing says (the step is then shown skipped, never done). The road reads this one answer, never a row's words. */
-export type RoadChecks = "passed" | "running" | "failed" | "not-run" | "off" | "unreadable" | null;
-/**
- * Any task's road (the step rows on its page): the first task's five steps, told only
- * from recorded facts. Approval is done only when the plan was approved (a rewritten plan waiting on approval
- * stands there again); a task that never needed one shows it skipped. Checks is done only when the approved check
- * passed; a running, missing or Off check says so, and with no checks fact it is skipped. A failed check, or one that
- * can't be read, stops the road at Checks: Ready isn't done (fail closed), even on a task a person marked complete.
- * A research report has no Checks step: a report stopped there stops at
- * Ready. The step that waits on a person carries `needsYou`.
- */
-export declare function taskRoad(read: Parameters<typeof firstTaskJourney>[0], approved: boolean, built: boolean, facts: {
-    report?: boolean;
-    checks?: RoadChecks;
-}): JourneyStep[];
-/** The agents setup offers: the two whose sign-in check, readiness and chat are supported end to end. */
-export type WelcomeAgentId = "claude" | "codex";
-export declare const WELCOME_AGENTS: readonly {
-    id: WelcomeAgentId;
-    name: string;
-    signIn: string;
-    install: string;
-}[];
-/** The sample project's folder name under the project folder. */
-export declare const SAMPLE_PROJECT_NAME = "toolroll-sample";
-export type WelcomeAgentState = "signed-in" | "signed-out" | "not-installed" | "checking";
-export type WelcomeAgent = {
-    id: WelcomeAgentId;
-    name: string;
-    state: WelcomeAgentState;
-    /** The exact command that signs it in on this computer (installing it first when it isn't there); null once signed in or while checking. */
-    command: string | null;
-    inUse: boolean;
-    /** "Use this one" can choose it: signed in with an account, not already in use, and this person may choose. */
-    canUse: boolean;
-};
-export type WelcomeStarter = {
-    label: string;
-    draft: string;
-    href: string;
-};
-export type WelcomeModel = {
-    agent: {
-        done: boolean;
-        checking: boolean;
-        agents: WelcomeAgent[];
-        inUse: WelcomeAgentId | null;
-        /** Tasks are built with another agent than the one in use (Settings → Models decides): say so, with where to change it. */
-        buildsWith: string | null;
-    };
-    project: {
-        done: boolean;
-        projects: {
-            name: string;
-            path: string;
-        }[];
-        /** Where "Try a sample project" puts it; null when there is no project folder or it is already added. */
-        sample: string | null;
-        /** A project is added but nothing on this computer takes its tasks yet. */
-        notTakingWork: boolean;
-    };
-    task: {
-        done: boolean;
-        open: boolean;
-        starters: WelcomeStarter[];
-    };
-    /** The step the screen's one primary belongs to, or null when nothing is left that a page can do. */
-    next: "agent" | "project" | "task" | null;
-    left: number;
-};
-export type WelcomeFacts = {
-    /** Each agent's last sign-in check on this computer; null until one has answered. */
-    agents: Record<WelcomeAgentId, SignInState | null>;
-    inUse: WelcomeAgentId | null;
-    /** The provider routine builds run on now (claude by default). */
-    buildsOn: string | null;
-    canChoose: boolean;
-    projects: readonly {
-        name: string;
-        path: string;
-    }[];
-    /** The folder new projects go in; null when this console has none. */
-    projectRoot: string | null;
-    ready: boolean;
-    hasTask: boolean;
-    starters: readonly FirstTaskSuggestion[];
-    platform: NodeJS.Platform;
-};
-/** The welcome's three steps (Agent · Project · First task) from live facts, the same for every screen that shows them. */
-export declare function welcomeModel(facts: WelcomeFacts): WelcomeModel;
-/** First tasks for the sample project: the changes its README suggests. */
-export declare const SAMPLE_FIRST_TASKS: readonly FirstTaskSuggestion[];
-export {};

package/dist/first-tasks-child.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/flaky-ci.d.ts

@@ -1,31 +0,0 @@
-import { type GhRead } from "./nightly-github.js";
-import type { Store } from "./store.js";
-/** How often a project is read at most. */
-export declare const CI_READ_EVERY_MS: number;
-/** The service cursor a project's reads keep (a cursor key can't hold a path). */
-export declare const ciCursorKey: (repo: string) => string;
-/** The GitHub repositories this project's records name: the nightly's opt-in and its failed-checks triggers. */
-export declare function ciRepositoriesOf(store: Store, repo: string): string[];
-export type CiPassResult = {
-    read: number;
-    observed: number;
-    rejected: number;
-};
-/** Pair one run's attempts n-1 and n. A pair already decided isn't read again. */
-export declare function observeCiRun(store: Store, input: {
-    repo: string;
-    slug: string;
-    run: number;
-    sha: string | null;
-    gh: GhRead;
-    now: Date;
-}): Promise<{
-    observed: number;
-    rejected: number;
-}>;
-/** One project's pass over its known runs. A read that fails records nothing and is tried on the next pass. */
-export declare function observeCiAttempts(store: Store, repo: string, gh: GhRead, now: Date): Promise<CiPassResult>;
-/** The storage sweep's own step: CI rows older than the retention window go; nothing else deletes them. */
-export declare function pruneCiObservations(store: Store, now: Date): number;
-/** Pairings refused since `since` for these repositories. */
-export declare function ciNotPaired(store: Store, repositories: readonly string[], since: string): number;

package/dist/flaky-cli.d.ts

@@ -1,60 +0,0 @@
-import { type FlakyList, type FlakyRow } from "./flaky.js";
-import type { Store } from "./store.js";
-export declare const FLAKY_DESCRIPTORS: readonly [{
-    readonly action: "list";
-    readonly synopsis: "tests with mixed outcomes under recorded conditions (read only)";
-    readonly mutation: "none";
-    readonly takesQuery: false;
-    readonly flags: readonly [{
-        readonly name: "repo";
-        readonly takesValue: true;
-        readonly meaning: "admitted project checkout root";
-    }, {
-        readonly name: "days";
-        readonly takesValue: true;
-        readonly meaning: "how far back to look (default 90)";
-    }, {
-        readonly name: "json";
-        readonly takesValue: false;
-        readonly meaning: "versioned structured response";
-    }, {
-        readonly name: "db";
-        readonly takesValue: true;
-        readonly meaning: "local Toolroll database";
-    }];
-}, {
-    readonly action: "show";
-    readonly synopsis: "one row's history, and the task that would fix it: flaky show <identity> (read only)";
-    readonly mutation: "none";
-    readonly takesQuery: true;
-    readonly flags: readonly [{
-        readonly name: "repo";
-        readonly takesValue: true;
-        readonly meaning: "admitted project checkout root";
-    }, {
-        readonly name: "days";
-        readonly takesValue: true;
-        readonly meaning: "how far back to look (default 90)";
-    }, {
-        readonly name: "json";
-        readonly takesValue: false;
-        readonly meaning: "versioned structured response";
-    }, {
-        readonly name: "db";
-        readonly takesValue: true;
-        readonly meaning: "local Toolroll database";
-    }];
-}];
-export type FlakyCliContext = {
-    store: Store;
-    write: (line: string) => void;
-    json: boolean;
-    now: Date;
-    actor: string | null;
-    repos: readonly string[];
-};
-/** A row's one line of status, the same words the page says. */
-export declare function flakyStatusWords(row: FlakyRow): string;
-/** How much of the window had per-test reporting, said plainly. */
-export declare function flakyCoverageWords(list: FlakyList): string;
-export declare function runFlakyCommand(positional: readonly string[], options: Map<string, string | true>, context: FlakyCliContext): number;

package/dist/flaky.d.ts

@@ -1,83 +0,0 @@
-import type { Store } from "./store.js";
-/** Track an identity a local observation named (one row per observation; first write wins, never rewritten). */
-export declare function watchObservation(store: Store, input: {
-    repo: string;
-    identity: string;
-    observation: number;
-    now: Date;
-}): boolean;
-/** How far back the list looks, how long the pruned rows are kept, and how many runs clear a row (the plan's defaults). */
-export declare const FLAKY_WINDOW_DAYS = 90;
-export declare const FLAKY_RETAIN_DAYS = 180;
-export declare const FLAKY_CLEAR_RUNS = 20;
-/** What can be observed at all: a test case, a journey or its group, or a file, never `part:`, `upgrade:`, `check` or
- * `unexplained`, and never a real-model journey (a model's behaviour isn't a test's flakiness). */
-export declare function observableIdentity(identity: string): boolean;
-/**
- * Every observation one settled check adds, in the transaction that records its results (check-facts.ts): an in-check
- * retry, and each identity that failed in one check and explicitly passed in another with equal tree, command, access,
- * harness and conditions. A `file:` identity is observed only as "failed, then the whole check passed", and only when
- * no case in that file names the failure. Idempotent: racing dispositions on one pair leave one row.
- */
-export declare function recordObservations(store: Store, runId: number, now: Date): number[];
-/** The storage sweep's own step: observations older than the retention window go; nothing else deletes them. */
-export declare function pruneObservations(store: Store, now: Date): number;
-export type FlakyStatus = "mixed outcomes" | "no failures since its file changed" | "not enough recorded history";
-export type FlakyRow = {
-    /** The stable handle `flaky show` takes: the identity, or `github:<lane>`. */
-    key: string;
-    kind: "test" | "file" | "lane";
-    /** What the row says, as recorded: untrusted test text, escaped wherever it's shown. */
-    name: string;
-    observations: number;
-    lastSeen: string;
-    /** `<platform>-<arch>-node<major>`, or GitHub for a lane. */
-    conditions: string[];
-    /** Failures under recorded conditions that have no recorded pass. */
-    hardFailures: number;
-    sources: string[];
-    /** When the test's file last changed, as far as the recorded checks show; null when they don't. */
-    fileChanged: string | null;
-    status: FlakyStatus;
-};
-export type FlakyList = {
-    repo: string;
-    days: number;
-    rows: FlakyRow[];
-    /** False when the window reaches past what is kept, so a count there could be short. */
-    complete: boolean;
-    /** CI pairings refused, and how many checks in the window had no per-test reporting. */
-    notPaired: number;
-    unreported: number;
-    reported: number;
-};
-export type FlakyObservation = {
-    kind: "regate" | "same-tree" | "in-check-retry" | "github";
-    at: string;
-    failed: string;
-    passed: string;
-    commit: string | null;
-    conditions: string;
-};
-/** The test file an identity names, when it names one. */
-export declare function identityFile(identity: string): string | null;
-/** A readable name: `<file> › <test>`; a journey's group and name; a file with its limit said. */
-export declare function identityWords(identity: string): string;
-/** Every row for a project: reads only. `days` past the kept window is answered with `complete: false`, never a zero. */
-export declare function flakyList(store: Store, repo: string, now: Date, days?: number): FlakyList;
-/** How many rows the list has now, cheaply: no tree is read. */
-export declare function flakyCount(store: Store, repo: string, now: Date): number;
-/** One row's history, newest first: each observation with both checks (or the CI run and attempts). Null: no such row. */
-export declare function flakyShow(store: Store, repo: string, key: string, now: Date, days?: number): {
-    row: FlakyRow;
-    history: FlakyObservation[];
-    fix: {
-        title: string;
-        goal: string;
-    };
-} | null;
-/** The ordinary task "Make a task to fix it" files; a person approves it as usual. Never to skip or delete the test. */
-export declare function fixTaskOf(row: Pick<FlakyRow, "key" | "name" | "observations" | "conditions" | "kind">): {
-    title: string;
-    goal: string;
-};

package/dist/fleet-schema.d.ts

@@ -1,17 +0,0 @@
-/**
- * The tables behind what happens to a result after its agent finishes (docs/plans/fleet-follow-through.md). v155 adds
- * them and changes no saved row, so the updater's history check needs no rule for it.
- *
- * Every reader of these tables goes through `readingFleet`: a deploy reads with the candidate's code over the installed
- * runtime's file before this version's migration has run (as buildReviewOf does), and a missing table is simply nothing
- * to show. Writers run only in a process whose Store opened, and so migrated, the file.
- */
-/** Who a finding's words are from. 'lead' (the lead drafted, a person confirmed) came after the first v155 builds, which
- * this build's v155 step widens in place (store.ts widenFindingSources). */
-export declare const FINDING_SOURCES = "CHECK (source IN ('build-review', 'person', 'lead', 'check-failure'))";
-export declare const FINDING_SOURCES_BEFORE_LEAD = "CHECK (source IN ('build-review', 'person', 'check-failure'))";
-export declare const V155_SCHEMA = "\n-- A finding sent to the task that owns the code. It belongs to the task family, so a revision or repair inherits it.\n-- summary, action and excerpt can hold model output or repository text: they are data everywhere they are read.\nCREATE TABLE IF NOT EXISTS finding (\n  id            INTEGER PRIMARY KEY AUTOINCREMENT,\n  family_root   TEXT NOT NULL,\n  task_id       TEXT NOT NULL,\n  repo          TEXT,\n  source        TEXT NOT NULL CHECK (source IN ('build-review', 'person', 'lead', 'check-failure')),\n  source_key    TEXT UNIQUE,\n  source_run    INTEGER,\n  severity      TEXT CHECK (severity IS NULL OR severity IN ('HIGH', 'MEDIUM', 'LOW')),\n  file          TEXT,\n  line          INTEGER,\n  summary       TEXT NOT NULL,\n  action        TEXT NOT NULL,\n  excerpt       TEXT,\n  revision      TEXT,\n  state         TEXT NOT NULL DEFAULT 'open' CHECK (state IN ('open', 'accepted', 'rejected', 'with-person', 'closed')),\n  rounds        INTEGER NOT NULL DEFAULT 1,\n  sent_by       TEXT NOT NULL,\n  sent_at       TEXT NOT NULL,\n  delivered_run INTEGER,\n  delivered_how TEXT CHECK (delivered_how IS NULL OR delivered_how IN ('mailbox', 'brief')),\n  delivered_at  TEXT,\n  read_at       TEXT,\n  closed_by     TEXT,\n  closed_note   TEXT,\n  closed_at     TEXT\n);\nCREATE INDEX IF NOT EXISTS finding_family ON finding (family_root, state);\n-- What the owner answered. 'saved' until the attempt that wrote it settles: then 'counted', or 'refused' with the reason\n-- (an accepted answer on a run that changed nothing; a rejection that names no file in the code).\nCREATE TABLE IF NOT EXISTS finding_answer (\n  id        INTEGER PRIMARY KEY AUTOINCREMENT,\n  finding   INTEGER NOT NULL REFERENCES finding(id) ON DELETE CASCADE,\n  round     INTEGER NOT NULL,\n  run       INTEGER NOT NULL,\n  answer    TEXT NOT NULL CHECK (answer IN ('accepted', 'rejected')),\n  detail    TEXT NOT NULL,\n  file      TEXT,\n  line      INTEGER,\n  revision  TEXT,\n  state     TEXT NOT NULL DEFAULT 'saved' CHECK (state IN ('saved', 'counted', 'refused')),\n  problem   TEXT,\n  at        TEXT NOT NULL,\n  UNIQUE (finding, round, run)\n);\n-- One failed check on one revision of one task family: the UNIQUE key is what stops a second repair of the same failure.\n-- attempt is the repair ledger's (repair_chain) attempt this row drafted, when it drafted one.\nCREATE TABLE IF NOT EXISTS check_repair (\n  id           INTEGER PRIMARY KEY AUTOINCREMENT,\n  family_root  TEXT NOT NULL,\n  owner_task   TEXT NOT NULL,\n  repo         TEXT NOT NULL,\n  revision     TEXT NOT NULL,\n  failure_key  TEXT NOT NULL,\n  source_run   INTEGER NOT NULL,\n  state        TEXT NOT NULL CHECK (state IN ('waiting', 'repairing', 'rerunning', 'with-person', 'parked', 'fixed', 'closed')),\n  why          TEXT NOT NULL,\n  repair_task  TEXT,\n  attempt      INTEGER,\n  created_at   TEXT NOT NULL,\n  updated_at   TEXT NOT NULL,\n  UNIQUE (family_root, revision, failure_key)\n);\nCREATE INDEX IF NOT EXISTS check_repair_state ON check_repair (repo, state);\n-- A failing result saved before a change. The after side is never stored: it is read from the task's latest results,\n-- so a newer commit reads as out of date on its own.\nCREATE TABLE IF NOT EXISTS evidence_pair (\n  id             INTEGER PRIMARY KEY AUTOINCREMENT,\n  family_root    TEXT NOT NULL,\n  repo           TEXT,\n  before_run     INTEGER NOT NULL,\n  before_head    TEXT NOT NULL,\n  receipt_digest TEXT NOT NULL,\n  command_digest TEXT,\n  saved_by       TEXT NOT NULL,\n  saved_at       TEXT NOT NULL,\n  UNIQUE (family_root, before_run)\n);\n-- A bug fix's optional failing test first: asked for on the family; the agent's report beside it, shown as its own report.\nCREATE TABLE IF NOT EXISTS failing_first (\n  family_root TEXT PRIMARY KEY,\n  repo        TEXT,\n  asked_by    TEXT NOT NULL,\n  asked_at    TEXT NOT NULL,\n  report_run  INTEGER,\n  test        TEXT,\n  output      TEXT,\n  reported_at TEXT\n);\n-- What a provider said when an attempt failed, kept as data for a person. Nothing reads it to route work.\nCREATE TABLE IF NOT EXISTS provider_capture (\n  id          INTEGER PRIMARY KEY AUTOINCREMENT,\n  run         INTEGER NOT NULL UNIQUE,\n  repo        TEXT,\n  provider    TEXT NOT NULL,\n  model       TEXT,\n  auth_mode   TEXT,\n  exit_code   INTEGER,\n  code        TEXT,\n  text        TEXT NOT NULL,\n  hint        INTEGER NOT NULL DEFAULT 0 CHECK (hint IN (0, 1)),\n  label       TEXT CHECK (label IS NULL OR label IN ('exhausted', 'not-exhausted')),\n  labelled_by TEXT,\n  at          TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS provider_capture_provider ON provider_capture (provider, id);\n";
-export declare const V155_TABLES: readonly ["finding", "finding_answer", "check_repair", "evidence_pair", "failing_first", "provider_capture"];
-export declare const V155_STEPS: readonly ["follow-through-tables", "finding-sources"];
-/** One read, or `fallback` when the file predates v155. Any other error is real and goes on. */
-export declare function readingFleet<T>(read: () => T, fallback: T): T;

package/dist/flow-actions.d.ts

@@ -1,79 +0,0 @@
-import { type FlowStage } from "./flows.js";
-import { type EmailSettings } from "./email-settings.js";
-export { readEmailSettings, saveEmailSettings, type EmailSettings } from "./email-settings.js";
-import { type ToolCall, type ToolSpec } from "./project-tools.js";
-import type { FlowCardRow, Store } from "./store.js";
-/** `output` is the answer whole: the step passes it on whole up to TEXT_LIMITS.stageOutput, and attaches longer to the card, linked (flow-steps settle). */
-export type ActionOutcome = {
-    state: "passed" | "failed" | "retry";
-    said: string;
-    log?: string;
-    output?: string;
-    /** email (v91): the Message-ID it went out with, and to whom, so a reply finds the card. */
-    mail?: {
-        id: string;
-        to: string[];
-    };
-};
-export { flowSecretNames, readFlowSecrets, scrubSecrets, SECRET_NAME, setFlowSecret } from "./flow-secrets.js";
-export type Fetcher = typeof fetch;
-export declare function runRequest(stage: FlowStage, card: FlowCardRow, repo: string, io: {
-    fetch: Fetcher;
-    dir: string | null;
-}): Promise<ActionOutcome>;
-/** The operator's mail server: everything but the password is shown back. */
-/** Whether Send email steps can send: a connected Google account or a mail server. */
-export declare function sendingReady(dir: string | null): boolean;
-/** The account Send email steps send from, signed in: Google when connected, else the mail server. */
-export declare function sendingAccount(dir: string | null, fetcher: typeof fetch): Promise<{
-    ok: true;
-    settings: EmailSettings & {
-        password: string;
-        accessToken?: string;
-    };
-} | {
-    ok: false;
-    said: string;
-    permanent: boolean;
-}>;
-/** `inReplyTo` and `references` keep a reply in the thread of the email a card came from. */
-export type Mail = {
-    from: string;
-    to: string[];
-    subject: string;
-    text: string;
-    inReplyTo?: string;
-    references?: string[];
-};
-export type MailSender = (settings: EmailSettings & {
-    password: string;
-    accessToken?: string;
-}, mail: Mail) => Promise<{
-    ok: true;
-    id: string;
-} | {
-    ok: false;
-    said: string;
-    permanent: boolean;
-}>;
-/** The production sender: the operator's mail server through nodemailer. */
-export declare const sendThroughServer: MailSender;
-/** The thread a card's conversation is in (v91): the latest message, the chain, and everyone in it. */
-export type MailThread = {
-    inReplyTo: string;
-    references: string[];
-    people: Set<string>;
-};
-export declare function sendEmail(stage: FlowStage, card: FlowCardRow, io: {
-    dir: string | null;
-    mail?: MailSender;
-    fetch?: typeof fetch;
-}, thread?: MailThread | null): Promise<ActionOutcome>;
-export type ToolCaller = (spec: ToolSpec, values: Record<string, string>, name: string, args: Record<string, unknown>) => Promise<ToolCall>;
-/** Whether the zone's tool is one of the project's, or what to say while it waits. */
-export declare function toolWaiting(store: Store, stage: FlowStage, repo: string): string | null;
-export declare function useTool(store: Store, stage: FlowStage, card: FlowCardRow, repo: string, io: {
-    callTool?: ToolCaller;
-    toolHome?: string;
-    fenceAvailable?: () => boolean;
-}): Promise<ActionOutcome>;

package/dist/flow-browser.d.ts

@@ -1,103 +0,0 @@
-import { type FlowDefinition } from "./flows.js";
-import type { FlowRow, FlowScriptRow, Store } from "./store.js";
-/** v144: each approval of browser use, live or ended. `digest` is browserApprovalDigest of what was approved. Additive only. */
-export declare const FLOW_BROWSER_SCHEMA = "\nCREATE TABLE IF NOT EXISTS flow_browser_grant (\n  id            INTEGER PRIMARY KEY AUTOINCREMENT,\n  flow          INTEGER NOT NULL,\n  repo          TEXT NOT NULL,\n  flow_revision INTEGER NOT NULL,\n  flow_digest   TEXT NOT NULL,\n  digest        TEXT NOT NULL,\n  zones_json    TEXT NOT NULL,\n  signed_by     TEXT NOT NULL,\n  signed_at     TEXT NOT NULL,\n  proof         TEXT NOT NULL,\n  revoked_at    TEXT,\n  revoked_by    TEXT\n);\nCREATE UNIQUE INDEX IF NOT EXISTS flow_browser_live ON flow_browser_grant (flow) WHERE revoked_at IS NULL;\n";
-/** One zone an approval covers: the zone, and the script it runs (name, version and content digest). */
-export type BrowserZone = {
-    zone: string;
-    script: string;
-    version: number;
-    digest: string;
-};
-/** Everything an approval is about: the flow, its project, the drawing (revision and digest) and every browser zone. */
-export type BrowserTerms = {
-    flow: number;
-    repo: string;
-    revision: number;
-    flowDigest: string;
-    zones: BrowserZone[];
-};
-export type FlowBrowserGrant = BrowserTerms & {
-    id: number;
-    digest: string;
-    signedBy: string;
-    signedAt: string;
-    proof: string;
-};
-/** The approval's digest: domain-separated over the whole of its terms, so a changed flow, drawing, revision or any
- * covered script (a restored one is a new version) is a different approval. */
-export declare function browserApprovalDigest(terms: BrowserTerms): string;
-/** The flow's script zones that say they start a browser, each with the script it runs now; null when one's script is
- * missing, waiting for approval, or runs a project file (an approval seals the script's own text, never a file the
- * project can change). */
-export declare function browserZonesOf(store: Store, flow: FlowRow, definition: FlowDefinition): BrowserZone[] | null;
-/** What an approval of this flow would be about now, read from the store; null when it can't be approved. */
-export declare function browserTermsOf(store: Store, flow: FlowRow): BrowserTerms | null;
-/** The flow's live approval, as recorded (whether it still stands is browserStanding's question). */
-export declare function liveBrowserGrant(store: Store, flowId: number): FlowBrowserGrant | null;
-/**
- * Whether `zone` of this flow may start a browser now. `run`, when given, is what the caller is about to run — the
- * drawing it read and the very script object it hands the launch — and the answer is about exactly that. The live
- * approval stands only when its digest is the approval this flow would be now (same flow, project, drawing revision and
- * digest, and every browser zone's script name, version and digest), it was a person's, and its signer is still an
- * approver who reaches the project; `run`'s drawing must be that drawing and its script that zone's script. Anything
- * unreadable, changed or mismatched is a no, with the plain words a card waits with.
- */
-export declare function browserStanding(store: Store, flowId: number, zone: string, run?: {
-    definition: FlowDefinition;
-    script: FlowScriptRow;
-}): {
-    allowed: true;
-} | {
-    allowed: false;
-    said: string;
-};
-/** What approving means, in words the person reads before they give their password. */
-export declare function browserTerms(zones: readonly BrowserZone[]): string[];
-/**
- * Approve browser use for the flow as it stands. `proof` is the signer's credential method, proved by the caller just
- * now; only a person's counts (a lead's or remote run's token is refused), from an approver who reaches the project.
- * Re-reads the flow, its zones and scripts in the one transaction that writes; `sawDigest` (required) is the approval
- * (browserApprovalDigest: drawing and scripts) the person read, and anything else is refused. Replaces any live one.
- */
-export declare function signFlowBrowser(store: Store, input: {
-    flow: number;
-    signer: string;
-    proof: string | null;
-    sawDigest: string;
-    /** The console and chat: the signer's account must still be this generation (the session that proved it) and reach every project. */
-    console?: {
-        generation: number;
-    };
-}, now: Date): {
-    ok: true;
-    grant: FlowBrowserGrant;
-} | {
-    ok: false;
-    message: string;
-};
-/** Any approver on the project ends it, with no password: lowering authority. False when there was none. */
-export declare function revokeFlowBrowser(store: Store, flowId: number, by: string, now: Date): boolean;
-/** What the flow page, `flows show` and chat say about browser use: null when no zone says it starts a browser. */
-export type BrowserView = {
-    /** allowed: the approval stands now; ended: there is one, but it no longer stands; none: no one has approved. */
-    status: "allowed" | "ended" | "none";
-    /** The one line every surface shows. */
-    words: string;
-    signedBy: string | null;
-    signedAt: string | null;
-    /** The browser zones as they stand now, each with its title. Empty while one can't be approved (see `problem`). */
-    zones: (BrowserZone & {
-        title: string;
-    })[];
-    /** What approving means (browserTerms), and the approval digest the step-up must carry back. */
-    terms: string[];
-    digest: string | null;
-    /** Why it can't be approved as it stands, or null. */
-    problem: string | null;
-};
-/**
- * Browser use for one flow, read from the store (no writes: page visits call it). Whether it is allowed is exactly
- * browserStanding's answer for the flow's browser zones; the rest only says why in plain words.
- */
-export declare function browserViewOf(store: Store, flow: FlowRow): BrowserView | null;

package/dist/flow-cadence.d.ts

@@ -1,48 +0,0 @@
-/**
- * Flow passes that don't wait for builds. The worker's pass used to move
- * cards only between builds, so a card whose research finished sat still
- * while another build ran (Oct 4: five minutes). Now the worker runs these
- * passes on their own cadence beside its builds, and a finished build,
- * research or check moves its card at once.
- *
- * Model-free and cheap: nothing here starts a build. Cards entering a build
- * zone file their task, which waits for a free slot like any other.
- */
-import { type FlowAdvance } from "./flow-engine.js";
-import { type TriggerIo, type TriggerPass } from "./flow-triggers.js";
-import { type ReplyWatch, type ReplyWatchIo } from "./flow-replies.js";
-import { type StepIo, type StepPass } from "./flow-steps.js";
-import type { Store } from "./store.js";
-import { type Git } from "./landed-cleanup.js";
-import { type YouiyouxPass } from "./youiyoux-intake.js";
-/** How often the worker moves cards, checks triggers, reads replies and runs steps, builds or not. */
-export declare const FLOW_EVERY_MS = 15000;
-/** One pass of a kind for a project at a time in this process: a second one asked for while it runs is skipped
- * (`idle`), and the next cadence takes up whatever it would have done. Cards are also claimed in the database,
- * so passes in other processes can't act twice either. */
-export declare function alone<T>(kind: string, project: string, idle: T, run: () => Promise<T>): Promise<T>;
-/** `youiyouxGit`: the hardened git an options request's result is read with (the plane's own runner; gitOf by default). */
-export type FlowIo = {
-    triggers: TriggerIo;
-    replies: ReplyWatchIo;
-    steps: StepIo;
-    evidenceRoot?: string;
-    youiyouxGit?: Git;
-};
-export type FlowHousekeeping = {
-    triggers: TriggerPass;
-    youiyoux: YouiyouxPass;
-    replies: ReplyWatch;
-    steps: StepPass;
-    flows: FlowAdvance;
-};
-/** One project's flow pass: triggers (which may start cards), youiyoux requests (which file tasks that wait for a
- * person, and move an options request's options to youiyoux's hub and a decision there back), replies (which move waiting cards), steps, then moves. `halted` (a stop or paused admission) skips
- * everything that reaches outside; moves still run. */
-export declare function flowHousekeeping(store: Store, repo: string, clock: () => Date, io: FlowIo, halted: () => boolean): Promise<FlowHousekeeping>;
-/** Move one project's cards. Synchronous, so two can't overlap in a process; each move is checked against the
- * card's visit in its own transaction, so a pass in another process can't move a card twice. */
-export declare function moveCards(store: Store, repo: string, now: Date, evidenceRoot: string | undefined): FlowAdvance;
-/** A build, research or check just finished: move the cards in this project, and in the project of any flow whose
- * card that task belongs to (a build zone may build in another project), now rather than on the next pass. */
-export declare function moveCardsAfter(store: Store, repo: string, tasks: readonly string[], now: Date, evidenceRoot: string | undefined): FlowAdvance;

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

@@ -1,11 +0,0 @@
-import type { Store } from "./store.js";
-import { type TaskStatus } from "./task-status.js";
-/** A task's status as its page reads it, from the store alone (no evidence files); null when it can't be read. */
-/** `root`: where results' saved evidence is. Without it the receipt is read without its saved checks, so a completion
- * (bound to the receipt read with them) doesn't read as one: a status that must say Complete passes it. */
-export declare function storedTaskStatus(store: Store, taskId: string, repo: string, now: Date, root?: string): {
-    status: TaskStatus;
-    activeTaskId: string;
-    live: ReturnType<Store["getRun"]>;
-} | null;
-export declare function flowCardTaskLine(store: Store, taskId: string, repo: string, now: Date, secrets?: readonly string[]): string;