@floh-solutions/pharos-cli 0.22.0 → 0.24.0

package/dist/half-link.js

@@ -0,0 +1,247 @@
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { normalizeRepo } from "@floh-solutions/gh-core";
+/**
+ * `~/.config/pharos/half-links.json` — the one thing this CLI remembers between
+ * invocations, and it exists because of the one state the durable layers cannot
+ * describe.
+ *
+ * ## What it is for
+ *
+ * `adopt` writes Azure DevOps first (`issue.ts` ▸ the write order), so the
+ * failure it can leave is always the same shape: the work item created, the
+ * GitHub comment not. In that state **both** indexes the bridge normally reads
+ * are silent about it — the marker was never posted, and Azure DevOps offers no
+ * query over relation URLs. An agent that retries the verb it just ran, which
+ * the CLI's own docs told it was safe, got a **second work item**: its own id,
+ * its own place in a sprint, its own notifications, on a client's board, and
+ * nothing in this app removes it.
+ *
+ * So the moment a work item is created, before the comment is attempted, the
+ * intent is written down here; the moment the comment lands it is taken back
+ * out. What remains is exactly the set of adoptions that half-happened, and the
+ * next `adopt` of the same issue refuses instead of creating a second one.
+ *
+ * **Written before the comment rather than in the failure handler.** A `catch`
+ * covers an HTTP error and nothing else — ctrl-C during a slow POST, a killed
+ * process, a laptop lid — and those leave precisely the same orphan. The write
+ * is local, so paying for it on the success path costs nothing worth measuring.
+ *
+ * ## Why a file, when nothing else here has one
+ *
+ * `issue.ts` argues that this CLI keeps no state and therefore cannot be stale,
+ * and that stays true of the **link**: the marker and the hyperlink are read
+ * fresh every time and this file is never consulted for what a link *is*. What
+ * it records is a local event — "this machine created a work item and did not
+ * finish" — which is not a fact about the link at all, and is not derivable
+ * from either platform. A stale entry can only ever cost one extra read, never
+ * a wrong answer: whether the work item it names is really still half-linked is
+ * decided by reading that work item, in `issue.ts`, and never trusted from
+ * here.
+ *
+ * It is also **not the only guard**, and must not be treated as one. The board
+ * scan in `issue.ts` catches the retry that arrives on a different machine, and
+ * this catches the retry that arrives before Azure DevOps' query index has
+ * caught up with the create — seconds, which is exactly when a retry happens.
+ * Neither subsumes the other.
+ *
+ * ## Never fatal
+ *
+ * Every operation here swallows its own I/O errors. A read-only `HOME`, a
+ * corrupt file, two invocations racing on the same path — none of that is a
+ * reason to fail an adoption that would otherwise work, and the half-linked
+ * error still carries `recover` regardless. The cost of losing an entry is one
+ * missed refusal; the cost of throwing here would be a verb that stops working
+ * because of a cache.
+ */
+/** The schema version written into the file. Additive changes keep it at 1. */
+export const HALF_LINKS_VERSION = 1;
+/**
+ * How many entries are kept. Nothing normal accumulates here — an entry is
+ * removed as soon as the link completes — so this is a backstop against a
+ * script looping on a broken GitHub token, not a working limit. Oldest first
+ * out.
+ */
+export const HALF_LINKS_LIMIT = 200;
+/**
+ * `$PHAROS_HALF_LINKS_FILE`, else `$XDG_CONFIG_HOME/pharos/half-links.json`,
+ * else `$HOME/.config/pharos/half-links.json` — beside `repos.json`, which is
+ * the path `pharos setup` prints and the one people already know.
+ *
+ * **`HOME` is read from the invocation's environment and there is no
+ * `homedir()` fallback.** Same rule the GitHub client states about `PATH`: the
+ * environment this run was given is the environment it acts in. The practical
+ * consequence is that a test harness that passes an explicit env gets no
+ * journal rather than silently writing into the developer's real home
+ * directory — an accidental write there would be a file nobody knows exists,
+ * refusing adoptions in a shell nobody connected to a test run.
+ */
+export function halfLinksPath(env) {
+    const override = env["PHAROS_HALF_LINKS_FILE"]?.trim();
+    if (override !== undefined && override !== "")
+        return override;
+    const xdg = env["XDG_CONFIG_HOME"]?.trim();
+    if (xdg !== undefined && xdg !== "")
+        return join(xdg, "pharos", "half-links.json");
+    const home = env["HOME"]?.trim();
+    if (home !== undefined && home !== "")
+        return join(home, ".config", "pharos", "half-links.json");
+    return undefined;
+}
+/**
+ * Decode the file, keeping only entries that are completely well formed.
+ *
+ * **A bad row is dropped, never thrown over.** This file is a convenience the
+ * bridge can live without, and refusing to parse it would turn one corrupt
+ * character into "adopt no longer works" — the opposite of what it is for. The
+ * caller cannot tell an empty file from an unreadable one, deliberately: in
+ * both cases the answer is "this machine remembers nothing", and the board scan
+ * is what covers that.
+ */
+export function parseHalfLinks(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    const rows = parsed?.pending;
+    if (!Array.isArray(rows))
+        return [];
+    const out = [];
+    for (const row of rows) {
+        const entry = readEntry(row);
+        if (entry !== undefined)
+            out.push(entry);
+    }
+    return out;
+}
+/** Encode the file. Newest last, which is the order entries are added in. */
+export function formatHalfLinks(entries) {
+    return `${JSON.stringify({ version: HALF_LINKS_VERSION, pending: entries }, undefined, 2)}\n`;
+}
+/** Does this entry name that issue, on that board? */
+export function matchesHalfLink(entry, key) {
+    return (entry.repo === normalizeRepo(key.repo)
+        && entry.issue === key.issue
+        && entry.organization === key.organization
+        && entry.project === key.project);
+}
+export function findHalfLink(entries, key) {
+    // Last wins. An issue can only be half-adopted onto one board at a time, so a
+    // second entry means the first was superseded by a later attempt — and the
+    // later work item is the one a refusal should name.
+    return [...entries].reverse().find((entry) => matchesHalfLink(entry, key));
+}
+/** The list with this entry added, replacing any earlier one for the same key. */
+export function withHalfLink(entries, entry) {
+    const kept = entries.filter((existing) => !matchesHalfLink(existing, entry));
+    kept.push(entry);
+    return kept.slice(Math.max(0, kept.length - HALF_LINKS_LIMIT));
+}
+/** The list with every entry for this key removed. */
+export function withoutHalfLink(entries, key) {
+    return entries.filter((entry) => !matchesHalfLink(entry, key));
+}
+/**
+ * The journal, as one invocation uses it.
+ *
+ * Every method is best-effort by construction — see the header. `record` and
+ * `forget` are read-modify-write and two concurrent adoptions can therefore
+ * lose one entry to the other; the file is replaced by `rename` so it is never
+ * half-written, and a lost entry costs a refusal this machine would have made,
+ * which the board scan still makes.
+ */
+export class HalfLinkJournal {
+    path;
+    constructor(env) {
+        this.path = halfLinksPath(env);
+    }
+    async read() {
+        if (this.path === undefined)
+            return [];
+        try {
+            return parseHalfLinks(await readFile(this.path, "utf8"));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** The entry for this issue on this board, if this machine left one. */
+    async find(key) {
+        return findHalfLink(await this.read(), key);
+    }
+    /** Write down an adoption that is about to try its second half. */
+    async record(entry) {
+        await this.#write(withHalfLink(await this.read(), { ...entry, repo: normalizeRepo(entry.repo) }));
+    }
+    /**
+     * Take an entry back out — the link completed, or the work item it named
+     * turned out not to be there any more.
+     */
+    async forget(key) {
+        const entries = await this.read();
+        const kept = withoutHalfLink(entries, key);
+        // Nothing to say and nothing to write. Worth checking: `adopt` calls this on
+        // its ordinary success path, and on a machine that has never half-linked
+        // anything that would otherwise create the file for no reason.
+        if (kept.length === entries.length)
+            return;
+        await this.#write(kept);
+    }
+    async #write(entries) {
+        const path = this.path;
+        if (path === undefined)
+            return;
+        // A distinct temp name per process: `rename` is atomic, so a reader sees the
+        // old file or the new one and never a truncated one — but two writers
+        // sharing a temp path would corrupt each other's copy before either
+        // renamed.
+        const temporary = `${path}.${process.pid}.tmp`;
+        try {
+            await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+            await writeFile(temporary, formatHalfLinks(entries), { mode: 0o600 });
+            await rename(temporary, path);
+        }
+        catch {
+            try {
+                await unlink(temporary);
+            }
+            catch {
+                // Nothing left to try, and an adoption must not fail over a cache file.
+            }
+        }
+    }
+}
+function readEntry(row) {
+    if (typeof row !== "object" || row === null || Array.isArray(row))
+        return undefined;
+    const record = row;
+    const repo = record["repo"];
+    const issue = record["issue"];
+    const workItem = record["workItem"];
+    const organization = record["organization"];
+    const project = record["project"];
+    const at = record["at"];
+    if (typeof repo !== "string" || repo === "")
+        return undefined;
+    if (!isPositiveInt(issue) || !isPositiveInt(workItem))
+        return undefined;
+    if (typeof organization !== "string" || organization === "")
+        return undefined;
+    if (project !== null && typeof project !== "string")
+        return undefined;
+    return {
+        repo: normalizeRepo(repo),
+        issue,
+        workItem,
+        organization,
+        project,
+        at: typeof at === "string" ? at : "",
+    };
+}
+function isPositiveInt(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+//# sourceMappingURL=half-link.js.map

package/dist/half-link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"half-link.js","sourceRoot":"","sources":["../src/half-link.ts"],"names":[],"mappings":"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"}

package/dist/issue-scan.d.ts

@@ -0,0 +1,383 @@
+import { type IssueLink, type LinkEvidence } from "@floh-solutions/gh-core";
+import type { StateCatalog } from "@floh-solutions/ado-core";
+/**
+ * The join behind `pharos issue drift` and `pharos issue backfill`, with no I/O
+ * in it.
+ *
+ * **Separate from the command for the same reason `wiql-build.ts` is** — this is
+ * where the bugs are. Every interesting question here is a comparison between
+ * two records that came from two different systems, and comparisons are exactly
+ * what can be proved without a network: which spelling of a repository counts as
+ * the same repository, what "still open" means on a board that renamed its
+ * states, whether one piece of evidence on each of two layers is one link or
+ * two. The command file around this reads, calls, and prints.
+ *
+ * ## The one idea both verbs are built on
+ *
+ * **The Azure DevOps side is the enumerable one, and that is what makes a
+ * 400-issue repository affordable.**
+ *
+ * GitHub cannot answer "which of my issues has Pharos adopted" — the answer
+ * lives in a comment on each issue, so asking costs one request per issue and a
+ * backfill would spend four hundred requests deciding what to do before doing
+ * anything. Azure DevOps *can*: a work item carries its `Hyperlink` relations on
+ * its own row, so one WIQL plus one `workitemsbatch` returns every link on the
+ * board at once.
+ *
+ * That index is correct as an answer to "what is already adopted" because
+ * `adopt` writes the Azure DevOps end **first** (`issue.ts` ▸ the write order).
+ * The half-state it can leave is a hyperlink with no comment, never a comment
+ * with no hyperlink — so an issue missing from this index was either never
+ * adopted, or adopted by something that died before its first write. Both mean
+ * the same thing to a backfill.
+ *
+ * The mirror-image state is still possible if somebody deletes the relation by
+ * hand, and it is why {@link backfillCandidates} produces *candidates* rather
+ * than a work list: the per-issue marker read that would catch it happens at
+ * adoption time, on the handful being written, instead of on all four hundred.
+ *
+ * ## Two traps peers already paid for
+ *
+ * 1. **Repositories are compared on {@link normalizeRepo}, never with `===`.**
+ *    GitHub resolves a repository case-insensitively and echoes back whatever
+ *    spelling it was created with, so `Contoso/Widgets` and `contoso/widgets`
+ *    are one repository and two strings. The app track reported a perfectly good
+ *    link as half-written over exactly this (#787).
+ * 2. **Evidence is counted nowhere.** `["marker","mention"]` is two pieces of
+ *    evidence and one side — both are GitHub's — so a link with no `Hyperlink`
+ *    at all passes a length check (#782 found this in its own code). Whether
+ *    both platforms carry a link is `gh-core`'s `isTwoSided`, and whether the
+ *    GitHub half was even *looked at* is {@link IssueSide.markers} being present
+ *    rather than empty.
+ */
+/**
+ * The statement `drift` runs when nobody passed `--wiql`.
+ *
+ * **BOTH `System.HyperLinkCount` AND `System.ExternalLinkCount`, and the reason
+ * this reads as belt-and-braces is that it once was neither.**
+ *
+ * This narrowed on `ExternalLinkCount` alone, on the stated grounds that it was
+ * the *broader* filter and that a false negative here is far worse than a false
+ * positive. The asymmetry argument is right. The premise was wrong, and it made
+ * the command silently useless: **the two counters are disjoint, not nested.**
+ * Azure DevOps counts each relation kind separately —
+ * `RelatedLinkCount` (work item ↔ work item), `HyperLinkCount` (a plain
+ * `Hyperlink`), `ExternalLinkCount` (an `ArtifactLink`: a commit, PR or build),
+ * `AttachedFileCount`.
+ *
+ * `adopt` writes a **`Hyperlink`** — it must, because minting the native
+ * `vstfs:///GitHub/Issue/…` artifact URI needs a connection id that is behind a
+ * 401 on our scopes (§2). So every pair this tool creates increments
+ * `HyperLinkCount` and leaves `ExternalLinkCount` at zero, and the old default
+ * could **never** see a link Pharos had made. It answered "no drift" forever,
+ * exit 0, which is the failure mode a drift detector must not have.
+ *
+ * Measured on the live board (#801, re-verified): an adopted pair read
+ * `HyperLinkCount 1, ExternalLinkCount 0`, and the two work items that DID
+ * match `ExternalLinkCount > 0` each carried an `ArtifactLink` and no
+ * `Hyperlink`.
+ *
+ * Both are kept rather than swapping one for the other, because a client whose
+ * org *does* have the Azure Boards GitHub connection gets a native artifact
+ * link in addition to ours (§2) — narrowing to hyperlinks alone would then miss
+ * exactly the boards that are best integrated.
+ *
+ * There is no way to ask WIQL about the *contents* of a relation — it queries
+ * fields, and a `Hyperlink`'s URL is not one. So this narrows to work items that
+ * have external links at all and the URLs are parsed afterwards, in
+ * {@link linksOnWorkItems}.
+ *
+ * `[System.TeamProject] = @project` is not redundant with the project in the
+ * URL: WIQL happily returns items from every project the token can read, and a
+ * drift report that reached across an organisation would be answering a question
+ * nobody asked. Same argument `buildWiql` already makes.
+ */
+export declare function driftWiql(): string;
+/**
+ * The statement `adopt` runs **before creating anything**, to find a work item
+ * that already links the issue in front of it.
+ *
+ * ## Why this is not `driftWiql`
+ *
+ * Two narrower choices, and both are the point.
+ *
+ * **`HyperLinkCount` alone.** `drift` asks "is any link here broken", so it
+ * takes both counters — a client whose organisation *does* have the Azure
+ * Boards connection gets a native `ArtifactLink` in addition to ours, and
+ * missing those would miss the best-integrated boards. This asks a different
+ * question: *did Pharos already adopt this issue*, and Pharos writes a
+ * `Hyperlink`, always, because the connection id an artifact link needs is
+ * behind a 401 on our scopes (§2). So `ExternalLinkCount` here would add every
+ * work item that ever had a commit, a PR or a build attached — which on a real
+ * board is most of them — to a query that runs on the way to a single
+ * adoption. Measured on the live board (#801): the adopted pair answered
+ * `HyperLinkCount 1, ExternalLinkCount 0`, and `[System.HyperLinkCount] > 0`
+ * returned it while `[System.ExternalLinkCount] > 0` returned two other items
+ * and not it.
+ *
+ * **Capped, newest first.** `drift` is a deliberate sweep and reads the whole
+ * board; this is a guard on a one-issue verb and must not turn it into one. The
+ * state it exists to catch is a work item written minutes ago, so ordering by
+ * `ChangedDate` descending and stopping at {@link ADOPT_GUARD_LIMIT} keeps the
+ * cost flat while looking exactly where the answer is. A board with more
+ * hyperlinked work items than that is not a wrong answer — it is a partial one,
+ * and `adopt` says so rather than reporting a clean check.
+ *
+ * There is still no way to ask WIQL about the *contents* of a relation, so the
+ * URLs are matched afterwards, client-side, by {@link claimsOn}. That is the
+ * same narrow-then-filter shape `drift` uses and the same reason.
+ */
+export declare function adoptGuardWiql(): string;
+/**
+ * How many hyperlinked work items `adopt`'s guard looks at. Two
+ * `workitemsbatch` calls at the 200-per-request chunk, on top of the WIQL.
+ */
+export declare const ADOPT_GUARD_LIMIT = 400;
+/** A work item, reduced to what a drift row needs to say about it. */
+export interface LinkedWorkItem {
+    readonly id: number;
+    readonly type: string | null;
+    readonly title: string | null;
+    readonly state: string | null;
+    readonly url: string;
+}
+/** One end of the bridge as the board records it: a work item and an issue it names. */
+export interface ScannedLink {
+    readonly workItem: LinkedWorkItem;
+    /** Lower-cased. The spelling the board wrote is in {@link ScannedLink.spelling}. */
+    readonly repo: string;
+    /** The repository as the `Hyperlink` spelled it, for putting in front of a person. */
+    readonly spelling: string;
+    readonly issueNumber: number;
+}
+/**
+ * Every GitHub issue link on a batch of work items, flattened.
+ *
+ * `hyperlinks` is a function rather than a field because reading relations off a
+ * `WorkItem` is the command's business — this file is not allowed to care what
+ * shape Azure DevOps returns.
+ */
+export declare function linksOnWorkItems<T>(items: readonly T[], describe: (item: T) => LinkedWorkItem, hyperlinks: (item: T) => readonly IssueLink[]): ScannedLink[];
+/**
+ * The links that name one particular issue — "who on this board already claims
+ * it".
+ *
+ * Compared on {@link normalizeRepo}, never with `===`: GitHub resolves a
+ * repository case-insensitively and echoes back whichever spelling it was
+ * created with, so a `Hyperlink` written as `Contoso/Widgets` and a coordinate
+ * typed as `contoso/widgets` are one issue and two strings. #787 reported a
+ * perfectly good link as half-written over exactly this, and here the same slip
+ * would be worse: it would report *no* claim, and a second work item is what
+ * follows from that.
+ */
+export declare function claimsOn(links: readonly ScannedLink[], coordinate: {
+    repo: string;
+    number: number;
+}): ScannedLink[];
+/** The repositories a set of links touches, lower-cased and de-duplicated. */
+export declare function reposOf(links: readonly ScannedLink[]): string[];
+/**
+ * How the finished states were decided, so a report can say it.
+ *
+ * The same argument `pharos query`'s `Openness` makes, for a different purpose:
+ * there it filters, here it *classifies*, and a classification is even less
+ * interpretable without its basis. "Three closed issues whose work items are
+ * still open" means nothing until you know what this project calls finished —
+ * and Azure DevOps lets a process template rename every state.
+ */
+export interface FinishedStates {
+    /** `categories` read the project. `fallback` guessed and says so. */
+    readonly source: "categories" | "fallback";
+    /** Terminal state names across every type. */
+    readonly terminal: readonly string[];
+    /** Per type, which is the only right answer when a name is ambiguous. */
+    readonly byType: ReadonlyMap<string, readonly string[]>;
+    /** State names that mean finished on one work item type and not on another. */
+    readonly ambiguous: readonly string[];
+    readonly note: string;
+}
+/** The catalogue as this file needs it, or the stock names with a warning attached. */
+export declare function finishedStates(catalog: StateCatalog | undefined, failure?: string): FinishedStates;
+/**
+ * Is this work item finished?
+ *
+ * **Its own type's list first**, because that is the whole reason `StateCatalog`
+ * carries `byType`: `Resolved` can be terminal on a Bug and open on a User
+ * Story, and one flat list gets one of them wrong. The flat list is the fallback
+ * for a type the catalogue does not know — a work item type added since, or a
+ * batch that came back with no `System.WorkItemType` at all.
+ *
+ * **An unknown state counts as open**, matching `stateCatalog`'s own rule and
+ * for its reason: the two mistakes are not equal. Calling a finished work item
+ * open puts a row in front of somebody who can dismiss it; calling an open one
+ * finished hides drift, which is the one thing this command exists to surface.
+ */
+export declare function isFinished(states: FinishedStates, type: string | null, state: string | null): boolean;
+/**
+ * Which state `close` should move a work item of this type into — or why it
+ * cannot know.
+ *
+ * **There is no hardcodable "Closed".** A process template renames every state,
+ * so writing `System.State = "Closed"` onto a board that calls it `Done` either
+ * fails with a message about a query nobody wrote, or — worse, on a board that
+ * has both — succeeds into a state nobody meant. This is the same measurement
+ * `pharos query` rests on, used to *act* rather than to filter, which raises the
+ * cost of getting it wrong.
+ *
+ * So the answer is the type's own terminal states, and **ambiguity is refused
+ * rather than guessed**: `Done` and `Removed` are both finished and they mean
+ * opposite things about the work. `Session.resolveWiki` breaks ties exactly this
+ * far and no further, for the same reason.
+ */
+export type TerminalChoice = {
+    readonly kind: "one";
+    readonly state: string;
+} | {
+    readonly kind: "several";
+    readonly states: readonly string[];
+} | {
+    readonly kind: "none";
+} | {
+    readonly kind: "unknown";
+};
+export declare function terminalStateFor(states: FinishedStates, type: string | null): TerminalChoice;
+/** What one issue looks like once it has been read, or why it could not be. */
+export interface IssueSide {
+    /** Absent when the issue could not be read at all. */
+    readonly issue?: IssueFacts | undefined;
+    /**
+     * The links this issue's own comments carry, or **absent** when the comments
+     * were not read.
+     *
+     * Absent and empty are different answers and conflating them is the bug: an
+     * empty array means "read, and Pharos has never commented here", which is a
+     * half-written link; absent means nobody looked, and reporting that as a
+     * half-written link would flag every issue whose comments a run skipped. The
+     * app track drew the same distinction from the other direction (#787: a
+     * missing marker in a lazily-filled mirror is not evidence of a missing
+     * marker).
+     */
+    readonly markers?: readonly IssueLink[] | undefined;
+    /** GitHub answered 404: the issue is gone, transferred, or never existed. */
+    readonly missing?: boolean;
+    /** Why the read failed, when it did. Prose, for a person. */
+    readonly problem?: string | undefined;
+}
+/** An issue, reduced to what a drift row needs. */
+export interface IssueFacts {
+    readonly repo: string;
+    readonly number: number;
+    readonly title: string;
+    readonly state: "open" | "closed";
+    readonly stateReason: string | null;
+    readonly updatedAt: string;
+    readonly url: string;
+}
+/**
+ * The four ways a link can be wrong, and they are deliberately four rather than
+ * one "broken" flag: each wants a different action from whoever reads it.
+ */
+export type DriftKind = 
+/** Both ends exist and disagree about whether the work is finished. */
+"state"
+/** The work item names an issue GitHub says is not there. */
+ | "missing-issue"
+/** One platform carries the link and the other does not. */
+ | "one-sided"
+/** The GitHub end could not be read, so nothing about this pair is known. */
+ | "unreadable";
+export type DriftDirection = 
+/** Closed on GitHub, still being worked on the board. */
+"issue-closed"
+/** Finished on the board, still open in front of the reporter. */
+ | "work-item-finished";
+export interface DriftRow {
+    readonly kind: DriftKind;
+    readonly direction?: DriftDirection;
+    readonly workItem: LinkedWorkItem;
+    readonly issue: (IssueFacts & {
+        readonly coordinate: string;
+    }) | null;
+    /** The coordinate as written, even when the issue itself could not be read. */
+    readonly coordinate: string;
+    readonly evidence: readonly LinkEvidence[];
+    /** Which platform is missing its half. Only on `one-sided`. */
+    readonly missing?: "hyperlink" | "marker";
+    readonly problem?: string;
+    /** One sentence a person can act on. */
+    readonly detail: string;
+    /** A literal command that repairs it, where one exists. */
+    readonly recover?: string;
+}
+export interface PairVerdict {
+    /** The row, or `undefined` when the pair is healthy. */
+    readonly drift?: DriftRow;
+    /** True when both ends were read and agree. */
+    readonly healthy: boolean;
+}
+/**
+ * Judge one link.
+ *
+ * **Order matters, and it is worst-first.** A pair whose issue cannot be read
+ * has no state to compare and no marker to look for, so reporting it as three
+ * problems would be reporting one problem three times — and the three rows would
+ * not even agree, because two of them would be inferred from an absence. Each
+ * link produces at most one row.
+ */
+export declare function judgeLink(link: ScannedLink, side: IssueSide, states: FinishedStates): PairVerdict;
+/** The counts a drift report leads with, so nobody has to tally the rows. */
+export declare function tallyDrift(rows: readonly DriftRow[]): Record<DriftKind, number>;
+export interface BackfillCandidate {
+    readonly number: number;
+    readonly title: string;
+    readonly state: "open" | "closed";
+    readonly url: string;
+    readonly updatedAt: string;
+}
+/**
+ * Which issues in a repository the board has never heard of.
+ *
+ * `linked` is the set of issue numbers already reached by a `Hyperlink` — the
+ * index this file's header argues for, and the reason this costs two Azure
+ * DevOps calls instead of one GitHub call per issue.
+ *
+ * **Ordered by issue number ascending**, which is a decision rather than an
+ * accident. The sweep arrives in `updated_at` order, so taking the first `n` of
+ * *that* would adopt a different set every run as issues get touched — and a
+ * `--limit` that means something different each time is a `--limit` nobody can
+ * resume against. Oldest issue first is stable, obvious, and makes a second run
+ * carry on where the first stopped.
+ */
+export declare function backfillCandidates(issues: readonly BackfillCandidate[], linked: ReadonlySet<number>): BackfillCandidate[];
+/** The issue numbers already linked from the board, for one repository. */
+export declare function linkedNumbersIn(links: readonly ScannedLink[], repo: string): Set<number>;
+/** How many writes adopting `count` issues costs. One create, one comment, each. */
+export declare const WRITES_PER_ADOPTION = 2;
+/**
+ * Run `work` over `items`, at most `limit` at a time, keeping the input order.
+ *
+ * `drift` reads two endpoints per link and a board with four hundred of them is
+ * the case this milestone exists for, so doing them one at a time is minutes of
+ * waiting. `Promise.all` over all of them is the other extreme and it is worse:
+ * GitHub's secondary rate limit is explicitly about concurrency rather than
+ * volume, and tripping it turns a diagnostic into an hour's ban on a token
+ * somebody else is also using.
+ *
+ * Rejections are **not** caught here. A caller that wants a failed read to
+ * become a row rather than an exception says so in `work` — which `drift` does,
+ * because one unreadable repository must not kill a sweep (#782).
+ */
+export declare function inBatches<T, R>(items: readonly T[], limit: number, work: (item: T, index: number) => Promise<R>): Promise<R[]>;
+/** How many issue reads `drift` has in flight at once. */
+export declare const READ_CONCURRENCY = 6;
+/**
+ * A WIQL failure that names the field this file introduced.
+ *
+ * `System.ExternalLinkCount` is queryable on every process template Azure DevOps
+ * ships, and this has not been run against a customised one. If a project
+ * somehow does not expose it the statement fails to parse, which reads as "drift
+ * is broken" — so the error says which clause is suspect and hands over the
+ * escape hatch `pharos query` already established.
+ */
+export declare function looksLikeWiqlRejection(message: string): boolean;
+//# sourceMappingURL=issue-scan.d.ts.map

package/dist/issue-scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-scan.d.ts","sourceRoot":"","sources":["../src/issue-scan.ts"],"names":[],"mappings":"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"}