toolroll 0.9.103 → 0.9.105

package/dist/public-access.d.ts

@@ -1,52 +0,0 @@
-/**
- * Serving on a real domain (remote team, phase 3): which requests arrived safely enough to carry an API token,
- * and when the console sends Strict-Transport-Security. Pure rules over what the socket and the one trusted proxy
- * say; serve.ts applies them right after its Host check, and `toolroll serve check-public` probes for them.
- *
- * Trust comes from the socket first. Only a LOOPBACK peer is the documented same-host TLS proxy (Caddy, Cloudflare
- * Tunnel), and only then are X-Forwarded-For (its last hop, via serve.ts's joinSourceOf) and X-Forwarded-Proto
- * believed. Any other peer's forwarded headers are ignored: it reached us over plain HTTP from where it stands.
- */
-/** One year, this exact host only: no includeSubDomains, no preload, so sibling names are never pinned. */
-export declare const HSTS_VALUE = "max-age=31536000";
-/** What a token-bearing request over plain HTTP from elsewhere is told. */
-export declare const USE_HTTPS = "Use HTTPS. API tokens are accepted over plain HTTP only from this computer or your tailnet; connect with the server's https:// address.";
-/**
- * The exact loopback peers serve.ts trusts as the same-host proxy (joinSourceOf, fromThisComputer). Not all of
- * 127/8: a proxy listening on 127.0.0.2 must not make public callers look like this computer.
- */
-export declare const LOOPBACK_PEERS: ReadonlySet<string>;
-/** One of LOOPBACK_PEERS (brackets, an IPv6 zone and case ignored). The only loopback test that grants trust. */
-export declare function isLoopbackPeer(address: string): boolean;
-/** 127.0.0.0/8, ::1 and their IPv4-mapped forms. For naming hosts only (public-check.ts); trust uses isLoopbackPeer. */
-export declare function isLoopbackAddress(address: string): boolean;
-/** Tailscale's ranges: 100.64.0.0/10 (and its IPv4-mapped form) and fd7a:115c:a1e0::/48. */
-export declare function isTailnetAddress(address: string): boolean;
-/** How one request reached the server, as far as it can be proved. */
-export type Transport = {
-    /** The caller's address: the socket peer, or the trusted proxy's last X-Forwarded-For hop. */
-    source: string;
-    /** Proved to have arrived over HTTPS at a same-host proxy. */
-    https: boolean;
-    /** The caller is this computer or a tailnet address (WireGuard already encrypts it). */
-    privatePath: boolean;
-};
-/**
- * The request's transport from its socket peer, the source serve.ts's joinSourceOf derived (`fwd:<hop>` only for a
- * loopback peer) and the proxy headers. A loopback peer that forwards with `Forwarded` but no X-Forwarded-For names
- * no caller we can read, so it is not treated as this computer.
- */
-export declare function transportOf(request: {
-    peer: string | undefined;
-    joinSource: string;
-    forwardedProto: string | string[] | undefined;
-    forwarded: string | string[] | undefined;
-}): Transport;
-/** The OAuth endpoints that hand out, consent to or take back a token (mcp-oauth.ts; revoke is reserved). Discovery stays public. */
-export declare const OAUTH_TOKEN_PATHS: ReadonlySet<string>;
-/** Requests that carry, or exist to carry, an API token: the remote CLI, the MCP gateway, MCP sign-in, and any bearer credential. */
-export declare function carriesToken(pathname: string, authorization: string | undefined): boolean;
-/** The refusal for a token sent over plain HTTP from outside this computer and the tailnet, else null. */
-export declare function plainHttpRefusal(transport: Transport, pathname: string, authorization: string | undefined): string | null;
-/** The Strict-Transport-Security value for a request to the configured public https host that arrived over HTTPS. */
-export declare function hstsFor(publicHost: string | null, host: string | undefined, transport: Transport): string | null;

package/dist/public-check.d.ts

@@ -1,37 +0,0 @@
-export type ProbeRequest = {
-    url: string;
-    headers: Record<string, string>;
-};
-export type ProbeAnswer = {
-    status: number;
-    headers: Record<string, string | string[] | undefined>;
-    body: string;
-} | {
-    error: string;
-};
-/** One bounded GET: no credentials, no redirects. */
-export type Probe = (request: ProbeRequest) => Promise<ProbeAnswer>;
-export type Finding = {
-    check: "public-url" | "allow-host" | "local" | "host" | "forwarding" | "certificate" | "proxy" | "hsts";
-    message: string;
-};
-/** The default probe: node's http/https with the platform trust store, a timeout and a 4 KB body cap. */
-export declare const networkProbe: Probe;
-/** The exact https origin --public-url must be, as serve.ts requires it; else what is wrong with it. */
-export declare function publicOriginOf(value: string | undefined): URL | string;
-/** Every problem with serving on --public-url, in a fixed order; an empty list means ready. */
-export declare function checkPublic(options: {
-    publicUrl: string | undefined;
-    port: number;
-    allowHosts: readonly string[];
-}, probe?: Probe): Promise<Finding[]>;
-/** The command: findings as lines (or one envelope), exit 0 when ready, 1 when not, 2 for a malformed --port. */
-export declare function checkPublicCommand(flags: Map<string, string | true>, context: {
-    write: (line: string) => void;
-    json: boolean;
-    envelope: (payload: {
-        ok: boolean;
-        command: string;
-    } & Record<string, unknown>) => string;
-    probe?: Probe;
-}): Promise<number>;

package/dist/publish.d.ts

@@ -1,146 +0,0 @@
-/**
- * Publication (§M4): built work becomes a pushed branch and a pull request,
- * under a grant whose every term was shown before the yes, through a durable
- * intent that survives any crash between "done" and "opened".
- *
- * Two external writes, two named capabilities. Pushing a branch and opening
- * a PR hurt differently, so `push-branch` and `open-pr` are granted
- * separately, with the exact GitHub repository, remote, allowed head
- * prefix, and base branch fixed at grant time — the worker re-proves all of
- * them at publish time, because a grant revoked overnight must stop the
- * morning's pushes.
- *
- * The push names the exact SHA the fenced completion accepted —
- * `git push <remote> <sha>:refs/heads/<head>` — never "whatever the branch
- * points at now". The PR is adopt-or-create: the worker first asks GitHub
- * for an open PR on that head and adopts it, so a crash after `pr create`
- * and before the record lands cannot mint a twin. The body is generated
- * only from durable state (task, scope, run record, answered decisions),
- * with the agent's prose fenced in a quote block so `Fixes #…` or an
- * @-mention in its conclusion cannot acquire GitHub semantics.
- */
-import { type ExecResult, type RunOptions } from "./exec.js";
-import { summarizeChecks } from "./pulls.js";
-import type { Publication, PublicationGrant, Store } from "./store.js";
-export declare const BODY_TEMPLATE_VERSION = 2;
-/** After this many failed attempts a publication stops retrying and pages instead. */
-export declare const MAX_PUBLISH_ATTEMPTS = 5;
-/**
- * The one grant lookup for a task's publication: its project is the task's repo, and that project's live grant
- * governs it. The publisher, Complete → pull request and a flow's Pull request zone all ask here, so none of them
- * can judge a publication by another project's grant. `fallback`: the repo to assume for a task with none recorded.
- */
-export declare function publicationGrantOf(store: Store, taskRef: number, fallback?: string | null): {
-    repo: string | null;
-    grant: PublicationGrant | null;
-};
-export type PublishExec = (file: string, args: readonly string[], options?: RunOptions) => Promise<ExecResult>;
-/** The grant's terms, in the words the approver must be shown before agreeing. */
-export declare function describePublicationGrant(grant: {
-    repo: string;
-    githubRepo: string;
-    remote: string;
-    headPrefix: string;
-    base: string;
-    capabilities: readonly string[];
-    selector: "ours" | "all";
-    draft: boolean;
-}): string[];
-export declare function publicationBody(store: Store, publication: Publication): string;
-export declare function bodyHashOf(body: string): string;
-export type PublishReport = {
-    pushed: number;
-    opened: number;
-    adopted: number;
-    failed: number;
-    problems: string[];
-};
-/**
- * One pass over everything owed. Each phase re-proves the grant and moves
- * exactly one durable state — a crash at any point leaves a row the next
- * pass picks up where this one stopped.
- */
-export declare function publishPass(store: Store, options: {
-    repo: string;
-    clock?: () => Date;
-    exec?: PublishExec;
-    /** v102: where the builds' sealed diffs live, to hold a branch that changed protected files on a one-person approval. */
-    evidenceRoot: string;
-}): Promise<PublishReport>;
-/** Why a publication may not proceed — checked against the whole grant, per phase. */
-export declare function permitsPublication(grant: PublicationGrant | null, publication: Pick<Publication, "githubRepo" | "remote" | "base" | "head" | "state">): {
-    ok: true;
-} | {
-    ok: false;
-    message: string;
-};
-/**
- * A publication given up on whose pull request exists anyway — a pass that gave up while another opened it, or a
- * person who opened it by hand: the PR on its exact head and base, carrying its exact commit, is adopted as opened
- * (merged or closed ones too; the next observation records which). Whether one was found.
- */
-export declare function adoptPublishedPullRequest(store: Store, publication: Publication, exec: PublishExec, clock: () => Date): Promise<boolean>;
-export type CheckReport = {
-    observed: number;
-    failing: number;
-    resolved: number;
-    problems: string[];
-    /** Every observation that won its settle, for the pull-request follower (CI revisions, Ready to merge). */
-    seen: ObservedPullRequest[];
-};
-export type ObservedPullRequest = {
-    publication: Publication;
-    headOid: string;
-    state: ReturnType<typeof summarizeChecks>;
-    remoteState: "MERGED" | "CLOSED" | null;
-    rollup: unknown;
-    mergeCommit: string | null;
-};
-/**
- * Read CI for every PR this control plane opened — structured rollup and the
- * exact head OID, never a command's exit status (finding 18). Episodes are
- * keyed `ci:<pr>:<headOid>`: a red head pages once; the episode resolves
- * when that exact head turns green or a newer commit supersedes it. `none`,
- * `running`, and not-read are never called green — an unread rollup neither
- * pages nor resolves anything.
- */
-export declare function observeChecks(store: Store, options: {
-    clock?: () => Date;
-    exec?: PublishExec;
-    /** Read only these (the fast pass's waiting pull requests, live-wakeups.md); every one is read exactly as below. */
-    publications?: readonly Publication[];
-}): Promise<CheckReport>;
-export declare const MERGE_LEASE_MS: number;
-export declare const FIRING_GRACE_MS: number;
-export declare const MERGE_MAX_ATTEMPTS = 3;
-/** The exact terms a merge intent binds - drift supersedes, never surprises. */
-export declare function mergeTermsHash(grant: PublicationGrant): string;
-export type MergeReport = {
-    merged: number;
-    refused: number;
-    skipped: number;
-    problems: string[];
-};
-/**
- * Merge what the grant allows and the evidence proves: this plane's own
- * publications, on this repo, whose PR was OBSERVED green on the exact
- * head - through a claim lease, a live-grant re-read, the queue proof,
- * and GitHub's own head CAS. Every refusal is typed and durable.
- */
-export declare function sweepMerges(store: Store, options: {
-    repo: string;
-    runner?: string;
-    clock?: () => Date;
-    exec?: PublishExec;
-}): Promise<MergeReport>;
-/** A conditional settle (store.settleObservation) and, only when it won, that head's checks' own timing (v146 ci_check),
- * in one transaction: a stale, losing answer neither settles nor records a check. */
-export declare function settleWithChecks(store: Store, observation: {
-    githubRepo: string;
-    prNumber: number;
-    headSha: string;
-    state: "passing" | "failing" | "running" | "none";
-    generation: number;
-}, rollup: unknown, now: Date): {
-    won: boolean;
-};

package/dist/pull-request-flow.d.ts

@@ -1,189 +0,0 @@
-/**
- * Complete → pull request → merge, without a person running git.
- *
- * Setup is one step per project: the project's GitHub remote and default branch are read, `gh` must be signed
- * in with push rights, and a publication grant is saved that publishes only when a person chooses "Complete and
- * open a pull request" (never on every build). The publisher (publish.ts) then pushes the exact accepted commit
- * and opens or adopts the PR, as it always has.
- *
- * The follower reads what observeChecks saw: a red head files ONE revision carrying the failing check's name and
- * a short log excerpt, fenced as untrusted CI output — at most two across one task's revisions, then a person is
- * asked instead. A green head on the exact accepted commit is announced once as Ready to merge.
- *
- * Merging is a person's act behind their password (or the project's opt-in "Merge when checks pass"): a fresh
- * read must show the PR open, on the accepted commit, with checks passing; GitHub's head-commit match guards
- * the race; the branch is deleted; the merge commit and who merged are recorded in the ledger.
- */
-import { type ObservedPullRequest, type PublishExec } from "./publish.js";
-import type { VerifiedApprover } from "./principal.js";
-import type { Publication, Store } from "./store.js";
-export type MergeMethod = "squash" | "merge" | "rebase";
-export declare const MERGE_METHODS: readonly MergeMethod[];
-/** CI revisions one task may file across its revisions before a person is asked instead. */
-export declare const MAX_CI_REVISIONS = 2;
-export declare const MERGED_ACTION = "pull request merged";
-export declare const REQUESTED_ACTION = "pull request requested";
-type Result<T> = ({
-    ok: true;
-} & T) | {
-    ok: false;
-    reason: string;
-    message: string;
-};
-export type PublishingPlan = {
-    repo: string;
-    githubRepo: string;
-    remote: string;
-    base: string;
-    account: string | null;
-};
-/** owner/name from a GitHub remote URL (https, ssh or scp form), or null when it is not GitHub. */
-export declare function githubRepoOf(remoteUrl: string): string | null;
-/** Everything setup needs, checked in the order a person would fix it — each refusal says what to do next. */
-export declare function checkPublishing(repo: string, options?: {
-    exec?: PublishExec;
-    remote?: string;
-}): Promise<Result<{
-    plan: PublishingPlan;
-}>>;
-export type PublishingSettings = {
-    mergeMethod: MergeMethod;
-    mergeWhenGreen: boolean;
-};
-export type Publishing = {
-    on: false;
-} | ({
-    on: true;
-    githubRepo: string;
-    base: string;
-    grantedBy: string;
-    legacy: boolean;
-} & PublishingSettings);
-export declare function publishingOf(store: Store, repo: string | null): Publishing;
-/** The grant setup creates: this project's GitHub repo, its default branch, Toolroll's own branches, pull requests
- * only when a person asks at Complete, ready for review, squash by default, branch deleted on merge. */
-export declare function savePublishing(store: Store, plan: PublishingPlan, by: string, settings: Partial<PublishingSettings>, now: Date): void;
-/** Change how merges happen, keeping every other term of the live grant. */
-export declare function saveMergeSettings(store: Store, repo: string, settings: PublishingSettings, by: string, now: Date): Result<object>;
-type FollowRow = {
-    publication: number;
-    flowCard: number | null;
-    revisions: number;
-    redHead: string | null;
-    revisionTask: string | null;
-    askedHead: string | null;
-    readyHead: string | null;
-    mergeCommit: string | null;
-    mergeMethod: MergeMethod | null;
-    mergedBy: string | null;
-    mergedAt: string | null;
-    mergeError: string | null;
-};
-/** Whether a pull request is followed (Complete's, or a flow zone's), and what came of it. */
-export declare const pullRequestFollowOf: (store: Store, publication: number) => FollowRow | null;
-/** Whether "Complete and open a pull request" may be offered for this result, and if not, why (null = offer it). */
-export declare function pullRequestBlocker(store: Store, runId: number): string | null;
-/**
- * Mark the exact displayed result complete and owe a pull request for its exact commit — one transaction, so
- * "complete" and "this must reach a PR" can't come apart. A result already marked complete may still open its
- * pull request. The watch process pushes and opens it; the task shows its progress.
- */
-export declare function completeAndOpenPullRequest(store: Store, input: {
-    taskId: string;
-    digest: string;
-    runId: number;
-    who: VerifiedApprover;
-    root: string;
-}, now: Date): Result<{
-    publication: Publication;
-}>;
-/**
- * Owe a pull request for a result's exact commit, under the project's live grant: the publisher pushes it and
- * opens (or adopts) the PR. Callers have checked pullRequestBlocker. `flowCard`: a flow's Pull request zone owes
- * it and follows its CI itself, so the Complete follower files no revisions for it.
- */
-export declare function owePullRequest(store: Store, runId: number, actor: string, flowCard: number | null, now: Date): Publication;
-export type FollowReport = {
-    revisions: number;
-    asked: number;
-    ready: number;
-    merged: number;
-    problems: string[];
-};
-/** The last lines of a failing GitHub Actions job's log, cleaned to inert text; null when it can't be read. */
-export declare function logExcerpt(exec: PublishExec, githubRepo: string, url: string | null, budget: number): Promise<string | null>;
-/** The revision note: the failing check by name, then its log as fenced, labelled untrusted data. At most 500 characters. */
-export declare function ciRevisionNote(check: string, prNumber: number, head: string, excerpt: string | null): string;
-/** The first failing check on a pull request, read fresh, with the revision note that carries it (its log's end,
- * fenced as untrusted CI output). null when GitHub couldn't be read. */
-export declare function failingCheckOf(exec: PublishExec, publication: Publication): Promise<{
-    check: string;
-    note: string;
-} | null>;
-/**
- * What observeChecks saw, acted on for pull requests opened through Complete: one revision per red head (at most
- * two per task, then a person is asked), Ready to merge once per green head on the accepted commit, and the merge
- * itself when the project merges on green. A remote merge done elsewhere is recorded with its commit.
- */
-export declare function followPullRequests(store: Store, seen: readonly ObservedPullRequest[], options: {
-    evidenceRoot: string;
-    exec?: PublishExec;
-    clock?: () => Date;
-    /** Asked again before each revision, ready mark and merge: false ends the pass there and writes nothing more. */
-    proceed?: () => boolean;
-}): Promise<FollowReport>;
-/** A person's merge: their password first, then the same checked merge. */
-export declare function mergeAsPerson(store: Store, input: {
-    runId: number;
-    name: string;
-    password: string;
-    exec?: PublishExec;
-    clock?: () => Date;
-    /** A person's choice to merge without waiting for the full check (Quick or Off results). */
-    anyway?: boolean;
-}): Promise<Result<{
-    commit: string | null;
-}>>;
-/**
- * Merge a followed pull request: callers have already established who is merging. A fresh read must show it open,
- * not a draft, on the accepted commit, with checks passing; the merge names that commit so GitHub refuses a head
- * that moved, uses the project's method, and deletes the branch.
- */
-export declare function mergePullRequest(store: Store, input: {
-    runId: number;
-    by: string;
-    exec?: PublishExec;
-    clock?: () => Date;
-    /** A flow's Pull request zone merges its own way; otherwise the project's. */
-    method?: MergeMethod;
-    /** Only a person merging by hand may skip waiting for the full check. */
-    anyway?: boolean;
-    /** An automatic pass's standing, read in the write that reserves the merge: false refuses ("halted") and merges nothing. */
-    proceed?: () => boolean;
-}): Promise<Result<{
-    commit: string | null;
-}>>;
-export type PullRequestView = {
-    runId: number;
-    prNumber: number | null;
-    prUrl: string | null;
-    state: "opening" | "running" | "waiting" | "ready" | "failing" | "merged" | "closed" | "failed";
-    label: string;
-    detail: string;
-    mergeCommit: string | null;
-    mergeMethod: MergeMethod;
-    canMerge: boolean;
-    revisionTask: string | null;
-    /** Quick or Off results: the full check Merge waits for, unless a person merges anyway. */
-    fullCheck: {
-        state: "not-requested" | "waiting" | "failed" | "not-run";
-        message: string;
-    } | null;
-};
-/** The pull request a result opened through Complete, in plain words; null when it opened none. */
-export declare function pullRequestViewOf(store: Store, runId: number): PullRequestView | null;
-/** The newest pull request any version of a task opened through Complete (versions oldest first), or null. */
-export declare function newestPullRequestOf(store: Store, versions: readonly string[]): PullRequestView | null;
-/** Why a machine credential's merge is refused (approval policy §1.7). */
-export declare const MERGE_NEEDS_PERSON = "Only a person can merge. Merge it on the task page or from your paired chat.";
-export {};

package/dist/pull-request-schema.d.ts

@@ -1,5 +0,0 @@
-/** A pull request opened by "Complete and open a pull request" is followed until it merges: how many CI
- * revisions it has filed (counted across the revisions of one task, at most two), the failing head each
- * answered, when a person was asked instead, the green head announced as ready, and the merge itself. One row
- * per publication; the publication row stays the record of the push and the PR. */
-export declare const PULL_REQUEST_SCHEMA = "\nCREATE TABLE IF NOT EXISTS pull_request_follow (\n  publication   INTEGER PRIMARY KEY REFERENCES publication(id) ON DELETE CASCADE,\n  revisions     INTEGER NOT NULL DEFAULT 0 CHECK (revisions >= 0),\n  red_head      TEXT,\n  revision_task TEXT,\n  asked_head    TEXT,\n  ready_head    TEXT,\n  merge_commit  TEXT,\n  merge_method  TEXT CHECK (merge_method IS NULL OR merge_method IN ('squash','merge','rebase')),\n  merged_by     TEXT,\n  merged_at     TEXT,\n  merge_error   TEXT,\n  created_at    TEXT NOT NULL,\n  updated_at    TEXT NOT NULL\n);\n";

package/dist/pull-request-ui.d.ts

@@ -1,25 +0,0 @@
-/** Settings → Projects → Pull requests: one project's pull-request setup, in plain words. Off shows what setup
- * found (or what to fix) and one Turn on; on shows where pull requests go and how they merge. Every change takes
- * the password; turning on restates the exact repository and branch that were checked. */
-import { type Html } from "./html.js";
-import type { Publishing, PublishingPlan } from "./pull-request-flow.js";
-export type PullRequestSettingsView = {
-    repo: string;
-    name: string;
-    csrf: string;
-    canChange: boolean;
-    publishing: Publishing;
-    /** When off: what setup found — the plan to confirm, or what to fix first. */
-    check: {
-        ok: true;
-        plan: PublishingPlan;
-    } | {
-        ok: false;
-        message: string;
-    } | "unchecked" | null;
-    said: string | null;
-    problem: string | null;
-};
-export declare function pullRequestSettingsHtml(view: PullRequestSettingsView): Html;
-/** Kept for the console's style bundle (server/chrome.ts); the page itself is kit markup. */
-export declare const PULL_REQUEST_SETTINGS_CSS = "";

package/dist/pulls.d.ts

@@ -1,121 +0,0 @@
-/**
- * What is waiting on a person.
- *
- * A pull request is where agent work stops being reversible, so it is where the
- * operator's attention actually has to land. The question this module answers is
- * not "what pull requests exist" but "which of these is waiting on me, and for
- * how long has it been waiting" — the case that motivated it was two finished,
- * green, unflagged pull requests that sat open for two months because nothing
- * ever said so.
- *
- * Three rules shape the classification.
- *
- * Absence of a verdict is not a negative verdict. GitHub computes mergeability
- * lazily, so `UNKNOWN` means not yet computed and must never be reported as a
- * conflict. Likewise an empty check rollup means no checks are configured, not
- * that checks passed.
- *
- * A failure outranks work still in progress. If one check has failed while
- * others are queued, the failure is already actionable and saying "running"
- * would defer a decision that can be made now.
- *
- * Nothing here reaches the network or the filesystem except `readPulls`, so the
- * part worth testing needs no fixture repository and no GitHub account.
- */
-import { type ExecResult, type RunOptions } from "./exec.js";
-/** Whose move it is. `none` means nobody is blocked — the author is still writing. */
-export type Attention = "human" | "agent" | "machine" | "none";
-export type ChecksState = "passing" | "failing" | "running" | "none";
-export type Mergeable = "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
-export type Pull = {
-    number: number;
-    title: string;
-    branch: string;
-    url: string;
-    isDraft: boolean;
-    /** UNKNOWN means GitHub has not computed it yet, not that it conflicts. */
-    mergeable: Mergeable;
-    checks: ChecksState;
-    createdAt: string;
-    updatedAt: string;
-};
-export type PullsRead = {
-    pulls: Pull[];
-    /** What could not be read, in words. Never silently dropped. */
-    problems: string[];
-};
-export type Runner = (file: string, args: readonly string[], options?: RunOptions) => Promise<ExecResult>;
-export type ReadPullsOptions = {
-    runner?: Runner;
-    limit?: number;
-    /** Overridden when a caller is spending a shared budget; see `remote.ts`. */
-    timeoutMs?: number;
-};
-/** A pull request read crosses the network, so it gets a network-sized bound. */
-export declare const PULL_TIMEOUT_MS = 20000;
-/**
- * Enough to cover a backlog without paginating. A repository with more open
- * pull requests than this has a problem no report is going to solve.
- */
-export declare const DEFAULT_PULL_LIMIT = 50;
-/**
- * Long enough that a busy person is not nagged about this morning's work, short
- * enough to catch the case above. A four-day content routine clears this only
- * when nobody looked at the previous run.
- */
-export declare const DEFAULT_STALE_DAYS = 3;
-/**
- * The convention this repository's reviewers already use to send a draft back.
- * Callers override it; it is a default, not a rule imposed on anyone.
- */
-export declare const DEFAULT_REVISION_MARKERS: readonly ["[NEEDS REVISION]"];
-/**
- * Open pull requests for the repository at `path`.
- *
- * Failure comes back as a problem rather than an exception, for the same reason
- * discovery never throws: a repository with no GitHub remote, or an operator who
- * has not logged in, must not end a report covering everything else.
- */
-export declare function readPulls(path: string, options?: ReadPullsOptions): Promise<PullsRead>;
-/**
- * Parse `gh pr list --json`. Returns null when the payload is not the array it
- * should be; individual records of the wrong shape are dropped rather than
- * trusted, because this is another program's output and not our own.
- */
-export declare function parsePulls(json: string): Pull[] | null;
-/**
- * Collapse the check rollup to one state.
- *
- * An empty rollup is `none`, not `passing`: a repository with no CI has not
- * told us anything, and treating silence as approval is how a broken change
- * gets reported as ready. SKIPPED is likewise not a failure — a job whose `if`
- * guard excluded it did exactly what it was written to do.
- */
-export declare function summarizeChecks(rollup: unknown): ChecksState;
-/** The checks that finished and did not succeed, by the name GitHub shows, with their details page when one is given. */
-export declare function failingChecks(rollup: unknown): {
-    name: string;
-    url: string | null;
-}[];
-/**
- * Whose move it is.
- *
- * Note the two that look alike and are not. A pull request sent back with a
- * revision marker is waiting on the agent, because a person already looked and
- * said what they wanted. One that is simply green and open is waiting on a
- * person, because nobody has looked at all.
- */
-export declare function classify(pull: Pull, markers?: readonly string[]): Attention;
-export declare function isFlagged(pull: Pull, markers?: readonly string[]): boolean;
-/**
- * Why it is waiting, in the words the operator would use. Kept beside
- * `classify` so a new state cannot be added to one without the other.
- */
-export declare function describe(pull: Pull, markers?: readonly string[]): string;
-/**
- * Idle days, measured from the last time anything happened rather than from
- * opening. A pull request being actively discussed is not stalled however old
- * it is. Null when the timestamp could not be read, which is absence of data
- * and not evidence of freshness.
- */
-export declare function idleDays(pull: Pull, now: Date): number | null;