toolroll 0.8.1 → 0.9.0

package/dist/cli.d.ts

@@ -39,7 +39,7 @@ export type ParseResult = {
     error: string;
 };
 type Write = (line: string) => void;
-export declare const HELP = "toolroll \u2014 a control plane for unattended coding agents\n\nUsage\n  toolroll [path...]        report what is in flight\n  toolroll pulls            report what is waiting on a person\n  toolroll graph            report which work graph is already here\n  toolroll repos            list connected repositories, and how to adjust\n  toolroll repos add <path> connect one (no path: the repo you are in)\n  toolroll repos remove <path>\n  toolroll repos add-from-github <owner/name> --root <dir>\n                                   preview, then clone and connect (--yes)\n  toolroll link             put `toolroll` on your PATH\n  toolroll unlink           take it off again\n  toolroll update           update to the latest release: verified, drained, undoable\n                                   (preview first; --yes, --now, --at HH:MM, --rollback)\n  toolroll contract         the machine contract: envelope version + capabilities\n                                   (--commands dumps the declared command guide)\n  toolroll skills install --claude-code [--dir <path>]\n                                   install this binary's guides for Claude Code (preview first)\n  toolroll skills install   teach a repo's agents this queue exists (preview first)\n  toolroll skills list      the guides this exact binary serves\n  toolroll skills get <name>  print one guide (version-matched, never stale)\n  toolroll demo             a seeded throwaway sandbox \u2014 see it working in 90 seconds\n  toolroll up               app + builder for every saved project \u2014 the normal start\n  toolroll onboard          make your agent Toolroll's lead: add this repo, install its skill (--yes)\n  toolroll status           running, queued, ready results, release check and plan windows\n  toolroll session          native coding sessions through the running service\n  toolroll connect          save a private connection to your central service\n  toolroll lead             named leads on the connected service\n  toolroll conversation     shared and private conversations on that service\n  toolroll chat --lead <id> --conversation <id>  central chat (use --local for local chat)\n\nOperating the queue \u2014 `toolroll task` prints the whole surface,\nand any queue command + --help prints it too\n  toolroll approver add <name>\n                               mint the credential that lets a person say yes\n  toolroll ready            what could be dispatched right now\n  toolroll check-progress <run>  current or final approved check progress\n  toolroll task wait <id> [--timeout <seconds>]\n                               wait for this attempt to finish or need a person\n  toolroll task add <title> queue work\n  toolroll task scope <id> --goal <text>\n                               state what success is; approval binds to it\n  toolroll task approve <id>\n                               the yes \u2014 nothing builds without one\n  toolroll claim <id> --runner <name>\n  toolroll heartbeat <lease> / release <lease> / reap\n  toolroll tick --runner <name> --token <t> --repo <path>\n                               one unattended pass over the ready set\n  toolroll chat --as <you> --token <t>\n                               talk to the mate: one conversation across every\n                               project; it proposes, you confirm (--say \"\u2026\" for one turn)\n  toolroll serve --repo <path>  advanced: run only the console\n                               (--editor vscode with --runner: file links\n                               open in VS Code on the device you browse from)\n  toolroll watch / daemon install   advanced: run only the builder\n  toolroll reconcile        recover what the last stretch left behind\n\nWith nothing connected it reports everything it can find below the working\ndirectory. Once you connect repositories it reports those instead.\n\nOptions\n  --all         report everything discoverable, ignoring connected repos\n  --depth <n>   directory levels to descend (default: 6)\n  --hidden      include dot-directories, which are skipped by default\n  --dirty       also read each working tree for uncommitted files\n  --local       branches only: no network, no pull requests, no issues\n  --json        emit a machine-readable envelope instead of a report\n  -o <file>     also write that envelope to a file (requires --json)\n  -h, --help    show this\n\nNothing is written, installed, or configured. Every repository is read\nthrough git with --no-optional-locks, so a scan never contends for the\nindex lock with an editor you have open.\n\n--dirty is off by default because reading a working tree is unbounded\nwork: on a large or cloud-synced repo `git status` can take minutes,\nwhere listing branches takes milliseconds.\n\nlink shows what it would do and changes nothing; add --yes to apply it,\nor --to <dir> to choose where. It never uses sudo, never leaves your\nhome directory, and never touches a file it did not create.";
+export declare const HELP = "toolroll \u2014 a control plane for unattended coding agents\n\nUsage\n  toolroll [path...]        report what is in flight\n  toolroll pulls            report what is waiting on a person\n  toolroll graph            report which work graph is already here\n  toolroll repos            list connected repositories, and how to adjust\n  toolroll repos add <path> connect one (no path: the repo you are in)\n  toolroll repos remove <path>\n  toolroll repos add-from-github <owner/name> --root <dir>\n                                   preview, then clone and connect (--yes)\n  toolroll link             put `toolroll` on your PATH\n  toolroll unlink           take it off again\n  toolroll update           update to the latest release: verified, drained, undoable\n                                   (preview first; --yes, --now, --at HH:MM, --rollback)\n  toolroll contract         the machine contract: envelope version + capabilities\n                                   (--commands dumps the declared command guide)\n  toolroll skills install --claude-code [--dir <path>]\n                                   install this binary's guides for Claude Code (preview first)\n  toolroll skills install   teach a repo's agents this queue exists (preview first)\n  toolroll skills list      the guides this exact binary serves\n  toolroll skills get <name>  print one guide (version-matched, never stale)\n  toolroll demo             a seeded throwaway sandbox \u2014 see it working in 90 seconds\n  toolroll up               app + builder for every saved project \u2014 the normal start\n  toolroll onboard          make your agent Toolroll's lead: add this repo, install its skill (--yes)\n  toolroll status           running, queued, ready results, release check and plan windows\n  toolroll integrations     which integrations work, and what to do about the ones that don't (--json)\n  toolroll session          native coding sessions through the running service\n  toolroll connect          save a private connection to your central service\n  toolroll lead             named leads on the connected service\n  toolroll conversation     shared and private conversations on that service\n  toolroll chat --lead <id> --conversation <id>  central chat (use --local for local chat)\n\nOperating the queue \u2014 `toolroll task` prints the whole surface,\nand any queue command + --help prints it too\n  toolroll approver add <name>\n                               mint the credential that lets a person say yes\n  toolroll ready            what could be dispatched right now\n  toolroll check-progress <run>  current or final approved check progress\n  toolroll task wait <id> [--timeout <seconds>]\n                               wait for this attempt to finish or need a person\n  toolroll task add <title> queue work\n  toolroll task scope <id> --goal <text>\n                               state what success is; approval binds to it\n  toolroll task approve <id>\n                               the yes \u2014 nothing builds without one\n  toolroll claim <id> --runner <name>\n  toolroll heartbeat <lease> / release <lease> / reap\n  toolroll tick --runner <name> --token <t> --repo <path>\n                               one unattended pass over the ready set\n  toolroll chat --as <you> --token <t>\n                               talk to the mate: one conversation across every\n                               project; it proposes, you confirm (--say \"\u2026\" for one turn)\n  toolroll serve --repo <path>  advanced: run only the console\n                               (--editor vscode with --runner: file links\n                               open in VS Code on the device you browse from)\n  toolroll watch / daemon install   advanced: run only the builder\n  toolroll reconcile        recover what the last stretch left behind\n\nWith nothing connected it reports everything it can find below the working\ndirectory. Once you connect repositories it reports those instead.\n\nOptions\n  --all         report everything discoverable, ignoring connected repos\n  --depth <n>   directory levels to descend (default: 6)\n  --hidden      include dot-directories, which are skipped by default\n  --dirty       also read each working tree for uncommitted files\n  --local       branches only: no network, no pull requests, no issues\n  --json        emit a machine-readable envelope instead of a report\n  -o <file>     also write that envelope to a file (requires --json)\n  -h, --help    show this\n\nNothing is written, installed, or configured. Every repository is read\nthrough git with --no-optional-locks, so a scan never contends for the\nindex lock with an editor you have open.\n\n--dirty is off by default because reading a working tree is unbounded\nwork: on a large or cloud-synced repo `git status` can take minutes,\nwhere listing branches takes milliseconds.\n\nlink shows what it would do and changes nothing; add --yes to apply it,\nor --to <dir> to choose where. It never uses sudo, never leaves your\nhome directory, and never touches a file it did not create.";
 export declare function parseArgs(argv: readonly string[]): ParseResult;
 /** The commands that operate the queue rather than report on the world. */
 /** Every verb the CLI routes OUTSIDE runOperate. Exported (with

package/dist/cli.js

@@ -61,6 +61,7 @@ Usage
   toolroll up               app + builder for every saved project — the normal start
   toolroll onboard          make your agent Toolroll's lead: add this repo, install its skill (--yes)
   toolroll status           running, queued, ready results, release check and plan windows
+  toolroll integrations     which integrations work, and what to do about the ones that don't (--json)
   toolroll session          native coding sessions through the running service
   toolroll connect          save a private connection to your central service
   toolroll lead             named leads on the connected service
@@ -197,10 +198,12 @@ export const OPERATE_COMMANDS = new Set([
     "ledger",
     "storage",
     "monitoring",
+    "integrations",
     "check-progress",
     "spend",
     "budget",
     "retention",
+    "notifications",
     "backup",
     "restore",
     "export",

package/dist/digest-times.d.ts

@@ -0,0 +1,3 @@
+/** The evening digest choices Settings offers: off, or an evening hour — plus a time set from the command line,
+ * kept as chosen. Shared by the console page and its no-script fallback. */
+export declare function digestTimes(current: string | null): [string, string][];

package/dist/digest-times.js

@@ -0,0 +1,7 @@
+/** The evening digest choices Settings offers: off, or an evening hour — plus a time set from the command line,
+ * kept as chosen. Shared by the console page and its no-script fallback. */
+export function digestTimes(current) {
+    const hours = ["17:00", "18:00", "19:00", "20:00", "21:00", "22:00"];
+    const times = current === null || hours.includes(current) ? hours : [...hours, current].sort();
+    return [["off", "Off"], ...times.map(one => [one, `At ${one}`])];
+}

package/dist/dispose.js

@@ -132,6 +132,7 @@ function disposeBuildOutcomeLocked(context, result) {
                     const grant = store.publicationGrantFor(repo);
                     const headSha = store.getRun(runId)?.headRevision ?? null;
                     if (grant !== null &&
+                        grant.publishOn !== "complete" &&
                         headSha !== null &&
                         headWithin(branch, grant.headPrefix) &&
                         (grant.selector === "all" || origin === "ours")) {
@@ -203,6 +204,7 @@ function disposeBuildOutcomeLocked(context, result) {
                 const grant = store.publicationGrantFor(repo);
                 const headSha = store.getRun(runId)?.headRevision ?? null;
                 if (grant !== null &&
+                    grant.publishOn !== "complete" &&
                     headSha !== null &&
                     headWithin(branch, grant.headPrefix) &&
                     (grant.selector === "all" || origin === "ours")) {

package/dist/export.js

@@ -60,7 +60,7 @@ export function categoryOf(table) {
         [/^(run|artifact|claim|worktree$|execution_slot|contest|tournament_terms|fallback_cycle|fallback_transition|held_session|session_turn|attended_authorization|criterion_review|diff_comment|proof_|review_request|repair_chain|incident|publication$|merge_|side_spend|knowledge_snapshot|learning_snapshot|skill_snapshot)/, "runs"],
         [/^(task|hold$|plan_|scope_|tool_seal|decision|external_|skill_test)/, "tasks"],
         [/^(project|approval_policy|capability|verify_command|worktree_setup|backend_grant|intake_grant|publication_grant|operating_mode|knowledge_|learning_|memory_|skill_)/, "projects"],
-        [/(_config|_default|_defaults)$|^(budget|model_|provider_|installation_fact|runtime_check|monitoring_status|quota|mode_rail|schema_version)/, "settings"],
+        [/(_config|_default|_defaults)$|^(budget|model_|provider_|installation_fact|runtime_check|monitoring_status|integration_check|quota|mode_rail|schema_version)/, "settings"],
     ];
     return rules.find(([pattern]) => pattern.test(table))?.[1] ?? "other";
 }

package/dist/first-run.d.ts

@@ -9,14 +9,17 @@ export type FirstRunAction = {
     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" | "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;
+    agentSignedIn: boolean | null;
     projects: number;
     hasTask: boolean;
     firstResultAt: string | null;

package/dist/first-run.js

@@ -15,7 +15,8 @@ export function firstRunSteps(facts) {
         return null;
     const project = facts.projects > 0;
     return [
-        { key: "agent", title: "Agent signed in", done: facts.agentSignedIn, action: facts.agentSignedIn ? null : { kind: "command", command: SIGN_IN_COMMAND } },
+        facts.agentSignedIn === null ? { key: "agent", title: "Agent signed in", done: false, action: null, checking: true }
+            : { key: "agent", title: "Agent signed in", done: facts.agentSignedIn, action: facts.agentSignedIn ? null : { kind: "command", command: SIGN_IN_COMMAND } },
         { key: "project", title: "Project added", done: project, action: project ? null : { kind: "link", label: "Add a project", href: "/projects" } },
         { key: "task", title: "Your first task", done: facts.hasTask, action: facts.hasTask ? null : { kind: "link", label: "New task", href: "/tasks/new" } },
     ];

package/dist/integrations-ui.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Settings → Integrations: which integrations work. One row each: its name
+ * and state, the account it's connected as, when it last worked and last
+ * failed, what uses it, and one action. The list comes from saved checks; a
+ * render never waits on one (see integrations.ts).
+ */
+import { type Integration } from "./integrations.js";
+export declare const INTEGRATIONS_CSS: string;
+export declare function integrationsHtml(list: readonly Integration[], csrf: string, notice: {
+    said?: string | null;
+    problem?: string | null;
+    checking?: boolean;
+}): string;

package/dist/integrations-ui.js

@@ -0,0 +1,65 @@
+/**
+ * Settings → Integrations: which integrations work. One row each: its name
+ * and state, the account it's connected as, when it last worked and last
+ * failed, what uses it, and one action. The list comes from saved checks; a
+ * render never waits on one (see integrations.ts).
+ */
+import { STATE_WORDS } from "./integrations.js";
+const e = (value) => String(value ?? "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+const when = (at) => `${e(at.slice(0, 16).replace("T", " "))} UTC`;
+export const INTEGRATIONS_CSS = `.integrations{max-width:760px;min-width:0}.integrations h2{margin:24px 0 6px;font-size:.9375rem}` +
+    `.integrations .integration{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:4px 16px;align-items:start;padding:12px 0;border-top:1px solid var(--so-line);min-width:0}` +
+    `.integrations .integration>:not(.integration-action){grid-column:1}.integrations .integration:first-of-type{border-top:0}.integrations .integration-head{margin:0;display:flex;flex-wrap:wrap;gap:6px 10px;align-items:center;min-width:0}` +
+    `.integrations .integration-head strong{overflow-wrap:anywhere}.integrations .integration p{margin:2px 0 0;min-width:0;overflow-wrap:anywhere}` +
+    `.integrations .integration-action{grid-column:2;grid-row:1 / span 3;align-self:center;margin:0}.integrations .integration-action button,.integrations .integration-action .button-link{min-height:44px;white-space:nowrap}` +
+    `.integrations .integration .integration-action button{width:auto}.integrations .integration .integration-action a.integration-quiet{background:var(--so-paper);color:var(--so-ink);border:1px solid var(--so-input-line)}` +
+    `.integrations .integration-fix{color:var(--so-danger)}.integrations code{overflow-wrap:anywhere}.integrations details{margin-top:4px;font-size:.8125rem}.integrations summary{cursor:pointer;padding:4px 0}` +
+    `.integration-state{display:inline-flex;align-items:center;gap:6px;font-size:.75rem;font-weight:500;padding:0 8px;border-radius:5px;line-height:20px;white-space:nowrap}` +
+    `.integration-state i{width:6px;height:6px;border-radius:50%;background:currentColor}` +
+    `.integration-state--connected{color:var(--so-success);background:var(--so-success-soft)}.integration-state--broken{color:var(--so-danger);background:var(--so-danger-soft)}` +
+    `.integration-state--not-set-up,.integration-state--checking{color:var(--so-muted);background:var(--so-neutral-soft)}` +
+    `@media (max-width:560px){.integrations .integration{grid-template-columns:minmax(0,1fr)}.integrations .integration-action{grid-column:1;grid-row:auto;margin-top:8px}}`;
+const GROUPS = [
+    ["chat", "Chat"], ["code", "Code and issues"], ["mail", "Email"], ["tools", "MCP tools"], ["monitoring", "Monitoring"], ["agents", "Agents"],
+];
+function action(one, csrf) {
+    const a = one.action;
+    if (a.kind === "test") {
+        return csrf === "" ? "" : `<form method="post" action="/settings/integrations/test" class="integration-action"><input type="hidden" name="csrf" value="${e(csrf)}">` +
+            `<input type="hidden" name="key" value="${e(one.key)}"><button type="submit">Send test</button></form>`;
+    }
+    // A command is run where Toolroll runs; a page is linked. Fix and Set up both say which.
+    // Fix is the one filled action on the page; Set up stays quiet so a list of unused services doesn't shout.
+    if (a.href !== null)
+        return `<p class="integration-action"><a class="button-link${a.kind === "setup" ? " integration-quiet" : ""}" href="${e(a.href)}">${a.label}</a></p>`;
+    return "";
+}
+function row(one, csrf) {
+    const badge = !one.checked && one.state === "connected"
+        ? `<span class="integration-state integration-state--checking"><i aria-hidden="true"></i>Checking</span>`
+        : `<span class="integration-state integration-state--${one.state}"><i aria-hidden="true"></i>${STATE_WORDS[one.state]}</span>`;
+    const facts = [one.account, one.detail].filter(Boolean).map(e).join(" · ");
+    const command = one.action.kind !== "test" ? one.action.command : null;
+    const fix = one.action.kind === "fix" ? `<p class="integration-fix" role="status">${e(one.action.words)}</p>` : "";
+    const run = command === null || (one.action.kind === "fix" && one.action.words.includes(command)) ? "" : `<p class="meta">Run <code>${e(command)}</code> on the computer running Toolroll.</p>`;
+    const seen = [one.lastSuccessAt === null ? null : `Last success ${when(one.lastSuccessAt)}`, one.usedBy.length === 0 ? null : `Used by ${e(one.usedBy.join(", "))}`].filter(Boolean);
+    const history = one.state === "not-set-up" || seen.length === 0 ? "" : `<p class="meta">${seen.join(" · ")}</p>`;
+    const lastError = one.lastError === null || one.state === "not-set-up" ? "" : one.state === "broken" && one.action.kind === "fix" && one.action.words === one.lastError
+        ? `<p class="meta">Failed ${when(one.lastErrorAt ?? "")}</p>`
+        : `<details><summary>Last error ${one.lastErrorAt === null ? "" : when(one.lastErrorAt)}</summary><p class="meta">${e(one.lastError)}</p></details>`;
+    return `<div class="integration" data-integration="${e(one.key)}" data-state="${one.state}">` +
+        `<p class="integration-head"><strong>${e(one.name)}</strong> ${badge}</p>` +
+        action(one, csrf) +
+        (facts === "" ? "" : `<p class="meta">${facts}</p>`) + fix + run + history + lastError + `</div>`;
+}
+export function integrationsHtml(list, csrf, notice) {
+    const note = notice.problem ? `<p class="problem" role="alert">${e(notice.problem)}</p>` : notice.said ? `<p role="status">${e(notice.said)}</p>` : "";
+    const broken = list.filter(one => one.state === "broken").length;
+    const summary = broken > 0 ? `<p><strong>${broken} need${broken === 1 ? "s" : ""} fixing.</strong></p>`
+        : notice.checking || list.some(one => !one.checked) ? `<p class="meta" role="status">Checking in the background. Refresh in a few seconds.</p>` : "";
+    const sections = GROUPS.map(([group, title]) => {
+        const rows = list.filter(one => one.group === group);
+        return rows.length === 0 ? "" : `<h2>${title}</h2>${rows.map(one => row(one, csrf)).join("")}`;
+    }).join("");
+    return `<section class="integrations">${note}${summary}${sections}</section>`;
+}

package/dist/integrations.d.ts

@@ -0,0 +1,113 @@
+import type { Store } from "./store.js";
+import type { Runner } from "./backend.js";
+import type { ConnectionChecker } from "./provider-connection.js";
+export type IntegrationState = "connected" | "not-set-up" | "broken";
+export type IntegrationGroup = "chat" | "code" | "mail" | "tools" | "monitoring" | "agents";
+/** Where a person goes (or what they run) to set something up or fix it. */
+export type IntegrationPlace = {
+    href: string | null;
+    command: string | null;
+};
+export type IntegrationAction = ({
+    kind: "setup";
+    label: "Set up";
+} & IntegrationPlace) | {
+    kind: "test";
+    label: "Send test";
+} | ({
+    kind: "fix";
+    label: "Fix";
+    words: string;
+} & IntegrationPlace);
+export type Integration = {
+    key: string;
+    group: IntegrationGroup;
+    name: string;
+    state: IntegrationState;
+    /** The account or workspace name, never a credential. */
+    account: string | null;
+    /** One short fact, such as which projects can be pushed to. */
+    detail: string | null;
+    /** Whether a check has answered for this integration yet (always true for those with nothing to check). */
+    checked: boolean;
+    checkedAt: string | null;
+    lastSuccessAt: string | null;
+    lastError: string | null;
+    lastErrorAt: string | null;
+    usedBy: string[];
+    action: IntegrationAction;
+};
+export declare const STATE_WORDS: Record<IntegrationState, string>;
+export type ProbeResult = {
+    outcome: "ok";
+    account?: string | null;
+    detail?: string | null;
+} | {
+    outcome: "failed";
+    problem: string;
+    account?: string | null;
+    detail?: string | null;
+    fix?: Partial<IntegrationPlace>;
+} | {
+    outcome: "absent";
+    problem: string;
+    setup?: Partial<IntegrationPlace>;
+};
+export type IntegrationIo = {
+    store: Store;
+    /** The folder beside the database where credential files live; null when there is none. */
+    dir: string | null;
+    telegramTokenFile: string | null;
+    env: Record<string, string | undefined>;
+    /** The projects whose MCP tools and GitHub push rights are listed. */
+    repos: readonly string[];
+    fetch?: typeof fetch;
+    /** How `gh` runs (tests replace it). */
+    gh?: Runner;
+    /** The same sign-in check Settings → AI providers makes. */
+    checkConnection?: ConnectionChecker;
+    /** Where project tool secrets live. */
+    toolHome?: string;
+    /** Whether a mail server answers at host:port (tests replace it). */
+    reach?: (host: string, port: number, secure: boolean) => Promise<void>;
+    clock?: () => Date;
+};
+/** Remove every known secret value and anything shaped like a token; keep it to one short line. */
+export declare function scrubIntegrationText(text: string, secrets?: readonly (string | null | undefined)[]): string;
+type CheckRow = {
+    key: string;
+    outcome: "ok" | "failed" | "absent";
+    account: string | null;
+    detail: string | null;
+    problem: string | null;
+    checkedAt: string;
+    okAt: string | null;
+    error: string | null;
+    errorAt: string | null;
+};
+export declare function readIntegrationChecks(store: Store): Map<string, CheckRow>;
+export declare function recordIntegrationCheck(store: Store, key: string, result: ProbeResult, now: Date): void;
+/** Whether something answers at host:port: a connection opened and closed, no login and no message. */
+export declare function reachServer(host: string, port: number, secure: boolean): Promise<void>;
+/** Every integration as it stands now, from files and saved history only: no network, no process, never slow. */
+export declare function integrationsNow(io: IntegrationIo): Integration[];
+/** Run the checks (all, or the named ones), record each answer, and return the list. */
+export declare function checkIntegrations(io: IntegrationIo, keys?: readonly string[]): Promise<Integration[]>;
+/** The one line `status` and `onboard` add when something is Broken; null when nothing is. */
+export declare function integrationsBrokenLine(list: readonly Integration[]): string | null;
+/** The CLI's lines: one per integration, then the fix under anything Broken. */
+export declare function renderIntegrations(list: readonly Integration[]): string[];
+export type IntegrationMonitor = {
+    /** The list now, without waiting; starts a background check when the last one is older than the cache. */
+    list(): Integration[];
+    /** Check now and wait (Send test, or the first answer in a test). */
+    check(keys?: readonly string[]): Promise<Integration[]>;
+    /** Whether a background check is running. */
+    readonly checking: boolean;
+};
+/** Checks in the background with a short cache, as the first-run suggestions are: a render never waits on a check. */
+export declare function createIntegrationMonitor(io: () => IntegrationIo, options?: {
+    cacheMs?: number;
+    now?: () => number;
+}): IntegrationMonitor;
+export {};