toolroll 0.9.104 → 0.9.105

package/dist/invoke.d.ts

@@ -1,228 +0,0 @@
-/**
- * The invocation gateway: the only door to any provider binary (§5).
- *
- * "Never let an LLM poll" is only enforceable if there is exactly one place
- * that can start an LLM, and this is it. Every call verifies an open run
- * record WHOSE RECORDED PROVIDER MATCHES the one about to spawn (a repair
- * resumed on the wrong harness is a meaningless session id and a silent
- * fresh spend — refused here, structurally), stamps `provider_started_at`
- * the instant before the process spawns, and parses usage off the envelope
- * of EVERY completed process — nonzero exits included, because a failed
- * turn still spent money and a cost report that skips failures is a
- * smaller number, not a truer one.
- *
- * The architecture test asserts the boundary by imports, not by string
- * scan: only this module imports the registry's spawning surface
- * (`adapterFor`), and only builder, planner, reviewer, and scout import
- * `invokeAgent`.
- */
-import { type AgentSpec, type Invocation, type ProviderRunner, type AgentEnding } from "./provider.js";
-import { type VersionProbe } from "./attest.js";
-import { type Store } from "./store.js";
-import type { RunOptions } from "./exec.js";
-import type { Runner } from "./worktree.js";
-import { type NetworkFence, type SignInGrants } from "./agent-fence.js";
-import { type CheckStamp } from "./check-stamp.js";
-import { type CheckAccess } from "./check-access.js";
-import { type WritesMode, type LaunchSandbox, type FenceGrants } from "./agent-fence.js";
-import { type NetworkProfile } from "./egress.js";
-export type { ProviderRunner } from "./provider.js";
-export type ProviderUsage = {
-    tokensIn: number | null;
-    tokensOut: number | null;
-    costUsd: number | null;
-};
-export type AgentOutcome = {
-    code: number;
-    stderr: string;
-    timedOut: boolean;
-    notFound: boolean;
-    /** The harness session, for repair-by-resume on the SAME provider. */
-    sessionId: string | null;
-    /** The agent's spoken conclusion — diagnostics, never the handoff. */
-    finalMessage: string | null;
-    /** Claude's `structured_output` alone (see ParsedEnvelope) — the only
-     * field a structured handback may be read from. */
-    structuredOutput?: string | null;
-    /** The harness's own account of the ending, when its dialect has one. */
-    ending?: AgentEnding | null;
-    usage: ProviderUsage;
-    /**
-     * The harness never came up: the provider has an init signal, it was not
-     * seen, and the turn also has nothing to show. Config, auth, or install —
-     * not an agent's attempt, and callers must not treat it as one (M5
-     * provider audit: init failure is retryable infrastructure, and its
-     * distinct reason keeps a broken environment from reading as three
-     * strikes of bad agent work).
-     */
-    initFailed: boolean;
-    /** An ACP conversation's facts (provider.ts ParsedEnvelope.acp): read by the conformance check only. */
-    acp?: NonNullable<import("./provider.js").ParsedEnvelope["acp"]>;
-};
-/**
- * The value-shaped gateway result (Phase 3 B5): a refusal is a VALUE, so
- * every caller's try/finally worktree release and disposition run exactly
- * as they do for any other outcome — nothing here throws for these.
- *
- * - `provider-unattested`: the pre-spawn check failed (races past the
- *   tick's pre-claim skip — an executable swap mid-tick). No process
- *   started; the refused version is stamped on the run.
- * - `provider-protocol`: the harness ran and broke its own contract — a
- *   zero exit without the required terminal proof (A4), or an init
- *   identity that does not match the minted one (A5). Spend was recorded;
- *   the handoff must never be ingested.
- */
-export type InvokeResult = {
-    kind: "ran";
-    outcome: AgentOutcome;
-} | {
-    kind: "refused";
-    reason: "provider-unattested" | "provider-protocol" | "runner-custody" | "auth-mode" | "route-authority" | "stopped" | "containment" | "protected-storage";
-    providerVersion: string | null;
-    diagnostic: string | null;
-    /** Bounded agent reply when a spawned turn later failed a protocol
-     * gate. Pre-spawn refusals omit it because no reply can exist. */
-    finalMessage?: string | null;
-    /** An ACP conversation's facts, when the refusal came after a spawn (the conformance check grades a cancel). */
-    acp?: NonNullable<import("./provider.js").ParsedEnvelope["acp"]>;
-};
-/**
- * Spend money, on the record. Throws — never refuses quietly — when the run
- * is missing, already finished, or recorded against a different provider:
- * a caller that reaches for a harness without a matching open run is a
- * bug, not a case. Attestation and protocol refusals are VALUES (above),
- * not throws — those are cases, and they must dispose cleanly.
- */
-/**
- * What a launch may reach on the network (egress.ts, docs/plans/agent-baseline-hardening.md arc 1). `policy`: the
- * network a build's approval sealed (or the narrowed legacy one), enforced through the run's own proxy. `via`: the
- * caller already runs the proxy (a scout's public-web proxy, its browser): only those loopback ports are reachable.
- * Absent: the provider's own hosts only (a planner, a check — nothing that installs or browses).
- */
-export type LaunchNetwork = {
-    policy: NetworkProfile;
-} | {
-    via: number[];
-};
-export declare function invokeAgent(store: Store, runId: number, spec: AgentSpec, invocation: Omit<Invocation, "model">, options: RunOptions & {
-    runner?: ProviderRunner;
-    clock?: () => Date;
-    versionProbe?: VersionProbe;
-    keyHome?: string;
-    accumulateUsage?: boolean;
-    network?: LaunchNetwork;
-    writes?: WritesMode;
-    sandbox?: LaunchSandbox;
-}): Promise<InvokeResult>;
-/**
- * A build's setup and check commands, run in its fence (arc 2): the same denies as its agent's (Toolroll's state,
- * credentials, other projects and runs), its write allowlist when its approval sealed one (its checkout and Git data,
- * its project's caches, and a temp folder of the command's own), and its package managers pointed at those caches.
- * Their network stays as it was. A machine without an OS fence runs them as before; a fence that can't be prepared
- * (a checkout whose binding no longer proves) runs nothing.
- */
-export declare function fencedCommands(store: Store, runId: number, writes: WritesMode, inner: Runner, available?: () => boolean, access?: CheckAccess, network?: NetworkProfile, sandbox?: LaunchSandbox): Runner;
-/**
- * A project's checks run in a checkout of a result's commit made for them (result-follow-ups.ts, batch-checks.ts), in
- * the same fence as a build's commands: Toolroll's state, credentials, other projects and runs denied; under the
- * project's writes setting, only that checkout, its Git data, its own temp folder, the project's caches and its check
- * database writable. Where nothing can confine them, they run only when an instance operator allowed unconfined agents.
- */
-export declare function fencedCheckoutCommands(store: Store, repo: string, checkout: string, inner: Runner, available?: () => boolean, access?: CheckAccess, network?: NetworkProfile, sandbox?: LaunchSandbox, stampRuns?: readonly number[]): Runner;
-/**
- * A `sign-ins` check's launch (check-access.ts, sandbox parity C10): its exact sign-in files, read by the check itself
- * through its sandbox (agent-fence.ts signInGrants: nothing privileged reads or copies one), its own transcript folder
- * and Codex's session and log folders; Codex, gh and XDG pointed at the real folders; and the network the check runs
- * under: open, or its allowlist through a proxy of its own (on Linux, relayed in by the sandbox runtime). Nothing about it is
- * started unless all of it is.
- */
-/**
- * macOS: the sign-ins a check with sign-ins needs that live in the keychain, not in files: Claude Code's
- * ("Claude Code-credentials", its current access token as CLAUDE_CODE_OAUTH_TOKEN) and gh's ("gh:github.com", as
- * GH_TOKEN). Read here, by Toolroll, outside the sandbox, and handed to the check in its environment, so the check never
- * reaches securityd (sandbox-runtime.ts SEATBELT_NO_KEYCHAIN) and nothing else in the keychain. The check can't renew
- * Claude's token: one that has expired fails its sign-in. A value that isn't a plain token is left out.
- */
-export declare const KEYCHAIN_SIGN_INS: readonly {
-    service: string;
-    env: string;
-    token(secret: string): string | null;
-}[];
-/** One keychain item's secret by its service, read with the system's `security` (null: none, or it can't be read). A
- * keychain file may be named (tests: a throwaway one); never the item's value in an argument. */
-export declare function readKeychainSecret(service: string, keychain?: string): string | null;
-/** The keychain's sign-ins as a check's environment (macOS only; elsewhere, for anything missing, and where Toolroll
- * keeps nothing in the keychain (TOOLROLL_SECRET_STORE=files: the test suite), nothing). */
-export declare function keychainSignIns(platform?: NodeJS.Platform, read?: (service: string) => string | null): Record<string, string>;
-export declare function signInsLaunch(store: Store, own: string, temp: string, checkout: string, policy: NetworkProfile, gitPaths: readonly string[], platform?: NodeJS.Platform, keychain?: () => Record<string, string>): Promise<{
-    grants: SignInGrants;
-    network: NetworkFence;
-    env: Record<string, string>;
-    close(): Promise<void>;
-} | {
-    problem: string;
-}>;
-/** How a check at `access` actually runs here: unsandboxed where no OS fence exists (and an operator allowed that), else
- * as asked. Recorded on every check's receipt, so a check that ran without a sandbox is never shown as sandboxed. */
-export declare function actualCheckAccess(store: Store, access: CheckAccess): CheckAccess;
-/**
- * A check of saved results, in their own checkout (batch-checks.ts, result-follow-ups.ts), worked out right before each
- * command: never wider than any of those results' own checks ran, nor than the project allows now; under sign-ins, the
- * narrowest of their sealed check networks and the project's current one. A result with no sealed network runs it
- * sandboxed.
- */
-export declare function checkoutLaunchOf(store: Store, repo: string, runIds: readonly number[], platform?: NodeJS.Platform): {
-    access: CheckAccess;
-    network: NetworkProfile | undefined;
-};
-/** The widest level a check's commands actually ran at (what its receipt says). */
-export declare const widestRan: (levels: readonly CheckAccess[]) => CheckAccess;
-/** A check log's line for how its commands ran, when wider than sandboxed (shown with the log). */
-export declare const ranAtLine: (level: CheckAccess) => string | null;
-/** A saved result's check command runner (batch-checks.ts, result-follow-ups.ts): its level and network worked out right
- * now (checkoutLaunchOf), and how it actually runs told to `ran`. */
-export declare function checkoutRunner(store: Store, repo: string, checkout: string, inner: Runner, runIds: readonly number[], ran: (level: CheckAccess) => void, platform?: NodeJS.Platform): Runner;
-/**
- * A saved result's checks' sandbox terms (sandbox parity C9), never wider than any of those results' own approvals nor
- * the project now: v2 only when every result's approval sealed v2; every read deny any of them sealed or the project
- * lists now; mach services only those all of them sealed and the project still lists. A result with
- * no readable approval counts as v1 with nothing listed.
- */
-export declare function checkoutSandboxOf(store: Store, repo: string, runIds: readonly number[]): LaunchSandbox;
-/** A fenced launch's stamp: the level it runs at and exactly what it was given (check-stamp.ts), read from the grants the
- * launch itself takes, never from what was asked for. */
-export declare function fencedStamp(level: "sandboxed" | "sign-ins", fence: readonly string[], grants: FenceGrants, network: NetworkProfile | undefined): CheckStamp;
-/** The digest of a launch's whole fence (its denied paths and grants, canonical), as stamped on its run (C11). */
-export declare function fenceDigest(fence: readonly string[], grants: FenceGrants): string;
-/** What a Claude turn's own stream says about how it billed (v105). */
-export type ClaudeBillingSeen = {
-    keySource: string | null;
-    model: string | null;
-    planWindows: boolean;
-    answered: boolean;
-};
-/**
- * One stream event's billing observation: the key source and model from the session's own init, plan windows from a
- * rate-limit event, and whether the main query answered. The session's own events only (stream-scope.ts): a
- * subagent's init, rate-limit event or result says nothing about this turn's billing.
- */
-export declare function observeClaudeBilling(seen: ClaudeBillingSeen, event: Record<string, unknown>): void;
-/**
- * What decides a child's credential: the environment it starts from (the plane's, then the caller's) and every variable
- * it sheds. Subscription: this provider's own keys too, so an ambient key can't force API billing over the login.
- * API key: every other own-key alias, so a stray one can't override the one key injected. Foreign keys and (for a
- * Claude build) plugin variables always. The live plan proof and the launch both use this one answer.
- */
-export declare function childAuthEnv(args: {
-    provider: string;
-    phase: string;
-    authMode: string;
-    keyEnvName: string | null;
-    ownKeyEnv: readonly string[];
-    extraOmitEnv: readonly string[];
-    runEnv: Record<string, string> | undefined;
-    runOmitEnv: readonly string[] | undefined;
-}): {
-    env: Record<string, string | undefined>;
-    omitEnv: string[];
-};

package/dist/is-record.d.ts

@@ -1,2 +0,0 @@
-/** A plain object: not null, not an array. */
-export declare const isRecord: (value: unknown) => value is Record<string, unknown>;

package/dist/issues.d.ts

@@ -1,41 +0,0 @@
-/**
- * GitHub Issues, through `gh`.
- *
- * No new credential: `gh` is already authenticated on any machine where the
- * rest of this tool works, which is the same reason pull requests are read
- * that way. Nothing here holds a token.
- *
- * Two things it deliberately will not do.
- *
- * **It will not write dependency edges.** GitHub grew native `blocked_by`
- * relations and sub-issues, and the design says to use them *where a
- * capability probe confirms them* — including a `gh` new enough to expose the
- * fields. This adapter has confirmed neither the endpoint shape nor the
- * version behaviour against a live repository, so it refuses instead of
- * guessing, and refuses rather than emulating. An invented edge would make our
- * scheduler disagree with what every human on the repository can see.
- *
- * **It will not reach the network on the scheduler's hot path.** Reading is a
- * round trip per repository, and GitHub allows five thousand authenticated
- * requests an hour; a scheduler polling dependencies for a hundred issues once
- * a minute would exhaust that before doing any real work. §4's answer is a
- * materialised snapshot read out of band, which is the scheduler's job to hold
- * — this module just makes each read explicit and bounded so that when the
- * scheduler arrives it is obvious what costs a network call.
- */
-import type { Deps } from "./graph.js";
-import { type GraphBackend, type Runner } from "./backend.js";
-/** A network round trip; bounded like the pull request read it sits beside. */
-export declare const ISSUE_TIMEOUT_MS = 20000;
-/** Enough to see a backlog without paginating. */
-export declare const DEFAULT_LIMIT = 100;
-export type IssuesOptions = {
-    repo: string;
-    runner?: Runner;
-    limit?: number;
-    /** Overridden when a caller is spending a shared budget; see `remote.ts`. */
-    timeoutMs?: number;
-    /** Whether `gh` is new enough for the dependency fields; see `graph.ts`. */
-    deps?: Deps;
-};
-export declare function githubIssues(options: IssuesOptions): GraphBackend;

package/dist/jsonl-discriminants.d.ts

@@ -1,11 +0,0 @@
-/** Bounded structural metadata for an event whose text may exceed the wire
- * cap. Long JSON strings become null in a small skeleton, but every escape
- * is still validated. JSON.parse proves the remaining structure. Unknown,
- * malformed or over-complex input never earns permission to discard it. */
-export declare function jsonlDiscriminants(): {
-    push(bytes: Buffer): void;
-    finish(): {
-        type: string;
-        itemType: string | null;
-    } | null;
-};

package/dist/keymap.d.ts

@@ -1,43 +0,0 @@
-/** One keymap for the console and the terminal UI (docs/plans/plain-toolroll.md P1.7). A shortcut only ever presses a
- * control the page already rendered, the same press a person's click makes, so any password field or confirm it opens
- * still appears; with no such control on the page the key does nothing. Shortcuts sleep in text fields, with a
- * modifier held, and while the shortcuts list is open. Navigation keys go to a page and post nothing. */
-/** What a key does in the console. `press`: the first visible, enabled control matching these, in order. */
-export type WebShortcut = {
-    kind: "go";
-    href: string;
-} | {
-    kind: "press";
-    selectors: readonly string[];
-} | {
-    kind: "search";
-} | {
-    kind: "help";
-};
-/** What a key does in the terminal UI, or null with the reason it has none there (a named gap). */
-export type TuiShortcut = "new" | "ink" | "send-back" | "retry" | "plan" | "list" | "help";
-export type Shortcut = {
-    keys: string;
-    says: string;
-    web: WebShortcut;
-    tui: TuiShortcut | {
-        none: string;
-    };
-};
-/** The page's ink act: Approve (the approve control itself, password popover and all) or Accept. */
-export declare const INK_ACT_SELECTORS: readonly ["[data-ink-approve]", '[data-ink-act="accept"]', "[data-accept-result][data-primary-action]"];
-/** Send back: the control that opens the Send back form (never its submit: the note comes first). */
-export declare const SEND_BACK_SELECTORS: readonly ['[data-act="request-changes"]', '[data-act="revise"]', 'a.result-feedback-link[href="#request-changes"]'];
-/** Retry: the result's Retry, or the failed box's own Retry form. */
-export declare const RETRY_SELECTORS: readonly ['[data-act="retry"]', 'form[data-retry] button[type="submit"]', 'form[data-rebuild] button[type="submit"]'];
-/** Plan it: the task page's own plan button (local-owner slice 2). */
-export declare const PLAN_SELECTORS: readonly ['form[action$="/plan"] button[type="submit"]'];
-export declare const SHORTCUTS: readonly Shortcut[];
-/** The keys typed, as the help list shows them: "g h" reads "g then h". */
-export declare const keyWords: (keys: string) => string;
-/**
- * The console's key routing, as an inline script (it runs inside chromeScript's closure, which defines `show` for the
- * jump-to palette, `toggleHelp`, `helpOpen`, `close` and `go`). Generated from SHORTCUTS, so the table is the only
- * place a key is defined.
- */
-export declare function webKeymapScript(): string;

package/dist/keys.d.ts

@@ -1,108 +0,0 @@
-/**
- * Provider API keys, managed instead of ambient (the gap the gemini
- * live-auth work exposed): one 0600 file per provider under
- * ~/.toolroll/keys/ (or an older ~/.standing-orders/keys/), written from the settings card or piped into
- * the CLI — never typed into an argv, never rendered back, never stored
- * in the database a backup might carry.
- *
- * The injection contract lives in the invocation gateway: a stored key is
- * added to EXACTLY its own provider's child environment at spawn, where
- * the adapter's foreign-credential strip has already shed everybody
- * else's. The plane's own process never needs the key in its environment
- * at all — a restart or a rotation is a file write, not a relaunch — and
- * an ambient env var still works as the fallback it always was (the file,
- * being deliberate, wins).
- */
-import type { ProviderId } from "./provider.js";
-import { type KeyedProviderId } from "./acp-agents.js";
-/** The ONE env name each provider's own harness reads its key from —
- * where a managed key is INJECTED. */
-export declare const PROVIDER_KEY_ENV: Record<KeyedProviderId, string>;
-/** EVERY env name a provider reads its OWN key from — what subscription
- * mode STRIPS so an ambient key cannot override the login. gemini reads
- * two; the rest read one. */
-export declare const OWN_KEY_ENV: Record<KeyedProviderId, readonly string[]>;
-export declare function keysDir(home?: string): string;
-/**
- * How a provider authenticates (the operator's ruling 2026-08-29: keep
- * BOTH, prefer the subscription). "subscription" uses the CLI's OWN login
- * — a Claude/ChatGPT plan, a Google cached login — and the API key is
- * kept but NOT handed to the process, so its own auth wins. "api-key"
- * hands the stored (or ambient) key to the process. openrouter has no
- * login and is always api-key. An ACP agent (acp-agents.ts) has neither:
- * it signs in its own way and Toolroll never holds a key for it —
- * "agent-login", which says nothing about how it is billed (that is the
- * agent's billing declaration, per model).
- */
-export type AuthMode = "subscription" | "api-key" | "agent-login";
-/** Providers that CAN authenticate without an API key (a subscription or
- * cached login). openrouter cannot — it is api-key only. */
-export declare const SUBSCRIPTION_CAPABLE: Record<KeyedProviderId, boolean>;
-/** The default when nothing is set: subscription where it exists (prefer
- * the plan the operator already pays for), api-key otherwise. */
-export declare const DEFAULT_AUTH_MODE: Record<KeyedProviderId, AuthMode>;
-export declare function readAuthMode(provider: ProviderId, home?: string): AuthMode;
-/**
- * The auth mode as an AUTHORITY reads it (raw authority repair): an absent
- * file is the provider's default, but a file that is present and says
- * neither `subscription` nor `api-key` is a stated problem — never the
- * subscription default a lenient read would coerce it to. A provider with
- * no subscription login is the key, whatever the file says.
- */
-export declare function readAuthModeStrict(provider: ProviderId, home?: string): {
-    ok: true;
-    mode: AuthMode;
-} | {
-    ok: false;
-    problem: string;
-};
-export declare function setAuthMode(provider: KeyedProviderId, mode: "subscription" | "api-key", home?: string): {
-    ok: true;
-} | {
-    ok: false;
-    reason: "no-subscription";
-};
-export declare function keyFileFor(provider: KeyedProviderId, home?: string): string;
-/** Shape check only — never a validity claim. A key is printable ASCII
- * without whitespace, bounded; anything else is a paste accident. */
-export declare function plausibleKey(value: string): boolean;
-export declare function saveProviderKey(provider: KeyedProviderId, value: string, home?: string): {
-    ok: true;
-} | {
-    ok: false;
-    reason: "implausible";
-};
-export declare function readProviderKey(provider: KeyedProviderId, home?: string): string | null;
-export declare function clearProviderKey(provider: KeyedProviderId, home?: string): boolean;
-/**
- * A live credential check that spends NO tokens: each provider exposes a
- * cheap authenticated GET (its model list, or a key-info route) whose only
- * job here is to make the provider's own auth boundary answer yes or no.
- * Injectable fetcher (the converse.ts precedent) so tests never touch the
- * network. Distinguishes a REJECTED key (bad/expired/wrong provider) from
- * an UNREACHABLE provider (offline, blocked) — the operator needs to know
- * which, because only one of them means "fix the key".
- */
-export type KeyVerdict = {
-    ok: true;
-} | {
-    ok: false;
-    reason: "rejected";
-    status: number;
-} | {
-    ok: false;
-    reason: "unreachable";
-} | {
-    ok: false;
-    reason: "unexpected";
-    status: number;
-};
-export declare function verifyProviderKey(provider: KeyedProviderId, value: string, fetcher?: typeof fetch, timeoutMs?: number): Promise<KeyVerdict>;
-/** Words for a verdict, safe to render on any surface (never the key). */
-export declare function verdictWords(provider: KeyedProviderId, verdict: KeyVerdict): string;
-/** What a surface may say about a key: that it exists and when it last
- * changed — NEVER the value, never a prefix, never a length. */
-export declare function keyStatus(provider: KeyedProviderId, home?: string): {
-    set: boolean;
-    updatedAt: string | null;
-};

package/dist/kits-ui.d.ts

@@ -1,16 +0,0 @@
-/**
- * Starter kits: the "With an agent" rows of New flow (each kit's promise, what it sets up, one button to its page)
- * and a kit's own page, a reading page: what it sets up, then its checklist with the next step on each line
- * (connect email, connect a tool, try a sample card).
- */
-import type { Store } from "./store.js";
-import { type Kit } from "./kits.js";
-import { type Html } from "./html.js";
-export declare const KITS_CSS: string;
-/** "With an agent": every kit as a row; Set it up (or Open, once it's there) goes to the kit's page for `repo`. */
-export declare function kitRowsHtml(store: Store, repo: string | null): Html;
-/** A kit's own page: what it sets up, Set up (once), then the next step on each line. */
-export declare function kitPageHtml(store: Store, kit: Kit, repo: string, dir: string | null, canSetUp: boolean, notice_: {
-    said?: string | null;
-    problem?: string | null;
-}, projectName?: (repo: string) => string): Html;

package/dist/kits.d.ts

@@ -1,88 +0,0 @@
-import { type FlowStepInput } from "./flows.js";
-import type { FlowRow, Store, SubagentRow } from "./store.js";
-import { type ToolIo } from "./subagent-tools.js";
-/** A tool a kit's subagent works better with: the catalog entry that connects it, and why. */
-export type KitTool = {
-    tool: string;
-    label: string;
-    why: string;
-};
-export type Kit = {
-    id: string;
-    name: string;
-    promise: string;
-    /** The subagent it hires: a template, and the name it starts with. */
-    subagent: {
-        template: string;
-        handle: string;
-    };
-    flowName: string;
-    steps: FlowStepInput[];
-    /** Triggers safe to add at once: buttons (they fire only when pressed). */
-    buttons: {
-        label: string;
-        questions: string[];
-    }[];
-    /** Other ways in, offered on its checklist. */
-    email?: boolean;
-    github?: boolean;
-    tools: KitTool[];
-    sample: {
-        title: string;
-        description: string;
-    };
-};
-export declare const KITS: readonly Kit[];
-export declare const kitOf: (id: string) => Kit | null;
-type Done = {
-    ok: true;
-    said: string;
-    flow: number;
-    subagent: number;
-} | {
-    ok: false;
-    said: string;
-};
-/** A kit set up in a project: its flow (by name) and its subagent, when both are there. */
-export declare function kitInstalled(store: Store, kit: Kit, repo: string): {
-    flow: FlowRow;
-    mate: SubagentRow;
-} | null;
-/**
- * Set a kit up: its subagent (kept if one of that name is already there), its
- * flow, and its button triggers; then its subagent may use whichever of the
- * kit's tools the project already has (reading free, writing asking first).
- */
-export declare function setUpKit(store: Store, kit: Kit, repo: string, by: string, now: Date, dir: string | null, io?: ToolIo, options?: {
-    widening?: "proved";
-}): Promise<Done>;
-/** The same, all at once and without its tools (a chat confirmation is never a grant's proof): its subagent, its flow and its buttons. */
-export declare function setUpKitNow(store: Store, kit: Kit, repo: string, by: string, now: Date, dir: string | null): Done;
-/** One line of a kit's checklist: done, or the next step with where to take it. */
-export type KitStep = {
-    id: string;
-    done: boolean;
-    said: string;
-    href: string | null;
-    action?: "sample" | "github" | "connect";
-    tool?: string;
-};
-/** What's set up and what's left, read fresh each time. */
-export declare function kitChecklist(store: Store, kit: Kit, repo: string, dir: string | null): KitStep[];
-/** A sample card in the kit's first zone, so its subagent starts on it at once. */
-export declare function addKitSample(store: Store, kit: Kit, repo: string, by: string, now: Date): {
-    ok: true;
-    href: string;
-} | {
-    ok: false;
-    said: string;
-};
-/** Bring new issues from the project's GitHub repository into the kit's flow (issues from anyone, polled). */
-export declare function addKitGithubTrigger(store: Store, kit: Kit, repo: string, by: string, now: Date, dir: string | null, proved?: "proved" | null): {
-    ok: true;
-    said: string;
-} | {
-    ok: false;
-    said: string;
-};
-export {};